eval-quality 1.4.2 → 3.0.0

package/dist/core/schemas/defect-signature.d.ts

@@ -53,17 +53,17 @@ export declare const ProbeBindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString,
     }>;
 }, z.core.$strict>]>>>;
 /**
- * Every input channel of either kind, spelled exactly as `ObservedCallInputs`
- * spells them. The two shapes agree on channel names, on the eight-key strict
- * form, and on flatness, so the selector filters recorded call inputs with no
- * shape to bridge.
+ * Every input channel the pointer grammar admits, spelled exactly as
+ * `ObservedCallInputs` spells them. The two shapes agree on channel names, on
+ * the strict form, on width, and on flatness, so the selector filters recorded
+ * call inputs with no shape to bridge.
  *
- * One object over both kinds rather than a union, on `ObservedCallInputs`'s own
- * reasoning: `null` already means "binds nothing here", so a selector that
- * binds only command channels writes `null` in the transport four and nothing
- * is ambiguous. `InputBinding` on the contract side is a union instead, because
- * a request-shape channel's "declared, no keys" state is not the same as
- * unused and the two spellings had to stay apart.
+ * One object over all three kinds rather than a union, on
+ * `ObservedCallInputs`'s own reasoning: `null` already means "binds nothing
+ * here", so a selector that binds only command channels writes `null` in the
+ * transport four and nothing is ambiguous. `InputBinding` on the contract side
+ * is a union instead, because a request-shape channel's "declared, no keys"
+ * state differs from unused and the two spellings had to stay apart.
  */
 export declare const ProbeInputBinding: z.ZodObject<{
     path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -130,6 +130,14 @@ export declare const ProbeInputBinding: z.ZodObject<{
             "type-violating": "type-violating";
         }>;
     }, z.core.$strict>]>>>;
+    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.core.$strict>;
 /**
  * AD-39's selector grammar, duplicated on the corpus side, minus the two
@@ -208,6 +216,14 @@ export declare const ProbeStepSelector: z.ZodObject<{
                 "type-violating": "type-violating";
             }>;
         }, z.core.$strict>]>>>;
+        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.core.$strict>;
 }, z.core.$strict>;
 /**
@@ -289,21 +305,31 @@ export declare const DiscriminatingCondition: z.ZodObject<{
                     "type-violating": "type-violating";
                 }>;
             }, z.core.$strict>]>>>;
+            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.core.$strict>;
     }, z.core.$strict>;
     predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
 }, z.core.$strict>;
 /**
- * A signature against an interface that speaks HTTP. `web` and `mcp` share the
- * shape and are still rejected by the qualification gate, which is what keeps
- * `signature-interface-kind-unsupported` fireable on the kinds whose probe
- * semantics are undeclared.
+ * A signature declaring a method and a path template. `web` shares the shape
+ * and is still rejected by the qualification gate, which is what keeps
+ * `signature-interface-kind-unsupported` fireable on the one kind whose probe
+ * semantics stay undeclared.
  *
- * One branch over the three kinds rather than three identical branches. Three
- * would publish three byte-identical subschemas, and AD-13's mutation sweep
- * cannot attribute a keyword deletion to one of several identical branches:
- * deleting `pathTemplate`'s pattern from the second still leaves the first
- * accepting everything the corpus carries, so nothing flips.
+ * One branch over both kinds rather than two identical branches. Two would
+ * publish two byte-identical subschemas, and AD-13's mutation sweep cannot
+ * attribute a keyword deletion to one of several identical branches: deleting
+ * `pathTemplate`'s pattern from the second still leaves the first accepting
+ * everything the corpus carries, so nothing flips. That argument reaches only
+ * branches publishing the same keyword shape, which is why the tool-call branch
+ * below is its own.
  */
 export declare const ApiDefectSignature: z.ZodObject<{
     observableChannel: z.ZodEnum<{
@@ -383,13 +409,20 @@ export declare const ApiDefectSignature: z.ZodObject<{
                         "type-violating": "type-violating";
                     }>;
                 }, z.core.$strict>]>>>;
+                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.core.$strict>;
         }, z.core.$strict>;
         predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
     }, z.core.$strict>;
     interfaceKind: z.ZodEnum<{
         api: "api";
-        mcp: "mcp";
         web: "web";
     }>;
     method: z.ZodEnum<{
@@ -488,6 +521,14 @@ export declare const CommandDefectSignature: z.ZodObject<{
                         "type-violating": "type-violating";
                     }>;
                 }, z.core.$strict>]>>>;
