openpond-sdk 0.5.6 → 0.5.7

package/dist/taskset-packages.js

@@ -4,44 +4,60 @@ import {
   ModelBatchReviewRequestSchema
 } from "./chunk-K5ZCYOZO.js";
 import {
-  GraderFixtureSchema,
-  GraderSpecSchema,
-  MAX_TASKSET_PACKAGE_BYTES,
+  importedPackageGraders,
+  learningVerifierModule,
+  materializePortableTasksetRelease,
+  portableTasksetEnvironment,
+  portableTasksetTools,
+  projectLearningBatchGraders,
+  projectPortableTaskRecord,
+  projectPreferenceComparisonRelease,
+  resolvePortableTasksetRewardExecution
+} from "./chunk-ARUJ3FJT.js";
+import {
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
   TasksetDraftSchema,
-  TasksetEnvironmentResourceSchema,
-  TasksetPackageContentSchema,
-  TasksetPackageFileSchema,
-  TasksetPackageLearningResourcesSchema,
   TasksetPackageModelConfigurationSchema,
   TasksetPackagePublicationSchema,
   TasksetPackageReadbackSchema,
   TasksetPackageReceiptSchema,
+  configuredTasksetDraftFiles,
+  createTasksetDraft,
+  createTasksetDraftWorkspace,
+  decodeTasksetDraftWorkspaceFile,
+  isManagedTasksetDraftFilePath,
+  publishTasksetDraft,
+  renderTasksetDraftManifests,
+  validateTasksetDraftWorkspace
+} from "./chunk-UJZ3XEE3.js";
+import {
+  GraderFixtureSchema,
+  MAX_TASKSET_PACKAGE_BYTES,
+  TasksetEnvironmentResourceSchema,
+  TasksetPackageContentSchema,
+  TasksetPackageFileSchema,
+  TasksetPackageLearningResourcesSchema,
   TasksetPackageSchema,
   TasksetSchema,
   TasksetSourceRefSchema,
   assertModelTasksetAuthoring,
   computeTasksetHash,
-  configuredTasksetDraftFiles,
-  createTasksetDraft,
-  createTasksetDraftWorkspace,
   createTasksetPackage,
   createTasksetPackageExecutionFile,
-  decodeTasksetDraftWorkspaceFile,
   decodeTasksetPackageFile,
-  isManagedTasksetDraftFilePath,
   learningPackageContextFiles,
   modelAuthoredTasksetId,
-  publishTasksetDraft,
-  renderTasksetDraftManifests,
   resolveTasksetPackageExecution,
   resolveTasksetPackageInstructions,
   tasksetPackageRewardBinding,
-  validateTasksetDraftWorkspace,
   validateTasksetLearningResources,
   validateTasksetPackage
-} from "./chunk-PXB6YY36.js";
+} from "./chunk-QFT2MCIC.js";
+import {
+  ModelStarterExecutionSchema,
+  modelStarterExecutionAssetId
+} from "./chunk-4IDTRFW2.js";
 import {
   ModelTasksetAuthoringOwnerSchema,
   ModelTasksetAuthoringSchema,
@@ -55,19 +71,12 @@ import {
 } from "./chunk-S7I45WJQ.js";
 import "./chunk-F5JBFRAH.js";
 import "./chunk-A4ZDOZKP.js";
-import {
-  ModelStarterExecutionSchema,
-  modelStarterExecutionAssetId
-} from "./chunk-4IDTRFW2.js";
-import {
-  CapabilityRequirementSchema,
-  ToolDeclarationSchema
-} from "./chunk-EV4PKJWN.js";
+import "./chunk-UKVK7MRJ.js";
 import {
   ImmutableAssetRefSchema,
   contentHash,
   sha256
-} from "./chunk-NF63YMOL.js";
+} from "./chunk-QUOW6URQ.js";
 import "./chunk-ZNFOVV7B.js";
 
 // src/model-batch-review.ts
@@ -372,431 +381,8 @@ function requireOrdinaryPackage(value) {
   return result;
 }
 
