eval-quality 0.2.0 → 0.5.0

package/dist/core/schemas/constraint-ledger.js

@@ -152,6 +152,17 @@ export const CONSTRAINT_LEDGER = [
             reason: "Uniqueness of a nested field across sibling array items has no draft-2020-12 keyword: `uniqueItems` compares whole items structurally and nothing in the dialect can name one property path and require distinctness on it alone. Unlike the lineage biconditional above, this constraint IS enforced by Zod (a `.refine()` on `observations`), because owed item 2 requires it schema-enforced and the AD-13 differential corpus never manufactures two observations sharing a `sequence`: the generated mutant walk is keyword-driven (it perturbs one occurrence at a time) and never clones or duplicates an `observations` array item, since that field carries no `maxItems` for the generator's clone-to-exceed step to fire against. The gap is therefore real but inert against the corpus this repository generates, and is stated in `Observation.sequence`'s own description for a non-Zod consumer to reimplement. This safety argument holds only while `observations` carries no `maxItems`: adding one later starts the clone-to-exceed step firing against this field, and this entry must be re-verified then.",
         },
     },
+    {
+        id: 'evidence-mode-caller-attested',
+        location: { kind: 'root', artifact: 'evidence-artifact' },
+        branch: null,
+        field: 'callerAttestedInputs',
+        statement: '`mode` appears in `callerAttestedInputs`. The other five scoring-version inputs may each legitimately be attested or computed, so the list admits any subset of them; `mode` cannot be, since `ScoringVersionInputs.mode` is read from the sealed run record and never re-derived, which makes omitting it a misdeclaration under AD-32 rather than a stricter integration.',
+        disposition: {
+            kind: 'not-expressible',
+            reason: 'A one-member `contains` would express it, and injecting one would fail the same way the observation-sequence entry describes in reverse: the mutant generator manufactures the witness trivially by dropping one array element, so a Zod refinement and an uninjected export would disagree on a corpus member this repository generates. The rule is enforced where the artifact is produced instead: `core/emit` names `mode` in `CALLER_ATTESTED_INPUTS` unconditionally, and the field description states the rule for a caller who authors the artifact by hand. This argument holds only while `emit` is the sole producer in this package.',
+        },
+    },
     {
         id: 'defect-signature-required',
         location: { kind: 'root', artifact: 'probe' },

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

@@ -53,10 +53,17 @@ export declare const ProbeBindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString,
     }>;
 }, z.core.$strict>]>>>;
 /**
- * The four transport channels, spelled exactly as `InputBinding` and
- * `ObservedCallInputs` spell them. The three shapes agree on channel names, on
- * the four-key strict form, and on flatness, so the selector filters recorded
- * call inputs with no shape to bridge.
+ * 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.
+ *
+ * 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.
  */
 export declare const ProbeInputBinding: z.ZodObject<{
     path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -91,6 +98,38 @@ export declare const ProbeInputBinding: z.ZodObject<{
             "type-violating": "type-violating";
         }>;
     }, z.core.$strict>]>>>;
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
 }, z.core.$strict>;
 /**
  * AD-39's selector grammar, duplicated on the corpus side, minus the two
@@ -137,6 +176,38 @@ export declare const ProbeStepSelector: z.ZodObject<{
                 "type-violating": "type-violating";
             }>;
         }, z.core.$strict>]>>>;
+        argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 /**
@@ -186,27 +257,138 @@ export declare const DiscriminatingCondition: z.ZodObject<{
                     "type-violating": "type-violating";
                 }>;
             }, z.core.$strict>]>>>;
+            argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
         }, z.core.$strict>;
     }, z.core.$strict>;
     predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
 }, z.core.$strict>;
 /**
- * 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.
+ * 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.
  *
- * 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`.
+ * 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.
  */
-export declare const DefectSignature: z.ZodObject<{
+export declare const ApiDefectSignature: z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
     interfaceKind: z.ZodEnum<{
         api: "api";
-        cli: "cli";
         mcp: "mcp";
         web: "web";
     }>;
@@ -220,7 +402,17 @@ export declare const DefectSignature: z.ZodObject<{
         PUT: "PUT";
     }>;
     pathTemplate: z.ZodString;
+}, z.core.$strict>;
+/**
+ * A signature against an interface that runs behind a command. It declares the
+ * transport identity a command operation declares, for the reason AD-40 gives
+ * for method and path template: the identity has to be contract-independent so
+ * a signature authored against a corpus binds a second contract's operation.
+ * An operation identifier is contract-local and would bind nothing.
+ */
+export declare const CommandDefectSignature: z.ZodObject<{
     observableChannel: z.ZodEnum<{
+        artifact: "artifact";
         "call-inputs": "call-inputs";
         "exit-code": "exit-code";
         "response-body": "response-body";
@@ -264,10 +456,240 @@ export declare const DefectSignature: z.ZodObject<{
                         "type-violating": "type-violating";
                     }>;
                 }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
             }, z.core.$strict>;
         }, z.core.$strict>;
         predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
     }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"cli">;
