eval-quality 0.2.0 → 0.5.0

package/dist/core/schemas/eval-contract.d.ts

@@ -99,6 +99,22 @@ export declare const Budgets: z.ZodObject<{
     maxWallClockMinutes: z.ZodInt;
     maxCostUsd: z.ZodString;
 }, z.core.$strict>;
+/**
+ * The one `schemaVersion` this build reads.
+ *
+ * AD-11 says "readers accept an equal `schemaVersion` only and throw
+ * `schema-version-mismatch` outside that", and puts the comparison on the
+ * reader rather than in the schema: `lineage.ts` records that a `z.literal`
+ * would turn a version-2 artifact into an anonymous parse failure instead of
+ * AD-28's dedicated fault. That left the rule stated everywhere and performed
+ * nowhere for this artifact, so a contract stamped 3 parsed and compiled clean
+ * and its stale version travelled into the scoring version, which is the one
+ * number AD-11 exists to keep comparable.
+ *
+ * `compile` is the reader that performs it. The constant lives here beside the
+ * schema whose version it names, so the bump and the constant are one edit.
+ */
+export declare const EVAL_CONTRACT_SCHEMA_VERSION = 4;
 export declare const EvalContract: z.ZodObject<{
     schemaVersion: z.ZodInt;
     parentDigest: z.ZodNullable<z.ZodString>;
@@ -185,14 +201,9 @@ export declare const EvalContract: z.ZodObject<{
         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<{
@@ -293,13 +304,17 @@ export declare const EvalContract: z.ZodObject<{
             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>;
@@ -309,12 +324,453 @@ export declare const EvalContract: z.ZodObject<{
                         }, 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>>>;
@@ -327,7 +783,7 @@ export declare const EvalContract: z.ZodObject<{
     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<{
@@ -376,7 +832,56 @@ export declare const EvalContract: z.ZodObject<{
             }, 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";

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

@@ -105,6 +105,22 @@ export const Budgets = z.strictObject({
     maxWallClockMinutes: z.int().min(0),
     maxCostUsd: UnsignedDecimalString.describe('Money, so AD-36 carries it as a string in a declared format rather than as a JSON number. Constrained to the unsigned form: a negative ceiling is not a ceiling.'),
 });
+/**
+ * The one `schemaVersion` this build reads.
+ *
+ * AD-11 says "readers accept an equal `schemaVersion` only and throw
+ * `schema-version-mismatch` outside that", and puts the comparison on the
+ * reader rather than in the schema: `lineage.ts` records that a `z.literal`
+ * would turn a version-2 artifact into an anonymous parse failure instead of
+ * AD-28's dedicated fault. That left the rule stated everywhere and performed
+ * nowhere for this artifact, so a contract stamped 3 parsed and compiled clean
+ * and its stale version travelled into the scoring version, which is the one
+ * number AD-11 exists to keep comparable.
+ *
+ * `compile` is the reader that performs it. The constant lives here beside the
+ * schema whose version it names, so the bump and the constant are one edit.
+ */
+export const EVAL_CONTRACT_SCHEMA_VERSION = 4;
 export const EvalContract = z
     .strictObject({
     // AD-11's schemaVersion and AD-29's lineage pair, spread from the leaf
@@ -128,7 +144,7 @@ export const EvalContract = z
     waivers: z.array(Waiver),
     permittedInterfaces: z
         .array(PermittedInterface)
-        .describe('AD-35: logical identifiers only. No entry here is ever a URL, a host, or a port.'),
+        .describe("AD-35: logical identifiers only. No entry here is ever a URL, a host, or a port. Discriminated on `kind`, which makes this field the eval contract's `schemaVersion` 3 -> 4 BREAKING bump under AD-11, whose rule is that \"adding an optional field is a `schemaVersion` bump recorded in the field's own description; removing or retyping is breaking\". The `api`, `web`, and `mcp` branches carry the shipped operation shape unchanged, so a version-3 contract's own bytes still parse on them; the `cli` branch carries a command operation, which declares a logical invocation instead of a method and a path template, four command input channels instead of the four transport channels, a nominated output channel for its one response descriptor, and the files it writes."),
     referenceSets: z
         .record(Identifier, ReferenceSetDeclaration)
         .nullable()
@@ -157,5 +173,5 @@ export const EvalContract = z
 })
     .meta({
     id: 'EvalContract',
-    description: "The Eval Contract. Succeeds the prior-art `eval-contract` schema per AD-24. It carries every declaration AD-19 requires so that AD-31's fourteen relevance and satisfaction predicates are decidable from declarations alone. AD-10's sensitivity witnesses arrived in this version, on each operation, as the additive `schemaVersion` bump AD-11 requires; the bump is recorded in each new field's own description, since no reader in this version declares an expected version constant to compare against.",
+    description: "The Eval Contract. Succeeds the prior-art `eval-contract` schema per AD-24. It carries every declaration AD-19 requires so that AD-31's fourteen relevance and satisfaction predicates are decidable from declarations alone. AD-10's sensitivity witnesses arrived on each operation as an additive `schemaVersion` bump; version 4 opens `permittedInterfaces` to a second interface kind, so a contract may describe a system under test that runs behind a command, and widens the interaction pointer's accepted language with the four command input channels and the `artifact` channel. The widening retypes nothing on its own, since every pointer legal under version 3 is still legal; it carries the same version because it ships in the same release as the retypes. Each bump is recorded in its own field's description, and `compile` compares the stamp against `EVAL_CONTRACT_SCHEMA_VERSION` and throws AD-28's `schema-version-mismatch` on anything else.",
 });