openpond-sdk 0.10.0 → 0.11.0

package/dist/{chunk-LGEF4S5I.js → chunk-XJDWHTH5.js}

@@ -1,6 +1,6 @@
 import {
   ChatModelRefSchema
-} from "./chunk-Y4NGWGTA.js";
+} from "./chunk-I2MBVOVX.js";
 import {
   ImmutableReleaseRefSchema,
   ReleaseHashSchema,
@@ -9,24 +9,48 @@ import {
   contentHash
 } from "./chunk-QUOW6URQ.js";
 
-// src/taskset-draft-dataset-artifacts.ts
+// src/connected-dataset-source.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(
+import { ConnectedSourceKindSchema } from "@openpond/evals/connected-evidence";
+var ConnectedDatasetSourceRefSchema = z.object({
+  schemaVersion: z.literal("openpond.connectedDatasetSource.v1"),
+  kind: z.literal("connected_activity"),
+  id: z.string().min(1).max(240),
+  profileId: z.string().min(1).max(240),
+  title: z.string().min(1).max(500),
+  sourceHash: z.string().regex(/^[a-f0-9]{64}$/),
+  occurredAt: z.string().datetime(),
+  licensingStatus: z.enum(["pending", "approved", "review", "blocked"]),
+  secretScanStatus: z.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z.enum(["pending", "passed", "review", "blocked"]),
+  origin: ConnectedSourceKindSchema,
+  sourceId: z.string().min(1).max(500),
+  sessionId: z.string().min(1).max(500),
+  normalizerVersion: z.string().min(1).max(200),
+  projection: z.enum(["turn", "conversation"]),
+  ownerUserId: z.string().min(1).max(500),
+  purpose: z.literal("recorded_evaluation"),
+  metadata: z.record(z.string(), z.unknown()).default({})
+}).strict();
+
+// src/taskset-draft-dataset-artifacts.ts
+import { z as z2 } from "zod";
+var IdSchema = z2.string().trim().min(1).max(240);
+var TimestampSchema = z2.string().trim().min(1);
+var HashSchema = z2.string().trim().min(8).max(256);
+var RelativePathSchema = z2.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([
+var DatasetSplitSchema = z2.enum([
   "train",
   "validation",
   "test",
   "frozen_eval"
 ]);
-var DatasetSemanticFieldSchema = z.object({
-  name: z.string().trim().min(1).max(500),
-  semanticRole: z.enum([
+var DatasetSemanticFieldSchema = z2.object({
+  name: z2.string().trim().min(1).max(500),
+  semanticRole: z2.enum([
     "row_id",
     "cluster_id",
     "prompt",
@@ -41,7 +65,7 @@ var DatasetSemanticFieldSchema = z.object({
     "tag",
     "metadata"
   ]),
-  logicalType: z.enum([
+  logicalType: z2.enum([
     "string",
     "integer",
     "float",
@@ -49,61 +73,61 @@ var DatasetSemanticFieldSchema = z.object({
     "json",
     "messages"
   ]),
-  nullable: z.boolean(),
-  policy: z.enum(["visible", "privileged", "metadata"])
+  nullable: z2.boolean(),
+  policy: z2.enum(["visible", "privileged", "metadata"])
 });
-var DatasetSemanticSchemaSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetSemanticSchema.v1"),
-  fields: z.array(DatasetSemanticFieldSchema).min(1).max(1e4),
+var DatasetSemanticSchemaSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetSemanticSchema.v1"),
+  fields: z2.array(DatasetSemanticFieldSchema).min(1).max(1e4),
   schemaHash: HashSchema
 });
-var DatasetShardRefSchema = z.object({
+var DatasetShardRefSchema = z2.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()
+  sizeBytes: z2.number().int().nonnegative(),
+  rowCount: z2.number().int().positive(),
+  rowGroupCount: z2.number().int().positive()
 });
-var DatasetArtifactManifestSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifact.v1"),
+var DatasetArtifactManifestSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetArtifact.v1"),
   id: IdSchema,
   tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
+  tasksetRevision: z2.number().int().positive(),
   contentHash: HashSchema,
-  format: z.literal("parquet"),
+  format: z2.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),
+  shards: z2.array(DatasetShardRefSchema).min(1).max(1e5),
+  rowCount: z2.number().int().positive(),
+  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
+  sourceReceiptRefs: z2.array(IdSchema).min(1).max(1e5),
   mappingHash: HashSchema,
   qualityReportHash: HashSchema,
   createdAt: TimestampSchema
 });
-var DatasetArtifactSummarySchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifactSummary.v1"),
+var DatasetArtifactSummarySchema = z2.object({
+  schemaVersion: z2.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(),
+  tasksetRevision: z2.number().int().positive(),
+  format: z2.literal("parquet"),
+  rowCount: z2.number().int().positive(),
+  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
+  sizeBytes: z2.number().int().nonnegative(),
   contentHash: HashSchema,
-  available: z.boolean(),
-  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
+  available: z2.boolean(),
+  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
   createdAt: TimestampSchema
 });
-var DatasetCatalogItemSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetCatalogItem.v1"),
+var DatasetCatalogItemSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetCatalogItem.v1"),
   tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
+  tasksetRevision: z2.number().int().positive(),
   artifactId: IdSchema.nullable(),
-  name: z.string().trim().min(1).max(500),
-  status: z.enum([
+  name: z2.string().trim().min(1).max(500),
+  status: z2.enum([
     "draft",
     "awaiting_disclosure_approval",
     "awaiting_materialization_approval",
@@ -116,138 +140,138 @@ var DatasetCatalogItemSchema = z.object({
     "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(),
+  storageKind: z2.enum(["inline", "parquet"]),
+  rowCount: z2.number().int().nonnegative(),
+  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
+  sizeBytes: z2.number().int().nonnegative().nullable(),
+  available: z2.boolean(),
+  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema
 });
-var DatasetCatalogResponseSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetCatalog.v1"),
+var DatasetCatalogResponseSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetCatalog.v1"),
   profileId: IdSchema,
-  datasets: z.array(DatasetCatalogItemSchema),
+  datasets: z2.array(DatasetCatalogItemSchema),
   generatedAt: TimestampSchema
 });
-var DatasetArtifactRegistryEntrySchema = z.object({
-  schemaVersion: z.literal("openpond.datasetArtifactRegistry.v1"),
+var DatasetArtifactRegistryEntrySchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetArtifactRegistry.v1"),
   manifest: DatasetArtifactManifestSchema,
   profileId: IdSchema,
-  storageRoot: z.string().trim().min(1).max(4e3),
+  storageRoot: z2.string().trim().min(1).max(4e3),
   relativeManifestPath: RelativePathSchema,
-  available: z.boolean(),
-  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
+  available: z2.boolean(),
+  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
   verifiedAt: TimestampSchema.nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema
 });
-var DatasetRowPageRequestSchema = z.object({
+var DatasetRowPageRequestSchema = z2.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([])
+  cursor: z2.string().trim().min(1).max(2e3).nullable().default(null),
+  limit: z2.number().int().min(1).max(100).default(25),
+  columns: z2.array(z2.string().trim().min(1).max(500)).max(100).default([])
 });
-var DatasetRowPageSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetRowPage.v1"),
+var DatasetRowPageSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetRowPage.v1"),
   tasksetId: IdSchema,
-  tasksetRevision: z.number().int().positive(),
+  tasksetRevision: z2.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()
+  rows: z2.array(z2.record(z2.string(), z2.unknown())).max(100),
+  nextCursor: z2.string().max(2e3).nullable(),
+  totalRows: z2.number().int().nonnegative(),
+  returnedRows: z2.number().int().nonnegative()
 });
-var DatasetStorageSettingsSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetStorageSettings.v1"),
-  datasetStorePath: z.string().trim().min(1).max(4e3),
+var DatasetStorageSettingsSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetStorageSettings.v1"),
+  datasetStorePath: z2.string().trim().min(1).max(4e3),
   updatedAt: TimestampSchema
 });
-var DatasetStorageRootSchema = z.object({
+var DatasetStorageRootSchema = z2.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()
+  label: z2.string().trim().min(1).max(500),
+  path: z2.string().trim().min(1).max(4e3),
+  datasetStorePath: z2.string().trim().min(1).max(4e3),
+  kind: z2.enum(["local", "network", "removable", "cache"]),
+  configured: z2.boolean(),
+  mounted: z2.boolean(),
+  writable: z2.boolean(),
+  totalBytes: z2.number().int().nonnegative().nullable(),
+  freeBytes: z2.number().int().nonnegative().nullable()
 });
-var DatasetStorageStateSchema = z.object({
-  schemaVersion: z.literal("openpond.datasetStorageState.v1"),
+var DatasetStorageStateSchema = z2.object({
+  schemaVersion: z2.literal("openpond.datasetStorageState.v1"),
   settings: DatasetStorageSettingsSchema,
-  storageRoots: z.array(DatasetStorageRootSchema)
+  storageRoots: z2.array(DatasetStorageRootSchema)
 });
-var UpdateDatasetStorageSettingsRequestSchema = z.object({
-  datasetStorePath: z.string().trim().min(1).max(4e3)
+var UpdateDatasetStorageSettingsRequestSchema = z2.object({
+  datasetStorePath: z2.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([
+import { z as z3 } from "zod";
+var IdSchema2 = z3.string().trim().min(1).max(240);
+var TimestampSchema2 = z3.string().trim().min(1);
+var HashSchema2 = z3.string().trim().min(8).max(256);
+var MetadataSchema = z3.record(z3.string(), z3.unknown()).default({});
+var RevisionSchema = z3.string().trim().min(7).max(256);
+var DatasetSourceReviewStatusSchema = z3.enum([
   "pending",
   "approved",
   "review",
   "blocked"
 ]);
-var ExternalDatasetSourceBaseSchema = z2.object({
+var ExternalDatasetSourceBaseSchema = z3.object({
   id: IdSchema2,
   profileId: IdSchema2,
-  title: z2.string().trim().min(1).max(500),
+  title: z3.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"]),
+  secretScanStatus: z3.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z3.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),
+  schemaVersion: z3.literal("openpond.huggingFaceDatasetSource.v1"),
+  kind: z3.literal("huggingface"),
+  repositoryId: z3.string().trim().regex(/^[^/\s]+\/[^/\s]+$/).max(500),
+  repositoryUrl: z3.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)
+  configuration: z3.string().trim().min(1).max(500),
+  upstreamSplits: z3.array(z3.string().trim().min(1).max(500)).min(1).max(1e3),
+  gated: z3.boolean(),
+  private: z3.boolean(),
+  declaredLicense: z3.string().trim().min(1).max(500).nullable(),
+  sourceFileHashes: z3.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)
+  schemaVersion: z3.literal("openpond.uploadedFileDatasetSource.v1"),
+  kind: z3.literal("uploaded_file"),
+  originalFileNames: z3.array(z3.string().trim().min(1).max(500)).min(1).max(1e3),
+  mediaTypes: z3.array(z3.string().trim().min(1).max(200)).min(1).max(1e3),
+  sourceFileHashes: z3.array(HashSchema2).min(1).max(1e3),
+  totalBytes: z3.number().int().nonnegative(),
+  parserVersion: z3.string().trim().min(1).max(200)
 });
 var GeneratedDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z2.literal("openpond.generatedDatasetSource.v1"),
-  kind: z2.literal("generated"),
+  schemaVersion: z3.literal("openpond.generatedDatasetSource.v1"),
+  kind: z3.literal("generated"),
   generatorId: IdSchema2,
-  generatorVersion: z2.string().trim().min(1).max(200),
-  seed: z2.number().int(),
+  generatorVersion: z3.string().trim().min(1).max(200),
+  seed: z3.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(),
+  schemaVersion: z3.literal("openpond.learningBatchDatasetSource.v1"),
+  kind: z3.literal("learning_batch"),
+  batch: z3.object({ id: IdSchema2, revision: z3.number().int().positive(), contentHash: HashSchema2 }).strict(),
+  taskDefinition: z3.object({ id: IdSchema2, revision: z3.number().int().positive(), contentHash: HashSchema2 }).strict(),
   admittedBy: IdSchema2
 });
-var ExternalDatasetSourceRefSchema = z2.discriminatedUnion("kind", [
+var ExternalDatasetSourceRefSchema = z3.discriminatedUnion("kind", [
   HuggingFaceDatasetSourceRefSchema,
   UploadedFileDatasetSourceRefSchema,
   GeneratedDatasetSourceRefSchema,
@@ -255,38 +279,39 @@ var ExternalDatasetSourceRefSchema = z2.discriminatedUnion("kind", [
 ]);
 
 // src/taskset-draft-harness-actions.ts
-import { z as z3 } from "zod";
-var HarnessActionBindingSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessActionBinding.v1"),
+import { z as z4 } from "zod";
+var HarnessActionBindingSchema = z4.object({
+  schemaVersion: z4.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()),
+  modelToolName: z4.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z4.string().trim().min(1).max(1e3),
+  inputSchema: z4.record(z4.string(), z4.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({
+  sideEffect: z4.enum(["read", "write"]),
+  studentVisible: z4.boolean(),
+  timeoutMs: z4.number().int().positive().max(36e5),
+  episodeArgumentBindings: z4.array(
+    z4.object({
       argument: ReleaseIdSchema,
-      source: z3.literal("case_id")
+      source: z4.literal("case_id")
     }).strict()
   ).max(20).default([])
 }).strict();
 
 // src/taskset-draft-core.ts
-import { z as z4 } from "zod";
+import { z as z5 } 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({});
+import { HumanFormSchema } from "@openpond/evals/human-review";
+var IdSchema3 = z5.string().trim().min(1).max(240);
+var TimestampSchema3 = z5.string().trim().min(1);
+var HashSchema3 = z5.string().trim().min(8).max(256);
+var Sha256Schema = z5.string().trim().regex(/^[a-f0-9]{64}$/);
+var CodeIdentifierSchema = z5.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
 var NullableIdSchema = IdSchema3.nullable();
 function safeRelativeFilePath(value) {
   const normalized = value.trim().replaceAll("\\", "/");
@@ -302,169 +327,170 @@ function safeFileName(value) {
   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"),
+var TasksetPurposeSchema = z5.enum(["general", "benchmark"]);
+var TasksetBenchmarkBindingSchema = z5.object({
+  schemaVersion: z5.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."),
+  managedReleasePath: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
   adaptationSplit: TasksetSplitSchema,
   evaluationSplit: TasksetSplitSchema,
-  primaryMetric: z4.enum([
+  primaryMetric: z5.enum([
     "foreground_tokens",
     "success_rate",
     "latency_ms",
     "cost_usd"
   ]),
-  qualityGate: z4.enum(["none", "non_regression", "all_pass"]),
-  source: z4.enum(["builtin", "imported"]),
+  qualityGate: z5.enum(["none", "non_regression", "all_pass"]),
+  source: z5.enum(["builtin", "imported"]),
   metadata: MetadataSchema2
 });
-var TasksetPreferenceComparisonBindingSchema = z4.object({
-  schemaVersion: z4.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
+var TasksetPreferenceComparisonBindingSchema = z5.object({
+  schemaVersion: z5.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"]),
+var TrainingSourceConsentSchema = z5.object({
+  status: z5.enum(["pending", "granted", "denied", "revoked"]),
+  scope: z5.enum(["metadata_only", "selected_turns", "full_session"]),
   grantedBy: NullableIdSchema,
   grantedAt: TimestampSchema3.nullable(),
-  purpose: z4.literal("task_authoring_and_evaluation")
+  purpose: z5.literal("task_authoring_and_evaluation")
 });
-var TrainingSourceRefSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingSource.v1"),
+var TrainingSourceRefSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingSource.v1"),
   id: IdSchema3,
   profileId: IdSchema3,
   sessionId: IdSchema3,
-  turnIds: z4.array(IdSchema3).max(1e3).default([]),
+  turnIds: z5.array(IdSchema3).max(1e3).default([]),
   workspaceId: NullableIdSchema,
   sourceHash: HashSchema3,
   clusterKey: IdSchema3,
-  title: z4.string().trim().min(1).max(500),
+  title: z5.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"]),
+  connectedAppIds: z5.array(IdSchema3).max(100).default([]),
+  secretScanStatus: z5.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z5.enum(["pending", "passed", "review", "blocked"]),
+  licensingStatus: z5.enum(["pending", "approved", "review", "blocked"]),
   metadata: MetadataSchema2
 });
-var TasksetSourceRefSchema = z4.union([
+var TasksetSourceRefSchema = z5.union([
   TrainingSourceRefSchema,
-  ExternalDatasetSourceRefSchema
+  ExternalDatasetSourceRefSchema,
+  ConnectedDatasetSourceRefSchema
 ]);
-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 TaskPolicyBoundarySchema = z5.object({
+  policyVisibleFields: z5.array(IdSchema3).max(1e3).default([]),
+  privilegedFields: z5.array(IdSchema3).max(1e3).default([]),
+  hiddenGraderRefs: z5.array(IdSchema3).max(100).default([]),
+  connectedAppScopes: z5.array(IdSchema3).max(100).default([])
 });
-var TaskAssetRefSchema = z4.object({
+var TaskAssetRefSchema = z5.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),
+  artifactRef: z5.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
+  fileName: z5.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
+  mediaType: z5.string().trim().min(1).max(200),
   sha256: Sha256Schema,
-  sizeBytes: z4.number().int().nonnegative().max(25e7),
+  sizeBytes: z5.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),
+var TaskRequiredOutputSchema = z5.object({
+  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
+  mediaType: z5.string().trim().min(1).max(200),
   schemaRef: IdSchema3.nullable().optional(),
-  maxBytes: z4.number().int().positive().max(1e7).optional(),
+  maxBytes: z5.number().int().positive().max(1e7).optional(),
   metadata: MetadataSchema2
 });
-var TaskDataRecordSchema = z4.object({
-  schemaVersion: z4.literal("openpond.taskData.v1"),
+var TaskDataRecordSchema = z5.object({
+  schemaVersion: z5.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({}),
+  input: z5.record(z5.string(), z5.unknown()),
+  expectedOutput: z5.record(z5.string(), z5.unknown()).nullable(),
+  policyVisibleContext: z5.record(z5.string(), z5.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([]),
+  sourceRefs: z5.array(IdSchema3).min(1).max(100),
+  assets: z5.array(TaskAssetRefSchema).max(1e3).optional(),
+  resourceRefs: z5.array(IdSchema3).max(1e3).optional(),
+  requiredOutputs: z5.array(TaskRequiredOutputSchema).max(100).optional(),
+  tags: z5.array(IdSchema3).max(100).default([]),
   metadata: MetadataSchema2
 });
-var TasksetEnvironmentResourceSchema = z4.object({
+var TasksetEnvironmentResourceSchema = z5.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(),
+  kind: z5.enum(["file", "catalog", "configuration", "code_module"]),
+  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
+  mediaType: z5.string().trim().min(1).max(200).nullable().optional(),
+  visibility: z5.enum(["policy_visible", "policy_hidden", "privileged"]),
+  required: z5.boolean(),
   metadata: MetadataSchema2
 });
-var LearningSignalBaseSchema = z4.object({
+var LearningSignalBaseSchema = z5.object({
   id: IdSchema3,
   taskId: NullableIdSchema,
-  sourceRefs: z4.array(IdSchema3).min(1).max(100),
+  sourceRefs: z5.array(IdSchema3).min(1).max(100),
   artifactRef: IdSchema3,
-  approved: z4.boolean(),
-  confidence: z4.number().min(0).max(1),
+  approved: z5.boolean(),
+  confidence: z5.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)
+  kind: z5.literal("demonstration"),
+  prompt: z5.string().max(1e5).nullable().default(null),
+  response: z5.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)
+  kind: z5.literal("preference"),
+  prompt: z5.string().max(1e5),
+  chosen: z5.string().max(2e5),
+  rejected: z5.string().max(2e5),
+  rationale: z5.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)
+  kind: z5.literal("correction"),
+  original: z5.string().max(2e5),
+  corrected: z5.string().max(2e5),
+  rationale: z5.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"])
+  kind: z5.literal("feedback"),
+  feedback: z5.string().max(1e5),
+  polarity: z5.enum(["positive", "negative", "mixed", "neutral"])
 });
 var RewardSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("reward"),
-  task: z4.string().max(1e5),
-  rules: z4.array(z4.object({
+  kind: z5.literal("reward"),
+  task: z5.string().max(1e5),
+  rules: z5.array(z5.object({
     id: IdSchema3,
-    points: z4.number().finite(),
-    condition: z4.string().trim().min(1).max(1e5)
+    points: z5.number().finite(),
+    condition: z5.string().trim().min(1).max(1e5)
   })).min(1).max(1e3),
-  otherwisePoints: z4.number().finite(),
-  executable: z4.boolean()
+  otherwisePoints: z5.number().finite(),
+  executable: z5.boolean()
 });
 var LabelSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z4.literal("label"),
-  labelKind: z4.literal("rubric"),
-  task: z4.string().max(1e5),
-  criteria: z4.array(z4.object({
+  kind: z5.literal("label"),
+  labelKind: z5.literal("rubric"),
+  task: z5.string().max(1e5),
+  criteria: z5.array(z5.object({
     id: IdSchema3,
-    label: z4.string().trim().min(1).max(500),
-    description: z4.string().trim().min(1).max(1e5)
+    label: z5.string().trim().min(1).max(500),
+    description: z5.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)
+  calibrationExamples: z5.object({
+    positive: z5.string().trim().min(1).max(2e5),
+    negative: z5.string().trim().min(1).max(2e5),
+    boundary: z5.string().trim().min(1).max(2e5)
   })
 });
-var LearningSignalRefSchema = z4.discriminatedUnion("kind", [
+var LearningSignalRefSchema = z5.discriminatedUnion("kind", [
   DemonstrationSignalSchema,
   PreferenceSignalSchema,
   CorrectionSignalSchema,
@@ -472,83 +498,84 @@ var LearningSignalRefSchema = z4.discriminatedUnion("kind", [
   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 LearningSignalInventorySchema = z5.object({
+  demonstrations: z5.array(DemonstrationSignalSchema).max(1e5).default([]),
+  preferences: z5.array(PreferenceSignalSchema).max(1e5).default([]),
+  corrections: z5.array(CorrectionSignalSchema).max(1e5).default([]),
+  feedback: z5.array(FeedbackSignalSchema).max(1e5).default([]),
+  rewards: z5.array(RewardSignalSchema).max(1e5).default([]),
+  labels: z5.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(),
+var TasksetEnvironmentContractSchema = z5.object({
+  protocolVersion: z5.literal("openpond.taskEnvironment.v1"),
+  kind: z5.enum(["chat", "agent", "program", "stateful_harness", "work"]),
+  entrypoint: z5.string().trim().min(1).max(1e3),
+  stateful: z5.boolean(),
+  deterministicSeeds: z5.boolean(),
+  toolNames: z5.array(IdSchema3).max(200).default([]),
+  actionBindings: z5.array(HarnessActionBindingSchema).max(200).optional(),
+  lifecycle: z5.array(z5.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
+  defaultTimeoutMs: z5.number().int().positive().max(36e5),
+  networkPolicy: z5.enum(["none", "declared_read_only", "declared_scoped"]),
+  resources: z5.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 TasksetCapabilityManifestSchema = z5.object({
+  schemaVersion: z5.literal("openpond.tasksetCapabilities.v1"),
+  taskKind: z5.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
+  supportedSignals: z5.array(z5.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
+  compatibleMethods: z5.array(z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
+  rewardKinds: z5.array(z5.enum(["none", "exact", "deterministic", "model_judge", "human"])),
+  requiresTools: z5.boolean(),
+  requiresState: z5.boolean(),
+  requiresPrivilegedGrading: z5.boolean(),
+  environmentPlacements: z5.array(z5.enum(["local", "remote", "colocated", "provider_native"])),
+  exportable: z5.boolean(),
+  portabilityBlockers: z5.array(z5.string().trim().min(1).max(2e3)).default([])
 });
-var GraderBaseSchema = z4.object({
+var GraderBaseSchema = z5.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),
+  version: z5.string().trim().min(1).max(100),
+  label: z5.string().trim().min(1).max(500),
+  weight: z5.number().min(0).max(1e3).default(1),
+  hardGate: z5.boolean().default(false),
+  rewardEligible: z5.boolean().default(false),
+  privileged: z5.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())
+  kind: z5.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
+  config: z5.record(z5.string(), z5.unknown())
 });
 var RubricGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.literal("model_judge"),
-  rubric: z4.string().trim().min(1).max(5e4),
+  kind: z5.literal("model_judge"),
+  rubric: z5.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)
+  calibrationFixtureRefs: z5.array(IdSchema3).min(1).max(500),
+  calibrationStatus: z5.enum(["pending", "passed", "failed"]),
+  temperature: z5.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)
+  kind: z5.literal("human"),
+  form: HumanFormSchema.optional(),
+  rubric: z5.string().trim().min(1).max(5e4),
+  reviewerRole: z5.string().trim().min(1).max(500)
 });
 var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z4.literal("custom_verifier"),
+  kind: z5.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."),
+  module: z5.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")
+  timeoutMs: z5.number().int().positive().max(3e5),
+  networkPolicy: z5.literal("none")
 });
-var GraderSpecSchema = z4.union([
+var GraderSpecSchema = z5.union([
   DeterministicGraderSpecSchema,
   RubricGraderSpecSchema,
   HumanGraderSpecSchema,
   CustomVerifierGraderSpecSchema
 ]);
-var GraderFixtureLabelSchema = z4.enum([
+var GraderFixtureLabelSchema = z5.enum([
   "positive",
   "negative",
   "boundary",
@@ -556,24 +583,24 @@ var GraderFixtureLabelSchema = z4.enum([
   "prompt_injection",
   "infrastructure_failure"
 ]);
-var GraderFixtureSchema = z4.object({
+var GraderFixtureSchema = z5.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(),
+  output: z5.record(z5.string(), z5.unknown()),
+  infrastructureError: z5.string().trim().min(1).max(1e4).nullable(),
+  expectedPassed: z5.boolean(),
+  expectedRewardEligible: z5.boolean(),
   metadata: MetadataSchema2
 });
 
 // src/taskset-authored-contracts.ts
-import { z as z5 } from "zod";
+import { z as z6 } 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 IdSchema4 = z6.string().trim().min(1).max(240);
+var TimestampSchema4 = z6.string().trim().min(1);
+var HashSchema4 = z6.string().trim().min(8).max(256);
+var MetadataSchema3 = z6.record(z6.string(), z6.unknown()).default({});
 var NullableIdSchema2 = IdSchema4.nullable();
 var TASKSET_WORK_TOOL_NAMES = [
   "work_capabilities",
@@ -589,7 +616,7 @@ var TASKSET_WORK_TOOL_NAMES = [
   "work_save_output",
   "work_stop"
 ];
-var TasksetStatusSchema = z5.enum([
+var TasksetStatusSchema = z6.enum([
   "draft",
   "awaiting_disclosure_approval",
   "awaiting_materialization_approval",
@@ -602,28 +629,28 @@ var TasksetStatusSchema = z5.enum([
   "failed",
   "archived"
 ]);
-var DatasetBuildIntentSchema = z5.enum([
+var DatasetBuildIntentSchema = z6.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"),
+var DatasetEvidenceTextSchema = z6.string().trim().max(1e5);
+var DatasetBuildSpecificationSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    kind: z6.literal("demonstrations"),
     behavior: DatasetEvidenceTextSchema,
-    examples: z5.array(z5.object({
+    examples: z6.array(z6.object({
       id: IdSchema4,
       prompt: DatasetEvidenceTextSchema,
       response: DatasetEvidenceTextSchema
     })).max(1e3).default([])
   }),
-  z5.object({
-    kind: z5.literal("preferences"),
+  z6.object({
+    kind: z6.literal("preferences"),
     preference: DatasetEvidenceTextSchema,
-    pairs: z5.array(z5.object({
+    pairs: z6.array(z6.object({
       id: IdSchema4,
       prompt: DatasetEvidenceTextSchema,
       chosen: DatasetEvidenceTextSchema,
@@ -631,22 +658,22 @@ var DatasetBuildSpecificationSchema = z5.discriminatedUnion("kind", [
       rationale: DatasetEvidenceTextSchema
     })).max(1e3).default([])
   }),
-  z5.object({
-    kind: z5.literal("verifiable_reward"),
+  z6.object({
+    kind: z6.literal("verifiable_reward"),
     task: DatasetEvidenceTextSchema,
-    rules: z5.array(z5.object({
+    rules: z6.array(z6.object({
       id: IdSchema4,
-      points: z5.number().finite(),
+      points: z6.number().finite(),
       condition: DatasetEvidenceTextSchema
     })).max(1e3).default([]),
-    otherwisePoints: z5.number().finite().default(0)
+    otherwisePoints: z6.number().finite().default(0)
   }),
-  z5.object({
-    kind: z5.literal("rubric"),
+  z6.object({
+    kind: z6.literal("rubric"),
     task: DatasetEvidenceTextSchema,
-    criteria: z5.array(z5.object({
+    criteria: z6.array(z6.object({
       id: IdSchema4,
-      label: z5.string().trim().max(500),
+      label: z6.string().trim().max(500),
       description: DatasetEvidenceTextSchema
     })).max(1e3).default([]),
     positiveExample: DatasetEvidenceTextSchema,
@@ -654,21 +681,21 @@ var DatasetBuildSpecificationSchema = z5.discriminatedUnion("kind", [
     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 GeneratedTaskFileSchema = z6.object({
+  path: z6.string().trim().min(1).max(1e3),
+  role: z6.enum(["environment", "verifier", "fixture"]),
+  content: z6.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)
+var TrainingPathRecommendationSchema = z6.object({
+  primaryMethod: z6.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
+  bootstrap: z6.object({
+    method: z6.literal("sft"),
+    purpose: z6.literal("trajectory_bootstrap"),
+    demonstrationRefs: z6.array(IdSchema4).min(1).max(1e5),
+    limitations: z6.array(z6.string().trim().min(1).max(5e3)).min(1).max(100)
   }).nullable()
 });
-var TrainingMethodReadinessReasonCodeSchema = z5.enum([
+var TrainingMethodReadinessReasonCodeSchema = z6.enum([
   "taskset_not_ready",
   "demonstrations_missing",
   "preference_pairs_missing",
@@ -679,74 +706,74 @@ var TrainingMethodReadinessReasonCodeSchema = z5.enum([
   "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 TrainingMethodReadinessSchema = z6.object({
+  method: z6.enum(["sft", "dpo", "grpo", "ppo"]),
+  status: z6.enum(["recommended", "compatible", "needs_dataset_work"]),
+  reasonCodes: z6.array(TrainingMethodReadinessReasonCodeSchema).default([]),
+  reasons: z6.array(z6.string().trim().min(1).max(5e3)).default([])
 });
-var TasksetReadinessFindingSchema = z5.object({
+var TasksetReadinessFindingSchema = z6.object({
   code: IdSchema4,
-  message: z5.string().trim().min(1).max(5e3),
-  path: z5.string().trim().max(2e3).nullable()
+  message: z6.string().trim().min(1).max(5e3),
+  path: z6.string().trim().max(2e3).nullable()
 });
-var TasksetReadinessReportSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetReadiness.v1"),
+var TasksetReadinessReportSchema = z6.object({
+  schemaVersion: z6.literal("openpond.tasksetReadiness.v1"),
   tasksetId: IdSchema4,
   tasksetHash: HashSchema4,
-  ready: z5.boolean(),
-  recommendedMethod: z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+  ready: z6.boolean(),
+  recommendedMethod: z6.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"])
+  methodReadiness: z6.array(TrainingMethodReadinessSchema).default([]),
+  compatibleDestinationClasses: z6.array(
+    z6.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([]),
+  blockers: z6.array(TasksetReadinessFindingSchema).default([]),
+  advisories: z6.array(TasksetReadinessFindingSchema).default([]),
+  warnings: z6.array(z6.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"),
+var AuthoringRepairSchema = z6.object({ attempt: z6.number().int().positive(), summary: z6.string().trim().min(1).max(5e3), createdAt: TimestampSchema4 });
+var AuthoringProvenanceSchema = z6.object({
+  schemaVersion: z6.literal("openpond.taskAuthoringProvenance.v1"),
   model: ChatModelRefSchema.nullable(),
   modelConfig: MetadataSchema3,
   skillHash: HashSchema4,
-  promptTemplateVersion: z5.string().trim().min(1).max(200),
+  promptTemplateVersion: z6.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),
+  evidenceHashes: z6.array(HashSchema4).max(1e5),
+  tasksetSdkVersion: z6.string().trim().min(1).max(100),
+  sourceCommit: z6.string().trim().min(1).max(256).nullable(),
+  repairHistory: z6.array(AuthoringRepairSchema).max(1e3),
   createdAt: TimestampSchema4
 });
-var TasksetSchema = z5.object({
-  schemaVersion: z5.literal("openpond.taskset.v1"),
+var TasksetSchema = z6.object({
+  schemaVersion: z6.literal("openpond.taskset.v1"),
   id: IdSchema4,
-  revision: z5.number().int().positive().default(1),
+  revision: z6.number().int().positive().default(1),
   profileId: IdSchema4,
   profileRelease: VersionedReleaseRefSchema.nullable().optional(),
   createImproveRunId: NullableIdSchema2.default(null),
-  name: z5.string().trim().min(1).max(500),
+  name: z6.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),
+  objective: z6.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),
+  sourceRefs: z6.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),
+  tasks: z6.array(TaskDataRecordSchema).max(1e6),
+  graders: z6.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),
+  graderFixtures: z6.array(GraderFixtureSchema).max(1e5),
   learningSignals: LearningSignalInventorySchema,
   authoringProvenance: AuthoringProvenanceSchema,
   readiness: TasksetReadinessReportSchema.nullable(),
@@ -1157,6 +1184,7 @@ function validateCapabilities(capabilities, issues, taskset) {
 }
 
 export {
+  ConnectedDatasetSourceRefSchema,
   DatasetSplitSchema,
   DatasetSemanticFieldSchema,
   DatasetSemanticSchemaSchema,
@@ -1226,4 +1254,4 @@ export {
   computeTasksetHash,
   validatePortability
 };
-//# sourceMappingURL=chunk-LGEF4S5I.js.map
+//# sourceMappingURL=chunk-XJDWHTH5.js.map