+                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.core.$strict>;
         }, z.core.$strict>;
         predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
@@ -498,10 +539,118 @@ export declare const CommandDefectSignature: z.ZodObject<{
         subcommandPath: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+/**
+ * A signature against an MCP tool server. It declares the published tool name,
+ * for the reason AD-40 gives for the api-shaped pair: the identity has to be
+ * contract-independent so a signature authored against a corpus binds a second
+ * contract's operation. Every MCP call shares the one transport method
+ * `tools/call`, so the tool name is the whole of what tells two calls apart,
+ * and `McpOperation.toolName` is the field it resolves against.
+ *
+ * Its own branch, on the model `CommandDefectSignature` set. A tool call has no
+ * method and no path template, so while `mcp` sat on the api-shaped branch a
+ * signature declared a pair it could never mean and rendered an identity no
+ * operation matched. This branch publishes `toolName`'s pattern where that one
+ * publishes `method`'s enum and `pathTemplate`'s pattern, so a keyword deleted
+ * from either is attributable to it and a fixture can flip it.
+ */
+export declare const McpDefectSignature: 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>]>>>;
+                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.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"mcp">;
+    toolName: z.ZodString;
+}, z.core.$strict>;
 /**
  * A plain union rather than a discriminated one: the discriminator would have
- * to be `interfaceKind`, and the api-shaped branch carries three values for it.
- * The two branches are told apart by the identity they declare, exactly as
+ * to be `interfaceKind`, and the api-shaped branch carries two values for it.
+ * The three branches are told apart by the identity they declare, exactly as
  * `InputBinding`'s two are told apart by the channels they name.
  */
 export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
@@ -582,13 +731,20 @@ export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
                         "type-violating": "type-violating";
                     }>;
                 }, z.core.$strict>]>>>;
+                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.core.$strict>;
         }, z.core.$strict>;
         predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
     }, z.core.$strict>;
     interfaceKind: z.ZodEnum<{
         api: "api";
-        mcp: "mcp";
         web: "web";
     }>;
     method: z.ZodEnum<{
@@ -679,6 +835,14 @@ export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
                         "type-violating": "type-violating";
                     }>;
                 }, z.core.$strict>]>>>;
+                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.core.$strict>;
         }, z.core.$strict>;
         predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
@@ -688,8 +852,101 @@ export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
         executable: z.ZodString;
         subcommandPath: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
+}, 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>]>>>;
+                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.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"mcp">;
+    toolName: z.ZodString;
 }, z.core.$strict>]>;
 export type ApiDefectSignature = z.infer<typeof ApiDefectSignature>;
 export type CommandDefectSignature = z.infer<typeof CommandDefectSignature>;
+export type McpDefectSignature = z.infer<typeof McpDefectSignature>;
 export type DefectSignature = z.infer<typeof DefectSignature>;
 export type ProbeInputBinding = z.infer<typeof ProbeInputBinding>;

package/dist/core/schemas/defect-signature.js

@@ -4,7 +4,7 @@ import { Expression } from './expression.js';
 import { CommandInvocation, HttpMethod, PathTemplate } from './interface.js';
 import { LiteralBindingValue, MatcherBindingValue } from './plan.js';
 import { EvidenceChannel } from './pointer.js';
