openpond-sdk 0.5.27 → 0.5.28

package/dist/taskset-packages.js

@@ -13,7 +13,7 @@ import {
   projectPortableTaskRecord,
   projectPreferenceComparisonRelease,
   resolvePortableTasksetRewardExecution
-} from "./chunk-AUQOAMHL.js";
+} from "./chunk-O27OEXXB.js";
 import {
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
@@ -30,7 +30,7 @@ import {
   publishTasksetDraft,
   renderTasksetDraftManifests,
   validateTasksetDraftWorkspace
-} from "./chunk-ULQC4SQF.js";
+} from "./chunk-FFRYTXGF.js";
 import {
   GraderFixtureSchema,
   TasksetEnvironmentResourceSchema,
@@ -41,14 +41,17 @@ import {
 import {
   MAX_TASKSET_PACKAGE_BYTES,
   ModelStarterExecutionSchema,
+  ModelTasksetDerivationSchema,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
   TasksetPackageLearningResourcesSchema,
   TasksetPackageSchema,
   assertModelTasksetAuthoring,
+  compileModelTasksetReward,
   createTasksetPackage,
   createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
+  deriveModelTaskset,
   learningPackageContextFiles,
   modelAuthoredTasksetId,
   modelStarterExecutionAssetId,
@@ -57,7 +60,7 @@ import {
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,
   validateTasksetPackage
-} from "./chunk-IDLMILN4.js";
+} from "./chunk-B3CH4V35.js";
 import {
   ModelTasksetAuthoringOwnerSchema,
   ModelTasksetAuthoringSchema,
@@ -68,7 +71,7 @@ import {
   TasksetDraftFileMutationSchema,
   TasksetDraftFilePathSchema,
   TasksetDraftFileSchema
-} from "./chunk-S7I45WJQ.js";
+} from "./chunk-2U54EOXJ.js";
 import "./chunk-GZOXT7YE.js";
 import "./chunk-A4ZDOZKP.js";
 import "./chunk-5FBPNWT4.js";
@@ -79,10 +82,69 @@ import {
 } from "./chunk-QUOW6URQ.js";
 import "./chunk-ZNFOVV7B.js";
 
+// src/model-ordinary-taskset-reward.ts
+import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sealLearningContent } from "@openpond/evals/learning";
+function bindOrdinaryModelTasksetReward(input) {
+  const source = validateTasksetPackage(input.source);
+  if (source.modelResources || source.learningResources) throw new Error("Binding an ordinary Reward requires an ordinary source package.");
+  const instructions = resolveTasksetPackageInstructions(source);
+  if (!instructions.trim()) throw new Error("Add collection instructions before selecting a saved Reward.");
+  const assets = /* @__PURE__ */ new Map();
+  const execution = resolveTasksetPackageExecution(source);
+  for (const asset of execution?.assets ?? []) assets.set(asset.id, asset);
+  const contextIds = /* @__PURE__ */ new Set([
+    ...source.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : []),
+    ...[source.environment.actionSchemaRef, source.environment.observationSchemaRef, source.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : [])
+  ]);
+  for (const id of contextIds) {
+    if (assets.has(id)) continue;
+    const file = source.files.find((file2) => file2.asset.id === id);
+    if (!file) throw new Error(`Source Taskset context is missing: ${id}.`);
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
+    assets.set(id, LearningTextAssetSchema.parse(sealLearningContent({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text })));
+  }
+  for (const asset of input.assets) {
+    const original = source.files.find((file) => file.asset.id === asset.id);
+    if (original && sealLearningContent({ asset: original.asset }).contentHash !== sealLearningContent({ asset: asset.asset }).contentHash) throw new Error(`Selected Reward conflicts with a source asset: ${asset.id}.`);
+    assets.set(asset.id, asset);
+  }
+  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = source.taskset;
+  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent({
+    schemaVersion: "openpond.taskDefinition.v1",
+    id: `${source.taskset.id}-definition`,
+    revision: 1,
+    name: source.taskset.id,
+    description: "",
+    instructions,
+    category: "custom",
+    familyNamespace: source.taskset.id,
+    inputSchema: { type: "object" },
+    outputSchema: { type: "object" },
+    rewardBinding: learningRef(input.rewardBinding),
+    harness: null,
+    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease }
+  }));
+  const derived = compileModelTasksetReward({ ...input, assets: [...assets.values()], source: {
+    taskset: source.taskset,
+    taskDefinition,
+    instructionMode: "per_task",
+    executionResources: { environment: source.environment, verifierSet: source.verifierSet },
+    ...execution ? { execution: execution.execution } : {}
+  } });
+  const files = new Map(source.files.map((file) => [file.asset.id, file]));
+  for (const asset of derived.assets) {
+    let raw = "";
+    for (const byte of new TextEncoder().encode(asset.text)) raw += String.fromCharCode(byte);
+    files.set(asset.id, { asset: asset.asset, base64: btoa(raw) });
+  }
+  const { taskset, executionResources, ...modelResources } = derived;
+  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset, ...executionResources, modelResources, files: [...files.values()] });
+}
+
 // src/model-batch-review.ts
 import {
   LearningDomainError as LearningDomainError2,
-  learningRef as learningRef2,
+  learningRef as learningRef3,
   sameLearningRef as sameLearningRef2,
   requireLearningRelease,
   requireLearningResource,
@@ -93,14 +155,14 @@ import {
 import {
   LearningDomainError,
   LearningSourceSchema,
-  TaskDefinitionSchema,
+  TaskDefinitionSchema as TaskDefinitionSchema2,
   TaskEvidenceSchema,
   TaskFeedbackSchema,
   assertLearningContentHash,
   learningEvidenceId,
-  learningRef,
+  learningRef as learningRef2,
   sameLearningRef,
-  sealLearningContent,
+  sealLearningContent as sealLearningContent2,
   taskBatchPackageMetadata,
   verifyLearningTextAsset
 } from "@openpond/evals/learning";
@@ -112,7 +174,7 @@ function prepareModelBatchReview(input) {
   const metadata = taskBatchPackageMetadata(value.taskset);
   const id = `model-review-${contentHash([input.scope, request.modelId, request.operationId])}`;
   const edits = new Map(request.examples.map((edit) => [contentHash(edit.evidence), edit]));
-  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef(evidence2))));
+  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef2(evidence2))));
   const decisions = new Map(learning.decisions.map((decision) => [contentHash(decision.evidence), decision]));
   if (edits.size !== request.examples.length || request.examples.some((edit) => !parentRefs.has(contentHash(edit.evidence)))) {
     throw new LearningDomainError("model_review_evidence_mismatch", 409);
@@ -121,7 +183,7 @@ function prepareModelBatchReview(input) {
   resolveBoundRewards(input.binding, input.rewards);
   const rewardByHash = /* @__PURE__ */ new Map();
   for (const source2 of input.binding.sources) {
-    const original = input.rewards.find((reward) => sameLearningRef(learningRef(reward), source2.reward));
+    const original = input.rewards.find((reward) => sameLearningRef(learningRef2(reward), source2.reward));
     const { contentHash: _hash, ...content } = original;
     rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
   }
@@ -131,7 +193,7 @@ function prepareModelBatchReview(input) {
     ...bindingContent,
     id: `${id}-binding`,
     revision: 1,
-    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef(rewardByHash.get(source2.reward.contentHash)) }))
+    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef2(rewardByHash.get(source2.reward.contentHash)) }))
   }, rewards);
   const assetRefs = rewards.flatMap((reward) => [
     ...reward.assets,
@@ -148,24 +210,24 @@ function prepareModelBatchReview(input) {
   })).values()];
   const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
   const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
