eval-quality 1.4.2 → 2.0.0

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

@@ -114,7 +114,7 @@ export declare const Budgets: z.ZodObject<{
  * `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 EVAL_CONTRACT_SCHEMA_VERSION = 5;
 export declare const EvalContract: z.ZodObject<{
     schemaVersion: z.ZodInt;
     parentDigest: z.ZodNullable<z.ZodString>;
@@ -305,6 +305,7 @@ export declare const EvalContract: z.ZodObject<{
                 witnessId: z.ZodString;
                 channel: z.ZodEnum<{
                     argument: "argument";
+                    arguments: "arguments";
                     body: "body";
                     environment: "environment";
                     option: "option";
@@ -337,6 +338,8 @@ export declare const EvalContract: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>>;
                 relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -446,6 +449,7 @@ export declare const EvalContract: z.ZodObject<{
                 witnessId: z.ZodString;
                 channel: z.ZodEnum<{
                     argument: "argument";
+                    arguments: "arguments";
                     body: "body";
                     environment: "environment";
                     option: "option";
@@ -478,6 +482,8 @@ export declare const EvalContract: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>>;
                 relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -488,55 +494,10 @@ export declare const EvalContract: z.ZodObject<{
         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;
+            toolName: 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<{
+                arguments: z.ZodObject<{
                     requiredKeys: z.ZodArray<z.ZodString>;
                     permittedKeys: z.ZodArray<z.ZodString>;
                     types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
@@ -549,6 +510,9 @@ export declare const EvalContract: z.ZodObject<{
                     }>>>;
                 }, z.core.$strict>;
             }, z.core.$strict>;
+            descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"structured-result">;
+            }, z.core.$strict>], "kind">;
             responseDescriptor: z.ZodObject<{
                 requiredKeys: z.ZodArray<z.ZodString>;
                 permittedKeys: z.ZodArray<z.ZodString>;
@@ -587,6 +551,7 @@ export declare const EvalContract: z.ZodObject<{
                 witnessId: z.ZodString;
                 channel: z.ZodEnum<{
                     argument: "argument";
+                    arguments: "arguments";
                     body: "body";
                     environment: "environment";
                     option: "option";
@@ -619,6 +584,8 @@ export declare const EvalContract: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>>;
                 relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -733,6 +700,7 @@ export declare const EvalContract: z.ZodObject<{
                 witnessId: z.ZodString;
                 channel: z.ZodEnum<{
                     argument: "argument";
+                    arguments: "arguments";
                     body: "body";
                     environment: "environment";
                     option: "option";
@@ -765,6 +733,8 @@ export declare const EvalContract: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>>;
                 relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -881,6 +851,19 @@ export declare const EvalContract: z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 principal: z.ZodString;
             }, z.core.$strict>]>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            arguments: 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<{
@@ -947,6 +930,8 @@ export declare const EvalContract: z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"absent">;
             }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
         }, z.core.$strict>]>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

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

@@ -120,7 +120,7 @@ export const Budgets = z.strictObject({
  * `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 EVAL_CONTRACT_SCHEMA_VERSION = 5;
 export const EvalContract = z
     .strictObject({
     // AD-11's schemaVersion and AD-29's lineage pair, spread from the leaf
@@ -144,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. 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."),
+        .describe('AD-35: logical identifiers only. No entry here is ever a URL, a host, or a port. Discriminated on `kind`, and the field AD-11 puts this artifact\'s bump record on, whose rule is that "adding an optional field is a `schemaVersion` bump recorded in the field\'s own description; removing or retyping is breaking". Version 4 added the `cli` branch, carrying a command operation: a logical invocation in place of a method and a path template, four command input channels, a nominated output channel for its one response descriptor, and the files it writes. Version 5 is the `schemaVersion` 4 -> 5 BREAKING bump: the `mcp` branch stops carrying the HTTP operation shape and carries a tool call instead, declaring a published tool name as its whole transport identity, one `arguments` request channel, and a tagged descriptor channel over the structured result. An `mcp` interface written against version 4 no longer parses. `api`, `web`, and `cli` keep every byte they had.'),
     referenceSets: z
         .record(Identifier, ReferenceSetDeclaration)
         .nullable()
@@ -173,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 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.",
+    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. Version 5 gives the `mcp` kind its own operation shape, so a contract may describe a tool server, and widens the pointer language and a step's input binding with the `arguments` channel. Each bump is recorded in its own field's description, and `compile` compares the stamp against `EVAL_CONTRACT_SCHEMA_VERSION` and throws AD-28's `schema-version-mismatch` on anything else.",
 });

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

@@ -250,6 +250,7 @@ export declare const Operation: z.ZodObject<{
         witnessId: z.ZodString;
         channel: z.ZodEnum<{
             argument: "argument";
+            arguments: "arguments";
             body: "body";
             environment: "environment";
             option: "option";
@@ -282,6 +283,8 @@ export declare const Operation: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"absent">;
                 }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
             }, z.core.$strict>]>;
         }, z.core.$strict>>;
         relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -505,6 +508,7 @@ export declare const CommandOperation: z.ZodObject<{
         witnessId: z.ZodString;
         channel: z.ZodEnum<{
             argument: "argument";
+            arguments: "arguments";
             body: "body";
             environment: "environment";
             option: "option";
@@ -537,14 +541,170 @@ export declare const CommandOperation: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"absent">;
                 }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
             }, 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>;
 export type CommandOperation = z.infer<typeof CommandOperation>;
