eval-quality 0.1.0

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

@@ -0,0 +1,1153 @@
+/** the closed inventory of interchange artifacts, as data. */
+import type { z } from 'zod';
+/**
+ * The phrase an artifact with no predecessor uses in its own description, per
+ * AD-24. Exported so a test checks one string instead of six hard-coded
+ * copies.
+ */
+export declare const NO_PRIOR_ART = "no prior art";
+/**
+ * The Structural Seed's inventory, closed at twelve, held as data: the
+ * prior-art test, the constraint ledger's lineage-entry generation, and the
+ * published-schema export walk all read it instead of a second hard-coded
+ * list.
+ *
+ * Lineage fields live in `lineage.ts`, not here, because eleven of the twelve
+ * schema modules import them (every entry but `artifact-reference`, the one
+ * with `carriesLineage: false`); importing this registry back from any of
+ * those would close a circular import.
+ */
+export declare const INTERCHANGE_ARTIFACTS: {
+    readonly 'eval-contract': {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            contractId: z.ZodString;
+            sourceSpecDigest: z.ZodNullable<z.ZodString>;
+            behaviors: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+                observableSuccessCriterion: z.ZodNullable<z.ZodString>;
+                requirementLinks: z.ZodArray<z.ZodObject<{
+                    scheme: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strict>>;
+                riskLinks: z.ZodArray<z.ZodObject<{
+                    scheme: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strict>>;
+                oracles: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            oracles: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                direction: z.ZodNullable<z.ZodObject<{
+                    evidenceTargets: z.ZodArray<z.ZodString>;
+                    relation: z.ZodEnum<{
+                        absence: "absence";
+                        all: "all";
+                        any: "any";
+                        containment: "containment";
+                        "count-tolerance": "count-tolerance";
+                        "covers-by-key": "covers-by-key";
+                        "deep-equality": "deep-equality";
+                        equality: "equality";
+                        existence: "existence";
+                        "for-all": "for-all";
+                        "for-any": "for-any";
+                        not: "not";
+                        ordering: "ordering";
+                        regex: "regex";
+                        "set-membership": "set-membership";
+                        shape: "shape";
+                    }>;
+                    polarity: z.ZodEnum<{
+                        "expects-hold": "expects-hold";
+                        "expects-violation": "expects-violation";
+                    }>;
+                    scope: z.ZodNullable<z.ZodString>;
+                    negativeDomain: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                check: z.ZodNullable<z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>>;
+                polarity: z.ZodEnum<{
+                    "expects-hold": "expects-hold";
+                    "expects-violation": "expects-violation";
+                }>;
+                commentary: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            rubrics: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                scaleLevels: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    level: z.ZodInt;
+                    anchor: z.ZodString;
+                }, z.core.$strict>>>;
+                failureModePenalties: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                maxLength: z.ZodNullable<z.ZodInt>;
+                criteria: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                    evidence: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            waivers: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                rule: z.ZodNullable<z.ZodString>;
+                rationale: z.ZodNullable<z.ZodString>;
+                condition: z.ZodNullable<z.ZodString>;
+                approval: z.ZodNullable<z.ZodString>;
+                expiresAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+            permittedInterfaces: z.ZodArray<z.ZodObject<{
+                logicalId: z.ZodString;
+                kind: z.ZodEnum<{
+                    api: "api";
+                    cli: "cli";
+                    mcp: "mcp";
+                    web: "web";
+                }>;
+                operations: z.ZodArray<z.ZodObject<{
+                    operationId: z.ZodString;
+                    method: z.ZodEnum<{
+                        DELETE: "DELETE";
+                        GET: "GET";
+                        HEAD: "HEAD";
+                        OPTIONS: "OPTIONS";
+                        PATCH: "PATCH";
+                        POST: "POST";
+                        PUT: "PUT";
+                    }>;
+                    pathTemplate: z.ZodString;
+                    stateChangeMarker: z.ZodBoolean;
+                    requestShape: z.ZodObject<{
+                        path: z.ZodObject<{
+                            requiredKeys: z.ZodArray<z.ZodString>;
+                            permittedKeys: z.ZodArray<z.ZodString>;
+                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                                array: "array";
+                                boolean: "boolean";
+                                null: "null";
+                                number: "number";
+                                object: "object";
+                                string: "string";
+                            }>>>;
+                        }, z.core.$strict>;
+                        query: z.ZodObject<{
+                            requiredKeys: z.ZodArray<z.ZodString>;
+                            permittedKeys: z.ZodArray<z.ZodString>;
+                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                                array: "array";
+                                boolean: "boolean";
+                                null: "null";
+                                number: "number";
+                                object: "object";
+                                string: "string";
+                            }>>>;
+                        }, z.core.$strict>;
+                        header: z.ZodObject<{
+                            requiredKeys: z.ZodArray<z.ZodString>;
+                            permittedKeys: z.ZodArray<z.ZodString>;
+                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                                array: "array";
+                                boolean: "boolean";
+                                null: "null";
+                                number: "number";
+                                object: "object";
+                                string: "string";
+                            }>>>;
+                        }, z.core.$strict>;
+                        body: z.ZodObject<{
+                            requiredKeys: z.ZodArray<z.ZodString>;
+                            permittedKeys: z.ZodArray<z.ZodString>;
+                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                                array: "array";
+                                boolean: "boolean";
+                                null: "null";
+                                number: "number";
+                                object: "object";
+                                string: "string";
+                            }>>>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>;
+                    responseDescriptor: z.ZodObject<{
+                        requiredKeys: z.ZodArray<z.ZodString>;
+                        permittedKeys: z.ZodArray<z.ZodString>;
+                        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                            array: "array";
+                            boolean: "boolean";
+                            null: "null";
+                            number: "number";
+                            object: "object";
+                            string: "string";
+                        }>>>;
+                        successIndicator: z.ZodNullable<z.ZodString>;
+                        channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                            collection: "collection";
+                            diagnostic: "diagnostic";
+                            payload: "payload";
+                            "success-indicator": "success-indicator";
+                        }>>>;
+                        collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            pointer: z.ZodString;
+                            expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                mode: z.ZodLiteral<"exact">;
+                                count: z.ZodInt;
+                            }, z.core.$strict>, z.ZodObject<{
+                                mode: z.ZodLiteral<"at-most">;
+                                max: z.ZodInt;
+                            }, z.core.$strict>, z.ZodObject<{
+                                mode: z.ZodLiteral<"page-bounded">;
+                                max: z.ZodInt;
+                            }, z.core.$strict>], "mode">;
+                            referenceSet: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>;
+                    volatilePointers: z.ZodArray<z.ZodString>;
+                    sensitivityWitness: z.ZodNullable<z.ZodObject<{
+                        witnessId: z.ZodString;
+                        channel: z.ZodEnum<{
+                            body: "body";
+                            path: "path";
+                            query: "query";
+                        }>;
+                        legs: z.ZodArray<z.ZodObject<{
+                            legId: z.ZodString;
+                            inputs: z.ZodObject<{
+                                path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                header: z.ZodRecord<z.ZodString, z.ZodString>;
+                                body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                    kind: z.ZodLiteral<"json">;
+                                    value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                                }, z.core.$strict>, z.ZodObject<{
+                                    kind: z.ZodLiteral<"absent">;
+                                }, z.core.$strict>], "kind">;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>>;
+                        relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            referenceSets: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                keys: z.ZodArray<z.ZodString>;
+                members: z.ZodArray<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+                commentary: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+            siblingGroups: z.ZodNullable<z.ZodObject<{
+                operations: z.ZodArray<z.ZodArray<z.ZodString>>;
+                parameters: z.ZodArray<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            interactionPlan: z.ZodArray<z.ZodObject<{
+                stepId: z.ZodString;
+                operationId: z.ZodString;
+                inputBinding: z.ZodObject<{
+                    path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        matcher: z.ZodEnum<{
+                            any: "any";
+                            "type-violating": "type-violating";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                    query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        matcher: z.ZodEnum<{
+                            any: "any";
+                            "type-violating": "type-violating";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                    header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        matcher: z.ZodEnum<{
+                            any: "any";
+                            "type-violating": "type-violating";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                    body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        matcher: z.ZodEnum<{
+                            any: "any";
+                            "type-violating": "type-violating";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                }, z.core.$strict>;
+                after: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            scopedResources: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                reference: z.ZodString;
+                kind: z.ZodString;
+            }, z.core.$strict>>>;
+            forbiddenInputs: z.ZodArray<z.ZodEnum<{
+                "builder-transcript": "builder-transcript";
+                "comparator-results": "comparator-results";
+                "human-labels": "human-labels";
+                "implementation-logs": "implementation-logs";
+                "original-spec": "original-spec";
+                repository: "repository";
+                "source-code": "source-code";
+            }>>;
+            testData: z.ZodObject<{
+                setup: z.ZodNullable<z.ZodString>;
+                cleanup: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            budgets: z.ZodObject<{
+                maxToolCalls: z.ZodInt;
+                maxWallClockMinutes: z.ZodInt;
+                maxCostUsd: z.ZodString;
+            }, z.core.$strict>;
+            safetyLimits: z.ZodArray<z.ZodString>;
+            requiredEvidence: z.ZodArray<z.ZodString>;
+            probeStepBound: z.ZodNullable<z.ZodInt>;
+            fixtureReset: z.ZodNullable<z.ZodObject<{
+                legId: z.ZodString;
+                interfaceId: z.ZodString;
+                operationId: z.ZodString;
+                inputs: z.ZodObject<{
+                    path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                    query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                    header: z.ZodRecord<z.ZodString, z.ZodString>;
+                    body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"json">;
+                        value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"absent">;
+                    }, z.core.$strict>], "kind">;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly priorArt: 'eval-contract';
+        readonly carriesLineage: true;
+    };
+    readonly rubric: {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            id: z.ZodString;
+            scaleLevels: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                level: z.ZodInt;
+                anchor: z.ZodString;
+            }, z.core.$strict>>>;
+            failureModePenalties: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            maxLength: z.ZodNullable<z.ZodInt>;
+            criteria: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                evidence: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+    readonly 'sealed-evaluator-brief': {
+        readonly schema: 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>;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+    readonly 'sealed-run-record': {
+        readonly schema: 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<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").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>;
+        readonly priorArt: 'h0-run-result';
+        readonly carriesLineage: true;
+    };
+    readonly 'isolation-manifest': {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            runId: z.ZodString;
+            contractId: z.ZodString;
+            conditionArm: z.ZodString;
+            modelSnapshot: z.ZodString;
+            systemPromptDigest: z.ZodString;
+            contractDigest: z.ZodString;
+            evaluatorConfigurationDigest: z.ZodString;
+            workspaceIdentity: z.ZodString;
+            allowedMounts: z.ZodArray<z.ZodString>;
+            observedMounts: z.ZodArray<z.ZodString>;
+            networkAllowlist: z.ZodArray<z.ZodString>;
+            observedNetworkTargets: z.ZodArray<z.ZodString>;
+            toolAllowlist: z.ZodArray<z.ZodString>;
+            observedToolCalls: z.ZodArray<z.ZodString>;
+            resourceCeilings: z.ZodObject<{
+                maxToolCalls: z.ZodInt;
+                maxInputTokens: z.ZodInt;
+                maxOutputTokens: z.ZodInt;
+                maxWallClockMinutes: z.ZodNumber;
+                maxCostUsd: z.ZodString;
+            }, z.core.$strict>;
+            actualResourceUse: z.ZodObject<{
+                toolCalls: z.ZodInt;
+                inputTokens: z.ZodInt;
+                outputTokens: z.ZodInt;
+                wallClockSeconds: z.ZodNumber;
+                costUsd: z.ZodString;
+            }, z.core.$strict>;
+            forbiddenInputAccounting: z.ZodObject<{
+                "builder-transcript": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                "comparator-results": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                "human-labels": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                "implementation-logs": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                "original-spec": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                repository: z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                "source-code": z.ZodObject<{
+                    withheld: z.ZodBoolean;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            violation: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        readonly priorArt: 'isolation-manifest';
+        readonly carriesLineage: true;
+    };
+    readonly 'evaluator-configuration': {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            sealedBriefDigest: z.ZodString;
+            evaluatorIdentity: z.ZodString;
+            modelSnapshot: z.ZodString;
+            systemPromptDigest: z.ZodString;
+            decodingParameters: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            toolInventory: z.ZodArray<z.ZodString>;
+            permissionInventory: z.ZodArray<z.ZodString>;
+            budgets: z.ZodObject<{
+                maxToolCalls: z.ZodInt;
+                maxWallClockMinutes: z.ZodInt;
+                maxCostUsd: z.ZodString;
+            }, z.core.$strict>;
+            seed: z.ZodNullable<z.ZodInt>;
+            judgeConfiguration: z.ZodNullable<z.ZodObject<{
+                modelSnapshot: z.ZodString;
+                systemPromptDigest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+    readonly probe: {
+        readonly schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            probeId: z.ZodString;
+            probeClass: z.ZodEnum<{
+                canary: "canary";
+                defect: "defect";
+                gameability: "gameability";
+                "zero-action": "zero-action";
+            }>;
+            behaviorId: z.ZodString;
+            systemId: z.ZodString;
+            implementationDigest: z.ZodString;
+            artifactDigest: z.ZodString;
+            commitDigest: z.ZodString;
+            rationale: z.ZodString;
+            expectedClean: z.ZodLiteral<true>;
+            defects: z.ZodArray<z.ZodObject<{
+                defectId: z.ZodString;
+                behaviorId: z.ZodString;
+                summary: z.ZodString;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+                oracleEvidence: 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">>;
+                source: z.ZodEnum<{
+                    "controlled-mutation": "controlled-mutation";
+                    natural: "natural";
+                }>;
+                manifestationWitness: z.ZodNullable<z.ZodObject<{
+                    legId: z.ZodString;
+                    interfaceId: z.ZodString;
+                    operationId: z.ZodString;
+                    inputs: z.ZodObject<{
+                        path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        header: z.ZodRecord<z.ZodString, z.ZodString>;
+                        body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"json">;
+                            value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"absent">;
+                        }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>;
+                    relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            probeId: z.ZodString;
+            probeClass: z.ZodEnum<{
+                canary: "canary";
+                defect: "defect";
+                gameability: "gameability";
+                "zero-action": "zero-action";
+            }>;
+            behaviorId: z.ZodString;
+            systemId: z.ZodString;
+            implementationDigest: z.ZodString;
+            artifactDigest: z.ZodString;
+            commitDigest: z.ZodString;
+            rationale: z.ZodString;
+            expectedClean: z.ZodLiteral<false>;
+            defects: z.ZodArray<z.ZodObject<{
+                defectId: z.ZodString;
+                behaviorId: z.ZodString;
+                summary: z.ZodString;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+                oracleEvidence: 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">>;
+                source: z.ZodEnum<{
+                    "controlled-mutation": "controlled-mutation";
+                    natural: "natural";
+                }>;
+                manifestationWitness: z.ZodNullable<z.ZodObject<{
+                    legId: z.ZodString;
+                    interfaceId: z.ZodString;
+                    operationId: z.ZodString;
+                    inputs: z.ZodObject<{
+                        path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        header: z.ZodRecord<z.ZodString, z.ZodString>;
+                        body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"json">;
+                            value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"absent">;
+                        }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>;
+                    relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "expectedClean">;
+        readonly priorArt: 'h0-ground-truth';
+        readonly carriesLineage: true;
+    };
+    readonly 'artifact-reference': {
+        readonly schema: 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">;
+        readonly priorArt: 'artifact-ref';
+        readonly carriesLineage: false;
+    };
+    readonly 'private-artifact-manifest': {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            entries: z.ZodArray<z.ZodObject<{
+                privateRef: z.ZodString;
+                digest: z.ZodString;
+                artifactKind: z.ZodEnum<{
+                    "human-label": "human-label";
+                    "implementation-patch": "implementation-patch";
+                    "isolation-manifest": "isolation-manifest";
+                    other: "other";
+                    "private-input-record": "private-input-record";
+                    "raw-result": "raw-result";
+                    "raw-trace": "raw-trace";
+                    "scripted-baseline-output": "scripted-baseline-output";
+                }>;
+                publicSafeRunId: z.ZodNullable<z.ZodString>;
+                sanitizationPolicy: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly priorArt: 'private-evidence-manifest';
+        readonly carriesLineage: true;
+    };
+    readonly 'preflight-verdict': {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            revisionCount: z.ZodInt;
+            runId: z.ZodString;
+            fixtureDigest: z.ZodString;
+            passed: z.ZodBoolean;
+            checks: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    "clean-control": "clean-control";
+                    "input-sensitivity": "input-sensitivity";
+                    "interface-present": "interface-present";
+                    "seeded-fault-fired": "seeded-fault-fired";
+                    "seeded-faults-scoped": "seeded-faults-scoped";
+                    "state-reset": "state-reset";
+                }>;
+                operationId: z.ZodNullable<z.ZodString>;
+                outcome: z.ZodEnum<{
+                    exempt: "exempt";
+                    failed: "failed";
+                    satisfied: "satisfied";
+                }>;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+    readonly 'scoring-policy': {
+        readonly schema: 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>;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+    readonly 'evidence-artifact': {
+        readonly schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            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;
+            verdictBasis: z.ZodArray<z.ZodString>;
+            callerAttestedInputs: z.ZodArray<z.ZodEnum<{
+                contractSchemaVersion: "contractSchemaVersion";
+                corpusDigest: "corpusDigest";
+                evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
+                fixtureDigest: "fixtureDigest";
+                scoringPolicyDigest: "scoringPolicyDigest";
+            }>>;
+            trials: z.ZodObject<{
+                declaredMinimum: z.ZodInt;
+                completed: z.ZodInt;
+                invalidatedAttempts: z.ZodArray<z.ZodObject<{
+                    attempt: z.ZodInt;
+                    reason: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            outcomes: z.ZodArray<z.ZodObject<{
+                oracleId: z.ZodString;
+                probeId: z.ZodNullable<z.ZodString>;
+                state: z.ZodEnum<{
+                    abstained: "abstained";
+                    bypassed: "bypassed";
+                    caught: "caught";
+                    confirmed: "confirmed";
+                    "false-positive": "false-positive";
+                    "infrastructure-error": "infrastructure-error";
+                    "judge-error": "judge-error";
+                    missed: "missed";
+                    "not-applicable": "not-applicable";
+                    "oracle-error": "oracle-error";
+                    "passed-clean-control": "passed-clean-control";
+                    unreached: "unreached";
+                }>;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+                disposition: z.ZodEnum<{
+                    held: "held";
+                    "not-attempted": "not-attempted";
+                    violated: "violated";
+                }>;
+                resolvedFrom: z.ZodNullable<z.ZodString>;
+                corroboration: z.ZodEnum<{
+                    agrees: "agrees";
+                    disagrees: "disagrees";
+                    "not-evaluable": "not-evaluable";
+                }>;
+                selectedObservationIds: z.ZodArray<z.ZodString>;
+                checkResolution: z.ZodNullable<z.ZodType<import("./evidence-artifact.ts").CheckResolutionValue, unknown, z.core.$ZodTypeInternals<import("./evidence-artifact.ts").CheckResolutionValue, unknown>>>;
+            }, z.core.$strict>>;
+            uncitedFindings: z.ZodArray<z.ZodString>;
+            coverageGaps: z.ZodArray<z.ZodObject<{
+                rule: z.ZodString;
+                relevancePredicate: z.ZodString;
+                satisfactionPredicate: z.ZodString;
+                satisfied: z.ZodBoolean;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+            }, z.core.$strict>>;
+            strength: z.ZodObject<{
+                denominator: z.ZodString;
+                basis: z.ZodEnum<{
+                    measured: "measured";
+                    reconstructed: "reconstructed";
+                }>;
+                vector: z.ZodObject<{
+                    defect: z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    gameability: z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    'zero-action': z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                comparable: z.ZodBoolean;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            remediation: z.ZodObject<{
+                revisionCount: z.ZodInt;
+                cap: z.ZodInt;
+                capSource: z.ZodLiteral<"caller-attested">;
+                lineageChain: z.ZodObject<{
+                    lengthConsistent: z.ZodBoolean;
+                    noRepeatedDigest: z.ZodBoolean;
+                    noGap: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            mode: z.ZodLiteral<"production">;
+            productionVerdict: z.ZodEnum<{
+                CONCERNS: "CONCERNS";
+                FAIL: "FAIL";
+                PASS: "PASS";
+                WAIVED: "WAIVED";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            schemaVersion: z.ZodInt;
+            parentDigest: z.ZodNullable<z.ZodString>;
+            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;
+            verdictBasis: z.ZodArray<z.ZodString>;
+            callerAttestedInputs: z.ZodArray<z.ZodEnum<{
+                contractSchemaVersion: "contractSchemaVersion";
+                corpusDigest: "corpusDigest";
+                evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
+                fixtureDigest: "fixtureDigest";
+                scoringPolicyDigest: "scoringPolicyDigest";
+            }>>;
+            trials: z.ZodObject<{
+                declaredMinimum: z.ZodInt;
+                completed: z.ZodInt;
+                invalidatedAttempts: z.ZodArray<z.ZodObject<{
+                    attempt: z.ZodInt;
+                    reason: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            outcomes: z.ZodArray<z.ZodObject<{
+                oracleId: z.ZodString;
+                probeId: z.ZodNullable<z.ZodString>;
+                state: z.ZodEnum<{
+                    abstained: "abstained";
+                    bypassed: "bypassed";
+                    caught: "caught";
+                    confirmed: "confirmed";
+                    "false-positive": "false-positive";
+                    "infrastructure-error": "infrastructure-error";
+                    "judge-error": "judge-error";
+                    missed: "missed";
+                    "not-applicable": "not-applicable";
+                    "oracle-error": "oracle-error";
+                    "passed-clean-control": "passed-clean-control";
+                    unreached: "unreached";
+                }>;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+                disposition: z.ZodEnum<{
+                    held: "held";
+                    "not-attempted": "not-attempted";
+                    violated: "violated";
+                }>;
+                resolvedFrom: z.ZodNullable<z.ZodString>;
+                corroboration: z.ZodEnum<{
+                    agrees: "agrees";
+                    disagrees: "disagrees";
+                    "not-evaluable": "not-evaluable";
+                }>;
+                selectedObservationIds: z.ZodArray<z.ZodString>;
+                checkResolution: z.ZodNullable<z.ZodType<import("./evidence-artifact.ts").CheckResolutionValue, unknown, z.core.$ZodTypeInternals<import("./evidence-artifact.ts").CheckResolutionValue, unknown>>>;
+            }, z.core.$strict>>;
+            uncitedFindings: z.ZodArray<z.ZodString>;
+            coverageGaps: z.ZodArray<z.ZodObject<{
+                rule: z.ZodString;
+                relevancePredicate: z.ZodString;
+                satisfactionPredicate: z.ZodString;
+                satisfied: z.ZodBoolean;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+            }, z.core.$strict>>;
+            strength: z.ZodObject<{
+                denominator: z.ZodString;
+                basis: z.ZodEnum<{
+                    measured: "measured";
+                    reconstructed: "reconstructed";
+                }>;
+                vector: z.ZodObject<{
+                    defect: z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    gameability: z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    'zero-action': z.ZodNullable<z.ZodObject<{
+                        caught: z.ZodInt;
+                        exercised: z.ZodInt;
+                        rate: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                comparable: z.ZodBoolean;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            remediation: z.ZodObject<{
+                revisionCount: z.ZodInt;
+                cap: z.ZodInt;
+                capSource: z.ZodLiteral<"caller-attested">;
+                lineageChain: z.ZodObject<{
+                    lengthConsistent: z.ZodBoolean;
+                    noRepeatedDigest: z.ZodBoolean;
+                    noGap: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            mode: z.ZodLiteral<"contract-scoring">;
+            contractVerdict: z.ZodEnum<{
+                CONCERNS: "CONCERNS";
+                FAIL: "FAIL";
+                PASS: "PASS";
+                WAIVED: "WAIVED";
+            }>;
+            systemRecommendationRecorded: z.ZodEnum<{
+                CONCERNS: "CONCERNS";
+                FAIL: "FAIL";
+                PASS: "PASS";
+            }>;
+            systemRecommendationNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>], "mode">;
+        readonly priorArt: null;
+        readonly carriesLineage: true;
+    };
+};
+export type InterchangeArtifactKey = keyof typeof INTERCHANGE_ARTIFACTS;
+export declare const INTERCHANGE_ARTIFACT_KEYS: readonly InterchangeArtifactKey[];