openpond 0.0.66 → 0.0.68

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

@@ -10,23 +10,29 @@ import {
   SandboxTemplateValidationDiagnosticSchema,
   ToolDeclarationSchema,
   validateConnectedAppToolCallRequest
-} from "./chunk-RN7MVPC6.js";
+} from "./chunk-MUS7KPXK.js";
 import "./chunk-3KLQ52B2.js";
 import "./chunk-W5GKHH77.js";
 import {
   loadOpenPondProfileState,
   parseProfileSkillMarkdown
-} from "./chunk-EJURKADM.js";
+} from "./chunk-N6FKRVAT.js";
 import "./chunk-JIEUB6OS.js";
-import "./chunk-BYAPLT37.js";
-import {
-  external_exports
-} from "./chunk-WYDVQOBL.js";
+import "./chunk-Z2ZWHU7O.js";
+import "./chunk-X7ZG4TSW.js";
 import {
   openPondConfigDirectory,
   updatePrivateJsonFile
 } from "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
+import {
+  ImmutableReleaseRefSchema,
+  RefinerBindingSchema,
+  RefinerReleaseSchema,
+  RefinerReviewProfileSchema,
+  RefinerTransitionReceiptSchema,
+  external_exports
+} from "./chunk-MLWNI3WG.js";
 import {
   parseBooleanOption
 } from "./chunk-MUMPWI4O.js";
@@ -3178,7 +3184,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 +5167,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 +5203,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 +5223,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 +5272,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 +5439,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 +5538,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 +5554,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 +5619,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 +5836,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 +5983,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 +6149,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 +6167,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 +6203,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 +6225,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 +6245,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 +6254,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 +6348,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 +6385,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 +6410,131 @@ 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,
+  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 +6636,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 +6669,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 +6706,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 +6719,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 +6776,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 +6844,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 +6883,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(),
+  qualificationKind: external_exports.enum(["synthetic_smoke", "human_heldout"])
+}).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 +6921,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 +7578,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 +7684,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),
@@ -7450,10 +7867,44 @@ var ModelProjectSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.modelProject.v1"),
   id: TrainingIdSchema,
   profileId: TrainingIdSchema,
+  revision: external_exports.number().int().positive().default(1),
   name: external_exports.string().trim().min(1).max(200),
   objective: external_exports.string().trim().max(5e3).nullable(),
   defaultBaseModel: BaseModelPreferenceSchema.nullable(),
   defaultDestinationId: TrainingDestinationIdSchema.nullable(),
+  hosted: external_exports.object({
+    schemaVersion: external_exports.literal("openpond.hostedModelProjectLink.v1"),
+    teamId: TrainingIdSchema,
+    projectId: TrainingIdSchema,
+    portableProjectId: TrainingIdSchema,
+    revision: external_exports.number().int().positive(),
+    etag: TrainingHashSchema,
+    syncedSourceRevision: external_exports.number().int().positive(),
+    syncedAt: TrainingTimestampSchema,
+    tasksets: external_exports.array(
+      external_exports.object({
+        localTasksetId: TrainingIdSchema,
+        releaseId: TrainingIdSchema,
+        releaseRevision: external_exports.number().int().positive(),
+        releaseHash: TrainingHashSchema,
+        hostedTasksetId: TrainingIdSchema,
+        syncedAt: TrainingTimestampSchema
+      }).strict()
+    ).max(1e4).default([])
+  }).strict().nullable().default(null),
+  tasksetSyncs: external_exports.array(
+    external_exports.object({
+      localTasksetId: TrainingIdSchema,
+      releaseId: TrainingIdSchema,
+      releaseRevision: external_exports.number().int().positive(),
+      releaseHash: TrainingHashSchema,
+      state: external_exports.enum(["syncing", "synced", "sync_failed"]),
+      hostedTasksetId: TrainingIdSchema.nullable().default(null),
+      lastAttemptAt: TrainingTimestampSchema,
+      syncedAt: TrainingTimestampSchema.nullable().default(null),
+      lastError: external_exports.string().trim().min(1).max(5e3).nullable().default(null)
+    }).strict()
+  ).max(1e4).default([]),
   createdAt: TrainingTimestampSchema,
   updatedAt: TrainingTimestampSchema
 });
@@ -7470,8 +7921,8 @@ var ModelRunDraftSchema = external_exports.object({
     revision: external_exports.number().int().positive(),
     contentHash: TrainingHashSchema
   }).nullable(),
-  harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
-  tasksetRelease: ImmutableReleaseRefSchema.nullable().optional(),
+  harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
+  tasksetRelease: ImmutableReleaseRefSchema2.nullable().optional(),
   datasetCreationId: TrainingIdSchema.nullable(),
   buildIntent: DatasetBuildIntentSchema.nullable(),
   buildSpecification: DatasetBuildSpecificationSchema.nullable(),
@@ -7490,8 +7941,8 @@ var TrainingPlanSchema = external_exports.object({
   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 +8020,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,
@@ -7861,11 +8312,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([]),
@@ -7880,6 +8340,8 @@ var TrainingStateResponseSchema = external_exports.object({
   modelRunDrafts: external_exports.array(ModelRunDraftSchema).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 +8369,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 +8534,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 +8567,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 +8637,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 +8722,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"),