openpond 0.0.43 → 0.0.44

package/dist/chunks/{chunk-M2NXTLH2.js → chunk-ZXWFYFFB.js}

@@ -844,12 +844,12 @@ var SandboxTemplateRuntimeSchema = external_exports.object({
   snapshot: external_exports.string().trim().min(1).max(191).optional(),
   image: DockerfileRuntimeImageSchema.optional(),
   dockerfile: DockerfileRuntimeSourceSchema.optional()
-}).strict().superRefine((runtime, context) => {
+}).strict().superRefine((runtime2, context) => {
   const selected = [
-    runtime.base,
-    runtime.snapshot,
-    runtime.image,
-    runtime.dockerfile
+    runtime2.base,
+    runtime2.snapshot,
+    runtime2.image,
+    runtime2.dockerfile
   ].filter(Boolean).length;
   if (selected !== 1) {
     context.addIssue({
@@ -1803,6 +1803,195 @@ function createHarnessAdvanceReceipt(content) {
   });
 }
 
+// ../../packages/harness/dist/evaluation-review.js
+var BoundedTextSchema2 = external_exports.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = external_exports.enum([
+  "no_action",
+  "harness_maintenance",
+  "runtime",
+  "product",
+  "taskset",
+  "model_improvement"
+]);
+var HarnessEvaluationReviewAuthoritySchema = external_exports.enum([
+  "none",
+  "runtime_service",
+  "product_team",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var HarnessReviewEvidenceKindSchema = external_exports.enum([
+  "observation",
+  "trigger",
+  "route_decision",
+  "refiner_outcome",
+  "proposal",
+  "validation",
+  "apply_receipt",
+  "harness_advance",
+  "rollback",
+  "work_outcome",
+  "taskset",
+  "evaluation",
+  "training_qualification",
+  "model_candidate"
+]);
+var HarnessReviewOwnerScopeSchema = external_exports.object({
+  kind: external_exports.enum(["personal", "team"]),
+  id: ReleaseIdSchema
+}).strict();
+var HarnessReviewSourcePolicyRefSchema = external_exports.object({
+  policy: ImmutableReleaseRefSchema,
+  state: external_exports.enum(["authorized", "revoked", "deleted", "expired"]),
+  checkedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewEvidenceRefSchema = external_exports.object({
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
+  occurrenceKey: ReleaseHashSchema,
+  occurredAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewExcludedEvidenceSchema = external_exports.object({
+  evidence: ImmutableReleaseRefSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
+  reason: external_exports.enum([
+    "outside_scope",
+    "before_watermark",
+    "duplicate",
+    "resolved",
+    "revoked",
+    "deleted",
+    "expired",
+    "sensitive",
+    "unverified",
+    "budget"
+  ])
+}).strict();
+var HarnessReviewWatermarkSchema = external_exports.object({
+  cursor: ReleaseHashSchema,
+  throughCreatedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewClaimSchema = external_exports.object({
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: external_exports.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema2,
+  independentOccurrences: external_exports.number().int().positive().max(1e6),
+  unresolvedOccurrences: external_exports.number().int().positive().max(1e6)
+}).strict().refine((claim2) => claim2.unresolvedOccurrences <= claim2.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
+var HarnessReviewTriageLayerSchema = external_exports.enum([
+  "harness",
+  "runtime",
+  "product",
+  "retrieval",
+  "tools",
+  "evaluation",
+  "model"
+]);
+var HarnessReviewTriageDecisionSchema = external_exports.object({
+  layer: HarnessReviewTriageLayerSchema,
+  status: external_exports.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  reason: BoundedTextSchema2,
+  evidenceRefs: external_exports.array(ImmutableReleaseRefSchema).max(1e3)
+}).strict();
+var HarnessEvaluationReviewReceiptContentSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
+  nextWatermark: HarnessReviewWatermarkSchema,
+  selectedEvidence: external_exports.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: external_exports.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  claim: HarnessReviewClaimSchema.nullable(),
+  classification: HarnessEvaluationReviewClassificationSchema,
+  triage: external_exports.array(HarnessReviewTriageDecisionSchema).max(16),
+  reason: BoundedTextSchema2,
+  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
+  maxEstimatedCostUsd: external_exports.number().finite().nonnegative(),
+  tasksetProposal: ImmutableReleaseRefSchema.nullable(),
+  evaluation: ImmutableReleaseRefSchema.nullable(),
+  trainingQualification: ImmutableReleaseRefSchema.nullable(),
+  policyVersion: ReleaseIdSchema,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema
+}).strict().superRefine((receipt, context) => {
+  const selectedKeys = receipt.selectedEvidence.map((item) => `${item.evidence.id}:${item.evidence.contentHash}`);
+  if (new Set(selectedKeys).size !== selectedKeys.length) {
+    context.addIssue({
+      code: "custom",
+      message: "selected review evidence must be unique",
+      path: ["selectedEvidence"]
+    });
+  }
+  if (receipt.selectedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "selected review evidence must be authorized at review time",
+      path: ["selectedEvidence"]
+    });
+  }
+  if (receipt.classification === "no_action") {
+    if (receipt.nextAuthority !== "none") {
+      context.addIssue({
+        code: "custom",
+        message: "no-action review receipts require no next authority",
+        path: ["nextAuthority"]
+      });
+    }
+    if (receipt.tasksetProposal || receipt.evaluation || receipt.trainingQualification) {
+      context.addIssue({
+        code: "custom",
+        message: "no-action review receipts cannot carry downstream refs"
+      });
+    }
+  } else if (!receipt.claim || receipt.selectedEvidence.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable review receipts require a claim and selected evidence"
+    });
+  }
+  if (receipt.classification === "runtime" && receipt.nextAuthority !== "runtime_service") {
+    context.addIssue({
+      code: "custom",
+      message: "runtime classifications route to runtime-service authority",
+      path: ["nextAuthority"]
+    });
+  }
+  if (receipt.classification === "product" && receipt.nextAuthority !== "product_team") {
+    context.addIssue({
+      code: "custom",
+      message: "product classifications route to product-team authority",
+      path: ["nextAuthority"]
+    });
+  }
+  if (receipt.classification === "taskset" && receipt.nextAuthority !== "human_review") {
+    context.addIssue({
+      code: "custom",
+      message: "Taskset classifications require human review"
+    });
+  }
+  if (receipt.classification === "model_improvement" && (!receipt.evaluation || !receipt.trainingQualification || !["human_review", "training_system"].includes(receipt.nextAuthority))) {
+    context.addIssue({
+      code: "custom",
+      message: "model-improvement classifications require Evaluation and qualification refs plus explicit authority"
+    });
+  }
+});
+var HarnessEvaluationReviewReceiptSchema = HarnessEvaluationReviewReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+function createHarnessEvaluationReviewReceipt(input) {
+  const content = HarnessEvaluationReviewReceiptContentSchema.parse(input);
+  return HarnessEvaluationReviewReceiptSchema.parse({
+    ...content,
+    contentHash: contentHash(content)
+  });
+}
+
 // ../../packages/harness/dist/tools.js
 var ToolDeclarationSchema = external_exports.object({
   name: external_exports.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
@@ -1909,7 +2098,7 @@ var HarnessTraceSchema = external_exports.object({
 }).strict();
 
 // ../../packages/harness/dist/harness-improvements.js
-var BoundedTextSchema2 = external_exports.string().trim().min(1).max(1e5);
+var BoundedTextSchema3 = external_exports.string().trim().min(1).max(1e5);
 var MetadataSchema3 = external_exports.record(external_exports.string(), external_exports.unknown()).default({});
 var ImprovementSafeBoundaryKindSchema = external_exports.enum([
   "completed_tool_batch",
@@ -1957,11 +2146,11 @@ var ImprovementObservationContentSchema = external_exports.object({
   state: ImprovementObservationStateSchema,
   tool: ImprovementToolIdentitySchema.nullable(),
   deterministicClass: external_exports.string().trim().min(1).max(500).nullable(),
-  summary: BoundedTextSchema2,
+  summary: BoundedTextSchema3,
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
 }).strict().superRefine((observation, context) => {
-  if (new Set(observation.eventRefs.map((reference) => reference.id)).size !== observation.eventRefs.length) {
+  if (new Set(observation.eventRefs.map((reference2) => reference2.id)).size !== observation.eventRefs.length) {
     context.addIssue({
       code: "custom",
       message: "observation event refs must be unique",
@@ -2004,7 +2193,7 @@ var RefinementTriggerDecisionContentSchema = external_exports.object({
   decision: RefinementTriggerDecisionKindSchema,
   deterministicRoute: HarnessImprovementRouteSchema.nullable(),
   suggestedRoutes: external_exports.array(HarnessImprovementRouteSchema).max(8),
-  reason: BoundedTextSchema2,
+  reason: BoundedTextSchema3,
   deduplicationKey: ReleaseHashSchema,
   policy: RefinementTriggerPolicySchema,
   estimatedMaxCostUsd: external_exports.number().finite().nonnegative(),
@@ -2081,7 +2270,7 @@ var ImprovementRouteDecisionContentSchema = external_exports.object({
   route: HarnessImprovementRouteSchema,
   authority: ImprovementRouteAuthoritySchema,
   automatic: external_exports.boolean(),
-  reason: BoundedTextSchema2,
+  reason: BoundedTextSchema3,
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
 }).strict().superRefine((decision2, context) => {
@@ -2109,7 +2298,7 @@ var HarnessRefinerOutcomeContentSchema = external_exports.object({
   trigger: ImmutableReleaseRefSchema,
   decision: external_exports.enum(["no_action", "proposed"]),
   proposal: ImmutableReleaseRefSchema.nullable(),
-  reason: BoundedTextSchema2,
+  reason: BoundedTextSchema3,
   evidenceRefs: external_exports.array(ImmutableReleaseRefSchema).max(100),
   estimatedCostUsd: external_exports.number().finite().nonnegative(),
   createdAt: ReleaseTimestampSchema,
@@ -2301,7 +2490,7 @@ async function authorLocalHarnessRefinementWithModel(input) {
     timeout.cleanup();
   }
 }
-function refinerMessages(evidence) {
+function refinerMessages(evidence2) {
   return [
     {
       role: "system",
@@ -2337,7 +2526,7 @@ function refinerMessages(evidence) {
     },
     {
       role: "user",
-      content: JSON.stringify(evidence, null, 2)
+      content: JSON.stringify(evidence2, null, 2)
     }
   ];
 }
@@ -2653,7 +2842,7 @@ function collectObservations(input) {
     });
     if (recoveredFailureKeys.has(failureKey))
       continue;
-    const failureObservationIndex = observations.findIndex((observation) => observation.kind === "tool_failure" && observation.eventRefs.some((reference) => reference.id === priorFailure.event.id));
+    const failureObservationIndex = observations.findIndex((observation) => observation.kind === "tool_failure" && observation.eventRefs.some((reference2) => reference2.id === priorFailure.event.id));
     if (failureObservationIndex >= 0) {
       observations[failureObservationIndex] = observationFor({
         input,
@@ -2687,7 +2876,7 @@ function collectObservations(input) {
   }
   const recovered = observations.filter((observation) => observation.kind === "recovery");
   if (input.boundary.kind === "turn_completed" && recovered.length > 0) {
-    const relevantOutcomes = input.outcomes.filter((outcome) => recovered.some((observation) => observation.eventRefs.some((reference) => reference.id === outcome.event.id)));
+    const relevantOutcomes = input.outcomes.filter((outcome) => recovered.some((observation) => observation.eventRefs.some((reference2) => reference2.id === outcome.event.id)));
     observations.push(observationFor({
       input,
       kind: "completion_detour",
@@ -2968,8 +3157,8 @@ function proposalEvidence(observations) {
   const byId = /* @__PURE__ */ new Map();
   for (const observation of observations) {
     for (const event of observation.eventRefs) {
-      const evidence = observationEvidence(observation, event);
-      byId.set(`${evidence.kind}:${evidence.id}`, evidence);
+      const evidence2 = observationEvidence(observation, event);
+      byId.set(`${evidence2.kind}:${evidence2.id}`, evidence2);
     }
   }
   return [...byId.values()];
@@ -2990,8 +3179,8 @@ function uniqueEventRefs(observations) {
   }
   return [...byId.values()];
 }
-function sameOverlayRef(overlay, reference) {
-  return overlay.id === reference.id && overlay.revision === reference.revision && overlay.contentHash === reference.contentHash;
+function sameOverlayRef(overlay, reference2) {
+  return overlay.id === reference2.id && overlay.revision === reference2.revision && overlay.contentHash === reference2.contentHash;
 }
 function overlayRef(overlay) {
   return {
@@ -3564,11 +3753,11 @@ function createWorkEvidenceReceipt(input) {
   const receipt = WorkEvidenceReceiptContentSchema.parse(input);
   return WorkEvidenceReceiptSchema.parse({ ...receipt, contentHash: contentHash(receipt) });
 }
-function createWorkFeedbackReceipt(input, evidence) {
+function createWorkFeedbackReceipt(input, evidence2) {
   const feedback = WorkFeedbackReceiptContentSchema.parse(input);
   const receipt = WorkFeedbackReceiptSchema.parse({ ...feedback, contentHash: contentHash(feedback) });
-  if (evidence)
-    assertFeedbackTargetsEvidence(receipt, evidence);
+  if (evidence2)
+    assertFeedbackTargetsEvidence(receipt, evidence2);
   return receipt;
 }
 function verifyWorkEvidenceReceipt(value) {
@@ -3581,11 +3770,11 @@ function workEvidenceReceiptRef(receipt) {
     sizeBytes: null
   });
 }
-function assertFeedbackTargetsEvidence(feedback, evidence) {
-  if (feedback.evidenceReceiptRef.contentHash !== evidence.contentHash) {
+function assertFeedbackTargetsEvidence(feedback, evidence2) {
+  if (feedback.evidenceReceiptRef.contentHash !== evidence2.contentHash) {
     throw new Error("Feedback targets a different Work evidence receipt.");
   }
-  if (feedback.outputRevisionRef && !evidence.outputRefs.some((output2) => output2.contentHash === feedback.outputRevisionRef.contentHash)) {
+  if (feedback.outputRevisionRef && !evidence2.outputRefs.some((output2) => output2.contentHash === feedback.outputRevisionRef.contentHash)) {
     throw new Error("Feedback targets an output revision not bound by the Work evidence receipt.");
   }
 }
@@ -3959,6 +4148,300 @@ var GraderEvidenceContentSchema = external_exports.object({
 }).strict();
 var GraderEvidenceSchema = GraderEvidenceContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
 
+// ../../packages/evals/dist/model-improvement-qualification.js
+var BoundedTextSchema4 = external_exports.string().trim().min(1).max(1e5);
+var ModelImprovementDecisionSchema = external_exports.enum([
+  "no_training",
+  "sft",
+  "preference",
+  "rl"
+]);
+var ModelImprovementSignalSchema = external_exports.object({
+  kind: external_exports.enum(["none", "demonstrations", "chosen_rejected", "scalar_reward"]),
+  strength: external_exports.enum(["absent", "weak", "usable"]),
+  calibrated: external_exports.boolean(),
+  confounded: external_exports.boolean(),
+  variance: external_exports.number().finite().nonnegative().nullable(),
+  evidenceRefs: external_exports.array(ImmutableReleaseRefSchema).max(1e5)
+}).strict();
+var ModelImprovementQualificationReceiptContentSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelImprovementQualificationReceipt.v1"),
+  id: ReleaseIdSchema,
+  review: ImmutableReleaseRefSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  tasksetRelease: ImmutableReleaseRefSchema.nullable(),
+  baselineEvaluation: ImmutableReleaseRefSchema.nullable(),
+  model: ModelRefSchema,
+  environmentHash: ReleaseHashSchema.nullable(),
+  toolContractHash: ReleaseHashSchema.nullable(),
+  permissionContractHash: ReleaseHashSchema.nullable(),
+  policyHash: ReleaseHashSchema.nullable(),
+  verifierRef: ImmutableReleaseRefSchema.nullable(),
+  sourcePolicies: external_exports.array(HarnessReviewSourcePolicyRefSchema).max(1e4),
+  trainingEvidenceRefs: external_exports.array(ImmutableReleaseRefSchema).max(1e5),
+  frozenEvaluationEvidenceRefs: external_exports.array(ImmutableReleaseRefSchema).max(1e5),
+  privacyApproval: ImmutableReleaseRefSchema.nullable(),
+  budgetApproval: ImmutableReleaseRefSchema.nullable(),
+  maximumCostUsd: external_exports.number().finite().nonnegative(),
+  signal: ModelImprovementSignalSchema,
+  decision: ModelImprovementDecisionSchema,
+  reasons: external_exports.array(BoundedTextSchema4).min(1).max(100),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema
+}).strict().superRefine((receipt, context) => {
+  const trainingKeys = new Set(receipt.trainingEvidenceRefs.map(refKey));
+  if (receipt.frozenEvaluationEvidenceRefs.some((reference2) => trainingKeys.has(refKey(reference2)))) {
+    context.addIssue({
+      code: "custom",
+      message: "frozen Evaluation evidence cannot be used as training evidence",
+      path: ["frozenEvaluationEvidenceRefs"]
+    });
+  }
+  if (receipt.decision === "no_training")
+    return;
+  const missingGate = !receipt.tasksetRelease || !receipt.baselineEvaluation || !receipt.environmentHash || !receipt.toolContractHash || !receipt.permissionContractHash || !receipt.policyHash || !receipt.verifierRef || !receipt.privacyApproval || !receipt.budgetApproval || receipt.sourcePolicies.length === 0 || receipt.sourcePolicies.some((policy) => policy.state !== "authorized") || receipt.trainingEvidenceRefs.length === 0 || receipt.signal.strength !== "usable" || !receipt.signal.calibrated || receipt.signal.confounded;
+  if (missingGate) {
+    context.addIssue({
+      code: "custom",
+      message: "qualified model improvement requires frozen lineage, authorized signal, privacy, and budget gates"
+    });
+  }
+  if (receipt.decision === "sft" && receipt.signal.kind !== "demonstrations") {
+    context.addIssue({
+      code: "custom",
+      message: "SFT qualification requires demonstration signal",
+      path: ["signal", "kind"]
+    });
+  }
+  if (receipt.decision === "preference" && receipt.signal.kind !== "chosen_rejected") {
+    context.addIssue({
+      code: "custom",
+      message: "preference qualification requires chosen/rejected signal",
+      path: ["signal", "kind"]
+    });
+  }
+  if (receipt.decision === "rl" && (receipt.signal.kind !== "scalar_reward" || receipt.signal.variance === null || receipt.signal.variance <= 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "RL qualification requires a usable scalar reward with variance",
+      path: ["signal"]
+    });
+  }
+});
+var ModelImprovementQualificationReceiptSchema = ModelImprovementQualificationReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+function createModelImprovementQualificationReceipt(input) {
+  const content = ModelImprovementQualificationReceiptContentSchema.parse(input);
+  return ModelImprovementQualificationReceiptSchema.parse({
+    ...content,
+    contentHash: contentHash(content)
+  });
+}
+function refKey(reference2) {
+  return `${reference2.id}:${reference2.contentHash}`;
+}
+
+// ../../packages/evals/dist/review-conformance.js
+var createdAt = "2026-08-08T12:00:00.000Z";
+var harnessRelease = ref("harness-release");
+var sourcePolicy = {
+  policy: ref("source-policy"),
+  state: "authorized",
+  checkedAt: createdAt
+};
+var evidence = (id, kind) => ({
+  evidence: ref(id),
+  kind,
+  sourceRef: `source-${id}`,
+  sourcePolicy,
+  occurrenceKey: contentHash(`occurrence-${id}`),
+  occurredAt: createdAt
+});
+var watermark = {
+  cursor: contentHash("review-watermark"),
+  throughCreatedAt: createdAt
+};
+var claim = (family, count = 3) => ({
+  fingerprint: contentHash(`claim-${family}`),
+  recurrenceFamily: family,
+  statement: `The ${family} behavior remains unresolved after smaller-layer triage.`,
+  independentOccurrences: count,
+  unresolvedOccurrences: count
+});
+var noAction = createHarnessEvaluationReviewReceipt({
+  schemaVersion: "openpond.harnessEvaluationReviewReceipt.v1",
+  id: "review-no-action",
+  ownerScope: { kind: "personal", id: "owner-1" },
+  workspaceRef: "workspace-1",
+  harnessRelease,
+  previousWatermark: null,
+  nextWatermark: watermark,
+  selectedEvidence: [],
+  excludedEvidence: [],
+  claim: null,
+  classification: "no_action",
+  triage: [],
+  reason: "The bounded evidence window contains no unresolved reusable claim.",
+  nextAuthority: "none",
+  maxEstimatedCostUsd: 0,
+  tasksetProposal: null,
+  evaluation: null,
+  trainingQualification: null,
+  policyVersion: "harness-review-policy-v1",
+  createdAt,
+  metadata: {}
+});
+var runtime = createHarnessEvaluationReviewReceipt({
+  ...withoutHash2(noAction),
+  id: "review-runtime",
+  selectedEvidence: [evidence("runtime-failure", "observation")],
+  claim: claim("runtime-transport-failure", 1),
+  classification: "runtime",
+  triage: [
+    {
+      layer: "runtime",
+      status: "unresolved",
+      reason: "The adapter failed before model policy could affect the result.",
+      evidenceRefs: [ref("runtime-failure")]
+    }
+  ],
+  reason: "A deterministic runtime regression is the smallest correct fix.",
+  nextAuthority: "runtime_service"
+});
+var product = createHarnessEvaluationReviewReceipt({
+  ...withoutHash2(noAction),
+  id: "review-product",
+  selectedEvidence: [evidence("product-routing", "route_decision")],
+  claim: claim("product-routing-defect", 1),
+  classification: "product",
+  triage: [
+    {
+      layer: "product",
+      status: "unresolved",
+      reason: "The product selected an unrelated Skill for an ordinary Work turn.",
+      evidenceRefs: [ref("product-routing")]
+    }
+  ],
+  reason: "Product routing must be corrected before behavioral Evaluation.",
+  nextAuthority: "product_team"
+});
+var taskset = createHarnessEvaluationReviewReceipt({
+  ...withoutHash2(noAction),
+  id: "review-taskset",
+  selectedEvidence: [
+    evidence("failure-1", "work_outcome"),
+    evidence("failure-2", "work_outcome"),
+    evidence("failure-3", "work_outcome")
+  ],
+  claim: claim("search-budget-allocation"),
+  classification: "taskset",
+  triage: [
+    {
+      layer: "harness",
+      status: "unresolved",
+      reason: "The active research Skill did not resolve three independent failures.",
+      evidenceRefs: [ref("failure-1"), ref("failure-2"), ref("failure-3")]
+    }
+  ],
+  reason: "The repeated behavioral claim now needs controlled measurement.",
+  nextAuthority: "human_review",
+  tasksetProposal: ref("taskset-proposal"),
+  maxEstimatedCostUsd: 2
+});
+var blockedRl = createModelImprovementQualificationReceipt({
+  schemaVersion: "openpond.modelImprovementQualificationReceipt.v1",
+  id: "qualification-rl-blocked",
+  review: reference(taskset),
+  harnessRelease,
+  tasksetRelease: ref("taskset-release"),
+  baselineEvaluation: ref("baseline-evaluation"),
+  model: modelRef(),
+  environmentHash: contentHash("environment"),
+  toolContractHash: contentHash("tools"),
+  permissionContractHash: contentHash("permissions"),
+  policyHash: contentHash("policy"),
+  verifierRef: ref("verifier"),
+  sourcePolicies: [sourcePolicy],
+  trainingEvidenceRefs: [ref("training-evidence")],
+  frozenEvaluationEvidenceRefs: [ref("frozen-evidence")],
+  privacyApproval: ref("privacy-approval"),
+  budgetApproval: ref("budget-approval"),
+  maximumCostUsd: 25,
+  signal: {
+    kind: "scalar_reward",
+    strength: "weak",
+    calibrated: true,
+    confounded: false,
+    variance: 0,
+    evidenceRefs: [ref("reward-audit")]
+  },
+  decision: "no_training",
+  reasons: ["The observed reward is constant and cannot support RL."],
+  createdAt,
+  metadata: { blockedMethod: "rl" }
+});
+var qualifiedRl = createModelImprovementQualificationReceipt({
+  ...withoutHash2(blockedRl),
+  id: "qualification-rl-qualified",
+  signal: {
+    kind: "scalar_reward",
+    strength: "usable",
+    calibrated: true,
+    confounded: false,
+    variance: 0.18,
+    evidenceRefs: [ref("reward-audit")]
+  },
+  decision: "rl",
+  reasons: [
+    "The frozen baseline has usable variance and a calibrated sequential reward."
+  ]
+});
+var modelImprovement = createHarnessEvaluationReviewReceipt({
+  ...withoutHash2(noAction),
+  id: "review-model-improvement",
+  selectedEvidence: [
+    evidence("baseline-evaluation", "evaluation"),
+    evidence("qualification-rl-qualified", "training_qualification")
+  ],
+  claim: claim("search-budget-allocation"),
+  classification: "model_improvement",
+  triage: [
+    {
+      layer: "model",
+      status: "unresolved",
+      reason: "Harness, runtime, product, retrieval, and tool triage left a qualified sequential policy gap.",
+      evidenceRefs: [ref("baseline-evaluation"), reference(qualifiedRl)]
+    }
+  ],
+  reason: "The qualified claim may proceed to a separately approved managed-training plan.",
+  nextAuthority: "training_system",
+  tasksetProposal: ref("taskset-proposal"),
+  evaluation: ref("baseline-evaluation"),
+  trainingQualification: reference(qualifiedRl),
+  maxEstimatedCostUsd: 25
+});
+function ref(id) {
+  return { id, contentHash: contentHash(id) };
+}
+function reference(value) {
+  return { id: value.id, contentHash: value.contentHash };
+}
+function withoutHash2(value) {
+  const { contentHash: _contentHash, ...content } = value;
+  return content;
+}
+function modelRef() {
+  return {
+    provider: "openpond",
+    model: "openpond-chat",
+    revision: "model-revision-1",
+    artifactHash: contentHash("model-artifact"),
+    tokenizerRevision: "tokenizer-1",
+    chatTemplateHash: contentHash("chat-template")
+  };
+}
+
 export {
   CONNECTED_APP_PROVIDER_TOOL_NAMES,
   CONNECTED_APP_TOOL_CALL_ENDPOINT,
@@ -4000,6 +4483,10 @@ export {
   createHarnessImprovementProposal,
   createHarnessTargetedValidationReceipt,
   createHarnessAdvanceReceipt,
+  HarnessReviewSourcePolicyRefSchema,
+  HarnessReviewWatermarkSchema,
+  HarnessEvaluationReviewReceiptSchema,
+  createHarnessEvaluationReviewReceipt,
   ToolDeclarationSchema,
   CapabilityRequirementSchema,
   AgentSnapshotSchema,
@@ -4032,6 +4519,7 @@ export {
   sameWorkspaceRevision,
   stableId2 as stableId,
   AttemptReceiptSchema,
+  EvaluationResultSchema,
   createRunManifest,
   createAttemptReceipt,
   aggregateEvaluationReceipts,
@@ -4050,5 +4538,7 @@ export {
   createWorkFeedbackReceipt,
   workEvidenceReceiptRef,
   WorkEvidencePolicyStateSchema,
-  classifyWorkEvidence
+  classifyWorkEvidence,
+  ModelImprovementQualificationReceiptSchema,
+  createModelImprovementQualificationReceipt
 };

package/dist/chunks/{cli-UU4WCREM.js → cli-64VFZWFY.js}

@@ -3,12 +3,12 @@ import {
   resolveWebLaunchMessages,
   runOpenPondAppServerCli,
   runOpenPondServerCli
-} from "./chunk-YYLUURQ4.js";
-import "./chunk-YEKQWRBS.js";
-import "./chunk-ZTE6A2VE.js";
-import "./chunk-L7SIUJEV.js";
-import "./chunk-2SF6HLT7.js";
-import "./chunk-M2NXTLH2.js";
+} from "./chunk-JBUNQVLP.js";
+import "./chunk-SLTKA5AW.js";
+import "./chunk-2NP3E4GP.js";
+import "./chunk-HKJG7VBI.js";
+import "./chunk-53YZBGDC.js";
+import "./chunk-ZXWFYFFB.js";
 import "./chunk-WYDVQOBL.js";
 import "./chunk-KHNHUA2H.js";
 import "./chunk-UACZUFIA.js";