-/** Either operation shape, for the consumers that read only kind-neutral fields. */
-export type AnyOperation = Operation | CommandOperation;
+/**
+ * The tool-call counterpart of `RequestShape`, a one-key strict object for the
+ * reason that comment gives: a record over a channel enum demands every member
+ * at parse time, and the partial spelling that would relax it is the one the
+ * Consistency Conventions ban.
+ *
+ * One key rather than four. A tool call carries an arguments object and nothing
+ * else, so declaring `path`, `query`, and `header` beside it would put three
+ * channels on every contract that no call can ever send and no oracle can ever
+ * reach.
+ */
+export declare const McpRequestShape: z.ZodObject<{
+    arguments: 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>;
+export type McpRequestShape = z.infer<typeof McpRequestShape>;
+/**
+ * Which output channel the operation's one response descriptor describes.
+ *
+ * Tagged on `kind` with one member, following `CommandDescriptorChannel`. The
+ * second member is already known: a tool that returns prose rather than
+ * structured content is outside this version, and admitting it later adds a
+ * member, which AD-11 makes additive, where retyping a bare field would be
+ * breaking.
+ */
+export declare const McpDescriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"structured-result">;
+}, z.core.$strict>], "kind">;
+export type McpDescriptorChannel = z.infer<typeof McpDescriptorChannel>;
+/**
+ * A tool-call operation.
+ *
+ * `toolName` is the whole transport identity. Every MCP call shares the one
+ * transport identity `tools/call` and the tool name is what distinguishes two
+ * of them, so a method and a path template would render one signature for every
+ * tool a server publishes and collide under `duplicate-operation-signature`.
+ * AD-40 needs that identity readable by a probe seeder who has never opened the
+ * contract, and a published tool name is exactly that.
+ *
+ * It carries the same `ResponseDescriptor` an api operation carries, over the
+ * structured result its `descriptorChannel` nominates, so all fourteen AD-31
+ * predicates read one descriptor one dereference deep with no kind-specific
+ * arm.
+ */
+export declare const McpOperation: z.ZodObject<{
+    operationId: z.ZodString;
+    toolName: z.ZodString;
+    stateChangeMarker: z.ZodBoolean;
+    requestShape: z.ZodObject<{
+        arguments: 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>;
+    descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"structured-result">;
+    }, 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";
+            arguments: "arguments";
+            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.ZodObject<{
+                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            }, 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>;
+export type McpOperation = z.infer<typeof McpOperation>;
+/** Any operation shape, for the consumers that read only kind-neutral fields. */
+export type AnyOperation = Operation | CommandOperation | McpOperation;
 /**
  * AD-19's four interface kinds, exported once so nothing else respells them:
  * the sealed evaluator brief carries interface identity without the operation
@@ -562,8 +722,9 @@ export declare const InterfaceKind: z.ZodEnum<{
 }>;
 /**
  * Discriminated on `kind`, so an operation shape cannot be smuggled onto the
- * wrong interface: a `cli` interface declaring `method` and an `api` interface
- * declaring `invocation` are both parse errors.
+ * wrong interface: a `cli` interface declaring `method`, an `api` interface
+ * declaring `invocation`, and an `mcp` interface declaring either are all parse
+ * errors.
  */
 export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
     logicalId: z.ZodString;
@@ -669,6 +830,7 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
             witnessId: z.ZodString;
             channel: z.ZodEnum<{
                 argument: "argument";
+                arguments: "arguments";
                 body: "body";
                 environment: "environment";
                 option: "option";
@@ -701,6 +863,8 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"absent">;
                     }, z.core.$strict>], "kind">;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
             relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -810,6 +974,7 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
             witnessId: z.ZodString;
             channel: z.ZodEnum<{
                 argument: "argument";
+                arguments: "arguments";
                 body: "body";
                 environment: "environment";
                 option: "option";
@@ -842,6 +1007,8 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"absent">;
                     }, z.core.$strict>], "kind">;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
             relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -852,55 +1019,10 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
     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;
