openpond-sdk 0.2.4 → 0.3.0

package/dist/taskset-packages.js

@@ -1,5 +1,5 @@
 // src/taskset-package-contracts.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // ../harness/dist/common.js
 import { z } from "zod";
@@ -2136,6 +2136,18 @@ var ModelStarterExecutionSchema = z12.object({
 var ModelStarterToolFixtureScriptSchema = z12.object({
   actions: z12.array(z12.object({ name: z12.string().min(1).max(64), arguments: z12.record(z12.string(), z12.unknown()) }).strict()).max(1e3)
 }).strict();
+function modelStarterExecutionAssetId(context) {
+  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
+  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
+}
+function createModelStarterExecutionAsset(value) {
+  const execution = ModelStarterExecutionSchema.parse(value);
+  assertExecutionIntegrity(execution);
+  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });
+  const generated = createLearningTextAsset({ text: canonicalJson2(execution), path: "environment/execution.json", mediaType: "application/json", visibility: "host_private" });
+  const { contentHash: _hash, ...content } = generated;
+  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });
+}
 function equal(left, right) {
   return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
 }
@@ -2601,34 +2613,138 @@ function validateTasksetLearningResources(taskset, input) {
   return resources;
 }
 
-// src/taskset-package-contracts.ts
+// src/model-taskset-authoring-lineage.ts
+import { sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
+
+// src/model-taskset-authoring-contracts.ts
+import { z as z17 } from "zod";
+import { LearningRevisionRefSchema } from "@openpond/evals/learning";
+var IdSchema3 = LearningRevisionRefSchema.shape.id;
+var HashSchema4 = z17.string().regex(/^[a-f0-9]{64}$/);
+var ModelTasksetAuthoringOwnerSchema = z17.object({ scopeId: IdSchema3, modelId: IdSchema3 }).strict();
+var ModelTasksetAuthoringSchema = z17.object({
+  schemaVersion: z17.literal("openpond.modelTasksetAuthoring.v1"),
+  owner: ModelTasksetAuthoringOwnerSchema,
+  root: LearningRevisionRefSchema,
+  parent: LearningRevisionRefSchema
+}).strict();
+var ModelTasksetDraftRequestSchema = z17.object({
+  schemaVersion: z17.literal("openpond.modelTasksetDraftRequest.v1"),
+  operationId: IdSchema3,
+  modelId: IdSchema3,
+  expectedModelRevision: z17.number().int().positive(),
+  sourcePackageHash: HashSchema4
+}).strict();
+var ModelTasksetDraftPreparationSchema = z17.object({
+  schemaVersion: z17.literal("openpond.modelTasksetDraftPreparation.v1"),
+  draftId: IdSchema3,
+  requestHash: HashSchema4,
+  sourcePackageHash: HashSchema4,
+  sourceTasksetRef: LearningRevisionRefSchema,
+  tasksetId: IdSchema3,
+  tasksetRevision: z17.number().int().positive(),
+  lineage: ModelTasksetAuthoringSchema
+}).strict();
+var TasksetDraftFilePathSchema = z17.string().min(1).max(1024).refine((value) => !value.includes("\\") && !value.includes(":") && !value.includes("\0") && !value.startsWith("/") && !value.split("/").some((part) => !part || part === "." || part === ".." || part.startsWith(".env")), "Use a relative Taskset file path without environment files.");
+var TasksetDraftFileInfoSchema = z17.object({
+  path: TasksetDraftFilePathSchema,
+  sizeBytes: z17.number().int().nonnegative(),
+  writable: z17.boolean()
+}).strict();
+var TasksetDraftFileContentSchema = z17.object({ encoding: z17.enum(["utf8", "base64"]), data: z17.string().max(8e6) }).strict();
+var TasksetDraftFileSchema = TasksetDraftFileInfoSchema.extend({ contentHash: HashSchema4, content: TasksetDraftFileContentSchema }).strict();
+var TasksetDraftFileMutationSchema = z17.object({
+  draftId: IdSchema3,
+  expectedDraftRevision: z17.number().int().positive(),
+  path: TasksetDraftFilePathSchema,
+  expectedFileHash: HashSchema4.nullable(),
+  content: TasksetDraftFileContentSchema.nullable()
+}).strict();
+
+// src/model-taskset-authoring-lineage.ts
+function modelAuthoredTasksetId(lineage) {
+  return `model-authored-taskset-${contentHash({ owner: lineage.owner, root: lineage.root })}`;
+}
+function assertModelTasksetAuthoring(taskset) {
+  if (taskset.metadata.modelTasksetAuthoring === void 0) return null;
+  const lineage = ModelTasksetAuthoringSchema.parse(taskset.metadata.modelTasksetAuthoring);
+  if (taskset.id !== modelAuthoredTasksetId(lineage) || (taskset.revision === 1 ? !sameLearningRef3(lineage.parent, lineage.root) : lineage.parent.id !== taskset.id || lineage.parent.revision !== taskset.revision - 1)) {
+    throw new Error("Authored Taskset revision differs from its ownership lineage.");
+  }
+  return lineage;
+}
+
+// src/taskset-package-execution.ts
+import { LearningTextAssetSchema as LearningTextAssetSchema3, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
+
+// src/taskset-package-files.ts
+import { z as z18 } from "zod";
 var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z17.object({
+var TasksetPackageFileSchema = z18.object({
   asset: ImmutableAssetRefSchema,
-  base64: z17.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
+  base64: z18.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
 }).strict();
+function decodeTasksetPackageFile(value) {
+  const file = TasksetPackageFileSchema.parse(value);
+  const raw = atob(file.base64);
+  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
+  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
+  return bytes;
+}
+
+// src/taskset-package-execution.ts
+function resolveTasksetPackageExecution(input) {
+  if (input.taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return null;
+  const byId = new Map(input.files.map((file) => [file.asset.id, file]));
+  const read = (id) => {
+    const file = byId.get(id);
+    if (!file) throw new Error(`Taskset environment asset is missing: ${id}.`);
+    if (file.asset.sizeBytes > 524288) throw new Error("Taskset environment source exceeds the authored asset limit.");
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
+    return LearningTextAssetSchema3.parse(sealLearningContent4({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text }));
+  };
+  let execution;
+  if (input.modelResources) {
+    if (!input.modelResources.execution) throw new Error("Bound Taskset JavaScript execution resources are missing.");
+    execution = ModelStarterExecutionSchema.parse(input.modelResources.execution);
+  } else {
+    const declaration = read(modelStarterExecutionAssetId(input.taskset));
+    if (declaration.asset.visibility !== "host_private" || declaration.asset.mediaType !== "application/json" || declaration.asset.path !== "environment/execution.json") throw new Error("Taskset execution declaration must be private JSON at environment/execution.json.");
+    execution = ModelStarterExecutionSchema.parse(JSON.parse(declaration.text));
+  }
+  const ids = /* @__PURE__ */ new Set([
+    execution.javascript.module.id,
+    ...[execution.environment.actionSchemaRef, execution.environment.observationSchemaRef, execution.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
+    ...input.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : [])
+  ]);
+  const assets = [...ids].map(read);
+  validateModelStarterExecution(execution, input.taskset, assets);
+  return { execution, assets };
+}
+function createTasksetPackageExecutionFile(execution) {
+  const asset = createModelStarterExecutionAsset(execution);
+  const bytes = new TextEncoder().encode(asset.text);
+  let raw = "";
+  for (const byte of bytes) raw += String.fromCharCode(byte);
+  return { asset: asset.asset, base64: btoa(raw) };
+}
+
+// src/taskset-package-contracts.ts
 var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackage.v1"),
+var TasksetPackageContentSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackage.v1"),
   taskset: TasksetReleaseSchema2,
   environment: EnvironmentReleaseSchema3,
   verifierSet: VerifierSetReleaseSchema3,
-  files: z17.array(TasksetPackageFileSchema).max(1e4),
+  files: z19.array(TasksetPackageFileSchema).max(1e4),
   modelResources: BoundModelResourcesSchema.optional(),
   learningResources: TasksetPackageLearningResourcesSchema.optional()
 }).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z17.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z19.string().regex(/^[a-f0-9]{64}$/) }).strict();
 function tasksetPackageRewardBinding(value) {
   return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
 }
-function decodeTasksetPackageFile(value) {
-  const file = TasksetPackageFileSchema.parse(value);
-  const raw = atob(file.base64);
-  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
-  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
-  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
-  return bytes;
-}
 function validateTasksetPackage(value) {
   assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
   const result = TasksetPackageSchema.parse(value);
@@ -2636,6 +2752,8 @@ function validateTasksetPackage(value) {
   if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
   const { taskset, environment, verifierSet } = result;
   assertTasksetRelease2(taskset);
+  const authoring = assertModelTasksetAuthoring(taskset);
+  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
   if (!verifyEnvironmentRelease3(environment) || !verifyVerifierSetRelease3(verifierSet) || !same2(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same2(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same2(taskset.environment, environment.contract) || !same2(taskset.graders, verifierSet.graders)) {
     throw new Error("Taskset package execution releases do not match its Taskset.");
   }
@@ -2664,9 +2782,16 @@ function validateTasksetPackage(value) {
       if (ref.visibility === "policy") throw new Error(`Taskset grader asset must be private: ${ref.id}.`);
     }
   }
+  if (taskset.metrics?.customAggregator) {
+    const aggregator = taskset.metrics.customAggregator;
+    const modules = result.files.filter((file) => file.asset.path === aggregator.module);
+    if (modules.length !== 1 || modules[0].asset.contentHash !== aggregator.contentHash || modules[0].asset.sizeBytes > 524288 || modules[0].asset.visibility === "policy") {
+      throw new Error("Taskset metric module is missing or mismatched, public, or exceeds the source limit.");
+    }
+  }
   for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
     if (declarations === void 0) continue;
-    for (const resource of z17.array(z17.object({ path: z17.string().min(1) }).passthrough()).parse(declarations)) {
+    for (const resource of z19.array(z19.object({ path: z19.string().min(1) }).passthrough()).parse(declarations)) {
       if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
     }
   }
@@ -2683,6 +2808,7 @@ function validateTasksetPackage(value) {
   } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
     throw new Error("Bound Taskset publication requires its complete model resources.");
   }
+  resolveTasksetPackageExecution(result);
   return result;
 }
 function createTasksetPackage(value) {
@@ -2695,45 +2821,45 @@ function same2(left, right) {
 }
 
 // src/taskset-package-client.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 
 // src/taskset-catalog.ts
-import { z as z18 } from "zod";
-var IdSchema3 = z18.string().trim().min(1).max(500);
-var HashSchema4 = z18.string().regex(/^[a-f0-9]{64}$/);
-var TasksetCatalogReleaseRefSchema = z18.object({ id: IdSchema3, revision: z18.number().int().positive(), contentHash: HashSchema4 }).strict();
-var HostedTasksetSummarySchema = z18.object({
-  schemaVersion: z18.literal("openpond.hostedTasksetSummary.v1"),
-  id: IdSchema3,
-  teamId: IdSchema3,
+import { z as z20 } from "zod";
+var IdSchema4 = z20.string().trim().min(1).max(500);
+var HashSchema5 = z20.string().regex(/^[a-f0-9]{64}$/);
+var TasksetCatalogReleaseRefSchema = z20.object({ id: IdSchema4, revision: z20.number().int().positive(), contentHash: HashSchema5 }).strict();
+var HostedTasksetSummarySchema = z20.object({
+  schemaVersion: z20.literal("openpond.hostedTasksetSummary.v1"),
+  id: IdSchema4,
+  teamId: IdSchema4,
   release: TasksetCatalogReleaseRefSchema,
-  name: z18.string().min(1).max(500),
-  description: z18.string().max(2e4),
-  taskCount: z18.number().int().nonnegative(),
-  buildIntent: z18.string().min(1).max(100),
-  methodHint: z18.string().min(1).max(100).nullable(),
-  packageBytes: z18.number().int().nonnegative().nullable(),
-  storedBytes: z18.number().int().nonnegative().nullable(),
-  createdAt: z18.string().datetime({ offset: true })
-}).strict();
-var TasksetCatalogQuerySchema = z18.object({
-  afterId: IdSchema3.optional(),
-  limit: z18.number().int().min(1).max(100).default(30),
-  modelProjectId: IdSchema3.optional()
-}).strict();
-var TasksetCatalogPageSchema = z18.object({
-  items: z18.array(HostedTasksetSummarySchema).max(100),
-  nextCursor: IdSchema3.nullable()
-}).strict();
-var TasksetCatalogErrorSchema = z18.object({
-  code: z18.string().min(1),
-  message: z18.string().min(1)
+  name: z20.string().min(1).max(500),
+  description: z20.string().max(2e4),
+  taskCount: z20.number().int().nonnegative(),
+  buildIntent: z20.string().min(1).max(100),
+  methodHint: z20.string().min(1).max(100).nullable(),
+  packageBytes: z20.number().int().nonnegative().nullable(),
+  storedBytes: z20.number().int().nonnegative().nullable(),
+  createdAt: z20.string().datetime({ offset: true })
+}).strict();
+var TasksetCatalogQuerySchema = z20.object({
+  afterId: IdSchema4.optional(),
+  limit: z20.number().int().min(1).max(100).default(30),
+  modelProjectId: IdSchema4.optional()
+}).strict();
+var TasksetCatalogPageSchema = z20.object({
+  items: z20.array(HostedTasksetSummarySchema).max(100),
+  nextCursor: IdSchema4.nullable()
+}).strict();
+var TasksetCatalogErrorSchema = z20.object({
+  code: z20.string().min(1),
+  message: z20.string().min(1)
 }).strict();
 
 // src/taskset-package-client.ts
 import { learningRef as learningRef4 } from "@openpond/evals/learning";
-var IdSchema4 = z19.string().trim().min(1).max(500);
-var HashSchema5 = z19.string().regex(/^[a-f0-9]{64}$/);
+var IdSchema5 = z21.string().trim().min(1).max(500);
+var HashSchema6 = z21.string().regex(/^[a-f0-9]{64}$/);
 var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   portableProjectId: true,
   name: true,
@@ -2743,35 +2869,35 @@ var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   sourceRevision: true,
   sourceUpdatedAt: true
 }).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true, recipe: true }) }).strict();
