openpond-sdk 0.11.0 → 0.11.3

package/dist/chunk-CPEOFPPF.js

@@ -0,0 +1,632 @@
+import {
+  DatasetArtifactManifestSchema,
+  GraderFixtureSchema,
+  GraderSpecSchema,
+  LearningSignalInventorySchema,
+  TaskDataRecordSchema,
+  TaskPolicyBoundarySchema,
+  TasksetBenchmarkBindingSchema,
+  TasksetCapabilityManifestSchema,
+  TasksetEnvironmentContractSchema,
+  TasksetPreferenceComparisonBindingSchema,
+  TasksetPurposeSchema,
+  TasksetSourceRefSchema
+} from "./chunk-LFH4EKWH.js";
+import {
+  ChatModelRefSchema
+} from "./chunk-4NZW4LFB.js";
+import {
+  VersionedReleaseRefSchema,
+  contentHash
+} from "./chunk-QUOW6URQ.js";
+
+// src/taskset-authored-contracts.ts
+import { z } from "zod";
+import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
+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 MetadataSchema = z.record(z.string(), z.unknown()).default({});
+var NullableIdSchema = IdSchema.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 = z.enum([
+  "draft",
+  "awaiting_disclosure_approval",
+  "awaiting_materialization_approval",
+  "materializing",
+  "validating",
+  "needs_review",
+  "baselining",
+  "ready",
+  "blocked",
+  "failed",
+  "archived"
+]);
+var DatasetBuildIntentSchema = z.enum([
+  "demonstrations",
+  "preferences",
+  "verifiable_reward",
+  "rubric",
+  "discovery"
+]);
+var DatasetEvidenceTextSchema = z.string().trim().max(1e5);
+var DatasetBuildSpecificationSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("demonstrations"),
+    behavior: DatasetEvidenceTextSchema,
+    examples: z.array(z.object({
+      id: IdSchema,
+      prompt: DatasetEvidenceTextSchema,
+      response: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z.object({
+    kind: z.literal("preferences"),
+    preference: DatasetEvidenceTextSchema,
+    pairs: z.array(z.object({
+      id: IdSchema,
+      prompt: DatasetEvidenceTextSchema,
+      chosen: DatasetEvidenceTextSchema,
+      rejected: DatasetEvidenceTextSchema,
+      rationale: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z.object({
+    kind: z.literal("verifiable_reward"),
+    task: DatasetEvidenceTextSchema,
+    rules: z.array(z.object({
+      id: IdSchema,
+      points: z.number().finite(),
+      condition: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    otherwisePoints: z.number().finite().default(0)
+  }),
+  z.object({
+    kind: z.literal("rubric"),
+    task: DatasetEvidenceTextSchema,
+    criteria: z.array(z.object({
+      id: IdSchema,
+      label: z.string().trim().max(500),
+      description: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    positiveExample: DatasetEvidenceTextSchema,
+    negativeExample: DatasetEvidenceTextSchema,
+    boundaryExample: DatasetEvidenceTextSchema
+  })
+]);
+var GeneratedTaskFileSchema = z.object({
+  path: z.string().trim().min(1).max(1e3),
+  role: z.enum(["environment", "verifier", "fixture"]),
+  content: z.string().max(25e4)
+});
+var TrainingPathRecommendationSchema = z.object({
+  primaryMethod: z.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
+  bootstrap: z.object({
+    method: z.literal("sft"),
+    purpose: z.literal("trajectory_bootstrap"),
+    demonstrationRefs: z.array(IdSchema).min(1).max(1e5),
+    limitations: z.array(z.string().trim().min(1).max(5e3)).min(1).max(100)
+  }).nullable()
+});
+var TrainingMethodReadinessReasonCodeSchema = z.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 = z.object({
+  method: z.enum(["sft", "dpo", "grpo", "ppo"]),
+  status: z.enum(["recommended", "compatible", "needs_dataset_work"]),
+  reasonCodes: z.array(TrainingMethodReadinessReasonCodeSchema).default([]),
+  reasons: z.array(z.string().trim().min(1).max(5e3)).default([])
+});
+var TasksetReadinessFindingSchema = z.object({
+  code: IdSchema,
+  message: z.string().trim().min(1).max(5e3),
+  path: z.string().trim().max(2e3).nullable()
+});
+var TasksetReadinessReportSchema = z.object({
+  schemaVersion: z.literal("openpond.tasksetReadiness.v1"),
+  tasksetId: IdSchema,
+  tasksetHash: HashSchema,
+  ready: z.boolean(),
+  recommendedMethod: z.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+  trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
+  methodReadiness: z.array(TrainingMethodReadinessSchema).default([]),
+  compatibleDestinationClasses: z.array(
+    z.enum(["export", "custom", "hosted_managed"])
+  ),
+  blockers: z.array(TasksetReadinessFindingSchema).default([]),
+  advisories: z.array(TasksetReadinessFindingSchema).default([]),
+  warnings: z.array(z.string().trim().min(1).max(5e3)).default([]),
+  generatedAt: TimestampSchema
+});
+var AuthoringRepairSchema = z.object({ attempt: z.number().int().positive(), summary: z.string().trim().min(1).max(5e3), createdAt: TimestampSchema });
+var AuthoringProvenanceSchema = z.object({
+  schemaVersion: z.literal("openpond.taskAuthoringProvenance.v1"),
+  model: ChatModelRefSchema.nullable(),
+  modelConfig: MetadataSchema,
+  skillHash: HashSchema,
+  promptTemplateVersion: z.string().trim().min(1).max(200),
+  buildIntent: DatasetBuildIntentSchema.default("demonstrations"),
+  buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),
+  evidenceHashes: z.array(HashSchema).max(1e5),
+  tasksetSdkVersion: z.string().trim().min(1).max(100),
+  sourceCommit: z.string().trim().min(1).max(256).nullable(),
+  repairHistory: z.array(AuthoringRepairSchema).max(1e3),
+  createdAt: TimestampSchema
+});
+var TasksetSchema = z.object({
+  schemaVersion: z.literal("openpond.taskset.v1"),
+  id: IdSchema,
+  revision: z.number().int().positive().default(1),
+  profileId: IdSchema,
+  profileRelease: VersionedReleaseRefSchema.nullable().optional(),
+  createImproveRunId: NullableIdSchema.default(null),
+  name: z.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: z.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetStatusSchema,
+  sourceRefs: z.array(TasksetSourceRefSchema).min(1).max(1e5),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema.optional(),
+  tasks: z.array(TaskDataRecordSchema).max(1e6),
+  graders: z.array(GraderSpecSchema).min(1).max(1e3),
+  // Imported releases are inspectable before local calibration. Admission
+  // requires real fixtures separately in validateTaskset.
+  graderFixtures: z.array(GraderFixtureSchema).max(1e5),
+  learningSignals: LearningSignalInventorySchema,
+  authoringProvenance: AuthoringProvenanceSchema,
+  readiness: TasksetReadinessReportSchema.nullable(),
+  contentHash: HashSchema,
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  metadata: MetadataSchema
+}).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) {
+  const humanReviewOnly = taskset.graders.length > 0 && taskset.graders.every((grader) => grader.kind === "human");
+  if (!humanReviewOnly && !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 humanReviewOnly ? [] : 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 {
+  TASKSET_WORK_TOOL_NAMES,
+  TasksetStatusSchema,
+  DatasetBuildIntentSchema,
+  DatasetBuildSpecificationSchema,
+  GeneratedTaskFileSchema,
+  TrainingPathRecommendationSchema,
+  TrainingMethodReadinessReasonCodeSchema,
+  TrainingMethodReadinessSchema,
+  TasksetReadinessFindingSchema,
+  TasksetReadinessReportSchema,
+  AuthoringRepairSchema,
+  AuthoringProvenanceSchema,
+  TasksetSchema,
+  isTrainingSourceRef,
+  validateTaskset,
+  computeTasksetHash,
+  validatePortability
+};
+//# sourceMappingURL=chunk-CPEOFPPF.js.map