@davesheffer/hunch 1.31.0 → 1.32.0

package/dist/constitution/schema.d.ts

@@ -0,0 +1,1763 @@
+import { z } from "zod";
+export declare const POLICY_IR_VERSION = 1;
+export declare const POLICY_EVALUATOR: {
+    readonly name: "hunch-graph-policy";
+    readonly version: "1.3.0";
+};
+export declare const MUTATION_ENGINE: {
+    readonly name: "hunch-static-graph-controls";
+    readonly version: "5";
+};
+export declare const EXECUTABLE_BEHAVIOR_IR_VERSION = 2;
+/** Source-gated correction policies deliberately use an IR unknown to pre-Matrix
+ * clients. Those clients then reject the artifact instead of loading it without
+ * understanding (and potentially bypassing) its activation gate. */
+export declare const CORRECTION_POLICY_IR_VERSION = 3;
+export declare const BEHAVIOR_POLICY_EVALUATOR: {
+    readonly name: "hunch-executable-behavior";
+    readonly version: "1.0.0";
+};
+export declare const BEHAVIOR_MUTATION_ENGINE: {
+    readonly name: "hunch-behavior-controls";
+    readonly version: "1";
+};
+export declare const DataClassSchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+    secret: "secret";
+}>;
+export type DataClass = z.infer<typeof DataClassSchema>;
+export declare const StructuralSymbolRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        type: "type";
+        enum: "enum";
+        file: "file";
+        method: "method";
+        class: "class";
+        interface: "interface";
+        trait: "trait";
+        variable: "variable";
+    }>;
+}, z.core.$strip>;
+export type StructuralSymbolRef = z.infer<typeof StructuralSymbolRefSchema>;
+export declare const StructuralCallRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    caller: z.ZodString;
+    callee: z.ZodString;
+    member: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type StructuralCallRef = z.infer<typeof StructuralCallRefSchema>;
+export declare const StructuralImportRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    specifier: z.ZodString;
+}, z.core.$strip>;
+export type StructuralImportRef = z.infer<typeof StructuralImportRefSchema>;
+export declare const StructuralDeltaSchema: z.ZodObject<{
+    id: z.ZodString;
+    before_commit: z.ZodString;
+    after_commit: z.ZodString;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    symbols: z.ZodObject<{
+        added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                type: "type";
+                enum: "enum";
+                file: "file";
+                method: "method";
+                class: "class";
+                interface: "interface";
+                trait: "trait";
+                variable: "variable";
+            }>;
+        }, z.core.$strip>>>;
+        removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                type: "type";
+                enum: "enum";
+                file: "file";
+                method: "method";
+                class: "class";
+                interface: "interface";
+                trait: "trait";
+                variable: "variable";
+            }>;
+        }, z.core.$strip>>>;
+        moved: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                type: "type";
+                enum: "enum";
+                file: "file";
+                method: "method";
+                class: "class";
+                interface: "interface";
+                trait: "trait";
+                variable: "variable";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    calls: z.ZodObject<{
+        added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            caller: z.ZodString;
+            callee: z.ZodString;
+            member: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            caller: z.ZodString;
+            callee: z.ZodString;
+            member: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    imports: z.ZodObject<{
+        added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            specifier: z.ZodString;
+        }, z.core.$strip>>>;
+        removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            specifier: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    content_hash: z.ZodString;
+}, z.core.$strict>;
+export type StructuralDelta = z.infer<typeof StructuralDeltaSchema>;
+export declare const CandidateAlternativeSchema: z.ZodObject<{
+    id: z.ZodString;
+    basis: z.ZodString;
+    reason: z.ZodString;
+    assertion_hash: z.ZodString;
+}, z.core.$strict>;
+export type CandidateAlternative = z.infer<typeof CandidateAlternativeSchema>;
+export declare const PolicyScopeSchema: z.ZodDefault<z.ZodObject<{
+    repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+export type PolicyScope = z.infer<typeof PolicyScopeSchema>;
+export declare const CandidateContextSchema: z.ZodDefault<z.ZodObject<{
+    alternatives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        basis: z.ZodString;
+        reason: z.ZodString;
+        assertion_hash: z.ZodString;
+    }, z.core.$strict>>>;
+    uncertainty: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    incumbent: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    scope_suggestion: z.ZodDefault<z.ZodNullable<z.ZodDefault<z.ZodObject<{
+        repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    counterexamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+export type CandidateContext = z.infer<typeof CandidateContextSchema>;
+export declare const EvidenceEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        commit: "commit";
+        review: "review";
+        decision: "decision";
+        revert: "revert";
+        correction: "correction";
+        incident: "incident";
+        bug_fix: "bug_fix";
+        test_failure: "test_failure";
+        instruction: "instruction";
+    }>;
+    occurred_at: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+    repository: z.ZodString;
+    commit: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    text_ref: z.ZodOptional<z.ZodString>;
+    diff_ref: z.ZodOptional<z.ZodString>;
+    related_records: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    content_hash: z.ZodString;
+    structural_delta: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        before_commit: z.ZodString;
+        after_commit: z.ZodString;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        symbols: z.ZodObject<{
+            added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    function: "function";
+                    type: "type";
+                    enum: "enum";
+                    file: "file";
+                    method: "method";
+                    class: "class";
+                    interface: "interface";
+                    trait: "trait";
+                    variable: "variable";
+                }>;
+            }, z.core.$strip>>>;
+            removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    function: "function";
+                    type: "type";
+                    enum: "enum";
+                    file: "file";
+                    method: "method";
+                    class: "class";
+                    interface: "interface";
+                    trait: "trait";
+                    variable: "variable";
+                }>;
+            }, z.core.$strip>>>;
+            moved: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    function: "function";
+                    type: "type";
+                    enum: "enum";
+                    file: "file";
+                    method: "method";
+                    class: "class";
+                    interface: "interface";
+                    trait: "trait";
+                    variable: "variable";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        calls: z.ZodObject<{
+            added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                caller: z.ZodString;
+                callee: z.ZodString;
+                member: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                caller: z.ZodString;
+                callee: z.ZodString;
+                member: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        imports: z.ZodObject<{
+            added: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                specifier: z.ZodString;
+            }, z.core.$strip>>>;
+            removed: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                specifier: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        content_hash: z.ZodString;
+    }, z.core.$strict>>;
+    compiler: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            conflicted: "conflicted";
+            eligible: "eligible";
+            compiled: "compiled";
+            covered: "covered";
+            uncompilable: "uncompilable";
+        }>;
+        policy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodDefault<z.ZodString>;
+        alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            basis: z.ZodString;
+            reason: z.ZodString;
+            assertion_hash: z.ZodString;
+        }, z.core.$strict>>>;
+        uncertainty: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        incumbent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        scope_suggestion: z.ZodOptional<z.ZodNullable<z.ZodDefault<z.ZodObject<{
+            repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>>;
+        counterexamples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$loose>;
+export type EvidenceEvent = z.infer<typeof EvidenceEventSchema>;
+export declare const EvidenceImportItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        commit: "commit";
+        review: "review";
+        decision: "decision";
+        instruction: "instruction";
+    }>;
+    occurred_at: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    text: z.ZodOptional<z.ZodString>;
+    text_ref: z.ZodOptional<z.ZodString>;
+    related_records: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    data_class: z.ZodDefault<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>>;
+    maintainer_confirmed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type EvidenceImportItem = z.infer<typeof EvidenceImportItemSchema>;
+export declare const EvidenceImportSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    source: z.ZodEnum<{
+        pr_export: "pr_export";
+        review_export: "review_export";
+        conversation_export: "conversation_export";
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            commit: "commit";
+            review: "review";
+            decision: "decision";
+            instruction: "instruction";
+        }>;
+        occurred_at: z.ZodString;
+        actor: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        text: z.ZodOptional<z.ZodString>;
+        text_ref: z.ZodOptional<z.ZodString>;
+        related_records: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        data_class: z.ZodDefault<z.ZodEnum<{
+            public: "public";
+            private: "private";
+            secret: "secret";
+        }>>;
+        maintainer_confirmed: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvidenceImport = z.infer<typeof EvidenceImportSchema>;
+export declare const PolicyStateSchema: z.ZodEnum<{
+    observed: "observed";
+    stale: "stale";
+    retired: "retired";
+    proposed: "proposed";
+    rejected: "rejected";
+    superseded: "superseded";
+    compiled: "compiled";
+    uncompilable: "uncompilable";
+    drafted: "drafted";
+    validating: "validating";
+    active_advisory: "active_advisory";
+    active_blocking: "active_blocking";
+    repaired: "repaired";
+}>;
+export type PolicyState = z.infer<typeof PolicyStateSchema>;
+export declare const PolicySelectorSchema: z.ZodObject<{
+    selector: z.ZodString;
+}, z.core.$strip>;
+export type PolicySelector = z.infer<typeof PolicySelectorSchema>;
+export declare const PolicyRelationSchema: z.ZodObject<{
+    edges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        depends_on: "depends_on";
+        calls: "calls";
+        imports: "imports";
+        contains: "contains";
+    }>>>;
+    transitive: z.ZodDefault<z.ZodBoolean>;
+    max_depth: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type PolicyRelation = z.infer<typeof PolicyRelationSchema>;
+export declare const PolicyAssertionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"exists">;
+    subject: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        reaches: "reaches";
+        "not-reaches": "not-reaches";
+    }>;
+    subject: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+    relation: z.ZodObject<{
+        edges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            depends_on: "depends_on";
+            calls: "calls";
+            imports: "imports";
+            contains: "contains";
+        }>>>;
+        transitive: z.ZodDefault<z.ZodBoolean>;
+        max_depth: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    object: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"must-pass-through">;
+    subject: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+    relation: z.ZodObject<{
+        edges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            depends_on: "depends_on";
+            calls: "calls";
+            imports: "imports";
+            contains: "contains";
+        }>>>;
+        transitive: z.ZodDefault<z.ZodBoolean>;
+        max_depth: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    via: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+    object: z.ZodObject<{
+        selector: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"executable-behavior">;
+    test: z.ZodObject<{
+        file: z.ZodString;
+        name: z.ZodString;
+        source_commit: z.ZodString;
+        source_hash: z.ZodString;
+    }, z.core.$strict>;
+    runner: z.ZodEnum<{
+        "node-test": "node-test";
+        "node-test-tsx": "node-test-tsx";
+    }>;
+    attestation: z.ZodObject<{
+        id: z.ZodString;
+        content_hash: z.ZodString;
+        candidate_id: z.ZodString;
+        candidate_hash: z.ZodString;
+        replay_id: z.ZodString;
+        replay_hash: z.ZodString;
+    }, z.core.$strict>;
+    dependency_snapshot_ids: z.ZodArray<z.ZodString>;
+    timeout_ms: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export type PolicyAssertion = z.infer<typeof PolicyAssertionSchema>;
+export declare const PolicyAuditEventSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        retired: "retired";
+        rejected: "rejected";
+        compiled: "compiled";
+        repaired: "repaired";
+        enriched: "enriched";
+        linked_exception: "linked_exception";
+        proved: "proved";
+        approved_advisory: "approved_advisory";
+        approved_blocking: "approved_blocking";
+        demoted: "demoted";
+        withdrawn: "withdrawn";
+    }>;
+    actor_kind: z.ZodEnum<{
+        system: "system";
+        human: "human";
+    }>;
+    actor: z.ZodString;
+    at: z.ZodString;
+    reason: z.ZodDefault<z.ZodString>;
+    proof: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type PolicyAuditEvent = z.infer<typeof PolicyAuditEventSchema>;
+export declare const PolicyAuthoritySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"human">;
+    actor: z.ZodString;
+    event: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strip>;
+export type PolicyAuthority = z.infer<typeof PolicyAuthoritySchema>;
+export declare const PolicyActivationGateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"source_currentness">;
+    status: z.ZodLiteral<"blocked">;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type PolicyActivationGate = z.infer<typeof PolicyActivationGateSchema>;
+export declare const PolicySpecSchema: z.ZodObject<{
+    id: z.ZodString;
+    topic: z.ZodString;
+    origin: z.ZodDefault<z.ZodEnum<{
+        generic: "generic";
+        correction_md1a: "correction_md1a";
+    }>>;
+    ir_version: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+    revision: z.ZodNumber;
+    state: z.ZodEnum<{
+        observed: "observed";
+        stale: "stale";
+        retired: "retired";
+        proposed: "proposed";
+        rejected: "rejected";
+        superseded: "superseded";
+        compiled: "compiled";
+        uncompilable: "uncompilable";
+        drafted: "drafted";
+        validating: "validating";
+        active_advisory: "active_advisory";
+        active_blocking: "active_blocking";
+        repaired: "repaired";
+    }>;
+    statement: z.ZodString;
+    rationale: z.ZodDefault<z.ZodString>;
+    scope: z.ZodDefault<z.ZodObject<{
+        repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    assertion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"exists">;
+        subject: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            reaches: "reaches";
+            "not-reaches": "not-reaches";
+        }>;
+        subject: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+        relation: z.ZodObject<{
+            edges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                depends_on: "depends_on";
+                calls: "calls";
+                imports: "imports";
+                contains: "contains";
+            }>>>;
+            transitive: z.ZodDefault<z.ZodBoolean>;
+            max_depth: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        object: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"must-pass-through">;
+        subject: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+        relation: z.ZodObject<{
+            edges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                depends_on: "depends_on";
+                calls: "calls";
+                imports: "imports";
+                contains: "contains";
+            }>>>;
+            transitive: z.ZodDefault<z.ZodBoolean>;
+            max_depth: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        via: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+        object: z.ZodObject<{
+            selector: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"executable-behavior">;
+        test: z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            source_commit: z.ZodString;
+            source_hash: z.ZodString;
+        }, z.core.$strict>;
+        runner: z.ZodEnum<{
+            "node-test": "node-test";
+            "node-test-tsx": "node-test-tsx";
+        }>;
+        attestation: z.ZodObject<{
+            id: z.ZodString;
+            content_hash: z.ZodString;
+            candidate_id: z.ZodString;
+            candidate_hash: z.ZodString;
+            replay_id: z.ZodString;
+            replay_hash: z.ZodString;
+        }, z.core.$strict>;
+        dependency_snapshot_ids: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+    severity: z.ZodDefault<z.ZodEnum<{
+        advisory: "advisory";
+        warning: "warning";
+        blocking: "blocking";
+    }>>;
+    surfaces: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        ci: "ci";
+        pre_edit: "pre_edit";
+        pre_commit: "pre_commit";
+        mcp: "mcp";
+        cli: "cli";
+    }>>>;
+    authority: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"human">;
+        actor: z.ZodString;
+        event: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>>;
+    activation_gate: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"source_currentness">;
+        status: z.ZodLiteral<"blocked">;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    proof: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    reversal_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    superseded_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    exception_of: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    valid_from: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data_class: z.ZodDefault<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    candidate: z.ZodDefault<z.ZodObject<{
+        alternatives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            basis: z.ZodString;
+            reason: z.ZodString;
+            assertion_hash: z.ZodString;
+        }, z.core.$strict>>>;
+        uncertainty: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        incumbent: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        scope_suggestion: z.ZodDefault<z.ZodNullable<z.ZodDefault<z.ZodObject<{
+            repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>>;
+        counterexamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    legacy_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    audit: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<{
+            retired: "retired";
+            rejected: "rejected";
+            compiled: "compiled";
+            repaired: "repaired";
+            enriched: "enriched";
+            linked_exception: "linked_exception";
+            proved: "proved";
+            approved_advisory: "approved_advisory";
+            approved_blocking: "approved_blocking";
+            demoted: "demoted";
+            withdrawn: "withdrawn";
+        }>;
+        actor_kind: z.ZodEnum<{
+            system: "system";
+            human: "human";
+        }>;
+        actor: z.ZodString;
+        at: z.ZodString;
+        reason: z.ZodDefault<z.ZodString>;
+        proof: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$loose>;
+export type PolicySpec = z.infer<typeof PolicySpecSchema>;
+export declare const PolicyCompositionMemberSchema: z.ZodObject<{
+    policy_id: z.ZodString;
+    policy_hash: z.ZodString;
+    exception_of: z.ZodString;
+    scope: z.ZodDefault<z.ZodObject<{
+        repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const PolicyCompositionBindingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"parent_with_exceptions">;
+    root_policy_id: z.ZodString;
+    root_policy_hash: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        policy_id: z.ZodString;
+        policy_hash: z.ZodString;
+        exception_of: z.ZodString;
+        scope: z.ZodDefault<z.ZodObject<{
+            repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+    composite_hash: z.ZodString;
+}, z.core.$strict>;
+export type PolicyCompositionBinding = z.infer<typeof PolicyCompositionBindingSchema>;
+export declare const PolicyEvaluationResultSchema: z.ZodEnum<{
+    unknown: "unknown";
+    error: "error";
+    satisfied: "satisfied";
+    violated: "violated";
+    not_applicable: "not_applicable";
+}>;
+export type PolicyEvaluationResult = z.infer<typeof PolicyEvaluationResultSchema>;
+export declare const BehaviorExecutionSchema: z.ZodObject<{
+    commit: z.ZodString;
+    workspace: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            staged: "staged";
+            working: "working";
+        }>;
+        base_commit: z.ZodString;
+        snapshot_hash: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    test: z.ZodObject<{
+        file: z.ZodString;
+        name: z.ZodString;
+        source_hash: z.ZodString;
+    }, z.core.$strict>;
+    runner: z.ZodEnum<{
+        "node-test": "node-test";
+        "node-test-tsx": "node-test-tsx";
+    }>;
+    dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    selected_event: z.ZodNullable<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    error_code: z.ZodOptional<z.ZodString>;
+    execution_hash: z.ZodString;
+}, z.core.$strict>;
+export type BehaviorExecution = z.infer<typeof BehaviorExecutionSchema>;
+export declare const ProofFixtureRefSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        commit: "commit";
+        event: "event";
+        fixture: "fixture";
+        mutation: "mutation";
+    }>;
+    ref: z.ZodString;
+    label: z.ZodString;
+    expected: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>;
+    attestation: z.ZodOptional<z.ZodObject<{
+        actor: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type ProofFixtureRef = z.infer<typeof ProofFixtureRefSchema>;
+export declare const ProofCorpusInputSchema: z.ZodObject<{
+    known_bad: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    known_good: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        label: z.ZodString;
+        attestation: z.ZodOptional<z.ZodObject<{
+            actor: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ProofCorpusInput = z.infer<typeof ProofCorpusInputSchema>;
+export declare const ProofCorpusSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    policy_id: z.ZodString;
+    policy_hash: z.ZodString;
+    repository: z.ZodString;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    known_bad: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"commit">;
+        ref: z.ZodString;
+        label: z.ZodString;
+        expected: z.ZodLiteral<"violated">;
+    }, z.core.$strict>>>;
+    known_good: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"commit">;
+        ref: z.ZodString;
+        label: z.ZodString;
+        expected: z.ZodLiteral<"satisfied">;
+        attestation: z.ZodOptional<z.ZodObject<{
+            actor: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type ProofCorpus = z.infer<typeof ProofCorpusSchema>;
+export declare const ProofPlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    policy_id: z.ZodString;
+    policy_candidate_hash: z.ZodString;
+    repository: z.ZodString;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    source_commit: z.ZodString;
+    valid_from_commit: z.ZodString;
+    evaluator: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    mutation_engine: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"parent_with_exceptions">;
+        root_policy_id: z.ZodString;
+        root_policy_hash: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            policy_id: z.ZodString;
+            policy_hash: z.ZodString;
+            exception_of: z.ZodString;
+            scope: z.ZodDefault<z.ZodObject<{
+                repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
+        composite_hash: z.ZodString;
+    }, z.core.$strict>>;
+    corpus_manifest: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        content_hash: z.ZodString;
+    }, z.core.$strict>>;
+    corpus: z.ZodObject<{
+        current_baseline: z.ZodObject<{
+            kind: z.ZodEnum<{
+                commit: "commit";
+                event: "event";
+                fixture: "fixture";
+                mutation: "mutation";
+            }>;
+            ref: z.ZodString;
+            label: z.ZodString;
+            expected: z.ZodEnum<{
+                unknown: "unknown";
+                error: "error";
+                satisfied: "satisfied";
+                violated: "violated";
+                not_applicable: "not_applicable";
+            }>;
+            attestation: z.ZodOptional<z.ZodObject<{
+                actor: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strip>;
+        accepted_history: z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            first_parent: z.ZodDefault<z.ZodBoolean>;
+            max_commits: z.ZodNumber;
+            exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        known_bad: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                commit: "commit";
+                event: "event";
+                fixture: "fixture";
+                mutation: "mutation";
+            }>;
+            ref: z.ZodString;
+            label: z.ZodString;
+            expected: z.ZodEnum<{
+                unknown: "unknown";
+                error: "error";
+                satisfied: "satisfied";
+                violated: "violated";
+                not_applicable: "not_applicable";
+            }>;
+            attestation: z.ZodOptional<z.ZodObject<{
+                actor: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strip>>>;
+        known_good: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                commit: "commit";
+                event: "event";
+                fixture: "fixture";
+                mutation: "mutation";
+            }>;
+            ref: z.ZodString;
+            label: z.ZodString;
+            expected: z.ZodEnum<{
+                unknown: "unknown";
+                error: "error";
+                satisfied: "satisfied";
+                violated: "violated";
+                not_applicable: "not_applicable";
+            }>;
+            attestation: z.ZodOptional<z.ZodObject<{
+                actor: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    mutations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        operator: z.ZodString;
+        base: z.ZodString;
+        expected: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    budgets: z.ZodObject<{
+        max_commits: z.ZodNumber;
+        max_mutations: z.ZodNumber;
+        max_minutes: z.ZodNumber;
+    }, z.core.$strip>;
+    expected: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        leg: z.ZodEnum<{
+            known_bad: "known_bad";
+            known_good: "known_good";
+            current_baseline: "current_baseline";
+            accepted_history: "accepted_history";
+            mutations: "mutations";
+        }>;
+        result: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>>;
+        classification_required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    evidence_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type ProofPlan = z.infer<typeof ProofPlanSchema>;
+export declare const PolicyEvaluationSchema: z.ZodObject<{
+    policy_id: z.ZodString;
+    policy_revision: z.ZodNumber;
+    result: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>;
+    evaluator: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    repository: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        head: z.ZodString;
+        graph_hash: z.ZodString;
+    }, z.core.$strip>;
+    matches: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        symbol: z.ZodOptional<z.ZodString>;
+        relation_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    explanation: z.ZodString;
+    evidence_refs: z.ZodArray<z.ZodString>;
+    behavior: z.ZodOptional<z.ZodObject<{
+        commit: z.ZodString;
+        workspace: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                staged: "staged";
+                working: "working";
+            }>;
+            base_commit: z.ZodString;
+            snapshot_hash: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        test: z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            source_hash: z.ZodString;
+        }, z.core.$strict>;
+        runner: z.ZodEnum<{
+            "node-test": "node-test";
+            "node-test-tsx": "node-test-tsx";
+        }>;
+        dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+        selected_event: z.ZodNullable<z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        error_code: z.ZodOptional<z.ZodString>;
+        execution_hash: z.ZodString;
+    }, z.core.$strict>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"parent_with_exceptions">;
+        root_policy_id: z.ZodString;
+        root_policy_hash: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            policy_id: z.ZodString;
+            policy_hash: z.ZodString;
+            exception_of: z.ZodString;
+            scope: z.ZodDefault<z.ZodObject<{
+                repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
+        composite_hash: z.ZodString;
+        selected_policy_id: z.ZodString;
+        applicable_policy_ids: z.ZodArray<z.ZodString>;
+        member_evaluation_hashes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+    deterministic_hash: z.ZodString;
+}, z.core.$strip>;
+export type PolicyEvaluation = z.infer<typeof PolicyEvaluationSchema>;
+export declare const ProofClassSchema: z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+    P4: "P4";
+    P5: "P5";
+}>;
+export type ProofClass = z.infer<typeof ProofClassSchema>;
+export declare const EvaluationSummarySchema: z.ZodObject<{
+    total: z.ZodNumber;
+    satisfied: z.ZodNumber;
+    violated: z.ZodNumber;
+    not_applicable: z.ZodNumber;
+    unknown: z.ZodNumber;
+    error: z.ZodNumber;
+    receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type EvaluationSummary = z.infer<typeof EvaluationSummarySchema>;
+export declare const ReplayReceiptSchema: z.ZodObject<{
+    leg: z.ZodEnum<{
+        known_bad: "known_bad";
+        known_good: "known_good";
+        current_baseline: "current_baseline";
+        accepted_history: "accepted_history";
+    }>;
+    commit: z.ZodString;
+    expected: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>>;
+    policy_hash: z.ZodString;
+    evaluator: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    result: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>;
+    graph_hash: z.ZodOptional<z.ZodString>;
+    evaluation_hash: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    behavior: z.ZodOptional<z.ZodObject<{
+        commit: z.ZodString;
+        workspace: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                staged: "staged";
+                working: "working";
+            }>;
+            base_commit: z.ZodString;
+            snapshot_hash: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        test: z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            source_hash: z.ZodString;
+        }, z.core.$strict>;
+        runner: z.ZodEnum<{
+            "node-test": "node-test";
+            "node-test-tsx": "node-test-tsx";
+        }>;
+        dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+        selected_event: z.ZodNullable<z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        error_code: z.ZodOptional<z.ZodString>;
+        execution_hash: z.ZodString;
+    }, z.core.$strict>>;
+    deterministic_hash: z.ZodString;
+}, z.core.$strict>;
+export type ReplayReceipt = z.infer<typeof ReplayReceiptSchema>;
+export declare const HistoryDispositionClassificationSchema: z.ZodEnum<{
+    true_positive_actionable: "true_positive_actionable";
+    true_positive_accepted_exception: "true_positive_accepted_exception";
+    false_positive_selector: "false_positive_selector";
+    false_positive_semantics: "false_positive_semantics";
+    false_positive_stale: "false_positive_stale";
+    unknown_insufficient_parser: "unknown_insufficient_parser";
+}>;
+export type HistoryDispositionClassification = z.infer<typeof HistoryDispositionClassificationSchema>;
+export declare const HistoryDispositionSchema: z.ZodObject<{
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    policy_id: z.ZodString;
+    proof_id: z.ZodString;
+    policy_hash: z.ZodString;
+    plan_hash: z.ZodString;
+    commit: z.ZodString;
+    receipt_hash: z.ZodString;
+    classification: z.ZodEnum<{
+        true_positive_actionable: "true_positive_actionable";
+        true_positive_accepted_exception: "true_positive_accepted_exception";
+        false_positive_selector: "false_positive_selector";
+        false_positive_semantics: "false_positive_semantics";
+        false_positive_stale: "false_positive_stale";
+        unknown_insufficient_parser: "unknown_insufficient_parser";
+    }>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type HistoryDisposition = z.infer<typeof HistoryDispositionSchema>;
+export declare const ShadowEvaluationRecordSchema: z.ZodObject<{
+    record_type: z.ZodLiteral<"evaluation">;
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    policy_id: z.ZodString;
+    proof_id: z.ZodString;
+    policy_hash: z.ZodString;
+    plan_hash: z.ZodString;
+    evaluation: z.ZodObject<{
+        policy_id: z.ZodString;
+        policy_revision: z.ZodNumber;
+        result: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        evaluator: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        repository: z.ZodObject<{
+            base: z.ZodOptional<z.ZodString>;
+            head: z.ZodString;
+            graph_hash: z.ZodString;
+        }, z.core.$strip>;
+        matches: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            symbol: z.ZodOptional<z.ZodString>;
+            relation_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        explanation: z.ZodString;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        behavior: z.ZodOptional<z.ZodObject<{
+            commit: z.ZodString;
+            workspace: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    staged: "staged";
+                    working: "working";
+                }>;
+                base_commit: z.ZodString;
+                snapshot_hash: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            test: z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                source_hash: z.ZodString;
+            }, z.core.$strict>;
+            runner: z.ZodEnum<{
+                "node-test": "node-test";
+                "node-test-tsx": "node-test-tsx";
+            }>;
+            dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+            exit_code: z.ZodNullable<z.ZodNumber>;
+            selected_event: z.ZodNullable<z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>>;
+            error_code: z.ZodOptional<z.ZodString>;
+            execution_hash: z.ZodString;
+        }, z.core.$strict>>;
+        composition: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"parent_with_exceptions">;
+            root_policy_id: z.ZodString;
+            root_policy_hash: z.ZodString;
+            members: z.ZodArray<z.ZodObject<{
+                policy_id: z.ZodString;
+                policy_hash: z.ZodString;
+                exception_of: z.ZodString;
+                scope: z.ZodDefault<z.ZodObject<{
+                    repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strict>>;
+            composite_hash: z.ZodString;
+            selected_policy_id: z.ZodString;
+            applicable_policy_ids: z.ZodArray<z.ZodString>;
+            member_evaluation_hashes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>;
+        deterministic_hash: z.ZodString;
+    }, z.core.$strip>;
+    also_detected_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    latency_ms: z.ZodNumber;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    observed_at: z.ZodString;
+}, z.core.$strict>;
+export type ShadowEvaluationRecord = z.infer<typeof ShadowEvaluationRecordSchema>;
+export declare const ShadowDispositionSchema: z.ZodObject<{
+    record_type: z.ZodLiteral<"disposition">;
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    shadow_id: z.ZodString;
+    policy_id: z.ZodString;
+    proof_id: z.ZodString;
+    policy_hash: z.ZodString;
+    evaluation_hash: z.ZodString;
+    classification: z.ZodEnum<{
+        true_positive_actionable: "true_positive_actionable";
+        true_positive_accepted_exception: "true_positive_accepted_exception";
+        false_positive_selector: "false_positive_selector";
+        false_positive_semantics: "false_positive_semantics";
+        false_positive_stale: "false_positive_stale";
+        unknown_insufficient_parser: "unknown_insufficient_parser";
+    }>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type ShadowDisposition = z.infer<typeof ShadowDispositionSchema>;
+export declare const ShadowRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    record_type: z.ZodLiteral<"evaluation">;
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    policy_id: z.ZodString;
+    proof_id: z.ZodString;
+    policy_hash: z.ZodString;
+    plan_hash: z.ZodString;
+    evaluation: z.ZodObject<{
+        policy_id: z.ZodString;
+        policy_revision: z.ZodNumber;
+        result: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        evaluator: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        repository: z.ZodObject<{
+            base: z.ZodOptional<z.ZodString>;
+            head: z.ZodString;
+            graph_hash: z.ZodString;
+        }, z.core.$strip>;
+        matches: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            symbol: z.ZodOptional<z.ZodString>;
+            relation_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        explanation: z.ZodString;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        behavior: z.ZodOptional<z.ZodObject<{
+            commit: z.ZodString;
+            workspace: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    staged: "staged";
+                    working: "working";
+                }>;
+                base_commit: z.ZodString;
+                snapshot_hash: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            test: z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                source_hash: z.ZodString;
+            }, z.core.$strict>;
+            runner: z.ZodEnum<{
+                "node-test": "node-test";
+                "node-test-tsx": "node-test-tsx";
+            }>;
+            dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+            exit_code: z.ZodNullable<z.ZodNumber>;
+            selected_event: z.ZodNullable<z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>>;
+            error_code: z.ZodOptional<z.ZodString>;
+            execution_hash: z.ZodString;
+        }, z.core.$strict>>;
+        composition: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"parent_with_exceptions">;
+            root_policy_id: z.ZodString;
+            root_policy_hash: z.ZodString;
+            members: z.ZodArray<z.ZodObject<{
+                policy_id: z.ZodString;
+                policy_hash: z.ZodString;
+                exception_of: z.ZodString;
+                scope: z.ZodDefault<z.ZodObject<{
+                    repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strict>>;
+            composite_hash: z.ZodString;
+            selected_policy_id: z.ZodString;
+            applicable_policy_ids: z.ZodArray<z.ZodString>;
+            member_evaluation_hashes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>;
+        deterministic_hash: z.ZodString;
+    }, z.core.$strip>;
+    also_detected_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    latency_ms: z.ZodNumber;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    observed_at: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    record_type: z.ZodLiteral<"disposition">;
+    id: z.ZodString;
+    content_hash: z.ZodString;
+    shadow_id: z.ZodString;
+    policy_id: z.ZodString;
+    proof_id: z.ZodString;
+    policy_hash: z.ZodString;
+    evaluation_hash: z.ZodString;
+    classification: z.ZodEnum<{
+        true_positive_actionable: "true_positive_actionable";
+        true_positive_accepted_exception: "true_positive_accepted_exception";
+        false_positive_selector: "false_positive_selector";
+        false_positive_semantics: "false_positive_semantics";
+        false_positive_stale: "false_positive_stale";
+        unknown_insufficient_parser: "unknown_insufficient_parser";
+    }>;
+    actor: z.ZodString;
+    reason: z.ZodString;
+    supersedes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strict>], "record_type">;
+export type ShadowRecord = z.infer<typeof ShadowRecordSchema>;
+export declare const MutationReceiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        primary: "primary";
+        control: "control";
+    }>;
+    operator: z.ZodString;
+    required: z.ZodBoolean;
+    engine: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    policy_hash: z.ZodString;
+    base_commit: z.ZodString;
+    base_graph_hash: z.ZodString;
+    mutated_graph_hash: z.ZodOptional<z.ZodString>;
+    expected: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>;
+    result: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        satisfied: "satisfied";
+        violated: "violated";
+        not_applicable: "not_applicable";
+    }>;
+    passed: z.ZodBoolean;
+    parseability: z.ZodEnum<{
+        not_applicable: "not_applicable";
+        parseable: "parseable";
+        unparseable: "unparseable";
+    }>;
+    graph_diff: z.ZodObject<{
+        added_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        removed_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        added_edges: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        removed_edges: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    parser_control: z.ZodOptional<z.ZodObject<{
+        source_hash: z.ZodString;
+        observed_target_calls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        observed_target_imports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    source_patch: z.ZodOptional<z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        diff: z.ZodString;
+        diff_hash: z.ZodString;
+    }, z.core.$strict>>;
+    evaluation_hash: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    behavior: z.ZodOptional<z.ZodObject<{
+        commit: z.ZodString;
+        workspace: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                staged: "staged";
+                working: "working";
+            }>;
+            base_commit: z.ZodString;
+            snapshot_hash: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        test: z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+            source_hash: z.ZodString;
+        }, z.core.$strict>;
+        runner: z.ZodEnum<{
+            "node-test": "node-test";
+            "node-test-tsx": "node-test-tsx";
+        }>;
+        dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+        selected_event: z.ZodNullable<z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        error_code: z.ZodOptional<z.ZodString>;
+        execution_hash: z.ZodString;
+    }, z.core.$strict>>;
+    deterministic_hash: z.ZodString;
+}, z.core.$strict>;
+export type MutationReceipt = z.infer<typeof MutationReceiptSchema>;
+export declare const PolicyProofSchema: z.ZodObject<{
+    id: z.ZodString;
+    plan_hash: z.ZodString;
+    policy_hash: z.ZodString;
+    evaluator: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    mutation_engine: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"parent_with_exceptions">;
+        root_policy_id: z.ZodString;
+        root_policy_hash: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            policy_id: z.ZodString;
+            policy_hash: z.ZodString;
+            exception_of: z.ZodString;
+            scope: z.ZodDefault<z.ZodObject<{
+                repos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
+        composite_hash: z.ZodString;
+    }, z.core.$strict>>;
+    generated_at: z.ZodString;
+    current: z.ZodObject<{
+        total: z.ZodNumber;
+        satisfied: z.ZodNumber;
+        violated: z.ZodNumber;
+        not_applicable: z.ZodNumber;
+        unknown: z.ZodNumber;
+        error: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    known_bad: z.ZodObject<{
+        total: z.ZodNumber;
+        satisfied: z.ZodNumber;
+        violated: z.ZodNumber;
+        not_applicable: z.ZodNumber;
+        unknown: z.ZodNumber;
+        error: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    known_good: z.ZodObject<{
+        total: z.ZodNumber;
+        satisfied: z.ZodNumber;
+        violated: z.ZodNumber;
+        not_applicable: z.ZodNumber;
+        unknown: z.ZodNumber;
+        error: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    accepted_history: z.ZodObject<{
+        total: z.ZodNumber;
+        satisfied: z.ZodNumber;
+        violated: z.ZodNumber;
+        not_applicable: z.ZodNumber;
+        unknown: z.ZodNumber;
+        error: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        classified_hits: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    mutations: z.ZodObject<{
+        total: z.ZodNumber;
+        satisfied: z.ZodNumber;
+        violated: z.ZodNumber;
+        not_applicable: z.ZodNumber;
+        unknown: z.ZodNumber;
+        error: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        operator_coverage: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+    replay_receipts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        leg: z.ZodEnum<{
+            known_bad: "known_bad";
+            known_good: "known_good";
+            current_baseline: "current_baseline";
+            accepted_history: "accepted_history";
+        }>;
+        commit: z.ZodString;
+        expected: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>>;
+        policy_hash: z.ZodString;
+        evaluator: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        graph_hash: z.ZodOptional<z.ZodString>;
+        evaluation_hash: z.ZodOptional<z.ZodString>;
+        error_code: z.ZodOptional<z.ZodString>;
+        behavior: z.ZodOptional<z.ZodObject<{
+            commit: z.ZodString;
+            workspace: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    staged: "staged";
+                    working: "working";
+                }>;
+                base_commit: z.ZodString;
+                snapshot_hash: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            test: z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                source_hash: z.ZodString;
+            }, z.core.$strict>;
+            runner: z.ZodEnum<{
+                "node-test": "node-test";
+                "node-test-tsx": "node-test-tsx";
+            }>;
+            dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+            exit_code: z.ZodNullable<z.ZodNumber>;
+            selected_event: z.ZodNullable<z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>>;
+            error_code: z.ZodOptional<z.ZodString>;
+            execution_hash: z.ZodString;
+        }, z.core.$strict>>;
+        deterministic_hash: z.ZodString;
+    }, z.core.$strict>>>;
+    mutation_receipts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            primary: "primary";
+            control: "control";
+        }>;
+        operator: z.ZodString;
+        required: z.ZodBoolean;
+        engine: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        policy_hash: z.ZodString;
+        base_commit: z.ZodString;
+        base_graph_hash: z.ZodString;
+        mutated_graph_hash: z.ZodOptional<z.ZodString>;
+        expected: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        result: z.ZodEnum<{
+            unknown: "unknown";
+            error: "error";
+            satisfied: "satisfied";
+            violated: "violated";
+            not_applicable: "not_applicable";
+        }>;
+        passed: z.ZodBoolean;
+        parseability: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            parseable: "parseable";
+            unparseable: "unparseable";
+        }>;
+        graph_diff: z.ZodObject<{
+            added_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            removed_symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            added_edges: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            removed_edges: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        parser_control: z.ZodOptional<z.ZodObject<{
+            source_hash: z.ZodString;
+            observed_target_calls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            observed_target_imports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        source_patch: z.ZodOptional<z.ZodObject<{
+            files: z.ZodArray<z.ZodString>;
+            diff: z.ZodString;
+            diff_hash: z.ZodString;
+        }, z.core.$strict>>;
+        evaluation_hash: z.ZodOptional<z.ZodString>;
+        error_code: z.ZodOptional<z.ZodString>;
+        behavior: z.ZodOptional<z.ZodObject<{
+            commit: z.ZodString;
+            workspace: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    staged: "staged";
+                    working: "working";
+                }>;
+                base_commit: z.ZodString;
+                snapshot_hash: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            test: z.ZodObject<{
+                file: z.ZodString;
+                name: z.ZodString;
+                source_hash: z.ZodString;
+            }, z.core.$strict>;
+            runner: z.ZodEnum<{
+                "node-test": "node-test";
+                "node-test-tsx": "node-test-tsx";
+            }>;
+            dependency_snapshot_id: z.ZodOptional<z.ZodString>;
+            exit_code: z.ZodNullable<z.ZodNumber>;
+            selected_event: z.ZodNullable<z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>>;
+            error_code: z.ZodOptional<z.ZodString>;
+            execution_hash: z.ZodString;
+        }, z.core.$strict>>;
+        deterministic_hash: z.ZodString;
+    }, z.core.$strict>>>;
+    mutation_controls: z.ZodDefault<z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        receipt_hashes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    project_checks: z.ZodDefault<z.ZodObject<{
+        build: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            passed: "passed";
+            failed: "failed";
+            not_run: "not_run";
+        }>>;
+        test: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            passed: "passed";
+            failed: "failed";
+            not_run: "not_run";
+        }>>;
+        required_for_evaluator_sensitivity: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    proof_class: z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+        P4: "P4";
+        P5: "P5";
+    }>;
+    artifact_hashes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    data_class: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        secret: "secret";
+    }>;
+}, z.core.$loose>;
+export type PolicyProof = z.infer<typeof PolicyProofSchema>;