@blokjs/shared 2.1.0 → 2.2.1

package/dist/EvidenceContracts.d.ts

@@ -0,0 +1,884 @@
+import { z } from "zod";
+import type { InteractionPayload } from "./InteractionContracts.js";
+/** Version of the language-neutral evidence wire contract. */
+export declare const EVIDENCE_CONTRACT_VERSION: "1";
+/** Evidence uses the same bounded JSON value envelope as H1-01 answers. */
+export declare const EVIDENCE_MAX_RECORD_BYTES: number;
+export declare const EVIDENCE_MAX_PAYLOAD_DEPTH = 8;
+export declare const EVIDENCE_MAX_PAYLOAD_ITEMS = 256;
+export declare const EVIDENCE_MAX_STRING_LENGTH: number;
+export declare const EVIDENCE_MAX_CHECKS = 32;
+export declare const EVIDENCE_MAX_REQUIREMENTS = 64;
+export declare const EVIDENCE_PRODUCER_KINDS: readonly ["capability", "deterministic-step", "runner"];
+export declare const EVIDENCE_VERIFIER_KINDS: readonly ["capability", "human", "runner"];
+export declare const EVIDENCE_VERIFICATION_STATUSES: readonly ["verified", "failed", "unverified", "expired"];
+export declare const EVIDENCE_VERIFICATION_METHODS: readonly ["artifact-digest", "schema-check", "deterministic-check", "capability-attestation", "human-approval"];
+export declare const EVIDENCE_CHECK_OUTCOMES: readonly ["passed", "failed"];
+export type EvidenceProducerKind = (typeof EVIDENCE_PRODUCER_KINDS)[number];
+export type EvidenceVerifierKind = (typeof EVIDENCE_VERIFIER_KINDS)[number];
+export type EvidenceVerificationStatus = (typeof EVIDENCE_VERIFICATION_STATUSES)[number];
+export type EvidenceVerificationMethod = (typeof EVIDENCE_VERIFICATION_METHODS)[number];
+export type EvidenceCheckOutcome = (typeof EVIDENCE_CHECK_OUTCOMES)[number];
+/** JSON values may be persisted in evidence only inside the shared bounds. */
+export type EvidencePayload = InteractionPayload;
+export interface ArtifactIdentity {
+    /** Stable logical identity, independent of a particular produced version. */
+    readonly id: string;
+    /** Artifact family, for example `test-result` or `diff`. */
+    readonly kind: string;
+}
+export interface ArtifactVersionIdentity {
+    readonly artifact: ArtifactIdentity;
+    /** Immutable producer/version label for the artifact. */
+    readonly version: string;
+    /** Content identity. A digest is required; a locator is not trusted evidence. */
+    readonly digest: string;
+}
+export interface EvidenceProducerIdentity {
+    readonly kind: EvidenceProducerKind;
+    /** Stable capability, step, or runner identity. */
+    readonly id: string;
+}
+export interface EvidenceTraceIdentity {
+    /** H1-01-compatible durable workflow run identity. */
+    readonly runId: string;
+    /** Optional node-run identity from the existing trace model. */
+    readonly nodeRunId?: string;
+}
+export interface EvidenceProvenanceIdentity {
+    readonly producer: EvidenceProducerIdentity;
+    readonly workflow: {
+        readonly name: string;
+        readonly version?: string;
+    };
+    readonly step: {
+        readonly id: string;
+        readonly index?: number;
+        readonly attempt?: number;
+    };
+    readonly trace: EvidenceTraceIdentity;
+    /** H1-01 interaction id when an approval contributed to provenance. */
+    readonly interactionId?: string;
+}
+export type EvidenceArtifactIdentity = ArtifactVersionIdentity;
+export interface EvidenceCheck {
+    /** Machine-readable check code; prose is intentionally not a check result. */
+    readonly code: string;
+    readonly outcome: EvidenceCheckOutcome;
+}
+export interface EvidenceVerifierIdentity {
+    readonly kind: EvidenceVerifierKind;
+    readonly id: string;
+}
+export interface EvidenceVerificationResult {
+    readonly status: EvidenceVerificationStatus;
+    readonly verifier: EvidenceVerifierIdentity;
+    readonly method: EvidenceVerificationMethod;
+    readonly checkedAt: string;
+    readonly checks: readonly EvidenceCheck[];
+    /** Stable machine-readable reason, never model-authored prose. */
+    readonly reasonCode?: string;
+}
+export type EvidenceKind = string;
+export interface EvidenceRecord {
+    readonly version: typeof EVIDENCE_CONTRACT_VERSION;
+    readonly id: string;
+    /** Machine-readable claim type, such as `tests.pass`. */
+    readonly kind: EvidenceKind;
+    /** Machine-readable claim code, such as `repository.tests.pass`. */
+    readonly claim: string;
+    readonly artifact: EvidenceArtifactIdentity;
+    readonly provenance: EvidenceProvenanceIdentity;
+    readonly verification: EvidenceVerificationResult;
+    readonly observedAt: string;
+    readonly expiresAt?: string;
+    /** Structured facts only; this is not a model explanation channel. */
+    readonly payload?: EvidencePayload;
+}
+export interface EvidenceRequirement {
+    readonly type: "evidence";
+    readonly id: string;
+    readonly kind: EvidenceKind;
+    readonly claim?: string;
+    readonly artifactKind?: string;
+    readonly producers: readonly EvidenceProducerKind[];
+    /** Completion can consume only a verified record. */
+    readonly verification: "verified";
+}
+export interface ApprovalRequirement {
+    readonly type: "approval";
+    readonly id: string;
+    /** Durable interaction id from H1-01, never an answer/prose substitute. */
+    readonly interactionId: string;
+    /** The interaction must have reached its accepted terminal answer. */
+    readonly status: "answered";
+}
+export type CompletionRequirement = EvidenceRequirement | ApprovalRequirement;
+export interface CompletionContract {
+    readonly version: typeof EVIDENCE_CONTRACT_VERSION;
+    readonly id: string;
+    readonly mode: "all" | "any";
+    readonly requirements: readonly CompletionRequirement[];
+}
+export declare class EvidenceContractError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+export declare const ArtifactIdentitySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: string;
+}, {
+    id: string;
+    kind: string;
+}>;
+export declare const ArtifactVersionIdentitySchema: z.ZodObject<{
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: string;
+    }, {
+        id: string;
+        kind: string;
+    }>;
+    version: z.ZodString;
+    digest: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    digest: string;
+    artifact: {
+        id: string;
+        kind: string;
+    };
+}, {
+    version: string;
+    digest: string;
+    artifact: {
+        id: string;
+        kind: string;
+    };
+}>;
+export declare const EvidenceProducerIdentitySchema: z.ZodObject<{
+    kind: z.ZodEnum<["capability", "deterministic-step", "runner"]>;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "capability" | "deterministic-step" | "runner";
+}, {
+    id: string;
+    kind: "capability" | "deterministic-step" | "runner";
+}>;
+export declare const EvidenceTraceIdentitySchema: z.ZodObject<{
+    runId: z.ZodString;
+    nodeRunId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    runId: string;
+    nodeRunId?: string | undefined;
+}, {
+    runId: string;
+    nodeRunId?: string | undefined;
+}>;
+export declare const EvidenceProvenanceIdentitySchema: z.ZodObject<{
+    producer: z.ZodObject<{
+        kind: z.ZodEnum<["capability", "deterministic-step", "runner"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "capability" | "deterministic-step" | "runner";
+    }, {
+        id: string;
+        kind: "capability" | "deterministic-step" | "runner";
+    }>;
+    workflow: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+    }>;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodOptional<z.ZodNumber>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        index?: number | undefined;
+        attempt?: number | undefined;
+    }, {
+        id: string;
+        index?: number | undefined;
+        attempt?: number | undefined;
+    }>;
+    trace: z.ZodObject<{
+        runId: z.ZodString;
+        nodeRunId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        runId: string;
+        nodeRunId?: string | undefined;
+    }, {
+        runId: string;
+        nodeRunId?: string | undefined;
+    }>;
+    interactionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        name: string;
+        version?: string | undefined;
+    };
+    step: {
+        id: string;
+        index?: number | undefined;
+        attempt?: number | undefined;
+    };
+    producer: {
+        id: string;
+        kind: "capability" | "deterministic-step" | "runner";
+    };
+    trace: {
+        runId: string;
+        nodeRunId?: string | undefined;
+    };
+    interactionId?: string | undefined;
+}, {
+    workflow: {
+        name: string;
+        version?: string | undefined;
+    };
+    step: {
+        id: string;
+        index?: number | undefined;
+        attempt?: number | undefined;
+    };
+    producer: {
+        id: string;
+        kind: "capability" | "deterministic-step" | "runner";
+    };
+    trace: {
+        runId: string;
+        nodeRunId?: string | undefined;
+    };
+    interactionId?: string | undefined;
+}>;
+export declare const EvidenceCheckSchema: z.ZodObject<{
+    code: z.ZodString;
+    outcome: z.ZodEnum<["passed", "failed"]>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    outcome: "failed" | "passed";
+}, {
+    code: string;
+    outcome: "failed" | "passed";
+}>;
+export declare const EvidenceVerifierIdentitySchema: z.ZodObject<{
+    kind: z.ZodEnum<["capability", "human", "runner"]>;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "capability" | "runner" | "human";
+}, {
+    id: string;
+    kind: "capability" | "runner" | "human";
+}>;
+export declare const EvidenceVerificationResultSchema: z.ZodEffects<z.ZodObject<{
+    status: z.ZodEnum<["verified", "failed", "unverified", "expired"]>;
+    verifier: z.ZodObject<{
+        kind: z.ZodEnum<["capability", "human", "runner"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    }, {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    }>;
+    method: z.ZodEnum<["artifact-digest", "schema-check", "deterministic-check", "capability-attestation", "human-approval"]>;
+    checkedAt: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        outcome: z.ZodEnum<["passed", "failed"]>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        outcome: "failed" | "passed";
+    }, {
+        code: string;
+        outcome: "failed" | "passed";
+    }>, "many">;
+    reasonCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "expired" | "verified" | "failed" | "unverified";
+    verifier: {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    };
+    method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+    checkedAt: string;
+    checks: {
+        code: string;
+        outcome: "failed" | "passed";
+    }[];
+    reasonCode?: string | undefined;
+}, {
+    status: "expired" | "verified" | "failed" | "unverified";
+    verifier: {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    };
+    method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+    checkedAt: string;
+    checks: {
+        code: string;
+        outcome: "failed" | "passed";
+    }[];
+    reasonCode?: string | undefined;
+}>, {
+    status: "expired" | "verified" | "failed" | "unverified";
+    verifier: {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    };
+    method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+    checkedAt: string;
+    checks: {
+        code: string;
+        outcome: "failed" | "passed";
+    }[];
+    reasonCode?: string | undefined;
+}, {
+    status: "expired" | "verified" | "failed" | "unverified";
+    verifier: {
+        id: string;
+        kind: "capability" | "runner" | "human";
+    };
+    method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+    checkedAt: string;
+    checks: {
+        code: string;
+        outcome: "failed" | "passed";
+    }[];
+    reasonCode?: string | undefined;
+}>;
+export declare const EvidencePayloadSchema: z.ZodEffects<z.ZodUnknown, string | number | boolean | readonly InteractionPayload[] | Readonly<{
+    [key: string]: InteractionPayload;
+}> | null | undefined, unknown>;
+export declare const EvidenceRecordSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    id: z.ZodString;
+    kind: z.ZodString;
+    claim: z.ZodString;
+    artifact: z.ZodObject<{
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: string;
+        }, {
+            id: string;
+            kind: string;
+        }>;
+        version: z.ZodString;
+        digest: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        digest: string;
+        artifact: {
+            id: string;
+            kind: string;
+        };
+    }, {
+        version: string;
+        digest: string;
+        artifact: {
+            id: string;
+            kind: string;
+        };
+    }>;
+    provenance: z.ZodObject<{
+        producer: z.ZodObject<{
+            kind: z.ZodEnum<["capability", "deterministic-step", "runner"]>;
+            id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        }, {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        }>;
+        workflow: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+        }>;
+        step: z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodOptional<z.ZodNumber>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        }, {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        }>;
+        trace: z.ZodObject<{
+            runId: z.ZodString;
+            nodeRunId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            runId: string;
+            nodeRunId?: string | undefined;
+        }, {
+            runId: string;
+            nodeRunId?: string | undefined;
+        }>;
+        interactionId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workflow: {
+            name: string;
+            version?: string | undefined;
+        };
+        step: {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        };
+        producer: {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        };
+        trace: {
+            runId: string;
+            nodeRunId?: string | undefined;
+        };
+        interactionId?: string | undefined;
+    }, {
+        workflow: {
+            name: string;
+            version?: string | undefined;
+        };
+        step: {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        };
+        producer: {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        };
+        trace: {
+            runId: string;
+            nodeRunId?: string | undefined;
+        };
+        interactionId?: string | undefined;
+    }>;
+    verification: z.ZodEffects<z.ZodObject<{
+        status: z.ZodEnum<["verified", "failed", "unverified", "expired"]>;
+        verifier: z.ZodObject<{
+            kind: z.ZodEnum<["capability", "human", "runner"]>;
+            id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        }, {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        }>;
+        method: z.ZodEnum<["artifact-digest", "schema-check", "deterministic-check", "capability-attestation", "human-approval"]>;
+        checkedAt: z.ZodString;
+        checks: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            outcome: z.ZodEnum<["passed", "failed"]>;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            outcome: "failed" | "passed";
+        }, {
+            code: string;
+            outcome: "failed" | "passed";
+        }>, "many">;
+        reasonCode: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    }, {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    }>, {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    }, {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    }>;
+    observedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodEffects<z.ZodUnknown, string | number | boolean | readonly InteractionPayload[] | Readonly<{
+        [key: string]: InteractionPayload;
+    }> | null | undefined, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: string;
+    version: "1";
+    artifact: {
+        version: string;
+        digest: string;
+        artifact: {
+            id: string;
+            kind: string;
+        };
+    };
+    claim: string;
+    provenance: {
+        workflow: {
+            name: string;
+            version?: string | undefined;
+        };
+        step: {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        };
+        producer: {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        };
+        trace: {
+            runId: string;
+            nodeRunId?: string | undefined;
+        };
+        interactionId?: string | undefined;
+    };
+    verification: {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    };
+    observedAt: string;
+    payload?: string | number | boolean | readonly InteractionPayload[] | Readonly<{
+        [key: string]: InteractionPayload;
+    }> | null | undefined;
+    expiresAt?: string | undefined;
+}, {
+    id: string;
+    kind: string;
+    version: "1";
+    artifact: {
+        version: string;
+        digest: string;
+        artifact: {
+            id: string;
+            kind: string;
+        };
+    };
+    claim: string;
+    provenance: {
+        workflow: {
+            name: string;
+            version?: string | undefined;
+        };
+        step: {
+            id: string;
+            index?: number | undefined;
+            attempt?: number | undefined;
+        };
+        producer: {
+            id: string;
+            kind: "capability" | "deterministic-step" | "runner";
+        };
+        trace: {
+            runId: string;
+            nodeRunId?: string | undefined;
+        };
+        interactionId?: string | undefined;
+    };
+    verification: {
+        status: "expired" | "verified" | "failed" | "unverified";
+        verifier: {
+            id: string;
+            kind: "capability" | "runner" | "human";
+        };
+        method: "artifact-digest" | "schema-check" | "deterministic-check" | "capability-attestation" | "human-approval";
+        checkedAt: string;
+        checks: {
+            code: string;
+            outcome: "failed" | "passed";
+        }[];
+        reasonCode?: string | undefined;
+    };
+    observedAt: string;
+    payload?: unknown;
+    expiresAt?: string | undefined;
+}>;
+export declare const EvidenceRequirementSchema: z.ZodObject<{
+    type: z.ZodLiteral<"evidence">;
+    id: z.ZodString;
+    kind: z.ZodString;
+    claim: z.ZodOptional<z.ZodString>;
+    artifactKind: z.ZodOptional<z.ZodString>;
+    producers: z.ZodArray<z.ZodEnum<["capability", "deterministic-step", "runner"]>, "many">;
+    verification: z.ZodLiteral<"verified">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: string;
+    type: "evidence";
+    verification: "verified";
+    producers: ("capability" | "deterministic-step" | "runner")[];
+    claim?: string | undefined;
+    artifactKind?: string | undefined;
+}, {
+    id: string;
+    kind: string;
+    type: "evidence";
+    verification: "verified";
+    producers: ("capability" | "deterministic-step" | "runner")[];
+    claim?: string | undefined;
+    artifactKind?: string | undefined;
+}>;
+export declare const ApprovalRequirementSchema: z.ZodObject<{
+    type: z.ZodLiteral<"approval">;
+    id: z.ZodString;
+    interactionId: z.ZodString;
+    status: z.ZodLiteral<"answered">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    interactionId: string;
+    status: "answered";
+    type: "approval";
+}, {
+    id: string;
+    interactionId: string;
+    status: "answered";
+    type: "approval";
+}>;
+export declare const CompletionRequirementSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"evidence">;
+    id: z.ZodString;
+    kind: z.ZodString;
+    claim: z.ZodOptional<z.ZodString>;
+    artifactKind: z.ZodOptional<z.ZodString>;
+    producers: z.ZodArray<z.ZodEnum<["capability", "deterministic-step", "runner"]>, "many">;
+    verification: z.ZodLiteral<"verified">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: string;
+    type: "evidence";
+    verification: "verified";
+    producers: ("capability" | "deterministic-step" | "runner")[];
+    claim?: string | undefined;
+    artifactKind?: string | undefined;
+}, {
+    id: string;
+    kind: string;
+    type: "evidence";
+    verification: "verified";
+    producers: ("capability" | "deterministic-step" | "runner")[];
+    claim?: string | undefined;
+    artifactKind?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"approval">;
+    id: z.ZodString;
+    interactionId: z.ZodString;
+    status: z.ZodLiteral<"answered">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    interactionId: string;
+    status: "answered";
+    type: "approval";
+}, {
+    id: string;
+    interactionId: string;
+    status: "answered";
+    type: "approval";
+}>]>;
+export declare const CompletionContractSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    id: z.ZodString;
+    mode: z.ZodEnum<["all", "any"]>;
+    requirements: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"evidence">;
+        id: z.ZodString;
+        kind: z.ZodString;
+        claim: z.ZodOptional<z.ZodString>;
+        artifactKind: z.ZodOptional<z.ZodString>;
+        producers: z.ZodArray<z.ZodEnum<["capability", "deterministic-step", "runner"]>, "many">;
+        verification: z.ZodLiteral<"verified">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    }, {
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"approval">;
+        id: z.ZodString;
+        interactionId: z.ZodString;
+        status: z.ZodLiteral<"answered">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    }, {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: "1";
+    mode: "all" | "any";
+    requirements: ({
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    } | {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    })[];
+}, {
+    id: string;
+    version: "1";
+    mode: "all" | "any";
+    requirements: ({
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    } | {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    })[];
+}>, {
+    id: string;
+    version: "1";
+    mode: "all" | "any";
+    requirements: ({
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    } | {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    })[];
+}, {
+    id: string;
+    version: "1";
+    mode: "all" | "any";
+    requirements: ({
+        id: string;
+        kind: string;
+        type: "evidence";
+        verification: "verified";
+        producers: ("capability" | "deterministic-step" | "runner")[];
+        claim?: string | undefined;
+        artifactKind?: string | undefined;
+    } | {
+        id: string;
+        interactionId: string;
+        status: "answered";
+        type: "approval";
+    })[];
+}>;
+/** Parse one bounded structured fact payload without accepting model prose as a record. */
+export declare function parseEvidencePayload(value: unknown): EvidencePayload;
+/** Parse and normalize an evidence record at the trusted boundary. */
+export declare function parseEvidenceRecord(value: unknown): EvidenceRecord;
+/** Parse and normalize a completion contract at the workflow/load boundary. */
+export declare function parseCompletionContract(value: unknown): CompletionContract;
+export declare function serializeEvidenceRecord(value: unknown): string;
+export declare function serializeCompletionContract(value: unknown): string;
+/**
+ * A model message is descriptive context only. It cannot be adapted into a
+ * trusted record because the only accepted producer kinds are capability,
+ * deterministic-step, and runner.
+ */
+export declare function rejectModelEvidence(_value: unknown): never;