openpond 0.0.67 → 0.0.69

package/dist/chunks/{extension-UUM4ELAF.js → extension-ZMRHCDO3.js}

@@ -4,29 +4,36 @@ import {
   CapabilityRequirementSchema,
   GraderInterfaceContractSchema,
   HarnessTurnSnapshotSchema,
+  ImmutableReleaseRefSchema,
   LifecycleContractSchema,
+  ModelProjectSchema,
   OptimizerTrainingSampleSchema,
+  RefinerBindingSchema,
+  RefinerReleaseSchema,
+  RefinerReviewProfileSchema,
+  RefinerTransitionReceiptSchema,
   SandboxTemplateManifestSchema,
   SandboxTemplateValidationDiagnosticSchema,
   ToolDeclarationSchema,
   validateConnectedAppToolCallRequest
-} from "./chunk-RN7MVPC6.js";
-import "./chunk-3KLQ52B2.js";
+} from "./chunk-BLFIIAWZ.js";
+import "./chunk-BVY5JYM6.js";
 import "./chunk-W5GKHH77.js";
 import {
   loadOpenPondProfileState,
   parseProfileSkillMarkdown
-} from "./chunk-EJURKADM.js";
-import "./chunk-JIEUB6OS.js";
-import "./chunk-BYAPLT37.js";
-import {
-  external_exports
-} from "./chunk-WYDVQOBL.js";
+} from "./chunk-47EIAYI7.js";
+import "./chunk-J3YDKJFD.js";
+import "./chunk-YVCYVDNP.js";
+import "./chunk-X7ZG4TSW.js";
 import {
   openPondConfigDirectory,
   updatePrivateJsonFile
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 import "./chunk-KSRWKXRB.js";
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
 import {
   parseBooleanOption
 } from "./chunk-MUMPWI4O.js";
@@ -3178,7 +3185,8 @@ var SHIPPED_OPENPOND_SKILL_NAMES = [
   "openpond-desktop-harness",
   "openpond-taskset-authoring",
   "openpond-skill-authoring",
-  "openpond-agent-authoring"
+  "openpond-agent-authoring",
+  "openpond-refiner-authoring"
 ];
 var OpenPondExtensionSkillSchema = external_exports.object({
   name: external_exports.string(),
@@ -5160,11 +5168,11 @@ var ExternalDatasetSourceRefSchema = external_exports.discriminatedUnion("kind",
 var ReleaseIdSchema = external_exports.string().trim().min(1).max(240);
 var ReleaseHashSchema = external_exports.string().regex(/^[a-f0-9]{64}$/);
 var ReleaseTimestampSchema = external_exports.string().datetime({ offset: true });
-var ImmutableReleaseRefSchema = external_exports.object({
+var ImmutableReleaseRefSchema2 = external_exports.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema
 }).strict();
-var VersionedReleaseRefSchema = ImmutableReleaseRefSchema.extend({
+var VersionedReleaseRefSchema = ImmutableReleaseRefSchema2.extend({
   revision: external_exports.number().int().positive()
 }).strict();
 var ScopedSecretDeclarationSchema = external_exports.object({
@@ -5196,7 +5204,7 @@ var HarnessActionBindingSchema = external_exports.object({
   description: external_exports.string().trim().min(1).max(1e3),
   inputSchema: external_exports.record(external_exports.string(), external_exports.unknown()),
   actionSchemaHash: ReleaseHashSchema,
-  agentRelease: ImmutableReleaseRefSchema,
+  agentRelease: ImmutableReleaseRefSchema2,
   implementationHash: ReleaseHashSchema,
   runtimeBindingId: ReleaseIdSchema,
   capabilityReceiptHash: ReleaseHashSchema,
@@ -5216,6 +5224,7 @@ var IdSchema4 = external_exports.string().trim().min(1).max(240);
 var TimestampSchema4 = external_exports.string().trim().min(1);
 var HashSchema3 = external_exports.string().trim().min(8).max(256);
 var Sha256Schema = external_exports.string().trim().regex(/^[a-f0-9]{64}$/);
+var CodeIdentifierSchema = external_exports.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
 var MetadataSchema6 = external_exports.record(external_exports.string(), external_exports.unknown()).default({});
 var NullableIdSchema = IdSchema4.nullable();
 function safeRelativeFilePath(value) {
@@ -5264,6 +5273,13 @@ var TasksetBenchmarkBindingSchema = external_exports.object({
   source: external_exports.enum(["builtin", "imported"]),
   metadata: MetadataSchema6
 });
+var TasksetPreferenceComparisonBindingSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
+  releaseId: IdSchema4,
+  releaseHash: Sha256Schema,
+  publishedAt: TimestampSchema4,
+  metadata: MetadataSchema6
+});
 var TaskCreationSurfaceSchema = external_exports.enum([
   "slash_train",
   "session_menu",
@@ -5424,10 +5440,20 @@ var TaskDataRecordSchema = external_exports.object({
   privilegedContextRef: NullableIdSchema,
   sourceRefs: external_exports.array(IdSchema4).min(1).max(100),
   assets: external_exports.array(TaskAssetRefSchema).max(1e3).optional(),
+  resourceRefs: external_exports.array(IdSchema4).max(1e3).optional(),
   requiredOutputs: external_exports.array(TaskRequiredOutputSchema).max(100).optional(),
   tags: external_exports.array(IdSchema4).max(100).default([]),
   metadata: MetadataSchema6
 });
+var TasksetEnvironmentResourceSchema = external_exports.object({
+  id: IdSchema4,
+  kind: external_exports.enum(["file", "catalog", "configuration", "code_module"]),
+  path: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
+  mediaType: external_exports.string().trim().min(1).max(200).nullable().optional(),
+  visibility: external_exports.enum(["policy_visible", "policy_hidden", "privileged"]),
+  required: external_exports.boolean(),
+  metadata: MetadataSchema6
+});
 var LearningSignalBaseSchema = external_exports.object({
   id: IdSchema4,
   taskId: NullableIdSchema,
@@ -5513,6 +5539,7 @@ var TasksetEnvironmentContractSchema = external_exports.object({
   lifecycle: external_exports.array(external_exports.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
   defaultTimeoutMs: external_exports.number().int().positive().max(36e5),
   networkPolicy: external_exports.enum(["none", "declared_read_only", "declared_scoped"]),
+  resources: external_exports.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
   metadata: MetadataSchema6
 });
 var TasksetCapabilityManifestSchema = external_exports.object({
@@ -5528,6 +5555,34 @@ var TasksetCapabilityManifestSchema = external_exports.object({
   exportable: external_exports.boolean(),
   portabilityBlockers: external_exports.array(external_exports.string().trim().min(1).max(2e3)).default([])
 });
+var TasksetMetricPolicySchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetMetricPolicy.v1"),
+  primaryMetric: IdSchema4,
+  aggregation: external_exports.enum(["mean_score", "pass_rate", "weighted_mean", "custom"]),
+  missingReward: external_exports.enum(["zero", "exclude"]),
+  customAggregator: external_exports.object({
+    module: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom metric modules must use a safe relative path."),
+    exportName: CodeIdentifierSchema,
+    contentHash: Sha256Schema,
+    timeoutMs: external_exports.number().int().positive().max(3e5),
+    networkPolicy: external_exports.literal("none")
+  }).nullable()
+}).superRefine((policy, context) => {
+  if (policy.aggregation === "custom" && !policy.customAggregator) {
+    context.addIssue({
+      code: "custom",
+      message: "Custom metric aggregation requires a content-hashed module.",
+      path: ["customAggregator"]
+    });
+  }
+  if (policy.aggregation !== "custom" && policy.customAggregator) {
+    context.addIssue({
+      code: "custom",
+      message: "Built-in metric aggregation cannot include a custom module.",
+      path: ["customAggregator"]
+    });
+  }
+});
 var TaskFailureClassSchema = external_exports.enum([
   "policy_failure",
   "grader_failure",
@@ -5565,8 +5620,8 @@ var HumanGraderSpecSchema = GraderBaseSchema.extend({
 });
 var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
   kind: external_exports.literal("custom_verifier"),
-  module: external_exports.string().trim().min(1).max(1e3),
-  exportName: IdSchema4,
+  module: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
+  exportName: CodeIdentifierSchema,
   timeoutMs: external_exports.number().int().positive().max(3e5),
   networkPolicy: external_exports.literal("none")
 });
@@ -5782,12 +5837,14 @@ var TasksetSchema = external_exports.object({
   objective: external_exports.string().trim().min(1).max(2e4),
   purpose: TasksetPurposeSchema.default("general"),
   benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
   status: TasksetStatusSchema,
   sourceRefs: external_exports.array(TasksetSourceRefSchema).min(1).max(1e5),
   datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
   policy: TaskPolicyBoundarySchema,
   environment: TasksetEnvironmentContractSchema,
   capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema.optional(),
   tasks: external_exports.array(TaskDataRecordSchema).max(1e6),
   graders: external_exports.array(GraderSpecSchema).min(1).max(1e3),
   graderFixtures: external_exports.array(GraderFixtureSchema).min(1).max(1e5),
@@ -5927,11 +5984,139 @@ var TaskCreationTranscriptSchema = external_exports.object({
   updatedAt: TimestampSchema4
 });
 
-// ../../packages/contracts/src/dataset-imports.ts
+// ../../packages/contracts/src/taskset-drafts.ts
 var IdSchema5 = external_exports.string().trim().min(1).max(240);
 var TimestampSchema5 = external_exports.string().trim().min(1);
 var HashSchema4 = external_exports.string().trim().min(8).max(256);
+var CodeIdentifierSchema2 = external_exports.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
 var MetadataSchema7 = external_exports.record(external_exports.string(), external_exports.unknown()).default({});
+function safeRelativeFilePath2(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
+    return false;
+  }
+  return !normalized.split("/").some(
+    (segment) => !segment || segment === "." || segment === ".."
+  );
+}
+var TaskDataDraftSchema = TaskDataRecordSchema.extend({
+  sourceRefs: external_exports.array(IdSchema5).max(100).default([])
+});
+var TasksetDraftStatusSchema = external_exports.enum([
+  "draft",
+  "validating",
+  "needs_review",
+  "published"
+]);
+var TasksetDraftReviewPolicySchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  candidateCount: external_exports.number().int().min(2).max(4),
+  minimumSamples: external_exports.number().int().min(1).max(1e4).default(100),
+  allowTies: external_exports.boolean(),
+  allowRejectAll: external_exports.boolean(),
+  rubric: external_exports.string().trim().max(5e4),
+  criteria: external_exports.array(external_exports.object({
+    id: IdSchema5,
+    label: external_exports.string().trim().min(1).max(500),
+    description: external_exports.string().trim().max(1e4),
+    weight: external_exports.number().nonnegative().max(1e3)
+  })).max(100)
+});
+var TasksetDraftOutputContractSchema = external_exports.object({
+  mode: external_exports.enum(["text", "structured_json", "artifacts"]),
+  jsonSchema: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  renderer: external_exports.object({
+    module: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath2, "Renderer modules must use a safe relative path."),
+    exportName: CodeIdentifierSchema2,
+    configRef: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath2, "Renderer configuration must use a safe relative path.").nullable().default(null)
+  }).nullable()
+}).superRefine((output, context) => {
+  if (output.mode === "structured_json" && !output.jsonSchema) {
+    context.addIssue({
+      code: "custom",
+      message: "Structured JSON output requires a JSON Schema.",
+      path: ["jsonSchema"]
+    });
+  }
+  if (output.mode === "text" && output.renderer) {
+    context.addIssue({
+      code: "custom",
+      message: "Text output cannot configure an artifact renderer.",
+      path: ["renderer"]
+    });
+  }
+});
+var TasksetDraftSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetDraft.v1"),
+  id: IdSchema5,
+  revision: external_exports.number().int().positive(),
+  profileId: IdSchema5,
+  name: external_exports.string().trim().max(500),
+  objective: external_exports.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetDraftStatusSchema,
+  sourceRefs: external_exports.array(TasksetSourceRefSchema).max(1e5).default([]),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  output: TasksetDraftOutputContractSchema.default({
+    mode: "text",
+    jsonSchema: null,
+    renderer: null
+  }),
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema,
+  review: TasksetDraftReviewPolicySchema,
+  tasks: external_exports.array(TaskDataDraftSchema).max(1e6).default([]),
+  graders: external_exports.array(GraderSpecSchema).max(1e3).default([]),
+  graderFixtures: external_exports.array(GraderFixtureSchema).max(1e5).default([]),
+  learningSignals: LearningSignalInventorySchema,
+  publishedTasksetRef: external_exports.object({
+    id: IdSchema5,
+    revision: external_exports.number().int().positive(),
+    contentHash: HashSchema4
+  }).nullable(),
+  createdAt: TimestampSchema5,
+  updatedAt: TimestampSchema5,
+  metadata: MetadataSchema7
+}).superRefine((draft, context) => {
+  if (draft.purpose === "benchmark" && !draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark drafts require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.purpose !== "benchmark" && draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark drafts may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.datasetArtifact && draft.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed drafts may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (draft.status === "published" && !draft.publishedTasksetRef) {
+    context.addIssue({
+      code: "custom",
+      message: "Published drafts require an immutable Taskset reference.",
+      path: ["publishedTasksetRef"]
+    });
+  }
+});
+
+// ../../packages/contracts/src/dataset-imports.ts
+var IdSchema6 = external_exports.string().trim().min(1).max(240);
+var TimestampSchema6 = external_exports.string().trim().min(1);
+var HashSchema5 = external_exports.string().trim().min(8).max(256);
+var MetadataSchema8 = external_exports.record(external_exports.string(), external_exports.unknown()).default({});
 var DatasetImportStatusSchema = external_exports.enum([
   "created",
   "inspecting",
@@ -5965,7 +6150,7 @@ var DatasetSourceSplitSchema = external_exports.object({
 });
 var HuggingFaceDatasetInspectionSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.huggingFaceDatasetInspection.v1"),
-  id: IdSchema5,
+  id: IdSchema6,
   locator: HuggingFaceDatasetLocatorSchema,
   resolvedRevision: external_exports.string().trim().min(7).max(256),
   title: external_exports.string().trim().min(1).max(500),
@@ -5983,10 +6168,10 @@ var HuggingFaceDatasetInspectionSchema = external_exports.object({
     split: external_exports.string().trim().min(1).max(500),
     revision: external_exports.string().trim().min(7).max(256),
     sizeBytes: external_exports.number().int().nonnegative().nullable(),
-    contentHash: HashSchema4.nullable()
+    contentHash: HashSchema5.nullable()
   })).max(1e5),
-  inspectedAt: TimestampSchema5,
-  metadata: MetadataSchema7
+  inspectedAt: TimestampSchema6,
+  metadata: MetadataSchema8
 });
 var DatasetMappingTargetSchema = external_exports.enum([
   "row_id",
@@ -6019,7 +6204,7 @@ var DatasetFieldBindingSchema = external_exports.object({
 });
 var DatasetImportMappingSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.datasetImportMapping.v1"),
-  sourceSchemaHash: HashSchema4,
+  sourceSchemaHash: HashSchema5,
   configuration: external_exports.string().trim().min(1).max(500),
   upstreamSplits: external_exports.array(external_exports.string().trim().min(1).max(500)).min(1).max(1e3),
   preset: external_exports.enum([
@@ -6041,7 +6226,7 @@ var DatasetImportMappingSchema = external_exports.object({
     frozenEvalPercent: external_exports.number().min(0).max(100)
   }),
   importerVersion: external_exports.string().trim().min(1).max(200),
-  mappingHash: HashSchema4
+  mappingHash: HashSchema5
 });
 var DatasetImportProgressSchema = external_exports.object({
   phase: external_exports.enum([
@@ -6061,8 +6246,8 @@ var DatasetImportProgressSchema = external_exports.object({
 });
 var DatasetImportJobSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.datasetImportJob.v1"),
-  id: IdSchema5,
-  profileId: IdSchema5,
+  id: IdSchema6,
+  profileId: IdSchema6,
   sourceKind: external_exports.enum(["huggingface", "uploaded_file"]),
   status: DatasetImportStatusSchema,
   locator: HuggingFaceDatasetLocatorSchema.nullable(),
@@ -6070,18 +6255,18 @@ var DatasetImportJobSchema = external_exports.object({
   mapping: DatasetImportMappingSchema.nullable(),
   progress: DatasetImportProgressSchema,
   targetStorageRoot: external_exports.string().trim().min(1).max(4e3).nullable(),
-  tasksetId: IdSchema5.nullable(),
+  tasksetId: IdSchema6.nullable(),
   tasksetRevision: external_exports.number().int().positive().nullable(),
-  artifactId: IdSchema5.nullable(),
+  artifactId: IdSchema6.nullable(),
   error: external_exports.string().trim().min(1).max(2e4).nullable(),
   cancellationRequested: external_exports.boolean(),
-  createdAt: TimestampSchema5,
-  updatedAt: TimestampSchema5,
-  completedAt: TimestampSchema5.nullable(),
-  metadata: MetadataSchema7
+  createdAt: TimestampSchema6,
+  updatedAt: TimestampSchema6,
+  completedAt: TimestampSchema6.nullable(),
+  metadata: MetadataSchema8
 });
 var CreateHuggingFaceDatasetImportRequestSchema = external_exports.object({
-  profileId: IdSchema5,
+  profileId: IdSchema6,
   url: external_exports.string().trim().min(1).max(2e3)
 });
 var ApproveDatasetImportMappingRequestSchema = external_exports.object({
@@ -6164,6 +6349,30 @@ var ModelVersionKindSchema = external_exports.enum([
   "base_reference",
   "lora_adapter"
 ]);
+var RewardModelRuntimeSchema = external_exports.object({
+  baseModel: external_exports.object({
+    source: external_exports.literal("huggingface"),
+    repoId: ReleaseIdSchema,
+    revision: external_exports.string().regex(/^[a-f0-9]{40}$/),
+    configHash: ReleaseHashSchema,
+    tokenizerHash: ReleaseHashSchema,
+    licenseId: ReleaseIdSchema,
+    gated: external_exports.boolean()
+  }).strict(),
+  processor: external_exports.object({
+    repository: ReleaseIdSchema,
+    revision: external_exports.string().regex(/^[a-f0-9]{40}$/),
+    configHash: ReleaseHashSchema
+  }).strict()
+}).strict().superRefine((runtime, context) => {
+  if (runtime.baseModel.repoId !== runtime.processor.repository || runtime.baseModel.revision !== runtime.processor.revision) {
+    context.addIssue({
+      code: "custom",
+      path: ["processor"],
+      message: "Reward Model processor must match the pinned scorer base model."
+    });
+  }
+});
 var ModelVersionSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.modelVersion.v1"),
   id: ReleaseIdSchema,
@@ -6177,8 +6386,8 @@ var ModelVersionSchema = external_exports.object({
   releaseGraph: external_exports.object({
     resolvedBundleHash: ReleaseHashSchema,
     profileRelease: VersionedReleaseRefSchema,
-    harnessRelease: ImmutableReleaseRefSchema,
-    agentRelease: ImmutableReleaseRefSchema.nullable(),
+    harnessRelease: ImmutableReleaseRefSchema2,
+    agentRelease: ImmutableReleaseRefSchema2.nullable(),
     grader: external_exports.object({
       id: ReleaseIdSchema,
       contentHash: ReleaseHashSchema
@@ -6202,6 +6411,132 @@ var ModelVersionSchema = external_exports.object({
     });
   }
 });
+var RewardModelVersionSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.rewardModelVersion.v1"),
+  id: ReleaseIdSchema,
+  modelId: ReleaseIdSchema,
+  profileId: ReleaseIdSchema,
+  version: external_exports.number().int().positive(),
+  role: external_exports.literal("reward"),
+  status: external_exports.enum(["available", "failed"]),
+  scope: external_exports.enum(["synthetic_smoke", "human_preference"]),
+  baseModel: BaseModelPreferenceSchema,
+  // Older persisted versions predate executable scorer identity.
+  // They remain readable but cannot be bound to a new policy run.
+  runtime: RewardModelRuntimeSchema.nullable().default(null),
+  taskset: VersionedReleaseRefSchema,
+  preferenceDatasetRelease: ImmutableReleaseRefSchema2,
+  releaseGraph: external_exports.object({
+    resolvedBundleHash: ReleaseHashSchema,
+    profileRelease: VersionedReleaseRefSchema,
+    harnessRelease: ImmutableReleaseRefSchema2,
+    grader: external_exports.object({
+      id: ReleaseIdSchema,
+      contentHash: ReleaseHashSchema
+    }).strict()
+  }).strict(),
+  artifacts: external_exports.object({
+    checkpoint: ImmutableReleaseRefSchema2.extend({
+      objectRef: external_exports.string().regex(/^r2:\/\/[A-Za-z0-9._/-]+$/),
+      files: external_exports.array(external_exports.object({
+        path: external_exports.string().trim().min(1).max(512),
+        sizeBytes: external_exports.number().int().positive(),
+        sha256: ReleaseHashSchema
+      }).strict()).min(4).max(128)
+    }).strict(),
+    adapter: ImmutableReleaseRefSchema2,
+    scalarHead: ImmutableReleaseRefSchema2,
+    bucketHead: ImmutableReleaseRefSchema2.nullable(),
+    processorRelease: ImmutableReleaseRefSchema2
+  }).strict(),
+  qualificationReport: ImmutableReleaseRefSchema2.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var RewardModelRunReceiptSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.rewardModelRunReceipt.v1"),
+  provider: ReleaseIdSchema,
+  providerRunId: ReleaseIdSchema,
+  resolvedBundleHash: ReleaseHashSchema,
+  finalCheckpoint: ImmutableReleaseRefSchema2.extend({
+    objectRef: external_exports.string().regex(/^r2:\/\/[A-Za-z0-9._/-]+$/)
+  }).strict(),
+  adapter: ImmutableReleaseRefSchema2,
+  scalarHead: ImmutableReleaseRefSchema2,
+  bucketHead: ImmutableReleaseRefSchema2.nullable(),
+  processorRelease: ImmutableReleaseRefSchema2,
+  optimizerEvidence: ImmutableReleaseRefSchema2,
+  managedExecutionReceipt: ImmutableReleaseRefSchema2.nullable().default(null),
+  parameterDeltaHash: ReleaseHashSchema,
+  cleanup: external_exports.object({
+    computeReleased: external_exports.boolean(),
+    providerTerminalObserved: external_exports.boolean()
+  }).strict(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var RewardModelRunSchema = external_exports.preprocess((value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if (record.tasksetRelease !== void 0) return value;
+  const taskset = record.taskset;
+  if (!taskset || typeof taskset !== "object" || Array.isArray(taskset)) return value;
+  const tasksetRecord = taskset;
+  if (typeof tasksetRecord.id !== "string" || typeof tasksetRecord.contentHash !== "string") {
+    return value;
+  }
+  return {
+    ...record,
+    tasksetRelease: {
+      id: tasksetRecord.id,
+      contentHash: tasksetRecord.contentHash
+    }
+  };
+}, external_exports.object({
+  schemaVersion: external_exports.literal("openpond.rewardModelRun.v1"),
+  id: ReleaseIdSchema,
+  rewardModelId: ReleaseIdSchema,
+  rewardModelVersionId: ReleaseIdSchema.nullable(),
+  profileId: ReleaseIdSchema,
+  role: external_exports.literal("reward"),
+  scope: external_exports.enum(["synthetic_smoke", "human_preference"]),
+  status: external_exports.enum(["prepared", "running", "succeeded", "failed", "cancelled"]),
+  taskset: VersionedReleaseRefSchema,
+  tasksetRelease: ImmutableReleaseRefSchema2,
+  preferenceDatasetRelease: ImmutableReleaseRefSchema2,
+  recipeRelease: ImmutableReleaseRefSchema2,
+  destinationId: ReleaseIdSchema,
+  quote: external_exports.object({
+    maximumSpendUsd: external_exports.number().positive(),
+    hourlyCostUsd: external_exports.number().nonnegative().nullable()
+  }).strict(),
+  managedRunId: ReleaseIdSchema.nullable(),
+  progress: external_exports.object({
+    completedSteps: external_exports.number().int().nonnegative(),
+    totalSteps: external_exports.number().int().positive(),
+    latestLoss: external_exports.number().finite().nullable()
+  }).strict(),
+  receipt: RewardModelRunReceiptSchema.nullable(),
+  qualificationReport: ImmutableReleaseRefSchema2.nullable(),
+  accruedSpendUsd: external_exports.number().nonnegative().nullable(),
+  failureOwner: external_exports.enum(["authoring", "admission", "provider", "runner", "artifact", "qualification", "cleanup"]).nullable(),
+  failure: external_exports.string().trim().min(1).max(5e3).nullable(),
+  startedAt: ReleaseTimestampSchema,
+  completedAt: ReleaseTimestampSchema.nullable(),
+  updatedAt: ReleaseTimestampSchema
+}).strict()).superRefine((run, context) => {
+  if (run.status === "succeeded" && (!run.receipt || !run.qualificationReport)) {
+    context.addIssue({
+      code: "custom",
+      message: "A successful Reward Model Run requires a canonical receipt and qualification report."
+    });
+  }
+  if (run.status !== "succeeded" && run.rewardModelVersionId !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "Only a successful Reward Model Run can publish a Reward Model Version."
+    });
+  }
+});
 var ModelRunReceiptSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.modelRunReceipt.v1"),
   provider: ReleaseIdSchema,
@@ -6303,12 +6638,12 @@ var ModelEvaluationReceiptSchema = external_exports.object({
     artifactPath: external_exports.string().trim().min(1).max(2e3)
   }).strict(),
   stages: external_exports.object({
-    baseline: ImmutableReleaseRefSchema,
-    adaptation: ImmutableReleaseRefSchema,
-    refiner: ImmutableReleaseRefSchema,
-    candidateAdaptation: ImmutableReleaseRefSchema,
-    candidate: ImmutableReleaseRefSchema,
-    comparison: ImmutableReleaseRefSchema
+    baseline: ImmutableReleaseRefSchema2,
+    adaptation: ImmutableReleaseRefSchema2,
+    refiner: ImmutableReleaseRefSchema2,
+    candidateAdaptation: ImmutableReleaseRefSchema2,
+    candidate: ImmutableReleaseRefSchema2,
+    comparison: ImmutableReleaseRefSchema2
   }).strict(),
   usage: ModelEvaluationUsageSchema,
   quality: external_exports.object({
@@ -6336,14 +6671,14 @@ var ModelEvaluationReceiptSchema = external_exports.object({
     observedSpendUsd: external_exports.number().nonnegative(),
     enforced: external_exports.boolean()
   }).strict(),
-  evidenceSnapshot: ImmutableReleaseRefSchema,
+  evidenceSnapshot: ImmutableReleaseRefSchema2,
   lineage: external_exports.object({
     adaptationEvidenceHash: ReleaseHashSchema,
     refinerInputHash: ReleaseHashSchema,
     refinerOutcomeHash: ReleaseHashSchema,
     validationHash: ReleaseHashSchema,
     applyReceiptHash: ReleaseHashSchema,
-    candidateRelease: ImmutableReleaseRefSchema,
+    candidateRelease: ImmutableReleaseRefSchema2,
     valid: external_exports.boolean()
   }).strict(),
   invalidReasons: external_exports.array(external_exports.string().trim().min(1).max(2e3)).max(100),
@@ -6373,8 +6708,8 @@ var ModelEvaluationStopReceiptSchema = external_exports.object({
   ]),
   reason: external_exports.string().trim().min(1).max(5e3),
   stoppedAfter: external_exports.literal("refiner"),
-  baselineHarness: ImmutableReleaseRefSchema,
-  candidateHarness: ImmutableReleaseRefSchema,
+  baselineHarness: ImmutableReleaseRefSchema2,
+  candidateHarness: ImmutableReleaseRefSchema2,
   refiner: external_exports.object({
     id: ReleaseIdSchema,
     contentHash: ReleaseHashSchema,
@@ -6386,7 +6721,7 @@ var ModelEvaluationStopReceiptSchema = external_exports.object({
     observedSpendUsd: external_exports.number().nonnegative(),
     enforced: external_exports.boolean()
   }).strict(),
-  evidenceSnapshot: ImmutableReleaseRefSchema,
+  evidenceSnapshot: ImmutableReleaseRefSchema2,
   attempts: external_exports.array(ModelEvaluationAttemptSchema).max(1e4),
   contentHash: ReleaseHashSchema
 }).strict();
@@ -6443,7 +6778,7 @@ var ModelRunSchema = external_exports.object({
   ]).nullable(),
   destinationId: ReleaseIdSchema.nullable(),
   taskset: VersionedReleaseRefSchema,
-  harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
+  harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
   quote: external_exports.object({
     maximumSpendUsd: external_exports.number().nonnegative(),
     hourlyCostUsd: external_exports.number().nonnegative().nullable()
@@ -6511,14 +6846,14 @@ var ModelRunSchema = external_exports.object({
 });
 
 // ../../packages/contracts/src/training-policy-optimization.ts
-var IdSchema6 = external_exports.string().trim().min(1).max(240);
-var HashSchema5 = external_exports.string().trim().min(8).max(256);
+var IdSchema7 = external_exports.string().trim().min(1).max(240);
+var HashSchema6 = external_exports.string().trim().min(8).max(256);
 var RftLossMethodSchema = external_exports.enum(["grpo", "dapo", "gspo-token"]);
 var TrainingModelRefSchema = external_exports.object({
-  id: IdSchema6,
+  id: IdSchema7,
   revision: external_exports.string().trim().min(1).max(256),
   tokenizerRevision: external_exports.string().trim().min(1).max(256),
-  chatTemplateHash: HashSchema5
+  chatTemplateHash: HashSchema6
 });
 var PolicyOptimizationBudgetSchema = external_exports.object({
   maxRollouts: external_exports.number().int().positive().max(1e6),
@@ -6550,13 +6885,31 @@ var PolicyOptimizerSchema = external_exports.discriminatedUnion("method", [
   GrpoOptimizerSchema,
   PpoOptimizerSchema
 ]);
+var LearnedPreferenceRewardBindingSchema = external_exports.object({
+  rewardModelVersion: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
+  qualificationReport: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
+  checkpoint: external_exports.object({
+    id: IdSchema7,
+    contentHash: HashSchema6,
+    objectRef: external_exports.string().regex(/^r2:\/\/[A-Za-z0-9._/-]+$/),
+    files: external_exports.array(external_exports.object({
+      path: external_exports.string().trim().min(1).max(512),
+      sizeBytes: external_exports.number().int().positive(),
+      sha256: HashSchema6
+    }).strict()).min(4).max(128)
+  }).strict(),
+  runtime: RewardModelRuntimeSchema,
+  processorRelease: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
+  rewardComposerRelease: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
+  executionReceipt: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict()
+}).strict();
 var PolicyOptimizationContractSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.policyOptimization.v1"),
   policyModel: TrainingModelRefSchema,
   referenceModel: TrainingModelRefSchema,
   dataset: external_exports.object({
-    tasksetId: IdSchema6,
-    tasksetHash: HashSchema5,
+    tasksetId: IdSchema7,
+    tasksetHash: HashSchema6,
     split: external_exports.literal("train"),
     selectionStrategy: external_exports.enum(["stable_hash_top_n", "rft_easy_curriculum_v1"]),
     selectionSeed: external_exports.number().int(),
@@ -6570,13 +6923,14 @@ var PolicyOptimizationContractSchema = external_exports.object({
     concurrency: external_exports.number().int().positive().max(1e3)
   }),
   environment: external_exports.object({
-    id: IdSchema6,
+    id: IdSchema7,
     version: external_exports.string().trim().min(1).max(256),
-    toolContractHash: HashSchema5
+    toolContractHash: HashSchema6
   }),
   reward: external_exports.object({
-    graderId: IdSchema6,
-    graderHash: HashSchema5
+    graderId: IdSchema7,
+    graderHash: HashSchema6,
+    learnedPreference: LearnedPreferenceRewardBindingSchema.nullable().default(null)
   }),
   kl: external_exports.object({
     coefficient: external_exports.number().nonnegative().nullable(),
@@ -7226,6 +7580,70 @@ var PolicyTrainingRecordSchema = external_exports.object({
   input: external_exports.record(external_exports.string(), external_exports.unknown()),
   tags: external_exports.array(TrainingIdSchema).max(100).default([])
 });
+var RewardModelRecipeSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.rewardModelRecipe.v1"),
+  method: external_exports.literal("reward_model"),
+  parameterization: external_exports.literal("lora_with_scalar_head"),
+  runScope: external_exports.enum(["synthetic_smoke", "human_preference"]),
+  baseModel: external_exports.object({
+    id: TrainingIdSchema,
+    revision: external_exports.string().trim().min(1).max(256),
+    tokenizerRevision: external_exports.string().trim().min(1).max(256),
+    processorRevision: external_exports.string().trim().min(1).max(256),
+    chatTemplateHash: TrainingHashSchema
+  }).strict(),
+  tasksetRelease: ImmutableReleaseRefSchema2,
+  preferenceDatasetRelease: ImmutableReleaseRefSchema2,
+  processorRelease: ImmutableReleaseRefSchema2,
+  input: external_exports.object({
+    kind: external_exports.literal("structured_text"),
+    serialization: external_exports.literal("scenario_input_and_candidate_json_v1"),
+    maxCharacters: external_exports.number().int().positive().max(5e5)
+  }).strict().default({
+    kind: "structured_text",
+    serialization: "scenario_input_and_candidate_json_v1",
+    maxCharacters: 32e3
+  }),
+  lora: external_exports.object({
+    rank: external_exports.number().int().positive().max(256),
+    alpha: external_exports.number().positive().max(1024),
+    dropout: external_exports.number().min(0).max(1),
+    targetModules: external_exports.array(TrainingIdSchema).min(1).max(100)
+  }).strict(),
+  heads: external_exports.object({
+    scalar: external_exports.literal("pooled_hidden_state_linear"),
+    bucket: external_exports.enum(["none", "three_class"]).default("three_class")
+  }).strict(),
+  loss: external_exports.object({
+    ranking: external_exports.literal("bradley_terry"),
+    rankingWeight: external_exports.number().positive(),
+    bucketWeight: external_exports.number().nonnegative(),
+    tieWeight: external_exports.number().nonnegative()
+  }).strict(),
+  optimizer: external_exports.object({
+    learningRate: external_exports.number().positive(),
+    maxSteps: external_exports.number().int().positive().max(1e5),
+    batchSize: external_exports.number().int().positive().max(1e4),
+    gradientAccumulationSteps: external_exports.number().int().positive().max(1e4),
+    seed: external_exports.number().int(),
+    checkpointEverySteps: external_exports.number().int().positive().max(1e5)
+  }).strict(),
+  resourceLimits: external_exports.object({
+    wallTimeMs: external_exports.number().int().positive().max(24 * 60 * 60 * 1e3),
+    maxExamples: external_exports.number().int().positive().max(1e5),
+    maxInputCharacters: external_exports.number().int().positive().max(5e5).default(32e3),
+    maxImagePixels: external_exports.number().int().positive().max(1e8).optional(),
+    maximumSpendUsd: external_exports.number().nonnegative().max(1e5)
+  }).strict()
+}).superRefine((recipe, context) => {
+  if (recipe.runScope === "synthetic_smoke" && (recipe.optimizer.maxSteps > 100 || recipe.resourceLimits.maximumSpendUsd > 10)) {
+    context.addIssue({
+      code: "custom",
+      path: ["resourceLimits"],
+      message: "Synthetic-smoke Reward Model runs are limited to 100 steps and USD 10."
+    });
+  }
+});
 var RftRecipeSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.rftRecipe.v1"),
   method: external_exports.literal("grpo"),
@@ -7268,7 +7686,8 @@ var RftRecipeSchema = external_exports.object({
     graderHash: TrainingHashSchema,
     environmentId: TrainingIdSchema,
     environmentVersion: external_exports.string().trim().min(1).max(256),
-    toolContractHash: TrainingHashSchema
+    toolContractHash: TrainingHashSchema,
+    learnedPreference: LearnedPreferenceRewardBindingSchema.nullable().optional()
   }),
   resourceLimits: external_exports.object({
     wallTimeMs: external_exports.number().int().positive().max(24 * 60 * 60 * 1e3),
@@ -7446,52 +7865,15 @@ var ModelRunPresetSchema = external_exports.enum([
   "custom",
   "small_experiment"
 ]);
-var ModelProjectSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.modelProject.v1"),
-  id: TrainingIdSchema,
-  profileId: TrainingIdSchema,
-  name: external_exports.string().trim().min(1).max(200),
-  objective: external_exports.string().trim().max(5e3).nullable(),
-  defaultBaseModel: BaseModelPreferenceSchema.nullable(),
-  defaultDestinationId: TrainingDestinationIdSchema.nullable(),
-  createdAt: TrainingTimestampSchema,
-  updatedAt: TrainingTimestampSchema
-});
-var ModelRunDraftSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.modelRunDraft.v1"),
-  id: TrainingIdSchema,
-  profileId: TrainingIdSchema,
-  modelId: TrainingIdSchema,
-  status: external_exports.enum(["draft", "ready_to_run", "launched", "cancelled"]),
-  title: external_exports.string().trim().min(1).max(200),
-  datasetMode: external_exports.enum(["existing", "build"]).nullable(),
-  tasksetRef: external_exports.object({
-    id: TrainingIdSchema,
-    revision: external_exports.number().int().positive(),
-    contentHash: TrainingHashSchema
-  }).nullable(),
-  harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
-  tasksetRelease: ImmutableReleaseRefSchema.nullable().optional(),
-  datasetCreationId: TrainingIdSchema.nullable(),
-  buildIntent: DatasetBuildIntentSchema.nullable(),
-  buildSpecification: DatasetBuildSpecificationSchema.nullable(),
-  baseModel: BaseModelPreferenceSchema.nullable(),
-  method: TrainingMethodSchema.nullable(),
-  destinationId: TrainingDestinationIdSchema.nullable(),
-  managedRolloutPlacement: external_exports.enum(["local", "remote"]).optional(),
-  runPreset: ModelRunPresetSchema.nullable(),
-  recipe: TrainingRecipeSchema.nullable(),
-  createdAt: TrainingTimestampSchema,
-  updatedAt: TrainingTimestampSchema
-});
+var ModelProjectSchema2 = ModelProjectSchema;
 var TrainingPlanSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.trainingPlan.v1"),
   id: TrainingIdSchema,
   modelId: TrainingIdSchema,
   tasksetId: TrainingIdSchema,
   tasksetHash: TrainingHashSchema,
-  harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
-  modelImprovementQualification: ImmutableReleaseRefSchema.nullable().optional(),
+  harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
+  modelImprovementQualification: ImmutableReleaseRefSchema2.nullable().optional(),
   destinationId: TrainingDestinationIdSchema,
   recipe: TrainingRecipeSchema,
   environmentPlacement: external_exports.enum([
@@ -7569,8 +7951,8 @@ var TrainingApprovalSchema = external_exports.object({
   id: TrainingIdSchema,
   planId: TrainingIdSchema,
   bundleHash: TrainingHashSchema,
-  harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
-  modelImprovementQualification: ImmutableReleaseRefSchema.nullable().optional(),
+  harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
+  modelImprovementQualification: ImmutableReleaseRefSchema2.nullable().optional(),
   destinationId: TrainingDestinationIdSchema,
   modelId: TrainingIdSchema,
   method: TrainingMethodSchema,
@@ -7579,6 +7961,21 @@ var TrainingApprovalSchema = external_exports.object({
   approvedBy: TrainingIdSchema,
   approvedAt: TrainingTimestampSchema
 });
+var TrainingJobSourceSnapshotSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.trainingJobSourceSnapshot.v1"),
+  modelProjectId: TrainingIdSchema,
+  sourceProjectRevision: external_exports.number().int().positive(),
+  profileId: TrainingIdSchema,
+  taskset: external_exports.object({
+    id: TrainingIdSchema,
+    revision: external_exports.number().int().positive(),
+    contentHash: TrainingHashSchema
+  }).strict(),
+  tasksetRelease: ImmutableReleaseRefSchema2,
+  harnessRelease: ImmutableReleaseRefSchema2,
+  baseModel: BaseModelPreferenceSchema,
+  method: TrainingMethodSchema
+}).strict();
 var TrainingJobStatusSchema = external_exports.enum([
   "queued",
   "starting",
@@ -7657,6 +8054,7 @@ var PolicyOptimizationMetricSchema = external_exports.object({
   learningRate: external_exports.number().nonnegative().nullable().default(null),
   policyLoss: external_exports.number().nullable(),
   valueLoss: external_exports.number().nullable(),
+  gradientNorm: external_exports.number().nonnegative().nullable().default(null),
   meanReward: external_exports.number().nullable(),
   meanReturn: external_exports.number().nullable(),
   kl: external_exports.number().nullable(),
@@ -7668,6 +8066,7 @@ var PolicyOptimizationMetricSchema = external_exports.object({
   inputTokens: external_exports.number().int().nonnegative(),
   outputTokens: external_exports.number().int().nonnegative(),
   environmentExecutions: external_exports.number().int().nonnegative(),
+  trajectoryCount: external_exports.number().int().nonnegative().nullable().default(null),
   costUsd: external_exports.number().nonnegative().nullable()
 });
 var ManagedTrainingRunEvidenceSchema = external_exports.object({
@@ -7861,11 +8260,20 @@ var TrainingActivityResponseSchema = external_exports.object({
   revision: TrainingHashSchema,
   generatedAt: TrainingTimestampSchema
 });
+var TasksetOperationalStateSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetOperationalState.v1"),
+  tasksetId: TrainingIdSchema,
+  attempts: external_exports.array(TaskAttemptResultSchema),
+  artifacts: external_exports.array(TaskAttemptArtifactSchema),
+  grades: external_exports.array(GradeResultSchema),
+  generatedAt: TrainingTimestampSchema
+});
 var TrainingStateResponseSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.trainingState.v1"),
   profileId: TrainingIdSchema,
   sources: external_exports.array(TrainingSourceRefSchema),
   creations: external_exports.array(TaskCreationSnapshotSchema),
+  tasksetDrafts: external_exports.array(TasksetDraftSchema).default([]),
   tasksets: external_exports.array(TasksetSchema),
   benchmarkRuns: external_exports.array(external_exports.custom()).default([]),
   benchmarkComparisons: external_exports.array(external_exports.custom()).default([]),
@@ -7876,10 +8284,11 @@ var TrainingStateResponseSchema = external_exports.object({
   candidates: external_exports.array(TaskCandidateSchema),
   minerConfig: TaskMinerConfigSchema,
   minerRuns: external_exports.array(TaskMinerRunSchema).default([]),
-  modelProjects: external_exports.array(ModelProjectSchema).default([]),
-  modelRunDrafts: external_exports.array(ModelRunDraftSchema).default([]),
+  modelProjects: external_exports.array(ModelProjectSchema2).default([]),
   modelVersions: external_exports.array(ModelVersionSchema).default([]),
   modelRuns: external_exports.array(ModelRunSchema).default([]),
+  rewardModelVersions: external_exports.array(RewardModelVersionSchema).default([]),
+  rewardModelRuns: external_exports.array(RewardModelRunSchema).default([]),
   modelTasksets: external_exports.array(TasksetSchema).default([]),
   plans: external_exports.array(TrainingPlanSchema),
   bundles: external_exports.array(TrainingBundleManifestSchema),
@@ -7907,10 +8316,10 @@ var LearningSignalKindSchema = external_exports.enum([
   "infrastructure_failure"
 ]);
 var LearningSignalLineageSchema = external_exports.object({
-  datasetRelease: ImmutableReleaseRefSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  evidenceSetRelease: ImmutableReleaseRefSchema.nullable(),
-  profileRelease: ImmutableReleaseRefSchema.nullable(),
+  datasetRelease: ImmutableReleaseRefSchema2,
+  harnessRelease: ImmutableReleaseRefSchema2,
+  evidenceSetRelease: ImmutableReleaseRefSchema2.nullable(),
+  profileRelease: ImmutableReleaseRefSchema2.nullable(),
   model: external_exports.object({
     source: external_exports.string().trim().min(1).max(200),
     revision: external_exports.string().trim().min(1).max(500),
@@ -8072,9 +8481,9 @@ var TrainingEngineBindingSchema = external_exports.object({
 var HarnessRunManifestContentSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.harnessRunManifest.v1"),
   id: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  datasetRelease: ImmutableReleaseRefSchema,
-  evidenceSets: external_exports.array(ImmutableReleaseRefSchema).max(1e4),
+  harnessRelease: ImmutableReleaseRefSchema2,
+  datasetRelease: ImmutableReleaseRefSchema2,
+  evidenceSets: external_exports.array(ImmutableReleaseRefSchema2).max(1e4),
   model: external_exports.object({
     source: external_exports.string().trim().min(1).max(200),
     revision: external_exports.string().trim().min(1).max(500),
@@ -8105,9 +8514,9 @@ var HarnessRunManifestSchema = HarnessRunManifestContentSchema.extend({
 var ResolvedTrainingBundleContentSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.resolvedTrainingBundle.v1"),
   projection: external_exports.literal("trainer"),
-  harnessRelease: ImmutableReleaseRefSchema,
-  datasetRelease: ImmutableReleaseRefSchema,
-  evidenceSetRelease: ImmutableReleaseRefSchema.nullable(),
+  harnessRelease: ImmutableReleaseRefSchema2,
+  datasetRelease: ImmutableReleaseRefSchema2,
+  evidenceSetRelease: ImmutableReleaseRefSchema2.nullable(),
   files: external_exports.array(
     external_exports.object({
       path: external_exports.string().trim().min(1).max(2e3),
@@ -8175,7 +8584,7 @@ var HarnessGraderEvidenceSchema = external_exports.object({
 }).strict();
 var HarnessRunTraceSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.harnessRunTrace.v1"),
-  manifest: ImmutableReleaseRefSchema,
+  manifest: ImmutableReleaseRefSchema2,
   taskId: ReleaseIdSchema,
   seed: external_exports.string().trim().min(1).max(500),
   events: external_exports.array(HarnessRuntimeEventReceiptSchema).max(1e6),
@@ -8260,6 +8669,28 @@ var HarnessSourceManifestSchema = external_exports.object({
   }
 });
 
+// ../../packages/contracts/src/refiner-history.ts
+var RefinerHistoryPayloadSchema = external_exports.object({
+  rootPath: external_exports.string(),
+  sourcePath: external_exports.string(),
+  binding: RefinerBindingSchema,
+  currentRelease: RefinerReleaseSchema,
+  releases: external_exports.array(RefinerReleaseSchema),
+  transitions: external_exports.array(RefinerTransitionReceiptSchema)
+}).strict();
+var UpdateRefinerProfileRequestSchema = external_exports.object({
+  profile: RefinerReviewProfileSchema,
+  activate: external_exports.boolean().default(true),
+  reason: external_exports.string().trim().min(1).max(1e4),
+  actor: external_exports.string().trim().min(1).max(240).default("local-user"),
+  authoringSkillHash: external_exports.string().regex(/^[a-f0-9]{64}$/).nullable().default(null)
+}).strict();
+var ActivateRefinerReleaseRequestSchema = external_exports.object({
+  release: ImmutableReleaseRefSchema,
+  reason: external_exports.string().trim().min(1).max(1e4),
+  actor: external_exports.string().trim().min(1).max(240).default("local-user")
+}).strict();
+
 // ../../packages/contracts/src/training-platform.ts
 var TrainingEngineCapabilitiesSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.trainingEngineCapabilities.v1"),
@@ -8388,6 +8819,8 @@ var AdapterValidationReceiptSchema = external_exports.object({
 var TrainingExecutionRefSchema = external_exports.object({
   runId: ReleaseIdSchema,
   adapterId: ReleaseIdSchema,
+  protocolVersion: external_exports.enum(["openpond.training.v2", "adapter.native.v1"]).default("adapter.native.v1"),
+  routeFamily: external_exports.enum(["training_v2", "adapter_native"]).default("adapter_native"),
   routeId: ReleaseIdSchema.optional(),
   providerJobId: external_exports.string().trim().min(1).max(1e3).nullable(),
   tenantId: ReleaseIdSchema.optional(),