@davidahmann/mill 0.1.4

package/dist/contracts/schemas.d.ts

@@ -0,0 +1,2705 @@
+import { z } from "zod";
+export declare const sourceManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    trigger: z.ZodEnum<{
+        bootstrap: "bootstrap";
+        adoption_uncertainty: "adoption_uncertainty";
+        approved_stack_change: "approved_stack_change";
+    }>;
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        queries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strict>>;
+        networkDisclosure: z.ZodString;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        class: z.ZodEnum<{
+            primary_documentation: "primary_documentation";
+            official_registry: "official_registry";
+            security_advisory: "security_advisory";
+            license: "license";
+            repository: "repository";
+            user_evidence: "user_evidence";
+            operator_constraint: "operator_constraint";
+        }>;
+        uri: z.ZodString;
+        revision: z.ZodString;
+        observedAt: z.ZodISODateTime;
+        freshness: z.ZodEnum<{
+            unknown: "unknown";
+            current: "current";
+            stale: "stale";
+        }>;
+        authority: z.ZodEnum<{
+            evidence: "evidence";
+            constraint: "constraint";
+            approved_decision: "approved_decision";
+        }>;
+        digest: z.ZodOptional<z.ZodString>;
+        claims: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const invariantSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    owner: z.ZodString;
+    criticality: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+        critical: "critical";
+    }>;
+    surfaceRefs: z.ZodArray<z.ZodString>;
+    verification: z.ZodObject<{
+        mode: z.ZodEnum<{
+            command: "command";
+            human: "human";
+            unsupported: "unsupported";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    sourceRefs: z.ZodArray<z.ZodString>;
+    unknowns: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const decisionCardSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        product: "product";
+        architecture: "architecture";
+        design: "design";
+        accessibility: "accessibility";
+        research: "research";
+    }>;
+    question: z.ZodString;
+    decision: z.ZodString;
+    rationale: z.ZodString;
+    sourceRefs: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        rejected: "rejected";
+        proposed: "proposed";
+        approved: "approved";
+    }>;
+    costlyToReverse: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const managedRepositorySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    id: z.ZodUUID;
+    forgeHost: z.ZodString;
+    owner: z.ZodString;
+    repository: z.ZodString;
+    canonicalBranch: z.ZodString;
+    remoteName: z.ZodString;
+    remoteUrl: z.ZodURL;
+    trustCeiling: z.ZodEnum<{
+        inspect: "inspect";
+        build: "build";
+        propose: "propose";
+    }>;
+}, z.core.$strict>;
+export declare const productContractSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    id: z.ZodString;
+    title: z.ZodString;
+    primaryUser: z.ZodString;
+    jobToBeDone: z.ZodString;
+    outcomes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    nonGoals: z.ZodArray<z.ZodString>;
+    assumptions: z.ZodArray<z.ZodString>;
+    unknowns: z.ZodArray<z.ZodString>;
+    sourceRefs: z.ZodArray<z.ZodString>;
+    acceptance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            functional: "functional";
+            quality: "quality";
+            operational: "operational";
+        }>;
+        statement: z.ZodString;
+        sourceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    invariants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        owner: z.ZodString;
+        criticality: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+            critical: "critical";
+        }>;
+        surfaceRefs: z.ZodArray<z.ZodString>;
+        verification: z.ZodObject<{
+            mode: z.ZodEnum<{
+                command: "command";
+                human: "human";
+                unsupported: "unsupported";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>;
+        sourceRefs: z.ZodArray<z.ZodString>;
+        unknowns: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            product: "product";
+            architecture: "architecture";
+            design: "design";
+            accessibility: "accessibility";
+            research: "research";
+        }>;
+        question: z.ZodString;
+        decision: z.ZodString;
+        rationale: z.ZodString;
+        sourceRefs: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            rejected: "rejected";
+            proposed: "proposed";
+            approved: "approved";
+        }>;
+        costlyToReverse: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const blueprintSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    id: z.ZodString;
+    productContractDigest: z.ZodString;
+    recipe: z.ZodString;
+    recipeVersion: z.ZodString;
+    runtime: z.ZodString;
+    architecture: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const scenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        authority: "authority";
+        normal: "normal";
+        exception: "exception";
+        degradation: "degradation";
+        recovery: "recovery";
+        adversarial: "adversarial";
+    }>;
+    given: z.ZodArray<z.ZodString>;
+    when: z.ZodArray<z.ZodString>;
+    then: z.ZodArray<z.ZodString>;
+    oracleOwner: z.ZodEnum<{
+        external: "external";
+        repository: "repository";
+        human: "human";
+    }>;
+    acceptanceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    invariantRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    coverage: z.ZodDefault<z.ZodEnum<{
+        new_behavior: "new_behavior";
+        preservation: "preservation";
+        both: "both";
+    }>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        builder_visible: "builder_visible";
+        reviewer_owned: "reviewer_owned";
+        human_acceptance: "human_acceptance";
+    }>>;
+    executionRef: z.ZodOptional<z.ZodString>;
+    recipeOracle: z.ZodOptional<z.ZodString>;
+    forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const scenarioSetSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    productContractDigest: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            authority: "authority";
+            normal: "normal";
+            exception: "exception";
+            degradation: "degradation";
+            recovery: "recovery";
+            adversarial: "adversarial";
+        }>;
+        given: z.ZodArray<z.ZodString>;
+        when: z.ZodArray<z.ZodString>;
+        then: z.ZodArray<z.ZodString>;
+        oracleOwner: z.ZodEnum<{
+            external: "external";
+            repository: "repository";
+            human: "human";
+        }>;
+        acceptanceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        invariantRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        coverage: z.ZodDefault<z.ZodEnum<{
+            new_behavior: "new_behavior";
+            preservation: "preservation";
+            both: "both";
+        }>>;
+        visibility: z.ZodDefault<z.ZodEnum<{
+            builder_visible: "builder_visible";
+            reviewer_owned: "reviewer_owned";
+            human_acceptance: "human_acceptance";
+        }>>;
+        executionRef: z.ZodOptional<z.ZodString>;
+        recipeOracle: z.ZodOptional<z.ZodString>;
+        forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const outcomeSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    acceptance: z.ZodArray<z.ZodString>;
+    acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        proposed: "proposed";
+        approved: "approved";
+        ready: "ready";
+        blocked: "blocked";
+        closed: "closed";
+    }>;
+    taskRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const outcomePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    productContractDigest: z.ZodString;
+    outcomes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        acceptance: z.ZodArray<z.ZodString>;
+        acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            proposed: "proposed";
+            approved: "approved";
+            ready: "ready";
+            blocked: "blocked";
+            closed: "closed";
+        }>;
+        taskRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const impactManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    id: z.ZodString;
+    productContractDigest: z.ZodString;
+    outcomeId: z.ZodString;
+    riskClass: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    acceptanceIds: z.ZodArray<z.ZodString>;
+    affectedInvariantIds: z.ZodArray<z.ZodString>;
+    uncertainInvariantIds: z.ZodArray<z.ZodString>;
+    surfaces: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            user: "user";
+            design: "design";
+            system: "system";
+            interface: "interface";
+            data: "data";
+            operations: "operations";
+        }>;
+        change: z.ZodString;
+    }, z.core.$strict>>;
+    scenarioIds: z.ZodArray<z.ZodString>;
+    commandIds: z.ZodArray<z.ZodString>;
+    materialDecisions: z.ZodArray<z.ZodString>;
+    unresolved: z.ZodArray<z.ZodString>;
+    exceptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        scopeRefs: z.ZodArray<z.ZodString>;
+        reason: z.ZodString;
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    approval: z.ZodNullable<z.ZodObject<{
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+        proposalDigest: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const specificationProposalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    prd: z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    sourceManifestDigest: z.ZodString;
+    productContract: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodString;
+        title: z.ZodString;
+        primaryUser: z.ZodString;
+        jobToBeDone: z.ZodString;
+        outcomes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        nonGoals: z.ZodArray<z.ZodString>;
+        assumptions: z.ZodArray<z.ZodString>;
+        unknowns: z.ZodArray<z.ZodString>;
+        sourceRefs: z.ZodArray<z.ZodString>;
+        acceptance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                functional: "functional";
+                quality: "quality";
+                operational: "operational";
+            }>;
+            statement: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        invariants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            owner: z.ZodString;
+            criticality: z.ZodEnum<{
+                medium: "medium";
+                low: "low";
+                high: "high";
+                critical: "critical";
+            }>;
+            surfaceRefs: z.ZodArray<z.ZodString>;
+            verification: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    command: "command";
+                    human: "human";
+                    unsupported: "unsupported";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            unknowns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                product: "product";
+                architecture: "architecture";
+                design: "design";
+                accessibility: "accessibility";
+                research: "research";
+            }>;
+            question: z.ZodString;
+            decision: z.ZodString;
+            rationale: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                proposed: "proposed";
+                approved: "approved";
+            }>;
+            costlyToReverse: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    blueprints: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodString;
+        productContractDigest: z.ZodString;
+        recipe: z.ZodString;
+        recipeVersion: z.ZodString;
+        runtime: z.ZodString;
+        architecture: z.ZodArray<z.ZodString>;
+        risks: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    scenarioSet: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        productContractDigest: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                authority: "authority";
+                normal: "normal";
+                exception: "exception";
+                degradation: "degradation";
+                recovery: "recovery";
+                adversarial: "adversarial";
+            }>;
+            given: z.ZodArray<z.ZodString>;
+            when: z.ZodArray<z.ZodString>;
+            then: z.ZodArray<z.ZodString>;
+            oracleOwner: z.ZodEnum<{
+                external: "external";
+                repository: "repository";
+                human: "human";
+            }>;
+            acceptanceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            invariantRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            coverage: z.ZodDefault<z.ZodEnum<{
+                new_behavior: "new_behavior";
+                preservation: "preservation";
+                both: "both";
+            }>>;
+            visibility: z.ZodDefault<z.ZodEnum<{
+                builder_visible: "builder_visible";
+                reviewer_owned: "reviewer_owned";
+                human_acceptance: "human_acceptance";
+            }>>;
+            executionRef: z.ZodOptional<z.ZodString>;
+            recipeOracle: z.ZodOptional<z.ZodString>;
+            forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    assumptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        sourceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    contradictions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        sourceRefs: z.ZodArray<z.ZodString>;
+        blocking: z.ZodBoolean;
+    }, z.core.$strict>>;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        recommendedDefault: z.ZodString;
+        reversible: z.ZodBoolean;
+        blocking: z.ZodBoolean;
+    }, z.core.$strict>>;
+    status: z.ZodLiteral<"proposed">;
+}, z.core.$strict>;
+export declare const millConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    repositoryId: z.ZodUUID;
+    trustCeiling: z.ZodEnum<{
+        inspect: "inspect";
+        build: "build";
+        propose: "propose";
+    }>;
+    sensitivePaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    verifier: z.ZodOptional<z.ZodObject<{
+        image: z.ZodString;
+        network: z.ZodLiteral<"none">;
+        dependencies: z.ZodOptional<z.ZodObject<{
+            manager: z.ZodLiteral<"npm">;
+            registry: z.ZodLiteral<"https://registry.npmjs.org">;
+            targetPath: z.ZodLiteral<"node_modules">;
+            lockPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    propose: z.ZodOptional<z.ZodObject<{
+        forge: z.ZodLiteral<"github">;
+        host: z.ZodLiteral<"github.com">;
+        owner: z.ZodString;
+        repository: z.ZodString;
+        repositoryNodeId: z.ZodString;
+        remoteName: z.ZodString;
+        baseBranch: z.ZodString;
+        branchPrefix: z.ZodLiteral<"mill/">;
+        allowedActors: z.ZodArray<z.ZodString>;
+        allowedMergerLogins: z.ZodArray<z.ZodString>;
+        requiredChecks: z.ZodArray<z.ZodString>;
+        reviewPolicy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                local_only: "local_only";
+                github_required: "github_required";
+            }>;
+            requiredReviewerLogins: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        allowedMergeMethods: z.ZodArray<z.ZodEnum<{
+            merge: "merge";
+            linear_tree_preserving: "linear_tree_preserving";
+        }>>;
+        approvalTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        pollTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    commands: z.ZodRecord<z.ZodString, z.ZodObject<{
+        argv: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+        controlPaths: z.ZodArray<z.ZodString>;
+        capability: z.ZodEnum<{
+            test: "test";
+            build: "build";
+            read: "read";
+            package: "package";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        execution: z.ZodDefault<z.ZodEnum<{
+            host: "host";
+            oci: "oci";
+        }>>;
+        writablePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const taskPacketV1Schema: z.ZodObject<{
+    authority: z.ZodObject<{
+        productContract: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSet: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    title: z.ZodString;
+    objective: z.ZodString;
+    riskClass: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    baseRef: z.ZodString;
+    contextPaths: z.ZodArray<z.ZodString>;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    commandIds: z.ZodArray<z.ZodString>;
+    commit: z.ZodObject<{
+        message: z.ZodString;
+        authorName: z.ZodString;
+        authorEmail: z.ZodEmail;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        deadlineSeconds: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+        retryCount: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"1">;
+}, z.core.$strict>;
+export declare const taskPacketV2Schema: z.ZodObject<{
+    authority: z.ZodObject<{
+        productContract: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSet: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        impactManifest: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    attestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        claims: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                acceptance: "acceptance";
+                invariant: "invariant";
+                scenario: "scenario";
+            }>;
+            id: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        invariantIds: z.ZodArray<z.ZodString>;
+        scenarioIds: z.ZodArray<z.ZodString>;
+        coverage: z.ZodEnum<{
+            new_behavior: "new_behavior";
+            preservation: "preservation";
+            both: "both";
+        }>;
+        evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"command">;
+            commandId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"human">;
+            attestationId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"unsupported">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "mode">;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    title: z.ZodString;
+    objective: z.ZodString;
+    riskClass: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    baseRef: z.ZodString;
+    contextPaths: z.ZodArray<z.ZodString>;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    commandIds: z.ZodArray<z.ZodString>;
+    commit: z.ZodObject<{
+        message: z.ZodString;
+        authorName: z.ZodString;
+        authorEmail: z.ZodEmail;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        deadlineSeconds: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+        retryCount: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"2">;
+}, z.core.$strict>;
+export declare const taskPacketSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    authority: z.ZodObject<{
+        productContract: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSet: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    title: z.ZodString;
+    objective: z.ZodString;
+    riskClass: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    baseRef: z.ZodString;
+    contextPaths: z.ZodArray<z.ZodString>;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    commandIds: z.ZodArray<z.ZodString>;
+    commit: z.ZodObject<{
+        message: z.ZodString;
+        authorName: z.ZodString;
+        authorEmail: z.ZodEmail;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        deadlineSeconds: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+        retryCount: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"1">;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodObject<{
+        productContract: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSet: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        impactManifest: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    attestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        claims: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                acceptance: "acceptance";
+                invariant: "invariant";
+                scenario: "scenario";
+            }>;
+            id: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        invariantIds: z.ZodArray<z.ZodString>;
+        scenarioIds: z.ZodArray<z.ZodString>;
+        coverage: z.ZodEnum<{
+            new_behavior: "new_behavior";
+            preservation: "preservation";
+            both: "both";
+        }>;
+        evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"command">;
+            commandId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"human">;
+            attestationId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"unsupported">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "mode">;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    title: z.ZodString;
+    objective: z.ZodString;
+    riskClass: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+    }>;
+    baseRef: z.ZodString;
+    contextPaths: z.ZodArray<z.ZodString>;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    commandIds: z.ZodArray<z.ZodString>;
+    commit: z.ZodObject<{
+        message: z.ZodString;
+        authorName: z.ZodString;
+        authorEmail: z.ZodEmail;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        deadlineSeconds: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+        retryCount: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"2">;
+}, z.core.$strict>], "schemaVersion">;
+export declare const workerProfileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    adapter: z.ZodLiteral<"codex-cli">;
+    role: z.ZodEnum<{
+        planner: "planner";
+        builder: "builder";
+        reviewer: "reviewer";
+    }>;
+    contractVersion: z.ZodLiteral<"1">;
+    harnessVersion: z.ZodString;
+    promptTemplateDigest: z.ZodString;
+    modelIdentity: z.ZodLiteral<"provider-mutable">;
+    approvalPolicy: z.ZodLiteral<"never">;
+    sandbox: z.ZodEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+    }>;
+    session: z.ZodLiteral<"ephemeral">;
+    hostRules: z.ZodLiteral<"ignored">;
+    skillDiscovery: z.ZodLiteral<"disabled">;
+    toolDiscovery: z.ZodLiteral<"disabled">;
+    networkPosture: z.ZodEnum<{
+        unknown: "unknown";
+        "provider-managed": "provider-managed";
+    }>;
+    capabilities: z.ZodArray<z.ZodString>;
+    outputContract: z.ZodString;
+}, z.core.$strict>;
+export declare const workerInvocationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    invocationId: z.ZodUUID;
+    runId: z.ZodUUID;
+    phase: z.ZodEnum<{
+        build: "build";
+        repair: "repair";
+        review: "review";
+    }>;
+    attempt: z.ZodNumber;
+    taskDigest: z.ZodString;
+    contextEpoch: z.ZodString;
+    baseCommit: z.ZodString;
+    candidateCommit: z.ZodOptional<z.ZodString>;
+    impactManifestDigest: z.ZodOptional<z.ZodString>;
+    profile: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        adapter: z.ZodLiteral<"codex-cli">;
+        role: z.ZodEnum<{
+            planner: "planner";
+            builder: "builder";
+            reviewer: "reviewer";
+        }>;
+        contractVersion: z.ZodLiteral<"1">;
+        harnessVersion: z.ZodString;
+        promptTemplateDigest: z.ZodString;
+        modelIdentity: z.ZodLiteral<"provider-mutable">;
+        approvalPolicy: z.ZodLiteral<"never">;
+        sandbox: z.ZodEnum<{
+            "read-only": "read-only";
+            "workspace-write": "workspace-write";
+        }>;
+        session: z.ZodLiteral<"ephemeral">;
+        hostRules: z.ZodLiteral<"ignored">;
+        skillDiscovery: z.ZodLiteral<"disabled">;
+        toolDiscovery: z.ZodLiteral<"disabled">;
+        networkPosture: z.ZodEnum<{
+            unknown: "unknown";
+            "provider-managed": "provider-managed";
+        }>;
+        capabilities: z.ZodArray<z.ZodString>;
+        outputContract: z.ZodString;
+    }, z.core.$strict>;
+    profileDigest: z.ZodString;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    deadlineAt: z.ZodISODateTime;
+    maxOutputBytes: z.ZodNumber;
+}, z.core.$strict>;
+export declare const contextManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    taskDigest: z.ZodString;
+    baseCommit: z.ZodString;
+    provider: z.ZodLiteral<"openai">;
+    adapter: z.ZodLiteral<"codex-cli">;
+    authOwner: z.ZodLiteral<"operator">;
+    isolation: z.ZodLiteral<"attended-trusted-host">;
+    modelIdentity: z.ZodLiteral<"provider-mutable">;
+    included: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+    excludedPatterns: z.ZodArray<z.ZodString>;
+    disclosure: z.ZodArray<z.ZodString>;
+    contextEpoch: z.ZodOptional<z.ZodString>;
+    effectiveInstructions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>>;
+    providerVisibleScope: z.ZodOptional<z.ZodObject<{
+        repositoryScope: z.ZodLiteral<"worktree">;
+        suppliedPaths: z.ZodArray<z.ZodString>;
+        writablePatterns: z.ZodArray<z.ZodString>;
+        observedReads: z.ZodLiteral<"unavailable">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const reviewResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    candidateCommit: z.ZodString;
+    summary: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            P0: "P0";
+            P1: "P1";
+            P2: "P2";
+            P3: "P3";
+        }>;
+        class: z.ZodEnum<{
+            style: "style";
+            authority: "authority";
+            correctness: "correctness";
+            security: "security";
+            "data-loss": "data-loss";
+            provenance: "provenance";
+            compatibility: "compatibility";
+            maintainability: "maintainability";
+        }>;
+        title: z.ZodString;
+        body: z.ZodString;
+        file: z.ZodNullable<z.ZodString>;
+        line: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const validationEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    candidateCommit: z.ZodString;
+    verifierImage: z.ZodString;
+    network: z.ZodLiteral<"none">;
+    commands: z.ZodArray<z.ZodObject<{
+        commandId: z.ZodString;
+        required: z.ZodBoolean;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNumber;
+        outputDigest: z.ZodString;
+        reason: z.ZodOptional<z.ZodEnum<{
+            HOST_EXECUTION_NOT_QUALIFIED: "HOST_EXECUTION_NOT_QUALIFIED";
+            CANCELLED: "CANCELLED";
+            DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED";
+            OUTPUT_BUDGET_EXCEEDED: "OUTPUT_BUDGET_EXCEEDED";
+            NONZERO_EXIT: "NONZERO_EXIT";
+        }>>;
+    }, z.core.$strict>>;
+    semantic: z.ZodOptional<z.ZodObject<{
+        impactManifestDigest: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                acceptance: "acceptance";
+                invariant: "invariant";
+                scenario: "scenario";
+            }>;
+            id: z.ZodString;
+            coverage: z.ZodEnum<{
+                new_behavior: "new_behavior";
+                preservation: "preservation";
+                both: "both";
+            }>;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                attested: "attested";
+            }>;
+            evidenceRefs: z.ZodArray<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        newBehaviorPassed: z.ZodBoolean;
+        preservationPassed: z.ZodBoolean;
+        passed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    passed: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const deliveryRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    runId: z.ZodUUID;
+    deliveryKey: z.ZodString;
+    proposalDigest: z.ZodString;
+    approvalExpiresAt: z.ZodISODateTime;
+    state: z.ZodEnum<{
+        blocked: "blocked";
+        closed: "closed";
+        effect_unknown: "effect_unknown";
+        planned: "planned";
+        proposing: "proposing";
+        awaiting_ci: "awaiting_ci";
+        awaiting_human: "awaiting_human";
+        merged: "merged";
+        post_merge_verified: "post_merge_verified";
+        cancelled: "cancelled";
+    }>;
+    target: z.ZodObject<{
+        forge: z.ZodLiteral<"github">;
+        host: z.ZodLiteral<"github.com">;
+        owner: z.ZodString;
+        repository: z.ZodString;
+        repositoryNodeId: z.ZodString;
+        cloneUrl: z.ZodURL;
+        remoteName: z.ZodString;
+        baseBranch: z.ZodString;
+        actorLogin: z.ZodString;
+        actorId: z.ZodNumber;
+    }, z.core.$strict>;
+    branchName: z.ZodString;
+    candidateCommit: z.ZodString;
+    candidateTree: z.ZodString;
+    requiredChecks: z.ZodArray<z.ZodString>;
+    reviewPolicy: z.ZodObject<{
+        mode: z.ZodEnum<{
+            local_only: "local_only";
+            github_required: "github_required";
+        }>;
+        requiredReviewerLogins: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    allowedMergerLogins: z.ZodArray<z.ZodString>;
+    allowedMergeMethods: z.ZodArray<z.ZodEnum<{
+        merge: "merge";
+        linear_tree_preserving: "linear_tree_preserving";
+    }>>;
+    effects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            push: "push";
+            pull_request: "pull_request";
+        }>;
+        candidateCommit: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            intent: "intent";
+            call_started: "call_started";
+            effect_unknown: "effect_unknown";
+            retryable_absent: "retryable_absent";
+            verified: "verified";
+        }>;
+        attemptCount: z.ZodNumber;
+        expectedOldCommit: z.ZodNullable<z.ZodString>;
+        errorCode: z.ZodNullable<z.ZodString>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    remoteHeadCommit: z.ZodNullable<z.ZodString>;
+    pullRequest: z.ZodNullable<z.ZodObject<{
+        number: z.ZodNumber;
+        nodeId: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+    observation: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    merge: z.ZodNullable<z.ZodObject<{
+        commit: z.ZodString;
+        tree: z.ZodString;
+        method: z.ZodEnum<{
+            merge: "merge";
+            linear_tree_preserving: "linear_tree_preserving";
+        }>;
+        mergedByLogin: z.ZodString;
+        mergedAt: z.ZodISODateTime;
+        defaultBranchHead: z.ZodString;
+    }, z.core.$strict>>;
+    lastErrorCode: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const millLockSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    mill: z.ZodObject<{
+        package: z.ZodLiteral<"@davidahmann/mill">;
+        version: z.ZodString;
+        integrity: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    schemaDigests: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    recipe: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+    integration: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            greenfield: "greenfield";
+            adoption: "adoption";
+        }>;
+        planDigest: z.ZodString;
+        baseCommit: z.ZodNullable<z.ZodString>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            ownership: z.ZodEnum<{
+                mill_only: "mill_only";
+                generated_once: "generated_once";
+                managed: "managed";
+            }>;
+            templateDigest: z.ZodString;
+            installedDigest: z.ZodString;
+            preexistingDigest: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const recipeManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    id: z.ZodLiteral<"node-typescript-next-web">;
+    version: z.ZodString;
+    status: z.ZodEnum<{
+        unsupported: "unsupported";
+        supported: "supported";
+        experimental: "experimental";
+    }>;
+    observedAt: z.ZodISODateTime;
+    runtime: z.ZodObject<{
+        node: z.ZodString;
+        npm: z.ZodString;
+    }, z.core.$strict>;
+    stack: z.ZodObject<{
+        next: z.ZodString;
+        react: z.ZodString;
+        reactDom: z.ZodString;
+        typescript: z.ZodString;
+        eslint: z.ZodString;
+        prettier: z.ZodString;
+        vitest: z.ZodString;
+        playwright: z.ZodString;
+    }, z.core.$strict>;
+    verifierImage: z.ZodString;
+    registry: z.ZodURL;
+    licensePolicy: z.ZodObject<{
+        allowed: z.ZodArray<z.ZodString>;
+        reviewedPackages: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            license: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    commands: z.ZodObject<{
+        required: z.ZodArray<z.ZodString>;
+        native: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    oracles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        commandId: z.ZodString;
+        evidencePaths: z.ZodArray<z.ZodString>;
+        proves: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    writablePaths: z.ZodArray<z.ZodString>;
+    sources: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const repositoryIntegrationPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    planDigest: z.ZodString;
+    generator: z.ZodObject<{
+        package: z.ZodLiteral<"@davidahmann/mill">;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    mode: z.ZodEnum<{
+        greenfield: "greenfield";
+        adoption: "adoption";
+    }>;
+    target: z.ZodObject<{
+        directoryName: z.ZodString;
+        canonicalPathDigest: z.ZodString;
+        baseCommit: z.ZodNullable<z.ZodString>;
+        scanDigest: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    productProposalDigest: z.ZodString;
+    productContractDigest: z.ZodString;
+    recipe: z.ZodObject<{
+        id: z.ZodLiteral<"node-typescript-next-web">;
+        version: z.ZodString;
+        digest: z.ZodString;
+        status: z.ZodLiteral<"supported">;
+        verifierImage: z.ZodString;
+    }, z.core.$strict>;
+    approval: z.ZodObject<{
+        approvedBy: z.ZodString;
+        approvedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        ownership: z.ZodEnum<{
+            mill_only: "mill_only";
+            generated_once: "generated_once";
+            managed: "managed";
+        }>;
+        action: z.ZodEnum<{
+            create: "create";
+            retain_identical: "retain_identical";
+        }>;
+        contentDigest: z.ZodString;
+        preexistingDigest: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    commandIds: z.ZodArray<z.ZodString>;
+    networkDisclosure: z.ZodArray<z.ZodString>;
+    baseline: z.ZodLiteral<"unverified">;
+}, z.core.$strict>;
+export declare const auditCategorySchema: z.ZodEnum<{
+    code: "code";
+    product: "product";
+    architecture: "architecture";
+    accessibility: "accessibility";
+    operations: "operations";
+    dependencies: "dependencies";
+    security: "security";
+    ux: "ux";
+    release: "release";
+}>;
+export declare const auditReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    candidate: z.ZodObject<{
+        commit: z.ZodString;
+        tree: z.ZodString;
+    }, z.core.$strict>;
+    generatedAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        passed: "passed";
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            product: "product";
+            architecture: "architecture";
+            accessibility: "accessibility";
+            operations: "operations";
+            dependencies: "dependencies";
+            security: "security";
+            ux: "ux";
+            release: "release";
+        }>;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+        }>;
+        summary: z.ZodString;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const supportTupleSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        experimental: "experimental";
+        qualified: "qualified";
+        expired: "expired";
+    }>;
+    testedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    host: z.ZodObject<{
+        os: z.ZodString;
+        architecture: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        node: z.ZodString;
+        npm: z.ZodString;
+    }, z.core.$strict>;
+    container: z.ZodObject<{
+        engine: z.ZodString;
+        version: z.ZodString;
+        verifierImage: z.ZodString;
+    }, z.core.$strict>;
+    worker: z.ZodObject<{
+        adapter: z.ZodLiteral<"codex-cli">;
+        harnessVersion: z.ZodString;
+        modelIdentity: z.ZodLiteral<"provider-mutable">;
+        authMode: z.ZodLiteral<"operator-session">;
+    }, z.core.$strict>;
+    forge: z.ZodObject<{
+        gitVersion: z.ZodString;
+        ghVersion: z.ZodString;
+        host: z.ZodLiteral<"github.com">;
+    }, z.core.$strict>;
+    recipe: z.ZodObject<{
+        id: z.ZodLiteral<"node-typescript-next-web">;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const publicAlphaQualificationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    package: z.ZodObject<{
+        name: z.ZodLiteral<"@davidahmann/mill">;
+        version: z.ZodString;
+        artifactDigest: z.ZodString;
+        npmIntegrity: z.ZodString;
+    }, z.core.$strict>;
+    supportTuple: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            experimental: "experimental";
+            qualified: "qualified";
+            expired: "expired";
+        }>;
+        testedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        host: z.ZodObject<{
+            os: z.ZodString;
+            architecture: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            npm: z.ZodString;
+        }, z.core.$strict>;
+        container: z.ZodObject<{
+            engine: z.ZodString;
+            version: z.ZodString;
+            verifierImage: z.ZodString;
+        }, z.core.$strict>;
+        worker: z.ZodObject<{
+            adapter: z.ZodLiteral<"codex-cli">;
+            harnessVersion: z.ZodString;
+            modelIdentity: z.ZodLiteral<"provider-mutable">;
+            authMode: z.ZodLiteral<"operator-session">;
+        }, z.core.$strict>;
+        forge: z.ZodObject<{
+            gitVersion: z.ZodString;
+            ghVersion: z.ZodString;
+            host: z.ZodLiteral<"github.com">;
+        }, z.core.$strict>;
+        recipe: z.ZodObject<{
+            id: z.ZodLiteral<"node-typescript-next-web">;
+            version: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    sequence: z.ZodObject<{
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            dependsOn: z.ZodArray<z.ZodString>;
+            baseCommit: z.ZodString;
+            candidateCommit: z.ZodString;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                blocked: "blocked";
+                accepted: "accepted";
+            }>;
+            newBehavior: z.ZodObject<{
+                requiredIds: z.ZodArray<z.ZodString>;
+                passedIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            preservation: z.ZodObject<{
+                requiredIds: z.ZodArray<z.ZodString>;
+                passedIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            scenarioIds: z.ZodArray<z.ZodString>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                currencyCost: z.ZodNullable<z.ZodNumber>;
+                source: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    "provider-measured": "provider-measured";
+                    "operator-declared": "operator-declared";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        seededFault: z.ZodObject<{
+            baseCommit: z.ZodString;
+            candidateCommit: z.ZodString;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            rejected: z.ZodBoolean;
+            recovered: z.ZodBoolean;
+            enteredAcceptedSequence: z.ZodBoolean;
+            reason: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    canaries: z.ZodObject<{
+        packedInstall: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        greenfield: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        adoption: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        downstreamWithoutMill: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        recovery: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        security: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+    }, z.core.$strict>;
+    auditCandidate: z.ZodObject<{
+        commit: z.ZodString;
+        tree: z.ZodString;
+    }, z.core.$strict>;
+    audits: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            code: "code";
+            product: "product";
+            architecture: "architecture";
+            accessibility: "accessibility";
+            operations: "operations";
+            dependencies: "dependencies";
+            security: "security";
+            ux: "ux";
+            release: "release";
+        }>;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        reportDigest: z.ZodString;
+    }, z.core.$strict>>;
+    generatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const releaseEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    state: z.ZodEnum<{
+        verified: "verified";
+        qualified: "qualified";
+        published: "published";
+    }>;
+    package: z.ZodObject<{
+        name: z.ZodLiteral<"@davidahmann/mill">;
+        version: z.ZodString;
+        tag: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        reviewedCandidateTree: z.ZodString;
+        resultingMainCommit: z.ZodString;
+        resultingMainTree: z.ZodString;
+        tagCommit: z.ZodString;
+    }, z.core.$strict>;
+    builders: z.ZodArray<z.ZodObject<{
+        builder: z.ZodString;
+        filename: z.ZodString;
+        sha256: z.ZodString;
+        npmIntegrity: z.ZodString;
+        contentsDigest: z.ZodString;
+    }, z.core.$strict>>;
+    selectedArtifact: z.ZodObject<{
+        builder: z.ZodString;
+        filename: z.ZodString;
+        sha256: z.ZodString;
+        npmIntegrity: z.ZodString;
+        contentsDigest: z.ZodString;
+    }, z.core.$strict>;
+    qualificationDigest: z.ZodString;
+    sbomDigest: z.ZodString;
+    registry: z.ZodNullable<z.ZodObject<{
+        tarball: z.ZodURL;
+        integrity: z.ZodString;
+        provenanceVerified: z.ZodBoolean;
+    }, z.core.$strict>>;
+    githubRelease: z.ZodNullable<z.ZodObject<{
+        url: z.ZodURL;
+        tag: z.ZodString;
+        artifactDigest: z.ZodString;
+    }, z.core.$strict>>;
+    generatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const contractSchemas: {
+    readonly auditReport: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        candidate: z.ZodObject<{
+            commit: z.ZodString;
+            tree: z.ZodString;
+        }, z.core.$strict>;
+        generatedAt: z.ZodISODateTime;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            passed: "passed";
+        }>;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodEnum<{
+                code: "code";
+                product: "product";
+                architecture: "architecture";
+                accessibility: "accessibility";
+                operations: "operations";
+                dependencies: "dependencies";
+                security: "security";
+                ux: "ux";
+                release: "release";
+            }>;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+            }>;
+            summary: z.ZodString;
+            evidence: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly blueprint: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodString;
+        productContractDigest: z.ZodString;
+        recipe: z.ZodString;
+        recipeVersion: z.ZodString;
+        runtime: z.ZodString;
+        architecture: z.ZodArray<z.ZodString>;
+        risks: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    readonly contextManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        taskDigest: z.ZodString;
+        baseCommit: z.ZodString;
+        provider: z.ZodLiteral<"openai">;
+        adapter: z.ZodLiteral<"codex-cli">;
+        authOwner: z.ZodLiteral<"operator">;
+        isolation: z.ZodLiteral<"attended-trusted-host">;
+        modelIdentity: z.ZodLiteral<"provider-mutable">;
+        included: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        excludedPatterns: z.ZodArray<z.ZodString>;
+        disclosure: z.ZodArray<z.ZodString>;
+        contextEpoch: z.ZodOptional<z.ZodString>;
+        effectiveInstructions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>>;
+        providerVisibleScope: z.ZodOptional<z.ZodObject<{
+            repositoryScope: z.ZodLiteral<"worktree">;
+            suppliedPaths: z.ZodArray<z.ZodString>;
+            writablePatterns: z.ZodArray<z.ZodString>;
+            observedReads: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly impactManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodString;
+        productContractDigest: z.ZodString;
+        outcomeId: z.ZodString;
+        riskClass: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+        }>;
+        acceptanceIds: z.ZodArray<z.ZodString>;
+        affectedInvariantIds: z.ZodArray<z.ZodString>;
+        uncertainInvariantIds: z.ZodArray<z.ZodString>;
+        surfaces: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                user: "user";
+                design: "design";
+                system: "system";
+                interface: "interface";
+                data: "data";
+                operations: "operations";
+            }>;
+            change: z.ZodString;
+        }, z.core.$strict>>;
+        scenarioIds: z.ZodArray<z.ZodString>;
+        commandIds: z.ZodArray<z.ZodString>;
+        materialDecisions: z.ZodArray<z.ZodString>;
+        unresolved: z.ZodArray<z.ZodString>;
+        exceptions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            scopeRefs: z.ZodArray<z.ZodString>;
+            reason: z.ZodString;
+            approvedBy: z.ZodString;
+            approvedAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        approval: z.ZodNullable<z.ZodObject<{
+            approvedBy: z.ZodString;
+            approvedAt: z.ZodISODateTime;
+            proposalDigest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly managedRepository: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodUUID;
+        forgeHost: z.ZodString;
+        owner: z.ZodString;
+        repository: z.ZodString;
+        canonicalBranch: z.ZodString;
+        remoteName: z.ZodString;
+        remoteUrl: z.ZodURL;
+        trustCeiling: z.ZodEnum<{
+            inspect: "inspect";
+            build: "build";
+            propose: "propose";
+        }>;
+    }, z.core.$strict>;
+    readonly millConfig: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        repositoryId: z.ZodUUID;
+        trustCeiling: z.ZodEnum<{
+            inspect: "inspect";
+            build: "build";
+            propose: "propose";
+        }>;
+        sensitivePaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        verifier: z.ZodOptional<z.ZodObject<{
+            image: z.ZodString;
+            network: z.ZodLiteral<"none">;
+            dependencies: z.ZodOptional<z.ZodObject<{
+                manager: z.ZodLiteral<"npm">;
+                registry: z.ZodLiteral<"https://registry.npmjs.org">;
+                targetPath: z.ZodLiteral<"node_modules">;
+                lockPaths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        propose: z.ZodOptional<z.ZodObject<{
+            forge: z.ZodLiteral<"github">;
+            host: z.ZodLiteral<"github.com">;
+            owner: z.ZodString;
+            repository: z.ZodString;
+            repositoryNodeId: z.ZodString;
+            remoteName: z.ZodString;
+            baseBranch: z.ZodString;
+            branchPrefix: z.ZodLiteral<"mill/">;
+            allowedActors: z.ZodArray<z.ZodString>;
+            allowedMergerLogins: z.ZodArray<z.ZodString>;
+            requiredChecks: z.ZodArray<z.ZodString>;
+            reviewPolicy: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    local_only: "local_only";
+                    github_required: "github_required";
+                }>;
+                requiredReviewerLogins: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            allowedMergeMethods: z.ZodArray<z.ZodEnum<{
+                merge: "merge";
+                linear_tree_preserving: "linear_tree_preserving";
+            }>>;
+            approvalTtlSeconds: z.ZodDefault<z.ZodNumber>;
+            pollTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        commands: z.ZodRecord<z.ZodString, z.ZodObject<{
+            argv: z.ZodArray<z.ZodString>;
+            cwd: z.ZodString;
+            controlPaths: z.ZodArray<z.ZodString>;
+            capability: z.ZodEnum<{
+                test: "test";
+                build: "build";
+                read: "read";
+                package: "package";
+            }>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+            execution: z.ZodDefault<z.ZodEnum<{
+                host: "host";
+                oci: "oci";
+            }>>;
+            writablePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly millLock: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        mill: z.ZodObject<{
+            package: z.ZodLiteral<"@davidahmann/mill">;
+            version: z.ZodString;
+            integrity: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        schemaDigests: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        recipe: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        integration: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                greenfield: "greenfield";
+                adoption: "adoption";
+            }>;
+            planDigest: z.ZodString;
+            baseCommit: z.ZodNullable<z.ZodString>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                ownership: z.ZodEnum<{
+                    mill_only: "mill_only";
+                    generated_once: "generated_once";
+                    managed: "managed";
+                }>;
+                templateDigest: z.ZodString;
+                installedDigest: z.ZodString;
+                preexistingDigest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly outcomePlan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        productContractDigest: z.ZodString;
+        outcomes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            acceptance: z.ZodArray<z.ZodString>;
+            acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dependsOn: z.ZodArray<z.ZodString>;
+            status: z.ZodEnum<{
+                proposed: "proposed";
+                approved: "approved";
+                ready: "ready";
+                blocked: "blocked";
+                closed: "closed";
+            }>;
+            taskRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly productContract: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodString;
+        title: z.ZodString;
+        primaryUser: z.ZodString;
+        jobToBeDone: z.ZodString;
+        outcomes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        nonGoals: z.ZodArray<z.ZodString>;
+        assumptions: z.ZodArray<z.ZodString>;
+        unknowns: z.ZodArray<z.ZodString>;
+        sourceRefs: z.ZodArray<z.ZodString>;
+        acceptance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                functional: "functional";
+                quality: "quality";
+                operational: "operational";
+            }>;
+            statement: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        invariants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            owner: z.ZodString;
+            criticality: z.ZodEnum<{
+                medium: "medium";
+                low: "low";
+                high: "high";
+                critical: "critical";
+            }>;
+            surfaceRefs: z.ZodArray<z.ZodString>;
+            verification: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    command: "command";
+                    human: "human";
+                    unsupported: "unsupported";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            unknowns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                product: "product";
+                architecture: "architecture";
+                design: "design";
+                accessibility: "accessibility";
+                research: "research";
+            }>;
+            question: z.ZodString;
+            decision: z.ZodString;
+            rationale: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                proposed: "proposed";
+                approved: "approved";
+            }>;
+            costlyToReverse: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    readonly recipeManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        id: z.ZodLiteral<"node-typescript-next-web">;
+        version: z.ZodString;
+        status: z.ZodEnum<{
+            unsupported: "unsupported";
+            supported: "supported";
+            experimental: "experimental";
+        }>;
+        observedAt: z.ZodISODateTime;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            npm: z.ZodString;
+        }, z.core.$strict>;
+        stack: z.ZodObject<{
+            next: z.ZodString;
+            react: z.ZodString;
+            reactDom: z.ZodString;
+            typescript: z.ZodString;
+            eslint: z.ZodString;
+            prettier: z.ZodString;
+            vitest: z.ZodString;
+            playwright: z.ZodString;
+        }, z.core.$strict>;
+        verifierImage: z.ZodString;
+        registry: z.ZodURL;
+        licensePolicy: z.ZodObject<{
+            allowed: z.ZodArray<z.ZodString>;
+            reviewedPackages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                license: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        commands: z.ZodObject<{
+            required: z.ZodArray<z.ZodString>;
+            native: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        oracles: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            commandId: z.ZodString;
+            evidencePaths: z.ZodArray<z.ZodString>;
+            proves: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        writablePaths: z.ZodArray<z.ZodString>;
+        sources: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>;
+    readonly releaseEvidence: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        state: z.ZodEnum<{
+            verified: "verified";
+            qualified: "qualified";
+            published: "published";
+        }>;
+        package: z.ZodObject<{
+            name: z.ZodLiteral<"@davidahmann/mill">;
+            version: z.ZodString;
+            tag: z.ZodString;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            reviewedCandidateTree: z.ZodString;
+            resultingMainCommit: z.ZodString;
+            resultingMainTree: z.ZodString;
+            tagCommit: z.ZodString;
+        }, z.core.$strict>;
+        builders: z.ZodArray<z.ZodObject<{
+            builder: z.ZodString;
+            filename: z.ZodString;
+            sha256: z.ZodString;
+            npmIntegrity: z.ZodString;
+            contentsDigest: z.ZodString;
+        }, z.core.$strict>>;
+        selectedArtifact: z.ZodObject<{
+            builder: z.ZodString;
+            filename: z.ZodString;
+            sha256: z.ZodString;
+            npmIntegrity: z.ZodString;
+            contentsDigest: z.ZodString;
+        }, z.core.$strict>;
+        qualificationDigest: z.ZodString;
+        sbomDigest: z.ZodString;
+        registry: z.ZodNullable<z.ZodObject<{
+            tarball: z.ZodURL;
+            integrity: z.ZodString;
+            provenanceVerified: z.ZodBoolean;
+        }, z.core.$strict>>;
+        githubRelease: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            tag: z.ZodString;
+            artifactDigest: z.ZodString;
+        }, z.core.$strict>>;
+        generatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    readonly repositoryIntegrationPlan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        planDigest: z.ZodString;
+        generator: z.ZodObject<{
+            package: z.ZodLiteral<"@davidahmann/mill">;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        mode: z.ZodEnum<{
+            greenfield: "greenfield";
+            adoption: "adoption";
+        }>;
+        target: z.ZodObject<{
+            directoryName: z.ZodString;
+            canonicalPathDigest: z.ZodString;
+            baseCommit: z.ZodNullable<z.ZodString>;
+            scanDigest: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        productProposalDigest: z.ZodString;
+        productContractDigest: z.ZodString;
+        recipe: z.ZodObject<{
+            id: z.ZodLiteral<"node-typescript-next-web">;
+            version: z.ZodString;
+            digest: z.ZodString;
+            status: z.ZodLiteral<"supported">;
+            verifierImage: z.ZodString;
+        }, z.core.$strict>;
+        approval: z.ZodObject<{
+            approvedBy: z.ZodString;
+            approvedAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            ownership: z.ZodEnum<{
+                mill_only: "mill_only";
+                generated_once: "generated_once";
+                managed: "managed";
+            }>;
+            action: z.ZodEnum<{
+                create: "create";
+                retain_identical: "retain_identical";
+            }>;
+            contentDigest: z.ZodString;
+            preexistingDigest: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        commandIds: z.ZodArray<z.ZodString>;
+        networkDisclosure: z.ZodArray<z.ZodString>;
+        baseline: z.ZodLiteral<"unverified">;
+    }, z.core.$strict>;
+    readonly reviewResult: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        candidateCommit: z.ZodString;
+        summary: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            severity: z.ZodEnum<{
+                P0: "P0";
+                P1: "P1";
+                P2: "P2";
+                P3: "P3";
+            }>;
+            class: z.ZodEnum<{
+                style: "style";
+                authority: "authority";
+                correctness: "correctness";
+                security: "security";
+                "data-loss": "data-loss";
+                provenance: "provenance";
+                compatibility: "compatibility";
+                maintainability: "maintainability";
+            }>;
+            title: z.ZodString;
+            body: z.ZodString;
+            file: z.ZodNullable<z.ZodString>;
+            line: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly scenarioSet: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        productContractDigest: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                authority: "authority";
+                normal: "normal";
+                exception: "exception";
+                degradation: "degradation";
+                recovery: "recovery";
+                adversarial: "adversarial";
+            }>;
+            given: z.ZodArray<z.ZodString>;
+            when: z.ZodArray<z.ZodString>;
+            then: z.ZodArray<z.ZodString>;
+            oracleOwner: z.ZodEnum<{
+                external: "external";
+                repository: "repository";
+                human: "human";
+            }>;
+            acceptanceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            invariantRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            coverage: z.ZodDefault<z.ZodEnum<{
+                new_behavior: "new_behavior";
+                preservation: "preservation";
+                both: "both";
+            }>>;
+            visibility: z.ZodDefault<z.ZodEnum<{
+                builder_visible: "builder_visible";
+                reviewer_owned: "reviewer_owned";
+                human_acceptance: "human_acceptance";
+            }>>;
+            executionRef: z.ZodOptional<z.ZodString>;
+            recipeOracle: z.ZodOptional<z.ZodString>;
+            forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly sourceManifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        trigger: z.ZodEnum<{
+            bootstrap: "bootstrap";
+            adoption_uncertainty: "adoption_uncertainty";
+            approved_stack_change: "approved_stack_change";
+        }>;
+        providers: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            queries: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                purpose: z.ZodString;
+            }, z.core.$strict>>;
+            networkDisclosure: z.ZodString;
+        }, z.core.$strict>>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            class: z.ZodEnum<{
+                primary_documentation: "primary_documentation";
+                official_registry: "official_registry";
+                security_advisory: "security_advisory";
+                license: "license";
+                repository: "repository";
+                user_evidence: "user_evidence";
+                operator_constraint: "operator_constraint";
+            }>;
+            uri: z.ZodString;
+            revision: z.ZodString;
+            observedAt: z.ZodISODateTime;
+            freshness: z.ZodEnum<{
+                unknown: "unknown";
+                current: "current";
+                stale: "stale";
+            }>;
+            authority: z.ZodEnum<{
+                evidence: "evidence";
+                constraint: "constraint";
+                approved_decision: "approved_decision";
+            }>;
+            digest: z.ZodOptional<z.ZodString>;
+            claims: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly supportTuple: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            experimental: "experimental";
+            qualified: "qualified";
+            expired: "expired";
+        }>;
+        testedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        host: z.ZodObject<{
+            os: z.ZodString;
+            architecture: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            npm: z.ZodString;
+        }, z.core.$strict>;
+        container: z.ZodObject<{
+            engine: z.ZodString;
+            version: z.ZodString;
+            verifierImage: z.ZodString;
+        }, z.core.$strict>;
+        worker: z.ZodObject<{
+            adapter: z.ZodLiteral<"codex-cli">;
+            harnessVersion: z.ZodString;
+            modelIdentity: z.ZodLiteral<"provider-mutable">;
+            authMode: z.ZodLiteral<"operator-session">;
+        }, z.core.$strict>;
+        forge: z.ZodObject<{
+            gitVersion: z.ZodString;
+            ghVersion: z.ZodString;
+            host: z.ZodLiteral<"github.com">;
+        }, z.core.$strict>;
+        recipe: z.ZodObject<{
+            id: z.ZodLiteral<"node-typescript-next-web">;
+            version: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly specificationProposal: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        prd: z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        sourceManifestDigest: z.ZodString;
+        productContract: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            id: z.ZodString;
+            title: z.ZodString;
+            primaryUser: z.ZodString;
+            jobToBeDone: z.ZodString;
+            outcomes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                statement: z.ZodString;
+                acceptanceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            nonGoals: z.ZodArray<z.ZodString>;
+            assumptions: z.ZodArray<z.ZodString>;
+            unknowns: z.ZodArray<z.ZodString>;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            acceptance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    functional: "functional";
+                    quality: "quality";
+                    operational: "operational";
+                }>;
+                statement: z.ZodString;
+                sourceRefs: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            invariants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                statement: z.ZodString;
+                owner: z.ZodString;
+                criticality: z.ZodEnum<{
+                    medium: "medium";
+                    low: "low";
+                    high: "high";
+                    critical: "critical";
+                }>;
+                surfaceRefs: z.ZodArray<z.ZodString>;
+                verification: z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        command: "command";
+                        human: "human";
+                        unsupported: "unsupported";
+                    }>;
+                    ref: z.ZodString;
+                }, z.core.$strict>;
+                sourceRefs: z.ZodArray<z.ZodString>;
+                unknowns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    product: "product";
+                    architecture: "architecture";
+                    design: "design";
+                    accessibility: "accessibility";
+                    research: "research";
+                }>;
+                question: z.ZodString;
+                decision: z.ZodString;
+                rationale: z.ZodString;
+                sourceRefs: z.ZodArray<z.ZodString>;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    proposed: "proposed";
+                    approved: "approved";
+                }>;
+                costlyToReverse: z.ZodBoolean;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        blueprints: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            id: z.ZodString;
+            productContractDigest: z.ZodString;
+            recipe: z.ZodString;
+            recipeVersion: z.ZodString;
+            runtime: z.ZodString;
+            architecture: z.ZodArray<z.ZodString>;
+            risks: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        scenarioSet: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            productContractDigest: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    authority: "authority";
+                    normal: "normal";
+                    exception: "exception";
+                    degradation: "degradation";
+                    recovery: "recovery";
+                    adversarial: "adversarial";
+                }>;
+                given: z.ZodArray<z.ZodString>;
+                when: z.ZodArray<z.ZodString>;
+                then: z.ZodArray<z.ZodString>;
+                oracleOwner: z.ZodEnum<{
+                    external: "external";
+                    repository: "repository";
+                    human: "human";
+                }>;
+                acceptanceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                invariantRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                coverage: z.ZodDefault<z.ZodEnum<{
+                    new_behavior: "new_behavior";
+                    preservation: "preservation";
+                    both: "both";
+                }>>;
+                visibility: z.ZodDefault<z.ZodEnum<{
+                    builder_visible: "builder_visible";
+                    reviewer_owned: "reviewer_owned";
+                    human_acceptance: "human_acceptance";
+                }>>;
+                executionRef: z.ZodOptional<z.ZodString>;
+                recipeOracle: z.ZodOptional<z.ZodString>;
+                forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        assumptions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        contradictions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            sourceRefs: z.ZodArray<z.ZodString>;
+            blocking: z.ZodBoolean;
+        }, z.core.$strict>>;
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            recommendedDefault: z.ZodString;
+            reversible: z.ZodBoolean;
+            blocking: z.ZodBoolean;
+        }, z.core.$strict>>;
+        status: z.ZodLiteral<"proposed">;
+    }, z.core.$strict>;
+    readonly taskPacket: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        authority: z.ZodObject<{
+            productContract: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            scenarioSet: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            policy: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        acceptance: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        title: z.ZodString;
+        objective: z.ZodString;
+        riskClass: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+        }>;
+        baseRef: z.ZodString;
+        contextPaths: z.ZodArray<z.ZodString>;
+        allowedPaths: z.ZodArray<z.ZodString>;
+        commandIds: z.ZodArray<z.ZodString>;
+        commit: z.ZodObject<{
+            message: z.ZodString;
+            authorName: z.ZodString;
+            authorEmail: z.ZodEmail;
+        }, z.core.$strict>;
+        budget: z.ZodObject<{
+            deadlineSeconds: z.ZodNumber;
+            maxOutputBytes: z.ZodNumber;
+            retryCount: z.ZodNumber;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"1">;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodObject<{
+            productContract: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            scenarioSet: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            policy: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+            impactManifest: z.ZodObject<{
+                path: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        attestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            approvedBy: z.ZodString;
+            approvedAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            claims: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    acceptance: "acceptance";
+                    invariant: "invariant";
+                    scenario: "scenario";
+                }>;
+                id: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        acceptance: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            invariantIds: z.ZodArray<z.ZodString>;
+            scenarioIds: z.ZodArray<z.ZodString>;
+            coverage: z.ZodEnum<{
+                new_behavior: "new_behavior";
+                preservation: "preservation";
+                both: "both";
+            }>;
+            evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"command">;
+                commandId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"human">;
+                attestationId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"unsupported">;
+                reason: z.ZodString;
+            }, z.core.$strict>], "mode">;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        title: z.ZodString;
+        objective: z.ZodString;
+        riskClass: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+        }>;
+        baseRef: z.ZodString;
+        contextPaths: z.ZodArray<z.ZodString>;
+        allowedPaths: z.ZodArray<z.ZodString>;
+        commandIds: z.ZodArray<z.ZodString>;
+        commit: z.ZodObject<{
+            message: z.ZodString;
+            authorName: z.ZodString;
+            authorEmail: z.ZodEmail;
+        }, z.core.$strict>;
+        budget: z.ZodObject<{
+            deadlineSeconds: z.ZodNumber;
+            maxOutputBytes: z.ZodNumber;
+            retryCount: z.ZodNumber;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"2">;
+    }, z.core.$strict>], "schemaVersion">;
+    readonly validationEvidence: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        candidateCommit: z.ZodString;
+        verifierImage: z.ZodString;
+        network: z.ZodLiteral<"none">;
+        commands: z.ZodArray<z.ZodObject<{
+            commandId: z.ZodString;
+            required: z.ZodBoolean;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNumber;
+            outputDigest: z.ZodString;
+            reason: z.ZodOptional<z.ZodEnum<{
+                HOST_EXECUTION_NOT_QUALIFIED: "HOST_EXECUTION_NOT_QUALIFIED";
+                CANCELLED: "CANCELLED";
+                DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED";
+                OUTPUT_BUDGET_EXCEEDED: "OUTPUT_BUDGET_EXCEEDED";
+                NONZERO_EXIT: "NONZERO_EXIT";
+            }>>;
+        }, z.core.$strict>>;
+        semantic: z.ZodOptional<z.ZodObject<{
+            impactManifestDigest: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    acceptance: "acceptance";
+                    invariant: "invariant";
+                    scenario: "scenario";
+                }>;
+                id: z.ZodString;
+                coverage: z.ZodEnum<{
+                    new_behavior: "new_behavior";
+                    preservation: "preservation";
+                    both: "both";
+                }>;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    passed: "passed";
+                    attested: "attested";
+                }>;
+                evidenceRefs: z.ZodArray<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            newBehaviorPassed: z.ZodBoolean;
+            preservationPassed: z.ZodBoolean;
+            passed: z.ZodBoolean;
+        }, z.core.$strict>>;
+        passed: z.ZodBoolean;
+    }, z.core.$strict>;
+    readonly publicAlphaQualification: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        package: z.ZodObject<{
+            name: z.ZodLiteral<"@davidahmann/mill">;
+            version: z.ZodString;
+            artifactDigest: z.ZodString;
+            npmIntegrity: z.ZodString;
+        }, z.core.$strict>;
+        supportTuple: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                experimental: "experimental";
+                qualified: "qualified";
+                expired: "expired";
+            }>;
+            testedAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            host: z.ZodObject<{
+                os: z.ZodString;
+                architecture: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                node: z.ZodString;
+                npm: z.ZodString;
+            }, z.core.$strict>;
+            container: z.ZodObject<{
+                engine: z.ZodString;
+                version: z.ZodString;
+                verifierImage: z.ZodString;
+            }, z.core.$strict>;
+            worker: z.ZodObject<{
+                adapter: z.ZodLiteral<"codex-cli">;
+                harnessVersion: z.ZodString;
+                modelIdentity: z.ZodLiteral<"provider-mutable">;
+                authMode: z.ZodLiteral<"operator-session">;
+            }, z.core.$strict>;
+            forge: z.ZodObject<{
+                gitVersion: z.ZodString;
+                ghVersion: z.ZodString;
+                host: z.ZodLiteral<"github.com">;
+            }, z.core.$strict>;
+            recipe: z.ZodObject<{
+                id: z.ZodLiteral<"node-typescript-next-web">;
+                version: z.ZodString;
+                digest: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        sequence: z.ZodObject<{
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                dependsOn: z.ZodArray<z.ZodString>;
+                baseCommit: z.ZodString;
+                candidateCommit: z.ZodString;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    blocked: "blocked";
+                    accepted: "accepted";
+                }>;
+                newBehavior: z.ZodObject<{
+                    requiredIds: z.ZodArray<z.ZodString>;
+                    passedIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                preservation: z.ZodObject<{
+                    requiredIds: z.ZodArray<z.ZodString>;
+                    passedIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                scenarioIds: z.ZodArray<z.ZodString>;
+                usage: z.ZodObject<{
+                    inputTokens: z.ZodNullable<z.ZodNumber>;
+                    outputTokens: z.ZodNullable<z.ZodNumber>;
+                    currencyCost: z.ZodNullable<z.ZodNumber>;
+                    source: z.ZodEnum<{
+                        unavailable: "unavailable";
+                        "provider-measured": "provider-measured";
+                        "operator-declared": "operator-declared";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            seededFault: z.ZodObject<{
+                baseCommit: z.ZodString;
+                candidateCommit: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    passed: "passed";
+                    failed: "failed";
+                    skipped: "skipped";
+                }>;
+                rejected: z.ZodBoolean;
+                recovered: z.ZodBoolean;
+                enteredAcceptedSequence: z.ZodBoolean;
+                reason: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        canaries: z.ZodObject<{
+            packedInstall: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            greenfield: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            adoption: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            downstreamWithoutMill: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            recovery: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            security: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+        }, z.core.$strict>;
+        auditCandidate: z.ZodObject<{
+            commit: z.ZodString;
+            tree: z.ZodString;
+        }, z.core.$strict>;
+        audits: z.ZodArray<z.ZodObject<{
+            category: z.ZodEnum<{
+                code: "code";
+                product: "product";
+                architecture: "architecture";
+                accessibility: "accessibility";
+                operations: "operations";
+                dependencies: "dependencies";
+                security: "security";
+                ux: "ux";
+                release: "release";
+            }>;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            reportDigest: z.ZodString;
+        }, z.core.$strict>>;
+        generatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    readonly workerInvocation: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        invocationId: z.ZodUUID;
+        runId: z.ZodUUID;
+        phase: z.ZodEnum<{
+            build: "build";
+            repair: "repair";
+            review: "review";
+        }>;
+        attempt: z.ZodNumber;
+        taskDigest: z.ZodString;
+        contextEpoch: z.ZodString;
+        baseCommit: z.ZodString;
+        candidateCommit: z.ZodOptional<z.ZodString>;
+        impactManifestDigest: z.ZodOptional<z.ZodString>;
+        profile: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1">;
+            adapter: z.ZodLiteral<"codex-cli">;
+            role: z.ZodEnum<{
+                planner: "planner";
+                builder: "builder";
+                reviewer: "reviewer";
+            }>;
+            contractVersion: z.ZodLiteral<"1">;
+            harnessVersion: z.ZodString;
+            promptTemplateDigest: z.ZodString;
+            modelIdentity: z.ZodLiteral<"provider-mutable">;
+            approvalPolicy: z.ZodLiteral<"never">;
+            sandbox: z.ZodEnum<{
+                "read-only": "read-only";
+                "workspace-write": "workspace-write";
+            }>;
+            session: z.ZodLiteral<"ephemeral">;
+            hostRules: z.ZodLiteral<"ignored">;
+            skillDiscovery: z.ZodLiteral<"disabled">;
+            toolDiscovery: z.ZodLiteral<"disabled">;
+            networkPosture: z.ZodEnum<{
+                unknown: "unknown";
+                "provider-managed": "provider-managed";
+            }>;
+            capabilities: z.ZodArray<z.ZodString>;
+            outputContract: z.ZodString;
+        }, z.core.$strict>;
+        profileDigest: z.ZodString;
+        allowedPaths: z.ZodArray<z.ZodString>;
+        deadlineAt: z.ZodISODateTime;
+        maxOutputBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    readonly workerProfile: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        adapter: z.ZodLiteral<"codex-cli">;
+        role: z.ZodEnum<{
+            planner: "planner";
+            builder: "builder";
+            reviewer: "reviewer";
+        }>;
+        contractVersion: z.ZodLiteral<"1">;
+        harnessVersion: z.ZodString;
+        promptTemplateDigest: z.ZodString;
+        modelIdentity: z.ZodLiteral<"provider-mutable">;
+        approvalPolicy: z.ZodLiteral<"never">;
+        sandbox: z.ZodEnum<{
+            "read-only": "read-only";
+            "workspace-write": "workspace-write";
+        }>;
+        session: z.ZodLiteral<"ephemeral">;
+        hostRules: z.ZodLiteral<"ignored">;
+        skillDiscovery: z.ZodLiteral<"disabled">;
+        toolDiscovery: z.ZodLiteral<"disabled">;
+        networkPosture: z.ZodEnum<{
+            unknown: "unknown";
+            "provider-managed": "provider-managed";
+        }>;
+        capabilities: z.ZodArray<z.ZodString>;
+        outputContract: z.ZodString;
+    }, z.core.$strict>;
+    readonly deliveryRecord: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        runId: z.ZodUUID;
+        deliveryKey: z.ZodString;
+        proposalDigest: z.ZodString;
+        approvalExpiresAt: z.ZodISODateTime;
+        state: z.ZodEnum<{
+            blocked: "blocked";
+            closed: "closed";
+            effect_unknown: "effect_unknown";
+            planned: "planned";
+            proposing: "proposing";
+            awaiting_ci: "awaiting_ci";
+            awaiting_human: "awaiting_human";
+            merged: "merged";
+            post_merge_verified: "post_merge_verified";
+            cancelled: "cancelled";
+        }>;
+        target: z.ZodObject<{
+            forge: z.ZodLiteral<"github">;
+            host: z.ZodLiteral<"github.com">;
+            owner: z.ZodString;
+            repository: z.ZodString;
+            repositoryNodeId: z.ZodString;
+            cloneUrl: z.ZodURL;
+            remoteName: z.ZodString;
+            baseBranch: z.ZodString;
+            actorLogin: z.ZodString;
+            actorId: z.ZodNumber;
+        }, z.core.$strict>;
+        branchName: z.ZodString;
+        candidateCommit: z.ZodString;
+        candidateTree: z.ZodString;
+        requiredChecks: z.ZodArray<z.ZodString>;
+        reviewPolicy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                local_only: "local_only";
+                github_required: "github_required";
+            }>;
+            requiredReviewerLogins: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        allowedMergerLogins: z.ZodArray<z.ZodString>;
+        allowedMergeMethods: z.ZodArray<z.ZodEnum<{
+            merge: "merge";
+            linear_tree_preserving: "linear_tree_preserving";
+        }>>;
+        effects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                push: "push";
+                pull_request: "pull_request";
+            }>;
+            candidateCommit: z.ZodString;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                intent: "intent";
+                call_started: "call_started";
+                effect_unknown: "effect_unknown";
+                retryable_absent: "retryable_absent";
+                verified: "verified";
+            }>;
+            attemptCount: z.ZodNumber;
+            expectedOldCommit: z.ZodNullable<z.ZodString>;
+            errorCode: z.ZodNullable<z.ZodString>;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        remoteHeadCommit: z.ZodNullable<z.ZodString>;
+        pullRequest: z.ZodNullable<z.ZodObject<{
+            number: z.ZodNumber;
+            nodeId: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+        observation: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        merge: z.ZodNullable<z.ZodObject<{
+            commit: z.ZodString;
+            tree: z.ZodString;
+            method: z.ZodEnum<{
+                merge: "merge";
+                linear_tree_preserving: "linear_tree_preserving";
+            }>;
+            mergedByLogin: z.ZodString;
+            mergedAt: z.ZodISODateTime;
+            defaultBranchHead: z.ZodString;
+        }, z.core.$strict>>;
+        lastErrorCode: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+};
+export type ContractKind = keyof typeof contractSchemas;
+//# sourceMappingURL=schemas.d.ts.map