openpond 0.0.69 → 0.1.1

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

@@ -1,4 +1,5 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import "./chunk-W5GKHH77.js";
 import {
   CONNECTED_APP_PROVIDER_TOOL_NAMES,
   CapabilityRequirementSchema,
@@ -16,9 +17,13 @@ import {
   SandboxTemplateValidationDiagnosticSchema,
   ToolDeclarationSchema,
   validateConnectedAppToolCallRequest
-} from "./chunk-BLFIIAWZ.js";
+} from "./chunk-NTK22KJD.js";
+import {
+  ContinualBenchIssuePacketSchema,
+  ContinualBenchPanelRoleSchema,
+  ContinualBenchmarkProtocolReleaseSchema
+} from "./chunk-R3C3MNSI.js";
 import "./chunk-BVY5JYM6.js";
-import "./chunk-W5GKHH77.js";
 import {
   loadOpenPondProfileState,
   parseProfileSkillMarkdown
@@ -2060,6 +2065,7 @@ var AppPreferencesSchema = external_exports.object({
   defaultNewProjectDirectory: external_exports.string().trim().max(4096).default(""),
   defaultTeamId: external_exports.string().trim().max(191).nullable().default(null),
   advancedWorkspaceControls: external_exports.boolean().default(false),
+  steerActiveResponses: external_exports.boolean().default(true),
   contextCompaction: ContextCompactionPreferencesSchema.optional().default(
     () => ContextCompactionPreferencesSchema.parse({})
   ),
@@ -3438,6 +3444,9 @@ var UsageRecordsQuerySchema = UsageSummaryQuerySchema.extend({
   turnId: external_exports.string().trim().min(1).optional(),
   limit: external_exports.number().int().positive().max(500).default(100)
 });
+var UsageTurnCacheQuerySchema = external_exports.object({
+  sessionId: external_exports.string().trim().min(1)
+});
 var UsageBreakdownBaseSchema = external_exports.object({
   requests: external_exports.number().int().nonnegative(),
   promptTokens: external_exports.number().int().nonnegative().nullable(),
@@ -3560,6 +3569,22 @@ var UsageRecordsResponseSchema = external_exports.object({
   hasMore: external_exports.boolean(),
   records: external_exports.array(ModelUsageRecordSchema)
 });
+var UsageTurnCacheSummarySchema = external_exports.object({
+  turnId: external_exports.string().trim().min(1),
+  requests: external_exports.number().int().nonnegative(),
+  cacheTelemetryRequests: external_exports.number().int().nonnegative(),
+  cachedPromptTokens: external_exports.number().int().nonnegative().nullable(),
+  uncachedPromptTokens: external_exports.number().int().nonnegative().nullable(),
+  cacheWritePromptTokens: external_exports.number().int().nonnegative().nullable(),
+  cacheHitRate: external_exports.number().min(0).max(1).nullable(),
+  cacheTelemetryCoverage: external_exports.number().min(0).max(1),
+  providers: external_exports.array(UsageProviderSchema)
+});
+var UsageTurnCacheResponseSchema = external_exports.object({
+  generatedAt: external_exports.string().trim().min(1),
+  sessionId: external_exports.string().trim().min(1),
+  turns: external_exports.array(UsageTurnCacheSummarySchema)
+});
 var UsageSignalTypeSchema = external_exports.enum([
   "usage_spike",
   "model_usage_spike",
@@ -3757,6 +3782,7 @@ var UpdateAppPreferencesRequestSchema = external_exports.object({
   defaultNewProjectDirectory: external_exports.string().trim().max(4096).optional(),
   defaultTeamId: external_exports.string().trim().max(191).nullable().optional(),
   advancedWorkspaceControls: external_exports.boolean().optional(),
+  steerActiveResponses: external_exports.boolean().optional(),
   contextCompaction: ContextCompactionPreferencesSchema.optional(),
   training: TrainingPreferencesSchema.optional(),
   sidebarWidth: external_exports.number().int().min(244).max(560).optional(),
@@ -4399,6 +4425,7 @@ var HostedSavedWorkResponseSchema = external_exports.object({
 var CreateHostedSavedWorkRequestSchema = external_exports.object({
   clientRequestId: external_exports.string().trim().min(1).max(191),
   sourceTurnId: external_exports.string().trim().min(1).max(191).nullable().optional(),
+  targetSessionId: external_exports.string().trim().min(1).max(191).nullable().optional(),
   name: external_exports.string().trim().min(1).max(180),
   prompt: external_exports.string().trim().min(1).max(2e4),
   recurrence: SavedWorkRecurrenceSchema,
@@ -4412,6 +4439,64 @@ var UpdateHostedSavedWorkRequestSchema = external_exports.union([
     recurrence: SavedWorkRecurrenceSchema
   })
 ]);
+var ChatWorkflowRunStatusSchema = external_exports.enum([
+  "queued",
+  "running",
+  "succeeded",
+  "failed"
+]);
+var ChatWorkflowSchema = external_exports.object({
+  id: external_exports.string(),
+  sessionId: external_exports.string(),
+  sessionTitle: external_exports.string(),
+  sourceTurnId: external_exports.string().nullable(),
+  name: external_exports.string(),
+  prompt: external_exports.string(),
+  recurrence: SavedWorkRecurrenceSchema,
+  enabled: external_exports.boolean(),
+  nextRunAt: external_exports.string().nullable(),
+  lastRunAt: external_exports.string().nullable(),
+  lastRunStatus: ChatWorkflowRunStatusSchema.nullable(),
+  lastRunId: external_exports.string().nullable(),
+  lastError: external_exports.string().nullable(),
+  scheduledRunCount: external_exports.number().int().nonnegative(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var ChatWorkflowRunSchema = external_exports.object({
+  id: external_exports.string(),
+  workflowId: external_exports.string(),
+  sessionId: external_exports.string(),
+  scheduledFor: external_exports.string(),
+  trigger: external_exports.enum(["schedule", "manual"]),
+  status: ChatWorkflowRunStatusSchema,
+  turnId: external_exports.string().nullable(),
+  error: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  startedAt: external_exports.string().nullable(),
+  completedAt: external_exports.string().nullable(),
+  updatedAt: external_exports.string()
+});
+var CreateChatWorkflowRequestSchema = external_exports.object({
+  sessionId: external_exports.string().trim().min(1).max(191),
+  sourceTurnId: external_exports.string().trim().min(1).max(191).nullable().optional(),
+  name: external_exports.string().trim().min(1).max(180),
+  prompt: external_exports.string().trim().min(1).max(2e4),
+  recurrence: SavedWorkRecurrenceSchema
+});
+var UpdateChatWorkflowRequestSchema = external_exports.union([
+  external_exports.object({ enabled: external_exports.boolean() }),
+  external_exports.object({
+    name: external_exports.string().trim().min(1).max(180),
+    prompt: external_exports.string().trim().min(1).max(2e4),
+    recurrence: SavedWorkRecurrenceSchema
+  })
+]);
+var ChatWorkflowsResponseSchema = external_exports.object({
+  workflows: external_exports.array(ChatWorkflowSchema),
+  runs: external_exports.array(ChatWorkflowRunSchema),
+  asOf: external_exports.string()
+});
 
 // ../../packages/contracts/src/team-chat.ts
 var MetadataSchema2 = external_exports.record(external_exports.string(), external_exports.unknown());
@@ -5631,6 +5716,32 @@ var GraderSpecSchema = external_exports.union([
   HumanGraderSpecSchema,
   CustomVerifierGraderSpecSchema
 ]);
+var TasksetGraderSourceSchema = external_exports.object({
+  graderId: IdSchema4.nullable(),
+  path: external_exports.string().trim().min(1).max(1e3),
+  language: external_exports.enum(["javascript", "typescript", "python", "json", "text"]),
+  content: external_exports.string().max(2e6),
+  sha256: HashSchema3,
+  declaredSha256: HashSchema3.nullable(),
+  integrity: external_exports.enum(["verified", "unverified", "mismatch"])
+});
+var TasksetGraderRuntimeSchema = external_exports.object({
+  protocolVersion: external_exports.string().trim().min(1).max(200),
+  module: external_exports.string().trim().min(1).max(1e3),
+  moduleSha256: HashSchema3,
+  command: external_exports.array(external_exports.string().max(2e3)).max(100),
+  cwd: external_exports.string().trim().min(1).max(4e3),
+  maxTurns: external_exports.number().int().positive().max(100)
+});
+var TasksetGraderDetailsResponseSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetGraderDetails.v1"),
+  taskset: VersionedReleaseRefSchema,
+  sourceTasksetId: IdSchema4,
+  graders: external_exports.array(GraderSpecSchema).max(1e3),
+  runtime: TasksetGraderRuntimeSchema.nullable(),
+  sources: external_exports.array(TasksetGraderSourceSchema).max(1e3),
+  unavailableReason: external_exports.string().max(2e3).nullable()
+});
 var GraderFixtureLabelSchema = external_exports.enum([
   "positive",
   "negative",
@@ -5774,6 +5885,11 @@ var TrainingMethodReadinessSchema = external_exports.object({
   reasonCodes: external_exports.array(TrainingMethodReadinessReasonCodeSchema).default([]),
   reasons: external_exports.array(external_exports.string().trim().min(1).max(5e3)).default([])
 });
+var TasksetReadinessFindingSchema = external_exports.object({
+  code: IdSchema4,
+  message: external_exports.string().trim().min(1).max(5e3),
+  path: external_exports.string().trim().max(2e3).nullable()
+});
 var TasksetReadinessReportSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.tasksetReadiness.v1"),
   tasksetId: IdSchema4,
@@ -5785,7 +5901,8 @@ var TasksetReadinessReportSchema = external_exports.object({
   compatibleDestinationClasses: external_exports.array(
     external_exports.enum(["export", "custom", "hosted_managed"])
   ),
-  blockers: external_exports.array(external_exports.object({ code: IdSchema4, message: external_exports.string().trim().min(1).max(5e3), path: external_exports.string().trim().max(2e3).nullable() })).default([]),
+  blockers: external_exports.array(TasksetReadinessFindingSchema).default([]),
+  advisories: external_exports.array(TasksetReadinessFindingSchema).default([]),
   warnings: external_exports.array(external_exports.string().trim().min(1).max(5e3)).default([]),
   generatedAt: TimestampSchema4
 });
@@ -6344,6 +6461,287 @@ var CorrelatedTelemetryReceiptSchema = external_exports.object({
   contentHash: ReleaseHashSchema
 }).strict();
 
+// ../../packages/contracts/src/model-comparisons.ts
+var ModelComparisonSeriesStatusSchema = external_exports.enum(["draft", "active", "completed", "archived"]);
+var ModelComparisonEntryStatusSchema = external_exports.enum([
+  "draft",
+  "ready",
+  "queued",
+  "running",
+  "candidate",
+  "accepted",
+  "rejected",
+  "no_signal",
+  "failed",
+  "cancelled"
+]);
+var ModelComparisonEntryRoleSchema = external_exports.enum([
+  "seed",
+  "daily_residual",
+  "rank_candidate",
+  "weekly_rollup",
+  "full_refresh"
+]);
+var ModelComparisonParentRuleSchema = external_exports.enum([
+  "base_model",
+  "previous_release",
+  "seed_release",
+  "accepted_daily_head",
+  "accepted_seed"
+]);
+var ModelComparisonTaskSourceSchema = external_exports.enum([
+  "seed_taskset",
+  "nightly_selection",
+  "daily_cohort_union",
+  "eligible_task_pool"
+]);
+var ModelComparisonEvidenceSourceSchema = external_exports.enum([
+  "live_client",
+  "evaluation_attempt",
+  "replay_evidence",
+  "manual"
+]);
+var ModelComparisonScheduleEntrySchema = external_exports.object({
+  id: ReleaseIdSchema,
+  ordinal: external_exports.number().int().nonnegative(),
+  label: external_exports.string().trim().min(1).max(100),
+  role: ModelComparisonEntryRoleSchema,
+  parentRule: ModelComparisonParentRuleSchema,
+  taskSource: ModelComparisonTaskSourceSchema,
+  trainableRank: external_exports.number().int().positive().max(1024),
+  minimumTasks: external_exports.number().int().nonnegative().max(1e5),
+  maximumTasks: external_exports.number().int().positive().max(1e5)
+}).strict().superRefine((entry, context) => {
+  if (entry.minimumTasks > entry.maximumTasks) {
+    context.addIssue({ code: "custom", path: ["minimumTasks"], message: "The minimum task count cannot exceed the maximum task count." });
+  }
+  const expected = {
+    seed: { parentRules: ["base_model"], taskSource: "seed_taskset" },
+    daily_residual: { parentRules: ["previous_release", "accepted_daily_head"], taskSource: "nightly_selection" },
+    rank_candidate: { parentRules: ["seed_release"], taskSource: "eligible_task_pool" },
+    weekly_rollup: { parentRules: ["seed_release", "accepted_seed"], taskSource: "daily_cohort_union" },
+    full_refresh: { parentRules: ["base_model"], taskSource: "eligible_task_pool" }
+  };
+  const { parentRules, taskSource } = expected[entry.role];
+  if (!parentRules.includes(entry.parentRule)) {
+    context.addIssue({ code: "custom", path: ["parentRule"], message: `${entry.role} requires parent rule ${parentRules.join(" or ")}.` });
+  }
+  if (entry.taskSource !== taskSource) {
+    context.addIssue({ code: "custom", path: ["taskSource"], message: `${entry.role} requires task source ${taskSource}.` });
+  }
+  if (entry.ordinal === 0 && entry.role !== "seed") {
+    context.addIssue({ code: "custom", path: ["role"], message: "The first series entry must be the seed." });
+  }
+});
+var ModelComparisonAdvancementPolicySchema = external_exports.object({
+  id: ReleaseIdSchema,
+  version: external_exports.number().int().positive(),
+  requireCheckpoint: external_exports.boolean(),
+  requireAppliedOptimizerUpdate: external_exports.boolean(),
+  minimumCurrentCohortMeanImprovement: external_exports.number().finite(),
+  maximumRetainedMeanRegression: external_exports.number().finite().nonnegative(),
+  blockCriticalInvariantRegression: external_exports.boolean(),
+  automaticDailyAdvancement: external_exports.boolean()
+}).strict();
+var ModelComparisonSeriesSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelComparisonSeries.v1"),
+  id: ReleaseIdSchema,
+  profileId: ReleaseIdSchema,
+  modelProjectId: ReleaseIdSchema,
+  name: external_exports.string().trim().min(1).max(500),
+  objective: external_exports.string().trim().min(1).max(2e4),
+  status: ModelComparisonSeriesStatusSchema,
+  revision: external_exports.number().int().positive(),
+  productionBinding: external_exports.object({ role: external_exports.literal("chat_manual"), roleTargetId: ReleaseIdSchema }).strict(),
+  baseModel: external_exports.object({ id: ReleaseIdSchema, revision: external_exports.string().trim().min(1).max(256) }).strict(),
+  seedTaskset: VersionedReleaseRefSchema,
+  eligibleTaskPool: VersionedReleaseRefSchema,
+  evaluationTasksets: external_exports.object({
+    development: VersionedReleaseRefSchema,
+    retained: VersionedReleaseRefSchema,
+    frozenFinal: VersionedReleaseRefSchema
+  }).strict(),
+  grader: ImmutableReleaseRefSchema2,
+  benchmarkProtocol: ContinualBenchmarkProtocolReleaseSchema.nullable().default(null),
+  automaticEvaluation: external_exports.object({ enabled: external_exports.boolean() }).strict().default({ enabled: false }),
+  residualProfile: external_exports.object({
+    profileId: ReleaseIdSchema,
+    serializedEnvelopeRank: external_exports.number().int().positive().max(1024),
+    maximumEnabledRank: external_exports.number().int().positive().max(1024),
+    topology: external_exports.literal("uniform_block_masked")
+  }).strict(),
+  schedule: external_exports.array(ModelComparisonScheduleEntrySchema).min(1).max(1e3),
+  scheduleSealedAt: ReleaseTimestampSchema.nullable(),
+  advancementPolicy: ModelComparisonAdvancementPolicySchema,
+  executionPolicy: external_exports.object({ startWhenReady: external_exports.literal(false) }).strict(),
+  acceptedSeedEntryId: ReleaseIdSchema.nullable(),
+  acceptedDailyHeadEntryId: ReleaseIdSchema.nullable(),
+  promotedBindingId: ReleaseIdSchema.nullable(),
+  createdBy: ReleaseIdSchema,
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((series, context) => {
+  const ordered = [...series.schedule].sort((left, right) => left.ordinal - right.ordinal);
+  if (ordered.some((entry, index) => entry.ordinal !== index)) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Schedule ordinals must be unique and contiguous from zero." });
+  }
+  if (new Set(series.schedule.map((entry) => entry.id)).size !== series.schedule.length || new Set(series.schedule.map((entry) => entry.label)).size !== series.schedule.length) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Schedule ids and labels must be unique." });
+  }
+  if (series.residualProfile.maximumEnabledRank > series.residualProfile.serializedEnvelopeRank) {
+    context.addIssue({ code: "custom", path: ["residualProfile"], message: "Maximum enabled rank cannot exceed the serialized envelope." });
+  }
+  const evaluationCohorts = Object.values(series.evaluationTasksets);
+  if (new Set(evaluationCohorts.map((reference) => `${reference.id}:${reference.revision}:${reference.contentHash}`)).size !== evaluationCohorts.length) {
+    context.addIssue({ code: "custom", path: ["evaluationTasksets"], message: "Development, retained, and frozen-final cohorts require distinct immutable Taskset releases." });
+  }
+  const seed = series.schedule.find((entry) => entry.role === "seed");
+  if (!seed || series.schedule.filter((entry) => entry.role === "seed").length !== 1) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "A series requires exactly one seed entry." });
+    return;
+  }
+  const rankCandidates = series.schedule.filter((entry) => entry.role === "rank_candidate");
+  if (rankCandidates.length === 1) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "A causal rank comparison requires at least two rank candidates." });
+  }
+  if (new Set(rankCandidates.map((entry) => entry.trainableRank)).size !== rankCandidates.length) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Causal rank candidates must use distinct trainable ranks." });
+  }
+  const dailyRank = seed.trainableRank + series.schedule.filter((entry) => entry.role === "daily_residual").reduce((sum, entry) => sum + entry.trainableRank, 0);
+  const branchRanks = [
+    dailyRank,
+    ...series.schedule.filter((entry) => entry.role === "weekly_rollup").map((entry) => seed.trainableRank + entry.trainableRank),
+    ...series.schedule.filter((entry) => entry.role === "rank_candidate").map((entry) => seed.trainableRank + entry.trainableRank),
+    ...series.schedule.filter((entry) => entry.role === "full_refresh").map((entry) => entry.trainableRank)
+  ];
+  if (branchRanks.some((rank) => rank > series.residualProfile.maximumEnabledRank)) {
+    context.addIssue({ code: "custom", path: ["schedule"], message: "A declared branch exceeds the maximum enabled rank." });
+  }
+});
+var ModelComparisonTaskSelectionInputSchema = external_exports.object({
+  source: ModelComparisonEvidenceSourceSchema,
+  taskIds: external_exports.array(ReleaseIdSchema).min(1).max(1e5),
+  observedFrom: ReleaseTimestampSchema,
+  observedTo: ReleaseTimestampSchema,
+  reviewedAt: ReleaseTimestampSchema,
+  reviewedBy: ReleaseIdSchema,
+  sourceTaskset: VersionedReleaseRefSchema
+}).strict();
+var ModelComparisonTaskSelectionSchema = ModelComparisonTaskSelectionInputSchema.extend({
+  derivedFamilyKeys: external_exports.array(ReleaseIdSchema).min(1).max(1e5),
+  familyDerivation: external_exports.object({ algorithm: ReleaseIdSchema, sourceTasksetHash: ReleaseHashSchema }).strict(),
+  selectionHash: ReleaseHashSchema
+}).strict();
+var ModelComparisonParentSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("base_model"), id: ReleaseIdSchema, revision: external_exports.string().trim().min(1).max(256) }).strict(),
+  external_exports.object({ kind: external_exports.literal("model_version"), id: ReleaseIdSchema, contentHash: ReleaseHashSchema }).strict()
+]);
+var ModelComparisonResidualBlockSchema = external_exports.object({
+  id: ReleaseIdSchema,
+  branchOrdinal: external_exports.number().int().nonnegative(),
+  rank: external_exports.number().int().positive().max(1024),
+  offsetStart: external_exports.number().int().nonnegative(),
+  offsetEnd: external_exports.number().int().positive(),
+  optimizationRole: external_exports.enum(["frozen", "trainable"]),
+  artifactLineageId: ReleaseIdSchema.nullable()
+}).strict().superRefine((block, context) => {
+  if (block.offsetEnd - block.offsetStart !== block.rank) {
+    context.addIssue({ code: "custom", path: ["offsetEnd"], message: "Block offsets must span exactly the declared rank." });
+  }
+});
+var ModelComparisonDecisionSchema = external_exports.object({
+  disposition: external_exports.enum(["advance", "hold", "no_signal"]),
+  policy: external_exports.object({ id: ReleaseIdSchema, version: external_exports.number().int().positive() }).strict(),
+  reasonCodes: external_exports.array(ReleaseIdSchema).min(1).max(100),
+  summary: external_exports.string().trim().min(1).max(5e3),
+  decidedBy: ReleaseIdSchema,
+  decidedAt: ReleaseTimestampSchema
+}).strict();
+var ModelComparisonEvaluationLinkSchema = external_exports.object({
+  evaluationRunId: ReleaseIdSchema,
+  modelVersionId: ReleaseIdSchema,
+  taskset: VersionedReleaseRefSchema,
+  grader: ImmutableReleaseRefSchema2,
+  cohortRole: external_exports.enum(["current", "correction", "sibling_verification", "cumulative_known", "development", "retained", "prior_disclosed", "frozen_final"]),
+  panelId: ReleaseIdSchema.nullable().default(null),
+  protocol: external_exports.object({ id: ReleaseIdSchema, revision: external_exports.number().int().positive(), contentHash: ReleaseHashSchema }).strict().nullable().default(null)
+}).strict();
+var ModelComparisonRunAttemptSchema = external_exports.object({
+  attemptOrdinal: external_exports.number().int().positive(),
+  trainingPlanId: ReleaseIdSchema.nullable(),
+  modelRunId: ReleaseIdSchema.nullable(),
+  terminalStatus: external_exports.enum(["failed", "cancelled"]),
+  queuedAt: ReleaseTimestampSchema.nullable(),
+  startedAt: ReleaseTimestampSchema.nullable(),
+  completedAt: ReleaseTimestampSchema
+}).strict();
+var ModelComparisonEntryRefSchema = external_exports.object({
+  seriesId: ReleaseIdSchema,
+  entryId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  ordinal: external_exports.number().int().nonnegative(),
+  releaseHash: ReleaseHashSchema
+}).strict();
+var ModelComparisonSeriesEntrySchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelComparisonSeriesEntry.v1"),
+  id: ReleaseIdSchema,
+  seriesId: ReleaseIdSchema,
+  profileId: ReleaseIdSchema,
+  modelProjectId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  releaseHash: ReleaseHashSchema,
+  ordinal: external_exports.number().int().nonnegative(),
+  label: external_exports.string().trim().min(1).max(100),
+  role: ModelComparisonEntryRoleSchema,
+  branch: external_exports.enum(["daily", "rank_candidate", "weekly_rollup", "full_refresh"]),
+  status: ModelComparisonEntryStatusSchema,
+  parent: ModelComparisonParentSchema,
+  taskset: VersionedReleaseRefSchema,
+  sourceTasksets: external_exports.array(VersionedReleaseRefSchema).min(1).max(1e3),
+  taskSelection: ModelComparisonTaskSelectionSchema.nullable(),
+  trainableRank: external_exports.number().int().positive().max(1024),
+  serializedEnvelopeRank: external_exports.number().int().positive().max(1024),
+  enabledCumulativeRank: external_exports.number().int().positive().max(1024),
+  trainableBlockId: ReleaseIdSchema,
+  residualBlocks: external_exports.array(ModelComparisonResidualBlockSchema).min(1).max(1024),
+  attemptOrdinal: external_exports.number().int().positive().default(1),
+  priorRunAttempts: external_exports.array(ModelComparisonRunAttemptSchema).max(100).default([]),
+  trainingPlanId: ReleaseIdSchema.nullable(),
+  modelRunId: ReleaseIdSchema.nullable(),
+  modelVersionId: ReleaseIdSchema.nullable(),
+  evaluations: external_exports.array(ModelComparisonEvaluationLinkSchema).max(1e5),
+  decision: ModelComparisonDecisionSchema.nullable(),
+  promotionBindingId: ReleaseIdSchema.nullable(),
+  queuedAt: ReleaseTimestampSchema.nullable(),
+  startedAt: ReleaseTimestampSchema.nullable(),
+  completedAt: ReleaseTimestampSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((entry, context) => {
+  const ordered = [...entry.residualBlocks].sort((left, right) => left.offsetStart - right.offsetStart);
+  if (ordered.some((block, index) => block.offsetStart !== (index === 0 ? 0 : ordered[index - 1].offsetEnd))) {
+    context.addIssue({ code: "custom", path: ["residualBlocks"], message: "Residual block offsets must be contiguous from zero." });
+  }
+  const enabled = ordered.at(-1)?.offsetEnd ?? 0;
+  if (enabled !== entry.enabledCumulativeRank || enabled > entry.serializedEnvelopeRank) {
+    context.addIssue({ code: "custom", path: ["enabledCumulativeRank"], message: "Enabled rank must match the block inventory and fit the envelope." });
+  }
+  const trainable = entry.residualBlocks.filter((block) => block.optimizationRole === "trainable");
+  if (trainable.length !== 1 || trainable[0]?.id !== entry.trainableBlockId || trainable[0]?.rank !== entry.trainableRank) {
+    context.addIssue({ code: "custom", path: ["trainableBlockId"], message: "Exactly one block must be trainable during the Run and match trainableRank." });
+  }
+  const attemptOrdinals = entry.priorRunAttempts.map((attempt) => attempt.attemptOrdinal);
+  if (entry.priorRunAttempts.length !== entry.attemptOrdinal - 1 || attemptOrdinals.some((ordinal, index) => ordinal !== index + 1)) {
+    context.addIssue({ code: "custom", path: ["priorRunAttempts"], message: "Prior Run attempts must be a contiguous history before the active attempt." });
+  }
+});
+var ModelComparisonQueueReleaseRequestSchema = external_exports.object({
+  seriesId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  taskSelection: ModelComparisonTaskSelectionInputSchema.nullable(),
+  expectedSeriesRevision: external_exports.number().int().positive()
+}).strict();
+
 // ../../packages/contracts/src/model-lifecycle.ts
 var ModelVersionKindSchema = external_exports.enum([
   "base_reference",
@@ -6383,6 +6781,7 @@ var ModelVersionSchema = external_exports.object({
   status: external_exports.enum(["available", "failed"]),
   baseModel: BaseModelPreferenceSchema,
   taskset: VersionedReleaseRefSchema,
+  comparisonSeriesEntry: ModelComparisonEntryRefSchema.nullable().optional(),
   releaseGraph: external_exports.object({
     resolvedBundleHash: ReleaseHashSchema,
     profileRelease: VersionedReleaseRefSchema,
@@ -6524,10 +6923,10 @@ var RewardModelRunSchema = external_exports.preprocess((value) => {
   completedAt: ReleaseTimestampSchema.nullable(),
   updatedAt: ReleaseTimestampSchema
 }).strict()).superRefine((run, context) => {
-  if (run.status === "succeeded" && (!run.receipt || !run.qualificationReport)) {
+  if (run.status === "succeeded" && !run.receipt) {
     context.addIssue({
       code: "custom",
-      message: "A successful Reward Model Run requires a canonical receipt and qualification report."
+      message: "A successful Reward Model Run requires a canonical receipt."
     });
   }
   if (run.status !== "succeeded" && run.rewardModelVersionId !== null) {
@@ -6725,8 +7124,121 @@ var ModelEvaluationStopReceiptSchema = external_exports.object({
   attempts: external_exports.array(ModelEvaluationAttemptSchema).max(1e4),
   contentHash: ReleaseHashSchema
 }).strict();
-var ModelEvaluationConfigurationSchema = external_exports.object({
-  benchmarkId: ReleaseIdSchema,
+var ConfidenceIntervalSchema = external_exports.object({
+  level: external_exports.literal(0.95),
+  lower: external_exports.number().finite(),
+  upper: external_exports.number().finite()
+}).strict().superRefine((interval, context) => {
+  if (interval.lower > interval.upper) {
+    context.addIssue({ code: "custom", message: "A confidence interval's lower bound cannot exceed its upper bound." });
+  }
+});
+var ModelComparisonBenchmarkReceiptSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelComparisonBenchmarkReceipt.v1"),
+  benchmarkId: external_exports.literal("model-comparison"),
+  target: external_exports.object({
+    kind: external_exports.enum(["base_model", "model_version", "external_reference"]),
+    label: external_exports.string().trim().min(1).max(300),
+    modelVersionId: ReleaseIdSchema.nullable(),
+    model: ChatModelRefSchema.nullable()
+  }).strict(),
+  taskset: VersionedReleaseRefSchema,
+  grader: ImmutableReleaseRefSchema2,
+  sampling: external_exports.object({
+    seeds: external_exports.array(external_exports.number().int()).min(1).max(100),
+    repetitions: external_exports.number().int().positive().max(20)
+  }).strict(),
+  deterministic: external_exports.object({
+    attemptedTaskCount: external_exports.number().int().nonnegative(),
+    completedTaskCount: external_exports.number().int().nonnegative(),
+    passedTaskCount: external_exports.number().int().nonnegative(),
+    failedTaskCount: external_exports.number().int().nonnegative(),
+    meanScore: external_exports.number().finite().nullable(),
+    passRate: external_exports.number().min(0).max(1).nullable(),
+    passRateCi95: ConfidenceIntervalSchema.nullable()
+  }).strict(),
+  judge: external_exports.object({
+    judgeModel: ChatModelRefSchema,
+    judgeRelease: ImmutableReleaseRefSchema2,
+    rubricRelease: ImmutableReleaseRefSchema2,
+    calibrationRelease: ImmutableReleaseRefSchema2,
+    score: external_exports.number().min(0).max(100),
+    scoreCi95: ConfidenceIntervalSchema,
+    comparisonCount: external_exports.number().int().positive(),
+    wins: external_exports.number().int().nonnegative(),
+    ties: external_exports.number().int().nonnegative(),
+    losses: external_exports.number().int().nonnegative(),
+    referenceLabel: external_exports.string().trim().min(1).max(300)
+  }).strict().superRefine((judge, context) => {
+    if (judge.wins + judge.ties + judge.losses !== judge.comparisonCount) {
+      context.addIssue({ code: "custom", message: "Judge win, tie, and loss counts must equal comparisonCount." });
+    }
+  }).nullable(),
+  attempts: external_exports.array(external_exports.object({
+    attemptId: ReleaseIdSchema.nullable().default(null),
+    taskId: ReleaseIdSchema,
+    seed: external_exports.number().int(),
+    repetition: external_exports.number().int().nonnegative(),
+    status: external_exports.enum(["succeeded", "failed"]),
+    deterministicScore: external_exports.number().finite().nullable(),
+    passed: external_exports.boolean().nullable(),
+    judgeScore: external_exports.number().min(0).max(100).nullable(),
+    judgePreference: external_exports.enum(["win", "tie", "loss"]).nullable(),
+    transcriptHash: ReleaseHashSchema.nullable(),
+    traceHash: ReleaseHashSchema.nullable(),
+    transcriptArtifact: external_exports.object({
+      artifactPath: external_exports.string().trim().min(1).max(2e3),
+      jsonPointer: external_exports.string().trim().min(1).max(1e3)
+    }).strict().nullable().default(null),
+    traceArtifact: external_exports.object({
+      artifactPath: external_exports.string().trim().min(1).max(2e3),
+      jsonPointer: external_exports.string().trim().min(1).max(1e3)
+    }).strict().nullable().default(null),
+    latencyMs: external_exports.number().int().nonnegative().nullable().default(null),
+    failureClass: TaskFailureClassSchema.nullable()
+  }).strict()).max(1e5),
+  usage: external_exports.object({
+    policy: EvaluationUsageCategorySchema.nullable(),
+    judge: EvaluationUsageCategorySchema.nullable(),
+    observedSpendUsd: external_exports.number().nonnegative().nullable(),
+    evaluationGpuSeconds: external_exports.number().nonnegative().nullable().default(null)
+  }).strict(),
+  managedServing: external_exports.object({
+    jobId: ReleaseIdSchema,
+    terminalState: external_exports.enum(["completed", "cancelled", "failed", "budget_exhausted"]),
+    sourcePolicyVersion: external_exports.number().int().nonnegative(),
+    sourceAdapterSha256: ReleaseHashSchema.nullable(),
+    servedPolicyVersion: external_exports.number().int().nonnegative().nullable(),
+    servedAdapterSha256: ReleaseHashSchema.nullable(),
+    accruedSpendUsd: external_exports.number().nonnegative(),
+    cleanupAttestationHash: ReleaseHashSchema,
+    resourceCount: external_exports.number().int().nonnegative(),
+    activeResourceCount: external_exports.literal(0)
+  }).strict().nullable().default(null),
+  evidenceSnapshot: external_exports.object({
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema,
+    artifactPath: external_exports.string().trim().min(1).max(2e3)
+  }).strict(),
+  completedAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict().superRefine((receipt, context) => {
+  const deterministic = receipt.deterministic;
+  if (deterministic.completedTaskCount > deterministic.attemptedTaskCount) {
+    context.addIssue({ code: "custom", message: "Completed task count cannot exceed attempted task count." });
+  }
+  if (deterministic.passedTaskCount + deterministic.failedTaskCount !== deterministic.completedTaskCount) {
+    context.addIssue({ code: "custom", message: "Passed and failed task counts must equal completed task count." });
+  }
+  if (deterministic.completedTaskCount === 0 !== (deterministic.meanScore === null)) {
+    context.addIssue({ code: "custom", message: "Deterministic mean score is available exactly when tasks completed." });
+  }
+  if (deterministic.completedTaskCount === 0 !== (deterministic.passRate === null)) {
+    context.addIssue({ code: "custom", message: "Deterministic pass rate is available exactly when tasks completed." });
+  }
+});
+var HarnessRefinerEvaluationConfigurationSchema = external_exports.object({
+  benchmarkId: external_exports.literal("harness-refiner"),
   model: ChatModelRefSchema,
   upstreamModel: external_exports.object({
     providerId: ReleaseIdSchema,
@@ -6752,11 +7264,55 @@ var ModelEvaluationConfigurationSchema = external_exports.object({
     attemptCount: external_exports.number().int().positive()
   }).strict()).length(4)
 }).strict();
+var ModelComparisonEvaluationConfigurationSchema = external_exports.object({
+  benchmarkId: external_exports.literal("model-comparison"),
+  target: external_exports.object({
+    kind: external_exports.enum(["base_model", "model_version", "external_reference"]),
+    label: external_exports.string().trim().min(1).max(300),
+    modelVersionId: ReleaseIdSchema.nullable(),
+    model: ChatModelRefSchema.nullable()
+  }).strict(),
+  grader: ImmutableReleaseRefSchema2,
+  judge: external_exports.object({
+    model: ChatModelRefSchema,
+    release: ImmutableReleaseRefSchema2,
+    rubricRelease: ImmutableReleaseRefSchema2,
+    calibrationRelease: ImmutableReleaseRefSchema2,
+    referenceLabel: external_exports.string().trim().min(1).max(300)
+  }).strict().nullable(),
+  seeds: external_exports.array(external_exports.number().int()).min(1).max(100),
+  repetitions: external_exports.number().int().positive().max(20),
+  maximumSpendUsd: external_exports.number().nonnegative(),
+  series: external_exports.object({
+    id: ReleaseIdSchema,
+    protocol: external_exports.object({ id: ReleaseIdSchema, revision: external_exports.number().int().positive(), contentHash: ReleaseHashSchema }).strict()
+  }).strict().nullable().default(null),
+  panel: external_exports.object({
+    id: ReleaseIdSchema,
+    role: external_exports.enum(["correction", "sibling_verification", "cumulative_known", "development", "retained", "frozen_final"]),
+    passLabel: ReleaseIdSchema.nullable()
+  }).strict().nullable().default(null),
+  comparisonPair: external_exports.object({
+    entryId: ReleaseIdSchema,
+    parent: ModelComparisonParentSchema,
+    candidateModelVersionId: ReleaseIdSchema
+  }).strict().nullable().default(null),
+  attemptPlan: external_exports.array(external_exports.object({
+    stage: external_exports.literal("comparison"),
+    split: external_exports.string().trim().min(1).max(100),
+    taskIds: external_exports.array(ReleaseIdSchema).min(1).max(1e5),
+    attemptCount: external_exports.number().int().positive()
+  }).strict()).length(1)
+}).strict();
+var ModelEvaluationConfigurationSchema = external_exports.union([
+  HarnessRefinerEvaluationConfigurationSchema,
+  ModelComparisonEvaluationConfigurationSchema
+]);
 var ModelRunSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.modelRun.v1"),
   id: ReleaseIdSchema,
   modelId: ReleaseIdSchema,
-  modelVersionId: ReleaseIdSchema,
+  modelVersionId: ReleaseIdSchema.nullable(),
   profileId: ReleaseIdSchema,
   kind: external_exports.enum(["rollout_smoke", "training", "evaluation"]),
   status: external_exports.enum([
@@ -6778,6 +7334,7 @@ var ModelRunSchema = external_exports.object({
   ]).nullable(),
   destinationId: ReleaseIdSchema.nullable(),
   taskset: VersionedReleaseRefSchema,
+  comparisonSeriesEntry: ModelComparisonEntryRefSchema.nullable().optional(),
   harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
   quote: external_exports.object({
     maximumSpendUsd: external_exports.number().nonnegative(),
@@ -6805,7 +7362,8 @@ var ModelRunSchema = external_exports.object({
   receipt: external_exports.union([
     ModelRunReceiptSchema,
     ModelEvaluationReceiptSchema,
-    ModelEvaluationStopReceiptSchema
+    ModelEvaluationStopReceiptSchema,
+    ModelComparisonBenchmarkReceiptSchema
   ]).nullable(),
   adapterArtifactLineageId: ReleaseIdSchema.nullable(),
   failure: external_exports.string().trim().min(1).max(5e3).nullable(),
@@ -6825,7 +7383,7 @@ var ModelRunSchema = external_exports.object({
       message: "An evaluation Model Run requires evaluation configuration and cannot claim training method, destination, or adapter lineage."
     });
   }
-  if (run.kind === "evaluation" && run.receipt && run.receipt.schemaVersion !== "openpond.modelEvaluationReceipt.v1" && run.receipt.schemaVersion !== "openpond.modelEvaluationStopReceipt.v1") {
+  if (run.kind === "evaluation" && run.receipt && run.receipt.schemaVersion !== "openpond.modelEvaluationReceipt.v1" && run.receipt.schemaVersion !== "openpond.modelEvaluationStopReceipt.v1" && run.receipt.schemaVersion !== "openpond.modelComparisonBenchmarkReceipt.v1") {
     context.addIssue({
       code: "custom",
       message: "An evaluation Model Run requires an evaluation receipt."
@@ -6845,10 +7403,347 @@ var ModelRunSchema = external_exports.object({
   }
 });
 
+// ../../packages/contracts/src/model-currency.ts
+var ModelCurrencyEvidenceStateSchema = external_exports.enum(["measuring", "up_to_date", "needs_attention"]);
+var ModelCurrencyTaskClassificationSchema = external_exports.enum(["fixed", "retained", "regressed", "unresolved", "unavailable"]);
+var ModelCurrencyAttemptEvidenceRefSchema = external_exports.object({
+  evaluationRunId: ReleaseIdSchema,
+  attemptKey: ReleaseIdSchema,
+  artifactPath: external_exports.string().trim().min(1).max(2e3),
+  jsonPointer: external_exports.string().trim().min(1).max(1e3),
+  transcriptHash: ReleaseHashSchema.nullable(),
+  traceHash: ReleaseHashSchema.nullable()
+}).strict();
+var Interval = external_exports.object({ level: external_exports.literal(0.95), lower: external_exports.number().finite(), upper: external_exports.number().finite() }).strict();
+var ModelCurrencyPanelMetricSchema = external_exports.object({
+  panelId: ReleaseIdSchema,
+  panelRole: ContinualBenchPanelRoleSchema,
+  passLabel: ReleaseIdSchema.nullable(),
+  taskset: VersionedReleaseRefSchema,
+  attempted: external_exports.number().int().nonnegative(),
+  available: external_exports.number().int().nonnegative(),
+  passed: external_exports.number().int().nonnegative(),
+  strictSuccess: external_exports.number().min(0).max(1).nullable(),
+  strictSuccessCi95: Interval.nullable(),
+  judgeScore: external_exports.number().min(0).max(100).nullable(),
+  judgeScoreCi95: Interval.nullable()
+}).strict();
+var ModelCurrencySnapshotSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelCurrencySnapshot.v1"),
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema,
+  seriesId: ReleaseIdSchema,
+  protocol: external_exports.object({ id: ReleaseIdSchema, revision: external_exports.number().int().positive(), contentHash: ReleaseHashSchema }).strict(),
+  entryId: ReleaseIdSchema,
+  passLabel: ReleaseIdSchema,
+  parent: external_exports.discriminatedUnion("kind", [
+    external_exports.object({ kind: external_exports.literal("base_model"), id: ReleaseIdSchema, revision: external_exports.string().trim().min(1).max(500) }).strict(),
+    external_exports.object({ kind: external_exports.literal("model_version"), id: ReleaseIdSchema, contentHash: ReleaseHashSchema }).strict()
+  ]),
+  candidate: external_exports.object({ kind: external_exports.literal("model_version"), id: ReleaseIdSchema, contentHash: ReleaseHashSchema }).strict(),
+  sources: external_exports.object({
+    evaluationRunIds: external_exports.array(ReleaseIdSchema).max(1e5),
+    attemptIds: external_exports.array(ReleaseIdSchema).max(1e6),
+    tasksets: external_exports.array(VersionedReleaseRefSchema).max(1e4),
+    grader: ImmutableReleaseRefSchema2,
+    judge: ImmutableReleaseRefSchema2.nullable(),
+    calibration: ImmutableReleaseRefSchema2.nullable()
+  }).strict(),
+  matches: external_exports.array(external_exports.object({
+    key: ReleaseIdSchema,
+    panelId: ReleaseIdSchema,
+    panelRole: ContinualBenchPanelRoleSchema,
+    taskId: ReleaseIdSchema,
+    issueFamilyId: ReleaseIdSchema,
+    seed: external_exports.number().int(),
+    repetition: external_exports.number().int().nonnegative(),
+    classification: ModelCurrencyTaskClassificationSchema,
+    parentPassed: external_exports.boolean().nullable(),
+    candidatePassed: external_exports.boolean().nullable(),
+    parentAttempt: ModelCurrencyAttemptEvidenceRefSchema.nullable(),
+    candidateAttempt: ModelCurrencyAttemptEvidenceRefSchema.nullable()
+  }).strict()).max(1e6),
+  taskIds: external_exports.object({
+    fixed: external_exports.array(ReleaseIdSchema).max(1e6),
+    retained: external_exports.array(ReleaseIdSchema).max(1e6),
+    regressed: external_exports.array(ReleaseIdSchema).max(1e6),
+    unresolved: external_exports.array(ReleaseIdSchema).max(1e6),
+    unavailable: external_exports.array(ReleaseIdSchema).max(1e6)
+  }).strict(),
+  panels: external_exports.array(ModelCurrencyPanelMetricSchema).max(1e4),
+  metrics: external_exports.object({
+    knownIssueCoverage: external_exports.number().min(0).max(1).nullable(),
+    issueFamilyGeneralization: external_exports.number().min(0).max(1).nullable(),
+    behavioralRetention: external_exports.number().min(0).max(1).nullable(),
+    currentAcquisitionDelta: external_exports.number().finite().nullable(),
+    retainedDeltaPoints: external_exports.number().finite().nullable(),
+    frontierStrictDelta: external_exports.number().finite().nullable(),
+    pairedPValue: external_exports.number().min(0).max(1).nullable(),
+    wins: external_exports.number().int().nonnegative(),
+    ties: external_exports.number().int().nonnegative(),
+    losses: external_exports.number().int().nonnegative()
+  }).strict(),
+  statistics: external_exports.object({
+    matchedAttemptCount: external_exports.number().int().nonnegative(),
+    strictDelta: external_exports.number().finite().nullable(),
+    strictDeltaCi95: Interval.nullable(),
+    exactPairedBinaryPValue: external_exports.number().min(0).max(1).nullable(),
+    pairedBootstrapSamples: external_exports.number().int().positive()
+  }).strict(),
+  criteria: external_exports.object({
+    allRequiredAttemptsTerminal: external_exports.boolean(),
+    criticalCorrectionPassRate: external_exports.number().min(0).max(1).nullable(),
+    siblingPassRate: external_exports.number().min(0).max(1).nullable(),
+    behavioralRetentionRate: external_exports.number().min(0).max(1).nullable(),
+    retainedRegressionPoints: external_exports.number().finite().nullable(),
+    criticalPriorRegressionCount: external_exports.number().int().nonnegative(),
+    thresholdRelease: ImmutableReleaseRefSchema2
+  }).strict(),
+  efficiency: external_exports.object({
+    inputTokens: external_exports.number().int().nonnegative(),
+    outputTokens: external_exports.number().int().nonnegative(),
+    totalTokens: external_exports.number().int().nonnegative(),
+    costUsd: external_exports.number().nonnegative().nullable(),
+    latencyMs: external_exports.number().int().nonnegative(),
+    tokensPerSuccess: external_exports.number().nonnegative().nullable(),
+    throughputPerHour: external_exports.number().nonnegative().nullable(),
+    gpuSeconds: external_exports.number().nonnegative().nullable()
+  }).strict(),
+  invariants: external_exports.object({
+    systemPromptHash: ReleaseHashSchema,
+    toolSchema: ImmutableReleaseRefSchema2,
+    application: ImmutableReleaseRefSchema2,
+    harness: ImmutableReleaseRefSchema2,
+    runtime: ImmutableReleaseRefSchema2,
+    grader: ImmutableReleaseRefSchema2,
+    autoRefinerEnabled: external_exports.boolean()
+  }).strict(),
+  evidenceState: ModelCurrencyEvidenceStateSchema,
+  evidenceReasons: external_exports.array(ReleaseIdSchema).max(100),
+  projectedAt: ReleaseTimestampSchema
+}).strict();
+
+// ../../packages/contracts/src/continual-support-review.ts
+var ContinualLearningResponseTargetSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("base_model"),
+    id: ReleaseIdSchema,
+    revision: external_exports.string().trim().min(1).max(500),
+    label: external_exports.string().trim().min(1).max(300)
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("model_version"),
+    id: ReleaseIdSchema,
+    label: external_exports.string().trim().min(1).max(300)
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("captured_model"),
+    id: ReleaseIdSchema,
+    label: external_exports.string().trim().min(1).max(300)
+  }).strict()
+]);
+var ContinualLearningCapturedAttemptSchema = external_exports.union([
+  external_exports.object({
+    source: external_exports.literal("evaluation_run").default("evaluation_run"),
+    evaluationRunId: ReleaseIdSchema,
+    attemptId: ReleaseIdSchema,
+    modelLabel: external_exports.string().trim().min(1).max(300).nullable().default(null),
+    modelVersionId: ReleaseIdSchema.nullable().default(null),
+    reward: external_exports.number().finite().nullable(),
+    components: external_exports.record(external_exports.string(), external_exports.number().finite()).default({})
+  }).strict(),
+  external_exports.object({
+    source: external_exports.literal("imported_response"),
+    modelLabel: external_exports.string().trim().min(1).max(300),
+    modelVersionId: ReleaseIdSchema.nullable().default(null),
+    response: external_exports.unknown().refine((value) => value !== void 0, "An imported model response is required."),
+    reward: external_exports.number().finite().nullable().default(null),
+    components: external_exports.record(external_exports.string(), external_exports.number().finite()).default({})
+  }).strict()
+]);
+var ContinualLearningObservedAttemptSchema = external_exports.union([
+  external_exports.object({
+    taskId: ReleaseIdSchema,
+    target: ContinualLearningResponseTargetSchema,
+    attempt: ContinualLearningCapturedAttemptSchema
+  }).strict(),
+  external_exports.object({
+    taskId: ReleaseIdSchema,
+    target: external_exports.enum(["base", "current"]).default("current"),
+    attempt: ContinualLearningCapturedAttemptSchema
+  }).strict(),
+  external_exports.object({
+    taskId: ReleaseIdSchema,
+    target: external_exports.enum(["base", "current"]).default("current"),
+    evaluationRunId: ReleaseIdSchema,
+    attemptId: ReleaseIdSchema,
+    reward: external_exports.number().finite().nullable(),
+    components: external_exports.record(external_exports.string(), external_exports.number().finite()).default({})
+  }).strict().transform(({ taskId, target, ...attempt }) => ({
+    taskId,
+    target,
+    attempt: { source: "evaluation_run", modelLabel: null, modelVersionId: null, ...attempt }
+  }))
+]);
+var ContinualLearningDailyBatchManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualLearningDailyBatchManifest.v1"),
+  id: ReleaseIdSchema,
+  seriesId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  dayOrdinal: external_exports.number().int().positive().max(1e4),
+  sourceTaskset: VersionedReleaseRefSchema,
+  taskIds: external_exports.array(ReleaseIdSchema).min(1).max(1e3),
+  observedAttempts: external_exports.array(ContinualLearningObservedAttemptSchema).max(1e3).default([]),
+  sourceFileName: external_exports.string().trim().min(1).max(500).nullable().default(null),
+  availableAt: ReleaseTimestampSchema
+}).strict().superRefine((batch, context) => {
+  if (new Set(batch.taskIds).size !== batch.taskIds.length) {
+    context.addIssue({ code: "custom", path: ["taskIds"], message: "A daily batch cannot repeat a task." });
+  }
+  if (new Set(batch.observedAttempts.map((attempt) => `${attempt.taskId}:${observedTargetKey(attempt.target)}`)).size !== batch.observedAttempts.length) {
+    context.addIssue({ code: "custom", path: ["observedAttempts"], message: "An intake batch cannot repeat a task and Policy target pair." });
+  }
+  const taskIds = new Set(batch.taskIds);
+  if (batch.observedAttempts.some((attempt) => !taskIds.has(attempt.taskId))) {
+    context.addIssue({ code: "custom", path: ["observedAttempts"], message: "Observed attempts must belong to tasks in the daily batch." });
+  }
+});
+var ContinualLearningDailyBatchSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualLearningDailyBatch.v1"),
+  id: ReleaseIdSchema,
+  seriesId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  dayOrdinal: external_exports.number().int().positive().max(1e4),
+  label: external_exports.string().trim().min(1).max(100),
+  runMode: external_exports.enum(["automatic", "manual"]).optional(),
+  source: external_exports.enum(["json_upload", "sealed_fixture"]),
+  sourceFileName: external_exports.string().trim().min(1).max(500).nullable(),
+  sourceTaskset: VersionedReleaseRefSchema,
+  tasks: external_exports.array(external_exports.object({
+    taskId: ReleaseIdSchema,
+    taskContentHash: ReleaseHashSchema,
+    familyKey: ReleaseIdSchema,
+    disposition: external_exports.enum(["include", "defer", "exclude"]).nullable(),
+    oracleReview: external_exports.enum(["pending", "confirmed", "needs_correction"]),
+    note: external_exports.string().trim().max(2e3),
+    observedAttempt: ContinualLearningCapturedAttemptSchema.nullable(),
+    baselineAttempt: ContinualLearningCapturedAttemptSchema.nullable().default(null),
+    responses: external_exports.array(external_exports.object({
+      target: ContinualLearningResponseTargetSchema,
+      attempt: ContinualLearningCapturedAttemptSchema
+    }).strict()).max(100).default([]),
+    stagedAt: ReleaseTimestampSchema.nullable().default(null),
+    queuedEntry: ModelComparisonEntryRefSchema.nullable().default(null)
+  }).strict()).min(1).max(1e3),
+  intakeEvaluation: external_exports.object({
+    status: external_exports.enum(["awaiting", "running", "ready", "failed"]),
+    requestedTargets: external_exports.array(external_exports.enum(["base", "current"])).max(2).default(["base", "current"]),
+    requestedPolicies: external_exports.array(ContinualLearningResponseTargetSchema).max(100).default([]),
+    runs: external_exports.array(external_exports.object({
+      target: ContinualLearningResponseTargetSchema,
+      runId: ReleaseIdSchema
+    }).strict()).max(100).default([]),
+    baselineRunId: ReleaseIdSchema.nullable(),
+    currentRunId: ReleaseIdSchema.nullable(),
+    currentPolicy: external_exports.discriminatedUnion("kind", [
+      external_exports.object({ kind: external_exports.literal("base_model"), id: ReleaseIdSchema }).strict(),
+      external_exports.object({ kind: external_exports.literal("model_version"), id: ReleaseIdSchema }).strict()
+    ]).nullable(),
+    failure: external_exports.string().trim().min(1).max(2e3).nullable()
+  }).strict().default({
+    status: "awaiting",
+    requestedTargets: ["base", "current"],
+    requestedPolicies: [],
+    runs: [],
+    baselineRunId: null,
+    currentRunId: null,
+    currentPolicy: null,
+    failure: null
+  }),
+  status: external_exports.enum(["pending", "reviewed", "queued"]),
+  queuedEntry: ModelComparisonEntryRefSchema.nullable(),
+  reviewedBy: ReleaseIdSchema.nullable(),
+  reviewedAt: ReleaseTimestampSchema.nullable(),
+  availableAt: ReleaseTimestampSchema,
+  revision: external_exports.number().int().positive(),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((batch, context) => {
+  if (new Set(batch.tasks.map((task) => task.taskId)).size !== batch.tasks.length) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "A daily batch cannot repeat a task." });
+  }
+  for (const [taskIndex, task] of batch.tasks.entries()) {
+    const keys = task.responses.map((response) => responseTargetKey(response.target));
+    if (new Set(keys).size !== keys.length) {
+      context.addIssue({ code: "custom", path: ["tasks", taskIndex, "responses"], message: "A task cannot repeat a model response target." });
+    }
+  }
+  const complete = batch.tasks.every((task) => task.disposition !== null && task.oracleReview !== "pending" && (task.oracleReview !== "needs_correction" || task.note.length > 0));
+  if (batch.status !== "pending" && !complete) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "Every task requires a decision and oracle review before the day completes." });
+  }
+  if (batch.status === "queued" !== (batch.queuedEntry !== null)) {
+    context.addIssue({ code: "custom", path: ["queuedEntry"], message: "Only a queued day carries an exact series-entry reference." });
+  }
+  if (batch.status === "pending" && (batch.reviewedAt !== null || batch.reviewedBy !== null)) {
+    context.addIssue({ code: "custom", path: ["reviewedAt"], message: "A pending day cannot carry reviewer completion identity." });
+  }
+  if (batch.status !== "pending" && (batch.reviewedAt === null || batch.reviewedBy === null)) {
+    context.addIssue({ code: "custom", path: ["reviewedAt"], message: "Reviewed identity is required after a day review completes." });
+  }
+});
+var ContinualBenchIssueReviewSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchIssueReview.v1"),
+  id: ReleaseIdSchema,
+  seriesId: ReleaseIdSchema,
+  scheduleEntryId: ReleaseIdSchema,
+  passLabel: ReleaseIdSchema,
+  packet: ContinualBenchIssuePacketSchema,
+  splitManifest: external_exports.object({ id: ReleaseIdSchema, contentHash: ReleaseHashSchema }).strict(),
+  decisions: external_exports.array(external_exports.object({
+    taskId: ReleaseIdSchema,
+    disposition: external_exports.enum(["include", "defer", "exclude"]).nullable(),
+    note: external_exports.string().trim().max(2e3)
+  }).strict()).min(2).max(1e4),
+  status: external_exports.enum(["pending", "reviewed", "queued"]),
+  queuedEntry: ModelComparisonEntryRefSchema.nullable(),
+  reviewedBy: ReleaseIdSchema.nullable(),
+  reviewedAt: ReleaseTimestampSchema.nullable(),
+  revision: external_exports.number().int().positive(),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((review, context) => {
+  const caseIds = [...review.packet.cases.map((item) => item.taskId)].sort();
+  const decisionIds = [...review.decisions.map((item) => item.taskId)].sort();
+  if (JSON.stringify(caseIds) !== JSON.stringify(decisionIds)) context.addIssue({ code: "custom", path: ["decisions"], message: "Review decisions must cover the exact issue-packet cases." });
+  const complete = review.decisions.every((item) => item.disposition !== null && item.note.length > 0);
+  if (review.status !== "pending" && !complete) context.addIssue({ code: "custom", path: ["decisions"], message: "Every case requires a disposition and note before review completes." });
+  if (review.status === "queued" !== (review.queuedEntry !== null)) context.addIssue({ code: "custom", path: ["queuedEntry"], message: "Only a queued review carries an exact series-entry reference." });
+}).readonly();
+function responseTargetKey(target) {
+  return `${target.kind}:${target.id}`;
+}
+function observedTargetKey(target) {
+  return typeof target === "string" ? target : responseTargetKey(target);
+}
+
 // ../../packages/contracts/src/training-policy-optimization.ts
 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 AdamwOptimizerConfigSchema = external_exports.object({
+  name: external_exports.literal("adamw").default("adamw"),
+  weightDecay: external_exports.number().nonnegative().max(1).default(0),
+  beta1: external_exports.number().positive().lt(1).default(0.9),
+  beta2: external_exports.number().positive().lt(1).default(0.999),
+  epsilon: external_exports.number().positive().max(0.01).default(1e-8)
+}).strict().default({
+  name: "adamw",
+  weightDecay: 0,
+  beta1: 0.9,
+  beta2: 0.999,
+  epsilon: 1e-8
+});
 var TrainingModelRefSchema = external_exports.object({
   id: IdSchema7,
   revision: external_exports.string().trim().min(1).max(256),
@@ -6868,7 +7763,13 @@ var GrpoOptimizerSchema = external_exports.object({
   method: external_exports.literal("grpo"),
   groupSize: external_exports.number().int().min(2).max(128),
   normalization: external_exports.literal("group_standardized"),
-  loss: RftLossMethodSchema
+  advantageEpsilon: external_exports.number().positive().max(0.01).default(1e-8),
+  loss: RftLossMethodSchema,
+  clipRange: external_exports.number().positive().max(1).default(0.2),
+  iterations: external_exports.number().int().min(2).max(16).default(2),
+  microbatchSize: external_exports.number().int().positive().max(128).default(1),
+  gradientAccumulationSteps: external_exports.number().int().positive().max(128).default(1),
+  adamw: AdamwOptimizerConfigSchema
 });
 var PpoOptimizerSchema = external_exports.object({
   method: external_exports.literal("ppo"),
@@ -6887,7 +7788,8 @@ var PolicyOptimizerSchema = external_exports.discriminatedUnion("method", [
 ]);
 var LearnedPreferenceRewardBindingSchema = external_exports.object({
   rewardModelVersion: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
-  qualificationReport: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict(),
+  qualificationReport: external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict().nullable().default(null),
+  evaluationReferences: external_exports.array(external_exports.object({ id: IdSchema7, contentHash: HashSchema6 }).strict()).max(1e3).default([]),
   checkpoint: external_exports.object({
     id: IdSchema7,
     contentHash: HashSchema6,
@@ -7597,7 +8499,10 @@ var RewardModelRecipeSchema = external_exports.object({
   processorRelease: ImmutableReleaseRefSchema2,
   input: external_exports.object({
     kind: external_exports.literal("structured_text"),
-    serialization: external_exports.literal("scenario_input_and_candidate_json_v1"),
+    serialization: external_exports.enum([
+      "scenario_input_and_candidate_json_v1",
+      "visible_agent_trajectory_v1"
+    ]),
     maxCharacters: external_exports.number().int().positive().max(5e5)
   }).strict().default({
     kind: "structured_text",
@@ -7675,7 +8580,13 @@ var RftRecipeSchema = external_exports.object({
   }),
   optimizer: external_exports.object({
     learningRate: external_exports.number().positive(),
-    maxSteps: external_exports.number().int().positive().max(1e5)
+    maxSteps: external_exports.number().int().positive().max(1e5),
+    clipRange: external_exports.number().positive().max(1).default(0.2),
+    iterations: external_exports.number().int().min(2).max(16).default(2),
+    microbatchSize: external_exports.number().int().positive().max(64).default(1),
+    gradientAccumulationSteps: external_exports.number().int().positive().max(64).default(1),
+    advantageEpsilon: external_exports.number().positive().max(0.01).default(1e-8),
+    adamw: AdamwOptimizerConfigSchema
   }),
   loss: external_exports.object({
     method: RftLossMethodSchema.default("grpo"),
@@ -7691,10 +8602,22 @@ var RftRecipeSchema = external_exports.object({
   }),
   resourceLimits: external_exports.object({
     wallTimeMs: external_exports.number().int().positive().max(24 * 60 * 60 * 1e3),
+    maxGpuSeconds: external_exports.number().int().positive().max(10800).optional(),
     maxRollouts: external_exports.number().int().positive().max(1e5),
     maxPayloadBytes: external_exports.number().int().positive().max(10 * 1024 * 1024)
   }),
-  policyOptimization: PolicyOptimizationContractSchema.nullable().default(null)
+  policyOptimization: PolicyOptimizationContractSchema.nullable().default(null),
+  continuation: external_exports.object({
+    schemaVersion: external_exports.literal("openpond.crossJobContinuationRequest.v1"),
+    parentArtifact: ImmutableReleaseRefSchema2,
+    sourceArtifact: external_exports.object({
+      jobId: TrainingIdSchema,
+      artifactId: TrainingIdSchema,
+      checkpointId: TrainingIdSchema,
+      contentHash: TrainingHashSchema
+    }).strict(),
+    optimizerMode: external_exports.enum(["continue", "reset"])
+  }).strict().optional()
 });
 var DpoRecipeSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.dpoRecipe.v1"),
@@ -7872,6 +8795,7 @@ var TrainingPlanSchema = external_exports.object({
   modelId: TrainingIdSchema,
   tasksetId: TrainingIdSchema,
   tasksetHash: TrainingHashSchema,
+  comparisonSeriesEntry: ModelComparisonEntryRefSchema.nullable().optional(),
   harnessRelease: ImmutableReleaseRefSchema2.nullable().optional(),
   modelImprovementQualification: ImmutableReleaseRefSchema2.nullable().optional(),
   destinationId: TrainingDestinationIdSchema,
@@ -8058,8 +8982,10 @@ var PolicyOptimizationMetricSchema = external_exports.object({
   meanReward: external_exports.number().nullable(),
   meanReturn: external_exports.number().nullable(),
   kl: external_exports.number().nullable(),
+  behaviorPolicyKlPreUpdate: external_exports.number().nonnegative().nullable().default(null),
   entropy: external_exports.number().nullable(),
   policyClipFraction: external_exports.number().min(0).max(1).nullable(),
+  behaviorPolicyClipFractionPreUpdate: external_exports.number().min(0).max(1).nullable().default(null),
   valueClipFraction: external_exports.number().min(0).max(1).nullable(),
   explainedVariance: external_exports.number().nullable(),
   rolloutLearnerLag: external_exports.number().int().nonnegative().nullable(),
@@ -8070,16 +8996,22 @@ var PolicyOptimizationMetricSchema = external_exports.object({
   costUsd: external_exports.number().nonnegative().nullable()
 });
 var ManagedTrainingRunEvidenceSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.managedTrainingRunEvidence.v1"),
+  schemaVersion: external_exports.literal("openpond.managedTrainingRunEvidence.v2"),
   provider: TrainingIdSchema,
   providerRunId: TrainingIdSchema,
   state: TrainingIdSchema,
   progress: external_exports.object({
     targetOptimizerSteps: external_exports.number().int().nonnegative(),
-    committedOptimizerSteps: external_exports.number().int().nonnegative()
+    committedOptimizerSteps: external_exports.number().int().nonnegative(),
+    skippedOptimizerSteps: external_exports.number().int().nonnegative()
   }),
   reward: external_exports.object({
     finalMean: external_exports.number().nullable(),
+    variance: external_exports.number().nonnegative().nullable(),
+    minimum: external_exports.number().nullable(),
+    maximum: external_exports.number().nullable(),
+    distinctValueCount: external_exports.number().int().nonnegative(),
+    noSignalGroupCount: external_exports.number().int().nonnegative(),
     trajectoryCount: external_exports.number().int().nonnegative(),
     eligibleTrajectoryCount: external_exports.number().int().nonnegative()
   }),
@@ -8092,7 +9024,9 @@ var ManagedTrainingRunEvidenceSchema = external_exports.object({
     provider: TrainingIdSchema,
     gpuType: external_exports.string().trim().min(1).max(300).nullable(),
     gpuCount: external_exports.number().int().nonnegative().nullable(),
-    hourlyCostUsd: external_exports.number().nonnegative().nullable()
+    hourlyCostUsd: external_exports.number().nonnegative().nullable(),
+    durationSeconds: external_exports.number().nonnegative().nullable(),
+    gpuSeconds: external_exports.number().nonnegative().nullable()
   }),
   cost: external_exports.object({
     totalUsd: external_exports.number().nonnegative().nullable()
@@ -8103,6 +9037,9 @@ var ManagedTrainingRunEvidenceSchema = external_exports.object({
     sha256: TrainingHashSchema.nullable(),
     sizeBytes: external_exports.number().int().nonnegative().nullable()
   }).nullable(),
+  movement: external_exports.object({
+    adapterDeltaNorm: external_exports.number().nonnegative().nullable()
+  }),
   evaluations: external_exports.array(
     external_exports.object({
       kind: external_exports.enum(["baseline", "candidate"]),
@@ -8287,6 +9224,11 @@ var TrainingStateResponseSchema = external_exports.object({
   modelProjects: external_exports.array(ModelProjectSchema2).default([]),
   modelVersions: external_exports.array(ModelVersionSchema).default([]),
   modelRuns: external_exports.array(ModelRunSchema).default([]),
+  comparisonSeries: external_exports.array(ModelComparisonSeriesSchema).default([]),
+  comparisonSeriesEntries: external_exports.array(ModelComparisonSeriesEntrySchema).default([]),
+  modelCurrencySnapshots: external_exports.array(ModelCurrencySnapshotSchema).default([]),
+  continualBenchIssueReviews: external_exports.array(ContinualBenchIssueReviewSchema).default([]),
+  continualLearningDailyBatches: external_exports.array(ContinualLearningDailyBatchSchema).default([]),
   rewardModelVersions: external_exports.array(RewardModelVersionSchema).default([]),
   rewardModelRuns: external_exports.array(RewardModelRunSchema).default([]),
   modelTasksets: external_exports.array(TasksetSchema).default([]),
@@ -8842,6 +9784,12 @@ var TrainingExecutionStatusSchema = external_exports.object({
   ]),
   phase: external_exports.string().trim().min(1).max(200),
   progress: external_exports.number().min(0).max(1).nullable(),
+  rolloutProgress: external_exports.object({
+    groupsCompleted: external_exports.number().int().nonnegative(),
+    groupsTarget: external_exports.number().int().nonnegative(),
+    optimizerUpdatesApplied: external_exports.number().int().nonnegative(),
+    optimizerUpdatesSkipped: external_exports.number().int().nonnegative()
+  }).strict().optional(),
   updatedAt: ReleaseTimestampSchema,
   errorCode: ReleaseIdSchema.nullable()
 }).strict();
@@ -8860,7 +9808,8 @@ var TrainingArtifactsSchema = external_exports.object({
       ]),
       objectRef: external_exports.string().trim().min(1).max(2e3),
       sha256: ReleaseHashSchema,
-      sizeBytes: external_exports.number().int().nonnegative()
+      sizeBytes: external_exports.number().int().nonnegative(),
+      metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
     }).strict()
   ),
   contentHash: ReleaseHashSchema