eval-quality 0.1.0 → 0.3.0

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

@@ -105,14 +105,9 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 approval: z.ZodNullable<z.ZodString>;
                 expiresAt: z.ZodNullable<z.ZodISODateTime>;
             }, z.core.$strict>>;
-            permittedInterfaces: z.ZodArray<z.ZodObject<{
+            permittedInterfaces: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 logicalId: z.ZodString;
-                kind: z.ZodEnum<{
-                    api: "api";
-                    cli: "cli";
-                    mcp: "mcp";
-                    web: "web";
-                }>;
+                kind: z.ZodLiteral<"api">;
                 operations: z.ZodArray<z.ZodObject<{
                     operationId: z.ZodString;
                     method: z.ZodEnum<{
@@ -213,13 +208,17 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     sensitivityWitness: z.ZodNullable<z.ZodObject<{
                         witnessId: z.ZodString;
                         channel: z.ZodEnum<{
+                            argument: "argument";
                             body: "body";
+                            environment: "environment";
+                            option: "option";
                             path: "path";
                             query: "query";
+                            stdin: "stdin";
                         }>;
                         legs: z.ZodArray<z.ZodObject<{
                             legId: z.ZodString;
-                            inputs: z.ZodObject<{
+                            inputs: z.ZodUnion<readonly [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>;
@@ -229,12 +228,453 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                 }, z.core.$strict>, z.ZodObject<{
                                     kind: z.ZodLiteral<"absent">;
                                 }, z.core.$strict>], "kind">;
-                            }, z.core.$strict>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                environment: z.ZodRecord<z.ZodString, z.ZodString>;
+                                stdin: 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<"text">;
+                                    value: z.ZodString;
+                                }, 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>>;
+            }, z.core.$strict>, z.ZodObject<{
+                logicalId: z.ZodString;
+                kind: z.ZodLiteral<"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<{
+                            argument: "argument";
+                            body: "body";
+                            environment: "environment";
+                            option: "option";
+                            path: "path";
+                            query: "query";
+                            stdin: "stdin";
+                        }>;
+                        legs: z.ZodArray<z.ZodObject<{
+                            legId: z.ZodString;
+                            inputs: z.ZodUnion<readonly [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.ZodObject<{
+                                argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                environment: z.ZodRecord<z.ZodString, z.ZodString>;
+                                stdin: 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<"text">;
+                                    value: z.ZodString;
+                                }, 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>, z.ZodObject<{
+                logicalId: z.ZodString;
+                kind: z.ZodLiteral<"mcp">;
+                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<{
+                            argument: "argument";
+                            body: "body";
+                            environment: "environment";
+                            option: "option";
+                            path: "path";
+                            query: "query";
+                            stdin: "stdin";
+                        }>;
+                        legs: z.ZodArray<z.ZodObject<{
+                            legId: z.ZodString;
+                            inputs: z.ZodUnion<readonly [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.ZodObject<{
+                                argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                environment: z.ZodRecord<z.ZodString, z.ZodString>;
+                                stdin: 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<"text">;
+                                    value: z.ZodString;
+                                }, 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>, z.ZodObject<{
+                logicalId: z.ZodString;
+                kind: z.ZodLiteral<"cli">;
+                operations: z.ZodArray<z.ZodObject<{
+                    operationId: z.ZodString;
+                    invocation: z.ZodObject<{
+                        executable: z.ZodString;
+                        subcommandPath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>;
+                    stateChangeMarker: z.ZodBoolean;
+                    requestShape: z.ZodObject<{
+                        argument: 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>;
+                        option: 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>;
+                        environment: 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>;
+                        stdin: 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>;
+                    artifacts: z.ZodArray<z.ZodString>;
+                    descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"stream">;
+                        channel: z.ZodEnum<{
+                            stderr: "stderr";
+                            stdout: "stdout";
+                        }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"artifact">;
+                        artifactId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    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<{
+                            argument: "argument";
+                            body: "body";
+                            environment: "environment";
+                            option: "option";
+                            path: "path";
+                            query: "query";
+                            stdin: "stdin";
+                        }>;
+                        legs: z.ZodArray<z.ZodObject<{
+                            legId: z.ZodString;
+                            inputs: z.ZodUnion<readonly [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.ZodObject<{
+                                argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                                environment: z.ZodRecord<z.ZodString, z.ZodString>;
+                                stdin: 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<"text">;
+                                    value: z.ZodString;
+                                }, 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>], "kind">>;
             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>>>;
@@ -247,7 +687,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
             interactionPlan: z.ZodArray<z.ZodObject<{
                 stepId: z.ZodString;
                 operationId: z.ZodString;
-                inputBinding: z.ZodObject<{
+                inputBinding: z.ZodUnion<readonly [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<{
@@ -255,6 +695,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 +707,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 +719,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 +731,67 @@ 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>;
+                }, z.core.$strict>, z.ZodObject<{
+                    argument: 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.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    option: 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.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    environment: 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.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    stdin: 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.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 +809,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 +910,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 +929,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;
@@ -456,7 +977,11 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 }, z.core.$strict>], "storage">>;
                 findingType: z.ZodLiteral<"defect">;
                 observationIds: z.ZodArray<z.ZodString>;
-                quotedEvidence: z.ZodArray<z.ZodObject<{
+                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";
@@ -467,7 +992,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         stderr: "stderr";
                         stdout: "stdout";
                     }>;
-                }, z.core.$strict>>;
+                    artifactId: z.ZodNull;
+                }, z.core.$strict>]>>;
             }, z.core.$strict>, z.ZodObject<{
                 findingId: z.ZodString;
                 oracleId: z.ZodNullable<z.ZodString>;
@@ -521,23 +1047,54 @@ 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";
                     "evaluator-chosen": "evaluator-chosen";
                 }>;
+                principal: z.ZodNullable<z.ZodString>;
                 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>>>;
+                    argument: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+                    option: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+                    environment: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+                    stdin: 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>;
+                stdout: 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<"text">;
+                    value: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"absent">;
+                }, z.core.$strict>], "kind">;
+                stderr: 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<"text">;
+                    value: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"absent">;
+                }, z.core.$strict>], "kind">;
                 exitCode: z.ZodNullable<z.ZodInt>;
+                artifacts: z.ZodRecord<z.ZodString, 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<"text">;
+                    value: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"absent">;
+                }, z.core.$strict>], "kind">>;
             }, z.core.$strict>>;
             judgeResults: z.ZodArray<z.ZodObject<{
                 rubricId: z.ZodString;
@@ -695,6 +1252,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 +1435,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 +1601,191 @@ 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.ZodUnion<readonly [z.ZodObject<{
+                observableChannel: z.ZodEnum<{
+                    artifact: "artifact";
+                    "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>]>>>;
+                            argument: 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>]>>>;
+                            option: 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>]>>>;
+                            environment: 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>]>>>;
+                            stdin: 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>;
+                interfaceKind: z.ZodEnum<{
+                    api: "api";
+                    mcp: "mcp";
+                    web: "web";
+                }>;
+                method: z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    HEAD: "HEAD";
+                    OPTIONS: "OPTIONS";
+                    PATCH: "PATCH";
+                    POST: "POST";
+                    PUT: "PUT";
+                }>;
+                pathTemplate: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                observableChannel: z.ZodEnum<{
+                    artifact: "artifact";
+                    "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>]>>>;
+                            argument: 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>]>>>;
+                            option: 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>]>>>;
+                            environment: 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>]>>>;
+                            stdin: 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>;
+                interfaceKind: z.ZodLiteral<"cli">;
+                invocation: z.ZodObject<{
+                    executable: z.ZodString;
+                    subcommandPath: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>>;
         }, z.core.$strict>], "expectedClean">;
         readonly priorArt: 'h0-ground-truth';
         readonly carriesLineage: true;
@@ -883,6 +1871,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 +1887,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 +1896,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 corpusDigest: "corpusDigest";
                 evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
                 fixtureDigest: "fixtureDigest";
+                mode: "mode";
                 scoringPolicyDigest: "scoringPolicyDigest";
             }>>;
             trials: z.ZodObject<{
@@ -1008,6 +1991,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 +2012,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 +2021,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 corpusDigest: "corpusDigest";
                 evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
                 fixtureDigest: "fixtureDigest";
+                mode: "mode";
                 scoringPolicyDigest: "scoringPolicyDigest";
             }>>;
             trials: z.ZodObject<{
@@ -1131,6 +2116,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 +2131,32 @@ 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.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";