openpond-sdk 0.12.5 → 0.12.6

package/dist/{chunk-XACJ63U4.js → chunk-Z4XGSEKC.js}

@@ -1,7 +1,7 @@
 import {
   TrainingHandoffOriginSchema,
   createPostTrainingClient
-} from "./chunk-RE426Q7Y.js";
+} from "./chunk-LIMTJR3A.js";
 import {
   validateHarnessPolicySourcePackage,
   validateHarnessSourcePackage
@@ -16,10 +16,13 @@ import {
   TRAINING_API_RESPONSE_MAX_BYTES,
   TRAINING_INPUT_ARTIFACT_MAX_BYTES,
   TRAINING_JOB_SUBMISSION_MAX_BYTES,
+  TrainingEstimateReviewSchema,
+  TrainingGpuCatalogSchema,
+  TrainingGpuSelectionSchema,
   assertCanonicalPayloadSize,
   canonicalSha256,
   parseBoundedJson
-} from "./chunk-CAMLCKSF.js";
+} from "./chunk-3SIGXGAE.js";
 import {
   ImmutableReleaseRefSchema
 } from "./chunk-H3JZ3P5T.js";
@@ -77,41 +80,123 @@ function createTrainingAcceptanceClient(request) {
 }
 
 // src/training.ts
-import { z as z8 } from "zod";
+import { z as z12 } from "zod";
 
-// src/training-preparations.ts
+// src/training-recovery.ts
 import { z as z2 } from "zod";
-var Id2 = z2.string().trim().min(1).max(191);
-var Hash = z2.string().regex(/^[a-f0-9]{64}$/);
-var TrainingPreparationRequestSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingPreparationRequest.v1"),
+var id = z2.string().trim().min(1).max(191);
+var hash = z2.string().regex(/^[a-f0-9]{64}$/);
+var ApprovalBodySchema = z2.object({
+  schemaVersion: z2.literal("openpond.checkpointRecoveryResourceApproval.v1"),
+  ownerUserId: id,
+  teamId: id,
+  sourceJobId: id,
+  sourceJobVersion: z2.number().int().positive(),
+  sourceInputManifestSha256: hash,
+  checkpointId: id,
+  adapterSha256: hash,
+  resumeSha256: hash,
+  idempotencyKey: z2.string().trim().min(16).max(191),
+  approvedAt: z2.iso.datetime({ offset: true }),
+  maximumSpendUsd: z2.number().positive().finite().max(30).refine(
+    (value) => Number(value.toFixed(6)) === value,
+    "Recovery spend must use whole microdollars"
+  ),
+  maximumGpuSeconds: z2.number().int().positive().max(21600),
+  maximumWallSeconds: z2.number().int().positive().max(21600)
+}).strict();
+var TrainingCheckpointRecoveryResourceApprovalSchema = ApprovalBodySchema.extend({
+  approvalHash: hash
+}).strict().superRefine((value, context) => {
+  if (value.maximumGpuSeconds > value.maximumWallSeconds)
+    context.addIssue({
+      code: "custom",
+      path: ["maximumGpuSeconds"],
+      message: "Recovery GPU duration exceeds its wall"
+    });
+});
+async function createTrainingCheckpointRecoveryResourceApproval(input) {
+  const body = ApprovalBodySchema.parse(input);
+  return TrainingCheckpointRecoveryResourceApprovalSchema.parse({
+    ...body,
+    approvalHash: await canonicalSha256(body)
+  });
+}
+var TrainingCheckpointRecoveryRequestSchema = z2.object({
+  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
+  mode: z2.literal("evaluation_only").optional(),
+  evaluationGpuType: z2.enum(["NVIDIA A100 80GB PCIe", "NVIDIA A100-SXM4-80GB", "NVIDIA H100 80GB HBM3"]).optional(),
+  expectedVersion: z2.number().int().positive(),
+  checkpointId: id,
+  idempotencyKey: z2.string().trim().min(16).max(191),
+  maximumSpendUsd: z2.number().positive().finite(),
+  maximumWallSeconds: z2.number().int().positive().max(21600)
+}).strict().superRefine((value, context) => {
+  if (value.evaluationGpuType && value.mode !== "evaluation_only")
+    context.addIssue({
+      code: "custom",
+      path: ["evaluationGpuType"],
+      message: "GPU substitution requires explicit evaluation-only recovery"
+    });
+  const a = value.resourceApproval;
+  if (a && (a.sourceJobVersion !== value.expectedVersion || a.checkpointId !== value.checkpointId || a.idempotencyKey !== value.idempotencyKey || a.maximumSpendUsd !== value.maximumSpendUsd || a.maximumWallSeconds !== value.maximumWallSeconds))
+    context.addIssue({
+      code: "custom",
+      path: ["resourceApproval"],
+      message: "Recovery resource approval does not match its request"
+    });
+});
+
+// src/training-physical-placement.ts
+import { z as z3 } from "zod";
+var TrainingPhysicalPlacementSchema = z3.object({
+  mode: z3.literal("reuse_only"),
+  physicalWorkerId: z3.string().trim().min(1).max(191),
+  providerPodId: z3.string().trim().min(1).max(191),
+  workerImageDigest: z3.string().regex(/^sha256:[a-f0-9]{64}$/),
+  baseProfileSha256: z3.string().regex(/^[a-f0-9]{64}$/),
+  gpuType: z3.string().trim().min(1).max(200),
+  sourceJobId: z3.string().trim().min(1).max(191),
+  sourceInputManifestSha256: z3.string().regex(/^[a-f0-9]{64}$/),
+  ownerTeamId: z3.string().trim().min(1).max(191),
+  deadlineAt: z3.string().datetime({ offset: true })
+}).strict();
+
+// src/training-preparations.ts
+import { z as z4 } from "zod";
+var Id2 = z4.string().trim().min(1).max(191);
+var Hash = z4.string().regex(/^[a-f0-9]{64}$/);
+var TrainingPreparationRequestSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingPreparationRequest.v1"),
   teamId: Id2,
   operationId: Id2,
   projectId: Id2.nullable(),
-  configuration: z2.object({ id: Id2, expectedRevision: z2.number().int().positive(), expectedEtag: Hash }).strict(),
+  configuration: z4.object({ id: Id2, expectedRevision: z4.number().int().positive(), expectedEtag: Hash }).strict(),
   origin: TrainingHandoffOriginSchema.optional(),
   batch: ModelProjectVersionedRefSchema,
-  name: z2.string().trim().min(1).max(191),
-  maximumSpendUsd: z2.number().finite().positive().max(1e6)
+  name: z4.string().trim().min(1).max(191),
+  maximumSpendUsd: z4.number().finite().positive().max(1e6),
+  gpuSelection: TrainingGpuSelectionSchema.optional(),
+  physicalPlacement: TrainingPhysicalPlacementSchema.optional()
 }).strict();
-var TrainingPreparationPlanContentSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingPreparationPlan.v1"),
+var TrainingPreparationPlanContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingPreparationPlan.v1"),
   id: Id2,
   creatorUserId: Id2,
   request: TrainingPreparationRequestSchema,
   requestHash: Hash,
-  source: z2.lazy(() => TrainingJobSourceSchema),
+  source: z4.lazy(() => TrainingJobSourceSchema),
   submissionHash: Hash,