+    invocation: z.ZodObject<{
+        executable: z.ZodString;
+        subcommandPath: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
+/**
+ * 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
+ * `InputBinding`'s two are told apart by the channels they name.
+ */
+export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodEnum<{
+        api: "api";
+        mcp: "mcp";
+        web: "web";
+    }>;
+    method: z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    pathTemplate: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"cli">;
+    invocation: z.ZodObject<{
+        executable: z.ZodString;
+        subcommandPath: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type ApiDefectSignature = z.infer<typeof ApiDefectSignature>;
+export type CommandDefectSignature = z.infer<typeof CommandDefectSignature>;
 export type DefectSignature = z.infer<typeof DefectSignature>;
 export type ProbeInputBinding = z.infer<typeof ProbeInputBinding>;

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

@@ -1,7 +1,7 @@
 /** AD-40's machine-readable defect signature and its probe-side selector. */
 import { z } from 'zod';
 import { Expression } from './expression.js';
-import { HttpMethod, InterfaceKind, PathTemplate } from './interface.js';
+import { CommandInvocation, HttpMethod, PathTemplate } from './interface.js';
 import { LiteralBindingValue, MatcherBindingValue } from './plan.js';
 import { EvidenceChannel } from './pointer.js';
 import { KeyName } from './primitives.js';
@@ -61,19 +61,30 @@ export const ProbeBindingChannel = z
     .nullable()
     .meta({
     id: 'ProbeInputBindingChannel',
-    description: "A parameter-name-to-binding-value map for one transport 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.",
+    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.",
 });
 /**
- * The four transport channels, spelled exactly as `InputBinding` and
- * `ObservedCallInputs` spell them. The three shapes agree on channel names, on
- * the four-key strict form, and on flatness, so the selector filters recorded
- * call inputs with no shape to bridge.
+ * 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.
+ *
+ * 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.
  */
 export const ProbeInputBinding = z.strictObject({
     path: ProbeBindingChannel,
     query: ProbeBindingChannel,
     header: ProbeBindingChannel,
     body: ProbeBindingChannel,
+    argument: ProbeBindingChannel,
+    option: ProbeBindingChannel,
+    environment: ProbeBindingChannel,
+    stdin: ProbeBindingChannel,
 });
 /**
  * AD-39's selector grammar, duplicated on the corpus side, minus the two
@@ -118,10 +129,47 @@ export const DiscriminatingCondition = z.strictObject({
  * collision inside one contract has already failed compilation under
  * `duplicate-operation-signature`.
  */
-export const DefectSignature = z.strictObject({
-    interfaceKind: InterfaceKind.describe('The interface the seeded defect lives behind. All four kinds parse so `unsupported-interface-kind` stays fireable contract-side, and the qualification gate rejects every kind but `api`: `Operation` carries no interface kind and requires a method and a path template with no per-kind variation, so a `cli` or `mcp` signature would declare a meaningless `POST /path`.'),
+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.
+ *
+ * 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.
+ */
+export const ApiDefectSignature = z.strictObject({
+    interfaceKind: z.enum(['api', 'web', 'mcp']),
     method: HttpMethod,
     pathTemplate: PathTemplate,
-    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.'),
-    condition: DiscriminatingCondition,
+    ...signatureCommon,
 });
+/**
+ * A signature against an interface that runs behind a command. It declares the
+ * transport identity a command operation declares, for the reason AD-40 gives
+ * for method and path template: the identity has to be contract-independent so
+ * a signature authored against a corpus binds a second contract's operation.
+ * An operation identifier is contract-local and would bind nothing.
+ */
+export const CommandDefectSignature = z.strictObject({
+    interfaceKind: z.literal('cli'),
+    invocation: CommandInvocation,
+    ...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
+ * `InputBinding`'s two are told apart by the channels they name.
+ */
+export const DefectSignature = z.union([
+    ApiDefectSignature,
+    CommandDefectSignature,
+]);