openpond-sdk 0.5.5 → 0.5.7

package/dist/training-bundle.js

@@ -0,0 +1,459 @@
+import {
+  learningVerifierModule,
+  projectLearningBatchGraders,
+  resolvePortableTasksetRewardExecution
+} from "./chunk-ARUJ3FJT.js";
+import {
+  TasksetSchema,
+  computeTasksetHash
+} from "./chunk-QFT2MCIC.js";
+import "./chunk-4IDTRFW2.js";
+import "./chunk-S7I45WJQ.js";
+import {
+  TRAINING_EVALUATION_SOURCE_PATH,
+  TrainingEvaluationSourceSchema,
+  assertTrainingEvaluationIsolation
+} from "./chunk-F5JBFRAH.js";
+import {
+  HarnessSourceSelectionSchema,
+  validateHarnessSourcePackage
+} from "./chunk-UKVK7MRJ.js";
+import {
+  ImmutableReleaseRefSchema,
+  ReleaseHashSchema,
+  ReleaseIdSchema,
+  ReleaseTimestampSchema,
+  canonicalJson,
+  contentHash,
+  sha256
+} from "./chunk-QUOW6URQ.js";
+import "./chunk-ZNFOVV7B.js";
+
+// src/training-bundle.ts
+import { compileBoundGraders } from "@openpond/evals/rewards";
+import { verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+
+// src/training-bundle-contracts.ts
+import { z } from "zod";
+var ScopedSecretDeclarationSchema = z.object({
+  id: ReleaseIdSchema,
+  purpose: z.string().trim().min(1).max(500),
+  audience: z.enum([
+    "orchestrator",
+    "environment",
+    "privileged_scorer",
+    "trainer",
+    "infrastructure"
+  ]),
+  required: z.boolean(),
+  ttlSeconds: z.number().int().positive().max(86400),
+  scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([])
+}).strict();
+var OpaqueSecretLeaseRefSchema = z.object({
+  declarationId: ReleaseIdSchema,
+  leaseRef: z.string().trim().min(8).max(1e3),
+  audience: ScopedSecretDeclarationSchema.shape.audience,
+  expiresAt: ReleaseTimestampSchema
+}).strict();
+var HarnessRuntimeTargetBindingSchema = z.object({
+  adapterId: ReleaseIdSchema,
+  placement: z.enum(["local", "remote", "colocated", "provider_native"]),
+  capabilityReceipt: ReleaseHashSchema,
+  runtimeVersion: z.string().trim().min(1).max(200),
+  dataPlane: z.object({
+    provider: ReleaseIdSchema,
+    dataPlaneId: ReleaseIdSchema,
+    cellId: ReleaseIdSchema,
+    runnerPoolId: ReleaseIdSchema,
+    runtimeImageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    capabilityReceipt: ReleaseHashSchema
+  }).strict().nullable()
+}).strict();
+var ComputeTargetBindingSchema = z.object({
+  adapterId: ReleaseIdSchema,
+  kind: z.enum(["local", "ssh", "managed", "custom"]),
+  deviceOrPool: z.string().trim().min(1).max(1e3),
+  capabilityReceipt: ReleaseHashSchema,
+  provider: ReleaseIdSchema.nullable()
+}).strict();
+var TrainingEngineBindingSchema = z.object({
+  adapterId: ReleaseIdSchema,
+  workerVersion: z.string().trim().min(1).max(200),
+  workerImageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/).nullable(),
+  upstreamRevision: z.string().trim().min(1).max(500),
+  capabilityReceipt: ReleaseHashSchema
+}).strict();
+var HarnessRunManifestContentSchema = z.object({
+  schemaVersion: z.literal("openpond.harnessRunManifest.v1"),
+  id: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  datasetRelease: ImmutableReleaseRefSchema,
+  evidenceSets: z.array(ImmutableReleaseRefSchema).max(1e4),
+  model: z.object({
+    source: z.string().trim().min(1).max(200),
+    revision: z.string().trim().min(1).max(500),
+    artifactHash: ReleaseHashSchema.nullable(),
+    tokenizerRevision: z.string().trim().min(1).max(500),
+    chatTemplateHash: ReleaseHashSchema
+  }).strict(),
+  recipe: z.object({
+    method: z.string().trim().min(1).max(100),
+    version: z.string().trim().min(1).max(200),
+    configHash: ReleaseHashSchema
+  }).strict(),
+  runtimeTarget: HarnessRuntimeTargetBindingSchema,
+  computeTarget: ComputeTargetBindingSchema,
+  engine: TrainingEngineBindingSchema,
+  resolvedBundleHash: ReleaseHashSchema,
+  secretLeaseRefs: z.array(OpaqueSecretLeaseRefSchema).max(1e3),
+  approval: z.object({
+    approvalHash: ReleaseHashSchema,
+    approvedAt: ReleaseTimestampSchema,
+    maximumSpendUsd: z.number().nonnegative().nullable()
+  }).strict(),
+  createdAt: ReleaseTimestampSchema
+}).strict();
+var HarnessRunManifestSchema = HarnessRunManifestContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var ResolvedTrainingBundleContentSchema = z.object({
+  schemaVersion: z.literal("openpond.resolvedTrainingBundle.v1"),
+  projection: z.literal("trainer"),
+  harnessRelease: ImmutableReleaseRefSchema,
+  datasetRelease: ImmutableReleaseRefSchema,
+  evidenceSetRelease: ImmutableReleaseRefSchema.nullable(),
+  files: z.array(
+    z.object({
+      path: z.string().trim().min(1).max(2e3),
+      sha256: ReleaseHashSchema,
+      sizeBytes: z.number().int().nonnegative()
+    }).strict()
+  ).max(1e5)
+}).strict();
+var ResolvedTrainingBundleManifestSchema = ResolvedTrainingBundleContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// src/training-learning-batch.ts
+import { compileTaskBatch, learningRef, taskBatchPackageMetadata, verifyLearningTextAsset } from "@openpond/evals";
+function materializeLearningBatchTaskset(input) {
+  const release = compileTaskBatch(input);
+  const metadata = taskBatchPackageMetadata(release);
+  if (release.environment.kind !== "text" || release.tools.length || release.tasks.some((task) => task.artifactRefs.length)) throw new Error("This learning batch requires an environment or asset adapter before training preparation.");
+  const sourceId = input.source.id;
+  const signals = { demonstrations: [], preferences: [], corrections: [], feedback: [], rewards: [], labels: [] };
+  const fixtures = [];
+  for (const admission of metadata.admissions) {
+    const evidence = input.evidence.find((item) => item.id === admission.evidence.id);
+    const decision = input.decisions.find((item) => item.id === admission.decision.id);
+    if (input.batch.purpose === "reward_training" && decision.grade?.training.status === "scored") signals.rewards.push({
+      id: `reward-${admission.taskId}`,
+      taskId: admission.taskId,
+      kind: "reward",
+      task: input.definition.instructions,
+      rules: [{ id: input.binding.id, points: 1, condition: "Execute the released Reward binding with its declared normalization, weights and gates." }],
+      otherwisePoints: 0,
+      executable: true,
+      approved: true,
+      confidence: 1,
+      sourceRefs: [sourceId],
+      artifactRef: input.binding.id,
+      metadata: { rewardBinding: learningRef(input.binding), evidence: admission.evidence, decision: admission.decision }
+    });
+    if (admission.supervisedTarget !== null) signals.demonstrations.push({ kind: "demonstration", id: `demo-${admission.taskId}`, taskId: admission.taskId, sourceRefs: [sourceId], artifactRef: admission.decision.id, approved: true, confidence: 1, prompt: null, response: JSON.stringify(admission.supervisedTarget), metadata: { evidence: admission.evidence, decision: admission.decision, targetGradeHash: decision.targetGrade?.contentHash } });
+    for (const [kind, output, grade] of [["observed", evidence.submission.observedOutput, decision.grade], ["target", decision.approvedTarget, decision.targetGrade]]) {
+      const outcome = fixtureOutcome(grade);
+      if (output === null || outcome === null) continue;
+      fixtures.push({ id: `fixture-${kind}-${admission.taskId}`, taskId: admission.taskId, label: outcome.passed ? "positive" : "negative", output, infrastructureError: null, expectedPassed: outcome.passed, expectedRewardEligible: outcome.rewardEligible, metadata: { gradeReceiptHash: grade.contentHash, evidence: admission.evidence, decision: admission.decision } });
+    }
+  }
+  if (!fixtures.length) throw new Error("Grade at least one reviewed response before preparing this batch. Grader fixtures must come from actual receipts.");
+  const graders = projectLearningBatchGraders(input.binding, input.rewards, input.assets);
+  const generatedFiles = [];
+  for (const grader of release.graders) {
+    if (grader.kind !== "custom_verifier") continue;
+    const asset = input.assets?.find((asset2) => asset2.id === grader.verifierRef.id);
+    if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable verifier source.`);
+    const module = learningVerifierModule(grader.verifierRef.contentHash);
+    if (!generatedFiles.some((file) => file.path === module)) generatedFiles.push({ path: module, role: "verifier", content: verifyLearningTextAsset(asset, grader.verifierRef) });
+  }
+  const taskset = TasksetSchema.parse({
+    schemaVersion: "openpond.taskset.v1",
+    id: `learning-${contentHash([input.profileId, input.batch.contentHash]).slice(0, 40)}`,
+    revision: 1,
+    profileId: input.profileId,
+    profileRelease: null,
+    createImproveRunId: null,
+    name: `${input.definition.name} \xB7 ${input.batch.examples.length} approved examples`,
+    objective: input.definition.instructions,
+    purpose: "general",
+    benchmark: null,
+    status: "needs_review",
+    sourceRefs: [input.source],
+    datasetArtifact: null,
+    policy: release.policy,
+    environment: { protocolVersion: "openpond.taskEnvironment.v1", kind: "chat", entrypoint: "openpond.text.v1", stateful: false, deterministicSeeds: release.environment.deterministicSeeds, toolNames: [], lifecycle: ["create", "reset", "step", "grade", "cleanup"], defaultTimeoutMs: release.environment.defaultTimeoutMs, networkPolicy: release.environment.networkPolicy, metadata: { portableEnvironment: release.environment } },
+    capabilities: { schemaVersion: "openpond.tasksetCapabilities.v1", taskKind: "chat", supportedSignals: signals.demonstrations.length ? ["demonstration", "reward"] : ["reward"], compatibleMethods: input.batch.purpose === "supervised_training" ? ["sft"] : input.batch.purpose === "reward_training" ? ["grpo", "ppo"] : ["none"], rewardKinds: ["deterministic"], requiresTools: false, requiresState: false, requiresPrivilegedGrading: true, environmentPlacements: ["local", "remote"], exportable: true, portabilityBlockers: [] },
+    tasks: release.tasks.map(({ artifactRefs: _assets, ...task }) => ({ ...task, schemaVersion: "openpond.taskData.v1", sourceRefs: [sourceId], metadata: { admission: metadata.admissions.find((entry) => entry.taskId === task.id), exampleOrigin: input.evidence.find((evidence) => evidence.id === task.id)?.correctionFeedbackId ? "corrected" : "extracted" } })),
+    graders,
+    graderFixtures: fixtures,
+    learningSignals: signals,
+    authoringProvenance: { schemaVersion: "openpond.taskAuthoringProvenance.v1", model: null, modelConfig: {}, skillHash: contentHash("openpond-learning-batch-v1"), promptTemplateVersion: "learning-batch-v1", buildIntent: input.batch.purpose === "supervised_training" ? "demonstrations" : "verifiable_reward", buildSpecification: null, evidenceHashes: input.batch.examples.map((entry) => entry.evidence.contentHash), tasksetSdkVersion: "learning-batch-v1", sourceCommit: null, repairHistory: [], createdAt: input.batch.sealedAt },
+    readiness: null,
+    contentHash: "00000000",
+    createdAt: input.batch.sealedAt,
+    updatedAt: input.batch.sealedAt,
+    metadata: { learning: metadata, learningRelease: learningRef(release), trainingMethod: input.batch.purpose === "supervised_training" ? "sft" : input.batch.purpose === "reward_training" ? "grpo" : "none", tasksetOutputContract: { mode: "structured_json", jsonSchema: input.definition.outputSchema, renderer: null } }
+  });
+  return { taskset: TasksetSchema.parse({ ...taskset, contentHash: computeTasksetHash(taskset) }), release, generatedFiles };
+}
+function fixtureOutcome(grade) {
+  if (!grade) return null;
+  const outcome = grade.training.status === "not_configured" ? grade.evaluation : grade.training;
+  if (outcome.status !== "scored") return null;
+  return { passed: outcome.passed === true, rewardEligible: grade.training.status === "scored" };
+}
+
+// src/training-bundle.ts
+function buildTasksetTrainingBundle(input) {
+  const { taskset, modelProject, harnessRelease, tasksetRelease } = input;
+  const setup = modelProject.trainingSetup;
+  const releasedHarness = ImmutableReleaseRefSchema.parse(harnessRelease);
+  const releasedTaskset = ImmutableReleaseRefSchema.parse(tasksetRelease);
+  void input.openpondRelease;
+  void input.workerProtocol;
+  const actualTasksetHash = computeTasksetHash(taskset);
+  if (actualTasksetHash !== taskset.contentHash) {
+    throw new Error(
+      "Taskset authoring state changed after its release was selected."
+    );
+  }
+  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 ?? {
+    id: `profile_${taskset.profileId}`,
+    revision: taskset.revision,
+    contentHash: contentHash({
+      profileId: taskset.profileId,
+      sourceCommit: taskset.authoringProvenance.sourceCommit,
+      skillHash: taskset.authoringProvenance.skillHash
+    })
+  };
+  const assets = /* @__PURE__ */ new Map();
+  if (input.evaluationSource) {
+    const evaluation = TrainingEvaluationSourceSchema.parse(input.evaluationSource);
+    if (contentHash(evaluation.taskset) !== contentHash(setup.evaluationTasksetRef)) {
+      throw new Error("The evaluation source differs from the prepared Model configuration.");
+    }
+    assertTrainingEvaluationIsolation(taskset.tasks.filter((task) => task.split === "train"), evaluation.tasks);
+    assets.set(TRAINING_EVALUATION_SOURCE_PATH, new TextEncoder().encode(canonicalJson(evaluation)));
+  } else if (setup.evaluationTasksetRef) {
+    throw new Error("The prepared Model requires its pinned evaluation source bytes.");
+  }
+  const harnessSource = input.harnessSource ? validateHarnessSourcePackage(input.harnessSource, releasedHarness) : null;
+  if (setup.harnessRelease && !harnessSource) {
+    throw new Error("A selected Harness requires its complete immutable source package.");
+  }
+  if (harnessSource && (!setup.harnessRelease || setup.harnessRelease.id !== releasedHarness.id || setup.harnessRelease.contentHash !== releasedHarness.contentHash)) {
+    throw new Error("Harness source differs from the Model's explicit selection.");
+  }
+  if (harnessSource) {
+    const leavesLocalHost = input.runtime.placement !== "local" || input.compute.kind !== "local";
+    if (leavesLocalHost && (!harnessSource.agentSnapshot.portability.portable || harnessSource.harnessRelease.files.some((file) => file.visibility === "host_private"))) {
+      throw new Error("The selected Harness contains source that cannot leave its local host.");
+    }
+    addJsonAsset(assets, "harness/source-package.json", harnessSource);
+  }
+  addJsonAsset(assets, "harness/execution.json", HarnessSourceSelectionSchema.parse({
+    schemaVersion: "openpond.harnessSourceSelection.v1",
+    mode: harnessSource ? "selected_release" : "taskset_owned",
+    harnessRelease: releasedHarness,
+    sourcePackageHash: harnessSource?.contentHash ?? null
+  }));
+  const rewardExecution = resolvePortableTasksetRewardExecution(taskset, input.rewardExecution);
+  if (rewardExecution) {
+    const verifierAssets = input.verifierAssets ?? [];
+    const references = compileBoundGraders(rewardExecution.binding, rewardExecution.rewards).flatMap((grader) => grader.kind === "custom_verifier" ? [grader.verifierRef] : []);
+    const expected = new Set(references.map((reference) => reference.id));
+    if (new Set(verifierAssets.map((asset) => asset.id)).size !== verifierAssets.length || verifierAssets.some((asset) => !expected.has(asset.id))) throw new Error("Unexpected or duplicate private verifier asset.");
+    for (const reference of references) {
+      const asset = verifierAssets.find((asset2) => asset2.id === reference.id);
+      if (!asset || reference.visibility !== "verifier") throw new Error("Training bundle requires its private verifier asset.");
+      verifyLearningTextAsset2(asset, reference);
+    }
+    addJsonAsset(assets, "reward-binding.json", { kind: "reward_binding_v1", binding: rewardExecution.binding, rewards: rewardExecution.rewards, assets: verifierAssets });
+  } else if (input.verifierAssets?.length) {
+    throw new Error("Private verifier assets require a published Reward binding.");
+  }
+  addJsonAsset(assets, "environment.json", {
+    schemaVersion: "openpond.harnessEnvironment.v1",
+    environment: taskset.environment,
+    capabilities: taskset.capabilities,
+    policy: taskset.policy,
+    outputContract: taskset.metadata.tasksetOutputContract?.mode === "text" ? null : taskset.metadata.tasksetOutputContract ?? null
+  });
+  addJsonAsset(assets, "graders.json", {
+    schemaVersion: "openpond.harnessGraders.v1",
+    graders: taskset.graders,
+    fixtures: taskset.graderFixtures
+  });
+  addJsonAsset(assets, "tool-contract.json", {
+    schemaVersion: "openpond.harnessToolContract.v1",
+    toolNames: taskset.environment.toolNames,
+    actionBindings: taskset.environment.actionBindings ?? [],
+    capabilities: taskset.capabilities,
+    connectedAppScopes: taskset.policy.connectedAppScopes
+  });
+  const trainTasks = taskset.tasks.filter((task) => task.split === "train");
+  if (trainTasks.length > 0) {
+    addJsonAsset(assets, "dataset/train.json", {
+      schemaVersion: "openpond.datasetSplit.v1",
+      split: "train",
+      tasks: trainTasks
+    });
+    addTasksetAssets({
+      assets,
+      tasks: trainTasks,
+      tasksetAssetBytes: input.tasksetAssetBytes ?? /* @__PURE__ */ new Map()
+    });
+  } else if (taskset.datasetArtifact) {
+    addJsonAsset(assets, "dataset/artifact.json", taskset.datasetArtifact);
+  } else {
+    throw new Error("Taskset has no training dataset.");
+  }
+  const approvedSignals = Object.values(taskset.learningSignals).flat().filter((signal) => signal.approved);
+  for (const signal of approvedSignals) {
+    const value = bytes(signal);
+    assets.set(`evidence/signals/${sha256(value)}.json`, value);
+  }
+  const datasetRelease = {
+    id: `dataset_${taskset.id}_r${taskset.revision}`,
+    contentHash: contentHash({
+      taskset: releasedTaskset,
+      sourceRefs: taskset.sourceRefs,
+      datasetArtifact: taskset.datasetArtifact ?? null,
+      trainTasks
+    })
+  };
+  const evidenceSetRelease = approvedSignals.length > 0 ? {
+    id: `evidence_${taskset.id}_r${taskset.revision}`,
+    contentHash: contentHash({
+      taskset: releasedTaskset,
+      harnessRelease: releasedHarness,
+      datasetRelease,
+      profileRelease,
+      signals: approvedSignals
+    })
+  } : null;
+  const bundleContent = ResolvedTrainingBundleContentSchema.parse({
+    schemaVersion: "openpond.resolvedTrainingBundle.v1",
+    projection: "trainer",
+    harnessRelease: releasedHarness,
+    datasetRelease,
+    evidenceSetRelease,
+    files: [...assets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([assetPath, value]) => ({
+      path: assetPath,
+      sha256: sha256(value),
+      sizeBytes: value.byteLength
+    }))
+  });
+  const resolvedBundleManifest = ResolvedTrainingBundleManifestSchema.parse({
+    ...bundleContent,
+    contentHash: contentHash(bundleContent)
+  });
+  const manifestContent = HarnessRunManifestContentSchema.parse({
+    schemaVersion: "openpond.harnessRunManifest.v1",
+    id: `manifest_${input.modelRunId}_${input.approval.approvalHash.slice(0, 16)}`,
+    harnessRelease,
+    datasetRelease,
+    evidenceSets: evidenceSetRelease ? [evidenceSetRelease] : [],
+    model: {
+      source: setup.baseModel.modelId,
+      revision: setup.baseModel.revision,
+      artifactHash: null,
+      tokenizerRevision: setup.baseModel.tokenizerRevision,
+      chatTemplateHash: setup.baseModel.chatTemplateHash
+    },
+    recipe: {
+      method: setup.recipe.method,
+      version: "openpond.trainingRecipe.v1",
+      configHash: contentHash(setup.recipe)
+    },
+    runtimeTarget: input.runtime,
+    computeTarget: input.compute,
+    engine: input.engine,
+    resolvedBundleHash: resolvedBundleManifest.contentHash,
+    secretLeaseRefs: input.secretLeaseRefs ?? [],
+    approval: input.approval,
+    createdAt: modelProject.updatedAt
+  });
+  const manifest = HarnessRunManifestSchema.parse({
+    ...manifestContent,
+    contentHash: contentHash(manifestContent)
+  });
+  return {
+    manifest,
+    resolvedBundleManifest,
+    assets,
+    profileRelease,
+    harnessRelease: releasedHarness,
+    tasksetRelease: releasedTaskset,
+    datasetRelease,
+    evidenceSetRelease
+  };
+}
+function addTasksetAssets(input) {
+  const expected = /* @__PURE__ */ new Set();
+  for (const task of input.tasks) {
+    for (const asset of task.assets ?? []) {
+      if (expected.has(asset.artifactRef)) {
+        throw new Error(
+          `Training asset path ${asset.artifactRef} is shared by multiple tasks.`
+        );
+      }
+      expected.add(asset.artifactRef);
+      const value = input.tasksetAssetBytes.get(asset.artifactRef);
+      if (!value) {
+        throw new Error(
+          `Resolved Training Bundle is missing Work asset ${asset.artifactRef}.`
+        );
+      }
+      if (value.byteLength !== asset.sizeBytes || sha256(value) !== asset.sha256) {
+        throw new Error(
+          `Resolved Training Bundle Work asset ${asset.artifactRef} failed immutable verification.`
+        );
+      }
+      input.assets.set(asset.artifactRef, value);
+    }
+  }
+  for (const assetPath of input.tasksetAssetBytes.keys()) {
+    if (!expected.has(assetPath)) {
+      throw new Error(
+        `Resolved Training Bundle received unexpected Work asset ${assetPath}.`
+      );
+    }
+  }
+}
+function addJsonAsset(assets, assetPath, value) {
+  assets.set(assetPath, bytes(value));
+}
+function bytes(value) {
+  return Buffer.from(canonicalJson(value), "utf8");
+}
+export {
+  ComputeTargetBindingSchema,
+  HarnessRunManifestContentSchema,
+  HarnessRunManifestSchema,
+  HarnessRuntimeTargetBindingSchema,
+  OpaqueSecretLeaseRefSchema,
+  ResolvedTrainingBundleContentSchema,
+  ResolvedTrainingBundleManifestSchema,
+  ScopedSecretDeclarationSchema,
+  TrainingEngineBindingSchema,
+  buildTasksetTrainingBundle,
+  materializeLearningBatchTaskset
+};
+//# sourceMappingURL=training-bundle.js.map

package/dist/training-bundle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/training-bundle.ts", "../src/training-bundle-contracts.ts", "../src/training-learning-batch.ts"],
+  "sourcesContent": ["import { canonicalJson, contentHash, sha256, ImmutableReleaseRefSchema, HarnessSourceSelectionSchema, validateHarnessSourcePackage, type HarnessSourcePackage, type ImmutableReleaseRef, type VersionedReleaseRef } from \"@openpond/harness\";\nimport { compileBoundGraders } from \"@openpond/evals/rewards\";\nimport { verifyLearningTextAsset, type LearningTextAsset } from \"@openpond/evals/learning\";\nimport { HarnessRunManifestContentSchema, HarnessRunManifestSchema, ResolvedTrainingBundleContentSchema, ResolvedTrainingBundleManifestSchema, type ComputeTargetBinding, type HarnessRunManifest, type HarnessRuntimeTargetBinding, type OpaqueSecretLeaseRef, type ResolvedTrainingBundleManifest, type TrainingEngineBinding } from \"./training-bundle-contracts.js\";\nimport type { ModelProject } from \"./model-projects.js\";\nimport type { Taskset } from \"./taskset-authored-contracts.js\";\nimport { computeTasksetHash } from \"./taskset-authored-validation.js\";\nimport { resolvePortableTasksetRewardExecution, type TasksetRewardExecution } from \"./taskset-authored-portable-release.js\";\nimport { TRAINING_EVALUATION_SOURCE_PATH, TrainingEvaluationSourceSchema, assertTrainingEvaluationIsolation, type TrainingEvaluationSource } from \"./training-evaluation-source.js\";\n\nexport * from \"./training-bundle-contracts.js\";\nexport { materializeLearningBatchTaskset } from \"./training-learning-batch.js\";\n\nexport type TasksetTrainingBundle = {\n  manifest: HarnessRunManifest;\n  resolvedBundleManifest: ResolvedTrainingBundleManifest;\n  assets: ReadonlyMap<string, Uint8Array>;\n  profileRelease: VersionedReleaseRef;\n  harnessRelease: ImmutableReleaseRef;\n  tasksetRelease: ImmutableReleaseRef;\n  datasetRelease: ImmutableReleaseRef;\n  evidenceSetRelease: ImmutableReleaseRef | null;\n};\n\n/**\n * Produces the one artifact the training worker consumes. The release refs in\n * the manifest are immutable lineage identifiers, not separately materialized\n * release objects.\n */\nexport function buildTasksetTrainingBundle(input: {\n  taskset: Taskset;\n  modelProject: ModelProject;\n  modelRunId: string;\n  runtime: HarnessRuntimeTargetBinding;\n  compute: ComputeTargetBinding;\n  engine: TrainingEngineBinding;\n  approval: {\n    approvalHash: string;\n    approvedAt: string;\n    maximumSpendUsd: number | null;\n  };\n  secretLeaseRefs?: OpaqueSecretLeaseRef[];\n  openpondRelease: string;\n  workerProtocol: string;\n  harnessRelease: ImmutableReleaseRef;\n  tasksetRelease: ImmutableReleaseRef;\n  harnessSource?: HarnessSourcePackage | null;\n  tasksetAssetBytes?: ReadonlyMap<string, Uint8Array>;\n  rewardExecution?: TasksetRewardExecution;\n  verifierAssets?: LearningTextAsset[];\n  evaluationSource?: TrainingEvaluationSource;\n}): TasksetTrainingBundle {\n  const { taskset, modelProject, harnessRelease, tasksetRelease } = input;\n  const setup = modelProject.trainingSetup;\n  const releasedHarness = ImmutableReleaseRefSchema.parse(harnessRelease);\n  const releasedTaskset = ImmutableReleaseRefSchema.parse(tasksetRelease);\n  // These remain part of the preparation API for adapter compatibility; the\n  // selected Harness release is now supplied explicitly and is never rebuilt\n  // from mutable Profile/Taskset state here.\n  void input.openpondRelease;\n  void input.workerProtocol;\n  const actualTasksetHash = computeTasksetHash(taskset);\n  if (actualTasksetHash !== taskset.contentHash) {\n    throw new Error(\n      \"Taskset authoring state changed after its release was selected.\",\n    );\n  }\n  if (\n    !setup.baseModel?.revision ||\n    !setup.baseModel.tokenizerRevision ||\n    !setup.baseModel.chatTemplateHash ||\n    !setup.recipe ||\n    !setup.tasksetRef ||\n    setup.tasksetRef.id !== taskset.id ||\n    setup.tasksetRef.contentHash !== taskset.contentHash\n  ) {\n    throw new Error(\n      \"Model Run must bind an exact Taskset, Model revision, tokenizer, chat template, and Recipe.\",\n    );\n  }\n\n  const profileRelease = taskset.profileRelease ?? {\n    id: `profile_${taskset.profileId}`,\n    revision: taskset.revision,\n    contentHash: contentHash({\n      profileId: taskset.profileId,\n      sourceCommit: taskset.authoringProvenance.sourceCommit,\n      skillHash: taskset.authoringProvenance.skillHash,\n    }),\n  };\n  const assets = new Map<string, Uint8Array>();\n  if (input.evaluationSource) {\n    const evaluation = TrainingEvaluationSourceSchema.parse(input.evaluationSource);\n    if (contentHash(evaluation.taskset) !== contentHash(setup.evaluationTasksetRef)) {\n      throw new Error(\"The evaluation source differs from the prepared Model configuration.\");\n    }\n    assertTrainingEvaluationIsolation(taskset.tasks.filter(task => task.split === \"train\"), evaluation.tasks);\n    assets.set(TRAINING_EVALUATION_SOURCE_PATH, new TextEncoder().encode(canonicalJson(evaluation)));\n  } else if (setup.evaluationTasksetRef) {\n    throw new Error(\"The prepared Model requires its pinned evaluation source bytes.\");\n  }\n  const harnessSource = input.harnessSource\n    ? validateHarnessSourcePackage(input.harnessSource, releasedHarness)\n    : null;\n  if (setup.harnessRelease && !harnessSource) {\n    throw new Error(\"A selected Harness requires its complete immutable source package.\");\n  }\n  if (harnessSource && (!setup.harnessRelease\n    || setup.harnessRelease.id !== releasedHarness.id\n    || setup.harnessRelease.contentHash !== releasedHarness.contentHash)) {\n    throw new Error(\"Harness source differs from the Model's explicit selection.\");\n  }\n  if (harnessSource) {\n    const leavesLocalHost = input.runtime.placement !== \"local\" || input.compute.kind !== \"local\";\n    if (leavesLocalHost && (!harnessSource.agentSnapshot.portability.portable\n      || harnessSource.harnessRelease.files.some(file => file.visibility === \"host_private\"))) {\n      throw new Error(\"The selected Harness contains source that cannot leave its local host.\");\n    }\n    addJsonAsset(assets, \"harness/source-package.json\", harnessSource);\n  }\n  addJsonAsset(assets, \"harness/execution.json\", HarnessSourceSelectionSchema.parse({\n    schemaVersion: \"openpond.harnessSourceSelection.v1\",\n    mode: harnessSource ? \"selected_release\" : \"taskset_owned\",\n    harnessRelease: releasedHarness,\n    sourcePackageHash: harnessSource?.contentHash ?? null,\n  }));\n  const rewardExecution = resolvePortableTasksetRewardExecution(taskset, input.rewardExecution);\n  if (rewardExecution) {\n    const verifierAssets = input.verifierAssets ?? [];\n    const references = compileBoundGraders(rewardExecution.binding, rewardExecution.rewards)\n      .flatMap(grader => grader.kind === \"custom_verifier\" ? [grader.verifierRef] : []);\n    const expected = new Set(references.map(reference => reference.id));\n    if (new Set(verifierAssets.map(asset => asset.id)).size !== verifierAssets.length\n      || verifierAssets.some(asset => !expected.has(asset.id))) throw new Error(\"Unexpected or duplicate private verifier asset.\");\n    for (const reference of references) {\n      const asset = verifierAssets.find(asset => asset.id === reference.id);\n      if (!asset || reference.visibility !== \"verifier\") throw new Error(\"Training bundle requires its private verifier asset.\");\n      verifyLearningTextAsset(asset, reference);\n    }\n    addJsonAsset(assets, \"reward-binding.json\", { kind: \"reward_binding_v1\", binding: rewardExecution.binding, rewards: rewardExecution.rewards, assets: verifierAssets });\n  } else if (input.verifierAssets?.length) {\n    throw new Error(\"Private verifier assets require a published Reward binding.\");\n  }\n  addJsonAsset(assets, \"environment.json\", {\n    schemaVersion: \"openpond.harnessEnvironment.v1\",\n    environment: taskset.environment,\n    capabilities: taskset.capabilities,\n    policy: taskset.policy,\n    outputContract:\n      (taskset.metadata.tasksetOutputContract as { mode?: unknown } | undefined)\n        ?.mode === \"text\"\n        ? null\n        : taskset.metadata.tasksetOutputContract ?? null,\n  });\n  addJsonAsset(assets, \"graders.json\", {\n    schemaVersion: \"openpond.harnessGraders.v1\",\n    graders: taskset.graders,\n    fixtures: taskset.graderFixtures,\n  });\n  addJsonAsset(assets, \"tool-contract.json\", {\n    schemaVersion: \"openpond.harnessToolContract.v1\",\n    toolNames: taskset.environment.toolNames,\n    actionBindings: taskset.environment.actionBindings ?? [],\n    capabilities: taskset.capabilities,\n    connectedAppScopes: taskset.policy.connectedAppScopes,\n  });\n  const trainTasks = taskset.tasks.filter((task) => task.split === \"train\");\n  if (trainTasks.length > 0) {\n    addJsonAsset(assets, \"dataset/train.json\", {\n      schemaVersion: \"openpond.datasetSplit.v1\",\n      split: \"train\",\n      tasks: trainTasks,\n    });\n    addTasksetAssets({\n      assets,\n      tasks: trainTasks,\n      tasksetAssetBytes: input.tasksetAssetBytes ?? new Map(),\n    });\n  } else if (taskset.datasetArtifact) {\n    addJsonAsset(assets, \"dataset/artifact.json\", taskset.datasetArtifact);\n  } else {\n    throw new Error(\"Taskset has no training dataset.\");\n  }\n\n  const approvedSignals = Object.values(taskset.learningSignals)\n    .flat()\n    .filter((signal) => signal.approved);\n  for (const signal of approvedSignals) {\n    const value = bytes(signal);\n    assets.set(`evidence/signals/${sha256(value)}.json`, value);\n  }\n\n  const datasetRelease = {\n    id: `dataset_${taskset.id}_r${taskset.revision}`,\n    contentHash: contentHash({\n      taskset: releasedTaskset,\n      sourceRefs: taskset.sourceRefs,\n      datasetArtifact: taskset.datasetArtifact ?? null,\n      trainTasks,\n    }),\n  };\n  const evidenceSetRelease =\n    approvedSignals.length > 0\n      ? {\n          id: `evidence_${taskset.id}_r${taskset.revision}`,\n          contentHash: contentHash({\n            taskset: releasedTaskset,\n            harnessRelease: releasedHarness,\n            datasetRelease,\n            profileRelease,\n            signals: approvedSignals,\n          }),\n        }\n      : null;\n\n  const bundleContent = ResolvedTrainingBundleContentSchema.parse({\n    schemaVersion: \"openpond.resolvedTrainingBundle.v1\",\n    projection: \"trainer\",\n    harnessRelease: releasedHarness,\n    datasetRelease,\n    evidenceSetRelease,\n    files: [...assets.entries()]\n      .sort(([left], [right]) => left.localeCompare(right))\n      .map(([assetPath, value]) => ({\n        path: assetPath,\n        sha256: sha256(value),\n        sizeBytes: value.byteLength,\n      })),\n  });\n  const resolvedBundleManifest = ResolvedTrainingBundleManifestSchema.parse({\n    ...bundleContent,\n    contentHash: contentHash(bundleContent),\n  });\n  const manifestContent = HarnessRunManifestContentSchema.parse({\n    schemaVersion: \"openpond.harnessRunManifest.v1\",\n    id: `manifest_${input.modelRunId}_${input.approval.approvalHash.slice(0, 16)}`,\n    harnessRelease,\n    datasetRelease,\n    evidenceSets: evidenceSetRelease ? [evidenceSetRelease] : [],\n    model: {\n      source: setup.baseModel.modelId,\n      revision: setup.baseModel.revision,\n      artifactHash: null,\n      tokenizerRevision: setup.baseModel.tokenizerRevision,\n      chatTemplateHash: setup.baseModel.chatTemplateHash,\n    },\n    recipe: {\n      method: setup.recipe.method,\n      version: \"openpond.trainingRecipe.v1\",\n      configHash: contentHash(setup.recipe),\n    },\n    runtimeTarget: input.runtime,\n    computeTarget: input.compute,\n    engine: input.engine,\n    resolvedBundleHash: resolvedBundleManifest.contentHash,\n    secretLeaseRefs: input.secretLeaseRefs ?? [],\n    approval: input.approval,\n    createdAt: modelProject.updatedAt,\n  });\n  const manifest = HarnessRunManifestSchema.parse({\n    ...manifestContent,\n    contentHash: contentHash(manifestContent),\n  });\n  return {\n    manifest,\n    resolvedBundleManifest,\n    assets,\n    profileRelease,\n    harnessRelease: releasedHarness,\n    tasksetRelease: releasedTaskset,\n    datasetRelease,\n    evidenceSetRelease,\n  };\n}\n\nfunction addTasksetAssets(input: {\n  assets: Map<string, Uint8Array>;\n  tasks: Taskset[\"tasks\"];\n  tasksetAssetBytes: ReadonlyMap<string, Uint8Array>;\n}): void {\n  const expected = new Set<string>();\n  for (const task of input.tasks) {\n    for (const asset of task.assets ?? []) {\n      if (expected.has(asset.artifactRef)) {\n        throw new Error(\n          `Training asset path ${asset.artifactRef} is shared by multiple tasks.`,\n        );\n      }\n      expected.add(asset.artifactRef);\n      const value = input.tasksetAssetBytes.get(asset.artifactRef);\n      if (!value) {\n        throw new Error(\n          `Resolved Training Bundle is missing Work asset ${asset.artifactRef}.`,\n        );\n      }\n      if (value.byteLength !== asset.sizeBytes || sha256(value) !== asset.sha256) {\n        throw new Error(\n          `Resolved Training Bundle Work asset ${asset.artifactRef} failed immutable verification.`,\n        );\n      }\n      input.assets.set(asset.artifactRef, value);\n    }\n  }\n  for (const assetPath of input.tasksetAssetBytes.keys()) {\n    if (!expected.has(assetPath)) {\n      throw new Error(\n        `Resolved Training Bundle received unexpected Work asset ${assetPath}.`,\n      );\n    }\n  }\n}\n\nfunction addJsonAsset(\n  assets: Map<string, Uint8Array>,\n  assetPath: string,\n  value: unknown,\n): void {\n  assets.set(assetPath, bytes(value));\n}\n\nfunction bytes(value: unknown): Uint8Array {\n  return Buffer.from(canonicalJson(value), \"utf8\");\n}\n", "import { z } from \"zod\";\nimport { ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from \"@openpond/harness\";\n\nexport const ScopedSecretDeclarationSchema = z\n  .object({\n    id: ReleaseIdSchema,\n    purpose: z.string().trim().min(1).max(500),\n    audience: z.enum([\n      \"orchestrator\",\n      \"environment\",\n      \"privileged_scorer\",\n      \"trainer\",\n      \"infrastructure\",\n    ]),\n    required: z.boolean(),\n    ttlSeconds: z.number().int().positive().max(86_400),\n    scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([]),\n  })\n  .strict();\n\nexport const OpaqueSecretLeaseRefSchema = z\n  .object({\n    declarationId: ReleaseIdSchema,\n    leaseRef: z.string().trim().min(8).max(1_000),\n    audience: ScopedSecretDeclarationSchema.shape.audience,\n    expiresAt: ReleaseTimestampSchema,\n  })\n  .strict();\n\nexport type ScopedSecretDeclaration = z.infer<\n  typeof ScopedSecretDeclarationSchema\n>;\nexport type OpaqueSecretLeaseRef = z.infer<typeof OpaqueSecretLeaseRefSchema>;\n\nexport const HarnessRuntimeTargetBindingSchema = z\n  .object({\n    adapterId: ReleaseIdSchema,\n    placement: z.enum([\"local\", \"remote\", \"colocated\", \"provider_native\"]),\n    capabilityReceipt: ReleaseHashSchema,\n    runtimeVersion: z.string().trim().min(1).max(200),\n    dataPlane: z\n      .object({\n        provider: ReleaseIdSchema,\n        dataPlaneId: ReleaseIdSchema,\n        cellId: ReleaseIdSchema,\n        runnerPoolId: ReleaseIdSchema,\n        runtimeImageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),\n        capabilityReceipt: ReleaseHashSchema,\n      })\n      .strict()\n      .nullable(),\n  })\n  .strict();\n\nexport const ComputeTargetBindingSchema = z\n  .object({\n    adapterId: ReleaseIdSchema,\n    kind: z.enum([\"local\", \"ssh\", \"managed\", \"custom\"]),\n    deviceOrPool: z.string().trim().min(1).max(1_000),\n    capabilityReceipt: ReleaseHashSchema,\n    provider: ReleaseIdSchema.nullable(),\n  })\n  .strict();\n\nexport const TrainingEngineBindingSchema = z\n  .object({\n    adapterId: ReleaseIdSchema,\n    workerVersion: z.string().trim().min(1).max(200),\n    workerImageDigest: z\n      .string()\n      .regex(/^sha256:[a-f0-9]{64}$/)\n      .nullable(),\n    upstreamRevision: z.string().trim().min(1).max(500),\n    capabilityReceipt: ReleaseHashSchema,\n  })\n  .strict();\n\nexport const HarnessRunManifestContentSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.harnessRunManifest.v1\"),\n    id: ReleaseIdSchema,\n    harnessRelease: ImmutableReleaseRefSchema,\n    datasetRelease: ImmutableReleaseRefSchema,\n    evidenceSets: z.array(ImmutableReleaseRefSchema).max(10_000),\n    model: z\n      .object({\n        source: z.string().trim().min(1).max(200),\n        revision: z.string().trim().min(1).max(500),\n        artifactHash: ReleaseHashSchema.nullable(),\n        tokenizerRevision: z.string().trim().min(1).max(500),\n        chatTemplateHash: ReleaseHashSchema,\n      })\n      .strict(),\n    recipe: z\n      .object({\n        method: z.string().trim().min(1).max(100),\n        version: z.string().trim().min(1).max(200),\n        configHash: ReleaseHashSchema,\n      })\n      .strict(),\n    runtimeTarget: HarnessRuntimeTargetBindingSchema,\n    computeTarget: ComputeTargetBindingSchema,\n    engine: TrainingEngineBindingSchema,\n    resolvedBundleHash: ReleaseHashSchema,\n    secretLeaseRefs: z.array(OpaqueSecretLeaseRefSchema).max(1_000),\n    approval: z\n      .object({\n        approvalHash: ReleaseHashSchema,\n        approvedAt: ReleaseTimestampSchema,\n        maximumSpendUsd: z.number().nonnegative().nullable(),\n      })\n      .strict(),\n    createdAt: ReleaseTimestampSchema,\n  })\n  .strict();\n\nexport const HarnessRunManifestSchema = HarnessRunManifestContentSchema.extend({\n  contentHash: ReleaseHashSchema,\n}).strict();\n\nexport const ResolvedTrainingBundleContentSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.resolvedTrainingBundle.v1\"),\n    projection: z.literal(\"trainer\"),\n    harnessRelease: ImmutableReleaseRefSchema,\n    datasetRelease: ImmutableReleaseRefSchema,\n    evidenceSetRelease: ImmutableReleaseRefSchema.nullable(),\n    files: z\n      .array(\n        z\n          .object({\n            path: z.string().trim().min(1).max(2_000),\n            sha256: ReleaseHashSchema,\n            sizeBytes: z.number().int().nonnegative(),\n          })\n          .strict(),\n      )\n      .max(100_000),\n  })\n  .strict();\n\nexport const ResolvedTrainingBundleManifestSchema =\n  ResolvedTrainingBundleContentSchema.extend({\n    contentHash: ReleaseHashSchema,\n  }).strict();\n\nexport type HarnessRuntimeTargetBinding = z.infer<\n  typeof HarnessRuntimeTargetBindingSchema\n>;\nexport type ComputeTargetBinding = z.infer<typeof ComputeTargetBindingSchema>;\nexport type TrainingEngineBinding = z.infer<\n  typeof TrainingEngineBindingSchema\n>;\nexport type HarnessRunManifest = z.infer<typeof HarnessRunManifestSchema>;\nexport type ResolvedTrainingBundleManifest = z.infer<\n  typeof ResolvedTrainingBundleManifestSchema\n>;\n", "import { TasksetSchema, type GeneratedTaskFile } from \"./taskset-authored-contracts.js\";\nimport type { GraderFixture, LearningSignalInventory, TasksetSourceRef } from \"./taskset-draft-core.js\";\nimport { compileTaskBatch, learningRef, taskBatchPackageMetadata, verifyLearningTextAsset, type LearningTextAsset, type RewardBinding, type RewardComposition, type RewardRelease, type TaskAdmissionDecision, type TaskBatch, type TaskDefinition, type TaskEvidence } from \"@openpond/evals\";\nimport { computeTasksetHash } from \"./taskset-authored-validation.js\";\nimport { contentHash } from \"@openpond/harness\";\nimport { learningVerifierModule, projectLearningBatchGraders } from \"./taskset-package-grader-projection.js\";\n\n/** Projects a sealed batch into training inputs. The public batch compiler\n * rechecks every evidence/decision snapshot before adaptation. */\nexport function materializeLearningBatchTaskset(input: {\n  batch: TaskBatch; definition: TaskDefinition; binding: RewardBinding; rewards: RewardRelease[];\n  evidence: TaskEvidence[]; decisions: TaskAdmissionDecision[]; profileId: string;\n  source: TasksetSourceRef;\n  assets?: LearningTextAsset[];\n}) {\n  const release = compileTaskBatch(input);\n  const metadata = taskBatchPackageMetadata(release);\n  if (release.environment.kind !== \"text\" || release.tools.length || release.tasks.some((task) => task.artifactRefs.length)) throw new Error(\"This learning batch requires an environment or asset adapter before training preparation.\");\n  const sourceId = input.source.id;\n  const signals: LearningSignalInventory = { demonstrations: [], preferences: [], corrections: [], feedback: [], rewards: [], labels: [] };\n  const fixtures: GraderFixture[] = [];\n  for (const admission of metadata.admissions) {\n    const evidence = input.evidence.find((item) => item.id === admission.evidence.id)!;\n    const decision = input.decisions.find((item) => item.id === admission.decision.id)!;\n    if (input.batch.purpose === \"reward_training\" && decision.grade?.training.status === \"scored\") signals.rewards.push({\n      id: `reward-${admission.taskId}`, taskId: admission.taskId, kind: \"reward\", task: input.definition.instructions,\n      rules: [{ id: input.binding.id, points: 1, condition: \"Execute the released Reward binding with its declared normalization, weights and gates.\" }],\n      otherwisePoints: 0, executable: true, approved: true, confidence: 1, sourceRefs: [sourceId], artifactRef: input.binding.id,\n      metadata: { rewardBinding: learningRef(input.binding), evidence: admission.evidence, decision: admission.decision },\n    });\n    if (admission.supervisedTarget !== null) signals.demonstrations.push({ kind: \"demonstration\", id: `demo-${admission.taskId}`, taskId: admission.taskId, sourceRefs: [sourceId], artifactRef: admission.decision.id, approved: true, confidence: 1, prompt: null, response: JSON.stringify(admission.supervisedTarget), metadata: { evidence: admission.evidence, decision: admission.decision, targetGradeHash: decision.targetGrade?.contentHash } });\n    for (const [kind, output, grade] of [[\"observed\", evidence.submission.observedOutput, decision.grade], [\"target\", decision.approvedTarget, decision.targetGrade]] as const) {\n      const outcome = fixtureOutcome(grade);\n      if (output === null || outcome === null) continue;\n      fixtures.push({ id: `fixture-${kind}-${admission.taskId}`, taskId: admission.taskId, label: outcome.passed ? \"positive\" : \"negative\", output, infrastructureError: null, expectedPassed: outcome.passed, expectedRewardEligible: outcome.rewardEligible, metadata: { gradeReceiptHash: grade!.contentHash, evidence: admission.evidence, decision: admission.decision } });\n    }\n  }\n  if (!fixtures.length) throw new Error(\"Grade at least one reviewed response before preparing this batch. Grader fixtures must come from actual receipts.\");\n  const graders = projectLearningBatchGraders(input.binding, input.rewards, input.assets);\n  const generatedFiles: GeneratedTaskFile[] = [];\n  for (const grader of release.graders) {\n    if (grader.kind !== \"custom_verifier\") continue;\n    const asset = input.assets?.find((asset) => asset.id === grader.verifierRef.id);\n    if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable verifier source.`);\n    const module = learningVerifierModule(grader.verifierRef.contentHash);\n    if (!generatedFiles.some((file) => file.path === module)) generatedFiles.push({ path: module, role: \"verifier\", content: verifyLearningTextAsset(asset, grader.verifierRef) });\n  }\n  const taskset = TasksetSchema.parse({\n    schemaVersion: \"openpond.taskset.v1\", id: `learning-${contentHash([input.profileId, input.batch.contentHash]).slice(0, 40)}`, revision: 1,\n    profileId: input.profileId, profileRelease: null, createImproveRunId: null, name: `${input.definition.name} \u00B7 ${input.batch.examples.length} approved examples`, objective: input.definition.instructions,\n    purpose: \"general\", benchmark: null, status: \"needs_review\", sourceRefs: [input.source], datasetArtifact: null,\n    policy: release.policy,\n    environment: { protocolVersion: \"openpond.taskEnvironment.v1\", kind: \"chat\", entrypoint: \"openpond.text.v1\", stateful: false, deterministicSeeds: release.environment.deterministicSeeds, toolNames: [], lifecycle: [\"create\", \"reset\", \"step\", \"grade\", \"cleanup\"], defaultTimeoutMs: release.environment.defaultTimeoutMs, networkPolicy: release.environment.networkPolicy, metadata: { portableEnvironment: release.environment } },\n    capabilities: { schemaVersion: \"openpond.tasksetCapabilities.v1\", taskKind: \"chat\", supportedSignals: signals.demonstrations.length ? [\"demonstration\", \"reward\"] : [\"reward\"], compatibleMethods: input.batch.purpose === \"supervised_training\" ? [\"sft\"] : input.batch.purpose === \"reward_training\" ? [\"grpo\", \"ppo\"] : [\"none\"], rewardKinds: [\"deterministic\"], requiresTools: false, requiresState: false, requiresPrivilegedGrading: true, environmentPlacements: [\"local\", \"remote\"], exportable: true, portabilityBlockers: [] },\n    tasks: release.tasks.map(({ artifactRefs: _assets, ...task }) => ({ ...task, schemaVersion: \"openpond.taskData.v1\", sourceRefs: [sourceId], metadata: { admission: metadata.admissions.find((entry) => entry.taskId === task.id), exampleOrigin: input.evidence.find((evidence) => evidence.id === task.id)?.correctionFeedbackId ? \"corrected\" : \"extracted\" } })),\n    graders, graderFixtures: fixtures, learningSignals: signals,\n    authoringProvenance: { schemaVersion: \"openpond.taskAuthoringProvenance.v1\", model: null, modelConfig: {}, skillHash: contentHash(\"openpond-learning-batch-v1\"), promptTemplateVersion: \"learning-batch-v1\", buildIntent: input.batch.purpose === \"supervised_training\" ? \"demonstrations\" : \"verifiable_reward\", buildSpecification: null, evidenceHashes: input.batch.examples.map((entry) => entry.evidence.contentHash), tasksetSdkVersion: \"learning-batch-v1\", sourceCommit: null, repairHistory: [], createdAt: input.batch.sealedAt },\n    readiness: null, contentHash: \"00000000\", createdAt: input.batch.sealedAt, updatedAt: input.batch.sealedAt,\n    metadata: { learning: metadata, learningRelease: learningRef(release), trainingMethod: input.batch.purpose === \"supervised_training\" ? \"sft\" : input.batch.purpose === \"reward_training\" ? \"grpo\" : \"none\", tasksetOutputContract: { mode: \"structured_json\", jsonSchema: input.definition.outputSchema, renderer: null } },\n  });\n  return { taskset: TasksetSchema.parse({ ...taskset, contentHash: computeTasksetHash(taskset) }), release, generatedFiles };\n}\n\nfunction fixtureOutcome(grade: RewardComposition | null) {\n  if (!grade) return null;\n  const outcome = grade.training.status === \"not_configured\" ? grade.evaluation : grade.training;\n  if (outcome.status !== \"scored\") return null;\n  return { passed: outcome.passed === true, rewardEligible: grade.training.status === \"scored\" };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,2BAA2B;AACpC,SAAS,2BAAAA,gCAAuD;;;ACFhE,SAAS,SAAS;AAGX,IAAM,gCAAgC,EAC1C,OAAO;AAAA,EACN,IAAI;AAAA,EACJ,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EACzC,UAAU,EAAE,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAAA,EACD,UAAU,EAAE,QAAQ;AAAA,EACpB,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,KAAM;AAAA,EAClD,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,EAAE,QAAQ,CAAC,CAAC;AACxE,CAAC,EACA,OAAO;AAEH,IAAM,6BAA6B,EACvC,OAAO;AAAA,EACN,eAAe;AAAA,EACf,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAK;AAAA,EAC5C,UAAU,8BAA8B,MAAM;AAAA,EAC9C,WAAW;AACb,CAAC,EACA,OAAO;AAOH,IAAM,oCAAoC,EAC9C,OAAO;AAAA,EACN,WAAW;AAAA,EACX,WAAW,EAAE,KAAK,CAAC,SAAS,UAAU,aAAa,iBAAiB,CAAC;AAAA,EACrE,mBAAmB;AAAA,EACnB,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAChD,WAAW,EACR,OAAO;AAAA,IACN,UAAU;AAAA,IACV,aAAa;AAAA,IACb,QAAQ;AAAA,IACR,cAAc;AAAA,IACd,oBAAoB,EAAE,OAAO,EAAE,MAAM,uBAAuB;AAAA,IAC5D,mBAAmB;AAAA,EACrB,CAAC,EACA,OAAO,EACP,SAAS;AACd,CAAC,EACA,OAAO;AAEH,IAAM,6BAA6B,EACvC,OAAO;AAAA,EACN,WAAW;AAAA,EACX,MAAM,EAAE,KAAK,CAAC,SAAS,OAAO,WAAW,QAAQ,CAAC;AAAA,EAClD,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAK;AAAA,EAChD,mBAAmB;AAAA,EACnB,UAAU,gBAAgB,SAAS;AACrC,CAAC,EACA,OAAO;AAEH,IAAM,8BAA8B,EACxC,OAAO;AAAA,EACN,WAAW;AAAA,EACX,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAC/C,mBAAmB,EAChB,OAAO,EACP,MAAM,uBAAuB,EAC7B,SAAS;AAAA,EACZ,kBAAkB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAClD,mBAAmB;AACrB,CAAC,EACA,OAAO;AAEH,IAAM,kCAAkC,EAC5C,OAAO;AAAA,EACN,eAAe,EAAE,QAAQ,gCAAgC;AAAA,EACzD,IAAI;AAAA,EACJ,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,cAAc,EAAE,MAAM,yBAAyB,EAAE,IAAI,GAAM;AAAA,EAC3D,OAAO,EACJ,OAAO;AAAA,IACN,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,IACxC,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,IAC1C,cAAc,kBAAkB,SAAS;AAAA,IACzC,mBAAmB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,IACnD,kBAAkB;AAAA,EACpB,CAAC,EACA,OAAO;AAAA,EACV,QAAQ,EACL,OAAO;AAAA,IACN,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,IACxC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,IACzC,YAAY;AAAA,EACd,CAAC,EACA,OAAO;AAAA,EACV,eAAe;AAAA,EACf,eAAe;AAAA,EACf,QAAQ;AAAA,EACR,oBAAoB;AAAA,EACpB,iBAAiB,EAAE,MAAM,0BAA0B,EAAE,IAAI,GAAK;AAAA,EAC9D,UAAU,EACP,OAAO;AAAA,IACN,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,iBAAiB,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS;AAAA,EACrD,CAAC,EACA,OAAO;AAAA,EACV,WAAW;AACb,CAAC,EACA,OAAO;AAEH,IAAM,2BAA2B,gCAAgC,OAAO;AAAA,EAC7E,aAAa;AACf,CAAC,EAAE,OAAO;AAEH,IAAM,sCAAsC,EAChD,OAAO;AAAA,EACN,eAAe,EAAE,QAAQ,oCAAoC;AAAA,EAC7D,YAAY,EAAE,QAAQ,SAAS;AAAA,EAC/B,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,oBAAoB,0BAA0B,SAAS;AAAA,EACvD,OAAO,EACJ;AAAA,IACC,EACG,OAAO;AAAA,MACN,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAK;AAAA,MACxC,QAAQ;AAAA,MACR,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,IAC1C,CAAC,EACA,OAAO;AAAA,EACZ,EACC,IAAI,GAAO;AAChB,CAAC,EACA,OAAO;AAEH,IAAM,uCACX,oCAAoC,OAAO;AAAA,EACzC,aAAa;AACf,CAAC,EAAE,OAAO;;;AC9IZ,SAAS,kBAAkB,aAAa,0BAA0B,+BAA2M;AAOtQ,SAAS,gCAAgC,OAK7C;AACD,QAAM,UAAU,iBAAiB,KAAK;AACtC,QAAM,WAAW,yBAAyB,OAAO;AACjD,MAAI,QAAQ,YAAY,SAAS,UAAU,QAAQ,MAAM,UAAU,QAAQ,MAAM,KAAK,CAAC,SAAS,KAAK,aAAa,MAAM,EAAG,OAAM,IAAI,MAAM,2FAA2F;AACtO,QAAM,WAAW,MAAM,OAAO;AAC9B,QAAM,UAAmC,EAAE,gBAAgB,CAAC,GAAG,aAAa,CAAC,GAAG,aAAa,CAAC,GAAG,UAAU,CAAC,GAAG,SAAS,CAAC,GAAG,QAAQ,CAAC,EAAE;AACvI,QAAM,WAA4B,CAAC;AACnC,aAAW,aAAa,SAAS,YAAY;AAC3C,UAAM,WAAW,MAAM,SAAS,KAAK,CAAC,SAAS,KAAK,OAAO,UAAU,SAAS,EAAE;AAChF,UAAM,WAAW,MAAM,UAAU,KAAK,CAAC,SAAS,KAAK,OAAO,UAAU,SAAS,EAAE;AACjF,QAAI,MAAM,MAAM,YAAY,qBAAqB,SAAS,OAAO,SAAS,WAAW,SAAU,SAAQ,QAAQ,KAAK;AAAA,MAClH,IAAI,UAAU,UAAU,MAAM;AAAA,MAAI,QAAQ,UAAU;AAAA,MAAQ,MAAM;AAAA,MAAU,MAAM,MAAM,WAAW;AAAA,MACnG,OAAO,CAAC,EAAE,IAAI,MAAM,QAAQ,IAAI,QAAQ,GAAG,WAAW,0FAA0F,CAAC;AAAA,MACjJ,iBAAiB;AAAA,MAAG,YAAY;AAAA,MAAM,UAAU;AAAA,MAAM,YAAY;AAAA,MAAG,YAAY,CAAC,QAAQ;AAAA,MAAG,aAAa,MAAM,QAAQ;AAAA,MACxH,UAAU,EAAE,eAAe,YAAY,MAAM,OAAO,GAAG,UAAU,UAAU,UAAU,UAAU,UAAU,SAAS;AAAA,IACpH,CAAC;AACD,QAAI,UAAU,qBAAqB,KAAM,SAAQ,eAAe,KAAK,EAAE,MAAM,iBAAiB,IAAI,QAAQ,UAAU,MAAM,IAAI,QAAQ,UAAU,QAAQ,YAAY,CAAC,QAAQ,GAAG,aAAa,UAAU,SAAS,IAAI,UAAU,MAAM,YAAY,GAAG,QAAQ,MAAM,UAAU,KAAK,UAAU,UAAU,gBAAgB,GAAG,UAAU,EAAE,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,iBAAiB,SAAS,aAAa,YAAY,EAAE,CAAC;AACrb,eAAW,CAAC,MAAM,QAAQ,KAAK,KAAK,CAAC,CAAC,YAAY,SAAS,WAAW,gBAAgB,SAAS,KAAK,GAAG,CAAC,UAAU,SAAS,gBAAgB,SAAS,WAAW,CAAC,GAAY;AAC1K,YAAM,UAAU,eAAe,KAAK;AACpC,UAAI,WAAW,QAAQ,YAAY,KAAM;AACzC,eAAS,KAAK,EAAE,IAAI,WAAW,IAAI,IAAI,UAAU,MAAM,IAAI,QAAQ,UAAU,QAAQ,OAAO,QAAQ,SAAS,aAAa,YAAY,QAAQ,qBAAqB,MAAM,gBAAgB,QAAQ,QAAQ,wBAAwB,QAAQ,gBAAgB,UAAU,EAAE,kBAAkB,MAAO,aAAa,UAAU,UAAU,UAAU,UAAU,UAAU,SAAS,EAAE,CAAC;AAAA,IAC3W;AAAA,EACF;AACA,MAAI,CAAC,SAAS,OAAQ,OAAM,IAAI,MAAM,mHAAmH;AACzJ,QAAM,UAAU,4BAA4B,MAAM,SAAS,MAAM,SAAS,MAAM,MAAM;AACtF,QAAM,iBAAsC,CAAC;AAC7C,aAAW,UAAU,QAAQ,SAAS;AACpC,QAAI,OAAO,SAAS,kBAAmB;AACvC,UAAM,QAAQ,MAAM,QAAQ,KAAK,CAACC,WAAUA,OAAM,OAAO,OAAO,YAAY,EAAE;AAC9E,QAAI,CAAC,MAAO,OAAM,IAAI,MAAM,UAAU,OAAO,EAAE,4CAA4C;AAC3F,UAAM,SAAS,uBAAuB,OAAO,YAAY,WAAW;AACpE,QAAI,CAAC,eAAe,KAAK,CAAC,SAAS,KAAK,SAAS,MAAM,EAAG,gBAAe,KAAK,EAAE,MAAM,QAAQ,MAAM,YAAY,SAAS,wBAAwB,OAAO,OAAO,WAAW,EAAE,CAAC;AAAA,EAC/K;AACA,QAAM,UAAU,cAAc,MAAM;AAAA,IAClC,eAAe;AAAA,IAAuB,IAAI,YAAY,YAAY,CAAC,MAAM,WAAW,MAAM,MAAM,WAAW,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AAAA,IAAI,UAAU;AAAA,IACxI,WAAW,MAAM;AAAA,IAAW,gBAAgB;AAAA,IAAM,oBAAoB;AAAA,IAAM,MAAM,GAAG,MAAM,WAAW,IAAI,SAAM,MAAM,MAAM,SAAS,MAAM;AAAA,IAAsB,WAAW,MAAM,WAAW;AAAA,IAC7L,SAAS;AAAA,IAAW,WAAW;AAAA,IAAM,QAAQ;AAAA,IAAgB,YAAY,CAAC,MAAM,MAAM;AAAA,IAAG,iBAAiB;AAAA,IAC1G,QAAQ,QAAQ;AAAA,IAChB,aAAa,EAAE,iBAAiB,+BAA+B,MAAM,QAAQ,YAAY,oBAAoB,UAAU,OAAO,oBAAoB,QAAQ,YAAY,oBAAoB,WAAW,CAAC,GAAG,WAAW,CAAC,UAAU,SAAS,QAAQ,SAAS,SAAS,GAAG,kBAAkB,QAAQ,YAAY,kBAAkB,eAAe,QAAQ,YAAY,eAAe,UAAU,EAAE,qBAAqB,QAAQ,YAAY,EAAE;AAAA,IACta,cAAc,EAAE,eAAe,mCAAmC,UAAU,QAAQ,kBAAkB,QAAQ,eAAe,SAAS,CAAC,iBAAiB,QAAQ,IAAI,CAAC,QAAQ,GAAG,mBAAmB,MAAM,MAAM,YAAY,wBAAwB,CAAC,KAAK,IAAI,MAAM,MAAM,YAAY,oBAAoB,CAAC,QAAQ,KAAK,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,eAAe,GAAG,eAAe,OAAO,eAAe,OAAO,2BAA2B,MAAM,uBAAuB,CAAC,SAAS,QAAQ,GAAG,YAAY,MAAM,qBAAqB,CAAC,EAAE;AAAA,IACxgB,OAAO,QAAQ,MAAM,IAAI,CAAC,EAAE,cAAc,SAAS,GAAG,KAAK,OAAO,EAAE,GAAG,MAAM,eAAe,wBAAwB,YAAY,CAAC,QAAQ,GAAG,UAAU,EAAE,WAAW,SAAS,WAAW,KAAK,CAAC,UAAU,MAAM,WAAW,KAAK,EAAE,GAAG,eAAe,MAAM,SAAS,KAAK,CAAC,aAAa,SAAS,OAAO,KAAK,EAAE,GAAG,uBAAuB,cAAc,YAAY,EAAE,EAAE;AAAA,IAClW;AAAA,IAAS,gBAAgB;AAAA,IAAU,iBAAiB;AAAA,IACpD,qBAAqB,EAAE,eAAe,uCAAuC,OAAO,MAAM,aAAa,CAAC,GAAG,WAAW,YAAY,4BAA4B,GAAG,uBAAuB,qBAAqB,aAAa,MAAM,MAAM,YAAY,wBAAwB,mBAAmB,qBAAqB,oBAAoB,MAAM,gBAAgB,MAAM,MAAM,SAAS,IAAI,CAAC,UAAU,MAAM,SAAS,WAAW,GAAG,mBAAmB,qBAAqB,cAAc,MAAM,eAAe,CAAC,GAAG,WAAW,MAAM,MAAM,SAAS;AAAA,IAC5gB,WAAW;AAAA,IAAM,aAAa;AAAA,IAAY,WAAW,MAAM,MAAM;AAAA,IAAU,WAAW,MAAM,MAAM;AAAA,IAClG,UAAU,EAAE,UAAU,UAAU,iBAAiB,YAAY,OAAO,GAAG,gBAAgB,MAAM,MAAM,YAAY,wBAAwB,QAAQ,MAAM,MAAM,YAAY,oBAAoB,SAAS,QAAQ,uBAAuB,EAAE,MAAM,mBAAmB,YAAY,MAAM,WAAW,cAAc,UAAU,KAAK,EAAE;AAAA,EAC5T,CAAC;AACD,SAAO,EAAE,SAAS,cAAc,MAAM,EAAE,GAAG,SAAS,aAAa,mBAAmB,OAAO,EAAE,CAAC,GAAG,SAAS,eAAe;AAC3H;AAEA,SAAS,eAAe,OAAiC;AACvD,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,UAAU,MAAM,SAAS,WAAW,mBAAmB,MAAM,aAAa,MAAM;AACtF,MAAI,QAAQ,WAAW,SAAU,QAAO;AACxC,SAAO,EAAE,QAAQ,QAAQ,WAAW,MAAM,gBAAgB,MAAM,SAAS,WAAW,SAAS;AAC/F;;;AFvCO,SAAS,2BAA2B,OAsBjB;AACxB,QAAM,EAAE,SAAS,cAAc,gBAAgB,eAAe,IAAI;AAClE,QAAM,QAAQ,aAAa;AAC3B,QAAM,kBAAkB,0BAA0B,MAAM,cAAc;AACtE,QAAM,kBAAkB,0BAA0B,MAAM,cAAc;AAItE,OAAK,MAAM;AACX,OAAK,MAAM;AACX,QAAM,oBAAoB,mBAAmB,OAAO;AACpD,MAAI,sBAAsB,QAAQ,aAAa;AAC7C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,MACE,CAAC,MAAM,WAAW,YAClB,CAAC,MAAM,UAAU,qBACjB,CAAC,MAAM,UAAU,oBACjB,CAAC,MAAM,UACP,CAAC,MAAM,cACP,MAAM,WAAW,OAAO,QAAQ,MAChC,MAAM,WAAW,gBAAgB,QAAQ,aACzC;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,iBAAiB,QAAQ,kBAAkB;AAAA,IAC/C,IAAI,WAAW,QAAQ,SAAS;AAAA,IAChC,UAAU,QAAQ;AAAA,IAClB,aAAa,YAAY;AAAA,MACvB,WAAW,QAAQ;AAAA,MACnB,cAAc,QAAQ,oBAAoB;AAAA,MAC1C,WAAW,QAAQ,oBAAoB;AAAA,IACzC,CAAC;AAAA,EACH;AACA,QAAM,SAAS,oBAAI,IAAwB;AAC3C,MAAI,MAAM,kBAAkB;AAC1B,UAAM,aAAa,+BAA+B,MAAM,MAAM,gBAAgB;AAC9E,QAAI,YAAY,WAAW,OAAO,MAAM,YAAY,MAAM,oBAAoB,GAAG;AAC/E,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AACA,sCAAkC,QAAQ,MAAM,OAAO,UAAQ,KAAK,UAAU,OAAO,GAAG,WAAW,KAAK;AACxG,WAAO,IAAI,iCAAiC,IAAI,YAAY,EAAE,OAAO,cAAc,UAAU,CAAC,CAAC;AAAA,EACjG,WAAW,MAAM,sBAAsB;AACrC,UAAM,IAAI,MAAM,iEAAiE;AAAA,EACnF;AACA,QAAM,gBAAgB,MAAM,gBACxB,6BAA6B,MAAM,eAAe,eAAe,IACjE;AACJ,MAAI,MAAM,kBAAkB,CAAC,eAAe;AAC1C,UAAM,IAAI,MAAM,oEAAoE;AAAA,EACtF;AACA,MAAI,kBAAkB,CAAC,MAAM,kBACxB,MAAM,eAAe,OAAO,gBAAgB,MAC5C,MAAM,eAAe,gBAAgB,gBAAgB,cAAc;AACtE,UAAM,IAAI,MAAM,6DAA6D;AAAA,EAC/E;AACA,MAAI,eAAe;AACjB,UAAM,kBAAkB,MAAM,QAAQ,cAAc,WAAW,MAAM,QAAQ,SAAS;AACtF,QAAI,oBAAoB,CAAC,cAAc,cAAc,YAAY,YAC5D,cAAc,eAAe,MAAM,KAAK,UAAQ,KAAK,eAAe,cAAc,IAAI;AACzF,YAAM,IAAI,MAAM,wEAAwE;AAAA,IAC1F;AACA,iBAAa,QAAQ,+BAA+B,aAAa;AAAA,EACnE;AACA,eAAa,QAAQ,0BAA0B,6BAA6B,MAAM;AAAA,IAChF,eAAe;AAAA,IACf,MAAM,gBAAgB,qBAAqB;AAAA,IAC3C,gBAAgB;AAAA,IAChB,mBAAmB,eAAe,eAAe;AAAA,EACnD,CAAC,CAAC;AACF,QAAM,kBAAkB,sCAAsC,SAAS,MAAM,eAAe;AAC5F,MAAI,iBAAiB;AACnB,UAAM,iBAAiB,MAAM,kBAAkB,CAAC;AAChD,UAAM,aAAa,oBAAoB,gBAAgB,SAAS,gBAAgB,OAAO,EACpF,QAAQ,YAAU,OAAO,SAAS,oBAAoB,CAAC,OAAO,WAAW,IAAI,CAAC,CAAC;AAClF,UAAM,WAAW,IAAI,IAAI,WAAW,IAAI,eAAa,UAAU,EAAE,CAAC;AAClE,QAAI,IAAI,IAAI,eAAe,IAAI,WAAS,MAAM,EAAE,CAAC,EAAE,SAAS,eAAe,UACtE,eAAe,KAAK,WAAS,CAAC,SAAS,IAAI,MAAM,EAAE,CAAC,EAAG,OAAM,IAAI,MAAM,iDAAiD;AAC7H,eAAW,aAAa,YAAY;AAClC,YAAM,QAAQ,eAAe,KAAK,CAAAC,WAASA,OAAM,OAAO,UAAU,EAAE;AACpE,UAAI,CAAC,SAAS,UAAU,eAAe,WAAY,OAAM,IAAI,MAAM,sDAAsD;AACzH,MAAAC,yBAAwB,OAAO,SAAS;AAAA,IAC1C;AACA,iBAAa,QAAQ,uBAAuB,EAAE,MAAM,qBAAqB,SAAS,gBAAgB,SAAS,SAAS,gBAAgB,SAAS,QAAQ,eAAe,CAAC;AAAA,EACvK,WAAW,MAAM,gBAAgB,QAAQ;AACvC,UAAM,IAAI,MAAM,6DAA6D;AAAA,EAC/E;AACA,eAAa,QAAQ,oBAAoB;AAAA,IACvC,eAAe;AAAA,IACf,aAAa,QAAQ;AAAA,IACrB,cAAc,QAAQ;AAAA,IACtB,QAAQ,QAAQ;AAAA,IAChB,gBACG,QAAQ,SAAS,uBACd,SAAS,SACT,OACA,QAAQ,SAAS,yBAAyB;AAAA,EAClD,CAAC;AACD,eAAa,QAAQ,gBAAgB;AAAA,IACnC,eAAe;AAAA,IACf,SAAS,QAAQ;AAAA,IACjB,UAAU,QAAQ;AAAA,EACpB,CAAC;AACD,eAAa,QAAQ,sBAAsB;AAAA,IACzC,eAAe;AAAA,IACf,WAAW,QAAQ,YAAY;AAAA,IAC/B,gBAAgB,QAAQ,YAAY,kBAAkB,CAAC;AAAA,IACvD,cAAc,QAAQ;AAAA,IACtB,oBAAoB,QAAQ,OAAO;AAAA,EACrC,CAAC;AACD,QAAM,aAAa,QAAQ,MAAM,OAAO,CAAC,SAAS,KAAK,UAAU,OAAO;AACxE,MAAI,WAAW,SAAS,GAAG;AACzB,iBAAa,QAAQ,sBAAsB;AAAA,MACzC,eAAe;AAAA,MACf,OAAO;AAAA,MACP,OAAO;AAAA,IACT,CAAC;AACD,qBAAiB;AAAA,MACf;AAAA,MACA,OAAO;AAAA,MACP,mBAAmB,MAAM,qBAAqB,oBAAI,IAAI;AAAA,IACxD,CAAC;AAAA,EACH,WAAW,QAAQ,iBAAiB;AAClC,iBAAa,QAAQ,yBAAyB,QAAQ,eAAe;AAAA,EACvE,OAAO;AACL,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AAEA,QAAM,kBAAkB,OAAO,OAAO,QAAQ,eAAe,EAC1D,KAAK,EACL,OAAO,CAAC,WAAW,OAAO,QAAQ;AACrC,aAAW,UAAU,iBAAiB;AACpC,UAAM,QAAQ,MAAM,MAAM;AAC1B,WAAO,IAAI,oBAAoB,OAAO,KAAK,CAAC,SAAS,KAAK;AAAA,EAC5D;AAEA,QAAM,iBAAiB;AAAA,IACrB,IAAI,WAAW,QAAQ,EAAE,KAAK,QAAQ,QAAQ;AAAA,IAC9C,aAAa,YAAY;AAAA,MACvB,SAAS;AAAA,MACT,YAAY,QAAQ;AAAA,MACpB,iBAAiB,QAAQ,mBAAmB;AAAA,MAC5C;AAAA,IACF,CAAC;AAAA,EACH;AACA,QAAM,qBACJ,gBAAgB,SAAS,IACrB;AAAA,IACE,IAAI,YAAY,QAAQ,EAAE,KAAK,QAAQ,QAAQ;AAAA,IAC/C,aAAa,YAAY;AAAA,MACvB,SAAS;AAAA,MACT,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AAAA,EACH,IACA;AAEN,QAAM,gBAAgB,oCAAoC,MAAM;AAAA,IAC9D,eAAe;AAAA,IACf,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB;AAAA,IACA;AAAA,IACA,OAAO,CAAC,GAAG,OAAO,QAAQ,CAAC,EACxB,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,cAAc,KAAK,CAAC,EACnD,IAAI,CAAC,CAAC,WAAW,KAAK,OAAO;AAAA,MAC5B,MAAM;AAAA,MACN,QAAQ,OAAO,KAAK;AAAA,MACpB,WAAW,MAAM;AAAA,IACnB,EAAE;AAAA,EACN,CAAC;AACD,QAAM,yBAAyB,qCAAqC,MAAM;AAAA,IACxE,GAAG;AAAA,IACH,aAAa,YAAY,aAAa;AAAA,EACxC,CAAC;AACD,QAAM,kBAAkB,gCAAgC,MAAM;AAAA,IAC5D,eAAe;AAAA,IACf,IAAI,YAAY,MAAM,UAAU,IAAI,MAAM,SAAS,aAAa,MAAM,GAAG,EAAE,CAAC;AAAA,IAC5E;AAAA,IACA;AAAA,IACA,cAAc,qBAAqB,CAAC,kBAAkB,IAAI,CAAC;AAAA,IAC3D,OAAO;AAAA,MACL,QAAQ,MAAM,UAAU;AAAA,MACxB,UAAU,MAAM,UAAU;AAAA,MAC1B,cAAc;AAAA,MACd,mBAAmB,MAAM,UAAU;AAAA,MACnC,kBAAkB,MAAM,UAAU;AAAA,IACpC;AAAA,IACA,QAAQ;AAAA,MACN,QAAQ,MAAM,OAAO;AAAA,MACrB,SAAS;AAAA,MACT,YAAY,YAAY,MAAM,MAAM;AAAA,IACtC;AAAA,IACA,eAAe,MAAM;AAAA,IACrB,eAAe,MAAM;AAAA,IACrB,QAAQ,MAAM;AAAA,IACd,oBAAoB,uBAAuB;AAAA,IAC3C,iBAAiB,MAAM,mBAAmB,CAAC;AAAA,IAC3C,UAAU,MAAM;AAAA,IAChB,WAAW,aAAa;AAAA,EAC1B,CAAC;AACD,QAAM,WAAW,yBAAyB,MAAM;AAAA,IAC9C,GAAG;AAAA,IACH,aAAa,YAAY,eAAe;AAAA,EAC1C,CAAC;AACD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,iBAAiB,OAIjB;AACP,QAAM,WAAW,oBAAI,IAAY;AACjC,aAAW,QAAQ,MAAM,OAAO;AAC9B,eAAW,SAAS,KAAK,UAAU,CAAC,GAAG;AACrC,UAAI,SAAS,IAAI,MAAM,WAAW,GAAG;AACnC,cAAM,IAAI;AAAA,UACR,uBAAuB,MAAM,WAAW;AAAA,QAC1C;AAAA,MACF;AACA,eAAS,IAAI,MAAM,WAAW;AAC9B,YAAM,QAAQ,MAAM,kBAAkB,IAAI,MAAM,WAAW;AAC3D,UAAI,CAAC,OAAO;AACV,cAAM,IAAI;AAAA,UACR,kDAAkD,MAAM,WAAW;AAAA,QACrE;AAAA,MACF;AACA,UAAI,MAAM,eAAe,MAAM,aAAa,OAAO,KAAK,MAAM,MAAM,QAAQ;AAC1E,cAAM,IAAI;AAAA,UACR,uCAAuC,MAAM,WAAW;AAAA,QAC1D;AAAA,MACF;AACA,YAAM,OAAO,IAAI,MAAM,aAAa,KAAK;AAAA,IAC3C;AAAA,EACF;AACA,aAAW,aAAa,MAAM,kBAAkB,KAAK,GAAG;AACtD,QAAI,CAAC,SAAS,IAAI,SAAS,GAAG;AAC5B,YAAM,IAAI;AAAA,QACR,2DAA2D,SAAS;AAAA,MACtE;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,aACP,QACA,WACA,OACM;AACN,SAAO,IAAI,WAAW,MAAM,KAAK,CAAC;AACpC;AAEA,SAAS,MAAM,OAA4B;AACzC,SAAO,OAAO,KAAK,cAAc,KAAK,GAAG,MAAM;AACjD;",
+  "names": ["verifyLearningTextAsset", "asset", "asset", "verifyLearningTextAsset"]
+}

package/dist/training.js

@@ -4,6 +4,8 @@ import {
   RewardModelTrainingRequestSchema,
   TRAINING_EVALUATION_SOURCE_PATH,
   TrainingApiErrorSchema,
+  TrainingCandidateDecisionRequestSchema,
+  TrainingCandidateDecisionSchema,
   TrainingCapabilitiesSchema,
   TrainingCapabilityRequirementSchema,
   TrainingEvaluationSourceSchema,
@@ -28,16 +30,18 @@ import {
   assertTrainingEvaluationIsolation,
   createTrainingClient,
   deterministicTrainingRewardSource,
+  parseAndVerifyTrainingCandidateDecision,
   parseAndVerifyTrainingEvaluationTaskPage,
   parseAndVerifyTrainingExecutionReceipt,
   parseAndVerifyTrainingInputArtifactUpload,
   parseAndVerifyTrainingJobSubmission,
+  trainingCandidateDecisionHash,
   trainingEvaluationSourceRef,
   trainingEvaluationTaskPageHash,
   trainingExecutionReceiptHash,
   trainingInputArtifactUploadHash,
   trainingJobSubmissionHash
-} from "./chunk-M6MM6IGG.js";
+} from "./chunk-F5JBFRAH.js";
 import {
   OPENPOND_TRAINING_MEDIA_TYPE,
   OPENPOND_TRAINING_PROTOCOL_MAJOR,
@@ -63,6 +67,8 @@ export {
   TRAINING_INPUT_ARTIFACT_MAX_BYTES,
   TRAINING_JOB_SUBMISSION_MAX_BYTES,
   TrainingApiErrorSchema,
+  TrainingCandidateDecisionRequestSchema,
+  TrainingCandidateDecisionSchema,
   TrainingCapabilitiesSchema,
   TrainingCapabilityRequirementSchema,
   TrainingEvaluationSourceSchema,
@@ -91,11 +97,13 @@ export {
   canonicalSha256,
   createTrainingClient,
   deterministicTrainingRewardSource,
+  parseAndVerifyTrainingCandidateDecision,
   parseAndVerifyTrainingEvaluationTaskPage,
   parseAndVerifyTrainingExecutionReceipt,
   parseAndVerifyTrainingInputArtifactUpload,
   parseAndVerifyTrainingJobSubmission,
   parseBoundedJson,
+  trainingCandidateDecisionHash,
   trainingEvaluationSourceRef,
   trainingEvaluationTaskPageHash,
   trainingExecutionReceiptHash,

package/dist/types/packages/sdk/src/taskset-authored-contracts.d.ts

@@ -6,13 +6,13 @@ export declare const TasksetStatusSchema: z.ZodEnum<{
     archived: "archived";
     ready: "ready";
     draft: "draft";
+    blocked: "blocked";
     awaiting_disclosure_approval: "awaiting_disclosure_approval";
     awaiting_materialization_approval: "awaiting_materialization_approval";
     materializing: "materializing";
     validating: "validating";
     needs_review: "needs_review";
     baselining: "baselining";
-    blocked: "blocked";
 }>;
 export declare const DatasetBuildIntentSchema: z.ZodEnum<{
     rubric: "rubric";
@@ -352,13 +352,13 @@ export declare const TasksetSchema: z.ZodObject<{
         archived: "archived";
         ready: "ready";
         draft: "draft";
+        blocked: "blocked";
         awaiting_disclosure_approval: "awaiting_disclosure_approval";
         awaiting_materialization_approval: "awaiting_materialization_approval";
         materializing: "materializing";
         validating: "validating";
         needs_review: "needs_review";
         baselining: "baselining";
-        blocked: "blocked";
     }>;
     sourceRefs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.trainingSource.v1">;

package/dist/types/packages/sdk/src/taskset-authored-files.d.ts

@@ -47,7 +47,7 @@ export declare function prepareAuthoredTasksetSource(tasksetInput: Taskset, sour
             publishedAt: string;
             metadata: Record<string, unknown>;
         } | null;
-        status: "failed" | "archived" | "ready" | "draft" | "awaiting_disclosure_approval" | "awaiting_materialization_approval" | "materializing" | "validating" | "needs_review" | "baselining" | "blocked";
+        status: "failed" | "archived" | "ready" | "draft" | "blocked" | "awaiting_disclosure_approval" | "awaiting_materialization_approval" | "materializing" | "validating" | "needs_review" | "baselining";
         sourceRefs: ({
             id: string;
             profileId: string;