openpond-sdk 0.12.2 → 0.12.4

package/dist/types/packages/sdk/src/training.d.ts

@@ -7,6 +7,7 @@ export { TrainingCandidateDecisionRequestSchema, TrainingCandidateDecisionSchema
 export { deterministicTrainingRewardSource } from "./training-grading-plan.js";
 export { TRAINING_EVALUATION_SOURCE_PATH, TrainingEvaluationSourceSchema, assertTrainingEvaluationIsolation, trainingEvaluationSourceRef, type TrainingEvaluationSource, } from "./training-evaluation-source.js";
 export { TrainingEvaluationTaskResultSchema, TrainingEvaluationTaskPageSchema, trainingEvaluationTaskPageHash, parseAndVerifyTrainingEvaluationTaskPage, type TrainingEvaluationTaskResult, type TrainingEvaluationTaskPage, } from "./training-evaluation-results.js";
+import { ModelProjectBaseModelSchema } from "./model-projects.js";
 export { OPENPOND_TRAINING_MEDIA_TYPE, OPENPOND_TRAINING_PROTOCOL_MAJOR, TRAINING_API_RESPONSE_MAX_BYTES, TRAINING_INPUT_ARTIFACT_MAX_BYTES, TRAINING_JOB_SUBMISSION_MAX_BYTES, OpenPondProtocolError, assertCanonicalPayloadSize, canonicalJson, canonicalJsonByteLength, canonicalSha256, parseBoundedJson, } from "./protocol.js";
 /**
  * Stages a content-addressed immutable input before Job admission. The payload
@@ -46,19 +47,19 @@ export declare const TrainingInputArtifactSchema: z.ZodObject<{
 export declare function trainingInputArtifactUploadHash(upload: Omit<TrainingInputArtifactUpload, "contentHash"> | TrainingInputArtifactUpload): Promise<string>;
 export declare function parseAndVerifyTrainingInputArtifactUpload(value: unknown): Promise<TrainingInputArtifactUpload>;
 export declare const TrainingJobKindSchema: z.ZodEnum<{
-    reward_model_train: "reward_model_train";
     policy_optimize: "policy_optimize";
+    reward_model_train: "reward_model_train";
 }>;
 export declare const TrainingJobStateSchema: z.ZodEnum<{
-    succeeded: "succeeded";
+    admitting: "admitting";
     cancelled: "cancelled";
+    cancelling: "cancelling";
     failed: "failed";
+    provisioning: "provisioning";
     queued: "queued";
     running: "running";
-    cancelling: "cancelling";
-    admitting: "admitting";
-    provisioning: "provisioning";
     stopping: "stopping";
+    succeeded: "succeeded";
 }>;
 export declare const TrainingCapabilityRequirementSchema: z.ZodObject<{
     id: z.ZodString;
@@ -163,10 +164,10 @@ export declare const TrainingJobSourceSchema: z.ZodObject<{
                         }, z.core.$strict>;
                     }, z.core.$strict>>;
                     split: z.ZodEnum<{
+                        frozen_eval: "frozen_eval";
+                        test: "test";
                         train: "train";
                         validation: "validation";
-                        test: "test";
-                        frozen_eval: "frozen_eval";
                     }>;
                     population: z.ZodArray<z.ZodObject<{
                         taskId: z.ZodString;
@@ -183,8 +184,8 @@ export declare const TrainingJobSourceSchema: z.ZodObject<{
                         configurationHash: z.ZodString;
                         output: z.ZodEnum<{
                             boolean: "boolean";
-                            score: "score";
                             category: "category";
+                            score: "score";
                         }>;
                         categories: z.ZodArray<z.ZodString>;
                     }, z.core.$strict>>;
@@ -193,17 +194,17 @@ export declare const TrainingJobSourceSchema: z.ZodObject<{
                         graderId: z.ZodString;
                         fields: z.ZodArray<z.ZodObject<{
                             destination: z.ZodEnum<{
-                                output: "output";
-                                input: "input";
-                                expectedOutput: "expectedOutput";
                                 evaluatorContext: "evaluatorContext";
+                                expectedOutput: "expectedOutput";
+                                input: "input";
+                                output: "output";
                             }>;
                             path: z.ZodArray<z.ZodString>;
                             source: z.ZodEnum<{
-                                output: "output";
-                                input: "input";
-                                expectedOutput: "expectedOutput";
                                 evaluatorContext: "evaluatorContext";
+                                expectedOutput: "expectedOutput";
+                                input: "input";
+                                output: "output";
                             }>;
                             sourcePath: z.ZodArray<z.ZodString>;
                         }, z.core.$strict>>;
@@ -317,9 +318,9 @@ export declare const RewardModelTrainingRequestSchema: z.ZodObject<{
         chatTemplateHash: z.ZodNullable<z.ZodString>;
         modelAssetId: z.ZodNullable<z.ZodString>;
         source: z.ZodEnum<{
+            builtin: "builtin";
             local: "local";
             managed: "managed";
-            builtin: "builtin";
         }>;
     }, z.core.$strict>;
     preferenceDatasetRelease: z.ZodObject<{
@@ -336,8 +337,22 @@ export declare const RewardModelTrainingRequestSchema: z.ZodObject<{
         parameterization: z.ZodLiteral<"lora_with_scalar_head">;
     }, z.core.$catchall<z.ZodUnknown>>;
 }, z.core.$strict>;
+export declare const TrainingQualificationBaseModelSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+    modelId: z.ZodString;
+    modelAssetId: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        builtin: "builtin";
+        local: "local";
+        managed: "managed";
+    }>;
+    revision: z.ZodString;
+    tokenizerRevision: z.ZodString;
+    chatTemplateHash: z.ZodString;
+}, z.core.$strict>;
 export declare const PolicyOptimizationRequestSchema: z.ZodObject<{
     kind: z.ZodLiteral<"policy_optimize">;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     baseModel: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
         modelId: z.ZodString;
@@ -346,26 +361,26 @@ export declare const PolicyOptimizationRequestSchema: z.ZodObject<{
         chatTemplateHash: z.ZodNullable<z.ZodString>;
         modelAssetId: z.ZodNullable<z.ZodString>;
         source: z.ZodEnum<{
+            builtin: "builtin";
             local: "local";
             managed: "managed";
-            builtin: "builtin";
         }>;
     }, z.core.$strict>;
     recipe: z.ZodObject<{
         schemaVersion: z.ZodString;
         method: z.ZodEnum<{
-            sft: "sft";
             dpo: "dpo";
             grpo: "grpo";
-            ppo: "ppo";
-            sdft: "sdft";
             opd: "opd";
             opsd: "opsd";
+            ppo: "ppo";
+            sdft: "sdft";
             sdpo: "sdpo";
+            sft: "sft";
         }>;
         parameterization: z.ZodEnum<{
-            lora: "lora";
             full: "full";
+            lora: "lora";
         }>;
     }, z.core.$catchall<z.ZodUnknown>>;
     rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -424,9 +439,9 @@ export declare const TrainingJobRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         chatTemplateHash: z.ZodNullable<z.ZodString>;
         modelAssetId: z.ZodNullable<z.ZodString>;
         source: z.ZodEnum<{
+            builtin: "builtin";
             local: "local";
             managed: "managed";
-            builtin: "builtin";
         }>;
     }, z.core.$strict>;
     preferenceDatasetRelease: z.ZodObject<{
@@ -444,6 +459,7 @@ export declare const TrainingJobRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     }, z.core.$catchall<z.ZodUnknown>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"policy_optimize">;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     baseModel: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
         modelId: z.ZodString;
@@ -452,26 +468,26 @@ export declare const TrainingJobRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         chatTemplateHash: z.ZodNullable<z.ZodString>;
         modelAssetId: z.ZodNullable<z.ZodString>;
         source: z.ZodEnum<{
+            builtin: "builtin";
             local: "local";
             managed: "managed";
-            builtin: "builtin";
         }>;
     }, z.core.$strict>;
     recipe: z.ZodObject<{
         schemaVersion: z.ZodString;
         method: z.ZodEnum<{
-            sft: "sft";
             dpo: "dpo";
             grpo: "grpo";
-            ppo: "ppo";
-            sdft: "sdft";
             opd: "opd";
             opsd: "opsd";
+            ppo: "ppo";
+            sdft: "sdft";
             sdpo: "sdpo";
+            sft: "sft";
         }>;
         parameterization: z.ZodEnum<{
-            lora: "lora";
             full: "full";
+            lora: "lora";
         }>;
     }, z.core.$catchall<z.ZodUnknown>>;
     rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -630,10 +646,10 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
                             }, z.core.$strict>;
                         }, z.core.$strict>>;
                         split: z.ZodEnum<{
+                            frozen_eval: "frozen_eval";
+                            test: "test";
                             train: "train";
                             validation: "validation";
-                            test: "test";
-                            frozen_eval: "frozen_eval";
                         }>;
                         population: z.ZodArray<z.ZodObject<{
                             taskId: z.ZodString;
@@ -650,8 +666,8 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
                             configurationHash: z.ZodString;
                             output: z.ZodEnum<{
                                 boolean: "boolean";
-                                score: "score";
                                 category: "category";
+                                score: "score";
                             }>;
                             categories: z.ZodArray<z.ZodString>;
                         }, z.core.$strict>>;
@@ -660,17 +676,17 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
                             graderId: z.ZodString;
                             fields: z.ZodArray<z.ZodObject<{
                                 destination: z.ZodEnum<{
-                                    output: "output";
-                                    input: "input";
-                                    expectedOutput: "expectedOutput";
                                     evaluatorContext: "evaluatorContext";
+                                    expectedOutput: "expectedOutput";
+                                    input: "input";
+                                    output: "output";
                                 }>;
                                 path: z.ZodArray<z.ZodString>;
                                 source: z.ZodEnum<{
-                                    output: "output";
-                                    input: "input";
-                                    expectedOutput: "expectedOutput";
                                     evaluatorContext: "evaluatorContext";
+                                    expectedOutput: "expectedOutput";
+                                    input: "input";
+                                    output: "output";
                                 }>;
                                 sourcePath: z.ZodArray<z.ZodString>;
                             }, z.core.$strict>>;
@@ -784,9 +800,9 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
             chatTemplateHash: z.ZodNullable<z.ZodString>;
             modelAssetId: z.ZodNullable<z.ZodString>;
             source: z.ZodEnum<{
+                builtin: "builtin";
                 local: "local";
                 managed: "managed";
-                builtin: "builtin";
             }>;
         }, z.core.$strict>;
         preferenceDatasetRelease: z.ZodObject<{
@@ -804,6 +820,7 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
         }, z.core.$catchall<z.ZodUnknown>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"policy_optimize">;
+        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
         baseModel: z.ZodObject<{
             schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
             modelId: z.ZodString;
@@ -812,26 +829,26 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
             chatTemplateHash: z.ZodNullable<z.ZodString>;
             modelAssetId: z.ZodNullable<z.ZodString>;
             source: z.ZodEnum<{
+                builtin: "builtin";
                 local: "local";
                 managed: "managed";
-                builtin: "builtin";
             }>;
         }, z.core.$strict>;
         recipe: z.ZodObject<{
             schemaVersion: z.ZodString;
             method: z.ZodEnum<{
-                sft: "sft";
                 dpo: "dpo";
                 grpo: "grpo";
-                ppo: "ppo";
-                sdft: "sdft";
                 opd: "opd";
                 opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
                 sdpo: "sdpo";
+                sft: "sft";
             }>;
             parameterization: z.ZodEnum<{
-                lora: "lora";
                 full: "full";
+                lora: "lora";
             }>;
         }, z.core.$catchall<z.ZodUnknown>>;
         rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -886,9 +903,9 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
         required: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
     placementObjective: z.ZodEnum<{
-        fast: "fast";
         balanced: "balanced";
         economical: "economical";
+        fast: "fast";
     }>;
     budget: z.ZodObject<{
         maximumSpendUsd: z.ZodNumber;
@@ -911,23 +928,24 @@ export declare const TrainingJobSchema: z.ZodObject<{
     id: z.ZodString;
     teamId: z.ZodString;
     kind: z.ZodEnum<{
-        reward_model_train: "reward_model_train";
         policy_optimize: "policy_optimize";
+        reward_model_train: "reward_model_train";
     }>;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     modelProjectId: z.ZodString;
     portableProjectId: z.ZodString;
     sourceProjectRevision: z.ZodNumber;
     submissionHash: z.ZodString;
     state: z.ZodEnum<{
-        succeeded: "succeeded";
+        admitting: "admitting";
         cancelled: "cancelled";
+        cancelling: "cancelling";
         failed: "failed";
+        provisioning: "provisioning";
         queued: "queued";
         running: "running";
-        cancelling: "cancelling";
-        admitting: "admitting";
-        provisioning: "provisioning";
         stopping: "stopping";
+        succeeded: "succeeded";
     }>;
     phase: z.ZodString;
     version: z.ZodNumber;
@@ -951,23 +969,24 @@ export declare const TrainingJobPageSchema: z.ZodObject<{
         id: z.ZodString;
         teamId: z.ZodString;
         kind: z.ZodEnum<{
-            reward_model_train: "reward_model_train";
             policy_optimize: "policy_optimize";
+            reward_model_train: "reward_model_train";
         }>;
+        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
         modelProjectId: z.ZodString;
         portableProjectId: z.ZodString;
         sourceProjectRevision: z.ZodNumber;
         submissionHash: z.ZodString;
         state: z.ZodEnum<{
-            succeeded: "succeeded";
+            admitting: "admitting";
             cancelled: "cancelled";
+            cancelling: "cancelling";
             failed: "failed";
+            provisioning: "provisioning";
             queued: "queued";
             running: "running";
-            cancelling: "cancelling";
-            admitting: "admitting";
-            provisioning: "provisioning";
             stopping: "stopping";
+            succeeded: "succeeded";
         }>;
         phase: z.ZodString;
         version: z.ZodNumber;
@@ -1002,8 +1021,8 @@ export declare const TrainingJobLogSchema: z.ZodObject<{
     jobId: z.ZodString;
     sequence: z.ZodNumber;
     level: z.ZodEnum<{
-        error: "error";
         debug: "debug";
+        error: "error";
         info: "info";
         warning: "warning";
     }>;
@@ -1018,13 +1037,13 @@ export declare const TrainingJobOutputSchema: z.ZodObject<{
     id: z.ZodString;
     jobId: z.ZodString;
     kind: z.ZodEnum<{
+        adapter: "adapter";
+        checkpoint: "checkpoint";
         evaluation: "evaluation";
         metrics: "metrics";
-        checkpoint: "checkpoint";
-        adapter: "adapter";
+        receipt: "receipt";
         scorer: "scorer";
         trace: "trace";
-        receipt: "receipt";
     }>;
     artifactRef: z.ZodString;
     contentHash: z.ZodString;
@@ -1032,6 +1051,38 @@ export declare const TrainingJobOutputSchema: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodString;
 }, z.core.$strict>;
+/** Evidence that collection used the pinned original learner and never updated it. */
+export declare const TrainingQualificationEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+        revision: z.ZodString;
+        tokenizerRevision: z.ZodString;
+        chatTemplateHash: z.ZodString;
+    }, z.core.$strict>;
+    group: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    rolloutReceipts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    rewardEvidenceHash: z.ZodString;
+    groupsCompleted: z.ZodLiteral<1>;
+    optimizerUpdatesApplied: z.ZodLiteral<0>;
+    optimizerUpdatesSkipped: z.ZodLiteral<0>;
+    trainingStepsCreated: z.ZodLiteral<0>;
+    checkpointsCreated: z.ZodLiteral<0>;
+    artifactsCreated: z.ZodLiteral<0>;
+}, z.core.$strict>;
 export declare const TrainingExecutionReceiptSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.trainingExecutionReceipt.v2">;
     id: z.ZodString;