-  const definition = TaskDefinitionSchema.parse(sealLearningContent({
+  const definition = TaskDefinitionSchema2.parse(sealLearningContent2({
     ...definitionContent,
     ...request.definition,
     id: `${id}-definition`,
     revision: 1,
-    rewardBinding: learningRef(binding),
+    rewardBinding: learningRef2(binding),
     execution: {
       ...execution,
       policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
     }
   }));
-  const source = LearningSourceSchema.parse(sealLearningContent({
+  const source = LearningSourceSchema.parse(sealLearningContent2({
     schemaVersion: "openpond.learningSource.v1",
     id,
     revision: 1,
     name: `${definition.name} review`,
     kind: "direct",
-    taskDefinition: learningRef(definition),
+    taskDefinition: learningRef2(definition),
     enabled: true,
     allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
     mapping: null,
@@ -173,13 +235,13 @@ function prepareModelBatchReview(input) {
     reviewOrigin: {
       modelId: request.modelId,
       packageHash: value.contentHash,
-      taskset: learningRef(value.taskset),
-      batch: learningRef(learning.batch),
-      rewardBinding: learningRef(input.binding)
+      taskset: learningRef2(value.taskset),
+      batch: learningRef2(learning.batch),
+      rewardBinding: learningRef2(input.binding)
     }
   }));
   const evidence = learning.evidence.map((parent) => {
-    const edit = edits.get(contentHash(learningRef(parent)));
+    const edit = edits.get(contentHash(learningRef2(parent)));
     const attemptId = `review-${parent.contentHash}`;
     const policyChanged = contentHash({
       instructions: definition.instructions,
@@ -194,15 +256,15 @@ function prepareModelBatchReview(input) {
       requiredOutputs: metadata.definition.requiredOutputs ?? [],
       input: parent.submission.input
     });
-    return TaskEvidenceSchema.parse(sealLearningContent({
+    return TaskEvidenceSchema.parse(sealLearningContent2({
       schemaVersion: "openpond.taskEvidence.v1",
       id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
       revision: 1,
-      source: learningRef(source),
+      source: learningRef2(source),
       submission: {
         ...parent.submission,
         sourceId: source.id,
-        taskDefinition: learningRef(definition),
+        taskDefinition: learningRef2(definition),
         attemptId,
         // The old response was observed under the old policy-visible task. Its
         // parent snapshot remains available, but it is not a run of new inputs.
@@ -212,7 +274,7 @@ function prepareModelBatchReview(input) {
         ...edit?.expected === void 0 ? {} : { expected: edit.expected },
         ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
       },
-      supersedes: learningRef(parent),
+      supersedes: learningRef2(parent),
       correctionFeedbackId: null,
       receivedAt: input.now
     }));
@@ -238,7 +300,7 @@ function prepareModelBatchReview(input) {
         note: "Proposed target for the revised task. Grade and review before admission."
       },
       status: "pending_review",
-      evidence: learningRef(item),
+      evidence: learningRef2(item),
       createdAt: input.now,
       review: null
     })];
@@ -277,7 +339,7 @@ async function beginModelBatchReview(transaction, input) {
   if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
   const metadata = taskBatchPackageMetadata2(value.taskset);
   const selected = request.rewardBindingRef;
-  const retained = !selected || sameLearningRef2(selected, learningRef2(metadata.binding));
+  const retained = !selected || sameLearningRef2(selected, learningRef3(metadata.binding));
   const binding = retained ? metadata.binding : await requireLearningRelease(transaction, "binding", selected);
   const rewards = retained ? metadata.rewards : await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
   const assetIds = new Set(rewards.flatMap((reward) => [
@@ -324,23 +386,111 @@ async function readReceipt(transaction, request, pointers) {
 
 // src/model-taskset-authoring.ts
 import { createVerifierSetRelease } from "@openpond/evals";
-import { learningRef as learningRef3, sameLearningRef as sameLearningRef3, sealLearningContent as sealLearningContent2 } from "@openpond/evals/learning";
+import { learningRef as learningRef5, sameLearningRef as sameLearningRef4, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
+import { TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
+
+// src/model-bound-taskset-authoring.ts
+import { LearningTextAssetSchema as LearningTextAssetSchema2, TaskDefinitionSchema as TaskDefinitionSchema3, learningRef as learningRef4, sameLearningRef as sameLearningRef3, sealLearningContent as sealLearningContent3 } from "@openpond/evals/learning";
 import { TasksetReleaseSchema } from "@openpond/evals/tasksets";
+function publishBoundModelTasksetDraftPackage(input) {
+  const source = validateTasksetPackage(input.source);
+  const edited = validateTasksetPackage(input.edited);
+  const prepared = input.preparation;
+  if (prepared.authoringGraph !== "bound" || !source.modelResources || source.learningResources || edited.modelResources || edited.learningResources) throw new Error("Bound task editing requires its source Reward and an ordinary edited workspace.");
+  if (source.contentHash !== prepared.sourcePackageHash || !sameLearningRef3(learningRef4(source.taskset), prepared.sourceTasksetRef)) throw new Error("Bound draft differs from its retained source package.");
+  const normalizedGraders = (value) => value.taskset.graders.map((grader) => grader.kind === "custom_verifier" ? { ...grader, exportName: grader.exportName ?? "verify" } : grader);
+  if (contentHash(normalizedGraders(source)) !== contentHash(normalizedGraders(edited))) throw new Error("Edit the saved Reward in Rewards before changing this Taskset's graders.");
+  const resources = source.modelResources;
+  const assets = new Map(resources.assets.map((asset) => [asset.id, asset]));
+  const execution = resolveTasksetPackageExecution(edited);
+  const sourceExecution = resolveTasksetPackageExecution(source);
+  const environmentContent = (value) => {
+    const { id: _id, revision: _revision, contentHash: _hash, metadata, ...contract } = value;
+    const { javascriptEnvironment: _javascript, ...retained } = metadata;
+    return { ...contract, metadata: { ...retained, resources: retained.resources ?? [] } };
+  };
+  const javascriptContent = (value) => {
+    if (!value) return null;
+    const { id: _id, revision: _revision, contentHash: _hash, ...contract } = value.execution.javascript;
+    return contract;
+  };
+  const unchangedEnvironment = contentHash(environmentContent(source.environment)) === contentHash(environmentContent(edited.environment)) && contentHash(javascriptContent(sourceExecution)) === contentHash(javascriptContent(execution));
+  const selectedEnvironment = unchangedEnvironment ? source.environment : edited.environment;
+  const selectedExecution = unchangedEnvironment ? sourceExecution : execution;
+  const requiredIds = /* @__PURE__ */ new Set([
+    ...resources.assets.map((asset) => asset.id),
+    ...edited.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : []),
+    ...[edited.environment.actionSchemaRef, edited.environment.observationSchemaRef, edited.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
+    ...execution?.assets.map((asset) => asset.id) ?? []
+  ]);
+  for (const id of requiredIds) {
+    const file = edited.files.find((file2) => file2.asset.id === id);
+    if (!file) throw new Error(`Bound Taskset asset is missing: ${id}.`);
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
+    assets.set(id, LearningTextAssetSchema2.parse(sealLearningContent3({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text })));
+  }
+  const instructions = resolveTasksetPackageInstructions(edited);
+  const { contentHash: _definitionHash, ...definitionContent } = resources.taskDefinition;
+  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = edited.taskset;
+  const taskDefinition = TaskDefinitionSchema3.parse(sealLearningContent3({
+    ...definitionContent,
+    instructions,
+    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease }
+  }));
+  const { contentHash: _taskHash, ...taskContent } = edited.taskset;
+  const taskset = TasksetReleaseSchema.parse(sealLearningContent3({ ...taskContent, tasks: edited.taskset.tasks.map((task) => resources.instructionMode === "per_task" ? task : { ...task, policyVisibleContext: { ...task.policyVisibleContext, instructions } }) }));
+  const derived = compileModelTasksetReward({
+    owner: prepared.lineage.owner,
+    source: { ...resources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },
+    rewardBinding: resources.rewardBinding,
+    rewards: resources.rewards,
+    assets: [...assets.values()],
+    edits: { taskset, taskDefinition, executionResources: { environment: selectedEnvironment, verifierSet: edited.verifierSet }, ...selectedExecution ? { execution: selectedExecution.execution } : {} }
+  });
+  const lineage = ModelTasksetDerivationSchema.parse(derived.taskset.metadata.modelTasksetDerivation);
+  if (derived.taskset.id !== prepared.tasksetId || derived.taskset.revision !== prepared.tasksetRevision || contentHash({ ...lineage, schemaVersion: prepared.lineage.schemaVersion }) !== contentHash(prepared.lineage)) throw new Error("Bound draft differs from its retained ownership lineage.");
+  const { taskset: published, executionResources, ...modelResources } = derived;
+  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset: published, ...executionResources, modelResources, files: edited.files });
+}
+
+// src/model-taskset-authoring.ts
 function prepareModelTasksetDraft(input) {
   const request = ModelTasksetDraftRequestSchema.parse(input.request);
   const owner = ModelTasksetAuthoringOwnerSchema.parse(input.owner);
-  const source = requireOrdinaryPackage(input.source);
+  const source = validateTasksetPackage(input.source);
+  if (source.learningResources) throw new Error("Reviewed Tasksets require their reviewed authoring workflow.");
   if (source.contentHash !== request.sourcePackageHash) throw new Error("Taskset draft source package changed.");
+  if (source.modelResources) {
+    const derived = deriveModelTaskset({
+      owner,
+      source: { ...source.modelResources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },
+      rewardBinding: source.modelResources.rewardBinding,
+      rewards: source.modelResources.rewards,
+      assets: source.modelResources.assets
+    });
+    const lineage2 = derived.taskset.metadata.modelTasksetDerivation;
+    return ModelTasksetDraftPreparationSchema.parse({
+      schemaVersion: "openpond.modelTasksetDraftPreparation.v1",
+      draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,
+      requestHash: contentHash(request),
+      sourcePackageHash: source.contentHash,
+      sourceTasksetRef: learningRef5(source.taskset),
+      tasksetId: derived.taskset.id,
+      tasksetRevision: derived.taskset.revision,
+      lineage: { ...lineage2, schemaVersion: "openpond.modelTasksetAuthoring.v1" },
+      authoringGraph: "bound"
+    });
+  }
   const previous = assertModelTasksetAuthoring(source.taskset);
   const owned = previous && contentHash(previous.owner) === contentHash(owner);
-  const root = owned ? previous.root : learningRef3(source.taskset);
-  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef3(source.taskset) };
+  const root = owned ? previous.root : learningRef5(source.taskset);
+  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef5(source.taskset) };
   return ModelTasksetDraftPreparationSchema.parse({
     schemaVersion: "openpond.modelTasksetDraftPreparation.v1",
     draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,
     requestHash: contentHash(request),
     sourcePackageHash: source.contentHash,
-    sourceTasksetRef: learningRef3(source.taskset),
+    sourceTasksetRef: learningRef5(source.taskset),
     tasksetId: modelAuthoredTasksetId(lineage),
     tasksetRevision: owned ? source.taskset.revision + 1 : 1,
     lineage
@@ -348,7 +498,11 @@ function prepareModelTasksetDraft(input) {
 }
 function publishModelTasksetDraftPackage(input) {
   const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (!sameLearningRef3(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
+  if (!sameLearningRef4(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
+  if (prepared.authoringGraph === "bound") {
+    if (!input.source) throw new Error("Bound Taskset authoring requires its retained source package.");
+    return publishBoundModelTasksetDraftPackage({ preparation: prepared, source: input.source, edited: input.edited });
+  }
   const edited = requireOrdinaryPackage(input.edited);
   const { contentHash: _verifierHash, ...verifierContent } = edited.verifierSet;
   const verifierSet = createVerifierSetRelease({
@@ -356,10 +510,10 @@ function publishModelTasksetDraftPackage(input) {
     id: `${prepared.tasksetId}-verifiers`,
     revision: prepared.tasksetRevision,
     calibrationReceiptRefs: [],
-    metadata: { sourceVerifierSet: learningRef3(edited.verifierSet) }
+    metadata: { sourceVerifierSet: learningRef5(edited.verifierSet) }
   });
   const { contentHash: _hash, ...content } = edited.taskset;
-  const taskset = TasksetReleaseSchema.parse(sealLearningContent2({
+  const taskset = TasksetReleaseSchema2.parse(sealLearningContent4({
     ...content,
     id: prepared.tasksetId,
     revision: prepared.tasksetRevision,
@@ -384,7 +538,7 @@ function requireOrdinaryPackage(value) {
 }
 
 // src/taskset-package-projection.ts
-import { learningRef as learningRef4, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+import { learningRef as learningRef6, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
 function prepareImportedTasksetPackage(input) {
   const value = validateTasksetPackage(input.package);
   const release = value.taskset;
@@ -507,8 +661,8 @@ function prepareImportedTasksetPackage(input) {
       ...learning ? { learning } : {},
       portableFileInventory: value.files.map((file) => ({ asset: file.asset, sourcePath: file.asset.path })),
       ...resources ? {
-        taskDefinition: learningRef4(resources.taskDefinition),
-        rewardBinding: learningRef4(resources.rewardBinding),
+        taskDefinition: learningRef6(resources.taskDefinition),
+        rewardBinding: learningRef6(resources.rewardBinding),
         rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards }
       } : {},
       portableCapabilities: release.capabilities,
@@ -528,7 +682,7 @@ import { z } from "zod";
 // src/taskset-authored-tool-environment.ts
 import { createEnvironmentRelease } from "@openpond/evals";
 import { JavaScriptEnvironmentDefinitionSchema } from "@openpond/evals/javascript-environment";
-import { learningRef as learningRef5, sealLearningContent as sealLearningContent3 } from "@openpond/evals/learning";
+import { learningRef as learningRef7, sealLearningContent as sealLearningContent5 } from "@openpond/evals/learning";
 function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
   if (taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return { taskset, inventory, generatedFiles: [] };
   const declarationPath = "environment/execution.json";
@@ -542,7 +696,7 @@ function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
     return file2.asset;
   };
   const { contentHash: _javascriptHash, ...javascriptContent } = previous.javascript;
-  const javascript = JavaScriptEnvironmentDefinitionSchema.parse(sealLearningContent3({
+  const javascript = JavaScriptEnvironmentDefinitionSchema.parse(sealLearningContent5({
     ...javascriptContent,
     id: `javascript-${taskset.id}`,
     revision: taskset.revision,
@@ -559,7 +713,7 @@ function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
     stateSchemaRef: repin(previous.environment.stateSchemaRef),
     artifactCollection: previous.environment.artifactCollection,
     adapterConformanceHashes: {},
-    metadata: { javascriptEnvironment: learningRef5(javascript), resources: taskset.environment.resources ?? [] }
+    metadata: { javascriptEnvironment: learningRef7(javascript), resources: taskset.environment.resources ?? [] }
   });
   const prepared = TasksetSchema.parse({ ...taskset, environment: {
     ...taskset.environment,
@@ -690,12 +844,12 @@ function compileModelTasksetDraftWorkspace(input) {
       return { asset: entry.asset, base64: Buffer.from(bytes).toString("base64") };
     })
   });
-  return preparation ? publishModelTasksetDraftPackage({ preparation, edited }) : edited;
+  return preparation ? publishModelTasksetDraftPackage({ preparation, edited, source: input.source }) : edited;
 }
 
 // src/taskset-draft-source.ts
 import { z as z2 } from "zod";
-import { learningRef as learningRef6, sameLearningRef as sameLearningRef4 } from "@openpond/evals/learning";
+import { learningRef as learningRef8, sameLearningRef as sameLearningRef5 } from "@openpond/evals/learning";
 var TasksetDraftSourceInitializationSchema = z2.object({
   draft: TasksetDraftSchema,
   filePaths: z2.array(z2.object({ assetId: z2.string().min(1), paths: z2.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
@@ -704,8 +858,9 @@ function prepareTasksetDraftSource(input) {
   const source = validateTasksetPackage(input.source);
   const original = TasksetDraftSchema.parse(input.sourceDraft);
   const preparation = ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (source.contentHash !== preparation.sourcePackageHash || !sameLearningRef4(learningRef6(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
-  if (source.modelResources || source.learningResources) throw new Error("This Taskset requires its bound or reviewed authoring workflow.");
+  if (source.contentHash !== preparation.sourcePackageHash || !sameLearningRef5(learningRef8(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
+  if (source.learningResources) throw new Error("Reviewed Tasksets require their reviewed authoring workflow.");
+  if (Boolean(source.modelResources) !== (preparation.authoringGraph === "bound")) throw new Error("Taskset draft authoring graph differs from its source.");
   const inventory = AuthoredTasksetFileInventorySchema.parse(original.metadata.portableFileInventory ?? []);
   const sourcePath = (relative) => isManagedTasksetDraftFilePath(relative) ? `source-artifacts/${source.contentHash}/${contentHash(relative)}/${relative.split("/").at(-1)}` : relative;
   const references = [
@@ -726,16 +881,22 @@ function prepareTasksetDraftSource(input) {
     }
     return { assetId: file.asset.id, paths: [...paths].map(sourcePath) };
   });
+  const metadata = { ...original.metadata };
+  if (source.modelResources) for (const key of ["taskDefinition", "rewardBinding", "rewardExecution", "derivedPortableMetadata", "modelTasksetDerivation", "importedPackageHash"]) delete metadata[key];
   const draft = TasksetDraftSchema.parse({
     ...original,
     id: preparation.draftId,
     revision: 1,
     status: "draft",
+    graders: original.graders.map((grader) => ({ ...grader, metadata: {
+      ...grader.metadata,
+      portableGrader: source.taskset.graders.find((candidate) => candidate.id === grader.id)
+    } })),
     environment: { ...original.environment, metadata: { ...original.environment.metadata, portableExecutionResources: { environment: source.environment } } },
     modelScope: { modelId: preparation.lineage.owner.modelId, expectedModelRevision: input.expectedModelRevision, source: preparation },
     publishedTasksetRef: preparation.tasksetRevision > 1 ? preparation.sourceTasksetRef : null,
     metadata: {
-      ...original.metadata,
+      ...metadata,
       modelTasksetAuthoring: preparation.lineage,
       portableFileInventory: inventory.map((entry) => ({ ...entry, sourcePath: sourcePath(entry.sourcePath), asset: {
         ...entry.asset,
@@ -801,6 +962,7 @@ export {
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
   beginModelBatchReview,
+  bindOrdinaryModelTasksetReward,
   compileModelTasksetDraftWorkspace,
   createTasksetPackage,
   createTasksetPackageExecutionFile,