openpond-sdk 0.3.3 → 0.4.0

package/dist/chunk-AZUCY3E5.js

@@ -0,0 +1,2395 @@
+import {
+  ModelTasksetAuthoringSchema,
+  ModelTasksetDraftPreparationSchema,
+  TasksetDraftFileContentSchema,
+  TasksetDraftFileMutationSchema,
+  TasksetDraftFilePathSchema
+} from "./chunk-S7I45WJQ.js";
+import {
+  TasksetCatalogReleaseRefSchema
+} from "./chunk-A4ZDOZKP.js";
+import {
+  ModelStarterExecutionSchema,
+  ModelTasksetPackageSchema,
+  createModelStarterExecutionAsset,
+  modelStarterExecutionAssetId,
+  validateModelStarterExecution,
+  validateModelTasksetPackage
+} from "./chunk-65D4C7HP.js";
+import {
+  ChatModelRefSchema
+} from "./chunk-IVEXCIHO.js";
+import {
+  ImmutableAssetRefSchema,
+  ImmutableReleaseRefSchema,
+  ReleaseHashSchema,
+  ReleaseIdSchema,
+  VersionedReleaseRefSchema,
+  canonicalJson,
+  contentHash,
+  sha256
+} from "./chunk-ZPCK222K.js";
+import {
+  HostedModelProjectSummarySchema,
+  HostedModelProjectSyncSchema,
+  HostedModelProjectTrainingSetupSchema,
+  canonicalJson as canonicalJson2
+} from "./chunk-5PRP457R.js";
+
+// src/taskset-package-learning.ts
+import { z } from "zod";
+import {
+  TaskBatchSchema,
+  TaskEvidenceSchema,
+  TaskAdmissionDecisionSchema,
+  LearningSourceSchema,
+  LearningTextAssetSchema,
+  assertLearningContentHash,
+  compileTaskBatch,
+  learningRef,
+  sameLearningRef,
+  taskBatchPackageMetadata,
+  verifyLearningTextAsset
+} from "@openpond/evals/learning";
+var TasksetPackageLearningResourcesSchema = z.object({
+  batch: TaskBatchSchema,
+  evidence: z.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
+  sources: z.array(LearningSourceSchema).min(1).max(1e4),
+  assets: z.array(LearningTextAssetSchema).max(1e3)
+}).strict();
+function learningPackageContextFiles(resources) {
+  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
+    const text = canonicalJson2(evidence.submission.evaluatorContext);
+    const bytes = new TextEncoder().encode(text);
+    return {
+      asset: {
+        id: `task-evidence:${evidence.contentHash}`,
+        path: `learning/context/${evidence.contentHash}.json`,
+        contentHash: sha256(bytes),
+        sizeBytes: bytes.byteLength,
+        mediaType: "application/json",
+        visibility: "host_private"
+      },
+      base64: btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
+    };
+  });
+}
+function validateTasksetLearningResources(taskset, input) {
+  const resources = TasksetPackageLearningResourcesSchema.parse(input);
+  const metadata = taskBatchPackageMetadata(taskset);
+  if (!sameLearningRef(learningRef(resources.batch), metadata.batch)) throw new Error("Taskset learning batch differs from its admission metadata.");
+  for (const collection of [resources.evidence, resources.decisions, resources.sources, resources.assets]) {
+    const identities = /* @__PURE__ */ new Set();
+    for (const resource of collection) {
+      assertLearningContentHash(resource);
+      const key = `${resource.id}:${resource.revision}`;
+      if (identities.has(key)) throw new Error("Taskset learning resource identities must be unique.");
+      identities.add(key);
+    }
+  }
+  if (resources.evidence.length !== resources.batch.examples.length || resources.decisions.length !== resources.batch.examples.length) throw new Error("Taskset learning snapshots must match the admitted batch inventory.");
+  for (const evidence of resources.evidence) {
+    const source = resources.sources.find((source2) => sameLearningRef(learningRef(source2), evidence.source));
+    if (!source || !sameLearningRef(source.taskDefinition, learningRef(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
+  }
+  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef(evidence.source, learningRef(source))))) throw new Error("Taskset package includes an unrelated learning source.");
+  const rewardAssets = metadata.rewards.flatMap((reward) => [
+    ...reward.assets,
+    ...reward.implementation.kind === "custom_verifier" ? [reward.implementation.verifierRef] : reward.implementation.kind === "model_judge" || reward.implementation.kind === "human" ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]);
+  for (const ref of rewardAssets) {
+    const asset = resources.assets.find((asset2) => asset2.id === ref.id);
+    if (!asset) throw new Error("Taskset learning Reward asset is missing.");
+    verifyLearningTextAsset(asset, ref);
+  }
+  if (resources.assets.some((asset) => !rewardAssets.some((ref) => ref.id === asset.id))) throw new Error("Taskset package includes an unrelated learning asset.");
+  const compiled = compileTaskBatch({
+    batch: resources.batch,
+    definition: metadata.definition,
+    binding: metadata.binding,
+    rewards: metadata.rewards,
+    evidence: resources.evidence,
+    decisions: resources.decisions
+  });
+  const compiledMetadata = taskBatchPackageMetadata(compiled);
+  if (contentHash(compiledMetadata) !== contentHash(metadata)) throw new Error("Taskset admission metadata differs from its reviewed snapshots.");
+  const execution = (release) => ({ policy: release.policy, environment: release.environment, tools: release.tools });
+  if (contentHash(execution(compiled)) !== contentHash(execution(taskset))) throw new Error("Taskset execution differs from its reviewed task definition.");
+  const taskContent = (task) => ({
+    id: task.id,
+    clusterKey: task.clusterKey,
+    split: task.split,
+    input: task.input,
+    expectedOutput: task.expectedOutput,
+    policyVisibleContext: task.policyVisibleContext,
+    privilegedContextRef: task.privilegedContextRef,
+    artifactRefs: task.artifactRefs,
+    requiredOutputs: task.requiredOutputs ?? [],
+    tags: task.tags
+  });
+  if (contentHash(compiled.tasks.map(taskContent)) !== contentHash(taskset.tasks.map(taskContent))) throw new Error("Taskset rows differ from their reviewed evidence.");
+  return resources;
+}
+
+// src/taskset-package-files.ts
+import { z as z2 } from "zod";
+var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
+var TasksetPackageFileSchema = z2.object({
+  asset: ImmutableAssetRefSchema,
+  base64: z2.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
+import { LearningTextAssetSchema as LearningTextAssetSchema2, sealLearningContent } from "@openpond/evals/learning";
+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 LearningTextAssetSchema2.parse(sealLearningContent({ 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
+import { z as z3 } from "zod";
+import { EnvironmentReleaseSchema, VerifierSetReleaseSchema, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
+import { assertTasksetRelease, TasksetReleaseSchema } from "@openpond/evals/tasksets";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
+
+// src/model-taskset-authoring-lineage.ts
+import { sameLearningRef as sameLearningRef2 } from "@openpond/evals/learning";
+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 ? !sameLearningRef2(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-contracts.ts
+var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
+var TasksetPackageContentSchema = z3.object({
+  schemaVersion: z3.literal("openpond.tasksetPackage.v1"),
+  taskset: TasksetReleaseSchema,
+  environment: EnvironmentReleaseSchema,
+  verifierSet: VerifierSetReleaseSchema,
+  files: z3.array(TasksetPackageFileSchema).max(1e4),
+  modelResources: BoundModelResourcesSchema.optional(),
+  learningResources: TasksetPackageLearningResourcesSchema.optional()
+}).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z3.string().regex(/^[a-f0-9]{64}$/) }).strict();
+function tasksetPackageRewardBinding(value) {
+  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
+}
+function resolveTasksetPackageInstructions(value) {
+  if (value.learningResources) return taskBatchPackageMetadata2(value.taskset).definition.instructions;
+  if (value.modelResources) return value.modelResources.taskDefinition.instructions;
+  const authoring = z3.object({ instructions: z3.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
+  return authoring.instructions ?? "";
+}
+function validateTasksetPackage(value) {
+  assertBoundedTaskJson(value, MAX_TASKSET_PACKAGE_BYTES);
+  const result = TasksetPackageSchema.parse(value);
+  const { contentHash: hash, ...content } = result;
+  if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
+  const { taskset, environment, verifierSet } = result;
+  assertTasksetRelease(taskset);
+  const authoring = assertModelTasksetAuthoring(taskset);
+  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
+  if (!verifyEnvironmentRelease(environment) || !verifyVerifierSetRelease(verifierSet) || !same(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same(taskset.environment, environment.contract) || !same(taskset.graders, verifierSet.graders)) {
+    throw new Error("Taskset package execution releases do not match its Taskset.");
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const file of result.files) {
+    if (files.has(file.asset.id)) throw new Error(`Duplicate Taskset asset identity: ${file.asset.id}.`);
+    decodeTasksetPackageFile(file);
+    files.set(file.asset.id, file);
+  }
+  function requireAsset(ref) {
+    const file = files.get(ref.id);
+    if (!file || !same(file.asset, ref)) throw new Error(`Taskset package asset is missing or mismatched: ${ref.id}.`);
+  }
+  for (const task of taskset.tasks) {
+    for (const asset of task.artifactRefs) requireAsset(asset);
+    for (const output of task.requiredOutputs ?? []) if (output.schemaRef) requireAsset(output.schemaRef);
+    if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
+      throw new Error(`Taskset package private context is missing: ${task.id}.`);
+    }
+  }
+  for (const ref of [environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) if (ref) requireAsset(ref);
+  for (const grader of taskset.graders) {
+    const ref = "verifierRef" in grader ? grader.verifierRef : "rubricRef" in grader ? grader.rubricRef : null;
+    if (ref) {
+      requireAsset(ref);
+      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 z3.array(z3.object({ path: z3.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}.`);
+    }
+  }
+  if (result.learningResources) {
+    if (result.modelResources) throw new Error("Taskset package cannot declare competing authoring graphs.");
+    const learning = validateTasksetLearningResources(taskset, result.learningResources);
+    for (const expected of learningPackageContextFiles(learning)) {
+      if (!same(files.get(expected.asset.id), expected)) throw new Error("Taskset private context differs from its reviewed evidence.");
+    }
+    for (const asset of learning.assets) requireAsset(asset.asset);
+  } else if (result.modelResources) {
+    const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
+    for (const asset of model.assets) requireAsset(asset.asset);
+  } 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) {
+  assertBoundedTaskJson(value, MAX_TASKSET_PACKAGE_BYTES);
+  const content = TasksetPackageContentSchema.parse(value);
+  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
+}
+function same(left, right) {
+  return contentHash({ value: left }) === contentHash({ value: right });
+}
+
+// src/taskset-package-client.ts
+import { z as z4 } from "zod";
+import { learningRef as learningRef2 } from "@openpond/evals/learning";
+var IdSchema = z4.string().trim().min(1).max(500);
+var HashSchema = z4.string().regex(/^[a-f0-9]{64}$/);
+var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
+  portableProjectId: true,
+  name: true,
+  objective: true,
+  defaultBaseModel: true,
+  defaultDestinationId: true,
+  sourceRevision: true,
+  sourceUpdatedAt: true
+}).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true, recipe: true }) }).strict();
+var TasksetPackagePublicationSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetPackagePublication.v1"),
+  operationId: IdSchema,
+  modelProjectId: IdSchema,
+  expectedProjectEtag: HashSchema.nullable(),
+  name: z4.string().trim().min(1).max(200),
+  description: z4.string().max(5e3),
+  buildIntent: z4.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
+  methodHint: z4.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
+  package: TasksetPackageSchema,
+  modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
+  selection: z4.enum(["select", "attach"]).optional()
+}).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.");
+var TasksetPackageReceiptSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetPackageReceipt.v1"),
+  teamId: IdSchema,
+  modelProjectId: IdSchema,
+  operationId: IdSchema,
+  taskset: TasksetCatalogReleaseRefSchema,
+  packageHash: HashSchema,
+  hostedTasksetId: IdSchema,
+  projectEtag: HashSchema,
+  project: HostedModelProjectSummarySchema.optional(),
+  selection: z4.enum(["select", "attach"]).optional()
+}).strict();
+var TasksetPackageReadbackSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetPackageReadback.v1"),
+  teamId: IdSchema,
+  modelProjectId: IdSchema,
+  package: TasksetPackageSchema
+}).strict();
+var OpenPondTasksetPackageError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "OpenPondTasksetPackageError";
+  }
+  status;
+  code;
+};
+var OpenPondTasksetPackageClient = class {
+  #options;
+  constructor(options) {
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim()) throw new Error("Taskset package client requires a clean HTTP(S) endpoint and workspace credentials.");
+    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
+  }
+  async publish(input, options = {}) {
+    const request = TasksetPackagePublicationSchema.parse(input);
+    validateTasksetPackage(request.package);
+    const receipt = TasksetPackageReceiptSchema.parse(await this.#request("", "POST", request, options.signal));
+    const release = request.package.taskset;
+    if (receipt.teamId !== this.#options.teamId || receipt.modelProjectId !== request.modelProjectId || receipt.operationId !== request.operationId || receipt.packageHash !== request.package.contentHash || receipt.taskset.id !== release.id || receipt.taskset.revision !== release.revision || receipt.taskset.contentHash !== release.contentHash) {
+      throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication receipt did not match the requested package and owner.");
+    }
+    if (request.selection !== void 0 && receipt.selection !== request.selection) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain its selection mode.");
+    if (request.selection === "attach" && receipt.projectEtag !== request.expectedProjectEtag) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Attaching a historical Taskset changed the Model configuration.");
+    if (request.modelConfiguration) {
+      const expected = request.modelConfiguration;
+      const project = receipt.project;
+      const binding = tasksetPackageRewardBinding(request.package);
+      const setup = HostedModelProjectTrainingSetupSchema.parse({
+        ...expected.trainingSetup,
+        tasksetRef: learningRef2(release),
+        rewardBindingRef: binding ? learningRef2(binding) : null,
+        tasksetRelease: null,
+        recipe: null
+      });
+      if (!project || project.teamId !== this.#options.teamId || project.etag !== receipt.projectEtag || ![project.id, project.portableProjectId].includes(request.modelProjectId) || project.portableProjectId !== expected.portableProjectId || project.name !== expected.name || project.objective !== expected.objective || project.sourceRevision !== expected.sourceRevision || Date.parse(project.sourceUpdatedAt) !== Date.parse(expected.sourceUpdatedAt) || contentHash(project.defaultBaseModel) !== contentHash(expected.defaultBaseModel) || project.defaultDestinationId !== expected.defaultDestinationId || contentHash(project.trainingSetup) !== contentHash(setup)) {
+        throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain the requested Model configuration.");
+      }
+    }
+    return receipt;
+  }
+  async get(modelProjectId, reference, options = {}) {
+    const project = IdSchema.parse(modelProjectId);
+    const ref = TasksetCatalogReleaseRefSchema.parse(reference);
+    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema.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.");
+    if (expectedPackageHash !== void 0 && response.package.contentHash !== expectedPackageHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the saved publication receipt.");
+    return validateTasksetPackage(response.package);
+  }
+  async #request(path, method, body, signal) {
+    const serialized = body === void 0 ? void 0 : JSON.stringify(body);
+    if (serialized && new TextEncoder().encode(serialized).byteLength > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset publication exceeds the 64 MiB envelope.");
+    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/taskset-packages${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "X-OpenPond-Team-Id": this.#options.teamId, Accept: "application/json", ...serialized ? { "Content-Type": "application/json" } : {} },
+      body: serialized,
+      signal,
+      redirect: "error"
+    });
+    const reader = response.body?.getReader();
+    if (!reader) throw new OpenPondTasksetPackageError(response.status, "empty_response", "Taskset package response was empty.");
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let bytes = 0;
+    let text = "";
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        bytes += chunk.value.byteLength;
+        if (bytes > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset response exceeds the 64 MiB envelope.");
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+      text += decoder.decode();
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+    const payload = JSON.parse(text);
+    if (!response.ok) {
+      const error = z4.object({ code: z4.string(), message: z4.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/taskset-draft-dataset-artifacts.ts
+import { z as z5 } from "zod";
+var IdSchema2 = z5.string().trim().min(1).max(240);
+var TimestampSchema = z5.string().trim().min(1);
+var HashSchema2 = z5.string().trim().min(8).max(256);
+var RelativePathSchema = z5.string().trim().min(1).max(1e3).refine(
+  (value) => !value.startsWith("/") && !value.startsWith("\\") && !value.split(/[\\/]/).includes(".."),
+  "Artifact paths must be relative and stay inside the Dataset."
+);
+var DatasetSplitSchema = z5.enum([
+  "train",
+  "validation",
+  "test",
+  "frozen_eval"
+]);
+var DatasetSemanticFieldSchema = z5.object({
+  name: z5.string().trim().min(1).max(500),
+  semanticRole: z5.enum([
+    "row_id",
+    "cluster_id",
+    "prompt",
+    "messages",
+    "demonstration",
+    "chosen",
+    "rejected",
+    "expected_output",
+    "privileged_context",
+    "reward",
+    "feedback",
+    "tag",
+    "metadata"
+  ]),
+  logicalType: z5.enum([
+    "string",
+    "integer",
+    "float",
+    "boolean",
+    "json",
+    "messages"
+  ]),
+  nullable: z5.boolean(),
+  policy: z5.enum(["visible", "privileged", "metadata"])
+});
+var DatasetSemanticSchemaSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetSemanticSchema.v1"),
+  fields: z5.array(DatasetSemanticFieldSchema).min(1).max(1e4),
+  schemaHash: HashSchema2
+});
+var DatasetShardRefSchema = z5.object({
+  id: IdSchema2,
+  split: DatasetSplitSchema,
+  path: RelativePathSchema,
+  contentHash: HashSchema2,
+  schemaHash: HashSchema2,
+  sizeBytes: z5.number().int().nonnegative(),
+  rowCount: z5.number().int().positive(),
+  rowGroupCount: z5.number().int().positive()
+});
+var DatasetArtifactManifestSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetArtifact.v1"),
+  id: IdSchema2,
+  tasksetId: IdSchema2,
+  tasksetRevision: z5.number().int().positive(),
+  contentHash: HashSchema2,
+  format: z5.literal("parquet"),
+  schema: DatasetSemanticSchemaSchema,
+  shards: z5.array(DatasetShardRefSchema).min(1).max(1e5),
+  rowCount: z5.number().int().positive(),
+  splitCounts: z5.record(DatasetSplitSchema, z5.number().int().nonnegative()),
+  sourceReceiptRefs: z5.array(IdSchema2).min(1).max(1e5),
+  mappingHash: HashSchema2,
+  qualityReportHash: HashSchema2,
+  createdAt: TimestampSchema
+});
+var DatasetArtifactSummarySchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetArtifactSummary.v1"),
+  artifactId: IdSchema2,
+  tasksetId: IdSchema2,
+  tasksetRevision: z5.number().int().positive(),
+  format: z5.literal("parquet"),
+  rowCount: z5.number().int().positive(),
+  splitCounts: z5.record(DatasetSplitSchema, z5.number().int().nonnegative()),
+  sizeBytes: z5.number().int().nonnegative(),
+  contentHash: HashSchema2,
+  available: z5.boolean(),
+  unavailableReason: z5.string().trim().min(1).max(2e3).nullable(),
+  createdAt: TimestampSchema
+});
+var DatasetCatalogItemSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetCatalogItem.v1"),
+  tasksetId: IdSchema2,
+  tasksetRevision: z5.number().int().positive(),
+  artifactId: IdSchema2.nullable(),
+  name: z5.string().trim().min(1).max(500),
+  status: z5.enum([
+    "draft",
+    "awaiting_disclosure_approval",
+    "awaiting_materialization_approval",
+    "materializing",
+    "validating",
+    "needs_review",
+    "baselining",
+    "ready",
+    "blocked",
+    "failed",
+    "archived"
+  ]),
+  storageKind: z5.enum(["inline", "parquet"]),
+  rowCount: z5.number().int().nonnegative(),
+  splitCounts: z5.record(DatasetSplitSchema, z5.number().int().nonnegative()),
+  sizeBytes: z5.number().int().nonnegative().nullable(),
+  available: z5.boolean(),
+  unavailableReason: z5.string().trim().min(1).max(2e3).nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+});
+var DatasetCatalogResponseSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetCatalog.v1"),
+  profileId: IdSchema2,
+  datasets: z5.array(DatasetCatalogItemSchema),
+  generatedAt: TimestampSchema
+});
+var DatasetArtifactRegistryEntrySchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetArtifactRegistry.v1"),
+  manifest: DatasetArtifactManifestSchema,
+  profileId: IdSchema2,
+  storageRoot: z5.string().trim().min(1).max(4e3),
+  relativeManifestPath: RelativePathSchema,
+  available: z5.boolean(),
+  unavailableReason: z5.string().trim().min(1).max(2e3).nullable(),
+  verifiedAt: TimestampSchema.nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+});
+var DatasetRowPageRequestSchema = z5.object({
+  split: DatasetSplitSchema.nullable().default(null),
+  cursor: z5.string().trim().min(1).max(2e3).nullable().default(null),
+  limit: z5.number().int().min(1).max(100).default(25),
+  columns: z5.array(z5.string().trim().min(1).max(500)).max(100).default([])
+});
+var DatasetRowPageSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetRowPage.v1"),
+  tasksetId: IdSchema2,
+  tasksetRevision: z5.number().int().positive(),
+  artifactHash: HashSchema2,
+  split: DatasetSplitSchema.nullable(),
+  rows: z5.array(z5.record(z5.string(), z5.unknown())).max(100),
+  nextCursor: z5.string().max(2e3).nullable(),
+  totalRows: z5.number().int().nonnegative(),
+  returnedRows: z5.number().int().nonnegative()
+});
+var DatasetStorageSettingsSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetStorageSettings.v1"),
+  datasetStorePath: z5.string().trim().min(1).max(4e3),
+  updatedAt: TimestampSchema
+});
+var DatasetStorageRootSchema = z5.object({
+  id: IdSchema2,
+  label: z5.string().trim().min(1).max(500),
+  path: z5.string().trim().min(1).max(4e3),
+  datasetStorePath: z5.string().trim().min(1).max(4e3),
+  kind: z5.enum(["local", "network", "removable", "cache"]),
+  configured: z5.boolean(),
+  mounted: z5.boolean(),
+  writable: z5.boolean(),
+  totalBytes: z5.number().int().nonnegative().nullable(),
+  freeBytes: z5.number().int().nonnegative().nullable()
+});
+var DatasetStorageStateSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetStorageState.v1"),
+  settings: DatasetStorageSettingsSchema,
+  storageRoots: z5.array(DatasetStorageRootSchema)
+});
+var UpdateDatasetStorageSettingsRequestSchema = z5.object({
+  datasetStorePath: z5.string().trim().min(1).max(4e3)
+});
+
+// src/taskset-draft-dataset-sources.ts
+import { z as z6 } from "zod";
+var IdSchema3 = z6.string().trim().min(1).max(240);
+var TimestampSchema2 = z6.string().trim().min(1);
+var HashSchema3 = z6.string().trim().min(8).max(256);
+var MetadataSchema = z6.record(z6.string(), z6.unknown()).default({});
+var RevisionSchema = z6.string().trim().min(7).max(256);
+var DatasetSourceReviewStatusSchema = z6.enum([
+  "pending",
+  "approved",
+  "review",
+  "blocked"
+]);
+var ExternalDatasetSourceBaseSchema = z6.object({
+  id: IdSchema3,
+  profileId: IdSchema3,
+  title: z6.string().trim().min(1).max(500),
+  sourceHash: HashSchema3,
+  occurredAt: TimestampSchema2,
+  licensingStatus: DatasetSourceReviewStatusSchema,
+  secretScanStatus: z6.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z6.enum(["pending", "passed", "review", "blocked"]),
+  metadata: MetadataSchema
+});
+var HuggingFaceDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z6.literal("openpond.huggingFaceDatasetSource.v1"),
+  kind: z6.literal("huggingface"),
+  repositoryId: z6.string().trim().regex(/^[^/\s]+\/[^/\s]+$/).max(500),
+  repositoryUrl: z6.string().url().max(2e3),
+  revision: RevisionSchema,
+  configuration: z6.string().trim().min(1).max(500),
+  upstreamSplits: z6.array(z6.string().trim().min(1).max(500)).min(1).max(1e3),
+  gated: z6.boolean(),
+  private: z6.boolean(),
+  declaredLicense: z6.string().trim().min(1).max(500).nullable(),
+  sourceFileHashes: z6.array(HashSchema3).min(1).max(1e5)
+});
+var UploadedFileDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z6.literal("openpond.uploadedFileDatasetSource.v1"),
+  kind: z6.literal("uploaded_file"),
+  originalFileNames: z6.array(z6.string().trim().min(1).max(500)).min(1).max(1e3),
+  mediaTypes: z6.array(z6.string().trim().min(1).max(200)).min(1).max(1e3),
+  sourceFileHashes: z6.array(HashSchema3).min(1).max(1e3),
+  totalBytes: z6.number().int().nonnegative(),
+  parserVersion: z6.string().trim().min(1).max(200)
+});
+var GeneratedDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z6.literal("openpond.generatedDatasetSource.v1"),
+  kind: z6.literal("generated"),
+  generatorId: IdSchema3,
+  generatorVersion: z6.string().trim().min(1).max(200),
+  seed: z6.number().int(),
+  generatorHash: HashSchema3
+});
+var LearningBatchDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z6.literal("openpond.learningBatchDatasetSource.v1"),
+  kind: z6.literal("learning_batch"),
+  batch: z6.object({ id: IdSchema3, revision: z6.number().int().positive(), contentHash: HashSchema3 }).strict(),
+  taskDefinition: z6.object({ id: IdSchema3, revision: z6.number().int().positive(), contentHash: HashSchema3 }).strict(),
+  admittedBy: IdSchema3
+});
+var ExternalDatasetSourceRefSchema = z6.discriminatedUnion("kind", [
+  HuggingFaceDatasetSourceRefSchema,
+  UploadedFileDatasetSourceRefSchema,
+  GeneratedDatasetSourceRefSchema,
+  LearningBatchDatasetSourceRefSchema
+]);
+
+// src/taskset-draft-harness-actions.ts
+import { z as z7 } from "zod";
+var HarnessActionBindingSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessActionBinding.v1"),
+  actionId: ReleaseIdSchema,
+  modelToolName: z7.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z7.string().trim().min(1).max(1e3),
+  inputSchema: z7.record(z7.string(), z7.unknown()),
+  actionSchemaHash: ReleaseHashSchema,
+  agentRelease: ImmutableReleaseRefSchema,
+  implementationHash: ReleaseHashSchema,
+  runtimeBindingId: ReleaseIdSchema,
+  capabilityReceiptHash: ReleaseHashSchema,
+  sideEffect: z7.enum(["read", "write"]),
+  studentVisible: z7.boolean(),
+  timeoutMs: z7.number().int().positive().max(36e5),
+  episodeArgumentBindings: z7.array(
+    z7.object({
+      argument: ReleaseIdSchema,
+      source: z7.literal("case_id")
+    }).strict()
+  ).max(20).default([])
+}).strict();
+
+// src/taskset-draft-core.ts
+import { z as z8 } from "zod";
+var IdSchema4 = z8.string().trim().min(1).max(240);
+var TimestampSchema3 = z8.string().trim().min(1);
+var HashSchema4 = z8.string().trim().min(8).max(256);
+var Sha256Schema = z8.string().trim().regex(/^[a-f0-9]{64}$/);
+var CodeIdentifierSchema = z8.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema2 = z8.record(z8.string(), z8.unknown()).default({});
+var NullableIdSchema = IdSchema4.nullable();
+function safeRelativeFilePath(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
+    return false;
+  }
+  return !normalized.split("/").some(
+    (segment) => !segment || segment === "." || segment === ".."
+  );
+}
+function safeFileName(value) {
+  const normalized = value.trim();
+  return normalized.length > 0 && normalized !== "." && normalized !== ".." && !normalized.includes("/") && !normalized.includes("\\") && !normalized.includes("\0");
+}
+var TasksetSplitSchema = DatasetSplitSchema;
+var TasksetPurposeSchema = z8.enum(["general", "benchmark"]);
+var TasksetBenchmarkBindingSchema = z8.object({
+  schemaVersion: z8.literal("openpond.tasksetBenchmark.v1"),
+  definitionId: IdSchema4,
+  releaseId: IdSchema4,
+  releaseHash: Sha256Schema,
+  managedReleasePath: z8.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
+  adaptationSplit: TasksetSplitSchema,
+  evaluationSplit: TasksetSplitSchema,
+  primaryMetric: z8.enum([
+    "foreground_tokens",
+    "success_rate",
+    "latency_ms",
+    "cost_usd"
+  ]),
+  qualityGate: z8.enum(["none", "non_regression", "all_pass"]),
+  source: z8.enum(["builtin", "imported"]),
+  metadata: MetadataSchema2
+});
+var TasksetPreferenceComparisonBindingSchema = z8.object({
+  schemaVersion: z8.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
+  releaseId: IdSchema4,
+  releaseHash: Sha256Schema,
+  publishedAt: TimestampSchema3,
+  metadata: MetadataSchema2
+});
+var TrainingSourceConsentSchema = z8.object({
+  status: z8.enum(["pending", "granted", "denied", "revoked"]),
+  scope: z8.enum(["metadata_only", "selected_turns", "full_session"]),
+  grantedBy: NullableIdSchema,
+  grantedAt: TimestampSchema3.nullable(),
+  purpose: z8.literal("task_authoring_and_evaluation")
+});
+var TrainingSourceRefSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingSource.v1"),
+  id: IdSchema4,
+  profileId: IdSchema4,
+  sessionId: IdSchema4,
+  turnIds: z8.array(IdSchema4).max(1e3).default([]),
+  workspaceId: NullableIdSchema,
+  sourceHash: HashSchema4,
+  clusterKey: IdSchema4,
+  title: z8.string().trim().min(1).max(500),
+  occurredAt: TimestampSchema3,
+  consent: TrainingSourceConsentSchema,
+  connectedAppIds: z8.array(IdSchema4).max(100).default([]),
+  secretScanStatus: z8.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z8.enum(["pending", "passed", "review", "blocked"]),
+  licensingStatus: z8.enum(["pending", "approved", "review", "blocked"]),
+  metadata: MetadataSchema2
+});
+var TasksetSourceRefSchema = z8.union([
+  TrainingSourceRefSchema,
+  ExternalDatasetSourceRefSchema
+]);
+var TaskPolicyBoundarySchema = z8.object({
+  policyVisibleFields: z8.array(IdSchema4).max(1e3).default([]),
+  privilegedFields: z8.array(IdSchema4).max(1e3).default([]),
+  hiddenGraderRefs: z8.array(IdSchema4).max(100).default([]),
+  connectedAppScopes: z8.array(IdSchema4).max(100).default([])
+});
+var TaskAssetRefSchema = z8.object({
+  id: IdSchema4,
+  sourceRefId: IdSchema4,
+  artifactRef: z8.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
+  fileName: z8.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
+  mediaType: z8.string().trim().min(1).max(200),
+  sha256: Sha256Schema,
+  sizeBytes: z8.number().int().nonnegative().max(25e7),
+  split: TasksetSplitSchema,
+  metadata: MetadataSchema2
+});
+var TaskRequiredOutputSchema = z8.object({
+  path: z8.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
+  mediaType: z8.string().trim().min(1).max(200),
+  schemaRef: IdSchema4.nullable().optional(),
+  maxBytes: z8.number().int().positive().max(1e7).optional(),
+  metadata: MetadataSchema2
+});
+var TaskDataRecordSchema = z8.object({
+  schemaVersion: z8.literal("openpond.taskData.v1"),
+  id: IdSchema4,
+  clusterKey: IdSchema4,
+  split: TasksetSplitSchema,
+  input: z8.record(z8.string(), z8.unknown()),
+  expectedOutput: z8.record(z8.string(), z8.unknown()).nullable(),
+  policyVisibleContext: z8.record(z8.string(), z8.unknown()).default({}),
+  privilegedContextRef: NullableIdSchema,
+  sourceRefs: z8.array(IdSchema4).min(1).max(100),
+  assets: z8.array(TaskAssetRefSchema).max(1e3).optional(),
+  resourceRefs: z8.array(IdSchema4).max(1e3).optional(),
+  requiredOutputs: z8.array(TaskRequiredOutputSchema).max(100).optional(),
+  tags: z8.array(IdSchema4).max(100).default([]),
+  metadata: MetadataSchema2
+});
+var TasksetEnvironmentResourceSchema = z8.object({
+  id: IdSchema4,
+  kind: z8.enum(["file", "catalog", "configuration", "code_module"]),
+  path: z8.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
+  mediaType: z8.string().trim().min(1).max(200).nullable().optional(),
+  visibility: z8.enum(["policy_visible", "policy_hidden", "privileged"]),
+  required: z8.boolean(),
+  metadata: MetadataSchema2
+});
+var LearningSignalBaseSchema = z8.object({
+  id: IdSchema4,
+  taskId: NullableIdSchema,
+  sourceRefs: z8.array(IdSchema4).min(1).max(100),
+  artifactRef: IdSchema4,
+  approved: z8.boolean(),
+  confidence: z8.number().min(0).max(1),
+  metadata: MetadataSchema2
+});
+var DemonstrationSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("demonstration"),
+  prompt: z8.string().max(1e5).nullable().default(null),
+  response: z8.string().max(2e5).nullable().default(null)
+});
+var PreferenceSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("preference"),
+  prompt: z8.string().max(1e5),
+  chosen: z8.string().max(2e5),
+  rejected: z8.string().max(2e5),
+  rationale: z8.string().max(1e5).nullable().default(null)
+});
+var CorrectionSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("correction"),
+  original: z8.string().max(2e5),
+  corrected: z8.string().max(2e5),
+  rationale: z8.string().max(1e5).nullable().default(null)
+});
+var FeedbackSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("feedback"),
+  feedback: z8.string().max(1e5),
+  polarity: z8.enum(["positive", "negative", "mixed", "neutral"])
+});
+var RewardSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("reward"),
+  task: z8.string().max(1e5),
+  rules: z8.array(z8.object({
+    id: IdSchema4,
+    points: z8.number().finite(),
+    condition: z8.string().trim().min(1).max(1e5)
+  })).min(1).max(1e3),
+  otherwisePoints: z8.number().finite(),
+  executable: z8.boolean()
+});
+var LabelSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z8.literal("label"),
+  labelKind: z8.literal("rubric"),
+  task: z8.string().max(1e5),
+  criteria: z8.array(z8.object({
+    id: IdSchema4,
+    label: z8.string().trim().min(1).max(500),
+    description: z8.string().trim().min(1).max(1e5)
+  })).min(1).max(1e3),
+  calibrationExamples: z8.object({
+    positive: z8.string().trim().min(1).max(2e5),
+    negative: z8.string().trim().min(1).max(2e5),
+    boundary: z8.string().trim().min(1).max(2e5)
+  })
+});
+var LearningSignalRefSchema = z8.discriminatedUnion("kind", [
+  DemonstrationSignalSchema,
+  PreferenceSignalSchema,
+  CorrectionSignalSchema,
+  FeedbackSignalSchema,
+  RewardSignalSchema,
+  LabelSignalSchema
+]);
+var LearningSignalInventorySchema = z8.object({
+  demonstrations: z8.array(DemonstrationSignalSchema).max(1e5).default([]),
+  preferences: z8.array(PreferenceSignalSchema).max(1e5).default([]),
+  corrections: z8.array(CorrectionSignalSchema).max(1e5).default([]),
+  feedback: z8.array(FeedbackSignalSchema).max(1e5).default([]),
+  rewards: z8.array(RewardSignalSchema).max(1e5).default([]),
+  labels: z8.array(LabelSignalSchema).max(1e5).default([])
+});
+var TasksetEnvironmentContractSchema = z8.object({
+  protocolVersion: z8.literal("openpond.taskEnvironment.v1"),
+  kind: z8.enum(["chat", "agent", "program", "stateful_harness", "work"]),
+  entrypoint: z8.string().trim().min(1).max(1e3),
+  stateful: z8.boolean(),
+  deterministicSeeds: z8.boolean(),
+  toolNames: z8.array(IdSchema4).max(200).default([]),
+  actionBindings: z8.array(HarnessActionBindingSchema).max(200).optional(),
+  lifecycle: z8.array(z8.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
+  defaultTimeoutMs: z8.number().int().positive().max(36e5),
+  networkPolicy: z8.enum(["none", "declared_read_only", "declared_scoped"]),
+  resources: z8.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
+  metadata: MetadataSchema2
+});
+var TasksetCapabilityManifestSchema = z8.object({
+  schemaVersion: z8.literal("openpond.tasksetCapabilities.v1"),
+  taskKind: z8.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
+  supportedSignals: z8.array(z8.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
+  compatibleMethods: z8.array(z8.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
+  rewardKinds: z8.array(z8.enum(["none", "exact", "deterministic", "model_judge", "human"])),
+  requiresTools: z8.boolean(),
+  requiresState: z8.boolean(),
+  requiresPrivilegedGrading: z8.boolean(),
+  environmentPlacements: z8.array(z8.enum(["local", "remote", "colocated", "provider_native"])),
+  exportable: z8.boolean(),
+  portabilityBlockers: z8.array(z8.string().trim().min(1).max(2e3)).default([])
+});
+var GraderBaseSchema = z8.object({
+  id: IdSchema4,
+  version: z8.string().trim().min(1).max(100),
+  label: z8.string().trim().min(1).max(500),
+  weight: z8.number().min(0).max(1e3).default(1),
+  hardGate: z8.boolean().default(false),
+  rewardEligible: z8.boolean().default(false),
+  privileged: z8.boolean().default(false),
+  metadata: MetadataSchema2
+});
+var DeterministicGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z8.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
+  config: z8.record(z8.string(), z8.unknown())
+});
+var RubricGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z8.literal("model_judge"),
+  rubric: z8.string().trim().min(1).max(5e4),
+  judge: ChatModelRefSchema,
+  calibrationFixtureRefs: z8.array(IdSchema4).min(1).max(500),
+  calibrationStatus: z8.enum(["pending", "passed", "failed"]),
+  temperature: z8.number().min(0).max(2).default(0)
+});
+var HumanGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z8.literal("human"),
+  rubric: z8.string().trim().min(1).max(5e4),
+  reviewerRole: z8.string().trim().min(1).max(500)
+});
+var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z8.literal("custom_verifier"),
+  module: z8.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
+  exportName: CodeIdentifierSchema,
+  timeoutMs: z8.number().int().positive().max(3e5),
+  networkPolicy: z8.literal("none")
+});
+var GraderSpecSchema = z8.union([
+  DeterministicGraderSpecSchema,
+  RubricGraderSpecSchema,
+  HumanGraderSpecSchema,
+  CustomVerifierGraderSpecSchema
+]);
+var GraderFixtureLabelSchema = z8.enum([
+  "positive",
+  "negative",
+  "boundary",
+  "adversarial",
+  "prompt_injection",
+  "infrastructure_failure"
+]);
+var GraderFixtureSchema = z8.object({
+  id: IdSchema4,
+  taskId: IdSchema4,
+  label: GraderFixtureLabelSchema,
+  output: z8.record(z8.string(), z8.unknown()),
+  infrastructureError: z8.string().trim().min(1).max(1e4).nullable(),
+  expectedPassed: z8.boolean(),
+  expectedRewardEligible: z8.boolean(),
+  metadata: MetadataSchema2
+});
+
+// src/taskset-authored-contracts.ts
+import { z as z9 } from "zod";
+import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
+var IdSchema5 = z9.string().trim().min(1).max(240);
+var TimestampSchema4 = z9.string().trim().min(1);
+var HashSchema5 = z9.string().trim().min(8).max(256);
+var MetadataSchema3 = z9.record(z9.string(), z9.unknown()).default({});
+var NullableIdSchema2 = IdSchema5.nullable();
+var TASKSET_WORK_TOOL_NAMES = [
+  "work_capabilities",
+  "work_environment",
+  "work_list_files",
+  "work_read_file",
+  "work_read_document",
+  "work_write_file",
+  "work_write_docx",
+  "work_edit_file",
+  "work_delete_file",
+  "work_exec",
+  "work_save_output",
+  "work_stop"
+];
+var TasksetStatusSchema = z9.enum([
+  "draft",
+  "awaiting_disclosure_approval",
+  "awaiting_materialization_approval",
+  "materializing",
+  "validating",
+  "needs_review",
+  "baselining",
+  "ready",
+  "blocked",
+  "failed",
+  "archived"
+]);
+var DatasetBuildIntentSchema = z9.enum([
+  "demonstrations",
+  "preferences",
+  "verifiable_reward",
+  "rubric",
+  "discovery"
+]);
+var DatasetEvidenceTextSchema = z9.string().trim().max(1e5);
+var DatasetBuildSpecificationSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("demonstrations"),
+    behavior: DatasetEvidenceTextSchema,
+    examples: z9.array(z9.object({
+      id: IdSchema5,
+      prompt: DatasetEvidenceTextSchema,
+      response: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z9.object({
+    kind: z9.literal("preferences"),
+    preference: DatasetEvidenceTextSchema,
+    pairs: z9.array(z9.object({
+      id: IdSchema5,
+      prompt: DatasetEvidenceTextSchema,
+      chosen: DatasetEvidenceTextSchema,
+      rejected: DatasetEvidenceTextSchema,
+      rationale: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z9.object({
+    kind: z9.literal("verifiable_reward"),
+    task: DatasetEvidenceTextSchema,
+    rules: z9.array(z9.object({
+      id: IdSchema5,
+      points: z9.number().finite(),
+      condition: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    otherwisePoints: z9.number().finite().default(0)
+  }),
+  z9.object({
+    kind: z9.literal("rubric"),
+    task: DatasetEvidenceTextSchema,
+    criteria: z9.array(z9.object({
+      id: IdSchema5,
+      label: z9.string().trim().max(500),
+      description: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    positiveExample: DatasetEvidenceTextSchema,
+    negativeExample: DatasetEvidenceTextSchema,
+    boundaryExample: DatasetEvidenceTextSchema
+  })
+]);
+var GeneratedTaskFileSchema = z9.object({
+  path: z9.string().trim().min(1).max(1e3),
+  role: z9.enum(["environment", "verifier", "fixture"]),
+  content: z9.string().max(25e4)
+});
+var TrainingPathRecommendationSchema = z9.object({
+  primaryMethod: z9.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
+  bootstrap: z9.object({
+    method: z9.literal("sft"),
+    purpose: z9.literal("trajectory_bootstrap"),
+    demonstrationRefs: z9.array(IdSchema5).min(1).max(1e5),
+    limitations: z9.array(z9.string().trim().min(1).max(5e3)).min(1).max(100)
+  }).nullable()
+});
+var TrainingMethodReadinessReasonCodeSchema = z9.enum([
+  "taskset_not_ready",
+  "demonstrations_missing",
+  "preference_pairs_missing",
+  "preference_pairs_invalid",
+  "executable_reward_missing",
+  "reward_not_calibrated",
+  "reward_model_missing",
+  "value_model_required",
+  "frozen_eval_missing"
+]);
+var TrainingMethodReadinessSchema = z9.object({
+  method: z9.enum(["sft", "dpo", "grpo", "ppo"]),
+  status: z9.enum(["recommended", "compatible", "needs_dataset_work"]),
+  reasonCodes: z9.array(TrainingMethodReadinessReasonCodeSchema).default([]),
+  reasons: z9.array(z9.string().trim().min(1).max(5e3)).default([])
+});
+var TasksetReadinessFindingSchema = z9.object({
+  code: IdSchema5,
+  message: z9.string().trim().min(1).max(5e3),
+  path: z9.string().trim().max(2e3).nullable()
+});
+var TasksetReadinessReportSchema = z9.object({
+  schemaVersion: z9.literal("openpond.tasksetReadiness.v1"),
+  tasksetId: IdSchema5,
+  tasksetHash: HashSchema5,
+  ready: z9.boolean(),
+  recommendedMethod: z9.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+  trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
+  methodReadiness: z9.array(TrainingMethodReadinessSchema).default([]),
+  compatibleDestinationClasses: z9.array(
+    z9.enum(["export", "custom", "hosted_managed"])
+  ),
+  blockers: z9.array(TasksetReadinessFindingSchema).default([]),
+  advisories: z9.array(TasksetReadinessFindingSchema).default([]),
+  warnings: z9.array(z9.string().trim().min(1).max(5e3)).default([]),
+  generatedAt: TimestampSchema4
+});
+var AuthoringRepairSchema = z9.object({ attempt: z9.number().int().positive(), summary: z9.string().trim().min(1).max(5e3), createdAt: TimestampSchema4 });
+var AuthoringProvenanceSchema = z9.object({
+  schemaVersion: z9.literal("openpond.taskAuthoringProvenance.v1"),
+  model: ChatModelRefSchema.nullable(),
+  modelConfig: MetadataSchema3,
+  skillHash: HashSchema5,
+  promptTemplateVersion: z9.string().trim().min(1).max(200),
+  buildIntent: DatasetBuildIntentSchema.default("demonstrations"),
+  buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),
+  evidenceHashes: z9.array(HashSchema5).max(1e5),
+  tasksetSdkVersion: z9.string().trim().min(1).max(100),
+  sourceCommit: z9.string().trim().min(1).max(256).nullable(),
+  repairHistory: z9.array(AuthoringRepairSchema).max(1e3),
+  createdAt: TimestampSchema4
+});
+var TasksetSchema = z9.object({
+  schemaVersion: z9.literal("openpond.taskset.v1"),
+  id: IdSchema5,
+  revision: z9.number().int().positive().default(1),
+  profileId: IdSchema5,
+  profileRelease: VersionedReleaseRefSchema.nullable().optional(),
+  createImproveRunId: NullableIdSchema2.default(null),
+  name: z9.string().trim().min(1).max(500),
+  // Portable tasks may carry all instructions in their individual inputs.
+  // Preserve an absent package prompt; draft publication validates its objective.
+  objective: z9.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetStatusSchema,
+  sourceRefs: z9.array(TasksetSourceRefSchema).min(1).max(1e5),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema.optional(),
+  tasks: z9.array(TaskDataRecordSchema).max(1e6),
+  graders: z9.array(GraderSpecSchema).min(1).max(1e3),
+  // Imported releases are inspectable before local calibration. Admission
+  // requires real fixtures separately in validateTaskset.
+  graderFixtures: z9.array(GraderFixtureSchema).max(1e5),
+  learningSignals: LearningSignalInventorySchema,
+  authoringProvenance: AuthoringProvenanceSchema,
+  readiness: TasksetReadinessReportSchema.nullable(),
+  contentHash: HashSchema5,
+  createdAt: TimestampSchema4,
+  updatedAt: TimestampSchema4,
+  metadata: MetadataSchema3
+}).superRefine((taskset, context) => {
+  if (taskset.purpose === "benchmark" && !taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark Tasksets require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (taskset.purpose !== "benchmark" && taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark Tasksets may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (taskset.datasetArtifact && taskset.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed Tasksets may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (!taskset.datasetArtifact && taskset.tasks.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "A Taskset requires inline tasks or a Dataset artifact manifest.",
+      path: ["tasks"]
+    });
+  }
+});
+function isTrainingSourceRef(source) {
+  return source.schemaVersion === "openpond.trainingSource.v1";
+}
+
+// src/taskset-authored-validation.ts
+function validateTaskset(input) {
+  const parsed = TasksetSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      taskset: null,
+      computedHash: null,
+      issues: parsed.error.issues.map((issue) => ({
+        code: "schema_invalid",
+        severity: "error",
+        message: issue.message,
+        path: issue.path.join(".")
+      }))
+    };
+  }
+  const taskset = parsed.data;
+  const issues = [];
+  validateSourceConsent(taskset, issues);
+  validateDatasetArtifact(taskset, issues);
+  validateSplitIsolation(taskset, issues);
+  validatePolicyBoundary(taskset, issues);
+  validateGraders(taskset, issues);
+  validateGraderFixtures(taskset, issues);
+  validateLearningSignals(taskset, issues);
+  validateCapabilities(taskset.capabilities, issues, taskset);
+  validateWorkExecution(taskset, issues);
+  const computedHash = tasksetContentHash(taskset);
+  if (taskset.contentHash !== computedHash) {
+    issues.push({
+      code: "content_hash_mismatch",
+      severity: "error",
+      message: `Taskset contentHash is ${taskset.contentHash}, expected ${computedHash}.`,
+      path: "contentHash"
+    });
+  }
+  return {
+    valid: !issues.some((issue) => issue.severity === "error"),
+    taskset,
+    computedHash,
+    issues
+  };
+}
+function validateGraderFixtures(taskset, issues) {
+  if (!taskset.graderFixtures.length) issues.push({ code: "grader_fixtures_required", severity: "error", message: "Taskset admission requires authored grader fixtures.", path: "graderFixtures" });
+  const taskIds = new Set(taskset.tasks.map((task) => task.id));
+  const required = /* @__PURE__ */ new Set(["positive", "negative", "boundary", "adversarial", "prompt_injection", "infrastructure_failure"]);
+  for (const fixture of taskset.graderFixtures) {
+    if (!taskset.datasetArtifact && !taskIds.has(fixture.taskId)) issues.push({ code: "grader_fixture_task_missing", severity: "warning", message: `Fixture ${fixture.id} references a task outside this Taskset revision (${fixture.taskId}).`, path: `graderFixtures.${fixture.id}.taskId` });
+    required.delete(fixture.label);
+    if (fixture.label === "infrastructure_failure" && !fixture.infrastructureError) issues.push({ code: "infrastructure_fixture_error_missing", severity: "error", message: `Infrastructure fixture ${fixture.id} must declare an infrastructure error.`, path: `graderFixtures.${fixture.id}.infrastructureError` });
+  }
+  for (const label of required) issues.push({ code: "grader_fixture_missing", severity: "warning", message: `Taskset does not include the optional ${label} grader calibration fixture.`, path: "graderFixtures" });
+}
+function validateDatasetArtifact(taskset, issues) {
+  const artifact = taskset.datasetArtifact;
+  if (!artifact) return;
+  if (artifact.tasksetId !== taskset.id || artifact.tasksetRevision !== taskset.revision) {
+    issues.push({
+      code: "dataset_artifact_taskset_mismatch",
+      severity: "error",
+      message: "Dataset artifact identity does not match its Taskset revision.",
+      path: "datasetArtifact"
+    });
+  }
+  const splitTotal = Object.values(artifact.splitCounts).reduce((total, count) => total + count, 0);
+  const shardTotal = artifact.shards.reduce((total, shard) => total + shard.rowCount, 0);
+  if (splitTotal !== artifact.rowCount || shardTotal !== artifact.rowCount) {
+    issues.push({
+      code: "dataset_artifact_row_count_mismatch",
+      severity: "error",
+      message: "Dataset artifact row, split, and shard counts do not agree.",
+      path: "datasetArtifact.rowCount"
+    });
+  }
+  const shardSplitCounts = /* @__PURE__ */ new Map();
+  for (const shard of artifact.shards) {
+    shardSplitCounts.set(
+      shard.split,
+      (shardSplitCounts.get(shard.split) ?? 0) + shard.rowCount
+    );
+  }
+  for (const [split, count] of Object.entries(artifact.splitCounts)) {
+    if ((shardSplitCounts.get(split) ?? 0) !== count) {
+      issues.push({
+        code: "dataset_artifact_split_count_mismatch",
+        severity: "error",
+        message: `Dataset artifact ${split} shard counts do not match its manifest.`,
+        path: `datasetArtifact.splitCounts.${split}`
+      });
+    }
+  }
+  const { contentHash: _contentHash, ...hashable } = artifact;
+  if (contentHash(hashable) !== artifact.contentHash) {
+    issues.push({
+      code: "dataset_artifact_hash_mismatch",
+      severity: "error",
+      message: "Dataset artifact manifest content hash is invalid.",
+      path: "datasetArtifact.contentHash"
+    });
+  }
+}
+function computeTasksetHash(taskset) {
+  return tasksetContentHash(taskset);
+}
+function tasksetContentHash(taskset) {
+  const { contentHash: _contentHash, status: _status, readiness: _readiness, updatedAt: _updatedAt, ...source } = taskset;
+  return contentHash(source);
+}
+function validatePortability(capabilities) {
+  const issues = [];
+  validateCapabilities(capabilities, issues, null);
+  return issues;
+}
+function validateSourceConsent(taskset, issues) {
+  for (const [index, source] of taskset.sourceRefs.entries()) {
+    if (isTrainingSourceRef(source) && source.consent.status !== "granted") {
+      issues.push({ code: "source_consent_missing", severity: "error", message: `Source ${source.id} is not consented.`, path: `sourceRefs.${index}.consent.status` });
+    }
+    if (source.secretScanStatus !== "passed") {
+      issues.push({ code: "source_secret_scan", severity: "error", message: `Source ${source.id} did not pass secret scanning.`, path: `sourceRefs.${index}.secretScanStatus` });
+    }
+    if (source.piiScanStatus !== "passed") {
+      issues.push({ code: "source_pii_scan", severity: "error", message: `Source ${source.id} has unresolved PII policy.`, path: `sourceRefs.${index}.piiScanStatus` });
+    }
+    if (source.licensingStatus !== "approved") {
+      issues.push({ code: "source_license", severity: "error", message: `Source ${source.id} has unresolved licensing policy.`, path: `sourceRefs.${index}.licensingStatus` });
+    }
+  }
+}
+function validateSplitIsolation(taskset, issues) {
+  const clusterSplits = /* @__PURE__ */ new Map();
+  for (const task of taskset.tasks) {
+    const splits = clusterSplits.get(task.clusterKey) ?? /* @__PURE__ */ new Set();
+    splits.add(task.split);
+    clusterSplits.set(task.clusterKey, splits);
+  }
+  for (const [cluster, splits] of clusterSplits) {
+    if (splits.size > 1) {
+      issues.push({ code: "split_cluster_contamination", severity: "error", message: `Source cluster ${cluster} appears in multiple splits: ${[...splits].join(", ")}.`, path: "tasks" });
+    }
+  }
+  const frozenCount = taskset.datasetArtifact ? taskset.datasetArtifact.splitCounts.frozen_eval ?? 0 : taskset.tasks.filter((task) => task.split === "frozen_eval").length;
+  if (frozenCount === 0) issues.push({ code: "frozen_eval_missing", severity: "warning", message: "Add an independent test example before training.", path: "tasks" });
+}
+function validateWorkExecution(taskset, issues) {
+  if (taskset.environment.kind !== "work") return;
+  if (taskset.environment.entrypoint !== "openpond-work-v1") {
+    issues.push({
+      code: "work_entrypoint_invalid",
+      severity: "error",
+      message: "Work Tasksets must use the openpond-work-v1 entrypoint.",
+      path: "environment.entrypoint"
+    });
+  }
+  if (taskset.environment.stateful) {
+    issues.push({
+      code: "work_stateful_invalid",
+      severity: "error",
+      message: "Automated Work attempts must start from clean state.",
+      path: "environment.stateful"
+    });
+  }
+  const allowedTools = new Set(TASKSET_WORK_TOOL_NAMES);
+  const unknownTools = taskset.environment.toolNames.filter(
+    (name) => !allowedTools.has(name)
+  );
+  if (unknownTools.length) {
+    issues.push({
+      code: "work_tool_unknown",
+      severity: "error",
+      message: `Work Taskset declares unknown tools: ${unknownTools.join(", ")}.`,
+      path: "environment.toolNames"
+    });
+  }
+  if (!taskset.environment.toolNames.includes("work_save_output")) {
+    issues.push({
+      code: "work_output_tool_missing",
+      severity: "error",
+      message: "Work Tasksets must declare work_save_output.",
+      path: "environment.toolNames"
+    });
+  }
+  for (const lifecycle of ["create", "reset", "step", "grade", "cleanup"]) {
+    if (!taskset.environment.lifecycle.includes(lifecycle)) {
+      issues.push({
+        code: "work_lifecycle_incomplete",
+        severity: "error",
+        message: `Work Tasksets require the ${lifecycle} lifecycle stage.`,
+        path: "environment.lifecycle"
+      });
+    }
+  }
+  const sourceById = new Map(
+    taskset.sourceRefs.map((source) => [source.id, source])
+  );
+  for (const [taskIndex, task] of taskset.tasks.entries()) {
+    const assetIds = /* @__PURE__ */ new Set();
+    const fileNames = /* @__PURE__ */ new Set();
+    for (const [assetIndex, asset] of (task.assets ?? []).entries()) {
+      const path = `tasks.${taskIndex}.assets.${assetIndex}`;
+      if (assetIds.has(asset.id)) {
+        issues.push({
+          code: "work_asset_duplicate_id",
+          severity: "error",
+          message: `Task ${task.id} repeats asset id ${asset.id}.`,
+          path: `${path}.id`
+        });
+      }
+      if (fileNames.has(asset.fileName)) {
+        issues.push({
+          code: "work_asset_duplicate_name",
+          severity: "error",
+          message: `Task ${task.id} repeats staged file name ${asset.fileName}.`,
+          path: `${path}.fileName`
+        });
+      }
+      assetIds.add(asset.id);
+      fileNames.add(asset.fileName);
+      if (!task.sourceRefs.includes(asset.sourceRefId)) {
+        issues.push({
+          code: "work_asset_task_source_missing",
+          severity: "error",
+          message: `Asset ${asset.id} references source ${asset.sourceRefId} outside task ${task.id}.`,
+          path: `${path}.sourceRefId`
+        });
+      }
+      const source = sourceById.get(asset.sourceRefId);
+      if (!source) {
+        issues.push({
+          code: "work_asset_source_missing",
+          severity: "error",
+          message: `Asset ${asset.id} references missing source ${asset.sourceRefId}.`,
+          path: `${path}.sourceRefId`
+        });
+      } else if ("sourceFileHashes" in source && !source.sourceFileHashes.includes(asset.sha256)) {
+        issues.push({
+          code: "work_asset_hash_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} hash is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.sha256`
+        });
+      }
+      if (source && "kind" in source && source.kind === "uploaded_file" && !source.originalFileNames.includes(asset.fileName)) {
+        issues.push({
+          code: "work_asset_name_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} file name is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.fileName`
+        });
+      }
+      if (source && "kind" in source && source.kind === "uploaded_file" && !source.mediaTypes.includes(asset.mediaType)) {
+        issues.push({
+          code: "work_asset_media_type_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} media type is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.mediaType`
+        });
+      }
+      if (asset.split !== task.split) {
+        issues.push({
+          code: "work_asset_split_mismatch",
+          severity: "error",
+          message: `Asset ${asset.id} is assigned to ${asset.split}, not task split ${task.split}.`,
+          path: `${path}.split`
+        });
+      }
+    }
+    const outputPaths = /* @__PURE__ */ new Set();
+    for (const [outputIndex, output] of (task.requiredOutputs ?? []).entries()) {
+      const normalized = output.path.replaceAll("\\", "/");
+      const path = `tasks.${taskIndex}.requiredOutputs.${outputIndex}.path`;
+      if (outputPaths.has(normalized)) {
+        issues.push({
+          code: "work_output_duplicate_path",
+          severity: "error",
+          message: `Task ${task.id} repeats required output path ${normalized}.`,
+          path
+        });
+      }
+      outputPaths.add(normalized);
+    }
+    if ((task.requiredOutputs ?? []).length === 0) {
+      issues.push({
+        code: "work_output_missing",
+        severity: "error",
+        message: `Work task ${task.id} must declare at least one required output.`,
+        path: `tasks.${taskIndex}.requiredOutputs`
+      });
+    }
+  }
+}
+function validatePolicyBoundary(taskset, issues) {
+  const visible = new Set(taskset.policy.policyVisibleFields);
+  for (const field of taskset.policy.privilegedFields) {
+    if (visible.has(field)) issues.push({ code: "privileged_field_visible", severity: "error", message: `Field ${field} is both policy-visible and privileged.`, path: "policy" });
+  }
+  for (const task of taskset.tasks) {
+    if (task.privilegedContextRef && Object.keys(task.policyVisibleContext).includes(task.privilegedContextRef)) {
+      issues.push({ code: "privileged_context_leak", severity: "error", message: `Task ${task.id} exposes its privileged context reference.`, path: `tasks.${task.id}.policyVisibleContext` });
+    }
+  }
+}
+function validateGraders(taskset, issues) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const grader of taskset.graders) {
+    if (ids.has(grader.id)) issues.push({ code: "grader_duplicate", severity: "error", message: `Duplicate grader id ${grader.id}.`, path: "graders" });
+    ids.add(grader.id);
+    if (grader.kind === "model_judge" && grader.rewardEligible && grader.calibrationStatus !== "passed") {
+      issues.push({ code: "judge_calibration_pending", severity: "warning", message: `Model judge ${grader.id} is selected for reward without a passing advisory calibration report.`, path: `graders.${grader.id}` });
+    }
+    if (grader.kind === "model_judge" && grader.calibrationStatus === "passed" && typeof grader.metadata.calibrationEvidenceHash !== "string") {
+      issues.push({ code: "judge_calibration_evidence_missing", severity: "warning", message: `Model judge ${grader.id} declares calibration without an OpenPond fixture evidence hash.`, path: `graders.${grader.id}.metadata.calibrationEvidenceHash` });
+    }
+    if (grader.kind === "human" && grader.rewardEligible) {
+      issues.push({ code: "human_online_reward", severity: "error", message: `Human grader ${grader.id} cannot be an online optimizer reward.`, path: `graders.${grader.id}` });
+    }
+  }
+}
+function validateLearningSignals(taskset, issues) {
+  const taskIds = new Set(taskset.tasks.map((task) => task.id));
+  const sourceIds = new Set(taskset.sourceRefs.map((source) => source.id));
+  for (const signal of [
+    ...taskset.learningSignals.demonstrations,
+    ...taskset.learningSignals.preferences,
+    ...taskset.learningSignals.corrections,
+    ...taskset.learningSignals.feedback,
+    ...taskset.learningSignals.rewards,
+    ...taskset.learningSignals.labels
+  ]) {
+    if (signal.taskId && !taskset.datasetArtifact && !taskIds.has(signal.taskId)) {
+      issues.push({ code: "learning_signal_task_missing", severity: "error", message: `Signal ${signal.id} references missing task ${signal.taskId}.`, path: `learningSignals.${signal.kind}.${signal.id}.taskId` });
+    }
+    if (signal.sourceRefs.some((sourceId) => !sourceIds.has(sourceId))) {
+      issues.push({ code: "learning_signal_source_missing", severity: "error", message: `Signal ${signal.id} references a source outside the Dataset.`, path: `learningSignals.${signal.kind}.${signal.id}.sourceRefs` });
+    }
+  }
+  for (const preference of taskset.learningSignals.preferences) {
+    if (preference.chosen.trim() === preference.rejected.trim()) {
+      issues.push({ code: "preference_pair_identical", severity: "error", message: `Preference ${preference.id} has identical chosen and rejected responses.`, path: `learningSignals.preferences.${preference.id}` });
+    }
+  }
+  for (const reward of taskset.learningSignals.rewards) {
+    if (!reward.executable) {
+      issues.push({ code: "reward_not_executable", severity: "warning", message: `Reward ${reward.id} is a reviewed specification but has no executable verifier yet.`, path: `learningSignals.rewards.${reward.id}.executable` });
+    }
+  }
+}
+function validateCapabilities(capabilities, issues, taskset) {
+  if (!capabilities.exportable && capabilities.portabilityBlockers.length === 0) {
+    issues.push({ code: "portability_reason_missing", severity: "error", message: "Non-exportable Tasksets must declare a portability blocker.", path: "capabilities.portabilityBlockers" });
+  }
+  if (capabilities.compatibleMethods.includes("grpo") && !capabilities.rewardKinds.some((kind) => kind === "exact" || kind === "deterministic" || kind === "model_judge")) {
+    issues.push({ code: "grpo_reward_missing", severity: "error", message: "GRPO compatibility requires a scalar reward kind.", path: "capabilities.rewardKinds" });
+  }
+  if (taskset?.capabilities.compatibleMethods.includes("sft") && taskset.learningSignals.demonstrations.length === 0) {
+    issues.push({ code: "sft_demonstrations_missing", severity: "error", message: "SFT compatibility requires approved demonstrations.", path: "learningSignals.demonstrations" });
+  }
+  if (taskset?.capabilities.compatibleMethods.includes("dpo") && taskset.learningSignals.preferences.length === 0) {
+    issues.push({ code: "dpo_preferences_missing", severity: "error", message: "DPO compatibility requires chosen and rejected response pairs.", path: "learningSignals.preferences" });
+  }
+  if (taskset && (taskset.capabilities.compatibleMethods.includes("grpo") || taskset.capabilities.compatibleMethods.includes("ppo")) && !taskset.learningSignals.rewards.some((reward) => reward.executable)) {
+    issues.push({ code: "online_reward_not_executable", severity: "error", message: "GRPO/PPO compatibility requires an executable scalar reward.", path: "learningSignals.rewards" });
+  }
+}
+
+// src/taskset-draft-document.ts
+import { z as z10 } from "zod";
+import { TasksetMetricPolicySchema as TasksetMetricPolicySchema2 } from "@openpond/evals/metrics";
+var IdSchema6 = z10.string().trim().min(1).max(240);
+var TimestampSchema5 = z10.string().trim().min(1);
+var HashSchema6 = z10.string().trim().min(8).max(256);
+var CodeIdentifierSchema2 = z10.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema4 = z10.record(z10.string(), z10.unknown()).default({});
+function safeRelativeFilePath2(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
+    return false;
+  }
+  return !normalized.split("/").some(
+    (segment) => !segment || segment === "." || segment === ".."
+  );
+}
+var TaskDataDraftSchema = TaskDataRecordSchema.extend({
+  sourceRefs: z10.array(IdSchema6).max(100).default([])
+});
+var TasksetDraftStatusSchema = z10.enum([
+  "draft",
+  "validating",
+  "needs_review",
+  "published"
+]);
+var TasksetDraftReviewPolicySchema = z10.object({
+  enabled: z10.boolean(),
+  candidateCount: z10.number().int().min(2).max(4),
+  minimumSamples: z10.number().int().min(1).max(1e4).default(100),
+  allowTies: z10.boolean(),
+  allowRejectAll: z10.boolean(),
+  rubric: z10.string().trim().max(5e4),
+  criteria: z10.array(z10.object({
+    id: IdSchema6,
+    label: z10.string().trim().min(1).max(500),
+    description: z10.string().trim().max(1e4),
+    weight: z10.number().nonnegative().max(1e3)
+  })).max(100)
+});
+var TasksetDraftOutputContractSchema = z10.object({
+  mode: z10.enum(["text", "structured_json", "artifacts"]),
+  jsonSchema: z10.record(z10.string(), z10.unknown()).nullable(),
+  renderer: z10.object({
+    module: z10.string().trim().min(1).max(1e3).refine(safeRelativeFilePath2, "Renderer modules must use a safe relative path."),
+    exportName: CodeIdentifierSchema2,
+    configRef: z10.string().trim().min(1).max(1e3).refine(safeRelativeFilePath2, "Renderer configuration must use a safe relative path.").nullable().default(null)
+  }).nullable()
+}).superRefine((output, context) => {
+  if (output.mode === "structured_json" && !output.jsonSchema) {
+    context.addIssue({
+      code: "custom",
+      message: "Structured JSON output requires a JSON Schema.",
+      path: ["jsonSchema"]
+    });
+  }
+  if (output.mode === "text" && output.renderer) {
+    context.addIssue({
+      code: "custom",
+      message: "Text output cannot configure an artifact renderer.",
+      path: ["renderer"]
+    });
+  }
+});
+var TasksetDraftSchema = z10.object({
+  schemaVersion: z10.literal("openpond.tasksetDraft.v1"),
+  id: IdSchema6,
+  revision: z10.number().int().positive(),
+  profileId: IdSchema6,
+  modelScope: z10.object({
+    modelId: IdSchema6,
+    expectedModelRevision: z10.number().int().positive(),
+    source: ModelTasksetDraftPreparationSchema.optional()
+  }).strict().nullable().default(null),
+  name: z10.string().trim().max(500),
+  objective: z10.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetDraftStatusSchema,
+  sourceRefs: z10.array(TasksetSourceRefSchema).max(1e5).default([]),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  output: TasksetDraftOutputContractSchema.default({
+    mode: "text",
+    jsonSchema: null,
+    renderer: null
+  }),
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema2,
+  review: TasksetDraftReviewPolicySchema,
+  tasks: z10.array(TaskDataDraftSchema).max(1e6).default([]),
+  graders: z10.array(GraderSpecSchema).max(1e3).default([]),
+  graderFixtures: z10.array(GraderFixtureSchema).max(1e5).default([]),
+  learningSignals: LearningSignalInventorySchema,
+  publishedTasksetRef: z10.object({
+    id: IdSchema6,
+    revision: z10.number().int().positive(),
+    contentHash: HashSchema6
+  }).nullable(),
+  createdAt: TimestampSchema5,
+  updatedAt: TimestampSchema5,
+  metadata: MetadataSchema4
+}).superRefine((draft, context) => {
+  if (draft.purpose === "benchmark" && !draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark drafts require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.purpose !== "benchmark" && draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark drafts may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.datasetArtifact && draft.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed drafts may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (draft.status === "published" && !draft.publishedTasksetRef) {
+    context.addIssue({
+      code: "custom",
+      message: "Published drafts require an immutable Taskset reference.",
+      path: ["publishedTasksetRef"]
+    });
+  }
+});
+
+// src/taskset-draft-authoring.ts
+var TasksetDraftPublishError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues.map((issue) => issue.message).join("\n"));
+    this.name = "TasksetDraftPublishError";
+    this.issues = issues;
+  }
+};
+function createTasksetDraft(input) {
+  const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const id = input.id?.trim() || `taskset-draft-${globalThis.crypto.randomUUID()}`;
+  return TasksetDraftSchema.parse({
+    schemaVersion: "openpond.tasksetDraft.v1",
+    id,
+    revision: 1,
+    profileId: input.profileId,
+    modelScope: input.modelScope ?? null,
+    name: input.name?.trim() ?? "",
+    objective: "",
+    purpose: "general",
+    benchmark: null,
+    preferenceComparison: null,
+    status: "draft",
+    sourceRefs: [],
+    datasetArtifact: null,
+    policy: {
+      policyVisibleFields: ["input"],
+      privilegedFields: ["expectedOutput"],
+      hiddenGraderRefs: [],
+      connectedAppScopes: []
+    },
+    environment: {
+      protocolVersion: "openpond.taskEnvironment.v1",
+      kind: "chat",
+      entrypoint: "openpond-chat-v1",
+      stateful: false,
+      deterministicSeeds: true,
+      toolNames: [],
+      lifecycle: ["create", "reset", "step", "grade", "cleanup"],
+      defaultTimeoutMs: 12e4,
+      networkPolicy: "none",
+      resources: [],
+      metadata: {}
+    },
+    output: {
+      mode: "text",
+      jsonSchema: null,
+      renderer: null
+    },
+    capabilities: {
+      schemaVersion: "openpond.tasksetCapabilities.v1",
+      taskKind: "chat",
+      supportedSignals: [
+        "demonstration",
+        "preference",
+        "correction",
+        "feedback",
+        "reward",
+        "label"
+      ],
+      compatibleMethods: ["none"],
+      rewardKinds: ["none"],
+      requiresTools: false,
+      requiresState: false,
+      requiresPrivilegedGrading: true,
+      environmentPlacements: ["local", "remote", "colocated"],
+      exportable: true,
+      portabilityBlockers: []
+    },
+    metrics: {
+      schemaVersion: "openpond.tasksetMetricPolicy.v1",
+      primaryMetric: "score",
+      aggregation: "mean_score",
+      missingReward: "zero",
+      customAggregator: null
+    },
+    review: {
+      enabled: false,
+      candidateCount: 2,
+      minimumSamples: 100,
+      allowTies: true,
+      allowRejectAll: true,
+      rubric: "",
+      criteria: []
+    },
+    tasks: [],
+    graders: [],
+    graderFixtures: [],
+    learningSignals: {
+      demonstrations: [],
+      preferences: [],
+      corrections: [],
+      feedback: [],
+      rewards: [],
+      labels: []
+    },
+    publishedTasksetRef: null,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    metadata: {}
+  });
+}
+function draftPublishIssues(draft) {
+  const issues = [];
+  if (!draft.name.trim()) issues.push({ code: "name_missing", message: "Name is required.", path: "name" });
+  if (!draft.objective.trim()) issues.push({ code: "objective_missing", message: "Objective is required.", path: "objective" });
+  if (!draft.datasetArtifact && draft.tasks.length === 0) issues.push({ code: "tasks_missing", message: "Add at least one task or Dataset artifact.", path: "tasks" });
+  if (draft.graders.length === 0) issues.push({ code: "graders_missing", message: "Add at least one grader.", path: "graders" });
+  if (draft.graderFixtures.length === 0) issues.push({ code: "grader_fixtures_missing", message: "Add grader fixtures before publishing.", path: "graderFixtures" });
+  const sourceIds = new Set(draft.sourceRefs.map((source) => source.id));
+  for (const task of draft.tasks) {
+    for (const sourceId of task.sourceRefs) {
+      if (!sourceIds.has(sourceId)) issues.push({ code: "task_source_missing", message: `Task ${task.id} references missing source ${sourceId}.`, path: `tasks.${task.id}.sourceRefs` });
+    }
+  }
+  return issues;
+}
+
+// src/taskset-draft-publication.ts
+function tasksetDraftFromTaskset(tasksetInput, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const taskset = TasksetSchema.parse(tasksetInput);
+  return TasksetDraftSchema.parse({
+    schemaVersion: "openpond.tasksetDraft.v1",
+    id: `${taskset.id}-draft`,
+    revision: 1,
+    profileId: taskset.profileId,
+    name: taskset.name,
+    objective: taskset.objective,
+    purpose: taskset.purpose,
+    benchmark: taskset.benchmark,
+    preferenceComparison: taskset.preferenceComparison,
+    status: "draft",
+    sourceRefs: taskset.sourceRefs,
+    datasetArtifact: taskset.datasetArtifact ?? null,
+    policy: taskset.policy,
+    environment: taskset.environment,
+    output: tasksetOutputContract(taskset.metadata),
+    capabilities: taskset.capabilities,
+    metrics: taskset.metrics ?? {
+      schemaVersion: "openpond.tasksetMetricPolicy.v1",
+      primaryMetric: "score",
+      aggregation: "mean_score",
+      missingReward: "zero",
+      customAggregator: null
+    },
+    review: {
+      enabled: Boolean(taskset.preferenceComparison),
+      candidateCount: 2,
+      minimumSamples: 100,
+      allowTies: true,
+      allowRejectAll: true,
+      rubric: "",
+      criteria: []
+    },
+    tasks: taskset.tasks,
+    graders: taskset.graders,
+    graderFixtures: taskset.graderFixtures,
+    learningSignals: taskset.learningSignals,
+    publishedTasksetRef: {
+      id: taskset.id,
+      revision: taskset.revision,
+      contentHash: taskset.contentHash
+    },
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      ...taskset.metadata,
+      importedFromTaskset: {
+        id: taskset.id,
+        revision: taskset.revision,
+        contentHash: taskset.contentHash
+      }
+    }
+  });
+}
+function publishTasksetDraft(input) {
+  const draft = TasksetDraftSchema.parse(input.draft);
+  const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const issues = draftPublishIssues(draft);
+  if (issues.length) throw new TasksetDraftPublishError(issues);
+  const preparedSource = draft.modelScope?.source;
+  if (preparedSource && input.tasksetId && input.tasksetId !== preparedSource.tasksetId) throw new Error("Taskset draft publication differs from its prepared identity.");
+  const tasksetId = preparedSource?.tasksetId || input.tasksetId?.trim() || draft.publishedTasksetRef?.id || draft.id.replace(/-draft$/, "");
+  const revision = preparedSource?.tasksetRevision ?? (draft.publishedTasksetRef?.id === tasksetId ? draft.publishedTasksetRef.revision + 1 : 1);
+  const sourceRefs = draft.sourceRefs.length ? draft.sourceRefs : [generatedDraftSource(draft, tasksetId, timestamp)];
+  const defaultSourceId = sourceRefs[0].id;
+  const tasks = draft.tasks.map((task) => TaskDataRecordSchema.parse({
+    ...task,
+    sourceRefs: task.sourceRefs.length ? task.sourceRefs : [defaultSourceId],
+    metadata: {
+      exampleOrigin: "expert_authored",
+      ...task.metadata
+    }
+  }));
+  const authoredMethod = draft.capabilities.compatibleMethods.find(
+    (method) => method !== "none" && method !== "retrieval"
+  ) ?? null;
+  const buildIntent = buildIntentForDraft(draft);
+  const taskset = TasksetSchema.parse({
+    schemaVersion: "openpond.taskset.v1",
+    id: tasksetId,
+    revision,
+    profileId: draft.profileId,
+    profileRelease: null,
+    createImproveRunId: null,
+    name: draft.name,
+    objective: draft.objective,
+    purpose: draft.purpose,
+    benchmark: draft.benchmark,
+    preferenceComparison: draft.preferenceComparison,
+    status: "needs_review",
+    sourceRefs,
+    datasetArtifact: draft.datasetArtifact ?? null,
+    policy: draft.policy,
+    environment: draft.environment,
+    capabilities: draft.capabilities,
+    metrics: draft.metrics,
+    tasks,
+    graders: draft.graders,
+    graderFixtures: draft.graderFixtures,
+    learningSignals: draft.learningSignals,
+    authoringProvenance: {
+      schemaVersion: "openpond.taskAuthoringProvenance.v1",
+      model: null,
+      modelConfig: {},
+      skillHash: contentHash("openpond-taskset-draft-authoring-v1"),
+      promptTemplateVersion: "taskset-draft-v1",
+      buildIntent,
+      buildSpecification: null,
+      evidenceHashes: sourceRefs.map((source) => source.sourceHash),
+      tasksetSdkVersion: "draft-v1",
+      sourceCommit: null,
+      repairHistory: [],
+      createdAt: timestamp
+    },
+    readiness: null,
+    contentHash: "00000000",
+    createdAt: revision === 1 ? draft.createdAt : timestamp,
+    updatedAt: timestamp,
+    metadata: {
+      ...draft.metadata,
+      ...preparedSource ? { modelTasksetAuthoring: preparedSource.lineage } : {},
+      tasksetReviewPolicy: draft.review,
+      tasksetOutputContract: draft.output,
+      ...input.sourcePackageHash ? { sourcePackageHash: input.sourcePackageHash } : {},
+      ...authoredMethod ? { trainingMethod: authoredMethod } : {},
+      diagnosis: {
+        schemaVersion: "openpond.capabilityDiagnosis.v1",
+        summary: draft.objective,
+        stableBehavior: [draft.objective],
+        changingKnowledge: [],
+        requiredContext: [],
+        requiredTools: draft.environment.toolNames,
+        intervention: authoredMethod === "dpo" ? "preference" : authoredMethod === "grpo" || authoredMethod === "ppo" ? "grpo_rft" : authoredMethod === "sft" ? "sft" : "no_training",
+        trainingEligible: authoredMethod !== null,
+        rationale: authoredMethod ? [`The author selected ${authoredMethod.toUpperCase()} compatibility.`] : ["The Taskset is currently configured for evaluation only."],
+        confidence: 1
+      }
+    }
+  });
+  const hashed = TasksetSchema.parse({
+    ...taskset,
+    contentHash: computeTasksetHash(taskset)
+  });
+  const report = validateTaskset(hashed);
+  const validationErrors = report.issues.filter((issue) => issue.severity === "error");
+  if (validationErrors.length) {
+    throw new TasksetDraftPublishError(validationErrors.map((issue) => ({
+      code: issue.code,
+      message: issue.message,
+      path: issue.path
+    })));
+  }
+  return hashed;
+}
+function generatedDraftSource(draft, tasksetId, timestamp) {
+  const generatorHash = contentHash({
+    draftId: draft.id,
+    draftRevision: draft.revision,
+    tasks: draft.tasks
+  });
+  return {
+    schemaVersion: "openpond.generatedDatasetSource.v1",
+    kind: "generated",
+    id: `source-${tasksetId}`,
+    profileId: draft.profileId,
+    title: `${draft.name} manual authoring`,
+    sourceHash: generatorHash,
+    occurredAt: timestamp,
+    licensingStatus: "approved",
+    secretScanStatus: "passed",
+    piiScanStatus: "passed",
+    generatorId: "openpond-taskset-draft",
+    generatorVersion: "1",
+    seed: 0,
+    generatorHash,
+    metadata: { draftId: draft.id, draftRevision: draft.revision }
+  };
+}
+function buildIntentForDraft(draft) {
+  if (draft.learningSignals.preferences.length) return "preferences";
+  if (draft.learningSignals.rewards.length) return "verifiable_reward";
+  if (draft.learningSignals.labels.length) return "rubric";
+  return "demonstrations";
+}
+function tasksetOutputContract(metadata) {
+  const value = metadata.tasksetOutputContract;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return { mode: "text", jsonSchema: null, renderer: null };
+}
+
+// src/taskset-draft-files.ts
+var MAX_TASKSET_DRAFT_EDIT_FILE_BYTES = 6e6;
+var MANAGED_FILES = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "tasks/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "metrics/policy.json", "assets/manifest.json", "environment/contract.json", "environment/taskset.ts", "rubrics/preference-review.md", "comparisons/policy.json"]);
+function isWritableTasksetDraftFilePath(value) {
+  const path = TasksetDraftFilePathSchema.parse(value);
+  return !MANAGED_FILES.has(path) && !path.startsWith("source-artifacts/");
+}
+function isManagedTasksetDraftFilePath(value) {
+  return MANAGED_FILES.has(TasksetDraftFilePathSchema.parse(value));
+}
+function createTasksetDraftFile(path, bytes) {
+  const writable = isWritableTasksetDraftFilePath(path);
+  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  let content;
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    content = /[\u0000-\u0008\u000e-\u001f]/.test(text) ? base64Content(bytes) : { encoding: "utf8", data: text };
+  } catch {
+    content = base64Content(bytes);
+  }
+  return { path, writable, content, sizeBytes: bytes.byteLength, contentHash: sha256(bytes) };
+}
+function decodeTasksetDraftFileContent(input) {
+  const content = TasksetDraftFileContentSchema.parse(input);
+  let bytes;
+  try {
+    if (content.encoding === "utf8") bytes = new TextEncoder().encode(content.data);
+    else {
+      const raw = atob(content.data);
+      if (btoa(raw) !== content.data) throw new Error("Noncanonical base64");
+      bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+    }
+  } catch {
+    throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  }
+  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  return bytes;
+}
+function base64Content(bytes) {
+  let raw = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  return { encoding: "base64", data: btoa(raw) };
+}
+
+// src/taskset-draft-manifests.ts
+function configuredTasksetDraftFiles(draft) {
+  const configured = [];
+  if (draft.output.renderer) {
+    configured.push({
+      relativePath: draft.output.renderer.module,
+      source: `export async function ${draft.output.renderer.exportName}(output: unknown) {
+  // Return artifact paths or bytes derived from the model's structured output.
+  return output;
+}
+`
+    });
+  }
+  for (const grader of draft.graders) {
+    if (grader.kind !== "custom_verifier") continue;
+    configured.push({
+      relativePath: grader.module,
+      source: `export async function ${grader.exportName}(input: { output: unknown; task: unknown }) {
+  return { passed: false, score: 0, feedback: "Implement this verifier." };
+}
+`
+    });
+  }
+  if (draft.metrics.customAggregator) {
+    configured.push({
+      relativePath: draft.metrics.customAggregator.module,
+      source: `export function ${draft.metrics.customAggregator.exportName}(scores: number[]) {
+  return scores.length ? scores.reduce((sum, score) => sum + score, 0) / scores.length : 0;
+}
+`
+    });
+  }
+  for (const file of configured) TasksetDraftFilePathSchema.parse(file.relativePath);
+  return configured;
+}
+function renderTasksetDraftManifests(input) {
+  const draft = TasksetDraftSchema.parse(input);
+  return /* @__PURE__ */ new Map([
+    ["taskset.json", canonicalJson(draft)],
+    ["tasks/tasks.jsonl", jsonLines(draft.tasks)],
+    ["graders/graders.json", canonicalJson(draft.graders)],
+    ["fixtures/grader-fixtures.json", canonicalJson(draft.graderFixtures)],
+    ["metrics/policy.json", canonicalJson(draft.metrics)],
+    ["assets/manifest.json", canonicalJson(draft.tasks.flatMap((task) => task.assets ?? []))],
+    ["environment/contract.json", canonicalJson(draft.environment)],
+    ["rubrics/preference-review.md", rubricMarkdown(draft)],
+    ["comparisons/policy.json", canonicalJson(draft.review)]
+  ]);
+}
+function rubricMarkdown(draft) {
+  const criteria = draft.review.criteria.length ? `
+
+## Criteria
+
+${draft.review.criteria.map(
+    (criterion) => `- **${criterion.label}** (${criterion.weight}): ${criterion.description}`
+  ).join("\n")}` : "";
+  return `# Preference review rubric
+
+${draft.review.rubric}${criteria}
+`;
+}
+function jsonLines(values) {
+  return values.length ? `${values.map((value) => JSON.stringify(value)).join("\n")}
+` : "";
+}
+
+// src/taskset-draft-workspace.ts
+import { z as z11 } from "zod";
+import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
+var MAX_TASKSET_DRAFT_WORKSPACE_BYTES = 64 * 1024 * 1024;
+var HashSchema7 = z11.string().regex(/^[a-f0-9]{64}$/);
+var TasksetDraftWorkspaceFileSchema = z11.object({
+  path: TasksetDraftFilePathSchema,
+  contentHash: HashSchema7,
+  sizeBytes: z11.number().int().nonnegative().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES),
+  base64: z11.string().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES)
+}).strict();
+var WorkspaceContentSchema = z11.object({
+  schemaVersion: z11.literal("openpond.tasksetDraftWorkspace.v1"),
+  draft: TasksetDraftSchema,
+  files: z11.array(TasksetDraftWorkspaceFileSchema).max(1e4)
+}).strict();
+var TasksetDraftWorkspaceSchema = WorkspaceContentSchema.extend({ contentHash: HashSchema7 }).strict();
+function createTasksetDraftWorkspace(input) {
+  assertBoundedTaskJson2(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
+  const content = WorkspaceContentSchema.parse(input);
+  content.files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+  return validateTasksetDraftWorkspace({ ...content, contentHash: contentHash(content) });
+}
+function validateTasksetDraftWorkspace(input) {
+  assertBoundedTaskJson2(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
+  const workspace = TasksetDraftWorkspaceSchema.parse(input);
+  const { contentHash: expectedHash, ...content } = workspace;
+  if (contentHash(content) !== expectedHash) throw new Error("Taskset draft workspace differs from its retained bytes.");
+  let previousPath = null;
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of workspace.files) {
+    if (isManagedTasksetDraftFilePath(file.path)) throw new Error("Managed Taskset files are represented by the draft document.");
+    if (previousPath !== null && previousPath >= file.path) throw new Error("Taskset draft file paths must be unique and sorted.");
+    const segments = file.path.split("/");
+    for (let end = 1; end < segments.length; end++) if (paths.has(segments.slice(0, end).join("/"))) throw new Error("A Taskset draft file occupies another file's directory.");
+    decodeTasksetDraftWorkspaceFile(file);
+    paths.add(file.path);
+    previousPath = file.path;
+  }
+  return workspace;
+}
+function readTasksetDraftWorkspaceFile(input, path) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  TasksetDraftFilePathSchema.parse(path);
+  const file = workspace.files.find((candidate) => candidate.path === path);
+  const manifest = isManagedTasksetDraftFilePath(path) ? renderTasksetDraftManifests(workspace.draft).get(path) : void 0;
+  if (!file && manifest === void 0) throw new Error("Taskset draft file does not exist.");
+  const result = createTasksetDraftFile(path, file ? decodeTasksetDraftWorkspaceFile(file) : new TextEncoder().encode(manifest));
+  return { draftRevision: workspace.draft.revision, file: { ...result, writable: result.writable && workspace.draft.status !== "published" } };
+}
+function listTasksetDraftWorkspaceFiles(input) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  const files = workspace.files.map((file) => ({
+    path: file.path,
+    sizeBytes: file.sizeBytes,
+    writable: workspace.draft.status !== "published" && isWritableTasksetDraftFilePath(file.path)
+  }));
+  for (const [path, content] of renderTasksetDraftManifests(workspace.draft)) files.push({ path, sizeBytes: new TextEncoder().encode(content).byteLength, writable: false });
+  return { draftRevision: workspace.draft.revision, files: files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0) };
+}
+function saveTasksetDraftWorkspaceDocument(input) {
+  const workspace = editableWorkspace(input.workspace, input.expectedDraftRevision);
+  const draft = TasksetDraftSchema.parse(input.draft);
+  const current = workspace.draft;
+  if (draft.id !== current.id || draft.profileId !== current.profileId || contentHash(draft.modelScope) !== contentHash(current.modelScope)) throw new Error("Taskset draft Model ownership cannot change.");
+  if (draft.revision !== current.revision || draft.status !== current.status || draft.createdAt !== current.createdAt || contentHash(draft.publishedTasksetRef) !== contentHash(current.publishedTasksetRef)) throw new Error("Taskset draft lifecycle fields cannot change through form edits.");
+  const files = [...workspace.files];
+  for (const configured of configuredTasksetDraftFiles(draft)) if (!files.some((file) => file.path === configured.relativePath)) {
+    const bytes = new TextEncoder().encode(configured.source);
+    files.push({ path: configured.relativePath, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
+  }
+  const aggregator = draft.metrics.customAggregator;
+  const module = aggregator ? files.find((file) => file.path === aggregator.module) : void 0;
+  return createTasksetDraftWorkspace({
+    schemaVersion: workspace.schemaVersion,
+    files,
+    draft: {
+      ...draft,
+      revision: current.revision + 1,
+      status: "draft",
+      updatedAt: input.now,
+      ...aggregator && module ? { metrics: { ...draft.metrics, customAggregator: { ...aggregator, contentHash: module.contentHash } } } : {}
+    }
+  });
+}
+function saveTasksetDraftWorkspaceFile(input) {
+  const mutation = TasksetDraftFileMutationSchema.parse(input.mutation);
+  const workspace = editableWorkspace(input.workspace, mutation.expectedDraftRevision);
+  if (workspace.draft.id !== mutation.draftId) throw new Error("Taskset draft file belongs to another draft.");
+  if (!isWritableTasksetDraftFilePath(mutation.path)) throw new Error("This file is managed by the Taskset forms or retained source history.");
+  const previous = workspace.files.find((file) => file.path === mutation.path);
+  if ((previous?.contentHash ?? null) !== mutation.expectedFileHash) throw new Error("Taskset draft file changed. Reload it before saving.");
+  if (!previous && mutation.content === null) throw new Error("Taskset draft file does not exist.");
+  const files = workspace.files.filter((file) => file.path !== mutation.path);
+  if (mutation.content !== null) {
+    const bytes = decodeTasksetDraftFileContent(mutation.content);
+    files.push({ path: mutation.path, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
+  }
+  return createTasksetDraftWorkspace({
+    schemaVersion: workspace.schemaVersion,
+    files,
+    draft: { ...workspace.draft, revision: workspace.draft.revision + 1, status: "draft", updatedAt: input.now }
+  });
+}
+function editableWorkspace(input, expectedRevision) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  if (workspace.draft.status === "published") throw new Error("Published Taskset drafts are immutable.");
+  if (workspace.draft.revision !== expectedRevision) throw new Error("Taskset draft changed. Reload before saving.");
+  return workspace;
+}
+function decodeTasksetDraftWorkspaceFile(input) {
+  const file = TasksetDraftWorkspaceFileSchema.parse(input);
+  let raw;
+  try {
+    raw = atob(file.base64);
+  } catch {
+    throw new Error("Taskset draft file contains invalid base64.");
+  }
+  if (btoa(raw) !== file.base64) throw new Error("Taskset draft file contains noncanonical base64.");
+  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+  if (bytes.byteLength !== file.sizeBytes || sha256(bytes) !== file.contentHash) throw new Error("Taskset draft file differs from its retained bytes.");
+  return bytes;
+}
+function base64(bytes) {
+  let raw = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  return btoa(raw);
+}
+
+export {
+  TasksetPackageLearningResourcesSchema,
+  learningPackageContextFiles,
+  validateTasksetLearningResources,
+  modelAuthoredTasksetId,
+  assertModelTasksetAuthoring,
+  MAX_TASKSET_PACKAGE_BYTES,
+  TasksetPackageFileSchema,
+  decodeTasksetPackageFile,
+  resolveTasksetPackageExecution,
+  createTasksetPackageExecutionFile,
+  TasksetPackageContentSchema,
+  TasksetPackageSchema,
+  tasksetPackageRewardBinding,
+  resolveTasksetPackageInstructions,
+  validateTasksetPackage,
+  createTasksetPackage,
+  TasksetPackageModelConfigurationSchema,
+  TasksetPackagePublicationSchema,
+  TasksetPackageReceiptSchema,
+  TasksetPackageReadbackSchema,
+  OpenPondTasksetPackageError,
+  OpenPondTasksetPackageClient,
+  DatasetSplitSchema,
+  DatasetSemanticFieldSchema,
+  DatasetSemanticSchemaSchema,
+  DatasetShardRefSchema,
+  DatasetArtifactManifestSchema,
+  DatasetArtifactSummarySchema,
+  DatasetCatalogItemSchema,
+  DatasetCatalogResponseSchema,
+  DatasetArtifactRegistryEntrySchema,
+  DatasetRowPageRequestSchema,
+  DatasetRowPageSchema,
+  DatasetStorageSettingsSchema,
+  DatasetStorageRootSchema,
+  DatasetStorageStateSchema,
+  UpdateDatasetStorageSettingsRequestSchema,
+  DatasetSourceReviewStatusSchema,
+  HuggingFaceDatasetSourceRefSchema,
+  UploadedFileDatasetSourceRefSchema,
+  GeneratedDatasetSourceRefSchema,
+  LearningBatchDatasetSourceRefSchema,
+  ExternalDatasetSourceRefSchema,
+  HarnessActionBindingSchema,
+  TasksetSplitSchema,
+  TasksetPurposeSchema,
+  TasksetBenchmarkBindingSchema,
+  TasksetPreferenceComparisonBindingSchema,
+  TrainingSourceConsentSchema,
+  TrainingSourceRefSchema,
+  TasksetSourceRefSchema,
+  TaskPolicyBoundarySchema,
+  TaskAssetRefSchema,
+  TaskRequiredOutputSchema,
+  TaskDataRecordSchema,
+  TasksetEnvironmentResourceSchema,
+  DemonstrationSignalSchema,
+  PreferenceSignalSchema,
+  CorrectionSignalSchema,
+  FeedbackSignalSchema,
+  RewardSignalSchema,
+  LabelSignalSchema,
+  LearningSignalRefSchema,
+  LearningSignalInventorySchema,
+  TasksetEnvironmentContractSchema,
+  TasksetCapabilityManifestSchema,
+  DeterministicGraderSpecSchema,
+  RubricGraderSpecSchema,
+  HumanGraderSpecSchema,
+  CustomVerifierGraderSpecSchema,
+  GraderSpecSchema,
+  GraderFixtureLabelSchema,
+  GraderFixtureSchema,
+  TASKSET_WORK_TOOL_NAMES,
+  TasksetStatusSchema,
+  DatasetBuildIntentSchema,
+  DatasetBuildSpecificationSchema,
+  GeneratedTaskFileSchema,
+  TrainingPathRecommendationSchema,
+  TrainingMethodReadinessReasonCodeSchema,
+  TrainingMethodReadinessSchema,
+  TasksetReadinessFindingSchema,
+  TasksetReadinessReportSchema,
+  AuthoringRepairSchema,
+  AuthoringProvenanceSchema,
+  TasksetSchema,
+  isTrainingSourceRef,
+  validateTaskset,
+  computeTasksetHash,
+  validatePortability,
+  TaskDataDraftSchema,
+  TasksetDraftStatusSchema,
+  TasksetDraftReviewPolicySchema,
+  TasksetDraftOutputContractSchema,
+  TasksetDraftSchema,
+  TasksetDraftPublishError,
+  createTasksetDraft,
+  draftPublishIssues,
+  tasksetDraftFromTaskset,
+  publishTasksetDraft,
+  MAX_TASKSET_DRAFT_EDIT_FILE_BYTES,
+  isWritableTasksetDraftFilePath,
+  isManagedTasksetDraftFilePath,
+  createTasksetDraftFile,
+  decodeTasksetDraftFileContent,
+  configuredTasksetDraftFiles,
+  renderTasksetDraftManifests,
+  MAX_TASKSET_DRAFT_WORKSPACE_BYTES,
+  TasksetDraftWorkspaceFileSchema,
+  TasksetDraftWorkspaceSchema,
+  createTasksetDraftWorkspace,
+  validateTasksetDraftWorkspace,
+  readTasksetDraftWorkspaceFile,
+  listTasksetDraftWorkspaceFiles,
+  saveTasksetDraftWorkspaceDocument,
+  saveTasksetDraftWorkspaceFile,
+  decodeTasksetDraftWorkspaceFile
+};
+//# sourceMappingURL=chunk-AZUCY3E5.js.map