@@ -1056,6 +1107,37 @@ export declare const TrainingExecutionReceiptSchema: z.ZodObject<{
     spendUsd: z.ZodNumber;
     durationSeconds: z.ZodNumber;
     cleanupComplete: z.ZodBoolean;
+    qualification: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+            revision: z.ZodString;
+            tokenizerRevision: z.ZodString;
+            chatTemplateHash: z.ZodString;
+        }, z.core.$strict>;
+        group: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        rolloutReceipts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        rewardEvidenceHash: z.ZodString;
+        groupsCompleted: z.ZodLiteral<1>;
+        optimizerUpdatesApplied: z.ZodLiteral<0>;
+        optimizerUpdatesSkipped: z.ZodLiteral<0>;
+        trainingStepsCreated: z.ZodLiteral<0>;
+        checkpointsCreated: z.ZodLiteral<0>;
+        artifactsCreated: z.ZodLiteral<0>;
+    }, z.core.$strict>>;
     issuer: z.ZodString;
     issuedAt: z.ZodString;
     signature: z.ZodNullable<z.ZodString>;
@@ -1067,7 +1149,14 @@ export declare function parseAndVerifyTrainingExecutionReceipt(value: unknown, e
     teamId?: string;
     jobId?: string;
     requireCleanup?: boolean;
+    qualificationSubmission?: TrainingJobSubmission;
+    outputs?: TrainingJobOutput[];
 }): Promise<TrainingExecutionReceipt>;
+export declare function assertTrainingQualificationReceipt(receipt: TrainingExecutionReceipt, expected: {
+    submissionHash: string;
+    baseModel?: z.infer<typeof ModelProjectBaseModelSchema>;
+    outputs?: TrainingJobOutput[];
+}): Promise<void>;
 export declare const TrainingJobOutputsSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.trainingJobOutputs.v2">;
     outputs: z.ZodArray<z.ZodObject<{
@@ -1075,13 +1164,13 @@ export declare const TrainingJobOutputsSchema: z.ZodObject<{
         id: z.ZodString;
         jobId: z.ZodString;
         kind: z.ZodEnum<{
+            adapter: "adapter";
+            checkpoint: "checkpoint";
             evaluation: "evaluation";
             metrics: "metrics";
-            checkpoint: "checkpoint";
-            adapter: "adapter";
+            receipt: "receipt";
             scorer: "scorer";
             trace: "trace";
-            receipt: "receipt";
         }>;
         artifactRef: z.ZodString;
         contentHash: z.ZodString;
@@ -1113,6 +1202,37 @@ export declare const TrainingJobOutputsSchema: z.ZodObject<{
         spendUsd: z.ZodNumber;
         durationSeconds: z.ZodNumber;
         cleanupComplete: z.ZodBoolean;
+        qualification: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+            baseModel: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    builtin: "builtin";
+                    local: "local";
+                    managed: "managed";
+                }>;
+                revision: z.ZodString;
+                tokenizerRevision: z.ZodString;
+                chatTemplateHash: z.ZodString;
+            }, z.core.$strict>;
+            group: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            rolloutReceipts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            rewardEvidenceHash: z.ZodString;
+            groupsCompleted: z.ZodLiteral<1>;
+            optimizerUpdatesApplied: z.ZodLiteral<0>;
+            optimizerUpdatesSkipped: z.ZodLiteral<0>;
+            trainingStepsCreated: z.ZodLiteral<0>;
+            checkpointsCreated: z.ZodLiteral<0>;
+            artifactsCreated: z.ZodLiteral<0>;
+        }, z.core.$strict>>;
         issuer: z.ZodString;
         issuedAt: z.ZodString;
         signature: z.ZodNullable<z.ZodString>;