-// src/taskset-authored-portable-release.ts
-import {
-  TaskRecordSchema,
-  GraderSpecSchema as PortableGraderSpecSchema,
-  TasksetReleaseContentSchema,
-  TasksetReleaseSchema as TasksetReleaseSchema2,
-  bindTasksetExecutionReleases,
-  createEnvironmentRelease,
-  createVerifierSetRelease as createVerifierSetRelease2,
-  EnvironmentReleaseSchema,
-  VerifierSetReleaseSchema,
-  verifyEnvironmentRelease,
-  verifyVerifierSetRelease,
-  verifyPreferenceComparisonRelease
-} from "@openpond/evals";
-import { TaskBatchPackageMetadataSchema } from "@openpond/evals/learning";
-import { compileBoundGraders as compileBoundGraders2, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-import { portableDeterministicCheck } from "@openpond/evals/graders";
-function resolvePortableTasksetRewardExecution(taskset, supplied) {
-  const learning = taskset.metadata.learning === void 0 ? null : TaskBatchPackageMetadataSchema.parse(taskset.metadata.learning);
-  const embedded = taskset.metadata.rewardExecution;
-  const execution = supplied ?? (embedded ? {
-    binding: RewardBindingSchema.parse(embedded.binding),
-    rewards: RewardReleaseSchema.array().parse(embedded.rewards)
-  } : learning);
-  if (taskset.metadata.rewardBinding !== void 0) {
-    const reference = taskset.metadata.rewardBinding;
-    if (!execution || !reference || reference.id !== execution.binding.id || reference.revision !== execution.binding.revision || reference.contentHash !== execution.binding.contentHash) {
-      throw new Error("Portable Taskset requires its exact published Reward binding.");
-    }
-  }
-  if (execution) compileBoundGraders2(execution.binding, execution.rewards);
-  return execution ? { binding: execution.binding, rewards: execution.rewards } : null;
-}
-function materializePortableTasksetRelease(input) {
-  const environment = portableEnvironment(input.taskset);
-  const tools = portableTools(input.taskset);
-  const learning = input.taskset.metadata.learning === void 0 ? null : TaskBatchPackageMetadataSchema.parse(input.taskset.metadata.learning);
-  const embedded = input.taskset.metadata.rewardExecution;
-  const rewardExecution = resolvePortableTasksetRewardExecution(input.taskset, input.rewardExecution);
-  const graders = rewardExecution ? compileBoundGraders2(rewardExecution.binding, rewardExecution.rewards) : input.taskset.graders.map(portableGrader);
-  const tasks = input.selectedTasks?.length ? input.selectedTasks : input.taskset.tasks;
-  if (!tasks.length) throw new Error("A portable Taskset release requires at least one task.");
-  const pinned = input.taskset.environment.metadata.portableExecutionResources;
-  if (environment.entrypoint === "openpond.javascript-environment.v1" && !pinned) throw new Error("Tool Taskset publication requires its pinned execution resources.");
-  const environmentRelease = pinned ? EnvironmentReleaseSchema.parse(pinned.environment) : createEnvironmentRelease({
-    schemaVersion: "openpond.environmentRelease.v1",
-    id: `environment-release-${input.taskset.id}-r${input.taskset.revision}`,
-    revision: input.taskset.revision,
-    contract: environment,
-    actionSchemaRef: null,
-    observationSchemaRef: null,
-    stateSchemaRef: null,
-    artifactCollection: {
-      maxArtifacts: 1e5,
-      maxTotalBytes: 25e7
-    },
-    adapterConformanceHashes: {
-      [input.adapterId]: contentHash({ adapterId: input.adapterId, environment, tools })
-    },
-    metadata: {
-      sourceTasksetId: input.taskset.id,
-      sourcePackageHash: input.taskset.metadata.sourcePackageHash ?? null,
-      resources: input.taskset.environment.resources ?? []
-    }
-  });
-  const verifierSetRelease = pinned?.verifierSet !== void 0 ? VerifierSetReleaseSchema.parse(pinned.verifierSet) : createVerifierSetRelease2({
-    schemaVersion: "openpond.verifierSetRelease.v1",
-    id: `verifier-set-release-${input.taskset.id}-r${input.taskset.revision}`,
-    revision: input.taskset.revision,
-    graders,
-    isolation: {
-      processBoundary: "isolated_process",
-      networkPolicy: "none",
-      defaultTimeoutMs: Math.min(input.taskset.environment.defaultTimeoutMs, 3e5)
-    },
-    calibrationReceiptRefs: [],
-    metadata: { sourceTasksetId: input.taskset.id }
-  });
-  if (!verifyEnvironmentRelease(environmentRelease) || !verifyVerifierSetRelease(verifierSetRelease) || contentHash(environmentRelease.contract) !== contentHash(environment) || contentHash(verifierSetRelease.graders) !== contentHash(graders)) {
-    throw new Error("Taskset execution resources differ from its declared environment or graders.");
-  }
-  const tasksetContent = TasksetReleaseContentSchema.parse({
-    schemaVersion: "openpond.tasksetRelease.v2",
-    id: input.taskset.metadata.derivedPortableMetadata === void 0 ? `taskset-release-${input.taskset.id}-r${input.taskset.revision}` : input.taskset.id,
-    revision: input.taskset.revision,
-    policy: {
-      policyVisibleFields: input.taskset.policy.policyVisibleFields,
-      privilegedFields: input.taskset.policy.privilegedFields,
-      hiddenGraderRefs: input.taskset.policy.hiddenGraderRefs,
-      connectedAppScopes: input.taskset.policy.connectedAppScopes
-    },
-    environment,
-    tools,
-    capabilities: portableCapabilities(input.taskset),
-    tasks: tasks.map(projectPortableTaskRecord),
-    graders,
-    ...input.taskset.metrics ? { metrics: input.taskset.metrics } : {},
-    metadata: input.taskset.metadata.derivedPortableMetadata ?? {
-      sourceTasksetId: input.taskset.id,
-      sourceTasksetHash: input.taskset.contentHash,
-      sourcePackageHash: input.taskset.metadata.sourcePackageHash ?? null,
-      environmentResources: input.taskset.environment.resources ?? [],
-      ordinaryAuthoring: {
-        instructions: input.taskset.objective,
-        graderFixtures: input.taskset.graderFixtures,
-        judgeCalibrationFixtures: Object.fromEntries(input.taskset.graders.filter((grader) => grader.kind === "model_judge").map((grader) => [grader.id, grader.calibrationFixtureRefs]))
-      },
-      ...learning ? { learning } : {},
-      // A sealed batch already pins these resources in learning metadata.
-      // Resolving that same binding at admission must not change its release.
-      ...rewardExecution && !learning && (input.rewardExecution || embedded) ? { rewardExecution: { binding: rewardExecution.binding, rewards: rewardExecution.rewards } } : {}
-    }
-  });
-  const draft = input.admittedTasksetRelease ? TasksetReleaseSchema2.parse(input.admittedTasksetRelease) : TasksetReleaseSchema2.parse({
-    ...tasksetContent,
-    contentHash: contentHash(tasksetContent)
-  });
-  const tasksetRelease = draft.environmentRelease ? assertReleaseBindings({ draft, environmentRelease, verifierSetRelease }) : bindTasksetExecutionReleases({
-    taskset: draft,
-    environment: environmentRelease,
-    verifierSet: verifierSetRelease
-  });
-  return { environmentRelease, verifierSetRelease, tasksetRelease };
-}
-function projectPreferenceComparisonRelease(input) {
-  if (!verifyPreferenceComparisonRelease(input.preferenceComparison)) {
-    throw new Error("Preference comparison release failed immutable content verification.");
-  }
-  const release = input.preferenceComparison;
-  if (release.tasksetRelease.id !== input.tasksetRelease.id || release.tasksetRelease.contentHash !== input.tasksetRelease.contentHash) {
-    throw new Error("Preference comparison release must reference the admitted portable Taskset release.");
-  }
-  return release;
-}
-function portableTasksetEnvironment(taskset) {
-  return portableEnvironment(taskset);
-}
-function portableTasksetTools(taskset) {
-  return portableTools(taskset);
-}
-function projectPortableTaskRecord(task) {
-  const admitted = task.metadata.portableTaskRecord;
-  if (admitted !== void 0) {
-    const original = TaskRecordSchema.parse(admitted);
-    const projected = TaskRecordSchema.parse({
-      ...original,
-      id: task.id,
-      clusterKey: task.clusterKey,
-      split: task.split,
-      input: task.input,
-      expectedOutput: portableExpectedOutput(task),
-      policyVisibleContext: task.policyVisibleContext,
-      privilegedContextRef: task.privilegedContextRef,
-      tags: task.tags,
-      artifactRefs: task.assets === void 0 ? original.artifactRefs : task.assets.map((asset) => {
-        const previous = original.artifactRefs.find((item) => item.id === asset.id);
-        return {
-          id: asset.id,
-          path: previous?.path ?? `tasks/${segment(task.id)}/${segment(asset.fileName)}`,
-          contentHash: hash(asset.sha256),
-          sizeBytes: asset.sizeBytes,
-          mediaType: asset.mediaType,
-          visibility: previous?.visibility ?? "policy"
-        };
-      }),
-      requiredOutputs: task.requiredOutputs === void 0 ? original.requiredOutputs : task.requiredOutputs.map((output) => {
-        const previous = original.requiredOutputs?.find((item) => item.path === output.path);
-        return {
-          path: output.path,
-          mediaType: output.mediaType,
-          schemaRef: previous?.schemaRef && previous.schemaRef.id === output.schemaRef ? previous.schemaRef : null,
-          maxBytes: output.maxBytes ?? null,
-          metadata: {
-            ...output.metadata,
-            ...output.schemaRef && previous?.schemaRef?.id !== output.schemaRef ? { legacySchemaRef: output.schemaRef } : {}
-          }
-        };
-      })
-    });
-    if (projected.requiredOutputs === void 0) delete projected.requiredOutputs;
-    return projected;
-  }
-  return {
-    id: task.id,
-    clusterKey: task.clusterKey,
-    split: task.split,
-    input: task.input,
-    expectedOutput: portableExpectedOutput(task),
-    policyVisibleContext: task.policyVisibleContext,
-    privilegedContextRef: task.privilegedContextRef,
-    artifactRefs: (task.assets ?? []).map((item) => ({
-      id: item.id,
-      path: `tasks/${segment(task.id)}/${segment(item.fileName)}`,
-      contentHash: hash(item.sha256),
-      sizeBytes: item.sizeBytes,
-      mediaType: item.mediaType,
-      visibility: "policy"
-    })),
-    requiredOutputs: (task.requiredOutputs ?? []).map((output) => ({
-      path: output.path,
-      mediaType: output.mediaType,
-      schemaRef: null,
-      maxBytes: output.maxBytes ?? null,
-      metadata: {
-        ...output.metadata,
-        legacySchemaRef: output.schemaRef ?? null
-      }
-    })),
-    tags: task.tags
-  };
-}
-function portableExpectedOutput(task) {
-  if (!task.expectedOutput) return null;
-  if ("artifactRenderer" in task.expectedOutput) {
-    throw new Error(
-      `Task ${task.id} embeds an artifact renderer. Put shared renderer configuration in Environment resources and reference it from the Scenario.`
-    );
-  }
-  return task.expectedOutput;
-}
-function portableEnvironment(taskset) {
-  const kind = taskset.environment.kind === "chat" ? "text" : taskset.environment.kind === "work" ? "work" : taskset.environment.kind === "program" ? "custom_program" : "agent";
-  return {
-    protocolVersion: "openpond.environment.v1",
-    kind,
-    entrypoint: taskset.environment.entrypoint,
-    stateful: taskset.environment.stateful,
-    deterministicSeeds: taskset.environment.deterministicSeeds,
-    lifecycle: ["create", "reset", "step", "collect", "destroy"],
-    networkPolicy: taskset.environment.networkPolicy,
-    defaultTimeoutMs: taskset.environment.defaultTimeoutMs
-  };
-}
-function portableTools(taskset) {
-  const admitted = taskset.environment.metadata.portableTools;
-  if (admitted !== void 0) {
-    return ToolDeclarationSchema.array().max(200).parse(admitted);
-  }
-  const bindings = taskset.environment.actionBindings ?? [];
-  if (bindings.length) return bindings.map((binding) => ({
-    name: binding.modelToolName,
-    description: binding.description,
-    inputSchema: binding.inputSchema,
-    inputSchemaHash: hash(binding.actionSchemaHash),
-    sideEffect: binding.sideEffect,
-    timeoutMs: binding.timeoutMs
-  }));
-  return taskset.environment.toolNames.map((name) => ({
-    name,
-    description: `Host-provided ${name} tool.`,
-    inputSchema: {},
-    inputSchemaHash: contentHash({}),
-    sideEffect: "write",
-    timeoutMs: taskset.environment.defaultTimeoutMs
-  }));
-}
-function portableGrader(grader) {
-  const base = {
-    id: grader.id,
-    version: grader.version,
-    weight: grader.weight,
-    hardGate: grader.hardGate,
-    rewardEligible: grader.rewardEligible,
-    privileged: grader.privileged
-  };
-  if (grader.kind === "model_judge") return {
-    ...base,
-    kind: "model_judge",
-    rubricRef: rubricAsset(grader),
-    model: modelJudgeRef(grader),
-    temperature: grader.temperature,
-    calibrationStatus: grader.calibrationStatus
-  };
-  if (grader.kind === "custom_verifier") {
-    if (grader.metadata.portableVerifierRef === void 0) {
-      throw new Error(`Custom verifier ${grader.id} requires its immutable executable asset before publication.`);
-    }
-    const imported = PortableGraderSpecSchema.safeParse(grader.metadata.portableGrader);
-    const preserveDefault = imported.success && imported.data.kind === "custom_verifier" && imported.data.exportName === void 0 && grader.exportName === "verify";
-    return {
-      ...base,
-      kind: "custom_verifier",
-      verifierRef: ImmutableAssetRefSchema.parse(grader.metadata.portableVerifierRef),
-      timeoutMs: grader.timeoutMs,
-      ...preserveDefault ? {} : { exportName: grader.exportName },
-      networkPolicy: "none"
-    };
-  }
-  if (grader.kind === "human") return {
-    ...base,
-    kind: "human",
-    rubricRef: rubricAsset(grader),
-    reviewerRole: grader.reviewerRole
-  };
-  return {
-    ...base,
-    ...portableDeterministicCheck(grader)
-  };
-}
-function portableCapabilities(taskset) {
-  const admitted = taskset.metadata.portableCapabilities;
-  if (admitted !== void 0) {
-    return CapabilityRequirementSchema.array().max(200).parse(admitted);
-  }
-  return [
-    ...taskset.capabilities.requiresTools ? [{ id: "tools", required: true, scopes: taskset.environment.toolNames }] : [],
-    ...taskset.capabilities.requiresState ? [{ id: "local-state", required: true, scopes: [] }] : [],
-    ...taskset.capabilities.requiresPrivilegedGrading ? [{ id: "private-verifier", required: true, scopes: taskset.policy.hiddenGraderRefs }] : [],
-    ...taskset.policy.connectedAppScopes.map((scope) => ({
-      id: `connected-app-${segment(scope)}`,
-      required: true,
-      scopes: [scope]
-    }))
-  ].map((requirement) => ({
-    ...requirement,
-    portability: requirement.id === "local-state" ? "host_adapter" : "portable"
-  }));
-}
-function assertReleaseBindings(input) {
-  if (input.draft.environmentRelease?.id !== input.environmentRelease.id || input.draft.environmentRelease.contentHash !== input.environmentRelease.contentHash) {
-    throw new Error("Admitted Taskset Release binds a different Environment Release.");
-  }
-  if (input.draft.verifierSetRelease?.id !== input.verifierSetRelease.id || input.draft.verifierSetRelease.contentHash !== input.verifierSetRelease.contentHash) {
-    throw new Error("Admitted Taskset Release binds a different Verifier Set Release.");
-  }
-  if (contentHash(input.draft.environment) !== contentHash(input.environmentRelease.contract)) {
-    throw new Error("Admitted Taskset Environment differs from its bound Environment Release.");
-  }
-  if (contentHash(input.draft.graders) !== contentHash(input.verifierSetRelease.graders)) {
-    throw new Error("Admitted Taskset graders differ from its bound Verifier Set Release.");
-  }
-  return input.draft;
-}
-function modelJudgeRef(grader) {
-  const previous = grader.metadata.portableGrader === void 0 ? null : PortableGraderSpecSchema.parse(grader.metadata.portableGrader);
-  const revision = previous?.kind === "model_judge" && previous.model?.providerId === grader.judge.providerId && previous.model.modelId === grader.judge.modelId ? previous.model.revision : null;
-  return { ...grader.judge, revision };
-}
-function rubricAsset(grader) {
-  const contentHash2 = sha256(grader.rubric);
-  const sizeBytes = new TextEncoder().encode(grader.rubric).byteLength;
-  const reference = grader.metadata.portableRubricRef;
-  if (reference !== void 0) {
-    const asset = ImmutableAssetRefSchema.parse(reference);
-    if (asset.contentHash !== contentHash2 || asset.sizeBytes !== sizeBytes || asset.visibility === "policy") throw new Error("Taskset rubric differs from its published private source.");
-    return asset;
-  }
-  return { id: `rubric-${grader.id}`, path: `graders/${segment(grader.id)}/rubric.md`, contentHash: contentHash2, sizeBytes, mediaType: "text/markdown", visibility: "verifier" };
-}
-function hash(value) {
-  return /^[a-f0-9]{64}$/.test(value) ? value : contentHash(value);
-}
-function segment(value) {
-  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized || "asset";
-}
-
-// src/taskset-package-projection.ts
-import { learningRef as learningRef5, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
-
-// src/taskset-package-grader-projection.ts
-import { compileBoundGraders as compileBoundGraders3, resolveBoundRewards as resolveBoundRewards2 } from "@openpond/evals/rewards";
-import { learningRef as learningRef4, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
-import { z } from "zod";
-function importedPackageGraders(value) {
-  const authoring = value.taskset.metadata.ordinaryAuthoring;
-  const calibrationFixtures = z.record(z.string(), z.array(z.string().min(1)).max(1e5)).parse(authoring?.judgeCalibrationFixtures ?? {});
-  return value.taskset.graders.map((grader) => {
-    const base = { ...grader, label: grader.id, metadata: { portableGrader: grader } };
-    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
-      ...base,
-      module: learningVerifierModule(grader.verifierRef.contentHash),
-      exportName: grader.exportName ?? "verify",
-      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
-    });
-    if (grader.kind === "human" || grader.kind === "model_judge") {
-      const file = value.files.find((file2) => file2.asset.id === grader.rubricRef.id);
-      if (!file) throw new Error(`Imported rubric is missing: ${grader.id}.`);
-      const rubric = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-      const metadata = { ...base.metadata, portableRubricRef: grader.rubricRef };
-      if (grader.kind === "human") return GraderSpecSchema.parse({ ...base, rubric, metadata });
-      if (!grader.model) throw new Error(`Imported judge ${grader.id} requires its declared model before local preparation.`);
-      return GraderSpecSchema.parse({
-        ...base,
-        rubric,
-        metadata,
-        judge: grader.model,
-        temperature: grader.temperature ?? 0,
-        calibrationStatus: "pending",
-        calibrationFixtureRefs: calibrationFixtures[grader.id] ?? []
-      });
-    }
-    return GraderSpecSchema.parse({
-      ...base,
-      kind: grader.kind === "artifact" ? "file" : grader.kind,
-      config: grader.kind === "artifact" ? { ...grader.config, ...grader.config.refIncludes === void 0 ? {} : { pathIncludes: grader.config.refIncludes } } : grader.config
-    });
-  });
-}
-function projectLearningBatchGraders(binding, rewards, assets = []) {
-  const resolved = resolveBoundRewards2(binding, rewards);
-  return compileBoundGraders3(binding, rewards).map((grader) => {
-    const reward = resolved.find(({ source }) => source.graderId === grader.id).reward;
-    const base = { ...grader, label: reward.name, metadata: { rewardBinding: learningRef4(binding) } };
-    if (grader.kind === "model_judge") throw new Error(`Reward ${grader.id} needs a calibrated model execution adapter before preparation.`);
-    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
-      ...base,
-      module: learningVerifierModule(grader.verifierRef.contentHash),
-      exportName: grader.exportName ?? "verify",
-      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
-    });
-    if (grader.kind === "human") {
-      const asset = assets.find((asset2) => asset2.id === grader.rubricRef.id);
-      if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable rubric.`);
-      return GraderSpecSchema.parse({ ...base, rubric: verifyLearningTextAsset2(asset, grader.rubricRef) });
-    }
-    return GraderSpecSchema.parse({ ...base, kind: grader.kind === "artifact" ? "file" : grader.kind });
-  });
-}
-function learningVerifierModule(hash2) {
-  return `graders/reward-${hash2}.js`;
-}
-
 // src/taskset-package-projection.ts
+import { learningRef as learningRef4, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
 function prepareImportedTasksetPackage(input) {
   const value = validateTasksetPackage(input.package);
   const release = value.taskset;
@@ -827,7 +413,7 @@ function prepareImportedTasksetPackage(input) {
     const file = value.files.find((file2) => file2.asset.id === grader.verifierRef.id);
     if (!file) throw new Error(`Imported verifier source is missing: ${grader.id}.`);
     const name = learningVerifierModule(grader.verifierRef.contentHash);
-    if (!files.some((file2) => file2.path === name)) files.push({ path: name, role: "verifier", content: asset ? verifyLearningTextAsset3(asset, grader.verifierRef) : new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file)) });
+    if (!files.some((file2) => file2.path === name)) files.push({ path: name, role: "verifier", content: asset ? verifyLearningTextAsset2(asset, grader.verifierRef) : new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file)) });
   }
   const authoring = release.metadata.ordinaryAuthoring ?? release.metadata.starterAuthoring;
   const fixtures = GraderFixtureSchema.array().max(1e5).parse(authoring?.graderFixtures ?? []);
@@ -919,8 +505,8 @@ function prepareImportedTasksetPackage(input) {
       ...learning ? { learning } : {},
       portableFileInventory: value.files.map((file) => ({ asset: file.asset, sourcePath: file.asset.path })),
       ...resources ? {
-        taskDefinition: learningRef5(resources.taskDefinition),
-        rewardBinding: learningRef5(resources.rewardBinding),
+        taskDefinition: learningRef4(resources.taskDefinition),
+        rewardBinding: learningRef4(resources.rewardBinding),
         rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards }
       } : {},
       portableCapabilities: release.capabilities,
@@ -935,12 +521,12 @@ function tasksetPackageSourceId(profileId, packageHash) {
 }
 
 // src/taskset-authored-files.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 
 // src/taskset-authored-tool-environment.ts
-import { createEnvironmentRelease as createEnvironmentRelease2 } from "@openpond/evals";
+import { createEnvironmentRelease } from "@openpond/evals";
 import { JavaScriptEnvironmentDefinitionSchema } from "@openpond/evals/javascript-environment";
-import { learningRef as learningRef6, sealLearningContent as sealLearningContent3 } from "@openpond/evals/learning";
+import { learningRef as learningRef5, sealLearningContent as sealLearningContent3 } 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";
@@ -961,7 +547,7 @@ function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
     module: repin(previous.javascript.module)
   }));
   if (contentHash(javascript.tools) !== contentHash(taskset.environment.metadata.portableTools) || contentHash(javascript.tools.map((tool) => tool.name)) !== contentHash(taskset.environment.toolNames)) throw new Error("Authored environment tools differ from the Taskset's declared tools.");
-  const environment = createEnvironmentRelease2({
+  const environment = createEnvironmentRelease({
     schemaVersion: "openpond.environmentRelease.v1",
     id: `environment-${taskset.id}`,
     revision: taskset.revision,
@@ -971,7 +557,7 @@ function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
     stateSchemaRef: repin(previous.environment.stateSchemaRef),
     artifactCollection: previous.environment.artifactCollection,
     adapterConformanceHashes: {},
-    metadata: { javascriptEnvironment: learningRef6(javascript), resources: taskset.environment.resources ?? [] }
+    metadata: { javascriptEnvironment: learningRef5(javascript), resources: taskset.environment.resources ?? [] }
   });
   const prepared = TasksetSchema.parse({ ...taskset, environment: {
     ...taskset.environment,
@@ -989,9 +575,9 @@ function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
 }
 
 // src/taskset-authored-files.ts
-var AuthoredTasksetFileInventorySchema = z2.array(z2.object({
+var AuthoredTasksetFileInventorySchema = z.array(z.object({
   asset: ImmutableAssetRefSchema,
-  sourcePath: z2.string().min(1)
+  sourcePath: z.string().min(1)
 }).strict()).max(1e4);
 var GENERATED_MANIFESTS = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "environment/taskset.ts"]);
 function isGeneratedTasksetPublicationFilePath(path) {
@@ -1064,7 +650,7 @@ function prepareAuthoredTasksetSource(tasksetInput, sourceFiles, adapterId) {
   const { importedPackageHash, derivedPortableMetadata: _derived, ...metadata } = taskset.metadata;
   const environmentMetadata = { ...taskset.environment.metadata };
   if (environmentMetadata.portableExecutionResources !== void 0) {
-    const resources = z2.object({ environment: z2.unknown(), verifierSet: z2.unknown().optional() }).parse(environmentMetadata.portableExecutionResources);
+    const resources = z.object({ environment: z.unknown(), verifierSet: z.unknown().optional() }).parse(environmentMetadata.portableExecutionResources);
     environmentMetadata.portableExecutionResources = { environment: resources.environment };
   }
   const prepared = TasksetSchema.parse({
@@ -1105,17 +691,17 @@ function compileModelTasksetDraftWorkspace(input) {
 }
 
 // src/taskset-draft-source.ts
-import { z as z3 } from "zod";
-import { learningRef as learningRef7, sameLearningRef as sameLearningRef4 } from "@openpond/evals/learning";
-var TasksetDraftSourceInitializationSchema = z3.object({
+import { z as z2 } from "zod";
+import { learningRef as learningRef6, sameLearningRef as sameLearningRef4 } from "@openpond/evals/learning";
+var TasksetDraftSourceInitializationSchema = z2.object({
   draft: TasksetDraftSchema,
-  filePaths: z3.array(z3.object({ assetId: z3.string().min(1), paths: z3.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
+  filePaths: z2.array(z2.object({ assetId: z2.string().min(1), paths: z2.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
 }).strict();
 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(learningRef7(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
+  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.");
   const inventory = AuthoredTasksetFileInventorySchema.parse(original.metadata.portableFileInventory ?? []);
   const sourcePath = (relative) => isManagedTasksetDraftFilePath(relative) ? `source-artifacts/${source.contentHash}/${contentHash(relative)}/${relative.split("/").at(-1)}` : relative;