tracegrove 0.0.0-stage → 0.3.1

package/dist/protocol/schemas/execution.d.ts

@@ -0,0 +1,3179 @@
+/**
+ * Execution-time records: frozen planning outputs, runtime bindings and sealed results.
+ * These never embed their consuming receipt; requests reference admissions, never results.
+ */
+import { z } from 'zod';
+export declare const RepositoryOrigin: z.ZodEnum<{
+    remote_object: "remote_object";
+    snapshot_bundle: "snapshot_bundle";
+}>;
+export declare const SourceSelection: z.ZodObject<{
+    draftRevision: z.ZodNumber;
+    strategy: z.ZodEnum<{
+        pr_base: "pr_base";
+        merge_base: "merge_base";
+        commit_pair: "commit_pair";
+        deployed_baseline: "deployed_baseline";
+        head_only: "head_only";
+    }>;
+    repositories: z.ZodArray<z.ZodObject<{
+        repositoryRole: z.ZodString;
+        canonicalUrl: z.ZodString;
+        requestedExpression: z.ZodString;
+        headCommit: z.ZodString;
+        baseCommit: z.ZodNullable<z.ZodString>;
+        origin: z.ZodEnum<{
+            remote_object: "remote_object";
+            snapshot_bundle: "snapshot_bundle";
+        }>;
+        sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        lockfileDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        resolvedAt: z.ZodString;
+        resolverRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    excludedRoles: z.ZodArray<z.ZodObject<{
+        repositoryRole: z.ZodString;
+        reasonRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    compatibilityRuleRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    revisionMatrixRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<"workflow.source-selection/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SourceSelection = z.infer<typeof SourceSelection>;
+export declare const TargetComponent: z.ZodObject<{
+    componentId: z.ZodString;
+    kind: z.ZodEnum<{
+        schema: "schema";
+        application: "application";
+        service: "service";
+        worker: "worker";
+        flag_set: "flag_set";
+        protocol_server: "protocol_server";
+        host: "host";
+        widget: "widget";
+        mobile_binary: "mobile_binary";
+        device_runtime: "device_runtime";
+        model_endpoint: "model_endpoint";
+        other: "other";
+    }>;
+    identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"source_digest">;
+        sourceDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"declared_release">;
+        release: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export declare const TargetTuple: z.ZodObject<{
+    componentProfileRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    requiredComponents: z.ZodArray<z.ZodString>;
+    excludedComponents: z.ZodArray<z.ZodObject<{
+        component: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    components: z.ZodArray<z.ZodObject<{
+        componentId: z.ZodString;
+        kind: z.ZodEnum<{
+            schema: "schema";
+            application: "application";
+            service: "service";
+            worker: "worker";
+            flag_set: "flag_set";
+            protocol_server: "protocol_server";
+            host: "host";
+            widget: "widget";
+            mobile_binary: "mobile_binary";
+            device_runtime: "device_runtime";
+            model_endpoint: "model_endpoint";
+            other: "other";
+        }>;
+        identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"source_digest">;
+            sourceDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"declared_release">;
+            release: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    repositories: z.ZodArray<z.ZodObject<{
+        repositoryRole: z.ZodString;
+        canonicalUrl: z.ZodString;
+        requestedRef: z.ZodString;
+        resolvedCommit: z.ZodString;
+        origin: z.ZodEnum<{
+            remote_object: "remote_object";
+            snapshot_bundle: "snapshot_bundle";
+        }>;
+        sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        lockfileDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        dirty: z.ZodLiteral<false>;
+    }, z.core.$strict>>;
+    corpus: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    runner: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    evaluator: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    frontendRelease: z.ZodNullable<z.ZodString>;
+    backendRelease: z.ZodNullable<z.ZodString>;
+    workerRelease: z.ZodNullable<z.ZodString>;
+    schemaFingerprint: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    browserVersion: z.ZodNullable<z.ZodString>;
+    containerImageDigest: z.ZodNullable<z.ZodString>;
+    modelConfigDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TargetTuple = z.infer<typeof TargetTuple>;
+export declare const Provenance: z.ZodObject<{
+    runtime: z.ZodEnum<{
+        live: "live";
+        replay: "replay";
+        mocked: "mocked";
+    }>;
+    data: z.ZodEnum<{
+        designated_production: "designated_production";
+        mocked: "mocked";
+        seeded_real: "seeded_real";
+        sanitized_real: "sanitized_real";
+    }>;
+    provider: z.ZodEnum<{
+        none: "none";
+        live: "live";
+        replay: "replay";
+        mocked: "mocked";
+    }>;
+    faults: z.ZodEnum<{
+        none: "none";
+        controlled: "controlled";
+    }>;
+    interceptors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    injectedFaults: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Provenance = z.infer<typeof Provenance>;
+export declare const SelectionCell: z.ZodObject<{
+    selectionCellId: z.ZodString;
+    required: z.ZodBoolean;
+    caseRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    personaRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    surfaceBindingRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    variantRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    sourceSelectionRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    environmentRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    expectedTarget: z.ZodObject<{
+        componentProfileRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        requiredComponents: z.ZodArray<z.ZodString>;
+        excludedComponents: z.ZodArray<z.ZodObject<{
+            component: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodObject<{
+            componentId: z.ZodString;
+            kind: z.ZodEnum<{
+                schema: "schema";
+                application: "application";
+                service: "service";
+                worker: "worker";
+                flag_set: "flag_set";
+                protocol_server: "protocol_server";
+                host: "host";
+                widget: "widget";
+                mobile_binary: "mobile_binary";
+                device_runtime: "device_runtime";
+                model_endpoint: "model_endpoint";
+                other: "other";
+            }>;
+            identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"source_digest">;
+                sourceDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"declared_release">;
+                release: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repositoryRole: z.ZodString;
+            canonicalUrl: z.ZodString;
+            requestedRef: z.ZodString;
+            resolvedCommit: z.ZodString;
+            origin: z.ZodEnum<{
+                remote_object: "remote_object";
+                snapshot_bundle: "snapshot_bundle";
+            }>;
+            sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            lockfileDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            dirty: z.ZodLiteral<false>;
+        }, z.core.$strict>>;
+        corpus: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        runner: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        evaluator: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        frontendRelease: z.ZodNullable<z.ZodString>;
+        backendRelease: z.ZodNullable<z.ZodString>;
+        workerRelease: z.ZodNullable<z.ZodString>;
+        schemaFingerprint: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        browserVersion: z.ZodNullable<z.ZodString>;
+        containerImageDigest: z.ZodNullable<z.ZodString>;
+        modelConfigDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    executionHostRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const SelectionManifest: z.ZodObject<{
+    policyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    cells: z.ZodArray<z.ZodObject<{
+        selectionCellId: z.ZodString;
+        required: z.ZodBoolean;
+        caseRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        personaRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        surfaceBindingRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        variantRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        sourceSelectionRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        environmentRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        expectedTarget: z.ZodObject<{
+            componentProfileRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            requiredComponents: z.ZodArray<z.ZodString>;
+            excludedComponents: z.ZodArray<z.ZodObject<{
+                component: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+            components: z.ZodArray<z.ZodObject<{
+                componentId: z.ZodString;
+                kind: z.ZodEnum<{
+                    schema: "schema";
+                    application: "application";
+                    service: "service";
+                    worker: "worker";
+                    flag_set: "flag_set";
+                    protocol_server: "protocol_server";
+                    host: "host";
+                    widget: "widget";
+                    mobile_binary: "mobile_binary";
+                    device_runtime: "device_runtime";
+                    model_endpoint: "model_endpoint";
+                    other: "other";
+                }>;
+                identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"source_digest">;
+                    sourceDigest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                    runtime: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"declared_release">;
+                    release: z.ZodString;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            repositories: z.ZodArray<z.ZodObject<{
+                repositoryRole: z.ZodString;
+                canonicalUrl: z.ZodString;
+                requestedRef: z.ZodString;
+                resolvedCommit: z.ZodString;
+                origin: z.ZodEnum<{
+                    remote_object: "remote_object";
+                    snapshot_bundle: "snapshot_bundle";
+                }>;
+                sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodString;
+                    digest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                lockfileDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                dirty: z.ZodLiteral<false>;
+            }, z.core.$strict>>;
+            corpus: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            runner: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            frontendRelease: z.ZodNullable<z.ZodString>;
+            backendRelease: z.ZodNullable<z.ZodString>;
+            workerRelease: z.ZodNullable<z.ZodString>;
+            schemaFingerprint: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            browserVersion: z.ZodNullable<z.ZodString>;
+            containerImageDigest: z.ZodNullable<z.ZodString>;
+            modelConfigDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        executionHostRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    excludedCells: z.ZodArray<z.ZodObject<{
+        cellKey: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<"workflow.selection/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SelectionManifest = z.infer<typeof SelectionManifest>;
+export declare const RunRequest: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"workflow.request/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    clientRequestId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestedScope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+    campaignId: z.ZodString;
+    purpose: z.ZodEnum<{
+        trial: "trial";
+        work_proof: "work_proof";
+        qualification: "qualification";
+        regression: "regression";
+    }>;
+    sourcePlanRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    reviewRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    scenarioRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    qualificationRoundRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    effectiveConfigRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    sourceSelectionRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    executionHostRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    intelligencePolicyRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    fidelityPlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    fixturePlanRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    caseRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    personaRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    environmentRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    expectedTarget: z.ZodNullable<z.ZodObject<{
+        componentProfileRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        requiredComponents: z.ZodArray<z.ZodString>;
+        excludedComponents: z.ZodArray<z.ZodObject<{
+            component: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodObject<{
+            componentId: z.ZodString;
+            kind: z.ZodEnum<{
+                schema: "schema";
+                application: "application";
+                service: "service";
+                worker: "worker";
+                flag_set: "flag_set";
+                protocol_server: "protocol_server";
+                host: "host";
+                widget: "widget";
+                mobile_binary: "mobile_binary";
+                device_runtime: "device_runtime";
+                model_endpoint: "model_endpoint";
+                other: "other";
+            }>;
+            identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"source_digest">;
+                sourceDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"declared_release">;
+                release: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repositoryRole: z.ZodString;
+            canonicalUrl: z.ZodString;
+            requestedRef: z.ZodString;
+            resolvedCommit: z.ZodString;
+            origin: z.ZodEnum<{
+                remote_object: "remote_object";
+                snapshot_bundle: "snapshot_bundle";
+            }>;
+            sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            lockfileDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            dirty: z.ZodLiteral<false>;
+        }, z.core.$strict>>;
+        corpus: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        runner: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        evaluator: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        frontendRelease: z.ZodNullable<z.ZodString>;
+        backendRelease: z.ZodNullable<z.ZodString>;
+        workerRelease: z.ZodNullable<z.ZodString>;
+        schemaFingerprint: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        browserVersion: z.ZodNullable<z.ZodString>;
+        containerImageDigest: z.ZodNullable<z.ZodString>;
+        modelConfigDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    selectionManifestRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    workBinding: z.ZodNullable<z.ZodObject<{
+        workId: z.ZodString;
+        requirementRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        deadlineMs: z.ZodNumber;
+        maxProviderRequests: z.ZodNumber;
+        maxTokens: z.ZodNumber;
+        costCeilingCents: z.ZodNumber;
+        maxBrowserActions: z.ZodNumber;
+        maxArtifactBytes: z.ZodNumber;
+        diagnosticRetries: z.ZodNumber;
+        concurrencyGroup: z.ZodString;
+    }, z.core.$strict>;
+    replayOf: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunRequest = z.infer<typeof RunRequest>;
+export declare const EffectiveConfig: z.ZodObject<{
+    projectId: z.ZodString;
+    profileName: z.ZodString;
+    configDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    corpusRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    profile: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    overrides: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    schemaVersion: z.ZodLiteral<"workflow.effective-config/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type EffectiveConfig = z.infer<typeof EffectiveConfig>;
+export declare const HostCapabilityState: z.ZodEnum<{
+    unknown: "unknown";
+    unsupported: "unsupported";
+    supported: "supported";
+    temporarily_unavailable: "temporarily_unavailable";
+}>;
+export declare const HostCapabilityObservation: z.ZodObject<{
+    hostPlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    hostLeaseRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        capability: z.ZodString;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            unsupported: "unsupported";
+            supported: "supported";
+            temporarily_unavailable: "temporarily_unavailable";
+        }>;
+        probe: z.ZodEnum<{
+            declared: "declared";
+            probed: "probed";
+        }>;
+        evidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    observedAt: z.ZodString;
+    expiresAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.host-observation/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HostCapabilityObservation = z.infer<typeof HostCapabilityObservation>;
+export declare const HostLease: z.ZodObject<{
+    hostPlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    generation: z.ZodNumber;
+    actorId: z.ZodString;
+    observedWorkspaceIdentityRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    observedRuntimeIdentity: z.ZodObject<{
+        node: z.ZodString;
+        platform: z.ZodString;
+        arch: z.ZodString;
+        pid: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    sessionHandleRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.host-lease/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HostLease = z.infer<typeof HostLease>;
+export declare const RuntimeObservation: z.ZodObject<{
+    family: z.ZodEnum<{
+        node: "node";
+        python: "python";
+    }>;
+    version: z.ZodString;
+    runtime: z.ZodString;
+    executable: z.ZodString;
+    executableSha256: z.ZodString;
+}, z.core.$strict>;
+export type RuntimeObservation = z.infer<typeof RuntimeObservation>;
+export declare const IdentityAttestation: z.ZodObject<{
+    componentId: z.ZodString;
+    kind: z.ZodEnum<{
+        schema: "schema";
+        application: "application";
+        service: "service";
+        worker: "worker";
+        flag_set: "flag_set";
+        protocol_server: "protocol_server";
+        host: "host";
+        widget: "widget";
+        mobile_binary: "mobile_binary";
+        device_runtime: "device_runtime";
+        model_endpoint: "model_endpoint";
+        other: "other";
+    }>;
+    identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"source_digest">;
+        sourceDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"declared_release">;
+        release: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    issuer: z.ZodEnum<{
+        local_launcher: "local_launcher";
+        declared_binding: "declared_binding";
+    }>;
+    trustPolicy: z.ZodEnum<{
+        launcher_computed_source_digest: "launcher_computed_source_digest";
+        operator_declared_unverified: "operator_declared_unverified";
+    }>;
+    evidence: z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>;
+        runtimeProbe: z.ZodOptional<z.ZodObject<{
+            family: z.ZodEnum<{
+                node: "node";
+                python: "python";
+            }>;
+            version: z.ZodString;
+            runtime: z.ZodString;
+            executable: z.ZodString;
+            executableSha256: z.ZodString;
+        }, z.core.$strict>>;
+        sourceSnapshotRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        gitSource: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodEnum<{
+                sha256: "sha256";
+                sha1: "sha1";
+            }>;
+            commit: z.ZodString;
+            tree: z.ZodString;
+            proofDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            verification: z.ZodLiteral<"actual_file_bytes">;
+        }, z.core.$strict>>;
+        observedHealthBody: z.ZodNullable<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strict>;
+    observedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.identity-attestation/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type IdentityAttestation = z.infer<typeof IdentityAttestation>;
+export declare const EnvironmentBinding: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"workflow.environment/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    planRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    generation: z.ZodNumber;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+    class: z.ZodEnum<{
+        isolated_candidate: "isolated_candidate";
+        deployed_preview: "deployed_preview";
+        deployed_canary: "deployed_canary";
+        production_observation: "production_observation";
+    }>;
+    origins: z.ZodArray<z.ZodString>;
+    credentialLeaseRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    actionEnvelopeRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    leaseExpiresAt: z.ZodString;
+    budgetReservationRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    admissionEvidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    expected: z.ZodObject<{
+        componentProfileRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        requiredComponents: z.ZodArray<z.ZodString>;
+        excludedComponents: z.ZodArray<z.ZodObject<{
+            component: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodObject<{
+            componentId: z.ZodString;
+            kind: z.ZodEnum<{
+                schema: "schema";
+                application: "application";
+                service: "service";
+                worker: "worker";
+                flag_set: "flag_set";
+                protocol_server: "protocol_server";
+                host: "host";
+                widget: "widget";
+                mobile_binary: "mobile_binary";
+                device_runtime: "device_runtime";
+                model_endpoint: "model_endpoint";
+                other: "other";
+            }>;
+            identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"source_digest">;
+                sourceDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"declared_release">;
+                release: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repositoryRole: z.ZodString;
+            canonicalUrl: z.ZodString;
+            requestedRef: z.ZodString;
+            resolvedCommit: z.ZodString;
+            origin: z.ZodEnum<{
+                remote_object: "remote_object";
+                snapshot_bundle: "snapshot_bundle";
+            }>;
+            sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            lockfileDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            dirty: z.ZodLiteral<false>;
+        }, z.core.$strict>>;
+        corpus: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        runner: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        evaluator: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        frontendRelease: z.ZodNullable<z.ZodString>;
+        backendRelease: z.ZodNullable<z.ZodString>;
+        workerRelease: z.ZodNullable<z.ZodString>;
+        schemaFingerprint: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        browserVersion: z.ZodNullable<z.ZodString>;
+        containerImageDigest: z.ZodNullable<z.ZodString>;
+        modelConfigDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    observed: z.ZodNullable<z.ZodObject<{
+        componentProfileRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        requiredComponents: z.ZodArray<z.ZodString>;
+        excludedComponents: z.ZodArray<z.ZodObject<{
+            component: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodObject<{
+            componentId: z.ZodString;
+            kind: z.ZodEnum<{
+                schema: "schema";
+                application: "application";
+                service: "service";
+                worker: "worker";
+                flag_set: "flag_set";
+                protocol_server: "protocol_server";
+                host: "host";
+                widget: "widget";
+                mobile_binary: "mobile_binary";
+                device_runtime: "device_runtime";
+                model_endpoint: "model_endpoint";
+                other: "other";
+            }>;
+            identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"source_digest">;
+                sourceDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"declared_release">;
+                release: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repositoryRole: z.ZodString;
+            canonicalUrl: z.ZodString;
+            requestedRef: z.ZodString;
+            resolvedCommit: z.ZodString;
+            origin: z.ZodEnum<{
+                remote_object: "remote_object";
+                snapshot_bundle: "snapshot_bundle";
+            }>;
+            sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            lockfileDigest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+            dirty: z.ZodLiteral<false>;
+        }, z.core.$strict>>;
+        corpus: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        runner: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        evaluator: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        frontendRelease: z.ZodNullable<z.ZodString>;
+        backendRelease: z.ZodNullable<z.ZodString>;
+        workerRelease: z.ZodNullable<z.ZodString>;
+        schemaFingerprint: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        browserVersion: z.ZodNullable<z.ZodString>;
+        containerImageDigest: z.ZodNullable<z.ZodString>;
+        modelConfigDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    provenance: z.ZodObject<{
+        runtime: z.ZodEnum<{
+            live: "live";
+            replay: "replay";
+            mocked: "mocked";
+        }>;
+        data: z.ZodEnum<{
+            designated_production: "designated_production";
+            mocked: "mocked";
+            seeded_real: "seeded_real";
+            sanitized_real: "sanitized_real";
+        }>;
+        provider: z.ZodEnum<{
+            none: "none";
+            live: "live";
+            replay: "replay";
+            mocked: "mocked";
+        }>;
+        faults: z.ZodEnum<{
+            none: "none";
+            controlled: "controlled";
+        }>;
+        interceptors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        injectedFaults: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    networkProfileRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    clockProfileRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EnvironmentBinding = z.infer<typeof EnvironmentBinding>;
+export declare const BoundaryObservation: z.ZodObject<{
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    selectionCellId: z.ZodString;
+    fidelityPlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    boundaryId: z.ZodString;
+    expectedMode: z.ZodEnum<{
+        real: "real";
+        stubbed: "stubbed";
+        recorded_replay: "recorded_replay";
+        synthetic_runtime: "synthetic_runtime";
+    }>;
+    observedMode: z.ZodUnion<readonly [z.ZodEnum<{
+        real: "real";
+        stubbed: "stubbed";
+        recorded_replay: "recorded_replay";
+        synthetic_runtime: "synthetic_runtime";
+    }>, z.ZodLiteral<"unknown">]>;
+    observedAccountClass: z.ZodUnion<readonly [z.ZodEnum<{
+        local: "local";
+        test_sandbox: "test_sandbox";
+        designated_production: "designated_production";
+        none: "none";
+    }>, z.ZodLiteral<"unknown">]>;
+    adapterRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    identityEvidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    interactionEvidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    resourceIdsRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    interceptorRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    faultRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    observedAt: z.ZodString;
+    mismatchReasons: z.ZodArray<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"workflow.boundary-observation/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BoundaryObservation = z.infer<typeof BoundaryObservation>;
+export declare const FixtureManifest: z.ZodObject<{
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    selectionCellId: z.ZodString;
+    campaignFixturePlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    caseFixturePlanRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    seedRecipeRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    logicalPayloadRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    materializedPayloadDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    observedSchemaIdentityRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    migrationDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    namespace: z.ZodString;
+    executionNonce: z.ZodString;
+    resourceLeaseRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    entities: z.ZodArray<z.ZodObject<{
+        entityKey: z.ZodString;
+        boundaryId: z.ZodString;
+        physicalId: z.ZodString;
+        dataOrigin: z.ZodEnum<{
+            generated_synthetic: "generated_synthetic";
+            sanitized_snapshot: "sanitized_snapshot";
+            designated_existing: "designated_existing";
+        }>;
+        cleanupOwnership: z.ZodEnum<{
+            allocated_by_attempt: "allocated_by_attempt";
+            borrowed_existing: "borrowed_existing";
+        }>;
+        startingVersion: z.ZodNullable<z.ZodString>;
+        baselineRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        compensationStrategyRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        ownershipEvidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        readbackEvidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        cleanupHandle: z.ZodNullable<z.ZodObject<{
+            actionId: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    outputBindings: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    lifecycleObservationRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    state: z.ZodEnum<{
+        blocked: "blocked";
+        unknown: "unknown";
+        failed: "failed";
+        cancelled: "cancelled";
+        verified: "verified";
+    }>;
+    missingEntityKeys: z.ZodArray<z.ZodString>;
+    unexpectedResourceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    deadlineAt: z.ZodString;
+    finalizedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.fixture-manifest/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FixtureManifest = z.infer<typeof FixtureManifest>;
+export declare const StepEvent: z.ZodObject<{
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    generation: z.ZodNumber;
+    sequence: z.ZodNumber;
+    eventId: z.ZodString;
+    stepId: z.ZodNullable<z.ZodString>;
+    kind: z.ZodString;
+    at: z.ZodString;
+    monotonicOffsetMs: z.ZodNumber;
+    correlation: z.ZodObject<{
+        traceId: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodNullable<z.ZodString>;
+        jobId: z.ZodNullable<z.ZodString>;
+        nativeRunId: z.ZodNullable<z.ZodString>;
+        providerRequestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    payloadDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    redactedPayload: z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strict>;
+export type StepEvent = z.infer<typeof StepEvent>;
+export declare const AssertionResult: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    not_observed: "not_observed";
+    not_applicable: "not_applicable";
+}>;
+export declare const AssertionObservation: z.ZodObject<{
+    assertionId: z.ZodString;
+    required: z.ZodBoolean;
+    oracleRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        not_observed: "not_observed";
+        not_applicable: "not_applicable";
+    }>;
+    reasonCode: z.ZodNullable<z.ZodString>;
+    actual: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    evidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    producerRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    inputDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    observedFrom: z.ZodString;
+    observedTo: z.ZodString;
+    judge: z.ZodNullable<z.ZodObject<{
+        requestedModel: z.ZodString;
+        observedModel: z.ZodNullable<z.ZodString>;
+        rubricRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        confidence: z.ZodNullable<z.ZodNumber>;
+        abstained: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AssertionObservation = z.infer<typeof AssertionObservation>;
+export declare const StepResult: z.ZodEnum<{
+    failed: "failed";
+    cancelled: "cancelled";
+    completed: "completed";
+    not_run: "not_run";
+}>;
+export declare const StepObservation: z.ZodObject<{
+    stepId: z.ZodString;
+    result: z.ZodEnum<{
+        failed: "failed";
+        cancelled: "cancelled";
+        completed: "completed";
+        not_run: "not_run";
+    }>;
+    reasonCode: z.ZodNullable<z.ZodString>;
+    eventIds: z.ZodArray<z.ZodString>;
+    evidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    inputDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    outputDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    output: z.ZodNullable<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    timing: z.ZodNullable<z.ZodObject<{
+        startedAt: z.ZodString;
+        finishedAt: z.ZodString;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StepObservation = z.infer<typeof StepObservation>;
+export declare const EvidenceArtifact: z.ZodObject<{
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    privateObject: z.ZodObject<{
+        provider: z.ZodString;
+        bucket: z.ZodString;
+        key: z.ZodString;
+    }, z.core.$strict>;
+    mediaType: z.ZodString;
+    byteCount: z.ZodNumber;
+    producerRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    stepIds: z.ZodArray<z.ZodString>;
+    timeRange: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>;
+    redactionPolicyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    retentionPolicyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    accessPolicyRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    derivativeOf: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvidenceArtifact = z.infer<typeof EvidenceArtifact>;
+export declare const OperationOwner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"authoring_job">;
+    jobId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"attempt">;
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const RoutingDecision: z.ZodObject<{
+    owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"authoring_job">;
+        jobId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"attempt">;
+        campaignId: z.ZodString;
+        executionId: z.ZodString;
+        attemptId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    stage: z.ZodEnum<{
+        analysis: "analysis";
+        drafting: "drafting";
+        discovery: "discovery";
+        diagnosis: "diagnosis";
+        evaluation: "evaluation";
+        benchmark: "benchmark";
+        replay: "replay";
+    }>;
+    inputDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    intelligencePolicyRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    catalogRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        modelId: z.ZodString;
+        providerRoute: z.ZodString;
+        eligible: z.ZodBoolean;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    selected: z.ZodNullable<z.ZodObject<{
+        modelId: z.ZodString;
+        providerRoute: z.ZodString;
+        snapshotId: z.ZodNullable<z.ZodString>;
+        effort: z.ZodNullable<z.ZodString>;
+        tools: z.ZodArray<z.ZodString>;
+        contextBand: z.ZodString;
+    }, z.core.$strict>>;
+    estimate: z.ZodObject<{
+        amountCents: z.ZodNullable<z.ZodNumber>;
+        unknownReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    budgetReservationRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    escalationReason: z.ZodNullable<z.ZodString>;
+    decidedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.routing-decision/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RoutingDecision = z.infer<typeof RoutingDecision>;
+export declare const CostObservation: z.ZodObject<{
+    owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"authoring_job">;
+        jobId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"attempt">;
+        campaignId: z.ZodString;
+        executionId: z.ZodString;
+        attemptId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    operationId: z.ZodString;
+    stage: z.ZodString;
+    billingRoute: z.ZodEnum<{
+        api_invoice: "api_invoice";
+        subscription_quota: "subscription_quota";
+        host_minutes: "host_minutes";
+        provider_operation: "provider_operation";
+        storage: "storage";
+        egress: "egress";
+    }>;
+    providerRequestId: z.ZodNullable<z.ZodString>;
+    usageRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    rateSnapshotRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    quantity: z.ZodNullable<z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodString;
+    }, z.core.$strict>>;
+    amount: z.ZodNullable<z.ZodObject<{
+        value: z.ZodNumber;
+        currency: z.ZodString;
+        kind: z.ZodEnum<{
+            measured: "measured";
+            estimated: "estimated";
+        }>;
+    }, z.core.$strict>>;
+    reconciliation: z.ZodEnum<{
+        unknown: "unknown";
+        pending: "pending";
+        reconciled: "reconciled";
+    }>;
+    observedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.cost-observation/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CostObservation = z.infer<typeof CostObservation>;
+export declare const Accounting: z.ZodObject<{
+    reservations: z.ZodArray<z.ZodObject<{
+        reservationId: z.ZodString;
+        kind: z.ZodEnum<{
+            action: "action";
+            cleanup: "cleanup";
+            uncertain: "uncertain";
+        }>;
+        cents: z.ZodNumber;
+    }, z.core.$strict>>;
+    runnerSeconds: z.ZodNumber;
+    browserSeconds: z.ZodNumber;
+    inferenceCalls: z.ZodNumber;
+    inferenceTokens: z.ZodNumber;
+    requestedModel: z.ZodNullable<z.ZodString>;
+    observedModel: z.ZodNullable<z.ZodString>;
+    providerRequestIds: z.ZodArray<z.ZodString>;
+    integrationOperations: z.ZodNumber;
+    artifactBytes: z.ZodNumber;
+    estimatedCents: z.ZodNullable<z.ZodNumber>;
+    reconciledCents: z.ZodNullable<z.ZodNumber>;
+    rateCardDigest: z.ZodNullable<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>>;
+    unknownCharges: z.ZodArray<z.ZodObject<{
+        route: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    routingDecisionRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    costObservationRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Accounting = z.infer<typeof Accounting>;
+export declare const PerformanceObservation: z.ZodObject<{
+    metric: z.ZodString;
+    boundary: z.ZodString;
+    clock: z.ZodEnum<{
+        monotonic: "monotonic";
+        wall: "wall";
+    }>;
+    cellId: z.ZodString;
+    valueMs: z.ZodNullable<z.ZodNumber>;
+    censored: z.ZodBoolean;
+    warm: z.ZodBoolean;
+    strata: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+export declare const CleanupObservation: z.ZodObject<{
+    ownedResources: z.ZodArray<z.ZodObject<{
+        entityKey: z.ZodString;
+        physicalId: z.ZodString;
+        boundaryId: z.ZodString;
+    }, z.core.$strict>>;
+    attempted: z.ZodArray<z.ZodString>;
+    confirmed: z.ZodArray<z.ZodString>;
+    remainingUnknownMutations: z.ZodNumber;
+    critical: z.ZodArray<z.ZodString>;
+    janitorReceiptRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type CleanupObservation = z.infer<typeof CleanupObservation>;
+export declare const Coverage: z.ZodObject<{
+    selected: z.ZodNumber;
+    required: z.ZodNumber;
+    attempted: z.ZodNumber;
+    observed: z.ZodNumber;
+    passed: z.ZodNumber;
+    blocked: z.ZodNumber;
+    excluded: z.ZodNumber;
+    requiredCells: z.ZodArray<z.ZodObject<{
+        selectionCellId: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strict>>;
+    expectedSteps: z.ZodNumber;
+    completedSteps: z.ZodNumber;
+    requiredAssertions: z.ZodNumber;
+    passedRequiredAssertions: z.ZodNumber;
+}, z.core.$strict>;
+export type Coverage = z.infer<typeof Coverage>;
+export declare const Outcome: z.ZodEnum<{
+    blocked: "blocked";
+    cancelled: "cancelled";
+    passed: "passed";
+    assertion_failed: "assertion_failed";
+    infrastructure_failed: "infrastructure_failed";
+    inconclusive: "inconclusive";
+}>;
+export type Outcome = z.infer<typeof Outcome>;
+export declare const ExecutionReceipt: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"workflow.execution/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    executionId: z.ZodString;
+    campaignId: z.ZodString;
+    attemptId: z.ZodString;
+    attemptNumber: z.ZodNumber;
+    predecessorAttemptRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    retryReason: z.ZodNullable<z.ZodString>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+    requesterId: z.ZodString;
+    caseRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    personaRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    surfaceBindingRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    variantRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    executionHostRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    hostLeaseRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    hostObservationRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    environment: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"workflow.environment/v1">;
+        ref: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        planRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        campaignId: z.ZodString;
+        executionId: z.ZodString;
+        attemptId: z.ZodString;
+        generation: z.ZodNumber;
+        scope: z.ZodObject<{
+            ownerId: z.ZodString;
+            tenantId: z.ZodNullable<z.ZodString>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                owner_private: "owner_private";
+                tenant_private: "tenant_private";
+            }>;
+        }, z.core.$strict>;
+        class: z.ZodEnum<{
+            isolated_candidate: "isolated_candidate";
+            deployed_preview: "deployed_preview";
+            deployed_canary: "deployed_canary";
+            production_observation: "production_observation";
+        }>;
+        origins: z.ZodArray<z.ZodString>;
+        credentialLeaseRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        actionEnvelopeRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        leaseExpiresAt: z.ZodString;
+        budgetReservationRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        admissionEvidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        expected: z.ZodObject<{
+            componentProfileRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            requiredComponents: z.ZodArray<z.ZodString>;
+            excludedComponents: z.ZodArray<z.ZodObject<{
+                component: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+            components: z.ZodArray<z.ZodObject<{
+                componentId: z.ZodString;
+                kind: z.ZodEnum<{
+                    schema: "schema";
+                    application: "application";
+                    service: "service";
+                    worker: "worker";
+                    flag_set: "flag_set";
+                    protocol_server: "protocol_server";
+                    host: "host";
+                    widget: "widget";
+                    mobile_binary: "mobile_binary";
+                    device_runtime: "device_runtime";
+                    model_endpoint: "model_endpoint";
+                    other: "other";
+                }>;
+                identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"source_digest">;
+                    sourceDigest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                    runtime: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"declared_release">;
+                    release: z.ZodString;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            repositories: z.ZodArray<z.ZodObject<{
+                repositoryRole: z.ZodString;
+                canonicalUrl: z.ZodString;
+                requestedRef: z.ZodString;
+                resolvedCommit: z.ZodString;
+                origin: z.ZodEnum<{
+                    remote_object: "remote_object";
+                    snapshot_bundle: "snapshot_bundle";
+                }>;
+                sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodString;
+                    digest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                lockfileDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                dirty: z.ZodLiteral<false>;
+            }, z.core.$strict>>;
+            corpus: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            runner: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            frontendRelease: z.ZodNullable<z.ZodString>;
+            backendRelease: z.ZodNullable<z.ZodString>;
+            workerRelease: z.ZodNullable<z.ZodString>;
+            schemaFingerprint: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            browserVersion: z.ZodNullable<z.ZodString>;
+            containerImageDigest: z.ZodNullable<z.ZodString>;
+            modelConfigDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodNullable<z.ZodObject<{
+            componentProfileRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            requiredComponents: z.ZodArray<z.ZodString>;
+            excludedComponents: z.ZodArray<z.ZodObject<{
+                component: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+            components: z.ZodArray<z.ZodObject<{
+                componentId: z.ZodString;
+                kind: z.ZodEnum<{
+                    schema: "schema";
+                    application: "application";
+                    service: "service";
+                    worker: "worker";
+                    flag_set: "flag_set";
+                    protocol_server: "protocol_server";
+                    host: "host";
+                    widget: "widget";
+                    mobile_binary: "mobile_binary";
+                    device_runtime: "device_runtime";
+                    model_endpoint: "model_endpoint";
+                    other: "other";
+                }>;
+                identity: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"source_digest">;
+                    sourceDigest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                    runtime: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"declared_release">;
+                    release: z.ZodString;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            repositories: z.ZodArray<z.ZodObject<{
+                repositoryRole: z.ZodString;
+                canonicalUrl: z.ZodString;
+                requestedRef: z.ZodString;
+                resolvedCommit: z.ZodString;
+                origin: z.ZodEnum<{
+                    remote_object: "remote_object";
+                    snapshot_bundle: "snapshot_bundle";
+                }>;
+                sourceObjectsRef: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodString;
+                    digest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        hex: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                lockfileDigest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+                dirty: z.ZodLiteral<false>;
+            }, z.core.$strict>>;
+            corpus: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            runner: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            frontendRelease: z.ZodNullable<z.ZodString>;
+            backendRelease: z.ZodNullable<z.ZodString>;
+            workerRelease: z.ZodNullable<z.ZodString>;
+            schemaFingerprint: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            featureFlagsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            capabilityVersionsDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+            browserVersion: z.ZodNullable<z.ZodString>;
+            containerImageDigest: z.ZodNullable<z.ZodString>;
+            modelConfigDigest: z.ZodNullable<z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        provenance: z.ZodObject<{
+            runtime: z.ZodEnum<{
+                live: "live";
+                replay: "replay";
+                mocked: "mocked";
+            }>;
+            data: z.ZodEnum<{
+                designated_production: "designated_production";
+                mocked: "mocked";
+                seeded_real: "seeded_real";
+                sanitized_real: "sanitized_real";
+            }>;
+            provider: z.ZodEnum<{
+                none: "none";
+                live: "live";
+                replay: "replay";
+                mocked: "mocked";
+            }>;
+            faults: z.ZodEnum<{
+                none: "none";
+                controlled: "controlled";
+            }>;
+            interceptors: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            injectedFaults: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        networkProfileRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        clockProfileRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    idempotencyKey: z.ZodString;
+    requestRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    selectionCellId: z.ZodString;
+    qualificationRoundRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    fixtureManifestRef: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    boundaryObservationRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    proofClaim: z.ZodString;
+    coverage: z.ZodObject<{
+        selected: z.ZodNumber;
+        required: z.ZodNumber;
+        attempted: z.ZodNumber;
+        observed: z.ZodNumber;
+        passed: z.ZodNumber;
+        blocked: z.ZodNumber;
+        excluded: z.ZodNumber;
+        requiredCells: z.ZodArray<z.ZodObject<{
+            selectionCellId: z.ZodString;
+            outcome: z.ZodString;
+        }, z.core.$strict>>;
+        expectedSteps: z.ZodNumber;
+        completedSteps: z.ZodNumber;
+        requiredAssertions: z.ZodNumber;
+        passedRequiredAssertions: z.ZodNumber;
+    }, z.core.$strict>;
+    eventsDigest: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        hex: z.ZodString;
+    }, z.core.$strict>;
+    assertions: z.ZodArray<z.ZodObject<{
+        assertionId: z.ZodString;
+        required: z.ZodBoolean;
+        oracleRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            not_observed: "not_observed";
+            not_applicable: "not_applicable";
+        }>;
+        reasonCode: z.ZodNullable<z.ZodString>;
+        actual: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        evidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        producerRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        inputDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        observedFrom: z.ZodString;
+        observedTo: z.ZodString;
+        judge: z.ZodNullable<z.ZodObject<{
+            requestedModel: z.ZodString;
+            observedModel: z.ZodNullable<z.ZodString>;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            confidence: z.ZodNullable<z.ZodNumber>;
+            abstained: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    steps: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        result: z.ZodEnum<{
+            failed: "failed";
+            cancelled: "cancelled";
+            completed: "completed";
+            not_run: "not_run";
+        }>;
+        reasonCode: z.ZodNullable<z.ZodString>;
+        eventIds: z.ZodArray<z.ZodString>;
+        evidenceRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        inputDigest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+        outputDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        output: z.ZodNullable<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        timing: z.ZodNullable<z.ZodObject<{
+            startedAt: z.ZodString;
+            finishedAt: z.ZodString;
+            durationMs: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        privateObject: z.ZodObject<{
+            provider: z.ZodString;
+            bucket: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strict>;
+        mediaType: z.ZodString;
+        byteCount: z.ZodNumber;
+        producerRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        stepIds: z.ZodArray<z.ZodString>;
+        timeRange: z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>;
+        redactionPolicyRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        retentionPolicyRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        accessPolicyRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        derivativeOf: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    accounting: z.ZodObject<{
+        reservations: z.ZodArray<z.ZodObject<{
+            reservationId: z.ZodString;
+            kind: z.ZodEnum<{
+                action: "action";
+                cleanup: "cleanup";
+                uncertain: "uncertain";
+            }>;
+            cents: z.ZodNumber;
+        }, z.core.$strict>>;
+        runnerSeconds: z.ZodNumber;
+        browserSeconds: z.ZodNumber;
+        inferenceCalls: z.ZodNumber;
+        inferenceTokens: z.ZodNumber;
+        requestedModel: z.ZodNullable<z.ZodString>;
+        observedModel: z.ZodNullable<z.ZodString>;
+        providerRequestIds: z.ZodArray<z.ZodString>;
+        integrationOperations: z.ZodNumber;
+        artifactBytes: z.ZodNumber;
+        estimatedCents: z.ZodNullable<z.ZodNumber>;
+        reconciledCents: z.ZodNullable<z.ZodNumber>;
+        rateCardDigest: z.ZodNullable<z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>>;
+        unknownCharges: z.ZodArray<z.ZodObject<{
+            route: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        routingDecisionRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        costObservationRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    performance: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        boundary: z.ZodString;
+        clock: z.ZodEnum<{
+            monotonic: "monotonic";
+            wall: "wall";
+        }>;
+        cellId: z.ZodString;
+        valueMs: z.ZodNullable<z.ZodNumber>;
+        censored: z.ZodBoolean;
+        warm: z.ZodBoolean;
+        strata: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+    cleanup: z.ZodObject<{
+        ownedResources: z.ZodArray<z.ZodObject<{
+            entityKey: z.ZodString;
+            physicalId: z.ZodString;
+            boundaryId: z.ZodString;
+        }, z.core.$strict>>;
+        attempted: z.ZodArray<z.ZodString>;
+        confirmed: z.ZodArray<z.ZodString>;
+        remainingUnknownMutations: z.ZodNumber;
+        critical: z.ZodArray<z.ZodString>;
+        janitorReceiptRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        passed: "passed";
+        assertion_failed: "assertion_failed";
+        infrastructure_failed: "infrastructure_failed";
+        inconclusive: "inconclusive";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    proofEligible: z.ZodBoolean;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finalizedAt: z.ZodString;
+}, z.core.$strict>;
+export type ExecutionReceipt = z.infer<typeof ExecutionReceipt>;
+export declare const CampaignResult: z.ZodObject<{
+    campaignId: z.ZodString;
+    requestRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    selectionManifestRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    cellReceiptRefs: z.ZodArray<z.ZodObject<{
+        selectionCellId: z.ZodString;
+        receiptRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    missingCellIds: z.ZodArray<z.ZodString>;
+    coverage: z.ZodObject<{
+        selected: z.ZodNumber;
+        required: z.ZodNumber;
+        attempted: z.ZodNumber;
+        observed: z.ZodNumber;
+        passed: z.ZodNumber;
+        blocked: z.ZodNumber;
+        excluded: z.ZodNumber;
+        requiredCells: z.ZodArray<z.ZodObject<{
+            selectionCellId: z.ZodString;
+            outcome: z.ZodString;
+        }, z.core.$strict>>;
+        expectedSteps: z.ZodNumber;
+        completedSteps: z.ZodNumber;
+        requiredAssertions: z.ZodNumber;
+        passedRequiredAssertions: z.ZodNumber;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        passed: "passed";
+        assertion_failed: "assertion_failed";
+        infrastructure_failed: "infrastructure_failed";
+        inconclusive: "inconclusive";
+    }>;
+    proofEligible: z.ZodBoolean;
+    finalizedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.campaign-result/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CampaignResult = z.infer<typeof CampaignResult>;
+export declare const BudgetReservation: z.ZodObject<{
+    campaignId: z.ZodString;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    actionCents: z.ZodNumber;
+    cleanupCents: z.ZodNumber;
+    uncertainCents: z.ZodNumber;
+    state: z.ZodEnum<{
+        reconciled: "reconciled";
+        reserved: "reserved";
+        consumed: "consumed";
+        refunded: "refunded";
+    }>;
+    reservedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.budget-reservation/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BudgetReservation = z.infer<typeof BudgetReservation>;
+export declare const CredentialLease: z.ZodObject<{
+    authRecipeRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    personaRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    executionId: z.ZodString;
+    attemptId: z.ZodString;
+    credentialName: z.ZodNullable<z.ZodString>;
+    issuedBy: z.ZodEnum<{
+        none: "none";
+        local_launcher: "local_launcher";
+        environment: "environment";
+    }>;
+    expiresAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"workflow.credential-lease/v1">;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        ownerId: z.ZodString;
+        tenantId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            owner_private: "owner_private";
+            tenant_private: "tenant_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CredentialLease = z.infer<typeof CredentialLease>;
+export declare const DeadlineMs: z.ZodNumber;