openpond-sdk 0.2.5 → 0.3.1

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,33 +2613,143 @@ 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 resolveTasksetPackageInstructions(value) {
+  if (value.learningResources) return taskBatchPackageMetadata2(value.taskset).definition.instructions;
+  if (value.modelResources) return value.modelResources.taskDefinition.instructions;
+  const authoring = z19.object({ instructions: z19.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
+  return authoring.instructions ?? "";
 }
 function validateTasksetPackage(value) {
   assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
@@ -2636,6 +2758,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 +2788,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 +2814,8 @@ 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);
+  resolveTasksetPackageInstructions(result);
   return result;
 }
 function createTasksetPackage(value) {
@@ -2695,45 +2828,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 +2876,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 +2952,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,7 +2991,7 @@ 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;
@@ -2869,53 +3002,53 @@ var OpenPondTasksetPackageClient = class {
 import {
   LearningDomainError as LearningDomainError2,
   learningRef as learningRef6,
-  sameLearningRef as sameLearningRef4,
+  sameLearningRef as sameLearningRef5,
   requireLearningRelease,
   requireLearningResource,
   taskBatchPackageMetadata as taskBatchPackageMetadata4
 } from "@openpond/evals/learning";
 
 // src/model-batch-review-contracts.ts
-import { z as z20 } from "zod";
-import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceSchema as LearningSourceSchema2, TaskEvidenceSchema as TaskEvidenceSchema2, TaskFeedbackSchema, TaskDefinitionSchema as TaskDefinitionSchema2, TaskAdmissionDecisionSchema as TaskAdmissionDecisionSchema2 } from "@openpond/evals/learning";
+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 = LearningRevisionRefSchema.shape.id;
-var ModelBatchReviewInspectionSchema = z20.object({
-  schemaVersion: z20.literal("openpond.modelBatchReviewInspection.v1"),
-  packageHash: z20.string().regex(/^[a-f0-9]{64}$/),
+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: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
-  decisions: z20.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
+  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
+  decisions: z22.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
 }).strict();
-var ModelBatchReviewRequestSchema = z20.object({
-  schemaVersion: z20.literal("openpond.modelBatchReviewRequest.v1"),
+var ModelBatchReviewRequestSchema = z22.object({
+  schemaVersion: z22.literal("openpond.modelBatchReviewRequest.v1"),
   operationId: ReleaseIdSchema2,
   modelId: ReleaseIdSchema2,
-  expectedModelRevision: z20.number().int().positive(),
-  tasksetRef: LearningRevisionRefSchema,
-  rewardBindingRef: LearningRevisionRefSchema.nullable(),
-  definition: z20.object({
-    name: z20.string().trim().min(1).max(500).optional(),
-    instructions: z20.string().trim().min(1).max(2e4).optional(),
+  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: z20.array(z20.object({
-    evidence: LearningRevisionRefSchema,
+  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 = z20.object({
-  schemaVersion: z20.literal("openpond.modelBatchReviewReceipt.v1"),
+var ModelBatchReviewReceiptSchema = z22.object({
+  schemaVersion: z22.literal("openpond.modelBatchReviewReceipt.v1"),
   operationId: ReleaseIdSchema2,
   modelId: ReleaseIdSchema2,
   source: LearningSourceSchema2,
-  evidence: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
-  proposals: z20.array(TaskFeedbackSchema).max(1e4)
+  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
+  proposals: z22.array(TaskFeedbackSchema).max(1e4)
 }).strict();
 
 // src/model-batch-review-preparation.ts
@@ -2928,8 +3061,8 @@ import {
   assertLearningContentHash as assertLearningContentHash3,
   learningEvidenceId,
   learningRef as learningRef5,
-  sameLearningRef as sameLearningRef3,
-  sealLearningContent as sealLearningContent4,
+  sameLearningRef as sameLearningRef4,
+  sealLearningContent as sealLearningContent5,
   taskBatchPackageMetadata as taskBatchPackageMetadata3,
   verifyLearningTextAsset as verifyLearningTextAsset5
 } from "@openpond/evals/learning";
@@ -2950,7 +3083,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) => sameLearningRef3(learningRef5(reward), source2.reward));
+    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 }));
   }
@@ -2977,7 +3110,7 @@ function prepareModelBatchReview(input) {
   })).values()];
   const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
   const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
-  const definition = TaskDefinitionSchema3.parse(sealLearningContent4({
+  const definition = TaskDefinitionSchema3.parse(sealLearningContent5({
     ...definitionContent,
     ...request.definition,
     id: `${id}-definition`,
@@ -2988,7 +3121,7 @@ function prepareModelBatchReview(input) {
       policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders2(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
     }
   }));
-  const source = LearningSourceSchema3.parse(sealLearningContent4({
+  const source = LearningSourceSchema3.parse(sealLearningContent5({
     schemaVersion: "openpond.learningSource.v1",
     id,
     revision: 1,
@@ -3021,7 +3154,7 @@ function prepareModelBatchReview(input) {
       outputSchema: metadata.definition.outputSchema,
       input: parent.submission.input
     });
-    return TaskEvidenceSchema3.parse(sealLearningContent4({
+    return TaskEvidenceSchema3.parse(sealLearningContent5({
       schemaVersion: "openpond.taskEvidence.v1",
       id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
       revision: 1,
@@ -3104,7 +3237,7 @@ async function beginModelBatchReview(transaction, input) {
   if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
   const metadata = taskBatchPackageMetadata4(value.taskset);
   const selected = request.rewardBindingRef;
-  const retained = !selected || sameLearningRef4(selected, learningRef6(metadata.binding));
+  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) => [
@@ -3148,14 +3281,84 @@ async function readReceipt(transaction, request, pointers) {
     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,
@@ -3166,10 +3369,15 @@ export {
   TasksetPackageSchema,
   beginModelBatchReview,
   createTasksetPackage,
+  createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
   findModelBatchReview,
   inspectModelBatchPackage,
   learningPackageContextFiles,
+  prepareModelTasksetDraft,
+  publishModelTasksetDraftPackage,
+  resolveTasksetPackageExecution,
+  resolveTasksetPackageInstructions,
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,
   validateTasksetPackage