-var TasksetPackagePublicationSchema = z19.object({
-  schemaVersion: z19.literal("openpond.tasksetPackagePublication.v1"),
-  operationId: IdSchema4,
-  modelProjectId: IdSchema4,
-  expectedProjectEtag: HashSchema5.nullable(),
-  name: z19.string().trim().min(1).max(200),
-  description: z19.string().max(5e3),
-  buildIntent: z19.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
-  methodHint: z19.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
+var TasksetPackagePublicationSchema = z21.object({
+  schemaVersion: z21.literal("openpond.tasksetPackagePublication.v1"),
+  operationId: IdSchema5,
+  modelProjectId: IdSchema5,
+  expectedProjectEtag: HashSchema6.nullable(),
+  name: z21.string().trim().min(1).max(200),
+  description: z21.string().max(5e3),
+  buildIntent: z21.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
+  methodHint: z21.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
   package: TasksetPackageSchema,
   modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
-  selection: z19.enum(["select", "attach"]).optional()
+  selection: z21.enum(["select", "attach"]).optional()
 }).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.");
-var TasksetPackageReceiptSchema = z19.object({
-  schemaVersion: z19.literal("openpond.tasksetPackageReceipt.v1"),
-  teamId: IdSchema4,
-  modelProjectId: IdSchema4,
-  operationId: IdSchema4,
+var TasksetPackageReceiptSchema = z21.object({
+  schemaVersion: z21.literal("openpond.tasksetPackageReceipt.v1"),
+  teamId: IdSchema5,
+  modelProjectId: IdSchema5,
+  operationId: IdSchema5,
   taskset: TasksetCatalogReleaseRefSchema,
-  packageHash: HashSchema5,
-  hostedTasksetId: IdSchema4,
-  projectEtag: HashSchema5,
+  packageHash: HashSchema6,
+  hostedTasksetId: IdSchema5,
+  projectEtag: HashSchema6,
   project: HostedModelProjectSummarySchema.optional(),
-  selection: z19.enum(["select", "attach"]).optional()
+  selection: z21.enum(["select", "attach"]).optional()
 }).strict();
-var TasksetPackageReadbackSchema = z19.object({
-  schemaVersion: z19.literal("openpond.tasksetPackageReadback.v1"),
-  teamId: IdSchema4,
-  modelProjectId: IdSchema4,
+var TasksetPackageReadbackSchema = z21.object({
+  schemaVersion: z21.literal("openpond.tasksetPackageReadback.v1"),
+  teamId: IdSchema5,
+  modelProjectId: IdSchema5,
   package: TasksetPackageSchema
 }).strict();
 var OpenPondTasksetPackageError = class extends Error {
@@ -2819,9 +2945,9 @@ var OpenPondTasksetPackageClient = class {
     return receipt;
   }
   async get(modelProjectId, reference, options = {}) {
-    const project = IdSchema4.parse(modelProjectId);
+    const project = IdSchema5.parse(modelProjectId);
     const ref = TasksetCatalogReleaseRefSchema.parse(reference);
-    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema5.parse(options.expectedPackageHash);
+    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema6.parse(options.expectedPackageHash);
     const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
     const taskset = response.package.taskset;
     if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
@@ -2858,16 +2984,374 @@ var OpenPondTasksetPackageClient = class {
     }
     const payload = JSON.parse(text);
     if (!response.ok) {
-      const error = z19.object({ code: z19.string(), message: z19.string() }).safeParse(payload);
+      const error = z21.object({ code: z21.string(), message: z21.string() }).safeParse(payload);
       throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
     }
     return payload;
   }
 };
+
+// src/model-batch-review.ts
+import {
+  LearningDomainError as LearningDomainError2,
+  learningRef as learningRef6,
+  sameLearningRef as sameLearningRef5,
+  requireLearningRelease,
+  requireLearningResource,
+  taskBatchPackageMetadata as taskBatchPackageMetadata4
+} from "@openpond/evals/learning";
+
+// src/model-batch-review-contracts.ts
+import { z as z22 } from "zod";
+import { LearningJsonObjectSchema, LearningRevisionRefSchema as LearningRevisionRefSchema2, LearningSourceSchema as LearningSourceSchema2, TaskEvidenceSchema as TaskEvidenceSchema2, TaskFeedbackSchema, TaskDefinitionSchema as TaskDefinitionSchema2, TaskAdmissionDecisionSchema as TaskAdmissionDecisionSchema2 } from "@openpond/evals/learning";
+import { RewardBindingSchema as RewardBindingSchema2 } from "@openpond/evals/rewards";
+var ReleaseIdSchema2 = LearningRevisionRefSchema2.shape.id;
+var ModelBatchReviewInspectionSchema = z22.object({
+  schemaVersion: z22.literal("openpond.modelBatchReviewInspection.v1"),
+  packageHash: z22.string().regex(/^[a-f0-9]{64}$/),
+  definition: TaskDefinitionSchema2,
+  binding: RewardBindingSchema2,
+  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
+  decisions: z22.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
+}).strict();
+var ModelBatchReviewRequestSchema = z22.object({
+  schemaVersion: z22.literal("openpond.modelBatchReviewRequest.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  expectedModelRevision: z22.number().int().positive(),
+  tasksetRef: LearningRevisionRefSchema2,
+  rewardBindingRef: LearningRevisionRefSchema2.nullable(),
+  definition: z22.object({
+    name: z22.string().trim().min(1).max(500).optional(),
+    instructions: z22.string().trim().min(1).max(2e4).optional(),
+    inputSchema: LearningJsonObjectSchema.optional(),
+    outputSchema: LearningJsonObjectSchema.optional()
+  }).strict(),
+  examples: z22.array(z22.object({
+    evidence: LearningRevisionRefSchema2,
+    input: LearningJsonObjectSchema.optional(),
+    expected: LearningJsonObjectSchema.nullable().optional(),
+    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),
+    proposedTarget: LearningJsonObjectSchema.nullable().optional()
+  }).strict()).max(1e4)
+}).strict();
+var ModelBatchReviewReceiptSchema = z22.object({
+  schemaVersion: z22.literal("openpond.modelBatchReviewReceipt.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  source: LearningSourceSchema2,
+  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
+  proposals: z22.array(TaskFeedbackSchema).max(1e4)
+}).strict();
+
+// src/model-batch-review-preparation.ts
+import {
+  LearningDomainError,
+  LearningSourceSchema as LearningSourceSchema3,
+  TaskDefinitionSchema as TaskDefinitionSchema3,
+  TaskEvidenceSchema as TaskEvidenceSchema3,
+  TaskFeedbackSchema as TaskFeedbackSchema2,
+  assertLearningContentHash as assertLearningContentHash3,
+  learningEvidenceId,
+  learningRef as learningRef5,
+  sameLearningRef as sameLearningRef4,
+  sealLearningContent as sealLearningContent5,
+  taskBatchPackageMetadata as taskBatchPackageMetadata3,
+  verifyLearningTextAsset as verifyLearningTextAsset5
+} from "@openpond/evals/learning";
+import { compileBoundGraders as compileBoundGraders2, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
+function prepareModelBatchReview(input) {
+  const { request, package: value } = input;
+  const learning = value.learningResources;
+  if (!learning) throw new LearningDomainError("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata3(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(learningRef5(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);
+  }
+  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash3(resource);
+  resolveBoundRewards(input.binding, input.rewards);
+  const rewardByHash = /* @__PURE__ */ new Map();
+  for (const source2 of input.binding.sources) {
+    const original = input.rewards.find((reward) => sameLearningRef4(learningRef5(reward), source2.reward));
+    const { contentHash: _hash, ...content } = original;
+    rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
+  }
+  const rewards = [...rewardByHash.values()];
+  const { contentHash: _bindingHash, recipeRef: _recipe, ...bindingContent } = input.binding;
+  const binding = createRewardBinding({
+    ...bindingContent,
+    id: `${id}-binding`,
+    revision: 1,
+    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef5(rewardByHash.get(source2.reward.contentHash)) }))
+  }, rewards);
+  const assetRefs = rewards.flatMap((reward) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]);
+  const assets = [...new Map(assetRefs.map((ref) => {
+    const asset = input.assets.find((asset2) => asset2.id === ref.id);
+    if (!asset) throw new LearningDomainError("model_review_reward_asset_missing", 422);
+    verifyLearningTextAsset5(asset, ref);
+    if (ref.visibility === "policy") throw new LearningDomainError("reward_asset_visibility_invalid", 422);
+    return [asset.id, asset];
+  })).values()];
+  const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
+  const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
+  const definition = TaskDefinitionSchema3.parse(sealLearningContent5({
+    ...definitionContent,
+    ...request.definition,
+    id: `${id}-definition`,
+    revision: 1,
+    rewardBinding: learningRef5(binding),
+    execution: {
+      ...execution,
+      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders2(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
+    }
+  }));
+  const source = LearningSourceSchema3.parse(sealLearningContent5({
+    schemaVersion: "openpond.learningSource.v1",
+    id,
+    revision: 1,
+    name: `${definition.name} review`,
+    kind: "direct",
+    taskDefinition: learningRef5(definition),
+    enabled: true,
+    allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
+    mapping: null,
+    adapterVersion: null,
+    reviewOrigin: {
+      modelId: request.modelId,
+      packageHash: value.contentHash,
+      taskset: learningRef5(value.taskset),
+      batch: learningRef5(learning.batch),
+      rewardBinding: learningRef5(input.binding)
+    }
+  }));
+  const evidence = learning.evidence.map((parent) => {
+    const edit = edits.get(contentHash(learningRef5(parent)));
+    const attemptId = `review-${parent.contentHash}`;
+    const policyChanged = contentHash({
+      instructions: definition.instructions,
+      inputSchema: definition.inputSchema,
+      outputSchema: definition.outputSchema,
+      input: edit?.input ?? parent.submission.input
+    }) !== contentHash({
+      instructions: metadata.definition.instructions,
+      inputSchema: metadata.definition.inputSchema,
+      outputSchema: metadata.definition.outputSchema,
+      input: parent.submission.input
+    });
+    return TaskEvidenceSchema3.parse(sealLearningContent5({
+      schemaVersion: "openpond.taskEvidence.v1",
+      id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
+      revision: 1,
+      source: learningRef5(source),
+      submission: {
+        ...parent.submission,
+        sourceId: source.id,
+        taskDefinition: learningRef5(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.
+        observedOutput: policyChanged ? null : parent.submission.observedOutput,
+        idempotencyKey: `${id}-${parent.contentHash}`,
+        ...edit?.input === void 0 ? {} : { input: edit.input },
+        ...edit?.expected === void 0 ? {} : { expected: edit.expected },
+        ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
+      },
+      supersedes: learningRef5(parent),
+      correctionFeedbackId: null,
+      receivedAt: input.now
+    }));
+  });
+  const proposals = evidence.flatMap((item) => {
+    const edit = edits.get(contentHash(item.supersedes));
+    const decision = decisions.get(contentHash(item.supersedes));
+    const target = edit?.proposedTarget === void 0 ? decision.approvedTarget : edit.proposedTarget;
+    return target === null ? [] : [TaskFeedbackSchema2.parse({
+      schemaVersion: "openpond.taskFeedbackRecord.v1",
+      id: `feedback-${contentHash([id, item.id])}`,
+      revision: 1,
+      submission: {
+        schemaVersion: "openpond.taskFeedback.v1",
+        sourceId: source.id,
+        idempotencyKey: `${id}-${item.id}`,
+        exampleId: item.submission.exampleId,
+        attemptId: item.submission.attemptId,
+        expectedEvidenceHash: item.contentHash,
+        occurredAt: input.now,
+        kind: "target_correction",
+        value: target,
+        note: "Proposed target for the revised task. Grade and review before admission."
+      },
+      status: "pending_review",
+      evidence: learningRef5(item),
+      createdAt: input.now,
+      review: null
+    })];
+  });
+  return { source, definition, binding, rewards, assets, evidence, proposals };
+}
+
+// src/model-batch-review.ts
+import { LearningDomainError as LearningDomainError3 } from "@openpond/evals/learning";
+var operation = (request) => `model-batch-review-${contentHash([request.modelId, request.operationId])}`;
+function inspectModelBatchPackage(raw) {
+  const value = validateTasksetPackage(raw);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  return ModelBatchReviewInspectionSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewInspection.v1",
+    packageHash: value.contentHash,
+    definition: metadata.definition,
+    binding: metadata.binding,
+    evidence: value.learningResources.evidence,
+    decisions: value.learningResources.decisions
+  });
+}
+async function findModelBatchReview(transaction, raw) {
+  const request = ModelBatchReviewRequestSchema.parse(raw);
+  const prior = await transaction.operation(operation(request));
+  if (!prior) return null;
+  if (prior.requestHash !== contentHash(request)) throw new LearningDomainError2("learning_idempotency_conflict", 409);
+  return readReceipt(transaction, request, prior.resources);
+}
+async function beginModelBatchReview(transaction, input) {
+  const request = ModelBatchReviewRequestSchema.parse(input.request);
+  const prior = await findModelBatchReview(transaction, request);
+  if (prior) return prior;
+  const value = validateTasksetPackage(input.package);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  const selected = request.rewardBindingRef;
+  const retained = !selected || sameLearningRef5(selected, learningRef6(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) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]).map((asset) => asset.id));
+  const assets = retained ? value.learningResources.assets : await Promise.all([...assetIds].map((id) => requireLearningResource(transaction, "asset", id, 1)));
+  const prepared = prepareModelBatchReview({ ...input, request, package: value, binding, rewards, assets });
+  const pointers = [];
+  for (const asset of prepared.assets) {
+    const existing = await transaction.get("asset", asset.id, 1);
+    if (existing && existing.contentHash !== asset.contentHash) throw new LearningDomainError2("model_review_asset_conflict", 409);
+    if (!existing) await transaction.put("asset", asset, 0);
+  }
+  for (const reward of prepared.rewards) await transaction.put("reward", reward, 0);
+  await transaction.put("binding", prepared.binding, 0);
+  await transaction.put("definition", prepared.definition, 0);
+  await transaction.put("source", prepared.source, 0, { parentId: request.modelId });
+  pointers.push({ kind: "source", id: prepared.source.id, revision: 1 });
+  for (const evidence of prepared.evidence) {
+    await transaction.put("evidence", evidence, 0, { parentId: prepared.source.id });
+    pointers.push({ kind: "evidence", id: evidence.id, revision: 1 });
+  }
+  for (const proposal of prepared.proposals) {
+    await transaction.put("feedback", proposal, 0, { parentId: proposal.evidence.id, status: proposal.status });
+    pointers.push({ kind: "feedback", id: proposal.id, revision: 1 });
+  }
+  await transaction.saveOperation(operation(request), { requestHash: contentHash(request), resources: pointers });
+  return readReceipt(transaction, request, pointers);
+}
+async function readReceipt(transaction, request, pointers) {
+  const resources = await Promise.all(pointers.map((pointer) => requireLearningResource(transaction, pointer.kind, pointer.id, pointer.revision)));
+  return ModelBatchReviewReceiptSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewReceipt.v1",
+    operationId: request.operationId,
+    modelId: request.modelId,
+    source: resources.find((resource) => resource.schemaVersion === "openpond.learningSource.v1"),
+    evidence: resources.filter((resource) => resource.schemaVersion === "openpond.taskEvidence.v1"),
+    proposals: resources.filter((resource) => resource.schemaVersion === "openpond.taskFeedbackRecord.v1")
+  });
+}
+
+// src/model-taskset-authoring.ts
+import { createVerifierSetRelease as createVerifierSetRelease2 } from "@openpond/evals";
+import { learningRef as learningRef7, sameLearningRef as sameLearningRef6, sealLearningContent as sealLearningContent6 } from "@openpond/evals/learning";
+import { TasksetReleaseSchema as TasksetReleaseSchema3 } from "@openpond/evals/tasksets";
+function prepareModelTasksetDraft(input) {
+  const request = ModelTasksetDraftRequestSchema.parse(input.request);
+  const owner = ModelTasksetAuthoringOwnerSchema.parse(input.owner);
+  const source = requireOrdinaryPackage(input.source);
+  if (source.contentHash !== request.sourcePackageHash) throw new Error("Taskset draft source package changed.");
+  const previous = assertModelTasksetAuthoring(source.taskset);
+  const owned = previous && contentHash(previous.owner) === contentHash(owner);
+  const root = owned ? previous.root : learningRef7(source.taskset);
+  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef7(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: learningRef7(source.taskset),
+    tasksetId: modelAuthoredTasksetId(lineage),
+    tasksetRevision: owned ? source.taskset.revision + 1 : 1,
+    lineage
+  });
+}
+function publishModelTasksetDraftPackage(input) {
+  const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);
+  if (!sameLearningRef6(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
+  const edited = requireOrdinaryPackage(input.edited);
+  const { contentHash: _verifierHash, ...verifierContent } = edited.verifierSet;
+  const verifierSet = createVerifierSetRelease2({
+    ...verifierContent,
+    id: `${prepared.tasksetId}-verifiers`,
+    revision: prepared.tasksetRevision,
+    calibrationReceiptRefs: [],
+    metadata: { sourceVerifierSet: learningRef7(edited.verifierSet) }
+  });
+  const { contentHash: _hash, ...content } = edited.taskset;
+  const taskset = TasksetReleaseSchema3.parse(sealLearningContent6({
+    ...content,
+    id: prepared.tasksetId,
+    revision: prepared.tasksetRevision,
+    verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash },
+    metadata: {
+      modelTasksetAuthoring: prepared.lineage,
+      ...edited.taskset.metadata.environmentResources === void 0 ? {} : { environmentResources: edited.taskset.metadata.environmentResources },
+      ...edited.taskset.metadata.ordinaryAuthoring === void 0 ? {} : { ordinaryAuthoring: edited.taskset.metadata.ordinaryAuthoring }
+    }
+  }));
+  const resolved = resolveTasksetPackageExecution(edited);
+  const files = resolved ? [
+    ...edited.files.filter((file) => file.asset.id !== modelStarterExecutionAssetId(edited.taskset)),
+    createTasksetPackageExecutionFile({ ...resolved.execution, verifierSet })
+  ] : edited.files;
+  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset, environment: edited.environment, verifierSet, files });
+}
+function requireOrdinaryPackage(value) {
+  const result = validateTasksetPackage(value);
+  if (result.modelResources || result.learningResources) throw new Error("This Taskset requires its bound or reviewed authoring workflow.");
+  return result;
+}
 export {
   MAX_TASKSET_PACKAGE_BYTES,
+  LearningDomainError3 as ModelBatchReviewError,
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema,
+  ModelTasksetAuthoringOwnerSchema,
+  ModelTasksetAuthoringSchema,
+  ModelTasksetDraftPreparationSchema,
+  ModelTasksetDraftRequestSchema,
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
+  TasksetDraftFileContentSchema,
+  TasksetDraftFileInfoSchema,
+  TasksetDraftFileMutationSchema,
+  TasksetDraftFilePathSchema,
+  TasksetDraftFileSchema,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
   TasksetPackageLearningResourcesSchema,
@@ -2876,9 +3360,16 @@ export {
   TasksetPackageReadbackSchema,
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
+  beginModelBatchReview,
   createTasksetPackage,
+  createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
+  findModelBatchReview,
+  inspectModelBatchPackage,
   learningPackageContextFiles,
+  prepareModelTasksetDraft,
+  publishModelTasksetDraftPackage,
+  resolveTasksetPackageExecution,
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,
   validateTasksetPackage