-  createdAt: z2.string().datetime({ offset: true })
+  createdAt: z4.string().datetime({ offset: true })
 }).strict();
 var TrainingPreparationPlanSchema = TrainingPreparationPlanContentSchema.extend({
   contentHash: Hash
 }).strict();
-var TrainingPreparationReceiptSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingPreparationReceipt.v1"),
+var TrainingPreparationReceiptSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingPreparationReceipt.v1"),
   plan: TrainingPreparationPlanSchema,
-  revision: z2.number().int().positive(),
-  state: z2.enum(["prepared", "submitted", "cancelled"]),
+  revision: z4.number().int().positive(),
+  state: z4.enum(["prepared", "submitted", "cancelled"]),
   jobId: Id2.nullable()
 }).strict().superRefine((value, context) => {
   if (value.state === "submitted" !== Boolean(value.jobId))
@@ -121,21 +206,22 @@ var TrainingPreparationReceiptSchema = z2.object({
       message: "Only submitted preparations identify a job."
     });
 });
-var TrainingPreparationControlSchema = z2.object({
+var TrainingPreparationControlSchema = z4.object({
   teamId: Id2,
   planHash: Hash,
-  expectedRevision: z2.number().int().positive()
+  expectedRevision: z4.number().int().positive(),
+  estimateReview: TrainingEstimateReviewSchema.optional()
 }).strict();
-var TrainingPreparationListQuerySchema = z2.object({
+var TrainingPreparationListQuerySchema = z4.object({
   projectId: Id2.optional(),
-  state: z2.enum(["prepared", "submitted", "cancelled"]).optional(),
+  state: z4.enum(["prepared", "submitted", "cancelled"]).optional(),
   afterId: Id2.optional(),
-  limit: z2.number().int().min(1).max(100).default(25)
+  limit: z4.number().int().min(1).max(100).default(25)
 }).strict();
-var TrainingPreparationPageSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingPreparationPage.v1"),
+var TrainingPreparationPageSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingPreparationPage.v1"),
   teamId: Id2,
-  items: z2.array(TrainingPreparationReceiptSchema).max(100),
+  items: z4.array(TrainingPreparationReceiptSchema).max(100),
   nextCursor: Id2.nullable()
 }).strict();
 async function parseAndVerifyTrainingPreparationReceipt(value) {
@@ -150,9 +236,9 @@ async function parseAndVerifyTrainingPreparationReceipt(value) {
   return receipt;
 }
 function createTrainingPreparationClient(request) {
-  async function read(value, teamId, id) {
+  async function read(value, teamId, id2) {
     const receipt = await parseAndVerifyTrainingPreparationReceipt(value);
-    if (receipt.plan.request.teamId !== teamId || id && receipt.plan.id !== id)
+    if (receipt.plan.request.teamId !== teamId || id2 && receipt.plan.id !== id2)
       throw new OpenPondProtocolError(
         "training_preparation_scope_mismatch",
         "The training preparation belongs to a different workspace or request."
@@ -205,22 +291,22 @@ function createTrainingPreparationClient(request) {
         );
       return receipt;
     },
-    async getPreparation(teamId, id) {
+    async getPreparation(teamId, id2) {
       return read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}`),
+        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}`),
         Id2.parse(teamId),
-        id
+        id2
       );
     },
-    async startPreparation(id, input) {
+    async startPreparation(id2, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
       const receipt = await read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}/start`, {
+        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}/start`, {
           method: "POST",
           body: JSON.stringify(parsed)
         }),
         parsed.teamId,
-        id
+        id2
       );
       if (receipt.plan.contentHash !== parsed.planHash || receipt.state !== "submitted")
         throw new OpenPondProtocolError(
@@ -229,15 +315,15 @@ function createTrainingPreparationClient(request) {
         );
       return receipt;
     },
-    async cancelPreparation(id, input) {
+    async cancelPreparation(id2, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
       const receipt = await read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}/cancel`, {
+        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}/cancel`, {
           method: "POST",
           body: JSON.stringify(parsed)
         }),
         parsed.teamId,
-        id
+        id2
       );
       if (receipt.plan.contentHash !== parsed.planHash || receipt.state !== "cancelled")
         throw new OpenPondProtocolError(
@@ -249,13 +335,184 @@ function createTrainingPreparationClient(request) {
   };
 }
 
+// src/training-estimates.ts
+import { z as z5 } from "zod";
+var Id3 = z5.string().trim().min(1).max(191);
+var Hash2 = z5.string().regex(/^[a-f0-9]{64}$/);
+var Timestamp = z5.string().datetime({ offset: true });
+var NonNegative = z5.number().finite().nonnegative();
+var TrainingEstimateSourceSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("preparation"), id: Id3, planHash: Hash2, expectedRevision: z5.number().int().positive() }).strict(),
+  z5.object({
+    kind: z5.literal("configuration"),
+    id: Id3,
+    expectedRevision: z5.number().int().positive(),
+    expectedEtag: Hash2,
+    batch: ModelProjectVersionedRefSchema.nullable().default(null)
+  }).strict(),
+  z5.object({ kind: z5.literal("submission"), submission: z5.lazy(() => TrainingJobSubmissionSchema) }).strict()
+]);
+var TrainingEstimateRequestSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingEstimateRequest.v1"),
+  teamId: Id3,
+  source: TrainingEstimateSourceSchema,
+  gpuSelection: TrainingGpuSelectionSchema.optional()
+}).strict();
+var PlanningRange = z5.object({ low: NonNegative, high: NonNegative }).strict().refine((value) => value.high >= value.low, "Planning range must be ordered");
+var TrainingEstimateComponentSchema = z5.object({
+  phase: z5.enum([
+    "startup",
+    "baseline_evaluation",
+    "rollouts",
+    "optimization",
+    "checkpointing",
+    "backbone_materialization",
+    "final_evaluation",
+    "publication",
+    "cleanup",
+    "retention"
+  ]),
+  resource: z5.enum(["gpu", "cpu", "judge", "storage", "network"]),
+  expectedUsd: NonNegative.nullable(),
+  expectedSeconds: NonNegative.nullable(),
+  planningRangeUsd: PlanningRange.nullable(),
+  evidence: z5.enum(["measured", "configured_rate", "unavailable"]),
+  reason: z5.string().trim().min(1).max(1e3).nullable()
+}).strict();
+function trainingEstimateSourceIdentity(source) {
+  if (source.kind === "submission") return {
+    kind: source.kind,
+    id: source.submission.idempotencyKey,
+    contentHash: source.submission.contentHash,
+    revision: null
+  };
+  if (source.kind === "preparation") return {
+    kind: source.kind,
+    id: source.id,
+    contentHash: source.planHash,
+    revision: source.expectedRevision
+  };
+  return { kind: source.kind, id: source.id, contentHash: source.expectedEtag, revision: source.expectedRevision };
+}
+var TrainingEstimateSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingEstimate.v1"),
+  id: Id3,
+  teamId: Id3,
+  requestHash: Hash2,
+  inputHash: Hash2,
+  source: z5.object({
+    kind: z5.enum(["preparation", "configuration", "submission"]),
+    id: Id3,
+    contentHash: Hash2,
+    revision: z5.number().int().positive().nullable()
+  }).strict(),
+  status: z5.enum(["available", "partial", "insufficient_evidence"]),
+  currency: z5.literal("USD"),
+  createdAt: Timestamp,
+  expiresAt: Timestamp,
+  estimatorVersion: Id3,
+  runtimeVersion: Id3,
+  pricing: z5.object({ version: Id3, quoteExpiresAt: Timestamp.nullable() }).strict(),
+  gpu: z5.object({
+    requested: TrainingGpuSelectionSchema,
+    resolved: z5.object({ availabilityId: Id3, gpuType: z5.string().min(1).max(256), gpuCount: z5.literal(1) }).strict().nullable(),
+    customerHourlyUsd: NonNegative.nullable(),
+    availability: z5.enum(["available", "limited", "unavailable", "unknown"])
+  }).strict(),
+  configuration: z5.object({
+    modelId: Id3,
+    modelRevision: z5.string().min(1).max(256),
+    method: Id3,
+    loraRank: z5.number().int().positive().nullable(),
+    adapterMode: z5.enum(["residual_append", "shared", "sequential_merge"]).nullable(),
+    groups: z5.number().int().nonnegative().nullable(),
+    rolloutConcurrency: z5.number().int().positive().nullable(),
+    maxOutputTokens: z5.number().int().positive().nullable(),
+    trainingRows: z5.number().int().nonnegative().nullable(),
+    evaluationRows: z5.number().int().nonnegative().nullable(),
+    retentionDays: z5.number().int().positive().nullable(),
+    approvedMaximumUsd: NonNegative.nullable()
+  }).strict(),
+  cost: z5.object({
+    expectedUsd: NonNegative.nullable(),
+    planningRangeUsd: PlanningRange.nullable(),
+    knownMinimumUsd: NonNegative,
+    recommendedMaximumUsd: NonNegative.nullable(),
+    minimumCleanupReserveUsd: NonNegative.nullable(),
+    components: z5.array(TrainingEstimateComponentSchema).max(50)
+  }).strict(),
+  executionSeconds: z5.object({ expected: NonNegative.nullable(), planningRange: PlanningRange.nullable() }).strict(),
+  queueWaitSeconds: z5.object({ expected: NonNegative, planningRange: PlanningRange.nullable() }).strict().nullable(),
+  calibration: z5.object({
+    version: Id3,
+    cohortHash: Hash2,
+    completedSamples: z5.number().int().nonnegative(),
+    partialSamples: z5.number().int().nonnegative(),
+    scope: z5.enum(["workspace", "authorized_aggregate"])
+  }).strict(),
+  assumptions: z5.array(z5.string().trim().min(1).max(1e3)).max(50),
+  unknowns: z5.array(z5.string().trim().min(1).max(1e3)).max(50),
+  review: TrainingEstimateReviewSchema
+}).strict().superRefine((estimate, context) => {
+  if (estimate.review.estimateId !== estimate.id || estimate.review.inputHash !== estimate.inputHash || estimate.review.requestHash !== estimate.requestHash || estimate.review.pricingVersion !== estimate.pricing.version || estimate.review.expiresAt !== estimate.expiresAt) {
+    context.addIssue({ code: "custom", path: ["review"], message: "Estimate review identity differs from the estimate" });
+  }
+  if (Date.parse(estimate.expiresAt) <= Date.parse(estimate.createdAt)) {
+    context.addIssue({ code: "custom", path: ["expiresAt"], message: "Estimate must expire after its creation" });
+  }
+  if (estimate.status === "available" && (estimate.cost.expectedUsd === null || estimate.executionSeconds.expected === null || estimate.unknowns.length > 0)) {
+    context.addIssue({ code: "custom", path: ["status"], message: "An available estimate requires complete cost and duration coverage" });
+  }
+  if (estimate.gpu.requested.mode === "manual" && estimate.gpu.resolved && (estimate.gpu.requested.availabilityId !== estimate.gpu.resolved.availabilityId || estimate.gpu.requested.gpuType !== estimate.gpu.resolved.gpuType)) {
+    context.addIssue({ code: "custom", path: ["gpu"], message: "An explicit GPU offering cannot be substituted" });
+  }
+});
+function createTrainingEstimateClient(request) {
+  return {
+    async estimate(input) {
+      const parsed = TrainingEstimateRequestSchema.parse(input);
+      if (parsed.source.kind === "submission") await parseAndVerifyTrainingJobSubmission(parsed.source.submission);
+      const result = TrainingEstimateSchema.parse(await request("/v1/training/estimates", {
+        method: "POST",
+        body: JSON.stringify(parsed)
+      }));
+      if (result.teamId !== parsed.teamId || result.requestHash !== await canonicalSha256(parsed) || await canonicalSha256(result.source) !== await canonicalSha256(trainingEstimateSourceIdentity(parsed.source)) || parsed.gpuSelection && await canonicalSha256(result.gpu.requested) !== await canonicalSha256(parsed.gpuSelection)) {
+        throw new OpenPondProtocolError("training_estimate_scope_mismatch", "The estimate does not match the requested workspace and exact configuration.");
+      }
+      return result;
+    }
+  };
+}
+
+// src/training-queue.ts
+import { z as z6 } from "zod";
+var Timestamp2 = z6.string().datetime({ offset: true });
+var TrainingQueueStatusSchema = z6.object({
+  ticketId: z6.string().trim().min(1).max(191),
+  ticketNumber: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  label: z6.literal("Waiting for resources"),
+  position: z6.number().int().positive().nullable(),
+  positionScope: z6.literal("compatible_fair_queue"),
+  enqueuedAt: Timestamp2,
+  asOf: Timestamp2,
+  estimate: z6.object({
+    revision: z6.number().int().nonnegative(),
+    estimatedStartAt: Timestamp2,
+    expiresAt: Timestamp2,
+    evidence: z6.enum(["observed_capacity", "measured_bootstrap", "scheduled_release"])
+  }).strict().nullable()
+}).strict().superRefine((value, context) => {
+  if (value.estimate && Date.parse(value.estimate.expiresAt) <= Date.parse(value.asOf))
+    context.addIssue({ code: "custom", path: ["estimate"], message: "An expired queue forecast must be returned as unavailable" });
+});
+
 // src/training-harness-sources.ts
