openpond-sdk 0.9.9 → 0.11.0

package/dist/types/packages/sdk/src/experiment-improvement-hosted-adoption.d.ts

@@ -0,0 +1,1361 @@
+import { z } from "zod";
+/** This export attests native owner execution. It never asserts a hosted run,
+ * grants training eligibility, or authorizes automatic candidate adoption. */
+export declare const HostedProfileCandidateExportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateExport.v1">;
+    actorId: z.ZodString;
+    teamId: z.ZodString;
+    candidateId: z.ZodString;
+    candidateRevision: z.ZodNumber;
+    projectId: z.ZodNullable<z.ZodString>;
+    profileRef: z.ZodObject<{
+        source: z.ZodLiteral<"openpond_git">;
+        repositoryId: z.ZodString;
+        profileId: z.ZodString;
+    }, z.core.$strict>;
+    expectedCommit: z.ZodString;
+    component: z.ZodObject<{
+        kind: z.ZodEnum<{
+            skill: "skill";
+            workflow: "workflow";
+            agent: "agent";
+            instruction: "instruction";
+        }>;
+        path: z.ZodString;
+        workflowId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    baseRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    frozenHash: z.ZodString;
+    executableSourceHash: z.ZodString;
+    protectedClosureHash: z.ZodString;
+    compiler: z.ZodObject<{
+        workspaceId: z.ZodString;
+        name: z.ZodString;
+        repositoryId: z.ZodString;
+    }, z.core.$strict>;
+    sourceManifest: z.ZodObject<{
+        base64: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    policySource: z.ZodObject<{
+        agentSnapshot: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.agentSnapshot.v2">;
+            id: z.ZodString;
+            sourceRelease: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            instructions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            skills: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            toolDeclarations: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                inputSchemaHash: z.ZodString;
+                sideEffect: z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>;
+                timeoutMs: z.ZodNumber;
+            }, z.core.$strict>>;
+            capabilityRequirements: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                required: z.ZodBoolean;
+                scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                portability: z.ZodEnum<{
+                    portable: "portable";
+                    host_adapter: "host_adapter";
+                    local_only: "local_only";
+                    hosted_only: "hosted_only";
+                }>;
+            }, z.core.$strict>>;
+            dependencyLock: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            portability: z.ZodObject<{
+                portable: z.ZodBoolean;
+                blockers: z.ZodArray<z.ZodString>;
+                localOnlyAssetRefs: z.ZodArray<z.ZodString>;
+                hostPrivateAssetRefs: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        harnessRelease: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.harnessRelease.v2">;
+            id: z.ZodString;
+            agentSnapshot: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            program: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                inputSchemaHash: z.ZodString;
+                sideEffect: z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>;
+                timeoutMs: z.ZodNumber;
+            }, z.core.$strict>>;
+            lifecycle: z.ZodObject<{
+                create: z.ZodLiteral<true>;
+                reset: z.ZodLiteral<true>;
+                step: z.ZodLiteral<true>;
+                collect: z.ZodLiteral<true>;
+                destroy: z.ZodLiteral<true>;
+                resetScope: z.ZodEnum<{
+                    task: "task";
+                    attempt: "attempt";
+                }>;
+            }, z.core.$strict>;
+            graderInterface: z.ZodObject<{
+                visibleEvidence: z.ZodArray<z.ZodString>;
+                privilegedEvidence: z.ZodArray<z.ZodString>;
+                privateVerifierIsolation: z.ZodBoolean;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            base64: z.ZodString;
+        }, z.core.$strict>>;
+        schemaVersion: z.ZodLiteral<"openpond.harnessPolicySourcePackage.v1">;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    qualification: z.ZodObject<{
+        kind: z.ZodEnum<{
+            owner_attested_local: "owner_attested_local";
+            hosted_execution: "hosted_execution";
+        }>;
+        ownerActorId: z.ZodString;
+        teamId: z.ZodString;
+        originalEvidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        baseline: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        comparisonHash: z.ZodString;
+        recipe: z.ZodObject<{
+            externalDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            scoring: z.ZodOptional<z.ZodObject<{
+                sourcePass: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                graders: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            input: "input";
+                            output: "output";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            input: "input";
+                            output: "output";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                maximumCostUsd: z.ZodNumber;
+            }, z.core.$strict>>;
+            modelId: z.ZodString;
+            maximumCostUsd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type HostedProfileCandidateExport = z.infer<typeof HostedProfileCandidateExportSchema>;
+export declare function verifyHostedProfileCandidateExport(raw: unknown): {
+    schemaVersion: "openpond.hostedProfileCandidateExport.v1";
+    actorId: string;
+    teamId: string;
+    candidateId: string;
+    candidateRevision: number;
+    projectId: string | null;
+    profileRef: {
+        source: "openpond_git";
+        repositoryId: string;
+        profileId: string;
+    };
+    expectedCommit: string;
+    component: {
+        kind: "skill" | "workflow" | "agent" | "instruction";
+        path: string;
+        workflowId?: string | undefined;
+    };
+    baseRelease: {
+        id: string;
+        contentHash: string;
+    };
+    frozenHash: string;
+    executableSourceHash: string;
+    protectedClosureHash: string;
+    compiler: {
+        workspaceId: string;
+        name: string;
+        repositoryId: string;
+    };
+    sourceManifest: {
+        base64: string;
+        contentHash: string;
+        sizeBytes: number;
+    };
+    policySource: {
+        agentSnapshot: {
+            schemaVersion: "openpond.agentSnapshot.v2";
+            id: string;
+            sourceRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            instructions: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            skills: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            agents: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            toolDeclarations: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilityRequirements: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+            }[];
+            dependencyLock: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            portability: {
+                portable: boolean;
+                blockers: string[];
+                localOnlyAssetRefs: string[];
+                hostPrivateAssetRefs: string[];
+            };
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        harnessRelease: {
+            schemaVersion: "openpond.harnessRelease.v2";
+            id: string;
+            agentSnapshot: {
+                id: string;
+                contentHash: string;
+            };
+            program: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            lifecycle: {
+                create: true;
+                reset: true;
+                step: true;
+                collect: true;
+                destroy: true;
+                resetScope: "attempt" | "task";
+            };
+            graderInterface: {
+                visibleEvidence: string[];
+                privilegedEvidence: string[];
+                privateVerifierIsolation: boolean;
+            };
+            files: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        files: {
+            path: string;
+            base64: string;
+        }[];
+        schemaVersion: "openpond.harnessPolicySourcePackage.v1";
+        contentHash: string;
+    };
+    qualification: {
+        kind: "owner_attested_local" | "hosted_execution";
+        ownerActorId: string;
+        teamId: string;
+        originalEvidence: {
+            id: string;
+            contentHash: string;
+        };
+        baseline: {
+            id: string;
+            contentHash: string;
+        };
+        candidate: {
+            id: string;
+            contentHash: string;
+        };
+        comparisonHash: string;
+        recipe: {
+            externalDatasetBinding: {
+                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                packageHash: string;
+                profileId: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                declaredProfileCatalogHash: string | null;
+                protectedProfileClosureHash: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                population: {
+                    taskId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                }[];
+                evaluators: {
+                    release: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    feedbackKey: string;
+                    configurationHash: string;
+                    output: "boolean" | "score" | "category";
+                    categories: string[];
+                }[];
+                fieldMappingsHash: string;
+                fieldMappings: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[];
+                environmentHash: string;
+                privateDatasetClosureHash: string;
+                criterion: {
+                    minimumPassRate: number;
+                    requireComplete: boolean;
+                };
+                contentHash: string;
+                recordedOrigin?: {
+                    execution: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    originalEvidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    members: {
+                        caseId: string;
+                        seed: string;
+                        fixtureId: string;
+                        sourceId: string;
+                        snapshotHash: string;
+                        boundaryRevisionHash: string;
+                    }[];
+                } | undefined;
+                gradingSource?: {
+                    pass: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | undefined;
+            };
+            modelId: string;
+            maximumCostUsd: number;
+            scoring?: {
+                sourcePass: {
+                    id: string;
+                    contentHash: string;
+                };
+                graders: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                }[];
+                maximumCostUsd: number;
+                mappings?: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[] | undefined;
+            } | undefined;
+        };
+    };
+    createdAt: string;
+    contentHash: string;
+};
+export declare const HostedProfileCandidateReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateAdoption.v1">;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    actorId: z.ZodString;
+    teamId: z.ZodString;
+    candidateId: z.ZodString;
+    exportHash: z.ZodString;
+    executionOrigin: z.ZodEnum<{
+        owner_attested_local: "owner_attested_local";
+        hosted_execution: "hosted_execution";
+    }>;
+    qualification: z.ZodObject<{
+        kind: z.ZodEnum<{
+            owner_attested_local: "owner_attested_local";
+            hosted_execution: "hosted_execution";
+        }>;
+        ownerActorId: z.ZodString;
+        teamId: z.ZodString;
+        originalEvidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        baseline: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        comparisonHash: z.ZodString;
+        recipe: z.ZodObject<{
+            externalDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            scoring: z.ZodOptional<z.ZodObject<{
+                sourcePass: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                graders: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            input: "input";
+                            output: "output";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            input: "input";
+                            output: "output";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                maximumCostUsd: z.ZodNumber;
+            }, z.core.$strict>>;
+            modelId: z.ZodString;
+            maximumCostUsd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    testedCandidateRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    activeRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    expectedCommit: z.ZodString;
+    committedProfileGit: z.ZodString;
+    executableSourceHash: z.ZodString;
+    protectedClosureHash: z.ZodString;
+    createdAt: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type HostedProfileCandidateReceipt = z.infer<typeof HostedProfileCandidateReceiptSchema>;
+export declare function verifyHostedProfileCandidateReceipt(raw: unknown): {
+    schemaVersion: "openpond.hostedProfileCandidateAdoption.v1";
+    id: string;
+    operationId: string;
+    actorId: string;
+    teamId: string;
+    candidateId: string;
+    exportHash: string;
+    executionOrigin: "owner_attested_local" | "hosted_execution";
+    qualification: {
+        kind: "owner_attested_local" | "hosted_execution";
+        ownerActorId: string;
+        teamId: string;
+        originalEvidence: {
+            id: string;
+            contentHash: string;
+        };
+        baseline: {
+            id: string;
+            contentHash: string;
+        };
+        candidate: {
+            id: string;
+            contentHash: string;
+        };
+        comparisonHash: string;
+        recipe: {
+            externalDatasetBinding: {
+                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                packageHash: string;
+                profileId: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                declaredProfileCatalogHash: string | null;
+                protectedProfileClosureHash: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                population: {
+                    taskId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                }[];
+                evaluators: {
+                    release: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    feedbackKey: string;
+                    configurationHash: string;
+                    output: "boolean" | "score" | "category";
+                    categories: string[];
+                }[];
+                fieldMappingsHash: string;
+                fieldMappings: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[];
+                environmentHash: string;
+                privateDatasetClosureHash: string;
+                criterion: {
+                    minimumPassRate: number;
+                    requireComplete: boolean;
+                };
+                contentHash: string;
+                recordedOrigin?: {
+                    execution: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    originalEvidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    members: {
+                        caseId: string;
+                        seed: string;
+                        fixtureId: string;
+                        sourceId: string;
+                        snapshotHash: string;
+                        boundaryRevisionHash: string;
+                    }[];
+                } | undefined;
+                gradingSource?: {
+                    pass: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | undefined;
+            };
+            modelId: string;
+            maximumCostUsd: number;
+            scoring?: {
+                sourcePass: {
+                    id: string;
+                    contentHash: string;
+                };
+                graders: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                }[];
+                maximumCostUsd: number;
+                mappings?: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[] | undefined;
+            } | undefined;
+        };
+    };
+    testedCandidateRelease: {
+        id: string;
+        contentHash: string;
+    };
+    activeRelease: {
+        id: string;
+        contentHash: string;
+    };
+    expectedCommit: string;
+    committedProfileGit: string;
+    executableSourceHash: string;
+    protectedClosureHash: string;
+    createdAt: string;
+    contentHash: string;
+};
+export declare const HostedProfileCandidateCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"adopt">;
+    operationId: z.ZodString;
+    export: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateExport.v1">;
+        actorId: z.ZodString;
+        teamId: z.ZodString;
+        candidateId: z.ZodString;
+        candidateRevision: z.ZodNumber;
+        projectId: z.ZodNullable<z.ZodString>;
+        profileRef: z.ZodObject<{
+            source: z.ZodLiteral<"openpond_git">;
+            repositoryId: z.ZodString;
+            profileId: z.ZodString;
+        }, z.core.$strict>;
+        expectedCommit: z.ZodString;
+        component: z.ZodObject<{
+            kind: z.ZodEnum<{
+                skill: "skill";
+                workflow: "workflow";
+                agent: "agent";
+                instruction: "instruction";
+            }>;
+            path: z.ZodString;
+            workflowId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        baseRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        frozenHash: z.ZodString;
+        executableSourceHash: z.ZodString;
+        protectedClosureHash: z.ZodString;
+        compiler: z.ZodObject<{
+            workspaceId: z.ZodString;
+            name: z.ZodString;
+            repositoryId: z.ZodString;
+        }, z.core.$strict>;
+        sourceManifest: z.ZodObject<{
+            base64: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        policySource: z.ZodObject<{
+            agentSnapshot: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.agentSnapshot.v2">;
+                id: z.ZodString;
+                sourceRelease: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                instructions: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                skills: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                agents: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                toolDeclarations: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    inputSchemaHash: z.ZodString;
+                    sideEffect: z.ZodEnum<{
+                        read: "read";
+                        write: "write";
+                    }>;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>>;
+                capabilityRequirements: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    required: z.ZodBoolean;
+                    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    portability: z.ZodEnum<{
+                        portable: "portable";
+                        host_adapter: "host_adapter";
+                        local_only: "local_only";
+                        hosted_only: "hosted_only";
+                    }>;
+                }, z.core.$strict>>;
+                dependencyLock: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                portability: z.ZodObject<{
+                    portable: z.ZodBoolean;
+                    blockers: z.ZodArray<z.ZodString>;
+                    localOnlyAssetRefs: z.ZodArray<z.ZodString>;
+                    hostPrivateAssetRefs: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            harnessRelease: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.harnessRelease.v2">;
+                id: z.ZodString;
+                agentSnapshot: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                program: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                tools: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    inputSchemaHash: z.ZodString;
+                    sideEffect: z.ZodEnum<{
+                        read: "read";
+                        write: "write";
+                    }>;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>>;
+                lifecycle: z.ZodObject<{
+                    create: z.ZodLiteral<true>;
+                    reset: z.ZodLiteral<true>;
+                    step: z.ZodLiteral<true>;
+                    collect: z.ZodLiteral<true>;
+                    destroy: z.ZodLiteral<true>;
+                    resetScope: z.ZodEnum<{
+                        task: "task";
+                        attempt: "attempt";
+                    }>;
+                }, z.core.$strict>;
+                graderInterface: z.ZodObject<{
+                    visibleEvidence: z.ZodArray<z.ZodString>;
+                    privilegedEvidence: z.ZodArray<z.ZodString>;
+                    privateVerifierIsolation: z.ZodBoolean;
+                }, z.core.$strict>;
+                files: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                base64: z.ZodString;
+            }, z.core.$strict>>;
+            schemaVersion: z.ZodLiteral<"openpond.harnessPolicySourcePackage.v1">;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            kind: z.ZodEnum<{
+                owner_attested_local: "owner_attested_local";
+                hosted_execution: "hosted_execution";
+            }>;
+            ownerActorId: z.ZodString;
+            teamId: z.ZodString;
+            originalEvidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            baseline: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            candidate: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            comparisonHash: z.ZodString;
+            recipe: z.ZodObject<{
+                externalDatasetBinding: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                    dataset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    packageHash: z.ZodString;
+                    profileId: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                    protectedProfileClosureHash: z.ZodString;
+                    recordedOrigin: z.ZodOptional<z.ZodObject<{
+                        execution: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        originalEvidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        members: z.ZodArray<z.ZodObject<{
+                            caseId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodString;
+                            sourceId: z.ZodString;
+                            snapshotHash: z.ZodString;
+                            boundaryRevisionHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    gradingSource: z.ZodOptional<z.ZodObject<{
+                        pass: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        evidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>>;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                    population: z.ZodArray<z.ZodObject<{
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    evaluators: z.ZodArray<z.ZodObject<{
+                        release: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                        }, z.core.$strict>;
+                        feedbackKey: z.ZodString;
+                        configurationHash: z.ZodString;
+                        output: z.ZodEnum<{
+                            boolean: "boolean";
+                            score: "score";
+                            category: "category";
+                        }>;
+                        categories: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                    fieldMappingsHash: z.ZodString;
+                    fieldMappings: z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    environmentHash: z.ZodString;
+                    privateDatasetClosureHash: z.ZodString;
+                    criterion: z.ZodObject<{
+                        minimumPassRate: z.ZodNumber;
+                        requireComplete: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                scoring: z.ZodOptional<z.ZodObject<{
+                    sourcePass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    graders: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                input: "input";
+                                output: "output";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                input: "input";
+                                output: "output";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>>;
+                    maximumCostUsd: z.ZodNumber;
+                }, z.core.$strict>>;
+                modelId: z.ZodString;
+                maximumCostUsd: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        read: "read";
+        rollback: "rollback";
+    }>;
+    operationId: z.ZodString;
+    adoptionOperationId: z.ZodString;
+    profileRepositoryId: z.ZodString;
+}, z.core.$strict>], "operation">;
+//# sourceMappingURL=experiment-improvement-hosted-adoption.d.ts.map