-import { KeyName } from './primitives.js';
+import { KeyName, ToolName } from './primitives.js';
 /**
  * The reserved step identifier every pointer in a discriminating condition is
  * rooted at. AD-40 requires the predicate to be rooted at the selected
@@ -50,9 +50,9 @@ export const PROBE_BINDING_CHANNEL_NON_EMPTY = 'probe-binding-channel-non-empty'
 //
 // Named, like `InputBindingChannel`, so the constraint ledger has one stable
 // address to inject `minProperties` at. Verified rather than assumed: leaving
-// it inlined at four addresses left the rejection Zod-only, and the
+// it inlined at one address per channel left the rejection Zod-only, and the
 // published-schema differential caught the disagreement on a synthesised
-// witness carrying `{}` in three of the four channels.
+// witness carrying `{}` in several of them.
 export const ProbeBindingChannel = z
     .record(KeyName, ProbeBindingValue)
     .refine((entries) => Object.keys(entries).length > 0, {
@@ -64,19 +64,20 @@ export const ProbeBindingChannel = z
     description: "A parameter-name-to-binding-value map for one input channel of a defect signature's selector, or `null` for a channel the selector binds nothing in. An empty map is rejected: `null` is the only spelling for unbound. Admits `{ literal }` and `{ matcher }` only; `{ captured }` and `{ principal }` are contract-local vocabulary and a corpus signature cannot carry either.",
 });
 /**
- * Every input channel of either kind, spelled exactly as `ObservedCallInputs`
- * spells them. The two shapes agree on channel names, on the eight-key strict
- * form, and on flatness, so the selector filters recorded call inputs with no
- * shape to bridge.
+ * Every input channel the pointer grammar admits, spelled exactly as
+ * `ObservedCallInputs` spells them. The two shapes agree on channel names, on
+ * the strict form, on width, and on flatness, so the selector filters recorded
+ * call inputs with no shape to bridge.
  *
- * One object over both kinds rather than a union, on `ObservedCallInputs`'s own
- * reasoning: `null` already means "binds nothing here", so a selector that
- * binds only command channels writes `null` in the transport four and nothing
- * is ambiguous. `InputBinding` on the contract side is a union instead, because
- * a request-shape channel's "declared, no keys" state is not the same as
- * unused and the two spellings had to stay apart.
+ * One object over all three kinds rather than a union, on
+ * `ObservedCallInputs`'s own reasoning: `null` already means "binds nothing
+ * here", so a selector that binds only command channels writes `null` in the
+ * transport four and nothing is ambiguous. `InputBinding` on the contract side
+ * is a union instead, because a request-shape channel's "declared, no keys"
+ * state differs from unused and the two spellings had to stay apart.
  */