+        toolName: 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<{
+            arguments: z.ZodObject<{
                 requiredKeys: z.ZodArray<z.ZodString>;
                 permittedKeys: z.ZodArray<z.ZodString>;
                 types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
@@ -913,6 +1035,9 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 }>>>;
             }, z.core.$strict>;
         }, z.core.$strict>;
+        descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"structured-result">;
+        }, z.core.$strict>], "kind">;
         responseDescriptor: z.ZodObject<{
             requiredKeys: z.ZodArray<z.ZodString>;
             permittedKeys: z.ZodArray<z.ZodString>;
@@ -951,6 +1076,7 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
             witnessId: z.ZodString;
             channel: z.ZodEnum<{
                 argument: "argument";
+                arguments: "arguments";
                 body: "body";
                 environment: "environment";
                 option: "option";
@@ -983,6 +1109,8 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"absent">;
                     }, z.core.$strict>], "kind">;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
             relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -1097,6 +1225,7 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
             witnessId: z.ZodString;
             channel: z.ZodEnum<{
                 argument: "argument";
+                arguments: "arguments";
                 body: "body";
                 environment: "environment";
                 option: "option";
@@ -1129,6 +1258,8 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"absent">;
                     }, z.core.$strict>], "kind">;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
             relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -1137,9 +1268,16 @@ export declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>], "kind">;
 export type PermittedInterface = z.infer<typeof PermittedInterface>;
 /**
- * One interface's operations widened to the element union. TypeScript will not
- * iterate `iface.operations` directly, because the union's branches give it a
- * union of array types whose `map` signatures do not unify; this is the one
- * place that widening is spelled, so no call site invents its own.
+ * One interface's operations widened to the element union, for the callers
+ * that read only fields all three shapes carry. `iface.operations.map(...)` on
+ * an un-narrowed interface does not compile, because the union's branches give
+ * it a union of array types whose `map` signatures do not unify, and this is
+ * the one place that widening is spelled so no call site invents its own.
+ *
+ * A caller that narrows on `iface.kind` first wants the opposite and should
+ * read `iface.operations` directly: each branch declares its own element type,
+ * and this function discards the kind-to-shape correlation that a later kind
+ * test cannot recover. `buildPlanIndex` (`core/seal/plan-index.ts`) is the site
+ * that sorts by kind, and it narrows first for exactly that reason.
  */
 export declare const operationsOf: (iface: PermittedInterface) => readonly AnyOperation[];