openpond-sdk 0.10.0 → 0.11.2

package/dist/chunk-LGEF4S5I.js

@@ -1,1229 +0,0 @@
-import {
-  ChatModelRefSchema
-} from "./chunk-Y4NGWGTA.js";
-import {
-  ImmutableReleaseRefSchema,
-  ReleaseHashSchema,
-  ReleaseIdSchema,
-  VersionedReleaseRefSchema,
-  contentHash
-} from "./chunk-QUOW6URQ.js";
-
-// src/taskset-draft-dataset-artifacts.ts
-import { z } from "zod";
-var IdSchema = z.string().trim().min(1).max(240);
-var TimestampSchema = z.string().trim().min(1);
-var HashSchema = z.string().trim().min(8).max(256);
-var RelativePathSchema = z.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 = z.enum([
-  "train",
-  "validation",
-  "test",
-  "frozen_eval"
-]);
-var DatasetSemanticFieldSchema = z.object({
-  name: z.string().trim().min(1).max(500),
-  semanticRole: z.enum([
-    "row_id",
-    "cluster_id",
-    "prompt",
-    "messages",
-    "demonstration",
-    "chosen",
-    "rejected",
-    "expected_output",
-    "privileged_context",
-    "reward",
-    "feedback",
-    "tag",
-    "metadata"
-  ]),
-  logicalType: z.enum([
-    "string",
-    "integer",
-    "float",
-    "boolean",
-    "json",
-    "messages"
-  ]),
-  nullable: z.boolean(),
-  policy: z.enum(["visible", "privileged", "metadata"])
-});
-var DatasetSemanticSchemaSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetSemanticSchema.v1"),
-  fields: z.array(DatasetSemanticFieldSchema).min(1).max(1e4),
-  schemaHash: HashSchema
-});
-var DatasetShardRefSchema = z.object({
-  id: IdSchema,
-  split: DatasetSplitSchema,
-  path: RelativePathSchema,
-  contentHash: HashSchema,
-  schemaHash: HashSchema,
-  sizeBytes: z.number().int().nonnegative(),
-  rowCount: z.number().int().positive(),
-  rowGroupCount: z.number().int().positive()
-});
-var DatasetArtifactManifestSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifact.v1"),
-  id: IdSchema,
-  tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
-  contentHash: HashSchema,
-  format: z.literal("parquet"),
-  schema: DatasetSemanticSchemaSchema,
-  shards: z.array(DatasetShardRefSchema).min(1).max(1e5),
-  rowCount: z.number().int().positive(),
-  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
-  sourceReceiptRefs: z.array(IdSchema).min(1).max(1e5),
-  mappingHash: HashSchema,
-  qualityReportHash: HashSchema,
-  createdAt: TimestampSchema
-});
-var DatasetArtifactSummarySchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifactSummary.v1"),
-  artifactId: IdSchema,
-  tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
-  format: z.literal("parquet"),
-  rowCount: z.number().int().positive(),
-  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
-  sizeBytes: z.number().int().nonnegative(),
-  contentHash: HashSchema,
-  available: z.boolean(),
-  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
-  createdAt: TimestampSchema
-});
-var DatasetCatalogItemSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetCatalogItem.v1"),
-  tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
-  artifactId: IdSchema.nullable(),
-  name: z.string().trim().min(1).max(500),
-  status: z.enum([
-    "draft",
-    "awaiting_disclosure_approval",
-    "awaiting_materialization_approval",
-    "materializing",
-    "validating",
-    "needs_review",
-    "baselining",
-    "ready",
-    "blocked",
-    "failed",
-    "archived"
-  ]),
-  storageKind: z.enum(["inline", "parquet"]),
-  rowCount: z.number().int().nonnegative(),
-  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
-  sizeBytes: z.number().int().nonnegative().nullable(),
-  available: z.boolean(),
-  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-});
-var DatasetCatalogResponseSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetCatalog.v1"),
-  profileId: IdSchema,
-  datasets: z.array(DatasetCatalogItemSchema),
-  generatedAt: TimestampSchema
-});
-var DatasetArtifactRegistryEntrySchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifactRegistry.v1"),
-  manifest: DatasetArtifactManifestSchema,
-  profileId: IdSchema,
-  storageRoot: z.string().trim().min(1).max(4e3),
-  relativeManifestPath: RelativePathSchema,
-  available: z.boolean(),
-  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
-  verifiedAt: TimestampSchema.nullable(),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-});
-var DatasetRowPageRequestSchema = z.object({
-  split: DatasetSplitSchema.nullable().default(null),
-  cursor: z.string().trim().min(1).max(2e3).nullable().default(null),
-  limit: z.number().int().min(1).max(100).default(25),
-  columns: z.array(z.string().trim().min(1).max(500)).max(100).default([])
-});
-var DatasetRowPageSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetRowPage.v1"),
-  tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
-  artifactHash: HashSchema,
-  split: DatasetSplitSchema.nullable(),
-  rows: z.array(z.record(z.string(), z.unknown())).max(100),
-  nextCursor: z.string().max(2e3).nullable(),
-  totalRows: z.number().int().nonnegative(),
-  returnedRows: z.number().int().nonnegative()
-});
-var DatasetStorageSettingsSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetStorageSettings.v1"),
-  datasetStorePath: z.string().trim().min(1).max(4e3),
-  updatedAt: TimestampSchema
-});
-var DatasetStorageRootSchema = z.object({
-  id: IdSchema,
-  label: z.string().trim().min(1).max(500),
-  path: z.string().trim().min(1).max(4e3),
-  datasetStorePath: z.string().trim().min(1).max(4e3),
-  kind: z.enum(["local", "network", "removable", "cache"]),
-  configured: z.boolean(),
-  mounted: z.boolean(),
-  writable: z.boolean(),
-  totalBytes: z.number().int().nonnegative().nullable(),
-  freeBytes: z.number().int().nonnegative().nullable()
-});
-var DatasetStorageStateSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetStorageState.v1"),
-  settings: DatasetStorageSettingsSchema,
-  storageRoots: z.array(DatasetStorageRootSchema)
-});
-var UpdateDatasetStorageSettingsRequestSchema = z.object({
-  datasetStorePath: z.string().trim().min(1).max(4e3)
-});
-
-// src/taskset-draft-dataset-sources.ts
-import { z as z2 } from "zod";
-var IdSchema2 = z2.string().trim().min(1).max(240);
-var TimestampSchema2 = z2.string().trim().min(1);
-var HashSchema2 = z2.string().trim().min(8).max(256);
-var MetadataSchema = z2.record(z2.string(), z2.unknown()).default({});
-var RevisionSchema = z2.string().trim().min(7).max(256);
-var DatasetSourceReviewStatusSchema = z2.enum([
-  "pending",
-  "approved",
-  "review",
-  "blocked"
-]);
-var ExternalDatasetSourceBaseSchema = z2.object({
-  id: IdSchema2,
-  profileId: IdSchema2,
-  title: z2.string().trim().min(1).max(500),
-  sourceHash: HashSchema2,
-  occurredAt: TimestampSchema2,
-  licensingStatus: DatasetSourceReviewStatusSchema,
-  secretScanStatus: z2.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z2.enum(["pending", "passed", "review", "blocked"]),
-  metadata: MetadataSchema
-});
-var HuggingFaceDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z2.literal("openpond.huggingFaceDatasetSource.v1"),
-  kind: z2.literal("huggingface"),
-  repositoryId: z2.string().trim().regex(/^[^/\s]+\/[^/\s]+$/).max(500),
-  repositoryUrl: z2.string().url().max(2e3),
-  revision: RevisionSchema,
-  configuration: z2.string().trim().min(1).max(500),
-  upstreamSplits: z2.array(z2.string().trim().min(1).max(500)).min(1).max(1e3),
-  gated: z2.boolean(),
-  private: z2.boolean(),
-  declaredLicense: z2.string().trim().min(1).max(500).nullable(),
-  sourceFileHashes: z2.array(HashSchema2).min(1).max(1e5)
-});
-var UploadedFileDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z2.literal("openpond.uploadedFileDatasetSource.v1"),
-  kind: z2.literal("uploaded_file"),
-  originalFileNames: z2.array(z2.string().trim().min(1).max(500)).min(1).max(1e3),
-  mediaTypes: z2.array(z2.string().trim().min(1).max(200)).min(1).max(1e3),
-  sourceFileHashes: z2.array(HashSchema2).min(1).max(1e3),
-  totalBytes: z2.number().int().nonnegative(),
-  parserVersion: z2.string().trim().min(1).max(200)
-});
-var GeneratedDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z2.literal("openpond.generatedDatasetSource.v1"),
-  kind: z2.literal("generated"),
-  generatorId: IdSchema2,
-  generatorVersion: z2.string().trim().min(1).max(200),
-  seed: z2.number().int(),
-  generatorHash: HashSchema2
-});
-var LearningBatchDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z2.literal("openpond.learningBatchDatasetSource.v1"),
-  kind: z2.literal("learning_batch"),
-  batch: z2.object({ id: IdSchema2, revision: z2.number().int().positive(), contentHash: HashSchema2 }).strict(),
-  taskDefinition: z2.object({ id: IdSchema2, revision: z2.number().int().positive(), contentHash: HashSchema2 }).strict(),
-  admittedBy: IdSchema2
-});
-var ExternalDatasetSourceRefSchema = z2.discriminatedUnion("kind", [
-  HuggingFaceDatasetSourceRefSchema,
-  UploadedFileDatasetSourceRefSchema,
-  GeneratedDatasetSourceRefSchema,
-  LearningBatchDatasetSourceRefSchema
-]);
-
-// src/taskset-draft-harness-actions.ts
-import { z as z3 } from "zod";
-var HarnessActionBindingSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessActionBinding.v1"),
-  actionId: ReleaseIdSchema,
-  modelToolName: z3.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-  description: z3.string().trim().min(1).max(1e3),
-  inputSchema: z3.record(z3.string(), z3.unknown()),
-  actionSchemaHash: ReleaseHashSchema,
-  agentRelease: ImmutableReleaseRefSchema,
-  implementationHash: ReleaseHashSchema,
-  runtimeBindingId: ReleaseIdSchema,
-  capabilityReceiptHash: ReleaseHashSchema,
-  sideEffect: z3.enum(["read", "write"]),
-  studentVisible: z3.boolean(),
-  timeoutMs: z3.number().int().positive().max(36e5),
-  episodeArgumentBindings: z3.array(
-    z3.object({
-      argument: ReleaseIdSchema,
-      source: z3.literal("case_id")
-    }).strict()
-  ).max(20).default([])
-}).strict();
-
-// src/taskset-draft-core.ts
-import { z as z4 } from "zod";
-import { CustomVerifierRuntimeSchema } from "@openpond/evals/tasksets";
-var IdSchema3 = z4.string().trim().min(1).max(240);
-var TimestampSchema3 = z4.string().trim().min(1);
-var HashSchema3 = z4.string().trim().min(8).max(256);
-var Sha256Schema = z4.string().trim().regex(/^[a-f0-9]{64}$/);
-var CodeIdentifierSchema = z4.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
-var MetadataSchema2 = z4.record(z4.string(), z4.unknown()).default({});
-var NullableIdSchema = IdSchema3.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 = z4.enum(["general", "benchmark"]);
-var TasksetBenchmarkBindingSchema = z4.object({
-  schemaVersion: z4.literal("openpond.tasksetBenchmark.v1"),
-  definitionId: IdSchema3,
-  releaseId: IdSchema3,
-  releaseHash: Sha256Schema,
-  managedReleasePath: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
-  adaptationSplit: TasksetSplitSchema,
-  evaluationSplit: TasksetSplitSchema,
-  primaryMetric: z4.enum([
-    "foreground_tokens",
-    "success_rate",
-    "latency_ms",
-    "cost_usd"
-  ]),
-  qualityGate: z4.enum(["none", "non_regression", "all_pass"]),
-  source: z4.enum(["builtin", "imported"]),
-  metadata: MetadataSchema2
-});
-var TasksetPreferenceComparisonBindingSchema = z4.object({
-  schemaVersion: z4.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
-  releaseId: IdSchema3,
-  releaseHash: Sha256Schema,
-  publishedAt: TimestampSchema3,
-  metadata: MetadataSchema2
-});
-var TrainingSourceConsentSchema = z4.object({
-  status: z4.enum(["pending", "granted", "denied", "revoked"]),
-  scope: z4.enum(["metadata_only", "selected_turns", "full_session"]),
-  grantedBy: NullableIdSchema,
-  grantedAt: TimestampSchema3.nullable(),
-  purpose: z4.literal("task_authoring_and_evaluation")
-});
-var TrainingSourceRefSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingSource.v1"),
-  id: IdSchema3,
-  profileId: IdSchema3,
-  sessionId: IdSchema3,
-  turnIds: z4.array(IdSchema3).max(1e3).default([]),
-  workspaceId: NullableIdSchema,
-  sourceHash: HashSchema3,
-  clusterKey: IdSchema3,
-  title: z4.string().trim().min(1).max(500),
-  occurredAt: TimestampSchema3,
-  consent: TrainingSourceConsentSchema,
-  connectedAppIds: z4.array(IdSchema3).max(100).default([]),
-  secretScanStatus: z4.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z4.enum(["pending", "passed", "review", "blocked"]),
-  licensingStatus: z4.enum(["pending", "approved", "review", "blocked"]),
-  metadata: MetadataSchema2
-});
-var TasksetSourceRefSchema = z4.union([
-  TrainingSourceRefSchema,
-  ExternalDatasetSourceRefSchema
-]);
-var TaskPolicyBoundarySchema = z4.object({
-  policyVisibleFields: z4.array(IdSchema3).max(1e3).default([]),
-  privilegedFields: z4.array(IdSchema3).max(1e3).default([]),
-  hiddenGraderRefs: z4.array(IdSchema3).max(100).default([]),
-  connectedAppScopes: z4.array(IdSchema3).max(100).default([])
-});
-var TaskAssetRefSchema = z4.object({
-  id: IdSchema3,
-  sourceRefId: IdSchema3,
-  artifactRef: z4.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
-  fileName: z4.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
-  mediaType: z4.string().trim().min(1).max(200),
-  sha256: Sha256Schema,
-  sizeBytes: z4.number().int().nonnegative().max(25e7),
-  split: TasksetSplitSchema,
-  metadata: MetadataSchema2
-});
-var TaskRequiredOutputSchema = z4.object({
-  path: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
-  mediaType: z4.string().trim().min(1).max(200),
-  schemaRef: IdSchema3.nullable().optional(),
-  maxBytes: z4.number().int().positive().max(1e7).optional(),
-  metadata: MetadataSchema2
-});
-var TaskDataRecordSchema = z4.object({
-  schemaVersion: z4.literal("openpond.taskData.v1"),
-  id: IdSchema3,
-  clusterKey: IdSchema3,
-  split: TasksetSplitSchema,
-  input: z4.record(z4.string(), z4.unknown()),
-  expectedOutput: z4.record(z4.string(), z4.unknown()).nullable(),
-  policyVisibleContext: z4.record(z4.string(), z4.unknown()).default({}),
-  privilegedContextRef: NullableIdSchema,
-  sourceRefs: z4.array(IdSchema3).min(1).max(100),
-  assets: z4.array(TaskAssetRefSchema).max(1e3).optional(),
-  resourceRefs: z4.array(IdSchema3).max(1e3).optional(),
-  requiredOutputs: z4.array(TaskRequiredOutputSchema).max(100).optional(),
-  tags: z4.array(IdSchema3).max(100).default([]),
-  metadata: MetadataSchema2
-});
-var TasksetEnvironmentResourceSchema = z4.object({
-  id: IdSchema3,
-  kind: z4.enum(["file", "catalog", "configuration", "code_module"]),
-  path: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
-  mediaType: z4.string().trim().min(1).max(200).nullable().optional(),
-  visibility: z4.enum(["policy_visible", "policy_hidden", "privileged"]),
-  required: z4.boolean(),
-  metadata: MetadataSchema2
-});
-var LearningSignalBaseSchema = z4.object({
-  id: IdSchema3,
-  taskId: NullableIdSchema,
-  sourceRefs: z4.array(IdSchema3).min(1).max(100),
-  artifactRef: IdSchema3,
-  approved: z4.boolean(),
-  confidence: z4.number().min(0).max(1),
-  metadata: MetadataSchema2
-});
-var DemonstrationSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("demonstration"),
-  prompt: z4.string().max(1e5).nullable().default(null),
-  response: z4.string().max(2e5).nullable().default(null)
-});
-var PreferenceSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("preference"),
-  prompt: z4.string().max(1e5),
-  chosen: z4.string().max(2e5),
-  rejected: z4.string().max(2e5),
-  rationale: z4.string().max(1e5).nullable().default(null)
-});
-var CorrectionSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("correction"),
-  original: z4.string().max(2e5),
-  corrected: z4.string().max(2e5),
-  rationale: z4.string().max(1e5).nullable().default(null)
-});
-var FeedbackSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("feedback"),
-  feedback: z4.string().max(1e5),
-  polarity: z4.enum(["positive", "negative", "mixed", "neutral"])
-});
-var RewardSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("reward"),
-  task: z4.string().max(1e5),
-  rules: z4.array(z4.object({
-    id: IdSchema3,
-    points: z4.number().finite(),
-    condition: z4.string().trim().min(1).max(1e5)
-  })).min(1).max(1e3),
-  otherwisePoints: z4.number().finite(),
-  executable: z4.boolean()
-});
-var LabelSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("label"),
-  labelKind: z4.literal("rubric"),
-  task: z4.string().max(1e5),
-  criteria: z4.array(z4.object({
-    id: IdSchema3,
-    label: z4.string().trim().min(1).max(500),
-    description: z4.string().trim().min(1).max(1e5)
-  })).min(1).max(1e3),
-  calibrationExamples: z4.object({
-    positive: z4.string().trim().min(1).max(2e5),
-    negative: z4.string().trim().min(1).max(2e5),
-    boundary: z4.string().trim().min(1).max(2e5)
-  })
-});
-var LearningSignalRefSchema = z4.discriminatedUnion("kind", [
-  DemonstrationSignalSchema,
-  PreferenceSignalSchema,
-  CorrectionSignalSchema,
-  FeedbackSignalSchema,
-  RewardSignalSchema,
-  LabelSignalSchema
-]);
-var LearningSignalInventorySchema = z4.object({
-  demonstrations: z4.array(DemonstrationSignalSchema).max(1e5).default([]),
-  preferences: z4.array(PreferenceSignalSchema).max(1e5).default([]),
-  corrections: z4.array(CorrectionSignalSchema).max(1e5).default([]),
-  feedback: z4.array(FeedbackSignalSchema).max(1e5).default([]),
-  rewards: z4.array(RewardSignalSchema).max(1e5).default([]),
-  labels: z4.array(LabelSignalSchema).max(1e5).default([])
-});
-var TasksetEnvironmentContractSchema = z4.object({
-  protocolVersion: z4.literal("openpond.taskEnvironment.v1"),
-  kind: z4.enum(["chat", "agent", "program", "stateful_harness", "work"]),
-  entrypoint: z4.string().trim().min(1).max(1e3),
-  stateful: z4.boolean(),
-  deterministicSeeds: z4.boolean(),
-  toolNames: z4.array(IdSchema3).max(200).default([]),
-  actionBindings: z4.array(HarnessActionBindingSchema).max(200).optional(),
-  lifecycle: z4.array(z4.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
-  defaultTimeoutMs: z4.number().int().positive().max(36e5),
-  networkPolicy: z4.enum(["none", "declared_read_only", "declared_scoped"]),
-  resources: z4.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
-  metadata: MetadataSchema2
-});
-var TasksetCapabilityManifestSchema = z4.object({
-  schemaVersion: z4.literal("openpond.tasksetCapabilities.v1"),
-  taskKind: z4.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
-  supportedSignals: z4.array(z4.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
-  compatibleMethods: z4.array(z4.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
-  rewardKinds: z4.array(z4.enum(["none", "exact", "deterministic", "model_judge", "human"])),
-  requiresTools: z4.boolean(),
-  requiresState: z4.boolean(),
-  requiresPrivilegedGrading: z4.boolean(),
-  environmentPlacements: z4.array(z4.enum(["local", "remote", "colocated", "provider_native"])),
-  exportable: z4.boolean(),
-  portabilityBlockers: z4.array(z4.string().trim().min(1).max(2e3)).default([])
-});
-var GraderBaseSchema = z4.object({
-  id: IdSchema3,
-  version: z4.string().trim().min(1).max(100),
-  label: z4.string().trim().min(1).max(500),
-  weight: z4.number().min(0).max(1e3).default(1),
-  hardGate: z4.boolean().default(false),
-  rewardEligible: z4.boolean().default(false),
-  privileged: z4.boolean().default(false),
-  metadata: MetadataSchema2
-});
-var DeterministicGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
-  config: z4.record(z4.string(), z4.unknown())
-});
-var RubricGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.literal("model_judge"),
-  rubric: z4.string().trim().min(1).max(5e4),
-  judge: ChatModelRefSchema,
-  calibrationFixtureRefs: z4.array(IdSchema3).min(1).max(500),
-  calibrationStatus: z4.enum(["pending", "passed", "failed"]),
-  temperature: z4.number().min(0).max(2).default(0)
-});
-var HumanGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.literal("human"),
-  rubric: z4.string().trim().min(1).max(5e4),
-  reviewerRole: z4.string().trim().min(1).max(500)
-});
-var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.literal("custom_verifier"),
-  runtime: CustomVerifierRuntimeSchema.optional(),
-  module: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
-  exportName: CodeIdentifierSchema,
-  timeoutMs: z4.number().int().positive().max(3e5),
-  networkPolicy: z4.literal("none")
-});
-var GraderSpecSchema = z4.union([
-  DeterministicGraderSpecSchema,
-  RubricGraderSpecSchema,
-  HumanGraderSpecSchema,
-  CustomVerifierGraderSpecSchema
-]);
-var GraderFixtureLabelSchema = z4.enum([
-  "positive",
-  "negative",
-  "boundary",
-  "adversarial",
-  "prompt_injection",
-  "infrastructure_failure"
-]);
-var GraderFixtureSchema = z4.object({
-  id: IdSchema3,
-  taskId: IdSchema3,
-  label: GraderFixtureLabelSchema,
-  output: z4.record(z4.string(), z4.unknown()),
-  infrastructureError: z4.string().trim().min(1).max(1e4).nullable(),
-  expectedPassed: z4.boolean(),
-  expectedRewardEligible: z4.boolean(),
-  metadata: MetadataSchema2
-});
-
-// src/taskset-authored-contracts.ts
-import { z as z5 } from "zod";
-import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
-var IdSchema4 = z5.string().trim().min(1).max(240);
-var TimestampSchema4 = z5.string().trim().min(1);
-var HashSchema4 = z5.string().trim().min(8).max(256);
-var MetadataSchema3 = z5.record(z5.string(), z5.unknown()).default({});
-var NullableIdSchema2 = IdSchema4.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 = z5.enum([
-  "draft",
-  "awaiting_disclosure_approval",
-  "awaiting_materialization_approval",
-  "materializing",
-  "validating",
-  "needs_review",
-  "baselining",
-  "ready",
-  "blocked",
-  "failed",
-  "archived"
-]);
-var DatasetBuildIntentSchema = z5.enum([
-  "demonstrations",
-  "preferences",
-  "verifiable_reward",
-  "rubric",
-  "discovery"
-]);
-var DatasetEvidenceTextSchema = z5.string().trim().max(1e5);
-var DatasetBuildSpecificationSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("demonstrations"),
-    behavior: DatasetEvidenceTextSchema,
-    examples: z5.array(z5.object({
-      id: IdSchema4,
-      prompt: DatasetEvidenceTextSchema,
-      response: DatasetEvidenceTextSchema
-    })).max(1e3).default([])
-  }),
-  z5.object({
-    kind: z5.literal("preferences"),
-    preference: DatasetEvidenceTextSchema,
-    pairs: z5.array(z5.object({
-      id: IdSchema4,
-      prompt: DatasetEvidenceTextSchema,
-      chosen: DatasetEvidenceTextSchema,
-      rejected: DatasetEvidenceTextSchema,
-      rationale: DatasetEvidenceTextSchema
-    })).max(1e3).default([])
-  }),
-  z5.object({
-    kind: z5.literal("verifiable_reward"),
-    task: DatasetEvidenceTextSchema,
-    rules: z5.array(z5.object({
-      id: IdSchema4,
-      points: z5.number().finite(),
-      condition: DatasetEvidenceTextSchema
-    })).max(1e3).default([]),
-    otherwisePoints: z5.number().finite().default(0)
-  }),
-  z5.object({
-    kind: z5.literal("rubric"),
-    task: DatasetEvidenceTextSchema,
-    criteria: z5.array(z5.object({
-      id: IdSchema4,
-      label: z5.string().trim().max(500),
-      description: DatasetEvidenceTextSchema
-    })).max(1e3).default([]),
-    positiveExample: DatasetEvidenceTextSchema,
-    negativeExample: DatasetEvidenceTextSchema,
-    boundaryExample: DatasetEvidenceTextSchema
-  })
-]);
-var GeneratedTaskFileSchema = z5.object({
-  path: z5.string().trim().min(1).max(1e3),
-  role: z5.enum(["environment", "verifier", "fixture"]),
-  content: z5.string().max(25e4)
-});
-var TrainingPathRecommendationSchema = z5.object({
-  primaryMethod: z5.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
-  bootstrap: z5.object({
-    method: z5.literal("sft"),
-    purpose: z5.literal("trajectory_bootstrap"),
-    demonstrationRefs: z5.array(IdSchema4).min(1).max(1e5),
-    limitations: z5.array(z5.string().trim().min(1).max(5e3)).min(1).max(100)
-  }).nullable()
-});
-var TrainingMethodReadinessReasonCodeSchema = z5.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 = z5.object({
-  method: z5.enum(["sft", "dpo", "grpo", "ppo"]),
-  status: z5.enum(["recommended", "compatible", "needs_dataset_work"]),
-  reasonCodes: z5.array(TrainingMethodReadinessReasonCodeSchema).default([]),
-  reasons: z5.array(z5.string().trim().min(1).max(5e3)).default([])
-});
-var TasksetReadinessFindingSchema = z5.object({
-  code: IdSchema4,
-  message: z5.string().trim().min(1).max(5e3),
-  path: z5.string().trim().max(2e3).nullable()
-});
-var TasksetReadinessReportSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetReadiness.v1"),
-  tasksetId: IdSchema4,
-  tasksetHash: HashSchema4,
-  ready: z5.boolean(),
-  recommendedMethod: z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
-  trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
-  methodReadiness: z5.array(TrainingMethodReadinessSchema).default([]),
-  compatibleDestinationClasses: z5.array(
-    z5.enum(["export", "custom", "hosted_managed"])
-  ),
-  blockers: z5.array(TasksetReadinessFindingSchema).default([]),
-  advisories: z5.array(TasksetReadinessFindingSchema).default([]),
-  warnings: z5.array(z5.string().trim().min(1).max(5e3)).default([]),
-  generatedAt: TimestampSchema4
-});
-var AuthoringRepairSchema = z5.object({ attempt: z5.number().int().positive(), summary: z5.string().trim().min(1).max(5e3), createdAt: TimestampSchema4 });
-var AuthoringProvenanceSchema = z5.object({
-  schemaVersion: z5.literal("openpond.taskAuthoringProvenance.v1"),
-  model: ChatModelRefSchema.nullable(),
-  modelConfig: MetadataSchema3,
-  skillHash: HashSchema4,
-  promptTemplateVersion: z5.string().trim().min(1).max(200),
-  buildIntent: DatasetBuildIntentSchema.default("demonstrations"),
-  buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),
-  evidenceHashes: z5.array(HashSchema4).max(1e5),
-  tasksetSdkVersion: z5.string().trim().min(1).max(100),
-  sourceCommit: z5.string().trim().min(1).max(256).nullable(),
-  repairHistory: z5.array(AuthoringRepairSchema).max(1e3),
-  createdAt: TimestampSchema4
-});
-var TasksetSchema = z5.object({
-  schemaVersion: z5.literal("openpond.taskset.v1"),
-  id: IdSchema4,
-  revision: z5.number().int().positive().default(1),
-  profileId: IdSchema4,
-  profileRelease: VersionedReleaseRefSchema.nullable().optional(),
-  createImproveRunId: NullableIdSchema2.default(null),
-  name: z5.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: z5.string().trim().max(2e4),
-  purpose: TasksetPurposeSchema.default("general"),
-  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
-  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
-  status: TasksetStatusSchema,
-  sourceRefs: z5.array(TasksetSourceRefSchema).min(1).max(1e5),
-  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
-  policy: TaskPolicyBoundarySchema,
-  environment: TasksetEnvironmentContractSchema,
-  capabilities: TasksetCapabilityManifestSchema,
-  metrics: TasksetMetricPolicySchema.optional(),
-  tasks: z5.array(TaskDataRecordSchema).max(1e6),
-  graders: z5.array(GraderSpecSchema).min(1).max(1e3),
-  // Imported releases are inspectable before local calibration. Admission
-  // requires real fixtures separately in validateTaskset.
-  graderFixtures: z5.array(GraderFixtureSchema).max(1e5),
-  learningSignals: LearningSignalInventorySchema,
-  authoringProvenance: AuthoringProvenanceSchema,
-  readiness: TasksetReadinessReportSchema.nullable(),
-  contentHash: HashSchema4,
-  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, options = {}) {
-  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, options);
-  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, options) {
-  if (!taskset.graderFixtures.length && !(options.allowUnscoredOnlineRewardBatch && taskset.metadata.trainingMethod === "grpo" && taskset.metadata.learning)) {
-    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.lifecycle.includes("reset") || !taskset.environment.lifecycle.includes("cleanup")) {
-    issues.push({
-      code: "work_reset_lifecycle_missing",
-      severity: "error",
-      message: "Work attempts require reset and cleanup; filesystem state belongs to one attempt.",
-      path: "environment.lifecycle"
-    });
-  }
-  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) && !taskset.graders.some((grader) => grader.rewardEligible && grader.weight > 0 && grader.kind !== "human")) {
-    issues.push({ code: "online_reward_not_executable", severity: "error", message: "GRPO/PPO compatibility requires an executable scalar reward.", path: "learningSignals.rewards" });
-  }
-}
-
-export {
-  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
-};
-//# sourceMappingURL=chunk-LGEF4S5I.js.map