openpond 0.0.68 → 0.0.69

package/dist/chunks/{src-VUJ6EBOU.js → src-IXYDKOBI.js}

@@ -153,7 +153,7 @@ import {
   workspaceHasHead,
   workspaceToolExperienceBlocker,
   writeWorkspaceFile
-} from "./chunk-IG72OKNB.js";
+} from "./chunk-OOM2PHBE.js";
 import {
   appWorkspacePaths,
   checkWorkspaceGitAvailability,
@@ -179,14 +179,14 @@ import {
   runCommand,
   startMacOSCommandLineToolsInstall,
   workspaceImageContentType
-} from "./chunk-WEB37YVJ.js";
+} from "./chunk-7C4OIFOC.js";
 import {
   runOpenPondServerCli
-} from "./chunk-PSGEH4FC.js";
+} from "./chunk-QTN6HXOR.js";
 import {
   createAppServer,
   runAgentCompaction
-} from "./chunk-OOJP442J.js";
+} from "./chunk-5TKZBMQM.js";
 import {
   APP_PREFERENCES_CACHE_KEY,
   APP_PREFERENCES_CACHE_TYPE,
@@ -198,7 +198,7 @@ import {
   isCliEntrypoint,
   now,
   textFromUnknown
-} from "./chunk-HFQHD35D.js";
+} from "./chunk-NPNIL6SQ.js";
 import {
   createOpenPondRepoApp,
   getBundledRuntimeVersion,
@@ -212,7 +212,7 @@ import {
   streamOpenPondHostedChatTurn,
   switchOpenPondAccount,
   updateOpenPondAccountConfig
-} from "./chunk-TSDVA7QP.js";
+} from "./chunk-FEOLMLYU.js";
 import {
   AccountStateSchema,
   AdapterValidationReceiptSchema,
@@ -279,7 +279,6 @@ import {
   ModelBindingSchema,
   ModelEvaluationReceiptSchema,
   ModelProjectSchema,
-  ModelRunDraftSchema,
   ModelRunSchema,
   ModelUsageRecordSchema,
   ModelVersionSchema,
@@ -374,6 +373,7 @@ import {
   TrainingExecutionStatusSchema,
   TrainingJobEventSchema,
   TrainingJobSchema,
+  TrainingJobSourceSnapshotSchema,
   TrainingPlanSchema,
   TrainingPreparedStartSchema,
   TrainingRecipeSchema,
@@ -453,8 +453,8 @@ import {
   workFormatCapabilityForContentType,
   workspacePathFromLocalPathWorkspaceId,
   writeSourceUploadCache
-} from "./chunk-OQLYO7TA.js";
-import "./chunk-QETF6ILG.js";
+} from "./chunk-MMRJNSWY.js";
+import "./chunk-DLQQIWN2.js";
 import {
   ArtifactManifestSchema,
   AttemptReceiptContentSchema,
@@ -462,15 +462,18 @@ import {
   BenchmarkDefinitionSchema,
   CONNECTED_APP_INTEGRATION_SKILLS,
   ComparisonAssignmentSchema,
+  DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
   EvidenceArtifactRefSchema,
-  MetricObservationSchema,
+  ImmutableAssetRefSchema,
+  ImmutableReleaseRefSchema,
   OPENPOND_MANIFEST_FILE_NAME,
+  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,
+  OpenPondTrainingApiError,
   PreferenceComparisonReleaseSchema,
   PreferenceDatasetReleaseSchema,
   RewardModelQualificationReportSchema,
   RewardReceiptSchema,
   RunManifestSchema,
-  RunTelemetryEventSchema,
   SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME,
   SANDBOX_TEMPLATE_PREVIEW_PORT_MAX,
   SANDBOX_TEMPLATE_PREVIEW_PORT_MIN,
@@ -479,18 +482,22 @@ import {
   WorkFeedbackReasonCodeSchema,
   WorkFeedbackVerdictSchema,
   aggregateEvaluationReceipts,
+  canonicalJson,
   classifyWorkEvidence,
   compareBenchmarkRuns,
+  contentHash,
   createAttemptReceipt,
   createBenchmarkDefinition,
   createBenchmarkRunSummary,
   createComparisonAssignment,
+  createModelProjectsClient,
   createPreferenceCalibrationReport,
   createPreferenceComparisonRelease,
   createPreferenceReceipt,
   createPreferenceRewardComponents,
   createRewardModelQualificationReport,
   createSyntheticFixturePreferenceReceipt,
+  createTrainingClient,
   createWorkEvidenceReceipt,
   createWorkFeedbackReceipt,
   createWorkProcessTrace,
@@ -499,9 +506,14 @@ import {
   harnessRefinerBenchmarkAssets,
   harnessRefinerBenchmarkRelease,
   materializePreferenceDatasetRelease,
+  parseAndVerifyTrainingExecutionReceipt,
   sandboxTemplateBuildPlan,
   sandboxTemplateExecutableEntries,
   sandboxTemplateScaffoldFiles,
+  sha256,
+  trainingExecutionReceiptHash,
+  trainingInputArtifactUploadHash,
+  trainingJobSubmissionHash,
   validateComparisonAssignment,
   validateSandboxTemplateYaml,
   verifyArtifactManifest,
@@ -512,22 +524,14 @@ import {
   workEvidenceReceiptRef,
   workSourceOpaqueRef,
   workWorkspaceOpaqueRef
-} from "./chunk-MUS7KPXK.js";
+} from "./chunk-BLFIIAWZ.js";
 import {
   yaml
 } from "./chunk-X7ZG4TSW.js";
+import "./chunk-JTHL5XJ2.js";
 import {
-  withVercelProtectionBypass
-} from "./chunk-JGOP4GCK.js";
-import {
-  DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
-  ImmutableAssetRefSchema,
-  ImmutableReleaseRefSchema,
-  canonicalJson,
-  contentHash,
-  external_exports,
-  sha256
-} from "./chunk-MLWNI3WG.js";
+  external_exports
+} from "./chunk-FQS2QL5F.js";
 import {
   __commonJS,
   __require,
@@ -13381,7 +13385,7 @@ var require_dist = __commonJS({
 
 // ../server/src/index.ts
 import path64 from "node:path";
-import { randomUUID as randomUUID24 } from "node:crypto";
+import { randomUUID as randomUUID25 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
 
 // ../../packages/codex-provider/dist/client.js
@@ -28223,7 +28227,6 @@ async function handleTrainingRoutes({ deps, request, requestUrl, response }) {
     { method: "POST", path: "/v1/training/taskset-drafts", action: "init_taskset_draft", status: 201 },
     { method: "POST", path: "/v1/training/models/from-taskset", action: "create_model_from_taskset", status: 201 },
     { method: "PUT", path: "/v1/training/models", action: "save_model_project" },
-    { method: "PUT", path: "/v1/training/model-run-drafts", action: "save_model_run_draft" },
     { method: "POST", path: "/v1/training/miner/run", action: "run_miner", status: 202 },
     { method: "PUT", path: "/v1/training/miner/config", action: "configure_miner" },
     { method: "POST", path: "/v1/training/grade", action: "grade" },
@@ -28245,8 +28248,8 @@ async function handleTrainingRoutes({ deps, request, requestUrl, response }) {
     return true;
   }
   const dynamic = [
-    { pattern: /^\/v1\/training\/model-runs\/([^/]+)\/prepare$/, method: "POST", action: "prepare_model_run", key: "modelRunId" },
-    { pattern: /^\/v1\/training\/model-runs\/([^/]+)\/start$/, method: "POST", action: "start_model_run", key: "modelRunId" },
+    { pattern: /^\/v1\/training\/model-projects\/([^/]+)\/training\/prepare$/, method: "POST", action: "prepare_model_run", key: "modelProjectId" },
+    { pattern: /^\/v1\/training\/model-projects\/([^/]+)\/training\/start$/, method: "POST", action: "start_model_run", key: "modelProjectId" },
     { pattern: /^\/v1\/training\/model-runs\/([^/]+)\/status$/, method: "GET", action: "model_run_status", key: "modelRunId" },
     { pattern: /^\/v1\/training\/model-runs\/([^/]+)\/events$/, method: "GET", action: "model_run_events", key: "modelRunId" },
     { pattern: /^\/v1\/training\/model-runs\/([^/]+)\/logs$/, method: "GET", action: "model_run_logs", key: "modelRunId" },
@@ -28285,7 +28288,6 @@ async function handleTrainingRoutes({ deps, request, requestUrl, response }) {
     { pattern: /^\/v1\/training\/models\/([^/]+)\/harness-refiner-benchmark$/, method: "POST", action: "start_harness_refiner_benchmark", key: "modelId" },
     { pattern: /^\/v1\/training\/models\/([^/]+)\/sync$/, method: "POST", action: "sync_model_project", key: "modelId" },
     { pattern: /^\/v1\/training\/models\/([^/]+)\/tasksets\/([^/]+)\/publish$/, method: "POST", action: "publish_model_project_taskset", key: "modelId", assignmentKey: "tasksetId" },
-    { pattern: /^\/v1\/training\/model-run-drafts\/([^/]+)$/, method: "DELETE", action: "delete_model_run_draft", key: "draftId" },
     { pattern: /^\/v1\/training\/dataset-imports\/([^/]+)\/materialize$/, method: "POST", action: "materialize_dataset_import", key: "importId" },
     { pattern: /^\/v1\/training\/dataset-imports\/([^/]+)\/cancel$/, method: "POST", action: "cancel_dataset_import", key: "importId" },
     { pattern: /^\/v1\/training\/sources\/([^/]+)$/, method: "DELETE", action: "remove_source", key: "sourceId" },
@@ -39707,7 +39709,8 @@ import { randomUUID as randomUUID16 } from "node:crypto";
 import { access, lstat, mkdir as mkdir5, readFile as readFile7, readdir as readdir2, rename, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import path40 from "node:path";
 function buildTasksetTrainingBundle(input) {
-  const { taskset, modelRun, harnessRelease, tasksetRelease } = input;
+  const { taskset, modelProject, harnessRelease, tasksetRelease } = input;
+  const setup = modelProject.trainingSetup;
   const releasedHarness2 = ImmutableReleaseRefSchema2.parse(harnessRelease);
   const releasedTaskset = ImmutableReleaseRefSchema2.parse(tasksetRelease);
   void input.openpondRelease;
@@ -39716,7 +39719,7 @@ function buildTasksetTrainingBundle(input) {
   if (actualTasksetHash !== taskset.contentHash) {
     throw new Error("Taskset authoring state changed after its release was selected.");
   }
-  if (!modelRun.baseModel?.revision || !modelRun.baseModel.tokenizerRevision || !modelRun.baseModel.chatTemplateHash || !modelRun.recipe || !modelRun.tasksetRef || modelRun.tasksetRef.id !== taskset.id || modelRun.tasksetRef.contentHash !== taskset.contentHash) {
+  if (!setup.baseModel?.revision || !setup.baseModel.tokenizerRevision || !setup.baseModel.chatTemplateHash || !setup.recipe || !setup.tasksetRef || setup.tasksetRef.id !== taskset.id || setup.tasksetRef.contentHash !== taskset.contentHash) {
     throw new Error("Model Run must bind an exact Taskset, Model revision, tokenizer, chat template, and Recipe.");
   }
   const profileRelease = taskset.profileRelease ?? {
@@ -39802,21 +39805,21 @@ function buildTasksetTrainingBundle(input) {
   });
   const manifestContent = HarnessRunManifestContentSchema.parse({
     schemaVersion: "openpond.harnessRunManifest.v1",
-    id: `manifest_${modelRun.id}_${input.approval.approvalHash.slice(0, 16)}`,
+    id: `manifest_${input.modelRunId}_${input.approval.approvalHash.slice(0, 16)}`,
     harnessRelease,
     datasetRelease,
     evidenceSets: evidenceSetRelease ? [evidenceSetRelease] : [],
     model: {
-      source: modelRun.baseModel.modelId,
-      revision: modelRun.baseModel.revision,
+      source: setup.baseModel.modelId,
+      revision: setup.baseModel.revision,
       artifactHash: null,
-      tokenizerRevision: modelRun.baseModel.tokenizerRevision,
-      chatTemplateHash: modelRun.baseModel.chatTemplateHash
+      tokenizerRevision: setup.baseModel.tokenizerRevision,
+      chatTemplateHash: setup.baseModel.chatTemplateHash
     },
     recipe: {
-      method: modelRun.recipe.method,
+      method: setup.recipe.method,
       version: "openpond.trainingRecipe.v1",
-      configHash: contentHash(modelRun.recipe)
+      configHash: contentHash(setup.recipe)
     },
     runtimeTarget: input.runtime,
     computeTarget: input.compute,
@@ -39824,7 +39827,7 @@ function buildTasksetTrainingBundle(input) {
     resolvedBundleHash: resolvedBundleManifest.contentHash,
     secretLeaseRefs: input.secretLeaseRefs ?? [],
     approval: input.approval,
-    createdAt: modelRun.updatedAt
+    createdAt: modelProject.updatedAt
   });
   const manifest = HarnessRunManifestSchema.parse({
     ...manifestContent,
@@ -41411,7 +41414,7 @@ var ManagedRlLocalRolloutExecutor = class {
     const requestUrl = `${this.input.access.apiBaseUrl}${path65}`;
     return requestJson(this.input.fetchImpl ?? fetch, requestUrl, {
       ...init,
-      headers: withVercelProtectionBypass(requestUrl, headers, this.input.env),
+      headers,
       signal: this.abortController.signal
     });
   }
@@ -41427,7 +41430,7 @@ var ManagedRlLocalRolloutExecutor = class {
       requestUrl,
       {
         method: "POST",
-        headers: withVercelProtectionBypass(requestUrl, headers, this.input.env),
+        headers,
         body: JSON.stringify(request),
         signal
       }
@@ -41468,547 +41471,117 @@ function delay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
-// ../server/src/training/openpond-managed-run-evidence.ts
-var OptionalTimestampSchema = external_exports.string().trim().min(1).nullable().optional();
-var OptionalMoneySchema = external_exports.string().trim().min(1).nullable().optional();
-var ManagedJobDetailSchema = external_exports.object({
-  job: external_exports.object({
-    id: external_exports.string().trim().min(1),
-    state: external_exports.string().trim().min(1),
-    targetGroups: external_exports.number().int().nonnegative().default(0),
-    completedGroups: external_exports.number().int().nonnegative().default(0),
-    currentPolicyVersion: external_exports.number().int().nonnegative().default(0),
-    accruedSpendUsd: OptionalMoneySchema,
-    canonicalPublishState: external_exports.string().trim().min(1).nullable().optional(),
-    canonicalAdapterArtifactId: external_exports.string().trim().min(1).nullable().optional(),
-    version: external_exports.number().int().positive().default(1),
-    terminalReason: external_exports.string().trim().min(1).nullable().optional(),
-    createdAt: external_exports.string().trim().min(1),
-    updatedAt: external_exports.string().trim().min(1),
-    completedAt: OptionalTimestampSchema,
-    inputBundle: external_exports.object({
-      harnessRelease: external_exports.object({ contentHash: external_exports.string().trim().min(1) }).optional(),
-      harnessRunManifest: external_exports.object({
-        harnessRelease: external_exports.object({ contentHash: external_exports.string().trim().min(1) }).optional(),
-        runtimeTarget: external_exports.object({
-          placement: external_exports.string().trim().min(1).optional()
-        }).optional()
-      }).optional()
-    }).optional()
-  }),
-  gpuLeases: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      provider: external_exports.string().trim().min(1).default("openpond"),
-      state: external_exports.string().trim().min(1),
-      gpuType: external_exports.string().trim().min(1).nullable().optional(),
-      gpuCount: external_exports.number().int().nonnegative().nullable().optional(),
-      quotedHourlyUsd: OptionalMoneySchema,
-      observedHourlyUsd: OptionalMoneySchema,
-      readyAt: OptionalTimestampSchema,
-      terminatedAt: OptionalTimestampSchema
-    })
-  ).default([]),
-  rolloutGroups: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      groupIndex: external_exports.number().int().nonnegative(),
-      policyVersion: external_exports.number().int().nonnegative(),
-      state: external_exports.string().trim().min(1),
-      eligibleTrajectoryCount: external_exports.number().int().nonnegative().default(0),
-      rewardMean: OptionalMoneySchema,
-      startedAt: OptionalTimestampSchema,
-      completedAt: OptionalTimestampSchema
-    })
-  ).default([]),
-  rollouts: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      groupId: external_exports.string().trim().min(1),
-      workerSlot: external_exports.number().int().nonnegative(),
-      attempt: external_exports.number().int().positive().default(1),
-      state: external_exports.string().trim().min(1),
-      startedAt: OptionalTimestampSchema,
-      completedAt: OptionalTimestampSchema
-    })
-  ).default([]),
-  trajectories: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      groupId: external_exports.string().trim().min(1),
-      rolloutId: external_exports.string().trim().min(1),
-      policyVersion: external_exports.number().int().nonnegative(),
-      rewardEligible: external_exports.boolean(),
-      reward: OptionalMoneySchema,
-      terminalClass: external_exports.string().trim().min(1).nullable().optional(),
-      rewardComponents: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
-      promptTokenCount: external_exports.number().int().nonnegative().nullable().optional(),
-      outputTokenCount: external_exports.number().int().nonnegative().nullable().optional(),
-      consumedTrainingStepId: external_exports.string().trim().min(1).nullable().optional(),
-      createdAt: external_exports.string().trim().min(1),
-      updatedAt: external_exports.string().trim().min(1)
-    })
-  ).default([]),
-  trainingSteps: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      groupId: external_exports.string().trim().min(1),
-      stepIndex: external_exports.number().int().positive(),
-      inputPolicyVersion: external_exports.number().int().nonnegative(),
-      outputPolicyVersion: external_exports.number().int().nonnegative(),
-      state: external_exports.string().trim().min(1),
-      metrics: external_exports.record(
-        external_exports.string(),
-        external_exports.union([external_exports.number(), external_exports.string(), external_exports.boolean(), external_exports.null()])
-      ).default({}),
-      startedAt: OptionalTimestampSchema,
-      committedAt: OptionalTimestampSchema
-    })
-  ).default([]),
-  checkpoints: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      policyVersion: external_exports.number().int().nonnegative(),
-      state: external_exports.string().trim().min(1),
-      adapterSha256: external_exports.string().trim().min(8).nullable().optional(),
-      sizeBytes: external_exports.number().int().nonnegative().nullable().optional(),
-      isLatest: external_exports.boolean().default(false),
-      isFinal: external_exports.boolean().default(false),
-      readyAt: OptionalTimestampSchema,
-      updatedAt: external_exports.string().trim().min(1)
-    })
-  ).default([]),
-  evaluations: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      kind: external_exports.enum(["baseline", "candidate"]),
-      policyVersion: external_exports.number().int().nonnegative(),
-      state: external_exports.string().trim().min(1),
-      score: OptionalMoneySchema,
-      threshold: OptionalMoneySchema,
-      passed: external_exports.boolean().nullable().optional(),
-      createdAt: external_exports.string().trim().min(1)
-    })
-  ).default([]),
-  telemetry: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      itemId: external_exports.string().trim().min(1),
-      sequence: external_exports.number().int().nonnegative(),
-      kind: external_exports.enum(["event", "observation"]),
-      event: RunTelemetryEventSchema.nullable().optional(),
-      observation: MetricObservationSchema.nullable().optional()
-    })
-  ).default([]),
-  commands: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      commandType: external_exports.string().trim().min(1),
-      state: external_exports.string().trim().min(1),
-      errorCode: external_exports.string().trim().min(1).nullable().optional(),
-      createdAt: external_exports.string().trim().min(1),
-      updatedAt: external_exports.string().trim().min(1),
-      completedAt: OptionalTimestampSchema
-    })
-  ).default([]),
-  outbox: external_exports.array(
-    external_exports.object({
-      id: external_exports.string().trim().min(1),
-      commandType: external_exports.string().trim().min(1),
-      state: external_exports.string().trim().min(1),
-      attemptCount: external_exports.number().int().nonnegative().default(0),
-      lastErrorCode: external_exports.string().trim().min(1).nullable().optional(),
-      createdAt: external_exports.string().trim().min(1),
-      updatedAt: external_exports.string().trim().min(1),
-      completedAt: OptionalTimestampSchema
-    })
-  ).default([])
-});
-function parseManagedJobDetail(value) {
-  return ManagedJobDetailSchema.parse(value);
-}
-async function persistManagedRunEvidence(input) {
-  const job = await input.store.getTrainingJob(input.ref.runId);
-  if (!job) return null;
-  const plan = await input.store.getTrainingPlan(job.planId);
-  const learningRate = plan?.recipe.method === "grpo" ? plan.recipe.optimizer.learningRate : null;
-  const evidence = managedRunEvidence(input.detail, input.now?.() ?? /* @__PURE__ */ new Date());
-  const existingEvents = await input.store.listTrainingJobEvents(job.id);
-  const events = managedTrainingEvents({
-    detail: input.detail,
-    jobId: job.id,
-    learningRate,
-    existingEvents
-  });
-  for (const event2 of events) {
-    await input.store.saveTrainingJobEvent(event2);
-  }
-  await input.store.saveTrainingJob({
-    ...job,
-    metadata: {
-      ...job.metadata,
-      managedTrainingEvidence: evidence,
-      optimizerUpdatesObserved: evidence.progress.committedOptimizerSteps,
-      trainingMethod: plan?.recipe.method === "grpo" ? "grpo" : job.metadata.trainingMethod
-    }
-  });
-  return evidence;
-}
-function managedRunEvidence(detail, syncedAt) {
-  const eligible = detail.trajectories.filter(
-    (trajectory) => trajectory.rewardEligible
-  );
-  const committedSteps = detail.trainingSteps.filter(
-    (step) => step.state === "committed"
+// ../server/src/training/openpond-managed-training-adapter-projection.ts
+async function managedQualification(input) {
+  if (!input.qualificationRef) return null;
+  const lineage = input.taskset.metadata.harnessEvaluationLineage;
+  if (!lineage || typeof lineage !== "object" || Array.isArray(lineage)) return null;
+  const review = lineage.review;
+  if (!review || typeof review !== "object" || Array.isArray(review)) return null;
+  const workspaceId = review.workspaceId;
+  if (typeof workspaceId !== "string" || !workspaceId) return null;
+  const receipts = await input.store.listHarnessImprovementArtifacts(
+    workspaceId,
+    "training_qualification",
+    1e3
   );
-  const finalGroup = [...detail.rolloutGroups].filter((group) => group.rewardMean != null).sort((left, right) => left.groupIndex - right.groupIndex).at(-1);
-  const lease = [...detail.gpuLeases].sort((left, right) => left.id.localeCompare(right.id)).at(-1);
-  const checkpoint2 = [...detail.checkpoints].filter((candidate2) => candidate2.state === "ready").sort(
-    (left, right) => Number(right.isFinal) - Number(left.isFinal) || Number(right.isLatest) - Number(left.isLatest) || right.policyVersion - left.policyVersion
-  ).at(0);
-  return ManagedTrainingRunEvidenceSchema.parse({
-    schemaVersion: "openpond.managedTrainingRunEvidence.v1",
-    provider: "openpond",
-    providerRunId: detail.job.id,
-    state: detail.job.state,
-    progress: {
-      targetOptimizerSteps: detail.job.targetGroups,
-      committedOptimizerSteps: committedSteps.length
-    },
-    reward: {
-      finalMean: decimal(finalGroup?.rewardMean),
-      trajectoryCount: detail.trajectories.length,
-      eligibleTrajectoryCount: eligible.length
-    },
-    usage: {
-      inputTokens: sumNullableIntegers(
-        eligible.map((trajectory) => trajectory.promptTokenCount)
-      ),
-      outputTokens: sumNullableIntegers(
-        eligible.map((trajectory) => trajectory.outputTokenCount)
-      ),
-      environmentExecutions: detail.rollouts.length
-    },
-    resource: {
-      provider: "openpond",
-      gpuType: lease?.gpuType ?? null,
-      gpuCount: lease?.gpuCount ?? null,
-      hourlyCostUsd: decimal(
-        lease?.observedHourlyUsd ?? lease?.quotedHourlyUsd
-      )
-    },
-    cost: {
-      totalUsd: decimal(detail.job.accruedSpendUsd)
-    },
-    checkpoint: checkpoint2 ? {
-      id: checkpoint2.id,
-      policyVersion: checkpoint2.policyVersion,
-      sha256: checkpoint2.adapterSha256 ?? null,
-      sizeBytes: checkpoint2.sizeBytes ?? null
-    } : null,
-    evaluations: detail.evaluations.map((evaluation) => ({
-      kind: evaluation.kind,
-      policyVersion: evaluation.policyVersion,
-      score: decimal(evaluation.score),
-      threshold: decimal(evaluation.threshold),
-      passed: evaluation.passed ?? null
-    })),
-    canonicalPublication: {
-      state: detail.job.canonicalPublishState ?? null,
-      artifactId: detail.job.canonicalAdapterArtifactId ?? null
+  return receipts.find(
+    (receipt) => receipt.id === input.qualificationRef.id && receipt.contentHash === input.qualificationRef.contentHash
+  ) ?? null;
+}
+function dateString(value) {
+  return new Date(value).toISOString();
+}
+function toExecutionStatus(job) {
+  const preparing = /* @__PURE__ */ new Set(["queued", "admitting", "provisioning"]);
+  const state = job.state === "succeeded" ? "succeeded" : job.state === "cancelled" ? "cancelled" : job.state === "failed" ? "failed" : job.state === "cancelling" ? "cancelling" : preparing.has(job.state) ? "preparing" : "running";
+  return {
+    runId: job.id,
+    state,
+    phase: job.state,
+    progress: job.progress,
+    updatedAt: dateString(job.updatedAt),
+    errorCode: state === "failed" ? (job.terminalReason?.trim() || "managed_training_failed").replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 191) : null
+  };
+}
+function learnedRewardSource(binding) {
+  return {
+    kind: "learned_reward",
+    rewardModelVersion: binding.rewardModelVersion,
+    qualificationReport: binding.qualificationReport,
+    scorerArtifact: {
+      artifactRef: binding.checkpoint.objectRef,
+      contentHash: binding.checkpoint.contentHash,
+      executionReceipt: binding.executionReceipt
     },
-    syncedAt: syncedAt.toISOString()
-  });
+    processorRelease: binding.processorRelease,
+    rewardComposerRelease: binding.rewardComposerRelease
+  };
 }
-function managedTrainingEvents(input) {
-  const candidates = [];
-  const startedAt = input.detail.gpuLeases.flatMap((lease) => lease.readyAt ? [lease.readyAt] : []).sort().at(0) ?? input.detail.job.createdAt;
-  candidates.push({
-    identity: "start",
-    timestamp: startedAt,
-    type: "start",
-    payload: {
-      device: input.detail.gpuLeases.find((lease) => lease.gpuType)?.gpuType ?? "OpenPond Managed",
-      provider: input.detail.gpuLeases.find((lease) => lease.provider)?.provider ?? "openpond"
-    }
-  });
-  for (const lease of input.detail.gpuLeases) {
-    candidates.push({
-      identity: `gpu-lease:${lease.id}`,
-      timestamp: lease.terminatedAt ?? lease.readyAt ?? input.detail.job.updatedAt,
-      type: lease.state === "failed" ? "failure" : "progress",
-      payload: {
-        telemetryType: "gpu_worker_state",
-        telemetrySource: "control_plane",
-        message: `${providerLabel(lease.provider)} GPU worker ${humanLabel(lease.state)}`,
-        provider: lease.provider,
-        state: lease.state,
-        gpuType: lease.gpuType ?? null
-      }
-    });
-  }
-  const rolloutById = new Map(
-    input.detail.rollouts.map((rollout) => [rollout.id, rollout])
-  );
-  const orderedTrajectories = [...input.detail.trajectories].sort(
-    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.rolloutId.localeCompare(right.rolloutId)
-  );
-  orderedTrajectories.forEach((trajectory, index) => {
-    const rollout = rolloutById.get(trajectory.rolloutId);
-    candidates.push({
-      identity: `rollout:${trajectory.id}`,
-      timestamp: rollout?.completedAt ?? trajectory.updatedAt,
-      type: "metric",
-      payload: {
-        metricKind: "rollout_trajectory",
-        rolloutIndex: index + 1,
-        rolloutId: trajectory.rolloutId,
-        rolloutGroupId: trajectory.groupId,
-        policyVersion: trajectory.policyVersion,
-        workerSlot: rollout?.workerSlot ?? null,
-        reward: decimal(trajectory.reward),
-        rewardEligible: trajectory.rewardEligible,
-        rewardComponents: trajectory.rewardComponents,
-        failureClass: trajectory.rewardEligible ? null : trajectory.terminalClass ?? "not_reward_eligible",
-        failureCode: trajectory.rewardEligible ? null : failureCode(trajectory.rewardComponents),
-        inputTokens: trajectory.promptTokenCount ?? 0,
-        outputTokens: trajectory.outputTokenCount ?? 0
-      }
-    });
-  });
-  for (const group of input.detail.rolloutGroups) {
-    candidates.push({
-      identity: `group:${group.id}`,
-      timestamp: group.completedAt ?? group.startedAt ?? input.detail.job.updatedAt,
-      type: group.state === "failed" ? "failure" : "progress",
-      payload: {
-        telemetryType: "rollout_group_state",
-        telemetrySource: "control_plane",
-        message: `Rollout group ${group.groupIndex + 1} ${humanLabel(group.state)}`,
-        groupIndex: group.groupIndex,
-        policyVersion: group.policyVersion,
-        eligibleAttempts: group.eligibleTrajectoryCount,
-        rewardMean: decimal(group.rewardMean)
-      }
-    });
-  }
-  for (const command of input.detail.outbox) {
-    candidates.push({
-      identity: `control-command:${command.id}`,
-      timestamp: command.updatedAt,
-      type: command.lastErrorCode ? "failure" : "progress",
-      payload: {
-        telemetryType: "control_plane_command",
-        telemetrySource: "control_plane",
-        message: `${humanLabel(command.commandType)} ${humanLabel(command.state)}`,
-        commandType: command.commandType,
-        state: command.state,
-        attempts: command.attemptCount,
-        errorCode: command.lastErrorCode ?? null
-      }
-    });
-  }
-  for (const command of input.detail.commands) {
-    candidates.push({
-      identity: `worker-command:${command.id}`,
-      timestamp: command.updatedAt,
-      type: command.errorCode ? "failure" : "progress",
-      payload: {
-        telemetryType: "worker_command",
-        telemetrySource: "runtime",
-        message: `${humanLabel(command.commandType)} ${humanLabel(command.state)}`,
-        commandType: command.commandType,
-        state: command.state,
-        errorCode: command.errorCode ?? null
-      }
-    });
-  }
-  const trajectoryByStep = /* @__PURE__ */ new Map();
-  for (const trajectory of input.detail.trajectories) {
-    if (!trajectory.consumedTrainingStepId) continue;
-    const current = trajectoryByStep.get(trajectory.consumedTrainingStepId);
-    if (current) current.push(trajectory);
-    else trajectoryByStep.set(trajectory.consumedTrainingStepId, [trajectory]);
-  }
-  const groupById = new Map(
-    input.detail.rolloutGroups.map((group) => [group.id, group])
-  );
-  const telemetryMetricsByStep = /* @__PURE__ */ new Map();
-  for (const item of input.detail.telemetry) {
-    if (item.kind !== "observation" || !item.observation) continue;
-    const step = item.observation.lineage.step;
-    if (step == null) continue;
-    const current = telemetryMetricsByStep.get(step) ?? {};
-    current[item.observation.metricId] = item.observation.value;
-    telemetryMetricsByStep.set(step, current);
-  }
-  for (const step of input.detail.trainingSteps.filter(
-    (candidate2) => candidate2.state === "committed"
-  )) {
-    const trajectories = trajectoryByStep.get(step.id) ?? [];
-    const group = groupById.get(step.groupId);
-    const telemetry = telemetryMetricsByStep.get(step.stepIndex) ?? {};
-    candidates.push({
-      identity: `optimizer:${step.id}`,
-      timestamp: step.committedAt ?? step.startedAt ?? input.detail.job.updatedAt,
-      type: "metric",
-      payload: {
-        schemaVersion: "openpond.policyOptimizationMetric.v1",
-        metricKind: "policy_optimization",
-        method: "grpo",
-        step: step.stepIndex,
-        timestamp: step.committedAt ?? step.startedAt ?? input.detail.job.updatedAt,
-        learningRate: input.learningRate,
-        policyLoss: metricNumber(step.metrics, "policyLoss") ?? metricNumber(telemetry, "optimizer.loss"),
-        valueLoss: metricNumber(step.metrics, "valueLoss"),
-        meanReward: metricNumber(step.metrics, "rewardMean") ?? decimal(group?.rewardMean),
-        meanReturn: metricNumber(step.metrics, "meanReturn"),
-        kl: metricNumber(step.metrics, "kl") ?? metricNumber(telemetry, "optimizer.kl"),
-        entropy: metricNumber(step.metrics, "entropy") ?? metricNumber(telemetry, "optimizer.entropy"),
-        policyClipFraction: metricNumber(
-          step.metrics,
-          "policyClipFraction"
-        ) ?? metricNumber(telemetry, "optimizer.clip_fraction"),
-        valueClipFraction: metricNumber(step.metrics, "valueClipFraction"),
-        explainedVariance: metricNumber(step.metrics, "explainedVariance"),
-        rolloutLearnerLag: 0,
-        inputTokens: sumNullableIntegers(
-          trajectories.map((trajectory) => trajectory.promptTokenCount)
-        ),
-        outputTokens: sumNullableIntegers(
-          trajectories.map((trajectory) => trajectory.outputTokenCount)
-        ),
-        environmentExecutions: trajectories.length,
-        costUsd: null,
-        inputPolicyVersion: step.inputPolicyVersion,
-        outputPolicyVersion: step.outputPolicyVersion
-      }
-    });
-  }
-  for (const item of input.detail.telemetry) {
-    if (item.kind === "event" && item.event) {
-      candidates.push({
-        identity: `telemetry-event:${item.itemId}`,
-        timestamp: item.event.occurredAt,
-        type: item.event.type === "run_failed" ? "failure" : item.event.type === "checkpoint_committed" ? "checkpoint" : item.event.type === "run_completed" ? "complete" : item.event.type === "run_started" ? "start" : "progress",
-        payload: {
-          telemetryType: item.event.type,
-          telemetrySource: item.event.source ?? "managed",
-          step: item.event.lineage.step ?? null,
-          ...item.event.attributes
-        }
-      });
-      continue;
-    }
-    if (item.kind === "observation" && item.observation) {
-      candidates.push({
-        identity: `telemetry-observation:${item.itemId}`,
-        timestamp: item.observation.observedAt,
-        type: "metric",
-        payload: {
-          metricKind: "managed_telemetry",
-          metricId: item.observation.metricId,
-          value: item.observation.value,
-          step: item.observation.lineage.step ?? null
-        }
-      });
-    }
-  }
-  for (const checkpoint2 of input.detail.checkpoints.filter(
-    (candidate2) => candidate2.state === "ready"
-  )) {
-    candidates.push({
-      identity: `checkpoint:${checkpoint2.id}`,
-      timestamp: checkpoint2.readyAt ?? checkpoint2.updatedAt,
-      type: "checkpoint",
-      payload: {
-        checkpointId: checkpoint2.id,
-        policyVersion: checkpoint2.policyVersion,
-        sha256: checkpoint2.adapterSha256 ?? null,
-        sizeBytes: checkpoint2.sizeBytes ?? null,
-        final: checkpoint2.isFinal
-      }
-    });
-  }
-  if (["completed", "cancelled", "budget_exhausted", "failed"].includes(
-    input.detail.job.state
-  )) {
-    candidates.push({
-      identity: "complete",
-      timestamp: input.detail.job.completedAt ?? input.detail.job.updatedAt,
-      type: input.detail.job.state === "completed" ? "complete" : input.detail.job.state === "cancelled" ? "cancel" : "failure",
-      payload: {
-        state: input.detail.job.state,
-        artifactCount: input.detail.checkpoints.filter(
-          (checkpoint2) => checkpoint2.state === "ready"
-        ).length,
-        optimizerUpdates: input.detail.trainingSteps.filter(
-          (step) => step.state === "committed"
-        ).length
-      }
-    });
-  }
-  const existingById = new Map(
-    input.existingEvents.map((event2) => [event2.id, event2])
-  );
-  let nextSequence = Math.max(-1, ...input.existingEvents.map((event2) => event2.sequence)) + 1;
-  return candidates.sort(
-    (left, right) => left.timestamp.localeCompare(right.timestamp) || left.identity.localeCompare(right.identity)
-  ).map((candidate2) => {
-    const id = managedEventId(input.jobId, candidate2.identity);
-    const existing = existingById.get(id);
-    return TrainingJobEventSchema.parse({
-      schemaVersion: "openpond.trainingJobEvent.v1",
-      id,
-      jobId: input.jobId,
-      sequence: existing?.sequence ?? nextSequence++,
-      type: candidate2.type,
-      timestamp: candidate2.timestamp,
-      payload: candidate2.payload
-    });
-  });
+function recordOrEmpty(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function managedEventId(jobId, identity) {
-  return `managed_event_${contentHash({ jobId, identity }).slice(0, 32)}`;
+function managedJobFromPublic(job) {
+  const state = job.state === "succeeded" ? "completed" : job.state === "queued" || job.state === "admitting" ? "admitted" : job.state === "provisioning" ? "provisioning_gpu" : job.state === "stopping" ? "stop_after_group" : job.state;
+  return {
+    id: job.id,
+    state,
+    version: job.version,
+    terminalReason: job.terminalReason,
+    createdAt: job.createdAt,
+    updatedAt: job.updatedAt
+  };
 }
-function humanLabel(value) {
-  return value.replaceAll("_", " ");
+function requiredRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} is invalid.`);
+  }
+  return value;
 }
-function providerLabel(value) {
-  if (value.toLowerCase().includes("runpod")) return "RunPod";
-  if (value.toLowerCase().includes("prime")) return "Prime Intellect";
+function requiredStringValue(value, label) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${label} is invalid.`);
   return value;
 }
-function metricNumber(values, key) {
-  const value = values[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
+function requiredHash(value, label) {
+  const parsed = requiredStringValue(value, label);
+  if (!/^[a-f0-9]{64}$/.test(parsed)) throw new Error(`${label} is invalid.`);
+  return parsed;
 }
-function decimal(value) {
-  if (value == null) return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+function requiredFiniteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} is invalid.`);
+  }
+  return value;
 }
-function failureCode(components) {
-  const value = components.failureCode;
-  return typeof value === "string" && value.trim().length ? value.slice(0, 191) : null;
+function requiredPositiveInteger(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(`${label} is invalid.`);
+  }
+  return value;
 }
-function sumNullableIntegers(values) {
-  return values.reduce((sum, value) => sum + (value ?? 0), 0);
+function requiredRef(value, label) {
+  const record12 = requiredRecord(value, label);
+  return {
+    id: requiredStringValue(record12.id, `${label} id`),
+    contentHash: requiredHash(record12.contentHash, `${label} hash`)
+  };
+}
+
+// ../server/src/training/openpond-managed-training-adapter-support.ts
+function localTrainingEventType(event2) {
+  if (typeof event2.data.metricKind === "string") return "metric";
+  if (event2.type.includes("checkpoint")) return "checkpoint";
+  if (event2.type === "provision_gpu" || event2.type === "start_inference") return "start";
+  if (event2.type === "cancel" || event2.type === "stop") return "cancel";
+  if (event2.type === "complete") return "complete";
+  if (event2.type === "failure") return "failure";
+  return "progress";
 }
 
 // ../server/src/training/openpond-managed-training-adapter.ts
 var ADAPTER_ID = "sandbox-managed-rl";
-var QUALIFIED_MODEL = {
-  source: "Qwen/Qwen3-0.6B",
-  revision: "c1899de289a04d12100db370d81485cdf75e47ca",
-  chatTemplateHash: "a55ee1b1660128b7098723e0abcd92caa0788061051c62d51cbe87d9cf1974d8"
-};
-var QUALIFIED_RECIPE = {
-  loraRank: 16,
-  rolloutGroupSize: 4,
-  rolloutConcurrency: 4,
-  maxPromptTokens: 4096
-};
+var REMOTE_TRAINING_EVENT_SEQUENCE_BASE = 1e6;
+var ACTIVE_EVIDENCE_REFRESH_TTL_MS = 1500;
 var OpenPondManagedTrainingAdapter = class {
   constructor(dependencies) {
     this.dependencies = dependencies;
@@ -42022,6 +41595,8 @@ var OpenPondManagedTrainingAdapter = class {
   resolveAccess;
   readFileImpl;
   localExecutors = /* @__PURE__ */ new Map();
+  evidenceRefreshes = /* @__PURE__ */ new Map();
+  evidenceRefreshedAt = /* @__PURE__ */ new Map();
   async createCalibrationBatch(request) {
     return this.requestJson(
       "/v1/managed-rl/calibration-batches",
@@ -42036,70 +41611,172 @@ var OpenPondManagedTrainingAdapter = class {
       await this.resolveBoundAccess()
     );
   }
-  /** Uploads an immutable rendered artifact for a managed Reward Model run. */
-  async uploadRewardModelArtifact(input) {
-    const bytes2 = Buffer.from(input.bytes);
-    return this.requestJson(
-      "/v1/managed-rl/reward-model-artifacts",
-      {
-        method: "POST",
-        body: JSON.stringify({
-          contentBase64: bytes2.toString("base64"),
-          expectedSha256: sha256(bytes2),
-          idempotencyKey: input.idempotencyKey,
-          mediaType: input.mediaType
-        })
-      },
-      await this.resolveBoundAccess()
+  async createRewardModelLaunch(input) {
+    const request = requiredRecord(input.request, "Reward Model launch request");
+    const requestHash = requiredHash(request.requestHash, "Reward Model request hash");
+    const rewardModelTraining = requiredRecord(
+      request.rewardModelTraining,
+      "Reward Model training payload"
     );
-  }
-  async createRewardModelLaunch(request) {
-    return this.requestJson(
-      "/v1/managed-rl/reward-model-launches",
-      { method: "POST", body: JSON.stringify(request) },
-      await this.resolveBoundAccess()
+    const taskset = requiredRecord(request.taskset, "Reward Model Taskset");
+    const preferenceDataset = requiredRef(
+      request.preferenceDatasetRelease,
+      "Reward Model preference dataset"
     );
+    const base = requiredRecord(rewardModelTraining.baseModel, "Reward Model base Model");
+    const projectValue = await this.dependencies.store.getModelProject(input.modelProjectId);
+    if (!projectValue) throw new Error("Reward Model Model Project was not found.");
+    const access5 = await this.resolveBoundAccess();
+    const project = await this.syncProjectForSubmission(projectValue, access5);
+    if (!project.hosted || !project.trainingSetup.harnessRelease) {
+      throw new Error("Reward Model training requires a synchronized Project Harness release.");
+    }
+    const tasksetRelease = project.trainingSetup.tasksetRelease;
+    if (!tasksetRelease || tasksetRelease.id !== requiredStringValue(taskset.id, "Reward Model Taskset id") || tasksetRelease.contentHash !== requiredHash(taskset.contentHash, "Reward Model Taskset hash")) {
+      throw new Error("Reward Model training does not match the Model Project Taskset release.");
+    }
+    const client = this.trainingClient(access5);
+    const artifactContent = {
+      schemaVersion: "openpond.trainingInputArtifactUpload.v2",
+      kind: "reward_model_dataset",
+      idempotencyKey: `stage:${requestHash}`,
+      sourceManifest: {
+        id: requiredStringValue(request.sourceRunRef, "Reward Model source Run"),
+        contentHash: requestHash
+      },
+      payload: rewardModelTraining
+    };
+    const staged = await client.stageArtifact({
+      ...artifactContent,
+      contentHash: await trainingInputArtifactUploadHash(artifactContent)
+    });
+    const maximumSpendUsd = requiredFiniteNumber(
+      request.maximumSpendUsd,
+      "Reward Model maximum spend"
+    );
+    const approvalHash = contentHash({
+      sourceRunRef: request.sourceRunRef,
+      requestHash,
+      maximumSpendUsd,
+      approvedAt: input.approvedAt
+    });
+    const jobContent = {
+      schemaVersion: "openpond.trainingJobSubmission.v2",
+      idempotencyKey: requiredStringValue(request.idempotencyKey, "Reward Model idempotency key"),
+      name: requiredStringValue(request.name, "Reward Model name").slice(0, 200),
+      source: {
+        modelProject: {
+          id: project.hosted.projectId,
+          portableProjectId: project.id,
+          revision: project.revision,
+          contentHash: project.hosted.etag
+        },
+        harnessRunManifest: artifactContent.sourceManifest,
+        harnessRelease: project.trainingSetup.harnessRelease,
+        taskset: {
+          id: tasksetRelease.id,
+          revision: requiredPositiveInteger(taskset.revision, "Reward Model Taskset revision"),
+          contentHash: tasksetRelease.contentHash
+        },
+        tasksetRelease,
+        dataset: { id: staged.artifactRef, contentHash: staged.contentHash },
+        evidenceSets: [preferenceDataset]
+      },
+      job: {
+        kind: "reward_model_train",
+        baseModel: {
+          schemaVersion: "openpond.baseModelPreference.v1",
+          modelId: requiredStringValue(base.repoId, "Reward Model repository"),
+          revision: requiredStringValue(base.revision, "Reward Model revision"),
+          tokenizerRevision: requiredStringValue(base.revision, "Reward Model tokenizer revision"),
+          chatTemplateHash: requiredHash(base.tokenizerHash, "Reward Model tokenizer hash"),
+          modelAssetId: null,
+          source: "managed"
+        },
+        preferenceDatasetRelease: preferenceDataset,
+        processorRelease: input.processorRelease,
+        recipe: input.recipe
+      },
+      requestedCapabilities: [
+        { id: "managed_rl.reward_model", version: "1", required: true }
+      ],
+      budget: {
+        maximumSpendUsd,
+        maximumWallSeconds: Math.ceil(input.recipe.resourceLimits.wallTimeMs / 1e3)
+      },
+      approval: {
+        approvalHash,
+        approvedAt: input.approvedAt,
+        exportApproved: true,
+        maximumSpendUsd,
+        retentionDays: project.trainingSetup.preferredRetentionDays,
+        region: null
+      }
+    };
+    const submission = {
+      ...jobContent,
+      contentHash: await trainingJobSubmissionHash(jobContent)
+    };
+    const job = await client.createJob(submission);
+    return { job: managedJobFromPublic(job), requestHash: submission.contentHash };
   }
   async rewardModelJob(jobId) {
-    const payload = await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(jobId)}`,
-      {},
-      await this.resolveBoundAccess()
-    );
-    return payload.job;
+    const access5 = await this.resolveBoundAccess();
+    const client = this.trainingClient(access5);
+    const job = await client.getJob(jobId);
+    const output = job.state === "succeeded" ? await client.outputs(jobId) : null;
+    const scorer = output?.outputs.find((candidate2) => candidate2.kind === "scorer");
+    return {
+      job: {
+        ...managedJobFromPublic(job),
+        cleanupAttestation: output?.receipt?.cleanupComplete === true ? { complete: true } : null
+      },
+      resources: scorer ? [{
+        kind: "artifact_upload",
+        state: "consumed",
+        metadata: {
+          ...scorer.metadata,
+          objectPrefix: scorer.artifactRef,
+          artifactSha256: scorer.contentHash
+        }
+      }] : [],
+      outputs: output,
+      executionReceiptRef: output?.receipt ? {
+        id: output.receipt.id,
+        contentHash: await trainingExecutionReceiptHash(output.receipt)
+      } : null
+    };
   }
   async cancelRewardModelJob(jobId, expectedVersion) {
-    return this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(jobId)}/cancel`,
-      { method: "POST", body: JSON.stringify({ expectedVersion }) },
-      await this.resolveBoundAccess()
-    );
+    const client = this.trainingClient(await this.resolveBoundAccess());
+    return { job: managedJobFromPublic(await client.cancelJob(jobId, expectedVersion)) };
   }
   async capabilities() {
-    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const access5 = await this.resolveBoundAccess();
+    const capabilities = await this.trainingClient(access5).capabilities();
+    const available = Date.parse(capabilities.expiresAt) > Date.now();
     return TrainingEngineCapabilitiesSchema.parse({
       schemaVersion: "openpond.trainingEngineCapabilities.v1",
       adapterId: this.id,
-      available: true,
-      methods: ["grpo"],
+      available,
+      methods: capabilities.methods,
       signalKinds: ["trajectory", "reward", "grader_evidence", "infrastructure_failure"],
       modelFamilies: ["transformers"],
       precisions: ["bf16"],
-      topologies: ["single_gpu_phased"],
-      workerProtocolVersion: "openpond.managedRlWorker.v2",
-      upstreamRevision: "e0d60e4d85ea636873acb2e7083e794740d20226",
+      topologies: capabilities.placements.map((placement) => `managed_${placement}`),
+      workerProtocolVersion: "openpond.training.v2",
+      upstreamRevision: capabilities.capabilityHash,
       workerImageDigest: null,
-      capabilityReceipt: contentHash({
-        adapterId: this.id,
-        contract: "openpond.managedRlPortableSubmission.v1",
-        qualifiedModel: QUALIFIED_MODEL
-      }),
-      checkedAt,
-      unavailableReason: null
+      capabilityReceipt: capabilities.capabilityHash,
+      checkedAt: capabilities.checkedAt,
+      unavailableReason: available ? null : "Managed Training capabilities expired."
     });
   }
   async validate(plan) {
     const issues = [];
+    const publicCapabilities = await this.trainingClient(
+      await this.resolveBoundAccess()
+    ).capabilities();
     if (plan.engine.adapterId !== this.id || plan.compute.adapterId !== "openpond-managed" || !(plan.runtime.adapterId === "local-harness" && plan.runtime.placement === "local" && plan.runtime.dataPlane === null || plan.runtime.adapterId === "openpond-managed-harness" && plan.runtime.placement === "remote")) {
       issues.push({
         code: "managed_binding_mismatch",
@@ -42107,24 +41784,25 @@ var OpenPondManagedTrainingAdapter = class {
         message: "The resolved plan is not bound to OpenPond Managed."
       });
     }
-    if (plan.manifest.model.source !== QUALIFIED_MODEL.source || plan.manifest.model.revision !== QUALIFIED_MODEL.revision || plan.manifest.model.tokenizerRevision !== QUALIFIED_MODEL.revision || plan.manifest.model.chatTemplateHash !== QUALIFIED_MODEL.chatTemplateHash) {
+    if (!publicCapabilities.methods.includes(plan.recipe.method)) {
       issues.push({
-        code: "managed_base_profile_unsupported",
-        path: "manifest.model",
-        message: "OpenPond Managed currently requires the qualified Qwen3-0.6B profile."
+        code: "managed_method_unsupported",
+        path: "recipe.method",
+        message: `OpenPond Managed does not currently advertise ${plan.recipe.method}.`
       });
     }
-    if (plan.recipe.method !== "grpo") {
+    if (!publicCapabilities.placements.includes(plan.runtime.placement)) {
       issues.push({
-        code: "managed_method_unsupported",
-        path: "recipe.method",
-        message: "OpenPond Managed currently accepts GRPO runs."
+        code: "managed_placement_unsupported",
+        path: "runtime.placement",
+        message: `OpenPond Managed does not currently advertise ${plan.runtime.placement} rollout placement.`
       });
-    } else if (plan.recipe.lora.rank !== QUALIFIED_RECIPE.loraRank || plan.recipe.rollout.groupSize !== QUALIFIED_RECIPE.rolloutGroupSize || plan.recipe.rollout.concurrency !== QUALIFIED_RECIPE.rolloutConcurrency || plan.recipe.dataset.maxPromptTokens !== QUALIFIED_RECIPE.maxPromptTokens) {
+    }
+    if (plan.maximumSpendUsd === null || plan.maximumSpendUsd > publicCapabilities.limits.maximumSpendUsd) {
       issues.push({
-        code: "managed_recipe_profile_unsupported",
-        path: "recipe",
-        message: "OpenPond Managed requires the qualified 0.6B recipe profile: LoRA rank 16, group size 4, rollout concurrency 4, and 4096 prompt tokens."
+        code: "managed_budget_unsupported",
+        path: "maximumSpendUsd",
+        message: "The approved spend exceeds the current managed-training capability."
       });
     }
     if (!plan.execution) {
@@ -42258,18 +41936,35 @@ var OpenPondManagedTrainingAdapter = class {
         };
       })
     );
-    const project = await this.dependencies.store.getModelProject(
+    let project = await this.dependencies.store.getModelProject(
       trainingPlan.modelId
     );
-    const submission = {
+    if (!project) {
+      throw new Error("The managed Model Project is no longer available.");
+    }
+    const access5 = await this.resolveBoundAccess();
+    project = await this.syncProjectForSubmission(project, access5);
+    if (!project?.hosted || project.hosted.syncedSourceRevision !== project.revision || project.hosted.portableProjectId !== project.id) {
+      throw new Error(
+        "Sync the exact Model Project revision before creating managed training."
+      );
+    }
+    if (plan.recipe.method !== "grpo" || plan.maximumSpendUsd === null) {
+      throw new Error("Managed Training V2 requires GRPO and an approved spend ceiling.");
+    }
+    const baseModel = project.trainingSetup.baseModel;
+    if (!baseModel || baseModel.modelId !== plan.manifest.model.source || baseModel.revision !== plan.manifest.model.revision || baseModel.tokenizerRevision !== plan.manifest.model.tokenizerRevision || baseModel.chatTemplateHash !== plan.manifest.model.chatTemplateHash) {
+      throw new Error("The synced Model Project base Model does not match the Run manifest.");
+    }
+    const portableSubmission = {
       schemaVersion: "openpond.managedRlPortableSubmission.v1",
       sourceRunRef: `openpond:model-run:${plan.manifest.id}`,
       name: `OpenPond Managed \xB7 ${trainingPlan.modelId}`.slice(0, 191),
       idempotencyKey: `openpond-managed:${plan.manifest.contentHash}`.slice(0, 191),
-      modelProject: project?.hosted ? {
+      modelProject: {
         id: project.hosted.projectId,
         portableProjectId: project.hosted.portableProjectId
-      } : null,
+      },
       manifest: plan.manifest,
       sourceTaskset: {
         id: taskset.id,
@@ -42284,24 +41979,102 @@ var OpenPondManagedTrainingAdapter = class {
       },
       validationTasks
     };
-    const access5 = await this.resolveBoundAccess();
-    const response = await this.requestJson(
-      "/v1/managed-rl/portable-launches",
-      {
-        method: "POST",
-        body: JSON.stringify(submission)
+    const client = this.trainingClient(access5);
+    const stagedContent = {
+      schemaVersion: "openpond.trainingInputArtifactUpload.v2",
+      kind: "portable_training_bundle",
+      idempotencyKey: `stage:${plan.manifest.contentHash}`,
+      sourceManifest: {
+        id: plan.manifest.id,
+        contentHash: plan.manifest.contentHash
       },
-      access5
-    );
+      payload: portableSubmission
+    };
+    const staged = {
+      ...stagedContent,
+      contentHash: await trainingInputArtifactUploadHash(stagedContent)
+    };
+    await client.stageArtifact(staged);
+    const grader = taskset.graders[0];
+    if (!grader) throw new Error("Managed training requires an immutable grader.");
+    const learnedPreference = plan.recipe.reward.learnedPreference ?? null;
+    const rewardSource = learnedPreference ? learnedRewardSource(learnedPreference) : {
+      kind: "deterministic",
+      grader: { id: grader.id, contentHash: contentHash(grader) },
+      composer: null
+    };
+    const jobContent = {
+      schemaVersion: "openpond.trainingJobSubmission.v2",
+      idempotencyKey: `openpond-training-v2:${plan.manifest.contentHash}`,
+      name: `OpenPond Managed \xB7 ${trainingPlan.modelId}`.slice(0, 200),
+      source: {
+        modelProject: {
+          id: project.hosted.projectId,
+          portableProjectId: project.hosted.portableProjectId,
+          revision: project.revision,
+          contentHash: project.hosted.etag
+        },
+        harnessRunManifest: {
+          id: plan.manifest.id,
+          contentHash: plan.manifest.contentHash
+        },
+        harnessRelease: plan.manifest.harnessRelease,
+        taskset: {
+          id: taskset.id,
+          revision: taskset.revision,
+          contentHash: taskset.contentHash
+        },
+        tasksetRelease: {
+          id: taskset.id,
+          contentHash: taskset.contentHash
+        },
+        dataset: bundleManifest.datasetRelease,
+        evidenceSets: bundleManifest.evidenceSetRelease ? [bundleManifest.evidenceSetRelease] : []
+      },
+      job: {
+        kind: "policy_optimize",
+        baseModel,
+        recipe: plan.recipe,
+        rewardSource,
+        resumeFrom: null
+      },
+      requestedCapabilities: [
+        { id: "managed_rl.policy.grpo", version: "1", required: true },
+        {
+          id: `managed_rl.rollouts.${plan.runtime.placement}`,
+          version: "1",
+          required: true
+        }
+      ],
+      budget: {
+        maximumSpendUsd: plan.maximumSpendUsd,
+        maximumWallSeconds: Math.ceil(plan.recipe.resourceLimits.wallTimeMs / 1e3)
+      },
+      approval: {
+        approvalHash: plan.approvalHash,
+        approvedAt: plan.manifest.approval.approvedAt,
+        exportApproved: true,
+        maximumSpendUsd: plan.maximumSpendUsd,
+        retentionDays: trainingPlan.dataPolicy.retentionDays,
+        region: trainingPlan.dataPolicy.region
+      }
+    };
+    const publicSubmission = {
+      ...jobContent,
+      contentHash: await trainingJobSubmissionHash(jobContent)
+    };
+    const job = await client.createJob(publicSubmission);
     const ref = {
-      runId: response.job.id,
+      runId: job.id,
       adapterId: this.id,
-      providerJobId: response.job.id,
+      protocolVersion: "openpond.training.v2",
+      routeFamily: "training_v2",
+      providerJobId: job.id,
       tenantId: access5.teamId,
       leaseId: null,
-      manifestHash: response.sourceManifestHash,
-      inputBundleHash: response.submissionHash,
-      createdAt: dateString(response.job.createdAt)
+      manifestHash: plan.manifest.contentHash,
+      inputBundleHash: publicSubmission.contentHash,
+      createdAt: dateString(job.createdAt)
     };
     if (plan.runtime.placement === "local") {
       this.ensureLocalExecutor(ref, access5, plan.manifest.harnessRelease.contentHash);
@@ -42312,75 +42085,117 @@ var OpenPondManagedTrainingAdapter = class {
     throw new Error("OpenPond Managed consumes the immutable submitted training bundle.");
   }
   async status(ref) {
-    const payload = await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}`,
-      {},
-      await this.resolveBoundAccess(ref.tenantId)
-    );
-    const detail = parseManagedJobDetail(payload.job);
-    await persistManagedRunEvidence({
-      store: this.dependencies.store,
-      ref,
-      detail
-    }).catch(() => void 0);
-    const placement = detail.job.inputBundle?.harnessRunManifest?.runtimeTarget?.placement;
+    const access5 = await this.resolveBoundAccess(ref.tenantId);
+    const job = await this.trainingClient(access5).getJob(ref.runId);
+    const localJob = await this.dependencies.store.getTrainingJob(ref.runId);
+    const bindings = recordOrEmpty(localJob?.metadata.portableAdapterBindings);
+    const runtime = recordOrEmpty(bindings.runtime);
+    const placement = runtime.placement;
     if (placement === "local") {
-      const localJob = await this.dependencies.store.getTrainingJob(ref.runId);
       const storedHarnessHash = localJob?.metadata.harnessReleaseHash;
       this.ensureLocalExecutor(
         ref,
-        await this.resolveBoundAccess(ref.tenantId),
-        detail.job.inputBundle?.harnessRelease?.contentHash ?? detail.job.inputBundle?.harnessRunManifest?.harnessRelease?.contentHash ?? (typeof storedHarnessHash === "string" ? storedHarnessHash : void 0)
+        access5,
+        typeof storedHarnessHash === "string" ? storedHarnessHash : void 0
       );
     }
-    if (["completed", "cancelled", "budget_exhausted", "failed"].includes(
-      detail.job.state
-    )) {
+    if (["succeeded", "cancelled", "failed"].includes(job.state)) {
       const executor = this.localExecutors.get(ref.runId);
       this.localExecutors.delete(ref.runId);
       void executor?.stop();
     }
-    return TrainingExecutionStatusSchema.parse(toExecutionStatus(detail.job));
+    return TrainingExecutionStatusSchema.parse(toExecutionStatus(job));
   }
   async refreshEvidence(ref) {
-    const payload = await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}`,
-      {},
-      await this.resolveBoundAccess(ref.tenantId)
+    const localJob = await this.dependencies.store.getTrainingJob(ref.runId);
+    const terminal = localJob ? ["succeeded", "failed", "cancelled"].includes(localJob.status) : false;
+    const snapshot = recordOrEmpty(
+      localJob?.metadata.managedEvidenceSnapshot
     );
-    await persistManagedRunEvidence({
-      store: this.dependencies.store,
-      ref,
-      detail: parseManagedJobDetail(payload.job)
+    if (terminal && snapshot.syncedJobUpdatedAt === localJob?.updatedAt) {
+      return;
+    }
+    const active = this.evidenceRefreshes.get(ref.runId);
+    if (active) return active;
+    const refreshedAt = this.evidenceRefreshedAt.get(ref.runId) ?? 0;
+    if (!terminal && Date.now() - refreshedAt < ACTIVE_EVIDENCE_REFRESH_TTL_MS) return;
+    const refresh = this.refreshEvidenceOnce(ref).finally(() => {
+      if (this.evidenceRefreshes.get(ref.runId) === refresh) {
+        this.evidenceRefreshes.delete(ref.runId);
+        this.evidenceRefreshedAt.set(ref.runId, Date.now());
+      }
     });
+    this.evidenceRefreshes.set(ref.runId, refresh);
+    return refresh;
+  }
+  async refreshEvidenceOnce(ref) {
+    const storedEvents = await this.dependencies.store.listTrainingJobEvents(ref.runId);
+    const client = this.trainingClient(await this.resolveBoundAccess(ref.tenantId));
+    const events = await client.events(ref.runId);
+    const storedById = new Map(storedEvents.map((event2) => [event2.id, event2]));
+    const occupiedSequences = new Set(storedEvents.map((event2) => event2.sequence));
+    let nextSequence = Math.max(
+      REMOTE_TRAINING_EVENT_SEQUENCE_BASE - 1,
+      ...storedEvents.map((event2) => event2.sequence)
+    );
+    for (const event2 of events) {
+      const stored = storedById.get(event2.id);
+      const projectedSequence = REMOTE_TRAINING_EVENT_SEQUENCE_BASE + event2.sequence;
+      const sequence = stored?.sequence ?? (occupiedSequences.has(projectedSequence) ? ++nextSequence : projectedSequence);
+      occupiedSequences.add(sequence);
+      nextSequence = Math.max(nextSequence, sequence);
+      await this.dependencies.store.saveTrainingJobEvent(TrainingJobEventSchema.parse({
+        schemaVersion: "openpond.trainingJobEvent.v1",
+        id: event2.id,
+        jobId: ref.runId,
+        sequence,
+        type: localTrainingEventType(event2),
+        timestamp: event2.createdAt,
+        payload: {
+          ...event2.data,
+          remoteEventType: event2.type,
+          remotePhase: event2.phase,
+          ...event2.message ? { message: event2.message } : {}
+        }
+      }));
+    }
+    const refreshedJob = await this.dependencies.store.getTrainingJob(ref.runId);
+    if (refreshedJob && ["succeeded", "failed", "cancelled"].includes(refreshedJob.status)) {
+      await this.dependencies.store.saveTrainingJob({
+        ...refreshedJob,
+        metadata: {
+          ...refreshedJob.metadata,
+          managedEvidenceSnapshot: {
+            schemaVersion: "openpond.managedEvidenceSnapshot.v1",
+            syncedJobUpdatedAt: refreshedJob.updatedAt,
+            eventCount: events.length,
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      });
+    }
   }
   async logs(ref, cursor) {
-    const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : "";
-    return this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}/logs${query}`,
-      {},
+    const logs = await this.trainingClient(
       await this.resolveBoundAccess(ref.tenantId)
-    );
+    ).logs(ref.runId);
+    const after = cursor === void 0 ? -1 : Number.parseInt(cursor, 10);
+    const entries = logs.filter((entry) => !Number.isFinite(after) || entry.sequence >= after).map((entry) => ({
+      timestamp: entry.createdAt,
+      level: entry.level,
+      message: entry.message
+    }));
+    const next = logs.length === 0 ? Math.max(after, 0) : logs.at(-1).sequence + 1;
+    return { cursor: String(next), entries };
   }
   async cancel(ref) {
     const executor = this.localExecutors.get(ref.runId);
     this.localExecutors.delete(ref.runId);
     void executor?.stop();
     const access5 = await this.resolveBoundAccess(ref.tenantId);
-    const current = await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}`,
-      {},
-      access5
-    );
-    const detail = parseManagedJobDetail(current.job);
-    await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}/cancel`,
-      {
-        method: "POST",
-        body: JSON.stringify({ expectedVersion: detail.job.version })
-      },
-      access5
-    );
+    const client = this.trainingClient(access5);
+    const current = await client.getJob(ref.runId);
+    await client.cancelJob(ref.runId, current.version);
   }
   async close() {
     const executors = [...this.localExecutors.values()];
@@ -42388,23 +42203,32 @@ var OpenPondManagedTrainingAdapter = class {
     await Promise.all(executors.map((executor) => executor.stop()));
   }
   async collect(ref) {
-    const payload = await this.requestJson(
-      `/v1/managed-rl/jobs/${encodeURIComponent(ref.runId)}/artifacts`,
-      {},
-      await this.resolveBoundAccess(ref.tenantId)
-    );
-    const candidate2 = payload.candidateBundle;
-    if (!candidate2 || candidate2.jobId !== ref.runId || !candidate2.artifact.modelArtifactId.trim() || !candidate2.artifact.uri.startsWith("r2://") || !/^[a-f0-9]{64}$/.test(candidate2.artifact.sha256) || !Number.isSafeInteger(candidate2.artifact.sizeBytes) || candidate2.artifact.sizeBytes <= 0) {
-      throw new Error("Sandbox completed managed training without a valid candidate artifact.");
-    }
-    const artifacts = [
-      {
-        kind: "adapter",
-        objectRef: `sandbox-managed-rl://${encodeURIComponent(ref.runId)}/` + encodeURIComponent(candidate2.artifact.modelArtifactId),
-        sha256: candidate2.artifact.sha256,
-        sizeBytes: candidate2.artifact.sizeBytes
-      }
-    ];
+    const access5 = await this.resolveBoundAccess(ref.tenantId);
+    const output = await this.trainingClient(access5).outputs(ref.runId);
+    if (!output.receipt) {
+      throw new Error("Sandbox completed managed training without an execution receipt.");
+    }
+    const receiptOutput = output.outputs.find((candidate2) => candidate2.kind === "receipt");
+    if (!receiptOutput) {
+      throw new Error("Sandbox completed managed training without a receipt artifact.");
+    }
+    await parseAndVerifyTrainingExecutionReceipt(output.receipt, {
+      id: output.receipt.id,
+      contentHash: receiptOutput.contentHash,
+      teamId: access5.teamId,
+      jobId: ref.runId,
+      requireCleanup: true
+    });
+    const adapterOutput = output.outputs.find((candidate2) => candidate2.kind === "adapter");
+    if (!adapterOutput) {
+      throw new Error("Sandbox completed managed training without an adapter artifact.");
+    }
+    const artifacts = output.outputs.filter((candidate2) => candidate2.kind !== "scorer").map((candidate2) => ({
+      kind: candidate2.kind,
+      objectRef: `sandbox-managed-rl://${encodeURIComponent(ref.runId)}/` + encodeURIComponent(candidate2.id),
+      sha256: candidate2.contentHash,
+      sizeBytes: candidate2.sizeBytes
+    }));
     const base = {
       runId: ref.runId,
       manifestHash: ref.manifestHash ?? (() => {
@@ -42420,11 +42244,7 @@ var OpenPondManagedTrainingAdapter = class {
   async requestJson(pathname, init = {}, suppliedAccess) {
     const access5 = suppliedAccess ?? await this.resolveBoundAccess();
     const requestUrl = `${access5.apiBaseUrl}${pathname}`;
-    const headers = withVercelProtectionBypass(
-      requestUrl,
-      hostedApiAuthHeaders(access5.token),
-      this.dependencies.env
-    );
+    const headers = hostedApiAuthHeaders(access5.token);
     headers.set("accept", "application/json");
     headers.set("x-openpond-team-id", access5.teamId);
     if (init.body) headers.set("content-type", "application/json");
@@ -42444,6 +42264,53 @@ var OpenPondManagedTrainingAdapter = class {
     }
     return access5;
   }
+  trainingClient(access5) {
+    const headers = hostedApiAuthHeaders(access5.token);
+    headers.set("x-openpond-team-id", access5.teamId);
+    return createTrainingClient({
+      baseUrl: access5.apiBaseUrl,
+      fetch: this.fetchImpl,
+      headers
+    });
+  }
+  async syncProjectForSubmission(project, access5) {
+    const headers = hostedApiAuthHeaders(access5.token);
+    headers.set("x-openpond-team-id", access5.teamId);
+    const client = createModelProjectsClient({
+      baseUrl: access5.apiBaseUrl,
+      fetch: this.fetchImpl,
+      headers
+    });
+    const hosted = await client.upsert({
+      schemaVersion: "openpond.hostedModelProjectSync.v2",
+      portableProjectId: project.id,
+      name: project.name,
+      objective: project.objective,
+      defaultBaseModel: project.defaultBaseModel,
+      defaultDestinationId: project.defaultDestinationId,
+      trainingSetup: project.trainingSetup,
+      sourceRevision: project.revision,
+      sourceUpdatedAt: project.updatedAt,
+      expectedEtag: project.hosted?.teamId === access5.teamId ? project.hosted.etag : null
+    });
+    const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const saved = ModelProjectSchema.parse({
+      ...project,
+      hosted: {
+        schemaVersion: "openpond.hostedModelProjectLink.v1",
+        teamId: access5.teamId,
+        projectId: hosted.id,
+        portableProjectId: hosted.portableProjectId,
+        revision: hosted.revision,
+        etag: hosted.etag,
+        syncedSourceRevision: project.revision,
+        syncedAt,
+        tasksets: project.hosted?.teamId === access5.teamId ? project.hosted.tasksets : []
+      }
+    });
+    await this.dependencies.store.saveModelProject(saved);
+    return saved;
+  }
   ensureLocalExecutor(ref, access5, harnessReleaseHash) {
     if (this.localExecutors.has(ref.runId)) return;
     if (!harnessReleaseHash) {
@@ -42468,46 +42335,6 @@ var OpenPondManagedTrainingAdapter = class {
     executor.start();
   }
 };
-async function managedQualification(input) {
-  if (!input.qualificationRef) return null;
-  const lineage = input.taskset.metadata.harnessEvaluationLineage;
-  if (!lineage || typeof lineage !== "object" || Array.isArray(lineage)) return null;
-  const review = lineage.review;
-  if (!review || typeof review !== "object" || Array.isArray(review)) return null;
-  const workspaceId = review.workspaceId;
-  if (typeof workspaceId !== "string" || !workspaceId) return null;
-  const receipts = await input.store.listHarnessImprovementArtifacts(
-    workspaceId,
-    "training_qualification",
-    1e3
-  );
-  return receipts.find(
-    (receipt) => receipt.id === input.qualificationRef.id && receipt.contentHash === input.qualificationRef.contentHash
-  ) ?? null;
-}
-function dateString(value) {
-  return new Date(value).toISOString();
-}
-function toExecutionStatus(job) {
-  const terminal = /* @__PURE__ */ new Set(["completed", "cancelled", "budget_exhausted", "failed"]);
-  const preparing = /* @__PURE__ */ new Set([
-    "draft",
-    "validating",
-    "admitted",
-    "provisioning_gpu",
-    "provisioning_rollouts"
-  ]);
-  const state = job.state === "completed" ? "succeeded" : job.state === "cancelled" ? "cancelled" : job.state === "failed" || job.state === "budget_exhausted" ? "failed" : job.state === "cancelling" ? "cancelling" : preparing.has(job.state) ? "preparing" : "running";
-  const progress2 = terminal.has(job.state) ? 1 : typeof job.completedGroups === "number" && typeof job.targetGroups === "number" && job.targetGroups > 0 ? job.completedGroups / job.targetGroups : null;
-  return {
-    runId: job.id,
-    state,
-    phase: job.state,
-    progress: progress2,
-    updatedAt: dateString(job.updatedAt),
-    errorCode: state === "failed" ? (job.terminalReason?.trim() || "managed_training_failed").replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 191) : null
-  };
-}
 
 // ../server/src/training/managed-training-engine-registry.ts
 function createDestinationTrainingEngineRegistry(input) {
@@ -42527,7 +42354,6 @@ function createDestinationTrainingEngineRegistry(input) {
   };
   adapters2.createCalibrationBatch = (request) => managed.createCalibrationBatch(request);
   adapters2.calibrationBatch = (jobId) => managed.calibrationBatch(jobId);
-  adapters2.uploadRewardModelArtifact = (input2) => managed.uploadRewardModelArtifact(input2);
   adapters2.createRewardModelLaunch = (request) => managed.createRewardModelLaunch(request);
   adapters2.rewardModelJob = (jobId) => managed.rewardModelJob(jobId);
   adapters2.cancelRewardModelJob = (jobId, expectedVersion) => managed.cancelRewardModelJob(jobId, expectedVersion);
@@ -42536,6 +42362,7 @@ function createDestinationTrainingEngineRegistry(input) {
 
 // ../server/src/training/portable-model-run-service.ts
 import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile5 } from "node:fs/promises";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import path49 from "node:path";
 
 // ../server/src/training/portable-model-run-artifacts.ts
@@ -42551,7 +42378,7 @@ async function importPortableModelRunArtifacts(input) {
   });
   if (provider === "sandbox") {
     const weights2 = artifacts.find((artifact) => artifact.metadata.managedRlCandidate === true);
-    if (!weights2 || artifacts.length !== 1) {
+    if (!weights2 || artifacts.filter((artifact) => artifact.metadata.managedRlCandidate === true).length !== 1) {
       throw new Error(
         "Sandbox managed training completed without one canonical candidate receipt."
       );
@@ -42618,12 +42445,12 @@ async function persistPortableArtifacts(input) {
   const optimizerReceiptHash = input.portable.artifacts.find((artifact) => artifact.kind === "receipt")?.sha256 ?? input.portable.contentHash;
   const persisted = [];
   for (const portable of input.portable.artifacts) {
-    const managedCandidate = managedRlCandidateRef(portable.objectRef, input.executionRef.runId);
-    if (input.provider === "sandbox" && (!managedCandidate || portable.kind !== "adapter")) {
-      throw new Error("Sandbox managed training returned an invalid remote candidate receipt.");
+    const managedOutput = managedRlOutputRef(portable.objectRef, input.executionRef.runId);
+    if (input.provider === "sandbox" && !managedOutput) {
+      throw new Error("Sandbox managed training returned an invalid remote output receipt.");
     }
-    const artifactPath2 = managedCandidate ? portable.objectRef : localArtifactPath(portable.objectRef);
-    if (!managedCandidate) {
+    const artifactPath2 = managedOutput ? portable.objectRef : localArtifactPath(portable.objectRef);
+    if (!managedOutput) {
       const info = await stat6(artifactPath2);
       if (!info.isFile() || info.size !== portable.sizeBytes) {
         throw new Error(`Portable artifact ${portable.objectRef} changed before import.`);
@@ -42640,7 +42467,7 @@ async function persistPortableArtifacts(input) {
       persisted.push(duplicate);
       continue;
     }
-    const providerFilename = managedCandidate ? "managed-rl-candidate" : portableFilenameFromRef(portable.objectRef);
+    const providerFilename = managedOutput ? portable.kind === "adapter" ? "managed-rl-candidate" : `managed-rl-${portable.kind}` : portableFilenameFromRef(portable.objectRef);
     const isWeights = isAdapterWeights(providerFilename);
     const metadata = {
       provider: input.provider,
@@ -42648,14 +42475,14 @@ async function persistPortableArtifacts(input) {
       portableKind: portable.kind,
       manifestHash: input.portable.manifestHash,
       verified: true,
-      ...managedCandidate ? {
-        managedRlCandidate: true,
-        managedRlJobId: managedCandidate.jobId,
-        managedRlModelArtifactId: managedCandidate.modelArtifactId,
+      ...managedOutput ? {
+        managedRlCandidate: portable.kind === "adapter",
+        managedRlJobId: managedOutput.jobId,
+        managedRlOutputId: managedOutput.outputId,
         managedRlTeamId: input.executionRef.tenantId ?? null
       } : {}
     };
-    if (input.draft.method === "grpo" && isWeights) {
+    if (input.source.method === "grpo" && isWeights) {
       metadata.groupedGrpoReceiptHash = optimizerReceiptHash;
     }
     const artifact = await input.store.saveTrainingArtifact(
@@ -42671,10 +42498,10 @@ async function persistPortableArtifacts(input) {
         path: artifactPath2,
         sha256: portable.sha256,
         sizeBytes: portable.sizeBytes,
-        baseModelId: input.draft.baseModel.modelId,
-        baseModelRevision: input.draft.baseModel.revision,
-        tokenizerRevision: input.draft.baseModel.tokenizerRevision,
-        chatTemplateHash: input.draft.baseModel.chatTemplateHash,
+        baseModelId: input.source.baseModel.modelId,
+        baseModelRevision: input.source.baseModel.revision,
+        tokenizerRevision: input.source.baseModel.tokenizerRevision,
+        chatTemplateHash: input.source.baseModel.chatTemplateHash,
         nonProduction: input.job.nonProduction,
         createdAt: input.completedAt,
         metadata
@@ -42691,13 +42518,13 @@ function localArtifactPath(objectRef2) {
   }
   return path47.resolve(objectRef2);
 }
-function managedRlCandidateRef(objectRef2, expectedJobId) {
+function managedRlOutputRef(objectRef2, expectedJobId) {
   const match = objectRef2.match(/^sandbox-managed-rl:\/\/([^/]+)\/([^/?#]+)$/);
   if (!match) return null;
   try {
     const jobId = decodeURIComponent(match[1]);
-    const modelArtifactId = decodeURIComponent(match[2]);
-    return jobId === expectedJobId && modelArtifactId ? { jobId, modelArtifactId } : null;
+    const outputId = decodeURIComponent(match[2]);
+    return jobId === expectedJobId && outputId ? { jobId, outputId } : null;
   } catch {
     return null;
   }
@@ -42748,29 +42575,35 @@ function objectValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
+// ../server/src/training/portable-model-run-terminal.ts
+function shouldCollectPortableTrainingArtifacts(state) {
+  return state === "succeeded";
+}
+
 // ../server/src/training/portable-model-run-lifecycle.ts
 import path48 from "node:path";
 async function preparePortableModelRunLifecycle(input) {
-  const baseModel = input.draft.baseModel;
-  const method = input.draft.method;
-  const destinationId = input.draft.destinationId;
-  if (!baseModel || !method || !destinationId || !input.draft.tasksetRef) {
+  const setup = input.modelProject.trainingSetup;
+  const baseModel = setup.baseModel;
+  const method = setup.method;
+  const destinationId = setup.destinationId;
+  if (!baseModel || !method || !destinationId || !setup.tasksetRef) {
     throw new Error(
       "Portable Model Run lifecycle requires an exact saved run."
     );
   }
-  const existingRun = await input.store.getModelRun(input.draft.id);
+  const existingRun = await input.store.getModelRun(input.modelRunId);
   if (existingRun) {
     throw new Error(
-      `Canonical Model Run ${input.draft.id} already exists with status ${existingRun.status}.`
+      `Canonical Model Run ${input.modelRunId} already exists with status ${existingRun.status}.`
     );
   }
   const versions = await input.store.listModelVersions({
-    modelId: input.draft.modelId
+    modelId: input.modelProject.id
   });
   const baseVersion = versions.find((version) => version.version === 0);
   if (baseVersion) {
-    if (baseVersion.kind !== "base_reference" || baseVersion.profileId !== input.draft.profileId || baseVersion.baseModel.modelId !== baseModel.modelId || baseVersion.baseModel.revision !== baseModel.revision || baseVersion.baseModel.tokenizerRevision !== baseModel.tokenizerRevision || baseVersion.baseModel.chatTemplateHash !== baseModel.chatTemplateHash) {
+    if (baseVersion.kind !== "base_reference" || baseVersion.profileId !== input.modelProject.profileId || baseVersion.baseModel.modelId !== baseModel.modelId || baseVersion.baseModel.revision !== baseModel.revision || baseVersion.baseModel.tokenizerRevision !== baseModel.tokenizerRevision || baseVersion.baseModel.chatTemplateHash !== baseModel.chatTemplateHash) {
       throw new Error(
         "Existing base Model Version does not match this portable run."
       );
@@ -42778,14 +42611,14 @@ async function preparePortableModelRunLifecycle(input) {
   } else {
     const core = {
       schemaVersion: "openpond.modelVersion.v1",
-      id: modelVersionId(input.draft.modelId, 0),
-      modelId: input.draft.modelId,
-      profileId: input.draft.profileId,
+      id: modelVersionId(input.modelProject.id, 0),
+      modelId: input.modelProject.id,
+      profileId: input.modelProject.profileId,
       version: 0,
       kind: "base_reference",
       status: "available",
       baseModel,
-      taskset: input.draft.tasksetRef,
+      taskset: setup.tasksetRef,
       releaseGraph: input.releaseGraph,
       artifactLineageId: null,
       adapterStatus: "not_trained",
@@ -42799,7 +42632,7 @@ async function preparePortableModelRunLifecycle(input) {
     );
   }
   const modelRuns = await input.store.listModelRuns({
-    modelId: input.draft.modelId
+    modelId: input.modelProject.id
   });
   const reservedIds = /* @__PURE__ */ new Set([
     ...versions.map((version) => version.id),
@@ -42807,26 +42640,26 @@ async function preparePortableModelRunLifecycle(input) {
   ]);
   let targetVersionNumber = 1;
   while (reservedIds.has(
-    modelVersionId(input.draft.modelId, targetVersionNumber)
+    modelVersionId(input.modelProject.id, targetVersionNumber)
   )) {
     targetVersionNumber += 1;
   }
   const targetVersion = {
-    id: modelVersionId(input.draft.modelId, targetVersionNumber),
+    id: modelVersionId(input.modelProject.id, targetVersionNumber),
     version: targetVersionNumber
   };
   const modelRun = await input.store.saveModelRun(
     ModelRunSchema.parse({
       schemaVersion: "openpond.modelRun.v1",
-      id: input.draft.id,
-      modelId: input.draft.modelId,
+      id: input.modelRunId,
+      modelId: input.modelProject.id,
       modelVersionId: targetVersion.id,
-      profileId: input.draft.profileId,
+      profileId: input.modelProject.profileId,
       kind: "training",
       status: "prepared",
       method,
       destinationId,
-      taskset: input.draft.tasksetRef,
+      taskset: setup.tasksetRef,
       harnessRelease: input.releaseGraph.harnessRelease,
       quote: {
         maximumSpendUsd: input.maximumSpendUsd ?? 0,
@@ -42841,7 +42674,18 @@ async function preparePortableModelRunLifecycle(input) {
       updatedAt: input.startedAt
     })
   );
-  return { modelRun, targetVersion };
+  const sourceSnapshot = TrainingJobSourceSnapshotSchema.parse({
+    schemaVersion: "openpond.trainingJobSourceSnapshot.v1",
+    modelProjectId: input.modelProject.id,
+    sourceProjectRevision: input.sourceProjectRevision,
+    profileId: input.modelProject.profileId,
+    taskset: setup.tasksetRef,
+    tasksetRelease: setup.tasksetRelease,
+    harnessRelease: setup.harnessRelease,
+    baseModel,
+    method
+  });
+  return { modelRun, targetVersion, sourceSnapshot };
 }
 async function markPortableModelRunRunning(input) {
   const modelRun = await requiredModelRun(input.store, input.modelRunId);
@@ -42907,16 +42751,6 @@ async function reconcilePortableModelRunLifecycle(input) {
       completedAt: completedAt2,
       error: failure
     });
-    if (input.status.state === "cancelled") {
-      const draft2 = await input.store.getModelRunDraft(input.modelRunId);
-      if (draft2) {
-        await input.store.saveModelRunDraft({
-          ...draft2,
-          status: "cancelled",
-          updatedAt: completedAt2
-        });
-      }
-    }
     return terminal2;
   }
   if (!input.artifacts) {
@@ -42924,17 +42758,17 @@ async function reconcilePortableModelRunLifecycle(input) {
       "Successful portable training requires collected artifacts."
     );
   }
-  const [draft, plan] = await Promise.all([
-    input.store.getModelRunDraft(input.modelRunId),
+  const [source, plan] = await Promise.all([
+    resolveTrainingJobSourceSnapshot(input.store, input.job, input.modelRunId),
     input.store.getTrainingPlan(input.job.planId)
   ]);
-  if (!draft || !draft.baseModel || !draft.tasksetRef || !plan) {
+  if (!plan) {
     throw new Error(
       "Portable training lineage disappeared before artifact import."
     );
   }
-  const taskset = await input.store.getTaskset(draft.tasksetRef.id);
-  if (!taskset || taskset.contentHash !== draft.tasksetRef.contentHash) {
+  const taskset = await input.store.getTaskset(source.taskset.id);
+  if (!taskset || taskset.contentHash !== source.taskset.contentHash) {
     throw new Error(
       "Portable training Taskset changed before artifact import."
     );
@@ -42943,7 +42777,7 @@ async function reconcilePortableModelRunLifecycle(input) {
   const imported = await importPortableModelRunArtifacts({
     store: input.store,
     job: input.job,
-    draft: { ...draft, baseModel: draft.baseModel },
+    source,
     executionRef: input.executionRef,
     completedAt,
     portable: input.artifacts
@@ -42958,11 +42792,11 @@ async function reconcilePortableModelRunLifecycle(input) {
     ModelArtifactLineageSchema.parse({
       schemaVersion: "openpond.modelArtifactLineage.v1",
       id: `model_lineage_${contentHash([
-        draft.modelId,
+        source.modelProjectId,
         weights.sha256,
         plan.contentHash
       ]).slice(0, 24)}`,
-      modelId: draft.modelId,
+      modelId: source.modelProjectId,
       artifactId: weights.id,
       jobId: input.job.id,
       tasksetId: taskset.id,
@@ -42994,13 +42828,13 @@ async function reconcilePortableModelRunLifecycle(input) {
   const versionCore = {
     schemaVersion: "openpond.modelVersion.v1",
     id: reservation.id,
-    modelId: draft.modelId,
-    profileId: draft.profileId,
+    modelId: source.modelProjectId,
+    profileId: source.profileId,
     version: reservation.version,
     kind: "lora_adapter",
     status: "available",
-    baseModel: draft.baseModel,
-    taskset: draft.tasksetRef,
+    baseModel: source.baseModel,
+    taskset: source.taskset,
     releaseGraph,
     artifactLineageId: lineage.id,
     adapterStatus: "trained",
@@ -43094,6 +42928,15 @@ async function requiredModelRun(store, id) {
   }
   return modelRun;
 }
+async function resolveTrainingJobSourceSnapshot(store, job, modelRunId) {
+  const current = TrainingJobSourceSnapshotSchema.safeParse(
+    job.metadata.sourceSnapshot
+  );
+  if (current.success) return current.data;
+  void store;
+  void modelRunId;
+  throw new Error("Training Job source snapshot is missing or invalid.");
+}
 function engineMetadata(job, key, fallback) {
   const bindings = objectValue2(job.metadata.portableAdapterBindings);
   const engine = objectValue2(bindings.engine);
@@ -43345,10 +43188,10 @@ function trainingTargets(input) {
 }
 function preparePortableModelRun(input) {
   const model = input.catalog.models.find(
-    (candidate2) => candidate2.modelId === input.modelRun.baseModel?.modelId && candidate2.revision === input.modelRun.baseModel?.revision
+    (candidate2) => candidate2.modelId === input.modelProject.trainingSetup.baseModel?.modelId && candidate2.revision === input.modelProject.trainingSetup.baseModel?.revision
   );
   const bindings = resolvePortableBindings({
-    modelRun: input.modelRun,
+    modelProject: input.modelProject,
     catalog: input.catalog
   });
   const engine = bindings.engine ? input.catalog.engines.find(
@@ -43358,7 +43201,7 @@ function preparePortableModelRun(input) {
     (candidate2) => candidate2.adapterId === bindings.compute.adapterId
   ) ?? null : null;
   return prepareTrainingSelection({
-    modelRunId: input.modelRun.id,
+    modelRunId: input.modelRunId ?? input.modelProject.id,
     modelCached: model?.cached ?? false,
     modelBytes: model?.expectedBytes ?? 0,
     engine,
@@ -43367,15 +43210,16 @@ function preparePortableModelRun(input) {
     maximumSpendUsd: input.maximumSpendUsd ?? null,
     quoteUsd: input.quoteUsd ?? null,
     retentionDays: input.retentionDays ?? null,
-    providerManaged: input.modelRun.destinationId === "openpond_managed"
+    providerManaged: input.modelProject.trainingSetup.destinationId === "openpond_managed"
   });
 }
 function resolvePortableBindings(input) {
-  const destinationId = input.modelRun.destinationId;
+  const setup = input.modelProject.trainingSetup;
+  const destinationId = setup.destinationId;
   if (!destinationId) return { runtime: null, compute: null, engine: null };
   const computeId = computeIdForDestination(destinationId);
   const engineId = engineIdForDestination(destinationId);
-  const runtimeId = destinationId === "openpond_managed" ? input.environmentPlacement === "remote" || input.environmentPlacement === void 0 && input.modelRun.managedRolloutPlacement === "remote" ? "openpond-managed-harness" : "local-harness" : "local-harness";
+  const runtimeId = destinationId === "openpond_managed" ? input.environmentPlacement === "remote" || input.environmentPlacement === void 0 && setup.managedRolloutPlacement === "remote" ? "openpond-managed-harness" : "local-harness" : "local-harness";
   const compute = input.catalog.compute.find((candidate2) => candidate2.adapterId === computeId);
   const engine = input.catalog.engines.find((candidate2) => candidate2.adapterId === engineId);
   const runtime = input.catalog.runtimes.find((candidate2) => candidate2.adapterId === runtimeId);
@@ -43514,29 +43358,36 @@ function createPortableModelRunService(deps) {
   let reconciliationInFlight = null;
   let lastReconciledAt = 0;
   async function start(input) {
-    const loadedModelRun = await deps.store.getModelRunDraft(input.modelRunId);
-    if (!loadedModelRun || loadedModelRun.status !== "ready_to_run") {
-      throw new Error("A ready saved Model Run is required.");
-    }
-    let modelRun = loadedModelRun;
-    if (!modelRun.tasksetRef || !modelRun.baseModel || !modelRun.recipe || !modelRun.destinationId) {
-      throw new Error("The saved Model Run is incomplete.");
-    }
-    const baseModel = modelRun.baseModel;
-    const tasksetRef = modelRun.tasksetRef;
-    const taskset = await deps.store.getTaskset(modelRun.tasksetRef.id);
-    if (!taskset || taskset.contentHash !== modelRun.tasksetRef.contentHash) {
-      throw new Error("The saved Model Run Taskset release is stale.");
-    }
-    const releasedHarness2 = await deps.resolveReleasedHarness({ taskset, modelRun });
-    modelRun = await deps.store.saveModelRunDraft({
-      ...modelRun,
-      harnessRelease: releasedHarness2.harnessRelease,
-      tasksetRelease: releasedHarness2.tasksetRelease,
+    let sourceProject = await deps.store.getModelProject(input.modelProjectId);
+    if (!sourceProject) throw new Error("A saved Model Project is required.");
+    let setup = sourceProject.trainingSetup;
+    if (!setup.tasksetRef || !setup.baseModel || !setup.recipe || !setup.destinationId) {
+      throw new Error("The Model Project training setup is incomplete.");
+    }
+    const baseModel = setup.baseModel;
+    const tasksetRef = setup.tasksetRef;
+    const taskset = await deps.store.getTaskset(setup.tasksetRef.id);
+    if (!taskset || taskset.contentHash !== setup.tasksetRef.contentHash) {
+      throw new Error("The Model Project Taskset release is stale.");
+    }
+    const releasedHarness2 = await deps.resolveReleasedHarness({
+      taskset,
+      modelProject: sourceProject
+    });
+    sourceProject = await deps.store.saveModelProject({
+      ...sourceProject,
+      revision: sourceProject.revision + 1,
+      trainingSetup: {
+        ...setup,
+        harnessRelease: releasedHarness2.harnessRelease,
+        tasksetRelease: releasedHarness2.tasksetRelease
+      },
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    setup = sourceProject.trainingSetup;
+    const recipe = TrainingRecipeSchema.parse(setup.recipe);
     const preparation = await deps.prepare({
-      modelRunId: modelRun.id,
+      modelProjectId: sourceProject.id,
       maximumSpendUsd: input.maximumSpendUsd,
       retentionDays: input.retentionDays
     });
@@ -43553,11 +43404,11 @@ function createPortableModelRunService(deps) {
       });
     }
     const prepared = await deps.prepareStart({
-      modelId: modelRun.modelId,
+      modelId: sourceProject.id,
       tasksetId: tasksetRef.id,
-      destinationId: modelRun.destinationId,
-      recipe: modelRun.recipe,
-      environmentPlacement: modelRun.destinationId === "openpond_managed" ? modelRun.managedRolloutPlacement ?? "local" : void 0,
+      destinationId: setup.destinationId,
+      recipe,
+      environmentPlacement: setup.destinationId === "openpond_managed" ? setup.managedRolloutPlacement : void 0,
       exportApproved: input.exportApproved,
       retentionDays: input.retentionDays,
       harnessRelease: releasedHarness2.harnessRelease
@@ -43568,16 +43419,18 @@ function createPortableModelRunService(deps) {
       maximumCostUsd: input.maximumSpendUsd
     });
     const bindings = resolvePortableBindings({
-      modelRun,
+      modelProject: sourceProject,
       catalog: await deps.catalog(),
       environmentPlacement: prepared.plan.environmentPlacement
     });
     if (!bindings.runtime || !bindings.compute || !bindings.engine) {
-      throw new Error("The saved Model Run has no complete portable adapter binding.");
+      throw new Error("The Model Project has no complete portable adapter binding.");
     }
+    const modelRunId = `model_run_${randomUUID18()}`;
     const graph = buildTasksetTrainingBundle({
       taskset,
-      modelRun,
+      modelProject: sourceProject,
+      modelRunId,
       runtime: bindings.runtime,
       compute: bindings.compute,
       engine: bindings.engine,
@@ -43594,7 +43447,7 @@ function createPortableModelRunService(deps) {
     const resolvedPlanBase = {
       schemaVersion: "openpond.resolvedTrainingPlan.v1",
       manifest: graph.manifest,
-      recipe: modelRun.recipe,
+      recipe,
       runtime: bindings.runtime,
       compute: bindings.compute,
       engine: bindings.engine,
@@ -43638,8 +43491,10 @@ function createPortableModelRunService(deps) {
     });
     const lifecycle = await preparePortableModelRunLifecycle({
       store: deps.store,
-      draft: modelRun,
+      modelProject: sourceProject,
+      modelRunId,
       taskset,
+      sourceProjectRevision: sourceProject.revision,
       releaseGraph: portableReleaseGraph2,
       maximumSpendUsd: approval.maximumCostUsd,
       startedAt: approval.approvedAt
@@ -43650,7 +43505,7 @@ function createPortableModelRunService(deps) {
     } catch (error) {
       await failPreparedPortableModelRun({
         store: deps.store,
-        modelRunId: modelRun.id,
+        modelRunId,
         error
       });
       throw error;
@@ -43661,7 +43516,7 @@ function createPortableModelRunService(deps) {
       planId: prepared.plan.id,
       bundleHash: prepared.bundle.contentHash,
       approvalId: approval.id,
-      destinationId: modelRun.destinationId,
+      destinationId: setup.destinationId,
       status: "queued",
       nonProduction: false,
       workerPid: null,
@@ -43676,7 +43531,8 @@ function createPortableModelRunService(deps) {
       ...launched,
       metadata: {
         ...launched.metadata,
-        modelRunId: modelRun.id,
+        modelRunId,
+        modelProjectId: sourceProject.id,
         harnessRunManifestId: graph.manifest.id,
         harnessRunManifestHash: graph.manifest.contentHash,
         harnessReleaseHash: graph.harnessRelease.contentHash,
@@ -43688,19 +43544,15 @@ function createPortableModelRunService(deps) {
         portableExecutionRef: executionRef2,
         portableValidationReceipt: validation,
         portableModelVersion: portableModelVersionMetadata(lifecycle.targetVersion),
-        portableReleaseGraph: portableReleaseGraph2
+        portableReleaseGraph: portableReleaseGraph2,
+        sourceSnapshot: lifecycle.sourceSnapshot
       }
     });
     await markPortableModelRunRunning({
       store: deps.store,
-      modelRunId: modelRun.id,
+      modelRunId,
       startedAt: executionRef2.createdAt
     });
-    await deps.store.saveModelRunDraft({
-      ...modelRun,
-      status: "launched",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
     return {
       preparation,
       manifest: graph.manifest,
@@ -43789,6 +43641,18 @@ function createPortableModelRunService(deps) {
         });
         return executionStatus;
       }
+      if (!shouldCollectPortableTrainingArtifacts(executionStatus.state)) {
+        const modelRun2 = await reconcilePortableModelRunLifecycle({
+          store: deps.store,
+          storeDir: deps.storeDir,
+          modelRunId,
+          job,
+          executionRef: parsed.data,
+          status: executionStatus,
+          failure: executionStatus.errorCode
+        });
+        return portableStatusFromModelRun(modelRun2);
+      }
       let artifacts2 = null;
       try {
         artifacts2 = await adapter.collect(parsed.data);
@@ -44004,15 +43868,15 @@ function createPortableTrainingServiceSupport(input) {
     });
   }
   async function prepare(inputPlan) {
-    const modelRun = await input.store.getModelRunDraft(
-      inputPlan.modelRunId
+    const modelProject = await input.store.getModelProject(
+      inputPlan.modelProjectId
     );
-    if (!modelRun || modelRun.status !== "ready_to_run") {
-      throw new Error("A ready saved Model Run is required.");
+    if (!modelProject) {
+      throw new Error("A saved Model Project is required.");
     }
     const trainingCatalog = await catalog();
     return preparePortableModelRun({
-      modelRun,
+      modelProject,
       catalog: trainingCatalog,
       maximumSpendUsd: inputPlan.maximumSpendUsd,
       retentionDays: inputPlan.retentionDays
@@ -44733,7 +44597,7 @@ function managedRewardModelIdempotencyKey(input) {
 }
 async function buildManagedRewardModelLaunchInput(input) {
   if (input.recipe.tasksetRelease.id !== input.tasksetRelease.id || input.recipe.tasksetRelease.contentHash !== input.tasksetRelease.contentHash || input.dataset.tasksetRelease.id !== input.tasksetRelease.id || input.dataset.tasksetRelease.contentHash !== input.tasksetRelease.contentHash) {
-    throw new Error("Reward Model launch must use the exact Taskset release pinned by D0 and the recipe.");
+    throw new Error("Reward Model launch must use the exact Taskset release pinned by the preference dataset and the recipe.");
   }
   if (input.recipe.preferenceDatasetRelease.id !== input.dataset.id || input.recipe.preferenceDatasetRelease.contentHash !== input.dataset.contentHash) {
     throw new Error("Reward Model recipe must pin the materialized preference dataset.");
@@ -44786,7 +44650,7 @@ async function buildManagedRewardModelLaunchInput(input) {
     })
   );
   if (!groups.some((group) => group.partition === "reward_train") || !groups.some((group) => group.partition === "reward_validation")) {
-    throw new Error("Reward Model launch requires D0 train and validation groups.");
+    throw new Error("Reward Model launch requires preference-dataset train and validation groups.");
   }
   const content = {
     schemaVersion: "openpond.managedRlRewardModelLaunchRequest.v1",
@@ -44945,6 +44809,7 @@ function projectQualifiedRewardModel(input) {
     bucketHead: version.artifacts.bucketHead,
     processorRelease: version.artifacts.processorRelease,
     optimizerEvidence: ref(optimizer),
+    managedExecutionReceipt: input.managedExecutionReceipt,
     parameterDeltaHash: contentHash({ before: input.evidence.parameterHashBefore, after: input.evidence.parameterHashAfter }),
     cleanup: input.cleanup
   };
@@ -45049,7 +44914,7 @@ function bindLearnedPreferenceReward(input) {
     runtime: input.version.runtime,
     processorRelease: input.version.artifacts.processorRelease,
     rewardComposerRelease: input.rewardComposerRelease,
-    qualificationKind: report.kind
+    executionReceipt: input.executionReceipt
   });
 }
 
@@ -45196,7 +45061,7 @@ function createTrainingService(deps) {
     prepare: prepareModelRun,
     prepareStart,
     approve,
-    resolveReleasedHarness: async ({ taskset, modelRun }) => {
+    resolveReleasedHarness: async ({ taskset, modelProject }) => {
       const releasedHarness2 = await deps.resolveReleasedHarness?.() ?? null;
       const profile = !releasedHarness2 && deps.loadProfileState ? await deps.loadProfileState() : null;
       const context = compileDesktopHarnessContext({
@@ -45205,7 +45070,7 @@ function createTrainingService(deps) {
         releasedHarness: releasedHarness2,
         model: {
           providerId: "openpond",
-          modelId: modelRun.baseModel.modelId
+          modelId: modelProject.trainingSetup.baseModel.modelId
         }
       });
       if (profile?.sourcePath) {
@@ -45230,10 +45095,10 @@ function createTrainingService(deps) {
   void portableModelRuns.reconcileActive({ force: true });
   async function launchRewardModel(input) {
     if (input.recipe.tasksetRelease.id !== input.dataset.tasksetRelease.id || input.recipe.tasksetRelease.contentHash !== input.dataset.tasksetRelease.contentHash) {
-      throw new Error("Reward Model recipe and D0 must pin the same Taskset release.");
+      throw new Error("Reward Model recipe and preference dataset must pin the same Taskset release.");
     }
     if (input.tasksetRelease.id !== input.dataset.tasksetRelease.id || input.tasksetRelease.contentHash !== input.dataset.tasksetRelease.contentHash) {
-      throw new Error("Reward Model Run must use the exact Taskset release pinned by D0.");
+      throw new Error("Reward Model Run must use the exact Taskset release pinned by the preference dataset.");
     }
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const recipeHash = contentHash(input.recipe);
@@ -45293,7 +45158,13 @@ function createTrainingService(deps) {
         managedBaseModel: input.managedBaseModel,
         attempts
       });
-      const launched = await portableAdapters.createRewardModelLaunch(request);
+      const launched = await portableAdapters.createRewardModelLaunch({
+        request,
+        modelProjectId: input.modelProject.id,
+        processorRelease: input.recipe.processorRelease,
+        recipe: input.recipe,
+        approvedAt: prepared.startedAt
+      });
       return deps.store.saveRewardModelRun({
         ...prepared,
         status: "running",
@@ -45301,11 +45172,12 @@ function createTrainingService(deps) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
+      const failure = error instanceof OpenPondTrainingApiError ? `${error.message} (${error.code})` : error instanceof Error ? error.message : "Reward Model launch failed.";
       return deps.store.saveRewardModelRun({
         ...prepared,
         status: "failed",
         failureOwner: "authoring",
-        failure: error instanceof Error ? error.message : "Reward Model launch failed.",
+        failure,
         completedAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -45317,7 +45189,7 @@ function createTrainingService(deps) {
       throw new Error("Reward Model Version was not found for this Taskset.");
     }
     const run = (await deps.store.listRewardModelRuns({ tasksetId: input.tasksetId })).find((candidate2) => candidate2.rewardModelVersionId === version.id && candidate2.status === "succeeded");
-    if (!run?.qualificationReport) {
+    if (!run?.qualificationReport || !run.receipt?.managedExecutionReceipt) {
       throw new Error("Reward Model Version has no immutable qualification report.");
     }
     const report = await loadRewardModelQualificationReport({
@@ -45341,7 +45213,8 @@ function createTrainingService(deps) {
       rewardComposerRelease: {
         id: `reward-composer:${rewardComposerHash.slice(0, 24)}`,
         contentHash: rewardComposerHash
-      }
+      },
+      executionReceipt: run.receipt.managedExecutionReceipt
     });
   }
   async function retryRewardModelQualification(runId, retryRunId) {
@@ -45404,7 +45277,8 @@ function createTrainingService(deps) {
         const upload = remote.resources.find(
           (resource) => resource.kind === "artifact_upload" && resource.state === "consumed"
         );
-        const evidence = upload?.metadata.evidence;
+        const uploadMetadata = recordOrNull(upload?.metadata);
+        const evidence = uploadMetadata?.evidence;
         const evidenceRecord = evidence && typeof evidence === "object" && !Array.isArray(evidence) ? evidence : null;
         const completedSteps = typeof evidenceRecord?.steps === "number" && Number.isInteger(evidenceRecord.steps) ? evidenceRecord.steps : run.progress.completedSteps;
         const latestLoss = typeof evidenceRecord?.loss === "number" && Number.isFinite(evidenceRecord.loss) ? evidenceRecord.loss : run.progress.latestLoss;
@@ -45428,17 +45302,15 @@ function createTrainingService(deps) {
         }
         if (remote.job.state === "completed") {
           try {
-            const resourceMetadata = upload?.metadata;
+            const resourceMetadata = uploadMetadata;
             const inventory = Array.isArray(resourceMetadata?.inventory) ? resourceMetadata.inventory.filter(isInventoryFile) : [];
             const checkpointPrefix = typeof resourceMetadata?.objectPrefix === "string" ? resourceMetadata.objectPrefix : "";
             const artifactSha256 = typeof resourceMetadata?.artifactSha256 === "string" ? resourceMetadata.artifactSha256 : "";
-            const inputBundle = remote.job.inputBundle;
-            const rewardTraining = recordOrNull(inputBundle?.rewardModelTraining);
-            const rewardBase = recordOrNull(rewardTraining?.baseModel);
-            const rewardProcessor = recordOrNull(rewardTraining?.processor);
-            const harness = recordOrNull(inputBundle?.harnessRunManifest);
+            const rewardBase = recordOrNull(resourceMetadata?.baseModel);
+            const rewardProcessor = recordOrNull(resourceMetadata?.processor);
+            const harness = recordOrNull(resourceMetadata?.harnessRunManifest);
             const taskset = await deps.store.getTaskset(run.taskset.id);
-            if (!taskset || !rewardBase || !rewardProcessor || !harness || !checkpointPrefix || !artifactSha256) {
+            if (!taskset || !rewardBase || !rewardProcessor || !harness || !checkpointPrefix || !artifactSha256 || !remote.executionReceiptRef) {
               throw new Error("Completed managed Reward Model job is missing immutable launch lineage.");
             }
             const versionNumber = nextRewardModelVersionNumber(
@@ -45471,6 +45343,7 @@ function createTrainingService(deps) {
                 computeReleased: remote.resources.every((resource) => resource.state !== "active"),
                 providerTerminalObserved: remote.job.cleanupAttestation !== null && remote.job.cleanupAttestation !== void 0
               },
+              managedExecutionReceipt: remote.executionReceiptRef,
               createdAt: (/* @__PURE__ */ new Date()).toISOString()
             });
             await saveRewardModelQualificationReport({
@@ -45707,12 +45580,13 @@ function createModelProjectHostingService(input) {
     const project = await requireProject(input.store, projectId);
     const access5 = await input.resolveAccess();
     const syncBody = {
-      schemaVersion: "openpond.hostedModelProjectSync.v1",
+      schemaVersion: "openpond.hostedModelProjectSync.v2",
       portableProjectId: project.id,
       name: project.name,
       objective: project.objective,
       defaultBaseModel: project.defaultBaseModel,
       defaultDestinationId: project.defaultDestinationId,
+      trainingSetup: project.trainingSetup,
       sourceRevision: project.revision,
       sourceUpdatedAt: project.updatedAt
     };
@@ -45860,15 +45734,15 @@ function createModelProjectHostingService(input) {
   }
   async function requestJson2(request) {
     const url = `${request.access.apiBaseUrl}${request.pathname}`;
-    const headers = withVercelProtectionBypass(
-      url,
-      hostedApiAuthHeaders(request.access.token),
-      input.env ?? process.env
+    const headers = hostedApiAuthHeaders(request.access.token);
+    const isModelProjectRequest = request.pathname.startsWith("/v1/model-projects/");
+    headers.set(
+      "accept",
+      isModelProjectRequest ? OPENPOND_MODEL_PROJECT_MEDIA_TYPE : "application/json"
     );
-    headers.set("accept", "application/json");
     headers.set(
       "content-type",
-      request.gzip ? PORTABLE_TASKSET_PUBLICATION_CONTENT_TYPE : "application/json"
+      request.gzip ? PORTABLE_TASKSET_PUBLICATION_CONTENT_TYPE : isModelProjectRequest ? OPENPOND_MODEL_PROJECT_MEDIA_TYPE : "application/json"
     );
     headers.set("x-openpond-team-id", request.access.teamId);
     const response = await fetchImpl(url, {
@@ -45880,7 +45754,7 @@ function createModelProjectHostingService(input) {
     if (!response.ok) {
       const endpoint = new URL(url);
       throw new Error(
-        `${typeof payload.error === "string" ? payload.error : "Hosted Model Project request failed"} (${response.status} ${endpoint.origin}${endpoint.pathname}).`
+        `${typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : "Hosted Model Project request failed"} (${response.status} ${endpoint.origin}${endpoint.pathname}).`
       );
     }
     return payload;
@@ -46278,10 +46152,10 @@ async function materializeSyntheticCollectionRun(input) {
 }
 
 // ../server/src/training/model-create-improve.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function createTasksetAuthoringCreateImproveRun(input) {
   const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-  const id = `create_improve_${randomUUID18()}`;
+  const id = `create_improve_${randomUUID19()}`;
   const evidenceSnapshot = createEvidenceSnapshot({
     objective: input.objective?.trim() || (input.resourceIntent === "dataset" ? "Create a Dataset from selected sources." : "Create a model from selected evidence."),
     sources: input.sources ?? [],
@@ -46387,7 +46261,7 @@ function createExistingTasksetModelCreateImproveRun(input) {
     sources: input.taskset.sourceRefs.filter(isTrainingSourceRef),
     targetIntent: {
       kind: "model",
-      id: input.modelId ?? `model_${randomUUID18()}`,
+      id: input.modelId ?? `model_${randomUUID19()}`,
       displayName: input.taskset.name,
       operation: "create"
     },
@@ -46436,7 +46310,7 @@ function createExistingTasksetModelCreateImproveRun(input) {
 }
 function createModelTrainingCreateImproveRun(input) {
   const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-  const runId = `create_improve_${randomUUID18()}`;
+  const runId = `create_improve_${randomUUID19()}`;
   const target = {
     kind: "model",
     id: input.modelId,
@@ -46753,7 +46627,7 @@ function targetForIntent(intent, objective) {
   if (intent.kind === "model") {
     return {
       kind: "model",
-      id: intent.id ?? `model_draft_${randomUUID18()}`,
+      id: intent.id ?? `model_draft_${randomUUID19()}`,
       displayName: displayName ?? "New model",
       trainingPlanId: null,
       trainingJobId: null,
@@ -47536,6 +47410,13 @@ function createTrainingApi(deps) {
       const tasksetId = requiredString10(input.tasksetId, "tasksetId");
       const datasetId = requiredString10(input.preferenceDatasetReleaseId, "preferenceDatasetReleaseId");
       const taskset = await requireTaskset(deps.store, tasksetId);
+      const modelProject = await deps.store.getModelProject(
+        requiredString10(input.modelProjectId, "modelProjectId")
+      );
+      if (!modelProject) throw new Error("Model Project was not found.");
+      if (modelProject.trainingSetup.tasksetRef?.id !== taskset.id) {
+        throw new Error("Reward Model Run must use the Taskset selected by the Model Project.");
+      }
       const dataset = (await requirePreferenceComparisons(deps.preferenceComparisons).listPreferenceDatasets(tasksetId)).find((candidate2) => candidate2.id === datasetId);
       if (!dataset) throw new Error("Preference Dataset release was not found for this Taskset.");
       const comparisonRelease = await deps.store.getPreferenceComparisonRelease(
@@ -47554,6 +47435,7 @@ function createTrainingApi(deps) {
       return deps.training.launchRewardModel({
         id: requiredString10(input.id, "id"),
         rewardModelId: requiredString10(input.rewardModelId, "rewardModelId"),
+        modelProject,
         taskset,
         tasksetRelease: comparisonRelease.tasksetRelease,
         dataset,
@@ -47665,42 +47547,6 @@ function createTrainingApi(deps) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
-    if (action === "save_model_run_draft") {
-      const draft = ModelRunDraftSchema.parse(input);
-      const existing = await deps.store.getModelRunDraft(draft.id);
-      if (existing && existing.profileId !== draft.profileId) {
-        throw new Error("Model run draft profile does not match the active Profile.");
-      }
-      if (existing && existing.modelId !== draft.modelId) {
-        throw new Error("A saved Model run draft cannot change Model identity.");
-      }
-      if (existing && (existing.status === "launched" || existing.status === "cancelled")) {
-        if (JSON.stringify(existing) !== JSON.stringify(draft)) {
-          throw new Error("Launched and cancelled Model runs are immutable.");
-        }
-        return existing;
-      }
-      const project = await deps.store.getModelProject(draft.modelId);
-      if (!project || project.profileId !== draft.profileId) {
-        throw new Error("Save the Model before saving its run draft.");
-      }
-      return deps.store.saveModelRunDraft({
-        ...draft,
-        createdAt: existing?.createdAt ?? draft.createdAt,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    if (action === "delete_model_run_draft") {
-      const draft = await deps.store.getModelRunDraft(
-        requiredString10(input.draftId, "draftId")
-      );
-      if (!draft) return { deleted: false };
-      if (draft.status === "launched") {
-        throw new Error("A launched Model run cannot be deleted.");
-      }
-      await deps.store.deleteModelRunDraft(draft.id);
-      return { deleted: true, draftId: draft.id };
-    }
     if (action === "add_source") return deps.taskCreator.addSessionSource({ profileId: requiredString10(input.profileId, "profileId"), sessionId: requiredString10(input.sessionId, "sessionId"), turnIds: stringArray5(input.turnIds), consentScope: input.consentScope === "selected_turns" ? "selected_turns" : "full_session" });
     if (action === "add_sources") {
       const profileId = requiredString10(input.profileId, "profileId");
@@ -48208,36 +48054,35 @@ function createTrainingApi(deps) {
       return { qualification, prepared };
     }
     if (action === "prepare_model_run") return deps.training.prepareModelRun({
-      modelRunId: requiredString10(input.modelRunId, "modelRunId"),
+      modelProjectId: requiredString10(input.modelProjectId, "modelProjectId"),
       maximumSpendUsd: nullableNumber(input.maximumSpendUsd),
       retentionDays: nullableNumber(input.retentionDays)
     });
     if (action === "start_model_run") {
-      const modelRunId = requiredString10(input.modelRunId, "modelRunId");
-      const modelRun = await deps.store.getModelRunDraft(modelRunId);
-      if (!modelRun || modelRun.status !== "ready_to_run") {
-        throw new Error("A ready saved Model Run is required.");
-      }
-      if (modelRun.destinationId === "openpond_managed") {
+      const modelProjectId = requiredString10(input.modelProjectId, "modelProjectId");
+      const modelProject = await deps.store.getModelProject(modelProjectId);
+      if (!modelProject) throw new Error("A saved Model Project is required.");
+      const setup = modelProject.trainingSetup;
+      if (setup.destinationId === "openpond_managed") {
         if (!deps.modelProjectHosting) {
           throw new Error("Managed runs require hosted Model Project sync.");
         }
-        if (!modelRun.tasksetRef) {
-          throw new Error("The saved Model Run has no Taskset.");
+        if (!setup.tasksetRef) {
+          throw new Error("The Model Project training setup has no Taskset.");
         }
-        const taskset = await requireTaskset(deps.store, modelRun.tasksetRef.id);
+        const taskset = await requireTaskset(deps.store, setup.tasksetRef.id);
         const release = await requireReleasedTaskset(
           deps.benchmarkTasksets,
           taskset
         );
         await deps.modelProjectHosting.publishTaskset({
-          projectId: modelRun.modelId,
+          projectId: modelProject.id,
           taskset,
           release
         });
       }
       return deps.training.startModelRun({
-        modelRunId,
+        modelProjectId,
         maximumSpendUsd: nullableNumber(input.maximumSpendUsd),
         retentionDays: nullableNumber(input.retentionDays),
         exportApproved: input.exportApproved === true,
@@ -48393,7 +48238,6 @@ function createTrainingApi(deps) {
       minerConfig,
       minerRuns,
       modelProjects,
-      modelRunDrafts,
       modelVersions,
       modelRuns,
       modelTasksets,
@@ -48409,7 +48253,6 @@ function createTrainingApi(deps) {
       deps.taskMiner.config(profileId),
       deps.store.listTaskMinerRuns(profileId),
       deps.store.listModelProjects(),
-      deps.store.listModelRunDrafts(),
       deps.store.listModelVersions(),
       deps.store.listModelRuns(),
       deps.store.listTasksets(),
@@ -48450,7 +48293,6 @@ function createTrainingApi(deps) {
       minerConfig,
       minerRuns,
       modelProjects,
-      modelRunDrafts,
       modelVersions,
       modelRuns,
       modelTasksets,
@@ -49316,7 +49158,7 @@ async function runDatasetWorker(projectDir, args) {
 }
 
 // ../server/src/training/dataset-imports/import-service.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 import {
   mkdir as mkdir11,
   readFile as readFile16,
@@ -49327,7 +49169,7 @@ import {
 import path55 from "node:path";
 
 // ../server/src/training/dataset-imports/hugging-face.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 var HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "www.huggingface.co"]);
 var METADATA_LIMIT_BYTES = 8 * 1024 * 1024;
 var REQUEST_TIMEOUT_MS = 25e3;
@@ -49446,7 +49288,7 @@ ${split.split}`) ?? {
   const title = typeof cardData?.pretty_name === "string" ? cardData.pretty_name : locator.repositoryId.split("/").at(-1);
   return HuggingFaceDatasetInspectionSchema.parse({
     schemaVersion: "openpond.huggingFaceDatasetInspection.v1",
-    id: `dataset_inspection_${randomUUID19()}`,
+    id: `dataset_inspection_${randomUUID20()}`,
     locator,
     resolvedRevision,
     title,
@@ -49714,7 +49556,7 @@ function requiredString11(value, label) {
 }
 
 // ../server/src/training/dataset-imports/imported-taskset.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 function buildImportedDatasetManifest(job, mapping, result) {
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const fields = mapping.bindings.map((binding) => ({
@@ -49726,7 +49568,7 @@ function buildImportedDatasetManifest(job, mapping, result) {
   }));
   const base = {
     schemaVersion: "openpond.datasetArtifact.v1",
-    id: `dataset_artifact_${randomUUID20()}`,
+    id: `dataset_artifact_${randomUUID21()}`,
     tasksetId: job.tasksetId,
     tasksetRevision: job.tasksetRevision,
     format: "parquet",
@@ -50243,7 +50085,7 @@ function createDatasetImportService(deps) {
     const locator = normalizeHuggingFaceDatasetLocator(input.url);
     let job = DatasetImportJobSchema.parse({
       schemaVersion: "openpond.datasetImportJob.v1",
-      id: `dataset_import_${randomUUID21()}`,
+      id: `dataset_import_${randomUUID22()}`,
       profileId: input.profileId,
       sourceKind: "huggingface",
       status: "inspecting",
@@ -53681,7 +53523,7 @@ function readableXmlText(value) {
   ).split(/\r?\n/).map((line) => line.replace(/[\t ]+/g, " ").trim()).filter(Boolean).join("\n");
 }
 function decodeXmlEntities(value) {
-  return value.replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))).replace(/&#(\d+);/g, (_, decimal2) => String.fromCodePoint(Number.parseInt(decimal2, 10))).replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+  return value.replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))).replace(/&#(\d+);/g, (_, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10))).replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
 }
 function boundedText(value) {
   return value.length <= MAX_EXTRACTED_CHARS ? value : `${value.slice(0, MAX_EXTRACTED_CHARS)}
@@ -54491,7 +54333,7 @@ function isImageMediaType(mediaType) {
 }
 
 // ../server/src/training/harness-refiner-benchmark-model.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 function createHarnessRefinerBenchmarkModelStream(streamOpenPondHostedChatTurn2) {
   return async function* ({
     model,
@@ -54502,7 +54344,7 @@ function createHarnessRefinerBenchmarkModelStream(streamOpenPondHostedChatTurn2)
     if (model.providerId !== "openpond") {
       throw new Error("Harness Refiner benchmark model must use the admitted OpenPond hosted provider.");
     }
-    const requestId = `harness-refiner-benchmark:${randomUUID22()}`;
+    const requestId = `harness-refiner-benchmark:${randomUUID23()}`;
     for (let retry = 0; ; retry += 1) {
       let received = false;
       try {
@@ -54938,7 +54780,7 @@ function supplementaryModelJudge(release) {
 
 // ../server/src/training/local-taskset-work-runtime.ts
 import { execFile as execFile9 } from "node:child_process";
-import { createHash as createHash16, randomUUID as randomUUID23 } from "node:crypto";
+import { createHash as createHash16, randomUUID as randomUUID24 } from "node:crypto";
 import { existsSync as existsSync12, promises as fs25 } from "node:fs";
 import os8 from "node:os";
 import path61 from "node:path";
@@ -55101,7 +54943,7 @@ async function executeLocalWorkspaceTool(input) {
         safeName2(input.session.id)
       );
       await fs25.mkdir(outputDir, { recursive: true, mode: 448 });
-      const destination = path61.join(outputDir, `001-${randomUUID23()}-${title}`);
+      const destination = path61.join(outputDir, `001-${randomUUID24()}-${title}`);
       await fs25.writeFile(destination, bytes2, { mode: 384 });
       const outputRef = FileOutputRefSchema.parse({
         kind: "file",
@@ -55840,11 +55682,7 @@ function createManagedAdapterRegistryClient(dependencies = {}) {
     const access5 = await resolveAccess(teamId);
     assertResolvedTeam(access5.teamId, teamId);
     const requestUrl = `${access5.apiBaseUrl}${path65}`;
-    const headers = withVercelProtectionBypass(
-      requestUrl,
-      hostedApiAuthHeaders(access5.token),
-      dependencies.env
-    );
+    const headers = hostedApiAuthHeaders(access5.token);
     headers.set("accept", "application/json");
     headers.set("x-openpond-team-id", access5.teamId);
     if (init.body) headers.set("content-type", "application/json");
@@ -55919,11 +55757,7 @@ function createManagedAdapterRegistryClient(dependencies = {}) {
     const access5 = await resolveInferenceAccess(input.teamId);
     assertResolvedTeam(access5.teamId, input.teamId);
     const requestUrl = `${access5.apiBaseUrl}/v1/chat/completions`;
-    const headers = withVercelProtectionBypass(
-      requestUrl,
-      hostedApiAuthHeaders(access5.token),
-      dependencies.env
-    );
+    const headers = hostedApiAuthHeaders(access5.token);
     headers.set("accept", "text/event-stream");
     headers.set("content-type", "application/json");
     headers.set("x-openpond-team-id", access5.teamId);
@@ -56502,7 +56336,7 @@ async function createOpenPondServer(options = {}) {
   });
   const workEvidenceApi = createDesktopWorkEvidenceApi({ store, storeDir });
   const startedAt = now();
-  const serverId = randomUUID24();
+  const serverId = randomUUID25();
   const workOutputService = createWorkOutputService({
     deviceId: serverId,
     storeDir,