npm - openpond-sdk - Versions diffs - 0.10.0 → 0.11.2 - Mend

openpond-sdk 0.10.0 → 0.11.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (263) hide show

package/dist/types/packages/sdk/src/post-training.d.ts ADDED Viewed

@@ -0,0 +1,3529 @@
+import { z } from "zod";
+export { TrainingHandoffOriginSchema, type TrainingHandoffOrigin } from "@openpond/evals/learning";
+export declare const TrainingHandoffContextSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+    origin: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
+        teamId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        configurationId: z.ZodString;
+        source: z.ZodObject<{
+            executionId: z.ZodString;
+            passId: z.ZodNullable<z.ZodString>;
+            manifestHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+            modelId: z.ZodString;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"harness">;
+            source: z.ZodObject<{
+                profileId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                definitionHash: 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">;
+                environmentHash: z.ZodString;
+                externalDatasetBinding: z.ZodOptional<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>>;
+                sourceCandidate: z.ZodOptional<z.ZodObject<{
+                    candidateId: z.ZodString;
+                    frozenRevision: z.ZodNumber;
+                    frozenHash: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    protectedClosureHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            source: z.ZodObject<{
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                agentSnapshot: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                sourcePackageHash: z.ZodString;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixture">;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        graders: z.ZodArray<z.ZodObject<{
+            feedbackKey: z.ZodString;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            expectedCount: z.ZodNumber;
+            scoredCount: z.ZodNumber;
+            score: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TrainingHandoffContext = z.infer<typeof TrainingHandoffContextSchema>;
+export declare const PostTrainingAttachmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.postTrainingAttachment.v1">;
+    binding: z.ZodObject<{
+        kind: z.ZodEnum<{
+            policy: "policy";
+            preparation: "preparation";
+        }>;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    projectId: z.ZodNullable<z.ZodString>;
+    automatic: z.ZodBoolean;
+    maximumSpendUsd: z.ZodNumber;
+    experiments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        configuration: z.ZodObject<{
+            operationId: z.ZodString;
+            request: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
+                operationId: z.ZodString;
+                teamId: z.ZodString;
+                modelProjectId: z.ZodNullable<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                    targetId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                taskset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"hosted_chat">;
+                    modelId: z.ZodString;
+                    localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        providerId: z.ZodLiteral<"custom-openai-compatible">;
+                        configurationHash: z.ZodString;
+                        maximumRequestCostUsd: z.ZodNumber;
+                        requestTimeoutMs: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        providerId: z.ZodLiteral<"claude-code">;
+                        configurationHash: z.ZodString;
+                        executableHash: z.ZodString;
+                        version: z.ZodString;
+                        capabilityHash: z.ZodString;
+                        maximumRequestCostUsd: z.ZodNumber;
+                        requestTimeoutMs: z.ZodNumber;
+                        maximumTurns: z.ZodNumber;
+                        holdOpen: z.ZodBoolean;
+                    }, z.core.$strict>]>>;
+                    candidate: z.ZodOptional<z.ZodObject<{
+                        artifactId: z.ZodString;
+                        contentHash: z.ZodString;
+                        preparationId: z.ZodString;
+                        dispatchId: z.ZodString;
+                        baseProfileId: z.ZodString;
+                        workerImageDigest: z.ZodString;
+                    }, z.core.$strict>>;
+                    harness: z.ZodOptional<z.ZodObject<{
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        agentSnapshot: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        sourcePackageHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        role: z.ZodEnum<{
+                            system: "system";
+                            user: "user";
+                            assistant: "assistant";
+                        }>;
+                        content: z.ZodString;
+                    }, z.core.$strict>>>;
+                    maxOutputTokens: z.ZodDefault<z.ZodNumber>;
+                    temperature: z.ZodDefault<z.ZodNumber>;
+                    topP: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fixture">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"hosted_harness">;
+                    modelId: z.ZodString;
+                    candidate: z.ZodOptional<z.ZodObject<{
+                        artifactId: z.ZodString;
+                        contentHash: z.ZodString;
+                        preparationId: z.ZodString;
+                        dispatchId: z.ZodString;
+                        baseProfileId: z.ZodString;
+                        workerImageDigest: z.ZodString;
+                    }, z.core.$strict>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        off: "off";
+                        medium: "medium";
+                        xhigh: "xhigh";
+                        max: "max";
+                    }>>;
+                    profileRepositoryId: z.ZodString;
+                    source: z.ZodObject<{
+                        profileId: z.ZodString;
+                        sourceRevision: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        catalogHash: z.ZodString;
+                        definitionId: z.ZodString;
+                        definitionHash: 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">;
+                        environmentHash: z.ZodString;
+                        externalDatasetBinding: z.ZodOptional<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>>;
+                        sourceCandidate: z.ZodOptional<z.ZodObject<{
+                            candidateId: z.ZodString;
+                            frozenRevision: z.ZodNumber;
+                            frozenHash: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            protectedClosureHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    modelConfigurationHash: z.ZodString;
+                    packageHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<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>>;
+                }, z.core.$strict>], "kind">;
+                population: z.ZodArray<z.ZodObject<{
+                    receiptId: z.ZodString;
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            maximumCostUsd: z.ZodNumber;
+            graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+                contentHash: z.ZodString;
+                mappings: 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>>>;
+            sourceExperimentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    acceptancePlan: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.acceptancePlan.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodBoolean;
+            role: z.ZodOptional<z.ZodEnum<{
+                retention: "retention";
+                quality: "quality";
+                diagnostic: "diagnostic";
+            }>>;
+            unit: z.ZodOptional<z.ZodString>;
+            baselineReuse: z.ZodOptional<z.ZodObject<{
+                maximumAgeSeconds: z.ZodNumber;
+                qualification: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            executionHash: z.ZodString;
+            populationHash: z.ZodString;
+            metric: z.ZodString;
+            direction: z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+            }>;
+            minimumCoverage: z.ZodNumber;
+            threshold: z.ZodNumber;
+            maximumRegression: z.ZodNumber;
+            maximumSpendUsd: z.ZodNumber;
+        }, z.core.$strict>>;
+        maximumSpendUsd: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PostTrainingAttachment = z.infer<typeof PostTrainingAttachmentSchema>;
+/** Target-independent recipe pins keep the paired baseline/candidate check on
+ * the same released data, case order, settings and graders. */
+export declare function postTrainingRecipe(configuration: PostTrainingAttachment["experiments"][number]["configuration"]): {
+    dataset: {
+        id: string;
+        contentHash: string;
+    };
+    populationHash: string;
+    executionHash: string;
+};
+export declare const PostTrainingQualificationSchema: z.ZodObject<{
+    baseline: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceRunId: z.ZodString;
+        sourceManifestHash: z.ZodString;
+        targetConfigurationHash: z.ZodString;
+        executionHash: z.ZodString;
+        populationHash: z.ZodString;
+        evaluator: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        feedbackKey: z.ZodString;
+        output: z.ZodEnum<{
+            boolean: "boolean";
+            score: "score";
+        }>;
+        unit: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PostTrainingStateSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    failed: "failed";
+    queued: "queued";
+    running: "running";
+    completed: "completed";
+    budget_exhausted: "budget_exhausted";
+    ready: "ready";
+    preparing: "preparing";
+    cleaning: "cleaning";
+    blocked: "blocked";
+    waiting_for_training: "waiting_for_training";
+}>;
+export declare const PostTrainingSummarySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.postTrainingSummary.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    jobId: z.ZodString;
+    revision: z.ZodNumber;
+    planHash: z.ZodString;
+    automatic: z.ZodBoolean;
+    candidate: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    state: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        budget_exhausted: "budget_exhausted";
+        ready: "ready";
+        preparing: "preparing";
+        cleaning: "cleaning";
+        blocked: "blocked";
+        waiting_for_training: "waiting_for_training";
+    }>;
+    total: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+    requiredOutcome: z.ZodEnum<{
+        none: "none";
+        passed: "passed";
+        pending: "pending";
+        failed: "failed";
+        blocked: "blocked";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    groupId: z.ZodNullable<z.ZodString>;
+    experimentIds: z.ZodArray<z.ZodString>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type PostTrainingSummary = z.infer<typeof PostTrainingSummarySchema>;
+export declare const PostTrainingControlSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    planHash: z.ZodString;
+}, z.core.$strict>;
+export declare const AttachPostTrainingSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    attachment: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.postTrainingAttachment.v1">;
+        binding: z.ZodObject<{
+            kind: z.ZodEnum<{
+                policy: "policy";
+                preparation: "preparation";
+            }>;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        projectId: z.ZodNullable<z.ZodString>;
+        automatic: z.ZodBoolean;
+        maximumSpendUsd: z.ZodNumber;
+        experiments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            configuration: z.ZodObject<{
+                operationId: z.ZodString;
+                request: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
+                    operationId: z.ZodString;
+                    teamId: z.ZodString;
+                    modelProjectId: z.ZodNullable<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                        targetId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    taskset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"hosted_chat">;
+                        modelId: z.ZodString;
+                        localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                            providerId: z.ZodLiteral<"custom-openai-compatible">;
+                            configurationHash: z.ZodString;
+                            maximumRequestCostUsd: z.ZodNumber;
+                            requestTimeoutMs: z.ZodNumber;
+                        }, z.core.$strict>, z.ZodObject<{
+                            providerId: z.ZodLiteral<"claude-code">;
+                            configurationHash: z.ZodString;
+                            executableHash: z.ZodString;
+                            version: z.ZodString;
+                            capabilityHash: z.ZodString;
+                            maximumRequestCostUsd: z.ZodNumber;
+                            requestTimeoutMs: z.ZodNumber;
+                            maximumTurns: z.ZodNumber;
+                            holdOpen: z.ZodBoolean;
+                        }, z.core.$strict>]>>;
+                        candidate: z.ZodOptional<z.ZodObject<{
+                            artifactId: z.ZodString;
+                            contentHash: z.ZodString;
+                            preparationId: z.ZodString;
+                            dispatchId: z.ZodString;
+                            baseProfileId: z.ZodString;
+                            workerImageDigest: z.ZodString;
+                        }, z.core.$strict>>;
+                        harness: z.ZodOptional<z.ZodObject<{
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            agentSnapshot: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            sourcePackageHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            role: z.ZodEnum<{
+                                system: "system";
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            content: z.ZodString;
+                        }, z.core.$strict>>>;
+                        maxOutputTokens: z.ZodDefault<z.ZodNumber>;
+                        temperature: z.ZodDefault<z.ZodNumber>;
+                        topP: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"fixture">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"hosted_harness">;
+                        modelId: z.ZodString;
+                        candidate: z.ZodOptional<z.ZodObject<{
+                            artifactId: z.ZodString;
+                            contentHash: z.ZodString;
+                            preparationId: z.ZodString;
+                            dispatchId: z.ZodString;
+                            baseProfileId: z.ZodString;
+                            workerImageDigest: z.ZodString;
+                        }, z.core.$strict>>;
+                        sourceCandidate: z.ZodOptional<z.ZodObject<{
+                            candidateId: z.ZodString;
+                            frozenRevision: z.ZodNumber;
+                            frozenHash: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            protectedClosureHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                            high: "high";
+                            low: "low";
+                            off: "off";
+                            medium: "medium";
+                            xhigh: "xhigh";
+                            max: "max";
+                        }>>;
+                        profileRepositoryId: z.ZodString;
+                        source: z.ZodObject<{
+                            profileId: z.ZodString;
+                            sourceRevision: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            catalogHash: z.ZodString;
+                            definitionId: z.ZodString;
+                            definitionHash: 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">;
+                            environmentHash: z.ZodString;
+                            externalDatasetBinding: z.ZodOptional<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>>;
+                            sourceCandidate: z.ZodOptional<z.ZodObject<{
+                                candidateId: z.ZodString;
+                                frozenRevision: z.ZodNumber;
+                                frozenHash: z.ZodString;
+                                harnessRelease: z.ZodObject<{
+                                    id: z.ZodString;
+                                    contentHash: z.ZodString;
+                                }, z.core.$strict>;
+                                protectedClosureHash: z.ZodString;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>;
+                        modelConfigurationHash: z.ZodString;
+                        packageHash: z.ZodString;
+                        externalDatasetBinding: z.ZodOptional<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>>;
+                    }, z.core.$strict>], "kind">;
+                    population: z.ZodArray<z.ZodObject<{
+                        receiptId: z.ZodString;
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                maximumCostUsd: z.ZodNumber;
+                graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    contentHash: z.ZodString;
+                    mappings: 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>>>;
+                sourceExperimentId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        acceptancePlan: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.acceptancePlan.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            checks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                required: z.ZodBoolean;
+                role: z.ZodOptional<z.ZodEnum<{
+                    retention: "retention";
+                    quality: "quality";
+                    diagnostic: "diagnostic";
+                }>>;
+                unit: z.ZodOptional<z.ZodString>;
+                baselineReuse: z.ZodOptional<z.ZodObject<{
+                    maximumAgeSeconds: z.ZodNumber;
+                    qualification: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                evaluator: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                executionHash: z.ZodString;
+                populationHash: z.ZodString;
+                metric: z.ZodString;
+                direction: z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                }>;
+                minimumCoverage: z.ZodNumber;
+                threshold: z.ZodNumber;
+                maximumRegression: z.ZodNumber;
+                maximumSpendUsd: z.ZodNumber;
+            }, z.core.$strict>>;
+            maximumSpendUsd: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const PostTrainingPlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    attachment: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.postTrainingAttachment.v1">;
+        binding: z.ZodObject<{
+            kind: z.ZodEnum<{
+                policy: "policy";
+                preparation: "preparation";
+            }>;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        projectId: z.ZodNullable<z.ZodString>;
+        automatic: z.ZodBoolean;
+        maximumSpendUsd: z.ZodNumber;
+        experiments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            configuration: z.ZodObject<{
+                operationId: z.ZodString;
+                request: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
+                    operationId: z.ZodString;
+                    teamId: z.ZodString;
+                    modelProjectId: z.ZodNullable<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                        targetId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    taskset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"hosted_chat">;
+                        modelId: z.ZodString;
+                        localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                            providerId: z.ZodLiteral<"custom-openai-compatible">;
+                            configurationHash: z.ZodString;
+                            maximumRequestCostUsd: z.ZodNumber;
+                            requestTimeoutMs: z.ZodNumber;
+                        }, z.core.$strict>, z.ZodObject<{
+                            providerId: z.ZodLiteral<"claude-code">;
+                            configurationHash: z.ZodString;
+                            executableHash: z.ZodString;
+                            version: z.ZodString;
+                            capabilityHash: z.ZodString;
+                            maximumRequestCostUsd: z.ZodNumber;
+                            requestTimeoutMs: z.ZodNumber;
+                            maximumTurns: z.ZodNumber;
+                            holdOpen: z.ZodBoolean;
+                        }, z.core.$strict>]>>;
+                        candidate: z.ZodOptional<z.ZodObject<{
+                            artifactId: z.ZodString;
+                            contentHash: z.ZodString;
+                            preparationId: z.ZodString;
+                            dispatchId: z.ZodString;
+                            baseProfileId: z.ZodString;
+                            workerImageDigest: z.ZodString;
+                        }, z.core.$strict>>;
+                        harness: z.ZodOptional<z.ZodObject<{
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            agentSnapshot: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            sourcePackageHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            role: z.ZodEnum<{
+                                system: "system";
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            content: z.ZodString;
+                        }, z.core.$strict>>>;
+                        maxOutputTokens: z.ZodDefault<z.ZodNumber>;
+                        temperature: z.ZodDefault<z.ZodNumber>;
+                        topP: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"fixture">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"hosted_harness">;
+                        modelId: z.ZodString;
+                        candidate: z.ZodOptional<z.ZodObject<{
+                            artifactId: z.ZodString;
+                            contentHash: z.ZodString;
+                            preparationId: z.ZodString;
+                            dispatchId: z.ZodString;
+                            baseProfileId: z.ZodString;
+                            workerImageDigest: z.ZodString;
+                        }, z.core.$strict>>;
+                        sourceCandidate: z.ZodOptional<z.ZodObject<{
+                            candidateId: z.ZodString;
+                            frozenRevision: z.ZodNumber;
+                            frozenHash: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            protectedClosureHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                            high: "high";
+                            low: "low";
+                            off: "off";
+                            medium: "medium";
+                            xhigh: "xhigh";
+                            max: "max";
+                        }>>;
+                        profileRepositoryId: z.ZodString;
+                        source: z.ZodObject<{
+                            profileId: z.ZodString;
+                            sourceRevision: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            catalogHash: z.ZodString;
+                            definitionId: z.ZodString;
+                            definitionHash: 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">;
+                            environmentHash: z.ZodString;
+                            externalDatasetBinding: z.ZodOptional<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>>;
+                            sourceCandidate: z.ZodOptional<z.ZodObject<{
+                                candidateId: z.ZodString;
+                                frozenRevision: z.ZodNumber;
+                                frozenHash: z.ZodString;
+                                harnessRelease: z.ZodObject<{
+                                    id: z.ZodString;
+                                    contentHash: z.ZodString;
+                                }, z.core.$strict>;
+                                protectedClosureHash: z.ZodString;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>;
+                        modelConfigurationHash: z.ZodString;
+                        packageHash: z.ZodString;
+                        externalDatasetBinding: z.ZodOptional<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>>;
+                    }, z.core.$strict>], "kind">;
+                    population: z.ZodArray<z.ZodObject<{
+                        receiptId: z.ZodString;
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                maximumCostUsd: z.ZodNumber;
+                graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    contentHash: z.ZodString;
+                    mappings: 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>>>;
+                sourceExperimentId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        acceptancePlan: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.acceptancePlan.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            checks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                required: z.ZodBoolean;
+                role: z.ZodOptional<z.ZodEnum<{
+                    retention: "retention";
+                    quality: "quality";
+                    diagnostic: "diagnostic";
+                }>>;
+                unit: z.ZodOptional<z.ZodString>;
+                baselineReuse: z.ZodOptional<z.ZodObject<{
+                    maximumAgeSeconds: z.ZodNumber;
+                    qualification: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                evaluator: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                executionHash: z.ZodString;
+                populationHash: z.ZodString;
+                metric: z.ZodString;
+                direction: z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                }>;
+                minimumCoverage: z.ZodNumber;
+                threshold: z.ZodNumber;
+                maximumRegression: z.ZodNumber;
+                maximumSpendUsd: z.ZodNumber;
+            }, z.core.$strict>>;
+            maximumSpendUsd: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    qualification: z.ZodNullable<z.ZodObject<{
+        baseline: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sourceRunId: z.ZodString;
+            sourceManifestHash: z.ZodString;
+            targetConfigurationHash: z.ZodString;
+            executionHash: z.ZodString;
+            populationHash: z.ZodString;
+            evaluator: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            feedbackKey: z.ZodString;
+            output: z.ZodEnum<{
+                boolean: "boolean";
+                score: "score";
+            }>;
+            unit: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type PostTrainingPlan = z.infer<typeof PostTrainingPlanSchema>;
+export declare function verifyPostTrainingPlan(raw: unknown): PostTrainingPlan;
+export declare function postTrainingActive(summary: PostTrainingSummary | null | undefined): boolean;
+/** Read/setup are configuration-only. Manual start authorizes exactly the
+ * retained candidate, plan and revision. A retry never launches training. */
+export declare function createPostTrainingClient(input: {
+    request: (path: string, init?: RequestInit) => Promise<unknown>;
+}): {
+    attach(teamId: string, raw: z.input<typeof AttachPostTrainingSchema>): Promise<{
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        attachment: {
+            schemaVersion: "openpond.postTrainingAttachment.v1";
+            binding: {
+                kind: "policy" | "preparation";
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            projectId: string | null;
+            automatic: boolean;
+            maximumSpendUsd: number;
+            experiments: {
+                id: string;
+                configuration: {
+                    operationId: string;
+                    request: {
+                        schemaVersion: "openpond.modelTasksetRunRequest.v1";
+                        operationId: string;
+                        teamId: string;
+                        modelProjectId: string | null;
+                        taskset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        policy: {
+                            kind: "hosted_chat";
+                            modelId: string;
+                            maxOutputTokens: number;
+                            temperature: number;
+                            topP: number;
+                            localRuntime?: {
+                                providerId: "claude-code";
+                                configurationHash: string;
+                                executableHash: string;
+                                version: string;
+                                capabilityHash: string;
+                                maximumRequestCostUsd: number;
+                                requestTimeoutMs: number;
+                                maximumTurns: number;
+                                holdOpen: boolean;
+                            } | {
+                                providerId: "custom-openai-compatible";
+                                configurationHash: string;
+                                maximumRequestCostUsd: number;
+                                requestTimeoutMs: number;
+                            } | undefined;
+                            candidate?: {
+                                artifactId: string;
+                                contentHash: string;
+                                preparationId: string;
+                                dispatchId: string;
+                                baseProfileId: string;
+                                workerImageDigest: string;
+                            } | undefined;
+                            harness?: {
+                                harnessRelease: {
+                                    id: string;
+                                    contentHash: string;
+                                };
+                                agentSnapshot: {
+                                    id: string;
+                                    contentHash: string;
+                                };
+                                sourcePackageHash: string;
+                            } | undefined;
+                            messages?: {
+                                role: "system" | "user" | "assistant";
+                                content: string;
+                            }[] | undefined;
+                        } | {
+                            kind: "hosted_harness";
+                            modelId: string;
+                            profileRepositoryId: string;
+                            source: {
+                                profileId: string;
+                                sourceRevision: string;
+                                harnessRelease: {
+                                    id: string;
+                                    contentHash: string;
+                                };
+                                catalogHash: string;
+                                definitionId: string;
+                                definitionHash: string;
+                                target: {
+                                    kind: "profile";
+                                } | {
+                                    kind: "workflow";
+                                    workflowId: string;
+                                } | {
+                                    kind: "skill";
+                                    skillPath: string;
+                                } | {
+                                    kind: "agent_action";
+                                    actionId: string;
+                                };
+                                environmentHash: string;
+                                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;
+                                } | undefined;
+                                sourceCandidate?: {
+                                    candidateId: string;
+                                    frozenRevision: number;
+                                    frozenHash: string;
+                                    harnessRelease: {
+                                        id: string;
+                                        contentHash: string;
+                                    };
+                                    protectedClosureHash: string;
+                                } | undefined;
+                            };
+                            modelConfigurationHash: string;
+                            packageHash: string;
+                            candidate?: {
+                                artifactId: string;
+                                contentHash: string;
+                                preparationId: string;
+                                dispatchId: string;
+                                baseProfileId: string;
+                                workerImageDigest: string;
+                            } | undefined;
+                            sourceCandidate?: {
+                                candidateId: string;
+                                frozenRevision: number;
+                                frozenHash: string;
+                                harnessRelease: {
+                                    id: string;
+                                    contentHash: string;
+                                };
+                                protectedClosureHash: string;
+                            } | undefined;
+                            reasoningEffort?: "high" | "low" | "off" | "medium" | "xhigh" | "max" | undefined;
+                            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;
+                            } | undefined;
+                        } | {
+                            kind: "fixture";
+                        };
+                        population: {
+                            receiptId: string;
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        name?: string | undefined;
+                        project?: {
+                            id: string;
+                            revision: number;
+                            contentHash: string;
+                            targetId: string | null;
+                        } | undefined;
+                    };
+                    maximumCostUsd: number;
+                    graders?: {
+                        id: string;
+                        version: string;
+                        contentHash: string;
+                        mappings: {
+                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            path: string[];
+                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            sourcePath: string[];
+                        }[];
+                    }[] | undefined;
+                    sourceExperimentId?: string | undefined;
+                };
+            }[];
+            acceptancePlan: {
+                schemaVersion: "openpond.acceptancePlan.v1";
+                id: string;
+                revision: number;
+                checks: {
+                    id: string;
+                    name: string;
+                    required: boolean;
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evaluator: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    executionHash: string;
+                    populationHash: string;
+                    metric: string;
+                    direction: "higher" | "lower";
+                    minimumCoverage: number;
+                    threshold: number;
+                    maximumRegression: number;
+                    maximumSpendUsd: number;
+                    role?: "retention" | "quality" | "diagnostic" | undefined;
+                    unit?: string | undefined;
+                    baselineReuse?: {
+                        maximumAgeSeconds: number;
+                        qualification: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                }[];
+                maximumSpendUsd: number;
+                contentHash: string;
+            } | null;
+        };
+        qualification: {
+            baseline: {
+                id: string;
+                contentHash: string;
+            };
+            checks: {
+                id: string;
+                sourceRunId: string;
+                sourceManifestHash: string;
+                targetConfigurationHash: string;
+                executionHash: string;
+                populationHash: string;
+                evaluator: {
+                    id: string;
+                    contentHash: string;
+                };
+                feedbackKey: string;
+                output: "boolean" | "score";
+                unit: string;
+            }[];
+        } | null;
+        contentHash: string;
+        createdAt: string;
+    }>;
+    get(teamId: string, jobId: string): Promise<{
+        schemaVersion: "openpond.postTrainingSummary.v1";
+        id: string;
+        teamId: string;
+        jobId: string;
+        revision: number;
+        planHash: string;
+        automatic: boolean;
+        candidate: {
+            id: string;
+            contentHash: string;
+        } | null;
+        state: "cancelled" | "failed" | "queued" | "running" | "completed" | "budget_exhausted" | "ready" | "preparing" | "cleaning" | "blocked" | "waiting_for_training";
+        total: number;
+        completed: number;
+        failed: number;
+        requiredOutcome: "none" | "passed" | "pending" | "failed" | "blocked";
+        reason: string | null;
+        groupId: string | null;
+        experimentIds: string[];
+        updatedAt: string;
+    } | null>;
+    control(teamId: string, jobId: string, action: "start" | "retry" | "cancel", raw: z.input<typeof PostTrainingControlSchema>): Promise<{
+        schemaVersion: "openpond.postTrainingSummary.v1";
+        id: string;
+        teamId: string;
+        jobId: string;
+        revision: number;
+        planHash: string;
+        automatic: boolean;
+        candidate: {
+            id: string;
+            contentHash: string;
+        } | null;
+        state: "cancelled" | "failed" | "queued" | "running" | "completed" | "budget_exhausted" | "ready" | "preparing" | "cleaning" | "blocked" | "waiting_for_training";
+        total: number;
+        completed: number;
+        failed: number;
+        requiredOutcome: "none" | "passed" | "pending" | "failed" | "blocked";
+        reason: string | null;
+        groupId: string | null;
+        experimentIds: string[];
+        updatedAt: string;
+    }>;
+};
+export declare const HostedTrainingSetupCatalogSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    configuration: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                local: "local";
+                managed: "managed";
+                builtin: "builtin";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+                sdft: "sdft";
+                opd: "opd";
+                opsd: "opsd";
+                sdpo: "sdpo";
+            }>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    local: "local";
+                    managed: "managed";
+                    builtin: "builtin";
+                }>;
+            }, z.core.$strict>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                fast: "fast";
+                balanced: "balanced";
+                economical: "economical";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                standard: "standard";
+                small_experiment: "small_experiment";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    sft: "sft";
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    opd: "opd";
+                    opsd: "opsd";
+                    sdpo: "sdpo";
+                }>;
+                parameterization: z.ZodEnum<{
+                    lora: "lora";
+                    full: "full";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    batches: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskBatch.v1">;
+        id: z.ZodString;
+        revision: z.ZodLiteral<1>;
+        taskDefinition: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        rewardBinding: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        purpose: z.ZodEnum<{
+            evaluation: "evaluation";
+            supervised_training: "supervised_training";
+            reward_training: "reward_training";
+        }>;
+        examples: z.ZodArray<z.ZodObject<{
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            decision: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            familyKey: z.ZodString;
+            inputHash: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+        }, z.core.$strict>>;
+        sealedAt: z.ZodString;
+        sealedBy: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            work: "work";
+            provider: "provider";
+            direct: "direct";
+            benchmark: "benchmark";
+            opentelemetry: "opentelemetry";
+        }>;
+        taskDefinition: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        enabled: z.ZodBoolean;
+        allowedSplits: z.ZodArray<z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>>;
+        mapping: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
+            exampleId: z.ZodString;
+            attemptId: z.ZodString;
+            occurredAt: z.ZodString;
+            input: z.ZodString;
+            observedOutput: z.ZodNullable<z.ZodString>;
+            expected: z.ZodNullable<z.ZodString>;
+            evaluatorContext: z.ZodNullable<z.ZodString>;
+            familyKey: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+        }, z.core.$strict>>;
+        adapterVersion: z.ZodNullable<z.ZodString>;
+        reviewOrigin: z.ZodOptional<z.ZodObject<{
+            modelId: z.ZodString;
+            packageHash: z.ZodString;
+            taskset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            batch: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            rewardBinding: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        capturedOrigin: z.ZodOptional<z.ZodObject<{
+            receiptId: z.ZodString;
+            ownerUserId: z.ZodString;
+            modelId: z.ZodString;
+            packageHash: z.ZodString;
+            taskset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    definitions: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        instructions: z.ZodString;
+        category: z.ZodEnum<{
+            custom: "custom";
+            structured: "structured";
+            question_answering: "question_answering";
+            coding: "coding";
+            tool_workflow: "tool_workflow";
+        }>;
+        familyNamespace: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            schemaRef: z.ZodDefault<z.ZodNullable<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>>>;
+            maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+        contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rewardBinding: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        harness: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            policy: z.ZodObject<{
+                policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+            environment: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
+                kind: z.ZodEnum<{
+                    text: "text";
+                    agent: "agent";
+                    work: "work";
+                    custom_program: "custom_program";
+                }>;
+                entrypoint: z.ZodString;
+                stateful: z.ZodBoolean;
+                deterministicSeeds: z.ZodBoolean;
+                lifecycle: z.ZodArray<z.ZodEnum<{
+                    step: "step";
+                    create: "create";
+                    reset: "reset";
+                    collect: "collect";
+                    destroy: "destroy";
+                }>>;
+                networkPolicy: z.ZodEnum<{
+                    none: "none";
+                    declared_read_only: "declared_read_only";
+                    declared_scoped: "declared_scoped";
+                }>;
+                defaultTimeoutMs: z.ZodNumber;
+            }, z.core.$strict>;
+            environmentRelease: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, 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>>;
+            capabilities: 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>>;
+            verifierSetRelease: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    experiments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        configuration: z.ZodObject<{
+            operationId: z.ZodString;
+            request: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
+                operationId: z.ZodString;
+                teamId: z.ZodString;
+                modelProjectId: z.ZodNullable<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                    targetId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                taskset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"hosted_chat">;
+                    modelId: z.ZodString;
+                    localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        providerId: z.ZodLiteral<"custom-openai-compatible">;
+                        configurationHash: z.ZodString;
+                        maximumRequestCostUsd: z.ZodNumber;
+                        requestTimeoutMs: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        providerId: z.ZodLiteral<"claude-code">;
+                        configurationHash: z.ZodString;
+                        executableHash: z.ZodString;
+                        version: z.ZodString;
+                        capabilityHash: z.ZodString;
+                        maximumRequestCostUsd: z.ZodNumber;
+                        requestTimeoutMs: z.ZodNumber;
+                        maximumTurns: z.ZodNumber;
+                        holdOpen: z.ZodBoolean;
+                    }, z.core.$strict>]>>;
+                    candidate: z.ZodOptional<z.ZodObject<{
+                        artifactId: z.ZodString;
+                        contentHash: z.ZodString;
+                        preparationId: z.ZodString;
+                        dispatchId: z.ZodString;
+                        baseProfileId: z.ZodString;
+                        workerImageDigest: z.ZodString;
+                    }, z.core.$strict>>;
+                    harness: z.ZodOptional<z.ZodObject<{
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        agentSnapshot: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        sourcePackageHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        role: z.ZodEnum<{
+                            system: "system";
+                            user: "user";
+                            assistant: "assistant";
+                        }>;
+                        content: z.ZodString;
+                    }, z.core.$strict>>>;
+                    maxOutputTokens: z.ZodDefault<z.ZodNumber>;
+                    temperature: z.ZodDefault<z.ZodNumber>;
+                    topP: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fixture">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"hosted_harness">;
+                    modelId: z.ZodString;
+                    candidate: z.ZodOptional<z.ZodObject<{
+                        artifactId: z.ZodString;
+                        contentHash: z.ZodString;
+                        preparationId: z.ZodString;
+                        dispatchId: z.ZodString;
+                        baseProfileId: z.ZodString;
+                        workerImageDigest: z.ZodString;
+                    }, z.core.$strict>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        off: "off";
+                        medium: "medium";
+                        xhigh: "xhigh";
+                        max: "max";
+                    }>>;
+                    profileRepositoryId: z.ZodString;
+                    source: z.ZodObject<{
+                        profileId: z.ZodString;
+                        sourceRevision: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        catalogHash: z.ZodString;
+                        definitionId: z.ZodString;
+                        definitionHash: 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">;
+                        environmentHash: z.ZodString;
+                        externalDatasetBinding: z.ZodOptional<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>>;
+                        sourceCandidate: z.ZodOptional<z.ZodObject<{
+                            candidateId: z.ZodString;
+                            frozenRevision: z.ZodNumber;
+                            frozenHash: z.ZodString;
+                            harnessRelease: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            protectedClosureHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    modelConfigurationHash: z.ZodString;
+                    packageHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<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>>;
+                }, z.core.$strict>], "kind">;
+                population: z.ZodArray<z.ZodObject<{
+                    receiptId: z.ZodString;
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            maximumCostUsd: z.ZodNumber;
+            graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+                contentHash: z.ZodString;
+                mappings: 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>>>;
+            sourceExperimentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        graders: z.ZodArray<z.ZodObject<{
+            feedbackKey: z.ZodString;
+            name: z.ZodString;
+            ref: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HostedTrainingSetupCatalog = z.infer<typeof HostedTrainingSetupCatalogSchema>;
+export declare const HostedTrainingSetupActionSchema: z.ZodEnum<{
+    start: "start";
+    cancel: "cancel";
+    prepare: "prepare";
+    publish: "publish";
+    attach: "attach";
+}>;
+export type HostedTrainingSetupAction = z.infer<typeof HostedTrainingSetupActionSchema>;
+export declare const HostedTrainingPolicyDetailSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    configuration: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                local: "local";
+                managed: "managed";
+                builtin: "builtin";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+                sdft: "sdft";
+                opd: "opd";
+                opsd: "opsd";
+                sdpo: "sdpo";
+            }>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    local: "local";
+                    managed: "managed";
+                    builtin: "builtin";
+                }>;
+            }, z.core.$strict>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                fast: "fast";
+                balanced: "balanced";
+                economical: "economical";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                standard: "standard";
+                small_experiment: "small_experiment";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    sft: "sft";
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    opd: "opd";
+                    opsd: "opsd";
+                    sdpo: "sdpo";
+                }>;
+                parameterization: z.ZodEnum<{
+                    lora: "lora";
+                    full: "full";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        origin: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
+            teamId: z.ZodString;
+            projectId: z.ZodNullable<z.ZodString>;
+            configurationId: z.ZodString;
+            source: z.ZodObject<{
+                executionId: z.ZodString;
+                passId: z.ZodNullable<z.ZodString>;
+                manifestHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"harness">;
+                source: z.ZodObject<{
+                    profileId: z.ZodString;
+                    sourceRevision: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    catalogHash: z.ZodString;
+                    definitionId: z.ZodString;
+                    definitionHash: 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">;
+                    environmentHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<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>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                source: z.ZodObject<{
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    agentSnapshot: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    sourcePackageHash: z.ZodString;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            graders: z.ZodArray<z.ZodObject<{
+                feedbackKey: z.ZodString;
+                evaluator: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                expectedCount: z.ZodNumber;
+                scoredCount: z.ZodNumber;
+                score: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelProjectId: z.ZodString;
+        executionOwner: z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+        }>;
+        enabled: z.ZodBoolean;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        taskDefinition: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        rewardBinding: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        admission: z.ZodObject<{
+            mode: z.ZodEnum<{
+                human: "human";
+                qualified_automatic: "qualified_automatic";
+            }>;
+            qualification: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            minimumApprovedExamples: z.ZodNumber;
+        }, z.core.$strict>;
+        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"approved_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schedule">;
+            intervalSeconds: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            localTime: z.ZodString;
+            timeZone: z.ZodString;
+            kind: z.ZodLiteral<"nightly">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"upstream_accepted">;
+            modelProjectId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        trainingParent: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        teacher: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        training: z.ZodObject<{
+            method: z.ZodEnum<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+                sdft: "sdft";
+                opd: "opd";
+                opsd: "opsd";
+                sdpo: "sdpo";
+            }>;
+            recipe: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            retentionEvaluation: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            replayBatches: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maxIterationSpendUsd: z.ZodNumber;
+            maxDailySpendUsd: z.ZodNumber;
+            cooldownSeconds: z.ZodNumber;
+            maxRetries: z.ZodNumber;
+            maxBatchExamples: z.ZodNumber;
+            maxBacklogExamples: z.ZodNumber;
+        }, z.core.$strict>;
+        automation: z.ZodObject<{
+            collect: z.ZodBoolean;
+            train: z.ZodBoolean;
+            accept: z.ZodBoolean;
+            serve: z.ZodBoolean;
+        }, z.core.$strict>;
+        acceptance: z.ZodObject<{
+            minimumScore: z.ZodNumber;
+            maximumRetentionRegression: z.ZodNumber;
+            requireImprovement: z.ZodBoolean;
+            rollbackVersion: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    inspection: z.ZodObject<{
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        modelProjectId: z.ZodString;
+        inspectedAt: z.ZodString;
+        chain: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.learningChain.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            modelProjectId: z.ZodString;
+            activeIterationId: z.ZodNullable<z.ZodString>;
+            acceptedParent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                iterationId: z.ZodString;
+                iterationRevision: z.ZodNumber;
+                candidate: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                decidedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            latestIterationId: z.ZodString;
+            lastReservedAt: z.ZodNullable<z.ZodString>;
+            updatedAt: z.ZodString;
+        }, z.core.$strict>>;
+        trainingParent: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            reference: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            selection: z.ZodNullable<z.ZodObject<{
+                iterationId: z.ZodString;
+                iterationRevision: z.ZodNumber;
+                candidate: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                decidedAt: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        counts: z.ZodNullable<z.ZodObject<{
+            eligible: z.ZodNumber;
+            awaitingReview: z.ZodNumber;
+            excluded: z.ZodNumber;
+            consumed: z.ZodNumber;
+        }, z.core.$strict>>;
+        minimumApprovedExamples: z.ZodNumber;
+        canReserve: z.ZodBoolean;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        cooldownUntil: z.ZodNullable<z.ZodString>;
+        budget: z.ZodObject<{
+            reservedSpendUsd: z.ZodNumber;
+            settledSpendUsd: z.ZodNumber;
+            committedSpendUsd: z.ZodNumber;
+            maximumIterationSpendUsd: z.ZodNumber;
+            maximumDailySpendUsd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    iterations: z.ZodArray<z.ZodObject<{
+        iteration: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            policy: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                accepted: "accepted";
+                rejected: "rejected";
+                cancelled: "cancelled";
+                failed: "failed";
+                training: "training";
+                waiting_for_data: "waiting_for_data";
+                waiting_for_review: "waiting_for_review";
+                ready: "ready";
+                dispatching: "dispatching";
+                evaluating: "evaluating";
+                candidate_ready: "candidate_ready";
+                paused: "paused";
+                cancelling: "cancelling";
+                completed_without_candidate: "completed_without_candidate";
+            }>;
+            triggerIdentity: z.ZodString;
+            batch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            sourceWatermarks: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            trainingParent: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            trainingParentSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                iterationId: z.ZodString;
+                iterationRevision: z.ZodNumber;
+                candidate: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                decidedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            teacher: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            upstreamEvent: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            trainingJob: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            evaluationJob: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            candidateVersion: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            candidateDecision: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            candidateDecisionAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            dispatchId: z.ZodString;
+            retryCount: z.ZodNumber;
+            spendUsd: z.ZodNumber;
+            failure: z.ZodNullable<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strict>;
+        evals: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.postTrainingSummary.v1">;
+            id: z.ZodString;
+            teamId: z.ZodString;
+            jobId: z.ZodString;
+            revision: z.ZodNumber;
+            planHash: z.ZodString;
+            automatic: z.ZodBoolean;
+            candidate: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            state: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                queued: "queued";
+                running: "running";
+                completed: "completed";
+                budget_exhausted: "budget_exhausted";
+                ready: "ready";
+                preparing: "preparing";
+                cleaning: "cleaning";
+                blocked: "blocked";
+                waiting_for_training: "waiting_for_training";
+            }>;
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+            requiredOutcome: z.ZodEnum<{
+                none: "none";
+                passed: "passed";
+                pending: "pending";
+                failed: "failed";
+                blocked: "blocked";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+            groupId: z.ZodNullable<z.ZodString>;
+            experimentIds: z.ZodArray<z.ZodString>;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const HostedTrainingPolicyControlSchema: z.ZodObject<{
+    id: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    policyHash: z.ZodString;
+    operationId: z.ZodString;
+    action: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+        reserve: "reserve";
+        "cancel-iteration": "cancel-iteration";
+        "retry-iteration": "retry-iteration";
+    }>;
+    iterationId: z.ZodOptional<z.ZodString>;
+    iterationRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type HostedTrainingPolicyControl = z.infer<typeof HostedTrainingPolicyControlSchema>;
+//# sourceMappingURL=post-training.d.ts.map