@@ -1138,15 +1258,28 @@ export declare const TrainingCapabilitiesSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.trainingCapabilities.v2">;
     capabilityHash: z.ZodString;
     jobKinds: z.ZodArray<z.ZodEnum<{
-        reward_model_train: "reward_model_train";
         policy_optimize: "policy_optimize";
+        reward_model_train: "reward_model_train";
     }>>;
     methods: z.ZodArray<z.ZodString>;
+    executionModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        qualification: "qualification";
+        training: "training";
+    }>>>;
+    structuredOutputs: z.ZodOptional<z.ZodObject<{
+        capability: z.ZodLiteral<"work.structured-output.v1">;
+        harnessRuntimeHash: z.ZodString;
+        workHarnessHash: z.ZodString;
+        schemaHash: z.ZodString;
+        artifactHash: z.ZodString;
+        invalidDataRejected: z.ZodLiteral<true>;
+        invalidBytesRejected: z.ZodLiteral<true>;
+    }, z.core.$strict>>;
     placements: z.ZodArray<z.ZodEnum<{
-        local: "local";
-        remote: "remote";
         colocated: "colocated";
+        local: "local";
         provider_native: "provider_native";
+        remote: "remote";
     }>>;
     controls: z.ZodObject<{
         cancel: z.ZodBoolean;
@@ -1162,6 +1295,7 @@ export declare const TrainingCapabilitiesSchema: z.ZodObject<{
     expiresAt: z.ZodString;
 }, z.core.$strict>;
 export type TrainingJobSubmission = z.infer<typeof TrainingJobSubmissionSchema>;
+export type TrainingQualificationEvidence = z.infer<typeof TrainingQualificationEvidenceSchema>;
 export type TrainingInputArtifactUpload = z.infer<typeof TrainingInputArtifactUploadSchema>;
 export type TrainingInputArtifact = z.infer<typeof TrainingInputArtifactSchema>;
 export type TrainingJob = z.infer<typeof TrainingJobSchema>;
@@ -1177,668 +1311,154 @@ export declare function createTrainingClient(input: {
     fetch?: typeof fetch;
     headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
 }): {
-    capabilities(): Promise<{
-        schemaVersion: "openpond.trainingCapabilities.v2";
-        capabilityHash: string;
-        jobKinds: ("reward_model_train" | "policy_optimize")[];
-        methods: string[];
-        placements: ("local" | "remote" | "colocated" | "provider_native")[];
-        controls: {
-            cancel: boolean;
-            stopAfterGroup: boolean;
-            resumeFromCheckpoint: boolean;
-        };
-        limits: {
-            maximumSpendUsd: number;
-            maximumWallSeconds: number;
-            maximumArtifactBytes: number;
-        };
-        checkedAt: string;
-        expiresAt: string;
-    }>;
-    stageArtifact(upload: TrainingInputArtifactUpload): Promise<{
-        schemaVersion: "openpond.trainingInputArtifact.v2";
-        kind: "portable_training_bundle" | "reward_model_dataset";
-        sourceManifest: {
+    acceptanceGroups(target: import("./training-acceptance.js").TrainingAcceptanceTarget, input?: import("./training-acceptance.js").TrainingAcceptanceGroupQuery): Promise<{
+        schemaVersion: "openpond.trainingAcceptanceGroupPage.v1";
+        teamId: string;
+        jobId: string;
+        groups: {
             id: string;
             contentHash: string;
-        };
-        artifactRef: string;
-        contentHash: string;
-        sizeBytes: number;
-        createdAt: string;
-    }>;
-    createJob(submission: TrainingJobSubmission): Promise<{
-        schemaVersion: "openpond.trainingJob.v2";
-        id: string;
-        teamId: string;
-        kind: "reward_model_train" | "policy_optimize";
-        modelProjectId: string;
-        portableProjectId: string;
-        sourceProjectRevision: number;
-        submissionHash: string;
-        state: "succeeded" | "cancelled" | "failed" | "queued" | "running" | "cancelling" | "admitting" | "provisioning" | "stopping";
-        phase: string;
-        version: number;
-        progress: number;
-        rolloutProgress: {
-            groupsCompleted: number;
-            groupsTarget: number;
-            optimizerUpdatesApplied: number;
-            optimizerUpdatesSkipped: number;
-        };
-        accruedSpendUsd: number;
-        terminalReason: string | null;
-        createdAt: string;
-        updatedAt: string;
-        completedAt: string | null;
+            revision: number;
+            teamId: string;
+            jobId: string;
+            plan: {
+                id: string;
+                contentHash: string;
+            };
+            baseline: {
+                id: string;
+                contentHash: string;
+            };
+            candidate: {
+                id: string;
+                contentHash: string;
+            };
+            state: "blocked" | "budget_exhausted" | "cancelled" | "cancelling" | "cleaning" | "completed" | "failed" | "queued" | "running";
+            updatedAt: string;
+        }[];
+        nextCursor: string | null;
     }>;
-    listJobs(options?: {
-        modelProjectId?: string;
-        cursor?: string;
-        limit?: number;
-    }): Promise<{
-        schemaVersion: "openpond.trainingJobPage.v2";
-        jobs: {
-            schemaVersion: "openpond.trainingJob.v2";
+    acceptanceGroup(target: import("./training-acceptance.js").TrainingAcceptanceTarget, groupId: string, expected?: import("./training-acceptance.js").TrainingAcceptanceGroupReference): Promise<{
+        schemaVersion: "openpond.acceptanceGroupSnapshot.v1";
+        manifest: {
+            schemaVersion: "openpond.acceptanceGroupManifest.v1";
             id: string;
             teamId: string;
-            kind: "reward_model_train" | "policy_optimize";
-            modelProjectId: string;
-            portableProjectId: string;
-            sourceProjectRevision: number;
-            submissionHash: string;
-            state: "succeeded" | "cancelled" | "failed" | "queued" | "running" | "cancelling" | "admitting" | "provisioning" | "stopping";
-            phase: string;
-            version: number;
-            progress: number;
-            rolloutProgress: {
-                groupsCompleted: number;
-                groupsTarget: number;
-                optimizerUpdatesApplied: number;
-                optimizerUpdatesSkipped: number;
+            trainingJob: {
+                id: string;
+                contentHash: string;
             };
-            accruedSpendUsd: number;
-            terminalReason: string | null;
-            createdAt: string;
-            updatedAt: string;
-            completedAt: string | null;
-        }[];
-        nextCursor: string | null;
-    }>;
-    getJob(jobId: string): Promise<{
-        schemaVersion: "openpond.trainingJob.v2";
-        id: string;
-        teamId: string;
-        kind: "reward_model_train" | "policy_optimize";
-        modelProjectId: string;
-        portableProjectId: string;
-        sourceProjectRevision: number;
-        submissionHash: string;
-        state: "succeeded" | "cancelled" | "failed" | "queued" | "running" | "cancelling" | "admitting" | "provisioning" | "stopping";
-        phase: string;
-        version: number;
-        progress: number;
-        rolloutProgress: {
-            groupsCompleted: number;
-            groupsTarget: number;
-            optimizerUpdatesApplied: number;
-            optimizerUpdatesSkipped: number;
-        };
-        accruedSpendUsd: number;
-        terminalReason: string | null;
-        createdAt: string;
-        updatedAt: string;
-        completedAt: string | null;
-    }>;
-    cancelJob(jobId: string, expectedVersion: number): Promise<{
-        schemaVersion: "openpond.trainingJob.v2";
-        id: string;
-        teamId: string;
-        kind: "reward_model_train" | "policy_optimize";
-        modelProjectId: string;
-        portableProjectId: string;
-        sourceProjectRevision: number;
-        submissionHash: string;
-        state: "succeeded" | "cancelled" | "failed" | "queued" | "running" | "cancelling" | "admitting" | "provisioning" | "stopping";
-        phase: string;
-        version: number;
-        progress: number;
-        rolloutProgress: {
-            groupsCompleted: number;
-            groupsTarget: number;
-            optimizerUpdatesApplied: number;
-            optimizerUpdatesSkipped: number;
-        };
-        accruedSpendUsd: number;
-        terminalReason: string | null;
-        createdAt: string;
-        updatedAt: string;
-        completedAt: string | null;
-    }>;
-    stopAfterGroup(jobId: string, expectedVersion: number): Promise<{
-        schemaVersion: "openpond.trainingJob.v2";
-        id: string;
-        teamId: string;
-        kind: "reward_model_train" | "policy_optimize";
-        modelProjectId: string;
-        portableProjectId: string;
-        sourceProjectRevision: number;
-        submissionHash: string;
-        state: "succeeded" | "cancelled" | "failed" | "queued" | "running" | "cancelling" | "admitting" | "provisioning" | "stopping";
-        phase: string;
-        version: number;
-        progress: number;
-        rolloutProgress: {
-            groupsCompleted: number;
-            groupsTarget: number;
-            optimizerUpdatesApplied: number;
-            optimizerUpdatesSkipped: number;
-        };
-        accruedSpendUsd: number;
-        terminalReason: string | null;
-        createdAt: string;
-        updatedAt: string;
-        completedAt: string | null;
-    }>;
-    events(jobId: string): Promise<{
-        schemaVersion: "openpond.trainingJobEvent.v2";
-        id: string;
-        jobId: string;
-        sequence: number;
-        type: string;
-        phase: string;
-        message: string | null;
-        data: Record<string, unknown>;
-        createdAt: string;
-    }[]>;
-    outputs(jobId: string): Promise<{
-        schemaVersion: "openpond.trainingJobOutputs.v2";
-        outputs: {
-            schemaVersion: "openpond.trainingJobOutput.v2";
-            id: string;
-            jobId: string;
-            kind: "evaluation" | "metrics" | "checkpoint" | "adapter" | "scorer" | "trace" | "receipt";
-            artifactRef: string;
-            contentHash: string;
-            sizeBytes: number;
-            metadata: Record<string, unknown>;
-            createdAt: string;
-        }[];
-        receipt: {
-            schemaVersion: "openpond.trainingExecutionReceipt.v2";
-            id: string;
-            teamId: string;
-            jobId: string;
-            submissionHash: string;
-            manifestHash: string;
-            recipeHash: string;
-            capabilityHash: string;
-            runtimeRelease: {
+            baseline: {
                 id: string;
                 contentHash: string;
             };
-            inputs: {
+            candidate: {
                 id: string;
                 contentHash: string;
-            }[];
-            outputs: {
+            };
+            plan: {
+                schemaVersion: "openpond.acceptancePlan.v1";
                 id: string;
+                revision: number;
+                checks: {
+                    id: string;
+                    name: string;
+                    required: boolean;
+                    role?: "diagnostic" | "quality" | "retention" | undefined;
+                    unit?: string | undefined;
+                    baselineReuse?: {
+                        maximumAgeSeconds: number;
+                        qualification: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                    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;
+                }[];
+                maximumSpendUsd: number;
                 contentHash: string;
-            }[];
-            spendUsd: number;
-            durationSeconds: number;
-            cleanupComplete: boolean;
-            issuer: string;
-            issuedAt: string;
-            signature: string | null;
-        } | null;
-    }>;
-    evaluationTasks(jobId: string, evaluation: {
-        id: string;
-        contentHash: string;
-    }, options?: {
-        cursor?: string;
-        limit?: number;
-    }): Promise<{
-        schemaVersion: "openpond.trainingEvaluationTaskPage.v1";
-        jobId: string;
-        teamId: string;
-        evaluation: {
-            id: string;
+            };
+            maximumParallelAttempts: number;
+            createdAt: string;
             contentHash: string;
         };
-        kind: "candidate" | "baseline";
-        policyVersion: number;
-        taskset: {
+        revision: number;
+        state: "blocked" | "budget_exhausted" | "cancelled" | "cancelling" | "cleaning" | "completed" | "failed" | "queued" | "running";
+        attempts: {
             id: string;
-            contentHash: string;
-            revision: number;
-        };
-        panelSha256: string;
-        offset: number;
-        total: number;
-        tasks: {
-            taskId: string;
-            taskSha256: string;
-            resultSha256: string;
-            input: {
-                instruction: string;
-                context: Record<string, unknown>;
-            };
-            output: string;
-            outputSha256: string;
-            score: number;
-            evidence: {
-                kind: "worker_command" | "hosted_trace" | "local_trace";
+            checkId: string;
+            subject: "baseline" | "candidate";
+            ordinal: number;
+            dispatchId: string;
+            state: "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "grading" | "queued" | "running";
+            artifact: {
                 id: string;
+                contentHash: string;
             };
+            checkHash: string;
+            measurement: {
+                runId: string;
+                artifact: {
+                    id: string;
+                    contentHash: string;
+                };
+                checkHash: string;
+                populationHash: string;
+                scoredPopulationHash: string;
+                executionHash: string;
+                evaluator: {
+                    id: string;
+                    contentHash: string;
+                };
+                metric: string;
+                expectedCount: number;
+                scoredCount: number;
+                score: number | null;
+                status: "cancelled" | "completed" | "failed" | "pending" | "running";
+                evidenceHash: string;
+            } | null;
+            executionReceipt: {
+                id: string;
+                contentHash: string;
+            } | null;
+            reusedFrom: {
+                group: {
+                    id: string;
+                    contentHash: string;
+                };
+                attemptId: string;
+            } | null;
+            spendUsd: number;
+            reservedUsd: number;
+            cleanupComplete: boolean;
+            accountingComplete: boolean;
+            failureCode: string | null;
+            createdAt: string;
+            updatedAt: string;
         }[];
-        nextCursor: string | null;
-        contentHash: string;
-    }>;
-    logs(jobId: string): Promise<{
-        schemaVersion: "openpond.trainingJobLog.v2";
-        jobId: string;
-        sequence: number;
-        level: "error" | "debug" | "info" | "warning";
-        message: string;
-        createdAt: string;
-    }[]>;
-    candidateDecision(target: import("./training-candidate-decisions.js").TrainingCandidateDecisionTarget, options?: {
-        decision?: {
-            id: string;
-            contentHash: string;
-        };
-    }): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision | null>;
-    recordCandidateDecision(input: import("./training-candidate-decisions.js").TrainingCandidateDecisionRequest): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision>;
-    publishHarnessSource(value: import("@openpond/harness").HarnessSourcePackage | import("@openpond/harness").HarnessPolicySourcePackage): Promise<{
-        schemaVersion: "openpond.trainingHarnessSourcePublication.v1";
-        harnessRelease: {
-            id: string;
-            contentHash: string;
-        };
-        sourcePackageHash: string;
-        sizeBytes: number;
-    }>;
-    getHarnessSource(reference: import("@openpond/harness").ImmutableReleaseRef): Promise<{
-        schemaVersion: "openpond.harnessSourcePackage.v1";
-        agentSnapshot: {
-            schemaVersion: "openpond.agentSnapshot.v2";
-            id: string;
-            sourceRelease: {
-                id: string;
-                contentHash: string;
-            } | null;
-            instructions: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            skills: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            agents: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            toolDeclarations: {
-                name: string;
-                description: string;
-                inputSchema: Record<string, unknown>;
-                inputSchemaHash: string;
-                sideEffect: "read" | "write";
-                timeoutMs: number;
-            }[];
-            capabilityRequirements: {
-                id: string;
-                required: boolean;
-                scopes: string[];
-                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
-            }[];
-            dependencyLock: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            };
-            portability: {
-                portable: boolean;
-                blockers: string[];
-                localOnlyAssetRefs: string[];
-                hostPrivateAssetRefs: string[];
-            };
-            metadata: Record<string, unknown>;
-            contentHash: string;
-        };
-        harnessRelease: {
-            schemaVersion: "openpond.harnessRelease.v2";
-            id: string;
-            agentSnapshot: {
-                id: string;
-                contentHash: string;
-            };
-            program: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            };
-            tools: {
-                name: string;
-                description: string;
-                inputSchema: Record<string, unknown>;
-                inputSchemaHash: string;
-                sideEffect: "read" | "write";
-                timeoutMs: number;
-            }[];
-            lifecycle: {
-                create: true;
-                reset: true;
-                step: true;
-                collect: true;
-                destroy: true;
-                resetScope: "attempt" | "task";
-            };
-            graderInterface: {
-                visibleEvidence: string[];
-                privilegedEvidence: string[];
-                privateVerifierIsolation: boolean;
-            };
-            files: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            metadata: Record<string, unknown>;
-            contentHash: string;
-        };
-        files: {
-            path: string;
-            base64: string;
-        }[];
-        contentHash: string;
-    } | {
-        agentSnapshot: {
-            schemaVersion: "openpond.agentSnapshot.v2";
-            id: string;
-            sourceRelease: {
-                id: string;
-                contentHash: string;
-            } | null;
-            instructions: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            skills: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            agents: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            toolDeclarations: {
-                name: string;
-                description: string;
-                inputSchema: Record<string, unknown>;
-                inputSchemaHash: string;
-                sideEffect: "read" | "write";
-                timeoutMs: number;
-            }[];
-            capabilityRequirements: {
-                id: string;
-                required: boolean;
-                scopes: string[];
-                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
-            }[];
-            dependencyLock: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            };
-            portability: {
-                portable: boolean;
-                blockers: string[];
-                localOnlyAssetRefs: string[];
-                hostPrivateAssetRefs: string[];
-            };
-            metadata: Record<string, unknown>;
-            contentHash: string;
-        };
-        harnessRelease: {
-            schemaVersion: "openpond.harnessRelease.v2";
-            id: string;
-            agentSnapshot: {
-                id: string;
-                contentHash: string;
-            };
-            program: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            };
-            tools: {
-                name: string;
-                description: string;
-                inputSchema: Record<string, unknown>;
-                inputSchemaHash: string;
-                sideEffect: "read" | "write";
-                timeoutMs: number;
-            }[];
-            lifecycle: {
-                create: true;
-                reset: true;
-                step: true;
-                collect: true;
-                destroy: true;
-                resetScope: "attempt" | "task";
-            };
-            graderInterface: {
-                visibleEvidence: string[];
-                privilegedEvidence: string[];
-                privateVerifierIsolation: boolean;
-            };
-            files: {
-                id: string;
-                path: string;
-                contentHash: string;
-                sizeBytes: number;
-                mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
-            }[];
-            metadata: Record<string, unknown>;
-            contentHash: string;
-        };
-        files: {
-            path: string;
-            base64: string;
-        }[];
-        schemaVersion: "openpond.harnessPolicySourcePackage.v1";
-        contentHash: string;
-    }>;
-    acceptanceGroups(target: import("./training-acceptance.js").TrainingAcceptanceTarget, input?: import("./training-acceptance.js").TrainingAcceptanceGroupQuery): Promise<{
-        schemaVersion: "openpond.trainingAcceptanceGroupPage.v1";
-        teamId: string;
-        jobId: string;
-        groups: {
-            id: string;
-            contentHash: string;
-            revision: number;
-            teamId: string;
-            jobId: string;
-            plan: {
-                id: string;
-                contentHash: string;
-            };
-            baseline: {
-                id: string;
-                contentHash: string;
-            };
-            candidate: {
-                id: string;
-                contentHash: string;
-            };
-            state: "cancelled" | "failed" | "queued" | "running" | "cancelling" | "completed" | "budget_exhausted" | "cleaning" | "blocked";
-            updatedAt: string;
-        }[];
-        nextCursor: string | null;
-    }>;
-    acceptanceGroup(target: import("./training-acceptance.js").TrainingAcceptanceTarget, groupId: string, expected?: import("./training-acceptance.js").TrainingAcceptanceGroupReference): Promise<{
-        schemaVersion: "openpond.acceptanceGroupSnapshot.v1";
-        manifest: {
-            schemaVersion: "openpond.acceptanceGroupManifest.v1";
-            id: string;
-            teamId: string;
-            trainingJob: {
-                id: string;
-                contentHash: string;
-            };
-            baseline: {
-                id: string;
-                contentHash: string;
-            };
-            candidate: {
-                id: string;
-                contentHash: string;
-            };
-            plan: {
-                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;
-            };
-            maximumParallelAttempts: number;
-            createdAt: string;
-            contentHash: string;
-        };
-        revision: number;
-        state: "cancelled" | "failed" | "queued" | "running" | "cancelling" | "completed" | "budget_exhausted" | "cleaning" | "blocked";
-        attempts: {
-            id: string;
-            checkId: string;
-            subject: "candidate" | "baseline";
-            ordinal: number;
-            dispatchId: string;
-            state: "cancelled" | "failed" | "queued" | "running" | "completed" | "budget_exhausted" | "dispatching" | "cleaning" | "grading";
-            artifact: {
-                id: string;
-                contentHash: string;
-            };
-            checkHash: string;
-            measurement: {
-                runId: string;
-                artifact: {
-                    id: string;
-                    contentHash: string;
-                };
-                checkHash: string;
-                populationHash: string;
-                scoredPopulationHash: string;
-                executionHash: string;
-                evaluator: {
-                    id: string;
-                    contentHash: string;
-                };
-                metric: string;
-                expectedCount: number;
-                scoredCount: number;
-                score: number | null;
-                status: "pending" | "cancelled" | "failed" | "running" | "completed";
-                evidenceHash: string;
-            } | null;
-            executionReceipt: {
-                id: string;
-                contentHash: string;
-            } | null;
-            reusedFrom: {
-                group: {
-                    id: string;
-                    contentHash: string;
-                };
-                attemptId: string;
-            } | null;
-            spendUsd: number;
-            reservedUsd: number;
-            cleanupComplete: boolean;
-            accountingComplete: boolean;
-            failureCode: string | null;
-            createdAt: string;
-            updatedAt: string;
-        }[];
-        failureCode: string | null;
-        updatedAt: string;
+        failureCode: string | null;
+        updatedAt: string;
         contentHash: string;
     }>;
     listPreparations(teamId: string, input?: import("./training-preparations.js").TrainingPreparationListQuery): Promise<{
+        schemaVersion: "openpond.trainingPreparationPage.v1";
+        teamId: string;
+        nextCursor: string | null;
         items: {
             schemaVersion: "openpond.trainingPreparationReceipt.v1";
             plan: {
@@ -1855,13 +1475,6 @@ export declare function createTrainingClient(input: {
                         expectedRevision: number;
                         expectedEtag: string;
                     };
-                    batch: {
-                        id: string;
-                        contentHash: string;
-                        revision: number;
-                    };
-                    name: string;
-                    maximumSpendUsd: number;
                     origin?: {
                         schemaVersion: "openpond.trainingHandoffOrigin.v1";
                         teamId: string;
@@ -1930,7 +1543,35 @@ export declare function createTrainingClient(input: {
                                     };
                                     declaredProfileCatalogHash: string | null;
                                     protectedProfileClosureHash: string;
-                                    split: "train" | "validation" | "test" | "frozen_eval";
+                                    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;
+                                    split: "frozen_eval" | "test" | "train" | "validation";
                                     population: {
                                         taskId: string;
                                         seed: string;
@@ -1944,16 +1585,16 @@ export declare function createTrainingClient(input: {
                                         };
                                         feedbackKey: string;
                                         configurationHash: string;
-                                        output: "boolean" | "score" | "category";
+                                        output: "boolean" | "category" | "score";
                                         categories: string[];
                                     }[];
                                     fieldMappingsHash: string;
                                     fieldMappings: {
                                         graderId: string;
                                         fields: {
-                                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             path: string[];
-                                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             sourcePath: string[];
                                         }[];
                                     }[];
@@ -1964,34 +1605,6 @@ export declare function createTrainingClient(input: {
                                         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;
@@ -2041,40 +1654,16 @@ export declare function createTrainingClient(input: {
                         }[];
                         contentHash: string;
                     } | undefined;
-                };
-                requestHash: string;
-                source: {
-                    modelProject: {
-                        id: string;
-                        portableProjectId: string;
-                        revision: number;
-                        contentHash: string;
-                    };
-                    harnessRunManifest: {
-                        id: string;
-                        contentHash: string;
-                    };
-                    harnessRelease: {
-                        id: string;
-                        contentHash: string;
-                    };
-                    taskset: {
+                    batch: {
                         id: string;
                         contentHash: string;
                         revision: number;
                     };
-                    tasksetRelease: {
-                        id: string;
-                        contentHash: string;
-                    };
-                    dataset: {
-                        id: string;
-                        contentHash: string;
-                    };
-                    evidenceSets: {
-                        id: string;
-                        contentHash: string;
-                    }[];
+                    name: string;
+                    maximumSpendUsd: number;
+                };
+                requestHash: string;
+                source: {
                     origin?: {
                         schemaVersion: "openpond.trainingHandoffOrigin.v1";
                         teamId: string;
@@ -2143,7 +1732,35 @@ export declare function createTrainingClient(input: {
                                     };
                                     declaredProfileCatalogHash: string | null;
                                     protectedProfileClosureHash: string;
-                                    split: "train" | "validation" | "test" | "frozen_eval";
+                                    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;
+                                    split: "frozen_eval" | "test" | "train" | "validation";
                                     population: {
                                         taskId: string;
                                         seed: string;
@@ -2157,16 +1774,16 @@ export declare function createTrainingClient(input: {
                                         };
                                         feedbackKey: string;
                                         configurationHash: string;
-                                        output: "boolean" | "score" | "category";
+                                        output: "boolean" | "category" | "score";
                                         categories: string[];
                                     }[];
                                     fieldMappingsHash: string;
                                     fieldMappings: {
                                         graderId: string;
                                         fields: {
-                                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             path: string[];
-                                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             sourcePath: string[];
                                         }[];
                                     }[];
@@ -2177,34 +1794,6 @@ export declare function createTrainingClient(input: {
                                         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;
@@ -2254,6 +1843,29 @@ export declare function createTrainingClient(input: {
                         }[];
                         contentHash: string;
                     } | undefined;
+                    modelProject: {
+                        id: string;
+                        portableProjectId: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    harnessRunManifest: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    taskset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    tasksetRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
                     evaluation?: {
                         taskset: {
                             id: string;
@@ -2265,6 +1877,14 @@ export declare function createTrainingClient(input: {
                             contentHash: string;
                         };
                     } | null | undefined;
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evidenceSets: {
+                        id: string;
+                        contentHash: string;
+                    }[];
                 };
                 submissionHash: string;
                 createdAt: string;
@@ -2274,9 +1894,6 @@ export declare function createTrainingClient(input: {
             state: "cancelled" | "prepared" | "submitted";
             jobId: string | null;
         }[];
-        schemaVersion: "openpond.trainingPreparationPage.v1";
-        teamId: string;
-        nextCursor: string | null;
     }>;
     prepareRun(input: import("./training-preparations.js").TrainingPreparationRequest): Promise<{
         schemaVersion: "openpond.trainingPreparationReceipt.v1";
@@ -2294,13 +1911,6 @@ export declare function createTrainingClient(input: {
                     expectedRevision: number;
                     expectedEtag: string;
                 };
-                batch: {
-                    id: string;
-                    contentHash: string;
-                    revision: number;
-                };
-                name: string;
-                maximumSpendUsd: number;
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -2369,7 +1979,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -2383,16 +2021,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -2403,34 +2041,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -2480,40 +2090,16 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
-            };
-            requestHash: string;
-            source: {
-                modelProject: {
-                    id: string;
-                    portableProjectId: string;
-                    revision: number;
-                    contentHash: string;
-                };
-                harnessRunManifest: {
-                    id: string;
-                    contentHash: string;
-                };
-                harnessRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                taskset: {
+                batch: {
                     id: string;
                     contentHash: string;
                     revision: number;
                 };
-                tasksetRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                dataset: {
-                    id: string;
-                    contentHash: string;
-                };
-                evidenceSets: {
-                    id: string;
-                    contentHash: string;
-                }[];
+                name: string;
+                maximumSpendUsd: number;
+            };
+            requestHash: string;
+            source: {
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -2582,7 +2168,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -2596,16 +2210,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -2616,34 +2230,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -2693,6 +2279,29 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
+                modelProject: {
+                    id: string;
+                    portableProjectId: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                harnessRunManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                taskset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
                 evaluation?: {
                     taskset: {
                         id: string;
@@ -2704,6 +2313,14 @@ export declare function createTrainingClient(input: {
                         contentHash: string;
                     };
                 } | null | undefined;
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                };
+                evidenceSets: {
+                    id: string;
+                    contentHash: string;
+                }[];
             };
             submissionHash: string;
             createdAt: string;
@@ -2729,13 +2346,6 @@ export declare function createTrainingClient(input: {
                     expectedRevision: number;
                     expectedEtag: string;
                 };
-                batch: {
-                    id: string;
-                    contentHash: string;
-                    revision: number;
-                };
-                name: string;
-                maximumSpendUsd: number;
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -2804,7 +2414,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -2818,16 +2456,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -2838,34 +2476,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -2915,40 +2525,16 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
-            };
-            requestHash: string;
-            source: {
-                modelProject: {
-                    id: string;
-                    portableProjectId: string;
-                    revision: number;
-                    contentHash: string;
-                };
-                harnessRunManifest: {
-                    id: string;
-                    contentHash: string;
-                };
-                harnessRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                taskset: {
+                batch: {
                     id: string;
                     contentHash: string;
                     revision: number;
                 };
-                tasksetRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                dataset: {
-                    id: string;
-                    contentHash: string;
-                };
-                evidenceSets: {
-                    id: string;
-                    contentHash: string;
-                }[];
+                name: string;
+                maximumSpendUsd: number;
+            };
+            requestHash: string;
+            source: {
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -3017,7 +2603,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -3031,16 +2645,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -3051,34 +2665,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -3128,6 +2714,29 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
+                modelProject: {
+                    id: string;
+                    portableProjectId: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                harnessRunManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                taskset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
                 evaluation?: {
                     taskset: {
                         id: string;
@@ -3139,6 +2748,14 @@ export declare function createTrainingClient(input: {
                         contentHash: string;
                     };
                 } | null | undefined;
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                };
+                evidenceSets: {
+                    id: string;
+                    contentHash: string;
+                }[];
             };
             submissionHash: string;
             createdAt: string;
@@ -3164,13 +2781,6 @@ export declare function createTrainingClient(input: {
                     expectedRevision: number;
                     expectedEtag: string;
                 };
-                batch: {
-                    id: string;
-                    contentHash: string;
-                    revision: number;
-                };
-                name: string;
-                maximumSpendUsd: number;
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -3239,7 +2849,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -3253,16 +2891,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -3273,34 +2911,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -3350,40 +2960,16 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
-            };
-            requestHash: string;
-            source: {
-                modelProject: {
-                    id: string;
-                    portableProjectId: string;
-                    revision: number;
-                    contentHash: string;
-                };
-                harnessRunManifest: {
-                    id: string;
-                    contentHash: string;
-                };
-                harnessRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                taskset: {
+                batch: {
                     id: string;
                     contentHash: string;
                     revision: number;
                 };
-                tasksetRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                dataset: {
-                    id: string;
-                    contentHash: string;
-                };
-                evidenceSets: {
-                    id: string;
-                    contentHash: string;
-                }[];
+                name: string;
+                maximumSpendUsd: number;
+            };
+            requestHash: string;
+            source: {
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -3452,7 +3038,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -3466,16 +3080,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -3486,34 +3100,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -3562,7 +3148,30 @@ export declare function createTrainingClient(input: {
                         score: number | null;
                     }[];
                     contentHash: string;
-                } | undefined;
+                } | undefined;
+                modelProject: {
+                    id: string;
+                    portableProjectId: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                harnessRunManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                taskset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
                 evaluation?: {
                     taskset: {
                         id: string;
@@ -3574,6 +3183,14 @@ export declare function createTrainingClient(input: {
                         contentHash: string;
                     };
                 } | null | undefined;
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                };
+                evidenceSets: {
+                    id: string;
+                    contentHash: string;
+                }[];
             };
             submissionHash: string;
             createdAt: string;
@@ -3599,13 +3216,6 @@ export declare function createTrainingClient(input: {
                     expectedRevision: number;
                     expectedEtag: string;
                 };
-                batch: {
-                    id: string;
-                    contentHash: string;
-                    revision: number;
-                };
-                name: string;
-                maximumSpendUsd: number;
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -3674,7 +3284,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -3688,16 +3326,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -3708,34 +3346,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -3785,40 +3395,16 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
-            };
-            requestHash: string;
-            source: {
-                modelProject: {
-                    id: string;
-                    portableProjectId: string;
-                    revision: number;
-                    contentHash: string;
-                };
-                harnessRunManifest: {
-                    id: string;
-                    contentHash: string;
-                };
-                harnessRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                taskset: {
+                batch: {
                     id: string;
                     contentHash: string;
                     revision: number;
                 };
-                tasksetRelease: {
-                    id: string;
-                    contentHash: string;
-                };
-                dataset: {
-                    id: string;
-                    contentHash: string;
-                };
-                evidenceSets: {
-                    id: string;
-                    contentHash: string;
-                }[];
+                name: string;
+                maximumSpendUsd: number;
+            };
+            requestHash: string;
+            source: {
                 origin?: {
                     schemaVersion: "openpond.trainingHandoffOrigin.v1";
                     teamId: string;
@@ -3887,7 +3473,35 @@ export declare function createTrainingClient(input: {
                                 };
                                 declaredProfileCatalogHash: string | null;
                                 protectedProfileClosureHash: string;
-                                split: "train" | "validation" | "test" | "frozen_eval";
+                                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;
+                                split: "frozen_eval" | "test" | "train" | "validation";
                                 population: {
                                     taskId: string;
                                     seed: string;
@@ -3901,16 +3515,16 @@ export declare function createTrainingClient(input: {
                                     };
                                     feedbackKey: string;
                                     configurationHash: string;
-                                    output: "boolean" | "score" | "category";
+                                    output: "boolean" | "category" | "score";
                                     categories: string[];
                                 }[];
                                 fieldMappingsHash: string;
                                 fieldMappings: {
                                     graderId: string;
                                     fields: {
-                                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         path: string[];
-                                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                         sourcePath: string[];
                                     }[];
                                 }[];
@@ -3921,34 +3535,6 @@ export declare function createTrainingClient(input: {
                                     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;
@@ -3998,6 +3584,29 @@ export declare function createTrainingClient(input: {
                     }[];
                     contentHash: string;
                 } | undefined;
+                modelProject: {
+                    id: string;
+                    portableProjectId: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                harnessRunManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                taskset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
                 evaluation?: {
                     taskset: {
                         id: string;
@@ -4009,15 +3618,272 @@ export declare function createTrainingClient(input: {
                         contentHash: string;
                     };
                 } | null | undefined;
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                };
+                evidenceSets: {
+                    id: string;
+                    contentHash: string;
+                }[];
+            };
+            submissionHash: string;
+            createdAt: string;
+            contentHash: string;
+        };
+        revision: number;
+        state: "cancelled" | "prepared" | "submitted";
+        jobId: string | null;
+    }>;
+    publishHarnessSource(value: import("@openpond/harness").HarnessSourcePackage | import("@openpond/harness").HarnessPolicySourcePackage): Promise<{
+        schemaVersion: "openpond.trainingHarnessSourcePublication.v1";
+        harnessRelease: {
+            id: string;
+            contentHash: string;
+        };
+        sourcePackageHash: string;
+        sizeBytes: number;
+    }>;
+    getHarnessSource(reference: import("@openpond/harness").ImmutableReleaseRef): Promise<{
+        schemaVersion: "openpond.harnessSourcePackage.v1";
+        agentSnapshot: {
+            schemaVersion: "openpond.agentSnapshot.v2";
+            id: string;
+            sourceRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            instructions: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            skills: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            agents: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            toolDeclarations: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilityRequirements: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
+            }[];
+            dependencyLock: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
             };
-            submissionHash: string;
-            createdAt: string;
+            portability: {
+                portable: boolean;
+                blockers: string[];
+                localOnlyAssetRefs: string[];
+                hostPrivateAssetRefs: string[];
+            };
+            metadata: Record<string, unknown>;
             contentHash: string;
         };
-        revision: number;
-        state: "cancelled" | "prepared" | "submitted";
-        jobId: string | null;
+        harnessRelease: {
+            schemaVersion: "openpond.harnessRelease.v2";
+            id: string;
+            agentSnapshot: {
+                id: string;
+                contentHash: string;
+            };
+            program: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            lifecycle: {
+                create: true;
+                reset: true;
+                step: true;
+                collect: true;
+                destroy: true;
+                resetScope: "attempt" | "task";
+            };
+            graderInterface: {
+                visibleEvidence: string[];
+                privilegedEvidence: string[];
+                privateVerifierIsolation: boolean;
+            };
+            files: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        files: {
+            path: string;
+            base64: string;
+        }[];
+        contentHash: string;
+    } | {
+        agentSnapshot: {
+            schemaVersion: "openpond.agentSnapshot.v2";
+            id: string;
+            sourceRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            instructions: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            skills: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            agents: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            toolDeclarations: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilityRequirements: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
+            }[];
+            dependencyLock: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            portability: {
+                portable: boolean;
+                blockers: string[];
+                localOnlyAssetRefs: string[];
+                hostPrivateAssetRefs: string[];
+            };
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        harnessRelease: {
+            schemaVersion: "openpond.harnessRelease.v2";
+            id: string;
+            agentSnapshot: {
+                id: string;
+                contentHash: string;
+            };
+            program: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            lifecycle: {
+                create: true;
+                reset: true;
+                step: true;
+                collect: true;
+                destroy: true;
+                resetScope: "attempt" | "task";
+            };
+            graderInterface: {
+                visibleEvidence: string[];
+                privilegedEvidence: string[];
+                privateVerifierIsolation: boolean;
+            };
+            files: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            }[];
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        files: {
+            path: string;
+            base64: string;
+        }[];
+        schemaVersion: "openpond.harnessPolicySourcePackage.v1";
+        contentHash: string;
     }>;
+    candidateDecision(target: import("./training-candidate-decisions.js").TrainingCandidateDecisionTarget, options?: {
+        decision?: {
+            id: string;
+            contentHash: string;
+        };
+    }): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision | null>;
+    recordCandidateDecision(input: import("./training-candidate-decisions.js").TrainingCandidateDecisionRequest): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision>;
     postTraining: {
         attach(teamId: string, raw: z.input<typeof import("./post-training.js").AttachPostTrainingSchema>): Promise<{
             id: string;
@@ -4043,6 +3909,13 @@ export declare function createTrainingClient(input: {
                             operationId: string;
                             teamId: string;
                             modelProjectId: string | null;
+                            name?: string | undefined;
+                            project?: {
+                                id: string;
+                                revision: number;
+                                contentHash: string;
+                                targetId: string | null;
+                            } | undefined;
                             taskset: {
                                 id: string;
                                 contentHash: string;
@@ -4051,10 +3924,12 @@ export declare function createTrainingClient(input: {
                             policy: {
                                 kind: "hosted_chat";
                                 modelId: string;
-                                maxOutputTokens: number;
-                                temperature: number;
-                                topP: number;
                                 localRuntime?: {
+                                    providerId: "custom-openai-compatible";
+                                    configurationHash: string;
+                                    maximumRequestCostUsd: number;
+                                    requestTimeoutMs: number;
+                                } | {
                                     providerId: "claude-code";
                                     configurationHash: string;
                                     executableHash: string;
@@ -4071,11 +3946,6 @@ export declare function createTrainingClient(input: {
                                     reasoningEffort: "high" | "low" | "medium" | "xhigh";
                                     maximumRequestCostUsd: number;
                                     requestTimeoutMs: number;
-                                } | {
-                                    providerId: "custom-openai-compatible";
-                                    configurationHash: string;
-                                    maximumRequestCostUsd: number;
-                                    requestTimeoutMs: number;
                                 } | undefined;
                                 candidate?: {
                                     artifactId: string;
@@ -4097,12 +3967,47 @@ export declare function createTrainingClient(input: {
                                     sourcePackageHash: string;
                                 } | undefined;
                                 messages?: {
-                                    role: "system" | "user" | "assistant";
+                                    role: "assistant" | "system" | "user";
                                     content: string;
                                 }[] | undefined;
+                                maxOutputTokens: number;
+                                temperature: number;
+                                topP: number;
+                            } | {
+                                kind: "fixture";
                             } | {
                                 kind: "hosted_harness";
                                 modelId: string;
+                                maxOutputTokens?: number | undefined;
+                                temperature?: number | undefined;
+                                topP?: number | undefined;
+                                localRuntime?: {
+                                    providerId: "codex";
+                                    configurationHash: string;
+                                    accountHash: string;
+                                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
+                                    maximumRequestCostUsd: number;
+                                    requestTimeoutMs: number;
+                                } | undefined;
+                                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" | "max" | "medium" | "off" | "xhigh" | undefined;
                                 profileRepositoryId: string;
                                 source: {
                                     profileId: string;
@@ -4150,7 +4055,35 @@ export declare function createTrainingClient(input: {
                                         };
                                         declaredProfileCatalogHash: string | null;
                                         protectedProfileClosureHash: string;
-                                        split: "train" | "validation" | "test" | "frozen_eval";
+                                        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;
+                                        split: "frozen_eval" | "test" | "train" | "validation";
                                         population: {
                                             taskId: string;
                                             seed: string;
@@ -4164,16 +4097,16 @@ export declare function createTrainingClient(input: {
                                             };
                                             feedbackKey: string;
                                             configurationHash: string;
-                                            output: "boolean" | "score" | "category";
+                                            output: "boolean" | "category" | "score";
                                             categories: string[];
                                         }[];
                                         fieldMappingsHash: string;
                                         fieldMappings: {
                                             graderId: string;
                                             fields: {
-                                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                                 path: string[];
-                                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                                 sourcePath: string[];
                                             }[];
                                         }[];
@@ -4184,34 +4117,6 @@ export declare function createTrainingClient(input: {
                                             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;
@@ -4226,25 +4131,6 @@ export declare function createTrainingClient(input: {
                                 };
                                 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" | "medium" | "xhigh" | "off" | "max" | undefined;
                                 externalDatasetBinding?: {
                                     schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                     dataset: {
@@ -4268,7 +4154,35 @@ export declare function createTrainingClient(input: {
                                     };
                                     declaredProfileCatalogHash: string | null;
                                     protectedProfileClosureHash: string;
-                                    split: "train" | "validation" | "test" | "frozen_eval";
+                                    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;
+                                    split: "frozen_eval" | "test" | "train" | "validation";
                                     population: {
                                         taskId: string;
                                         seed: string;
@@ -4282,16 +4196,16 @@ export declare function createTrainingClient(input: {
                                         };
                                         feedbackKey: string;
                                         configurationHash: string;
-                                        output: "boolean" | "score" | "category";
+                                        output: "boolean" | "category" | "score";
                                         categories: string[];
                                     }[];
                                     fieldMappingsHash: string;
                                     fieldMappings: {
                                         graderId: string;
                                         fields: {
-                                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             path: string[];
-                                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                             sourcePath: string[];
                                         }[];
                                     }[];
@@ -4302,37 +4216,7 @@ export declare function createTrainingClient(input: {
                                         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;
@@ -4340,13 +4224,6 @@ export declare function createTrainingClient(input: {
                                 seed: string;
                                 fixtureId: string | null;
                             }[];
-                            name?: string | undefined;
-                            project?: {
-                                id: string;
-                                revision: number;
-                                contentHash: string;
-                                targetId: string | null;
-                            } | undefined;
                         };
                         maximumCostUsd: number;
                         graders?: {
@@ -4354,9 +4231,9 @@ export declare function createTrainingClient(input: {
                             version: string;
                             contentHash: string;
                             mappings: {
-                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                 path: string[];
-                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                 sourcePath: string[];
                             }[];
                         }[] | undefined;
@@ -4371,6 +4248,15 @@ export declare function createTrainingClient(input: {
                         id: string;
                         name: string;
                         required: boolean;
+                        role?: "diagnostic" | "quality" | "retention" | undefined;
+                        unit?: string | undefined;
+                        baselineReuse?: {
+                            maximumAgeSeconds: number;
+                            qualification: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
                         dataset: {
                             id: string;
                             contentHash: string;
@@ -4387,88 +4273,389 @@ export declare function createTrainingClient(input: {
                         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;
+            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: "blocked" | "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "failed" | "preparing" | "queued" | "ready" | "running" | "waiting_for_training";
+            total: number;
+            completed: number;
+            failed: number;
+            requiredOutcome: "blocked" | "failed" | "none" | "passed" | "pending";
+            reason: string | null;
+            groupId: string | null;
+            experimentIds: string[];
+            updatedAt: string;
+        } | null>;
+        control(teamId: string, jobId: string, action: "start" | "retry" | "cancel", raw: z.input<typeof import("./post-training.js").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: "blocked" | "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "failed" | "preparing" | "queued" | "ready" | "running" | "waiting_for_training";
+            total: number;
+            completed: number;
+            failed: number;
+            requiredOutcome: "blocked" | "failed" | "none" | "passed" | "pending";
+            reason: string | null;
+            groupId: string | null;
+            experimentIds: string[];
+            updatedAt: string;
+        }>;
+    };
+    capabilities(): Promise<{
+        schemaVersion: "openpond.trainingCapabilities.v2";
+        capabilityHash: string;
+        jobKinds: ("policy_optimize" | "reward_model_train")[];
+        methods: string[];
+        executionModes?: ("qualification" | "training")[] | undefined;
+        structuredOutputs?: {
+            capability: "work.structured-output.v1";
+            harnessRuntimeHash: string;
+            workHarnessHash: string;
+            schemaHash: string;
+            artifactHash: string;
+            invalidDataRejected: true;
+            invalidBytesRejected: true;
+        } | undefined;
+        placements: ("colocated" | "local" | "provider_native" | "remote")[];
+        controls: {
+            cancel: boolean;
+            stopAfterGroup: boolean;
+            resumeFromCheckpoint: boolean;
+        };
+        limits: {
+            maximumSpendUsd: number;
+            maximumWallSeconds: number;
+            maximumArtifactBytes: number;
+        };
+        checkedAt: string;
+        expiresAt: string;
+    }>;
+    stageArtifact(upload: TrainingInputArtifactUpload): Promise<{
+        schemaVersion: "openpond.trainingInputArtifact.v2";
+        kind: "portable_training_bundle" | "reward_model_dataset";
+        sourceManifest: {
+            id: string;
+            contentHash: string;
+        };
+        artifactRef: string;
+        contentHash: string;
+        sizeBytes: number;
+        createdAt: string;
+    }>;
+    createJob(submission: TrainingJobSubmission): Promise<{
+        schemaVersion: "openpond.trainingJob.v2";
+        id: string;
+        teamId: string;
+        kind: "policy_optimize" | "reward_model_train";
+        executionMode?: "qualification" | undefined;
+        modelProjectId: string;
+        portableProjectId: string;
+        sourceProjectRevision: number;
+        submissionHash: string;
+        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
+        phase: string;
+        version: number;
+        progress: number;
+        rolloutProgress: {
+            groupsCompleted: number;
+            groupsTarget: number;
+            optimizerUpdatesApplied: number;
+            optimizerUpdatesSkipped: number;
+        };
+        accruedSpendUsd: number;
+        terminalReason: string | null;
+        createdAt: string;
+        updatedAt: string;
+        completedAt: string | null;
+    }>;
+    listJobs(options?: {
+        modelProjectId?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        schemaVersion: "openpond.trainingJobPage.v2";
+        jobs: {
+            schemaVersion: "openpond.trainingJob.v2";
+            id: string;
+            teamId: string;
+            kind: "policy_optimize" | "reward_model_train";
+            executionMode?: "qualification" | undefined;
+            modelProjectId: string;
+            portableProjectId: string;
+            sourceProjectRevision: number;
+            submissionHash: string;
+            state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
+            phase: string;
+            version: number;
+            progress: number;
+            rolloutProgress: {
+                groupsCompleted: number;
+                groupsTarget: number;
+                optimizerUpdatesApplied: number;
+                optimizerUpdatesSkipped: number;
+            };
+            accruedSpendUsd: number;
+            terminalReason: string | null;
+            createdAt: string;
+            updatedAt: string;
+            completedAt: string | null;
+        }[];
+        nextCursor: string | null;
+    }>;
+    getJob(jobId: string): Promise<{
+        schemaVersion: "openpond.trainingJob.v2";
+        id: string;
+        teamId: string;
+        kind: "policy_optimize" | "reward_model_train";
+        executionMode?: "qualification" | undefined;
+        modelProjectId: string;
+        portableProjectId: string;
+        sourceProjectRevision: number;
+        submissionHash: string;
+        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
+        phase: string;
+        version: number;
+        progress: number;
+        rolloutProgress: {
+            groupsCompleted: number;
+            groupsTarget: number;
+            optimizerUpdatesApplied: number;
+            optimizerUpdatesSkipped: number;
+        };
+        accruedSpendUsd: number;
+        terminalReason: string | null;
+        createdAt: string;
+        updatedAt: string;
+        completedAt: string | null;
+    }>;
+    cancelJob(jobId: string, expectedVersion: number): Promise<{
+        schemaVersion: "openpond.trainingJob.v2";
+        id: string;
+        teamId: string;
+        kind: "policy_optimize" | "reward_model_train";
+        executionMode?: "qualification" | undefined;
+        modelProjectId: string;
+        portableProjectId: string;
+        sourceProjectRevision: number;
+        submissionHash: string;
+        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
+        phase: string;
+        version: number;
+        progress: number;
+        rolloutProgress: {
+            groupsCompleted: number;
+            groupsTarget: number;
+            optimizerUpdatesApplied: number;
+            optimizerUpdatesSkipped: number;
+        };
+        accruedSpendUsd: number;
+        terminalReason: string | null;
+        createdAt: string;
+        updatedAt: string;
+        completedAt: string | null;
+    }>;
+    stopAfterGroup(jobId: string, expectedVersion: number): Promise<{
+        schemaVersion: "openpond.trainingJob.v2";
+        id: string;
+        teamId: string;
+        kind: "policy_optimize" | "reward_model_train";
+        executionMode?: "qualification" | undefined;
+        modelProjectId: string;
+        portableProjectId: string;
+        sourceProjectRevision: number;
+        submissionHash: string;
+        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
+        phase: string;
+        version: number;
+        progress: number;
+        rolloutProgress: {
+            groupsCompleted: number;
+            groupsTarget: number;
+            optimizerUpdatesApplied: number;
+            optimizerUpdatesSkipped: number;
+        };
+        accruedSpendUsd: number;
+        terminalReason: string | null;
+        createdAt: string;
+        updatedAt: string;
+        completedAt: string | null;
+    }>;
+    events(jobId: string): Promise<{
+        schemaVersion: "openpond.trainingJobEvent.v2";
+        id: string;
+        jobId: string;
+        sequence: number;
+        type: string;
+        phase: string;
+        message: string | null;
+        data: Record<string, unknown>;
+        createdAt: string;
+    }[]>;
+    outputs(jobId: string): Promise<{
+        schemaVersion: "openpond.trainingJobOutputs.v2";
+        outputs: {
+            schemaVersion: "openpond.trainingJobOutput.v2";
+            id: string;
+            jobId: string;
+            kind: "adapter" | "checkpoint" | "evaluation" | "metrics" | "receipt" | "scorer" | "trace";
+            artifactRef: string;
             contentHash: string;
+            sizeBytes: number;
+            metadata: Record<string, unknown>;
             createdAt: string;
-        }>;
-        get(teamId: string, jobId: string): Promise<{
-            schemaVersion: "openpond.postTrainingSummary.v1";
+        }[];
+        receipt: {
+            schemaVersion: "openpond.trainingExecutionReceipt.v2";
             id: string;
             teamId: string;
             jobId: string;
-            revision: number;
-            planHash: string;
-            automatic: boolean;
-            candidate: {
+            submissionHash: string;
+            manifestHash: string;
+            recipeHash: string;
+            capabilityHash: string;
+            runtimeRelease: {
                 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 import("./post-training.js").PostTrainingControlSchema>): Promise<{
-            schemaVersion: "openpond.postTrainingSummary.v1";
+            };
+            inputs: {
+                id: string;
+                contentHash: string;
+            }[];
+            outputs: {
+                id: string;
+                contentHash: string;
+            }[];
+            spendUsd: number;
+            durationSeconds: number;
+            cleanupComplete: boolean;
+            qualification?: {
+                schemaVersion: "openpond.trainingQualificationEvidence.v1";
+                baseModel: {
+                    schemaVersion: "openpond.baseModelPreference.v1";
+                    modelId: string;
+                    modelAssetId: string | null;
+                    source: "builtin" | "local" | "managed";
+                    revision: string;
+                    tokenizerRevision: string;
+                    chatTemplateHash: string;
+                };
+                group: {
+                    id: string;
+                    contentHash: string;
+                };
+                rolloutReceipts: {
+                    id: string;
+                    contentHash: string;
+                }[];
+                rewardEvidenceHash: string;
+                groupsCompleted: 1;
+                optimizerUpdatesApplied: 0;
+                optimizerUpdatesSkipped: 0;
+                trainingStepsCreated: 0;
+                checkpointsCreated: 0;
+                artifactsCreated: 0;
+            } | undefined;
+            issuer: string;
+            issuedAt: string;
+            signature: string | null;
+        } | null;
+    }>;
+    evaluationTasks(jobId: string, evaluation: {
+        id: string;
+        contentHash: string;
+    }, options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        schemaVersion: "openpond.trainingEvaluationTaskPage.v1";
+        jobId: string;
+        teamId: string;
+        evaluation: {
             id: string;
-            teamId: string;
-            jobId: string;
+            contentHash: string;
+        };
+        kind: "baseline" | "candidate";
+        policyVersion: number;
+        taskset: {
+            id: string;
+            contentHash: string;
             revision: number;
-            planHash: string;
-            automatic: boolean;
-            candidate: {
+        };
+        panelSha256: string;
+        offset: number;
+        total: number;
+        tasks: {
+            taskId: string;
+            taskSha256: string;
+            resultSha256: string;
+            input: {
+                instruction: string;
+                context: Record<string, unknown>;
+            };
+            output: string;
+            outputSha256: string;
+            score: number;
+            evidence: {
+                kind: "hosted_trace" | "local_trace" | "worker_command";
                 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;
-        }>;
-    };
+            };
+        }[];
+        nextCursor: string | null;
+        contentHash: string;
+    }>;
+    logs(jobId: string): Promise<{
+        schemaVersion: "openpond.trainingJobLog.v2";
+        jobId: string;
+        sequence: number;
+        level: "debug" | "error" | "info" | "warning";
+        message: string;
+        createdAt: string;
+    }[]>;
 };
 //# sourceMappingURL=training.d.ts.map