-import { z as z3 } from "zod";
-var TrainingHarnessSourcePublicationSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingHarnessSourcePublication.v1"),
+import { z as z7 } from "zod";
+var TrainingHarnessSourcePublicationSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingHarnessSourcePublication.v1"),
   harnessRelease: ImmutableReleaseRefSchema,
-  sourcePackageHash: z3.string().regex(/^[a-f0-9]{64}$/),
-  sizeBytes: z3.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
+  sourcePackageHash: z7.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: z7.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
 }).strict();
 function createTrainingHarnessSourceClient(request) {
   const route = (reference) => {
@@ -288,28 +545,28 @@ function validateSource(value, reference) {
 }
 
 // src/training-candidate-decisions.ts
-import { z as z4 } from "zod";
-var IdSchema = /* @__PURE__ */ (() => z4.string().trim().min(1).max(500))();
-var HashSchema = /* @__PURE__ */ (() => z4.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z4.object({
-  schemaVersion: z4.literal("openpond.trainingCandidateDecisionRequest.v1"),
+import { z as z8 } from "zod";
+var IdSchema = /* @__PURE__ */ (() => z8.string().trim().min(1).max(500))();
+var HashSchema = /* @__PURE__ */ (() => z8.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z8.object({
+  schemaVersion: z8.literal("openpond.trainingCandidateDecisionRequest.v1"),
   teamId: IdSchema,
   jobId: IdSchema,
   artifact: ModelProjectImmutableRefSchema,
   evaluation: ModelProjectImmutableRefSchema,
   executionReceipt: ModelProjectImmutableRefSchema,
-  decision: z4.enum(["accepted", "rejected"]),
-  reason: z4.string().trim().min(1).max(5e3),
+  decision: z8.enum(["accepted", "rejected"]),
+  reason: z8.string().trim().min(1).max(5e3),
   idempotencyKey: IdSchema,
   expectedDecision: ModelProjectImmutableRefSchema.nullable()
 }).strict())();
-var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z4.object({
-  schemaVersion: z4.literal("openpond.trainingCandidateDecision.v1"),
+var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z8.object({
+  schemaVersion: z8.literal("openpond.trainingCandidateDecision.v1"),
   id: IdSchema,
   request: TrainingCandidateDecisionRequestSchema,
-  revision: z4.number().int().positive(),
-  actor: z4.object({ userId: IdSchema, kind: z4.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
-  decidedAt: z4.string().datetime({ offset: true }),
+  revision: z8.number().int().positive(),
+  actor: z8.object({ userId: IdSchema, kind: z8.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
+  decidedAt: z8.string().datetime({ offset: true }),
   contentHash: HashSchema
 }).strict().superRefine((value, context) => {
   if (value.revision === 1 !== (value.request.expectedDecision === null)) {
@@ -346,7 +603,7 @@ function createTrainingCandidateDecisionClient(request) {
       IdSchema.parse(target.teamId);
       const reference = options.decision ? ModelProjectImmutableRefSchema.parse(options.decision) : void 0;
       const query = reference ? `?decisionId=${encodeURIComponent(reference.id)}` : "";
-      const response = z4.object({ decision: z4.unknown().nullable() }).strict().parse(await request(`${route(target)}${query}`));
+      const response = z8.object({ decision: z8.unknown().nullable() }).strict().parse(await request(`${route(target)}${query}`));
       if (response.decision === null && !reference) return null;
       const decision = await parseAndVerifyTrainingCandidateDecision(response.decision, target);
       if (reference && (decision.id !== reference.id || decision.contentHash !== reference.contentHash)) {
@@ -363,38 +620,38 @@ function createTrainingCandidateDecisionClient(request) {
 }
 
 // src/training-evaluation-results.ts
-import { z as z5 } from "zod";
-var IdSchema2 = /* @__PURE__ */ (() => z5.string().trim().min(1).max(500))();
-var HashSchema2 = /* @__PURE__ */ (() => z5.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z5.object({
+import { z as z9 } from "zod";
+var IdSchema2 = /* @__PURE__ */ (() => z9.string().trim().min(1).max(500))();
+var HashSchema2 = /* @__PURE__ */ (() => z9.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z9.object({
   taskId: IdSchema2,
   taskSha256: HashSchema2,
   resultSha256: HashSchema2,
-  input: z5.object({
-    instruction: z5.string().max(1e6),
-    context: z5.record(z5.string(), z5.unknown())
+  input: z9.object({
+    instruction: z9.string().max(1e6),
+    context: z9.record(z9.string(), z9.unknown())
   }).strict(),
-  output: z5.string().max(1e6),
+  output: z9.string().max(1e6),
   outputSha256: HashSchema2,
-  score: z5.number().finite().min(0).max(1),
-  evidence: z5.object({
-    kind: z5.enum(["worker_command", "hosted_trace", "local_trace"]),
+  score: z9.number().finite().min(0).max(1),
+  evidence: z9.object({
+    kind: z9.enum(["worker_command", "hosted_trace", "local_trace"]),
     id: IdSchema2
   }).strict()
 }).strict())();
-var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z5.object({
-  schemaVersion: z5.literal("openpond.trainingEvaluationTaskPage.v1"),
+var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z9.object({
+  schemaVersion: z9.literal("openpond.trainingEvaluationTaskPage.v1"),
   jobId: IdSchema2,
   teamId: IdSchema2,
   evaluation: ModelProjectImmutableRefSchema,
-  kind: z5.enum(["baseline", "candidate"]),
-  policyVersion: z5.number().int().nonnegative(),
+  kind: z9.enum(["baseline", "candidate"]),
+  policyVersion: z9.number().int().nonnegative(),
   taskset: ModelProjectVersionedRefSchema,
   panelSha256: HashSchema2,
-  offset: z5.number().int().nonnegative(),
-  total: z5.number().int().min(1).max(1e4),
-  tasks: z5.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
-  nextCursor: z5.string().regex(/^[1-9]\d*$/).nullable(),
+  offset: z9.number().int().nonnegative(),
+  total: z9.number().int().min(1).max(1e4),
+  tasks: z9.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
+  nextCursor: z9.string().regex(/^[1-9]\d*$/).nullable(),
   contentHash: HashSchema2
 }).strict().superRefine((page, context) => {
   const end = page.offset + page.tasks.length;
@@ -429,12 +686,12 @@ async function parseAndVerifyTrainingEvaluationTaskPage(value, expected) {
 }
 
 // src/training-grading-plan.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-var GradersSchema = z6.array(z6.object({ id: z6.string().trim().min(1) }).catchall(z6.unknown())).min(1).max(1e3);
-var RewardExecutionSchema = z6.object({
+var GradersSchema = z10.array(z10.object({ id: z10.string().trim().min(1) }).catchall(z10.unknown())).min(1).max(1e3);
+var RewardExecutionSchema = z10.object({
   binding: RewardBindingSchema,
-  rewards: z6.array(RewardReleaseSchema).min(1).max(100)
+  rewards: z10.array(RewardReleaseSchema).min(1).max(100)
 }).strict();
 async function deterministicTrainingRewardSource(input) {
   const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
@@ -442,32 +699,32 @@ async function deterministicTrainingRewardSource(input) {
   if (new Set(graders.map((grader) => grader.id)).size !== graders.length) {
     throw new Error("Training grader identities must be unique.");
   }
-  const hash = await canonicalSha256({ schemaVersion: "openpond.trainingGraderSet.v1", graders });
+  const hash2 = await canonicalSha256({ schemaVersion: "openpond.trainingGraderSet.v1", graders });
   return {
     kind: "deterministic",
-    grader: { id: `training-graders-${hash.slice(0, 32)}`, contentHash: hash },
+    grader: { id: `training-graders-${hash2.slice(0, 32)}`, contentHash: hash2 },
     composer: execution ? { id: execution.binding.id, contentHash: execution.binding.contentHash } : null
   };
 }
 
 // src/training-evaluation-source.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
-var TaskIdentitySchema = z7.object({
-  id: z7.string().trim().min(1),
-  clusterKey: z7.string().trim().min(1),
-  split: z7.enum(["train", "validation", "frozen_eval"])
+var TaskIdentitySchema = z11.object({
+  id: z11.string().trim().min(1),
+  clusterKey: z11.string().trim().min(1),
+  split: z11.enum(["train", "validation", "frozen_eval"])
 }).passthrough();
-var TrainingEvaluationSourceSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingEvaluationSource.v1"),
+var TrainingEvaluationSourceSchema = z11.object({
+  schemaVersion: z11.literal("openpond.trainingEvaluationSource.v1"),
   taskset: ModelProjectVersionedRefSchema,
-  tasks: z7.array(TaskIdentitySchema).min(1).max(1e4),
-  assets: z7.array(z7.object({
-    path: z7.string().trim().min(1).max(2e3),
-    sha256: z7.string().regex(/^[a-f0-9]{64}$/),
-    sizeBytes: z7.number().int().nonnegative(),
-    encoding: z7.literal("base64"),
-    content: z7.string().max(32 * 1024 * 1024)
+  tasks: z11.array(TaskIdentitySchema).min(1).max(1e4),
+  assets: z11.array(z11.object({
+    path: z11.string().trim().min(1).max(2e3),
+    sha256: z11.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z11.number().int().nonnegative(),
+    encoding: z11.literal("base64"),
+    content: z11.string().max(32 * 1024 * 1024)
   }).strict()).max(1e4)
 }).strict().superRefine((source, context) => {
   const ids = /* @__PURE__ */ new Set();
@@ -478,8 +735,8 @@ var TrainingEvaluationSourceSchema = z7.object({
   });
 });
 function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
-  const training = z7.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
-  const evaluation = z7.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
+  const training = z11.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
+  const evaluation = z11.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
   const trainIds = /* @__PURE__ */ new Set();
   const trainFamilies = /* @__PURE__ */ new Set();
   for (const task of training) {
@@ -500,29 +757,29 @@ function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
 }
 async function trainingEvaluationSourceRef(input) {
   const source = TrainingEvaluationSourceSchema.parse(input);
-  const hash = await canonicalSha256(source);
-  return { taskset: source.taskset, dataset: { id: `training-evaluation-${hash.slice(0, 32)}`, contentHash: hash } };
+  const hash2 = await canonicalSha256(source);
+  return { taskset: source.taskset, dataset: { id: `training-evaluation-${hash2.slice(0, 32)}`, contentHash: hash2 } };
 }
 
 // src/training.ts
-var IdSchema3 = z8.string().trim().min(1).max(500);
-var HashSchema3 = z8.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z8.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z8.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z8.string().trim().min(1).max(500),
+var IdSchema3 = z12.string().trim().min(1).max(500);
+var HashSchema3 = z12.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z12.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z12.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z12.string().trim().min(1).max(500),
   sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z8.unknown(),
+  payload: z12.unknown(),
   contentHash: HashSchema3
 }).strict();
-var TrainingInputArtifactSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingInputArtifact.v2"),
-  kind: z8.enum(["portable_training_bundle", "reward_model_dataset"]),
+var TrainingInputArtifactSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingInputArtifact.v2"),
+  kind: z12.enum(["portable_training_bundle", "reward_model_dataset"]),
   sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z8.string().trim().min(1).max(2e3),
+  artifactRef: z12.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z8.number().int().positive(),
+  sizeBytes: z12.number().int().positive(),
   createdAt: TimestampSchema
 }).strict();
 async function trainingInputArtifactUploadHash(upload) {
@@ -541,8 +798,8 @@ async function parseAndVerifyTrainingInputArtifactUpload(value) {
   }
   return parsed;
 }
-var TrainingJobKindSchema = z8.enum(["reward_model_train", "policy_optimize"]);
-var TrainingJobStateSchema = z8.enum([
+var TrainingJobKindSchema = z12.enum(["reward_model_train", "policy_optimize"]);
+var TrainingJobStateSchema = z12.enum([
   "queued",
   "admitting",
   "provisioning",
@@ -553,53 +810,53 @@ var TrainingJobStateSchema = z8.enum([
   "failed",
   "cancelled"
 ]);
-var TrainingCapabilityRequirementSchema = z8.object({
+var TrainingCapabilityRequirementSchema = z12.object({
   id: IdSchema3,
-  version: z8.string().trim().min(1).max(200).nullable().default(null),
-  required: z8.boolean().default(true)
+  version: z12.string().trim().min(1).max(200).nullable().default(null),
+  required: z12.boolean().default(true)
 }).strict();
-var TrainingJobSourceSchema = z8.object({
+var TrainingJobSourceSchema = z12.object({
   origin: TrainingHandoffOriginSchema.optional(),
-  modelProject: z8.object({
+  modelProject: z12.object({
     id: IdSchema3,
     portableProjectId: IdSchema3,
-    revision: z8.number().int().positive(),
+    revision: z12.number().int().positive(),
     contentHash: HashSchema3
   }).strict(),
   harnessRunManifest: ModelProjectImmutableRefSchema,
   harnessRelease: ModelProjectImmutableRefSchema,
   taskset: ModelProjectVersionedRefSchema,
   tasksetRelease: ModelProjectImmutableRefSchema,
-  evaluation: z8.object({
+  evaluation: z12.object({
     taskset: ModelProjectVersionedRefSchema,
     dataset: ModelProjectImmutableRefSchema
   }).strict().nullable().optional(),
   dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z8.array(ModelProjectImmutableRefSchema).max(1e4)
+  evidenceSets: z12.array(ModelProjectImmutableRefSchema).max(1e4)
 }).strict();
-var RewardModelTrainingRequestSchema = z8.object({
-  kind: z8.literal("reward_model_train"),
+var RewardModelTrainingRequestSchema = z12.object({
+  kind: z12.literal("reward_model_train"),
   baseModel: ModelProjectBaseModelSchema,
   preferenceDatasetRelease: ModelProjectImmutableRefSchema,
   processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z8.object({
-    schemaVersion: z8.literal("openpond.rewardModelRecipe.v1"),
-    method: z8.literal("reward_model"),
-    parameterization: z8.literal("lora_with_scalar_head")
-  }).catchall(z8.unknown())
+  recipe: z12.object({
+    schemaVersion: z12.literal("openpond.rewardModelRecipe.v1"),
+    method: z12.literal("reward_model"),
+    parameterization: z12.literal("lora_with_scalar_head")
+  }).catchall(z12.unknown())
 }).strict();
-var DeterministicRewardSourceSchema = z8.object({
-  kind: z8.literal("deterministic"),
+var DeterministicRewardSourceSchema = z12.object({
+  kind: z12.literal("deterministic"),
   grader: ModelProjectImmutableRefSchema,
   composer: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var LearnedRewardSourceSchema = z8.object({
-  kind: z8.literal("learned_reward"),
+var LearnedRewardSourceSchema = z12.object({
+  kind: z12.literal("learned_reward"),
   rewardModelVersion: ModelProjectImmutableRefSchema,
   qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z8.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z8.object({
-    artifactRef: z8.string().trim().min(1).max(2e3),
+  evaluationReferences: z12.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z12.object({
+    artifactRef: z12.string().trim().min(1).max(2e3),
     contentHash: HashSchema3,
     executionReceipt: ModelProjectImmutableRefSchema
   }).strict(),
@@ -607,49 +864,54 @@ var LearnedRewardSourceSchema = z8.object({
   rewardComposerRelease: ModelProjectImmutableRefSchema
 }).strict();
 var TrainingQualificationBaseModelSchema = ModelProjectBaseModelSchema.extend({
-  revision: z8.string().regex(/^[a-f0-9]{40,64}$/),
-  tokenizerRevision: z8.string().regex(/^[a-f0-9]{40,64}$/),
+  revision: z12.string().regex(/^[a-f0-9]{40,64}$/),
+  tokenizerRevision: z12.string().regex(/^[a-f0-9]{40,64}$/),
   chatTemplateHash: HashSchema3
 }).strict();
-var PolicyOptimizationRequestSchema = z8.object({
-  kind: z8.literal("policy_optimize"),
+var PolicyOptimizationRequestSchema = z12.object({
+  kind: z12.literal("policy_optimize"),
   /** Collect and grade one original-learner group without optimizer work. */
-  executionMode: z8.literal("qualification").optional(),
+  executionMode: z12.literal("qualification").optional(),
   baseModel: ModelProjectBaseModelSchema,
   recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z8.discriminatedUnion("kind", [
+  rewardSource: z12.discriminatedUnion("kind", [
     DeterministicRewardSourceSchema,
     LearnedRewardSourceSchema
   ]),
   resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var TrainingJobRequestSchema = z8.discriminatedUnion("kind", [
+var TrainingJobRequestSchema = z12.discriminatedUnion("kind", [
   RewardModelTrainingRequestSchema,
   PolicyOptimizationRequestSchema
 ]);
-var TrainingJobApprovalSchema = z8.object({
+var TrainingJobApprovalSchema = z12.object({
   approvalHash: HashSchema3,
   approvedAt: TimestampSchema,
-  exportApproved: z8.boolean(),
-  maximumSpendUsd: z8.number().nonnegative(),
-  retentionDays: z8.number().int().nonnegative().nullable(),
-  region: z8.string().trim().min(1).max(200).nullable().default(null)
+  exportApproved: z12.boolean(),
+  maximumSpendUsd: z12.number().nonnegative(),
+  retentionDays: z12.number().int().nonnegative().nullable(),
+  region: z12.string().trim().min(1).max(200).nullable().default(null)
 }).strict();
-var TrainingJobSubmissionSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z8.string().trim().min(1).max(500),
-  name: z8.string().trim().min(1).max(200),
+var TrainingJobSubmissionSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z12.string().trim().min(1).max(500),
+  name: z12.string().trim().min(1).max(200),
   source: TrainingJobSourceSchema,
   job: TrainingJobRequestSchema,
-  requestedCapabilities: z8.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z8.enum(["fast", "balanced", "economical"]),
-  budget: z8.object({
-    maximumSpendUsd: z8.number().nonnegative(),
-    maximumWallSeconds: z8.number().int().positive()
+  requestedCapabilities: z12.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z12.enum(["fast", "balanced", "economical"]),
+  gpuSelection: TrainingGpuSelectionSchema.optional(),
+  physicalPlacement: TrainingPhysicalPlacementSchema.optional(),
+  budget: z12.object({
+    maximumSpendUsd: z12.number().nonnegative(),
+    maximumWallSeconds: z12.number().int().positive()
   }).strict(),
   approval: TrainingJobApprovalSchema,
   contentHash: HashSchema3
 }).strict().superRefine((submission, context) => {
+  if (submission.physicalPlacement && (submission.job.kind !== "policy_optimize" || submission.job.resumeFrom || submission.job.executionMode || submission.job.recipe.continuation !== void 0)) {
+    context.addIssue({ code: "custom", path: ["physicalPlacement"], message: "Reuse-only placement requires fresh-base policy training without continuation." });
+  }
   if (submission.job.kind === "policy_optimize" && submission.job.executionMode === "qualification") {
     const job = submission.job;
     if (!TrainingQualificationBaseModelSchema.safeParse(job.baseModel).success) {
@@ -694,87 +956,99 @@ async function parseAndVerifyTrainingJobSubmission(value) {
   }
   return parsed;
 }
-var TrainingJobSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJob.v2"),
+var TrainingJobRecoverySchema = z12.object({
+  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
+  mode: z12.literal("evaluation_only").optional(),
+  trainingWorkloadComplete: z12.boolean().optional(),
+  sourceJobId: IdSchema3,
+  checkpointId: IdSchema3,
+  policyVersion: z12.number().int().positive(),
+  completedGroups: z12.number().int().positive(),
+  optimizerMode: z12.literal("continue")
+}).strict();
+var TrainingJobSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJob.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   kind: TrainingJobKindSchema,
-  executionMode: z8.literal("qualification").optional(),
+  executionMode: z12.literal("qualification").optional(),
+  recovery: TrainingJobRecoverySchema.optional(),
   modelProjectId: IdSchema3,
   portableProjectId: IdSchema3,
-  sourceProjectRevision: z8.number().int().positive(),
+  sourceProjectRevision: z12.number().int().positive(),
   submissionHash: HashSchema3,
   state: TrainingJobStateSchema,
-  phase: z8.string().trim().min(1).max(200),
-  version: z8.number().int().nonnegative(),
-  progress: z8.number().min(0).max(1),
-  rolloutProgress: z8.object({
-    groupsCompleted: z8.number().int().nonnegative(),
-    groupsTarget: z8.number().int().nonnegative(),
-    optimizerUpdatesApplied: z8.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z8.number().int().nonnegative()
+  queue: TrainingQueueStatusSchema.optional(),
+  phase: z12.string().trim().min(1).max(200),
+  version: z12.number().int().nonnegative(),
+  progress: z12.number().min(0).max(1),
+  rolloutProgress: z12.object({
+    groupsCompleted: z12.number().int().nonnegative(),
+    groupsTarget: z12.number().int().nonnegative(),
+    optimizerUpdatesApplied: z12.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z12.number().int().nonnegative()
   }).strict(),
-  accruedSpendUsd: z8.number().nonnegative(),
-  terminalReason: z8.string().trim().min(1).max(5e3).nullable(),
+  accruedSpendUsd: z12.number().nonnegative(),
+  terminalReason: z12.string().trim().min(1).max(5e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
   completedAt: TimestampSchema.nullable()
 }).strict();
-var TrainingJobPageSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobPage.v2"),
-  jobs: z8.array(TrainingJobSchema).max(1e3),
-  nextCursor: z8.string().trim().min(1).max(2e3).nullable()
+var TrainingJobPageSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobPage.v2"),
+  jobs: z12.array(TrainingJobSchema).max(1e3),
+  nextCursor: z12.string().trim().min(1).max(2e3).nullable()
 }).strict();
-var TrainingJobEventSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobEvent.v2"),
+var TrainingJobEventSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobEvent.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  sequence: z8.number().int().nonnegative(),
+  sequence: z12.number().int().nonnegative(),
   type: IdSchema3,
-  phase: z8.string().trim().min(1).max(200),
-  message: z8.string().trim().min(1).max(5e3).nullable(),
-  data: z8.record(z8.string(), z8.unknown()).default({}),
+  phase: z12.string().trim().min(1).max(200),
+  message: z12.string().trim().min(1).max(5e3).nullable(),
+  data: z12.record(z12.string(), z12.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobLogSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobLog.v2"),
+var TrainingJobLogSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobLog.v2"),
   jobId: IdSchema3,
-  sequence: z8.number().int().nonnegative(),
-  level: z8.enum(["debug", "info", "warning", "error"]),
-  message: z8.string().max(2e4),
+  sequence: z12.number().int().nonnegative(),
+  level: z12.enum(["debug", "info", "warning", "error"]),
+  message: z12.string().max(2e4),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobControlRequestSchema = z8.object({ expectedVersion: z8.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobOutput.v2"),
+var TrainingJobControlRequestSchema = z12.object({ expectedVersion: z12.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobOutput.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  kind: z8.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
-  artifactRef: z8.string().trim().min(1).max(2e3),
+  kind: z12.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
+  artifactRef: z12.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z8.number().int().nonnegative(),
-  metadata: z8.record(z8.string(), z8.unknown()).default({}),
+  sizeBytes: z12.number().int().nonnegative(),
+  metadata: z12.record(z12.string(), z12.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingQualificationEvidenceSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingQualificationEvidence.v1"),
+var TrainingQualificationEvidenceSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingQualificationEvidence.v1"),
   baseModel: TrainingQualificationBaseModelSchema,
   group: ModelProjectImmutableRefSchema,
-  rolloutReceipts: z8.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
+  rolloutReceipts: z12.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
   rewardEvidenceHash: HashSchema3,
-  groupsCompleted: z8.literal(1),
-  optimizerUpdatesApplied: z8.literal(0),
-  optimizerUpdatesSkipped: z8.literal(0),
-  trainingStepsCreated: z8.literal(0),
-  checkpointsCreated: z8.literal(0),
-  artifactsCreated: z8.literal(0)
+  groupsCompleted: z12.literal(1),
+  optimizerUpdatesApplied: z12.literal(0),
+  optimizerUpdatesSkipped: z12.literal(0),
+  trainingStepsCreated: z12.literal(0),
+  checkpointsCreated: z12.literal(0),
+  artifactsCreated: z12.literal(0)
 }).strict().superRefine((evidence, context) => {
   if (new Set(evidence.rolloutReceipts.map((receipt) => receipt.id)).size !== evidence.rolloutReceipts.length) {
     context.addIssue({ code: "custom", path: ["rolloutReceipts"], message: "Qualification rollout receipt identities must be unique." });
   }
 });
-var TrainingExecutionReceiptSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingExecutionReceipt.v2"),
+var TrainingExecutionReceiptSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingExecutionReceipt.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   jobId: IdSchema3,
@@ -783,15 +1057,15 @@ var TrainingExecutionReceiptSchema = z8.object({
   recipeHash: HashSchema3,
   capabilityHash: HashSchema3,
   runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z8.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z8.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z8.number().nonnegative(),
-  durationSeconds: z8.number().nonnegative(),
-  cleanupComplete: z8.boolean(),
+  inputs: z12.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z12.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z12.number().nonnegative(),
+  durationSeconds: z12.number().nonnegative(),
+  cleanupComplete: z12.boolean(),
   qualification: TrainingQualificationEvidenceSchema.optional(),
   issuer: IdSchema3,
   issuedAt: TimestampSchema,
-  signature: z8.string().trim().min(1).max(1e4).nullable()
+  signature: z12.string().trim().min(1).max(1e4).nullable()
 }).strict();
 async function trainingExecutionReceiptHash(receipt) {
   return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
@@ -846,18 +1120,18 @@ async function assertTrainingQualificationReceipt(receipt, expected) {
     throw new OpenPondProtocolError("qualification_updated_artifact", "Qualification must not publish trained artifacts or checkpoints.");
   }
 }
-var TrainingJobOutputsSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z8.array(TrainingJobOutputSchema).max(1e4),
+var TrainingJobOutputsSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z12.array(TrainingJobOutputSchema).max(1e4),
   receipt: TrainingExecutionReceiptSchema.nullable()
 }).strict();
-var TrainingApiErrorSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingApiError.v2"),
-  code: z8.string().trim().min(1).max(200),
-  message: z8.string().trim().min(1).max(5e3),
-  retryable: z8.boolean().default(false),
-  requestId: z8.string().trim().min(1).max(500).nullable().default(null),
-  details: z8.record(z8.string(), z8.unknown()).default({})
+var TrainingApiErrorSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingApiError.v2"),
+  code: z12.string().trim().min(1).max(200),
+  message: z12.string().trim().min(1).max(5e3),
+  retryable: z12.boolean().default(false),
+  requestId: z12.string().trim().min(1).max(500).nullable().default(null),
+  details: z12.record(z12.string(), z12.unknown()).default({})
 }).strict();
 var OpenPondTrainingApiError = class extends Error {
   status;
@@ -875,31 +1149,56 @@ var OpenPondTrainingApiError = class extends Error {
     this.details = error.details;
   }
 };
-var TrainingCapabilitiesSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingCapabilities.v2"),
+var TrainingPolicyLoraCapabilitiesSchema = z12.object({
+  workerImageDigest: z12.string().regex(/^sha256:[a-f0-9]{64}$/),
+  envelopeRank: z12.number().int().positive().max(256),
+  supportedRanks: z12.array(z12.number().int().positive().max(256)).max(256),
+  qualification: z12.object({ evidenceRef: z12.string().min(1), evidenceSha256: HashSchema3 }).strict().nullable(),
+  continuation: z12.object({
+    sharedRequiresSameRank: z12.literal(true),
+    mergedRequiresSameRank: z12.literal(true),
+    residualAppendRequiresFreeCapacity: z12.literal(true),
+    stageOptimizer: z12.literal("reset"),
+    interruptedRecoveryOptimizer: z12.literal("restore")
+  }).strict()
+}).strict().superRefine((value, context) => {
+  if (new Set(value.supportedRanks).size !== value.supportedRanks.length || value.supportedRanks.some((rank) => rank > value.envelopeRank))
+    context.addIssue({ code: "custom", path: ["supportedRanks"], message: "Supported ranks must be unique and fit the physical adapter envelope." });
+  if (value.supportedRanks.length && !value.qualification)
+    context.addIssue({ code: "custom", path: ["qualification"], message: "Advertised ranks require immutable image qualification evidence." });
+});
+function supportsTrainingPolicyLoraRank(capabilities, rank, continuation) {
+  if (!capabilities.supportedRanks.includes(rank)) return false;
+  if (!continuation) return true;
+  return continuation.mode === "residual_append" ? continuation.parentEnabledRank + rank <= capabilities.envelopeRank : continuation.parentEnabledRank === rank;
+}
+var TrainingCapabilitiesSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingCapabilities.v2"),
   capabilityHash: HashSchema3,
-  jobKinds: z8.array(TrainingJobKindSchema),
-  methods: z8.array(z8.string().trim().min(1).max(200)),
-  executionModes: z8.array(z8.enum(["training", "qualification"])).optional(),
-  structuredOutputs: z8.object({
-    capability: z8.literal("work.structured-output.v1"),
+  jobKinds: z12.array(TrainingJobKindSchema),
+  methods: z12.array(z12.string().trim().min(1).max(200)),
+  executionModes: z12.array(z12.enum(["training", "qualification"])).optional(),
+  policyLora: TrainingPolicyLoraCapabilitiesSchema.optional(),
+  structuredOutputs: z12.object({
+    capability: z12.literal("work.structured-output.v1"),
     harnessRuntimeHash: HashSchema3,
     workHarnessHash: HashSchema3,
     schemaHash: HashSchema3,
     artifactHash: HashSchema3,
-    invalidDataRejected: z8.literal(true),
-    invalidBytesRejected: z8.literal(true)
+    invalidDataRejected: z12.literal(true),
+    invalidBytesRejected: z12.literal(true)
   }).strict().optional(),
-  placements: z8.array(z8.enum(["local", "remote", "colocated", "provider_native"])),
-  controls: z8.object({
-    cancel: z8.boolean(),
-    stopAfterGroup: z8.boolean(),
-    resumeFromCheckpoint: z8.boolean()
+  placements: z12.array(z12.enum(["local", "remote", "colocated", "provider_native"])),
+  controls: z12.object({
+    cancel: z12.boolean(),
+    stopAfterGroup: z12.boolean(),
+    resumeFromCheckpoint: z12.boolean()
   }).strict(),
-  limits: z8.object({
-    maximumSpendUsd: z8.number().nonnegative(),
-    maximumWallSeconds: z8.number().int().positive(),
-    maximumArtifactBytes: z8.number().int().positive()
+  estimates: z12.object({ schemaVersion: z12.literal("openpond.trainingEstimate.v1") }).strict().optional(),
+  limits: z12.object({
+    maximumSpendUsd: z12.number().nonnegative(),
+    maximumWallSeconds: z12.number().int().positive(),
+    maximumArtifactBytes: z12.number().int().positive()
   }).strict(),
   checkedAt: TimestampSchema,
   expiresAt: TimestampSchema
@@ -953,6 +1252,7 @@ function createTrainingClient(input) {
   return {
     postTraining: createPostTrainingClient({ request }),
     ...createTrainingPreparationClient(request),
+    ...createTrainingEstimateClient(request),
     ...createTrainingAcceptanceClient(request),
     ...createTrainingHarnessSourceClient(request),
     ...createTrainingCandidateDecisionClient(request),
@@ -961,6 +1261,9 @@ function createTrainingClient(input) {
         unwrapObject(await request("/v1/training/capabilities"), "capabilities")
       );
     },
+    async gpuCatalog() {
+      return TrainingGpuCatalogSchema.parse(unwrapObject(await request("/v1/training/gpu-catalog"), "catalog"));
+    },
     async stageArtifact(upload) {
       const parsed = await parseAndVerifyTrainingInputArtifactUpload(upload);
       return TrainingInputArtifactSchema.parse(
@@ -991,10 +1294,10 @@ function createTrainingClient(input) {
         parameters.set("modelProjectId", IdSchema3.parse(options.modelProjectId));
       }
       if (options.cursor) {
-        parameters.set("cursor", z8.string().trim().min(1).max(2e3).parse(options.cursor));
+        parameters.set("cursor", z12.string().trim().min(1).max(2e3).parse(options.cursor));
       }
       if (options.limit !== void 0) {
-        parameters.set("limit", String(z8.number().int().min(1).max(1e3).parse(options.limit)));
+        parameters.set("limit", String(z12.number().int().min(1).max(1e3).parse(options.limit)));
       }
       const query = parameters.size > 0 ? `?${parameters.toString()}` : "";
       return TrainingJobPageSchema.parse(await request(`/v1/training/jobs${query}`));
@@ -1031,8 +1334,20 @@ function createTrainingClient(input) {
         )
       );
     },
+    async recoverCheckpoint(jobId, input2) {
+      const recovery = TrainingCheckpointRecoveryRequestSchema.parse(input2);
+      if (recovery.resourceApproval) {
+        const { approvalHash, ...body } = recovery.resourceApproval;
+        if (body.sourceJobId !== jobId || await canonicalSha256(body) !== approvalHash)
+          throw new OpenPondProtocolError("content_hash_mismatch", "Recovery resource approval does not bind this source request.");
+      }
+      return TrainingJobSchema.parse(unwrapObject(await request(
+        `/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/recover`,
+        { method: "POST", body: JSON.stringify(recovery) }
+      ), "job"));
+    },
     async events(jobId) {
-      return z8.array(TrainingJobEventSchema).parse(
+      return z12.array(TrainingJobEventSchema).parse(
         unwrapObject(
           await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/events`),
           "events"
@@ -1045,24 +1360,24 @@ function createTrainingClient(input) {
       );
     },
     async evaluationTasks(jobId, evaluation, options = {}) {
-      const id = IdSchema3.parse(jobId);
+      const id2 = IdSchema3.parse(jobId);
       const reference = ModelProjectImmutableRefSchema.parse(evaluation);
       const parameters = new URLSearchParams();
-      const cursor = options.cursor === void 0 ? void 0 : z8.string().regex(/^[1-9]\d*$/).parse(options.cursor);
-      const offset = cursor === void 0 ? 0 : z8.number().int().min(1).max(9999).parse(Number(cursor));
+      const cursor = options.cursor === void 0 ? void 0 : z12.string().regex(/^[1-9]\d*$/).parse(options.cursor);
+      const offset = cursor === void 0 ? 0 : z12.number().int().min(1).max(9999).parse(Number(cursor));
       if (cursor !== void 0) parameters.set("cursor", cursor);
       if (options.limit !== void 0)
-        parameters.set("limit", String(z8.number().int().min(1).max(100).parse(options.limit)));
+        parameters.set("limit", String(z12.number().int().min(1).max(100).parse(options.limit)));
       const query = parameters.size ? `?${parameters.toString()}` : "";
       return parseAndVerifyTrainingEvaluationTaskPage(
         await request(
-          `/v1/training/jobs/${encodeURIComponent(id)}/evaluations/${encodeURIComponent(reference.id)}/tasks${query}`
+          `/v1/training/jobs/${encodeURIComponent(id2)}/evaluations/${encodeURIComponent(reference.id)}/tasks${query}`
         ),
-        { jobId: id, evaluation: reference, offset }
+        { jobId: id2, evaluation: reference, offset }
       );
     },
     async logs(jobId) {
-      return z8.array(TrainingJobLogSchema).max(1e5).parse(
+      return z12.array(TrainingJobLogSchema).max(1e5).parse(
         unwrapObject(
           await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/logs`),
           "logs"
@@ -1101,6 +1416,10 @@ export {
   TrainingAcceptanceGroupSummarySchema,
   TrainingAcceptanceGroupPageSchema,
   TrainingAcceptanceGroupQuerySchema,
+  TrainingCheckpointRecoveryResourceApprovalSchema,
+  createTrainingCheckpointRecoveryResourceApproval,
+  TrainingCheckpointRecoveryRequestSchema,
+  TrainingPhysicalPlacementSchema,
   TrainingPreparationRequestSchema,
   TrainingPreparationPlanContentSchema,
   TrainingPreparationPlanSchema,
@@ -1109,6 +1428,12 @@ export {
   TrainingPreparationListQuerySchema,
   TrainingPreparationPageSchema,
   parseAndVerifyTrainingPreparationReceipt,
+  TrainingEstimateSourceSchema,
+  TrainingEstimateRequestSchema,
+  TrainingEstimateComponentSchema,
+  trainingEstimateSourceIdentity,
+  TrainingEstimateSchema,
+  TrainingQueueStatusSchema,
   TrainingHarnessSourcePublicationSchema,
   TrainingCandidateDecisionRequestSchema,
   TrainingCandidateDecisionSchema,
@@ -1139,6 +1464,7 @@ export {
   TrainingJobSubmissionSchema,
   trainingJobSubmissionHash,
   parseAndVerifyTrainingJobSubmission,
+  TrainingJobRecoverySchema,
   TrainingJobSchema,
   TrainingJobPageSchema,
   TrainingJobEventSchema,
@@ -1153,7 +1479,9 @@ export {
   TrainingJobOutputsSchema,
   TrainingApiErrorSchema,
   OpenPondTrainingApiError,
+  TrainingPolicyLoraCapabilitiesSchema,
+  supportsTrainingPolicyLoraRank,
   TrainingCapabilitiesSchema,
   createTrainingClient
 };
-//# sourceMappingURL=chunk-XACJ63U4.js.map
+//# sourceMappingURL=chunk-Z4XGSEKC.js.map