-export const ProbeInputBinding = z.strictObject({
+export const ProbeInputBinding = z
+    .strictObject({
     path: ProbeBindingChannel,
     query: ProbeBindingChannel,
     header: ProbeBindingChannel,
@@ -85,7 +86,9 @@ export const ProbeInputBinding = z.strictObject({
     option: ProbeBindingChannel,
     environment: ProbeBindingChannel,
     stdin: ProbeBindingChannel,
-});
+    arguments: ProbeBindingChannel,
+})
+    .describe('The probe\'s `schemaVersion` 4 -> 5 BREAKING bump under AD-11, whose rule is that removing or retyping is breaking. Two retypings land under this one stamp and both are named here. This selector gained a ninth channel, `arguments`, so a signature against a tool call can filter on what the call supplied; the sealed run record\'s `ObservedCallInputs` gained the same key under its own breaking bump, since a selector naming a channel no observation records would filter against nothing. And `DefectSignature` gained an `McpDefectSignature` branch declaring a published tool name, while `ApiDefectSignature.interfaceKind` narrowed to `api` and `web`, so a version-4 probe carrying `interfaceKind: "mcp"` beside a method and a path template stops parsing. Version 4 took the witness leg shape and this stamp takes both changes above, so each retype stays independently releasable.');
 /**
  * AD-39's selector grammar, duplicated on the corpus side, minus the two
  * members a corpus cannot fill. The operation is the signature's own home
@@ -117,36 +120,40 @@ export const DiscriminatingCondition = z.strictObject({
     predicate: Expression.describe("An AD-4 expression over AD-26 response channels, every pointer rooted at the reserved step identifier `observed`. Legality is the corpus qualification gate's: an unchecked predicate admits `existence` over a literal, which is true of every observation and makes the catch rate 1.00 by construction."),
 });
 /**
- * AD-40's four declarations: the interface kind, the defect's home operation as
- * a method and a path template, the observable channel it manifests in, and the
- * discriminating condition that separates it from correct behaviour.
+ * Three of AD-40's four declarations, the three every branch shares: the
+ * observable channel the defect manifests in, the discriminating condition that
+ * separates it from correct behaviour, and the interface kind each branch
+ * spells as its own literal or enum. The fourth is the defect's home operation,
+ * which each branch declares in its own kind's transport identity.
  *
- * Method and path template rather than an operation identifier, because AD-19
- * declares both per operation and both are contract-independent: an identifier
- * is contract-local and would bind nothing against a second contract.
- * Resolution erases parameter names before comparing, so a signature on
- * `/notes/{id}` binds a contract declaring `/notes/{noteId}`; a post-erasure
- * collision inside one contract has already failed compilation under
- * `duplicate-operation-signature`.
+ * A declared transport identity rather than an operation identifier, because
+ * AD-19 declares one per operation and it is contract-independent: an
+ * identifier is contract-local and would bind nothing against a second
+ * contract. The api-shaped branch erases parameter names before comparing, so a
+ * signature on `/notes/{id}` binds a contract declaring `/notes/{noteId}`; a
+ * post-erasure collision inside one contract has already failed compilation
+ * under `duplicate-operation-signature`.
  */
 const signatureCommon = {
     observableChannel: EvidenceChannel.describe('AD-26\'s channel the seeded defect manifests in. The qualification gate reads it: a condition passes only if its pointers name this channel, or name two channels with at least one response-side member. That rule exists to reject a condition collapsing to "the evidence contains the string I sent", which is satisfied by a finding that merely echoes its own input. It must also be a channel the declared kind produces: an api interface writes nothing to standard output and a command returns no HTTP status.'),
     condition: DiscriminatingCondition,
 };
 /**
- * A signature against an interface that speaks HTTP. `web` and `mcp` share the
- * shape and are still rejected by the qualification gate, which is what keeps
- * `signature-interface-kind-unsupported` fireable on the kinds whose probe
- * semantics are undeclared.
+ * A signature declaring a method and a path template. `web` shares the shape
+ * and is still rejected by the qualification gate, which is what keeps
+ * `signature-interface-kind-unsupported` fireable on the one kind whose probe
+ * semantics stay undeclared.
  *
- * One branch over the three kinds rather than three identical branches. Three
- * would publish three byte-identical subschemas, and AD-13's mutation sweep
- * cannot attribute a keyword deletion to one of several identical branches:
- * deleting `pathTemplate`'s pattern from the second still leaves the first
- * accepting everything the corpus carries, so nothing flips.
+ * One branch over both kinds rather than two identical branches. Two would
+ * publish two byte-identical subschemas, and AD-13's mutation sweep cannot
+ * attribute a keyword deletion to one of several identical branches: deleting
+ * `pathTemplate`'s pattern from the second still leaves the first accepting
+ * everything the corpus carries, so nothing flips. That argument reaches only
+ * branches publishing the same keyword shape, which is why the tool-call branch
+ * below is its own.
  */
 export const ApiDefectSignature = z.strictObject({
-    interfaceKind: z.enum(['api', 'web', 'mcp']),
+    interfaceKind: z.enum(['api', 'web']),
     method: HttpMethod,
     pathTemplate: PathTemplate,
     ...signatureCommon,
@@ -163,13 +170,34 @@ export const CommandDefectSignature = z.strictObject({
     invocation: CommandInvocation,
     ...signatureCommon,
 });
+/**
+ * A signature against an MCP tool server. It declares the published tool name,
+ * for the reason AD-40 gives for the api-shaped pair: the identity has to be
+ * contract-independent so a signature authored against a corpus binds a second
+ * contract's operation. Every MCP call shares the one transport method
+ * `tools/call`, so the tool name is the whole of what tells two calls apart,
+ * and `McpOperation.toolName` is the field it resolves against.
+ *
+ * Its own branch, on the model `CommandDefectSignature` set. A tool call has no
+ * method and no path template, so while `mcp` sat on the api-shaped branch a
+ * signature declared a pair it could never mean and rendered an identity no
+ * operation matched. This branch publishes `toolName`'s pattern where that one
+ * publishes `method`'s enum and `pathTemplate`'s pattern, so a keyword deleted
+ * from either is attributable to it and a fixture can flip it.
+ */
+export const McpDefectSignature = z.strictObject({
+    interfaceKind: z.literal('mcp'),
+    toolName: ToolName,
+    ...signatureCommon,
+});
 /**
  * A plain union rather than a discriminated one: the discriminator would have
- * to be `interfaceKind`, and the api-shaped branch carries three values for it.
- * The two branches are told apart by the identity they declare, exactly as
+ * to be `interfaceKind`, and the api-shaped branch carries two values for it.
+ * The three branches are told apart by the identity they declare, exactly as
  * `InputBinding`'s two are told apart by the channels they name.
  */
 export const DefectSignature = z.union([
     ApiDefectSignature,
     CommandDefectSignature,
+    McpDefectSignature,
 ]);