openpond-sdk 0.3.3 → 0.4.0

package/dist/chunk-IVEXCIHO.js

@@ -0,0 +1,1373 @@
+import {
+  FailureClassSchema,
+  HarnessRefinerCapabilitiesSchema,
+  HarnessRefinerEvidenceBasisSchema,
+  ImmutableArtifactRefSchema,
+  ImmutableAssetRefSchema,
+  ImmutableReleaseRefSchema,
+  MetadataSchema,
+  ReleaseHashSchema,
+  ReleaseIdSchema,
+  ReleaseTimestampSchema,
+  contentHash
+} from "./chunk-ZPCK222K.js";
+
+// ../harness/dist/tools.js
+import { z } from "zod";
+var ToolDeclarationSchema = z.object({
+  name: z.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z.string().trim().min(1).max(2e3),
+  inputSchema: z.record(z.string(), z.unknown()),
+  inputSchemaHash: ReleaseHashSchema,
+  sideEffect: z.enum(["read", "write"]),
+  timeoutMs: z.number().int().positive().max(36e5)
+}).strict();
+var CapabilityRequirementSchema = z.object({
+  id: ReleaseIdSchema,
+  required: z.boolean(),
+  scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([]),
+  portability: z.enum(["portable", "host_adapter", "local_only", "hosted_only"])
+}).strict();
+
+// ../harness/dist/models.js
+import { z as z2 } from "zod";
+var ModelRefSchema = z2.object({
+  provider: ReleaseIdSchema,
+  model: ReleaseIdSchema,
+  revision: z2.string().trim().min(1).max(500).nullable().default(null),
+  artifactHash: ReleaseHashSchema.nullable().default(null),
+  tokenizerRevision: z2.string().trim().min(1).max(500).nullable().default(null),
+  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
+}).strict();
+var PROVIDER_IDS = [
+  "openpond",
+  "codex",
+  "anthropic",
+  "openai",
+  "xai",
+  "google",
+  "openrouter",
+  "deepseek",
+  "zai",
+  "moonshot",
+  "together",
+  "groq",
+  "custom-openai-compatible"
+];
+var ProviderIdSchema = z2.enum(PROVIDER_IDS);
+var ChatModelRefSchema = z2.object({
+  providerId: ProviderIdSchema,
+  modelId: z2.string().trim().min(1).max(300)
+});
+
+// ../harness/dist/evaluation-review.js
+import { z as z3 } from "zod";
+var BoundedTextSchema = z3.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = z3.enum([
+  "no_action",
+  "harness_maintenance",
+  "runtime",
+  "product",
+  "taskset",
+  "model_improvement"
+]);
+var HarnessEvaluationReviewAuthoritySchema = z3.enum([
+  "none",
+  "runtime_service",
+  "product_team",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var HarnessReviewEvidenceKindSchema = z3.enum([
+  "observation",
+  "trigger",
+  "route_decision",
+  "refiner_outcome",
+  "proposal",
+  "validation",
+  "apply_receipt",
+  "harness_advance",
+  "rollback",
+  "work_outcome",
+  "taskset",
+  "evaluation",
+  "training_qualification",
+  "model_candidate"
+]);
+var HarnessReviewOwnerScopeSchema = z3.object({
+  kind: z3.enum(["personal", "team"]),
+  id: ReleaseIdSchema
+}).strict();
+var HarnessReviewSourcePolicyRefSchema = z3.object({
+  policy: ImmutableReleaseRefSchema,
+  state: z3.enum(["authorized", "revoked", "deleted", "expired"]),
+  checkedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewEvidenceRefSchema = z3.object({
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
+  occurrenceKey: ReleaseHashSchema,
+  occurredAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewExcludedEvidenceSchema = z3.object({
+  evidence: ImmutableReleaseRefSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
+  reason: z3.enum([
+    "outside_scope",
+    "before_watermark",
+    "duplicate",
+    "resolved",
+    "revoked",
+    "deleted",
+    "expired",
+    "sensitive",
+    "unverified",
+    "budget"
+  ])
+}).strict();
+var HarnessReviewWatermarkSchema = z3.object({
+  cursor: ReleaseHashSchema,
+  throughCreatedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewClaimSchema = z3.object({
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z3.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  candidateDisposition: z3.enum(["observe", "confirm"]).optional(),
+  independentOccurrences: z3.number().int().positive().max(1e6),
+  unresolvedOccurrences: z3.number().int().positive().max(1e6)
+}).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
+var HarnessReviewTriageLayerSchema = z3.enum([
+  "harness",
+  "runtime",
+  "product",
+  "retrieval",
+  "tools",
+  "evaluation",
+  "model"
+]);
+var HarnessReviewTriageDecisionSchema = z3.object({
+  layer: HarnessReviewTriageLayerSchema,
+  status: z3.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  reason: BoundedTextSchema,
+  evidenceRefs: z3.array(ImmutableReleaseRefSchema).max(1e3)
+}).strict();
+var HarnessEvaluationReviewReceiptContentSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
+  nextWatermark: HarnessReviewWatermarkSchema,
+  selectedEvidence: z3.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: z3.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  claim: HarnessReviewClaimSchema.nullable(),
+  classification: HarnessEvaluationReviewClassificationSchema,
+  triage: z3.array(HarnessReviewTriageDecisionSchema).max(16),
+  reason: BoundedTextSchema,
+  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
+  maxEstimatedCostUsd: z3.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();
+var HarnessEvaluationReviewModelEvidenceSchema = z3.object({
+  id: ReleaseIdSchema,
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  occurredAt: ReleaseTimestampSchema,
+  payload: z3.record(z3.string(), z3.unknown())
+}).strict();
+var HarnessEvaluationReviewModelNoActionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z3.literal("no_action"),
+  reason: BoundedTextSchema,
+  ignoredEvidence: z3.array(z3.object({
+    id: ReleaseIdSchema,
+    reason: z3.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3)
+}).strict();
+var HarnessEvaluationReviewModelActionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z3.literal("review"),
+  classification: z3.enum([
+    "harness_maintenance",
+    "runtime",
+    "product",
+    "taskset"
+  ]),
+  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z3.array(z3.object({
+    id: ReleaseIdSchema,
+    reason: z3.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  recurrenceFamily: z3.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  triageLayer: HarnessReviewTriageLayerSchema,
+  expectedOutcome: BoundedTextSchema,
+  counterevidence: z3.string().trim().max(1e4),
+  confidence: z3.number().min(0).max(1),
+  candidateDisposition: z3.enum(["observe", "confirm"]).nullable(),
+  reason: BoundedTextSchema
+}).strict().superRefine((decision, context) => {
+  const requiresDisposition = decision.classification === "harness_maintenance";
+  if (requiresDisposition !== (decision.candidateDisposition !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "Harness maintenance requires a candidate disposition; external routes require null",
+      path: ["candidateDisposition"]
+    });
+  }
+});
+var HarnessEvaluationReviewModelResolutionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z3.literal("resolve_candidate"),
+  candidateId: ReleaseIdSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z3.array(z3.object({
+    id: ReleaseIdSchema,
+    reason: z3.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  confidence: z3.number().min(0).max(1),
+  reason: BoundedTextSchema
+}).strict();
+var HarnessEvaluationReviewModelDecisionSchema = z3.discriminatedUnion("decision", [
+  HarnessEvaluationReviewModelNoActionSchema,
+  HarnessEvaluationReviewModelActionSchema,
+  HarnessEvaluationReviewModelResolutionSchema
+]);
+var HarnessEvaluationReviewNavigationDecisionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
+  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(50),
+  reason: BoundedTextSchema
+}).strict();
+
+// ../harness/dist/harness.js
+import { z as z4 } from "zod";
+var PortabilityReportSchema = z4.object({
+  portable: z4.boolean(),
+  blockers: z4.array(z4.string().trim().min(1).max(2e3)).max(1e3),
+  localOnlyAssetRefs: z4.array(ReleaseIdSchema).max(1e4),
+  hostPrivateAssetRefs: z4.array(ReleaseIdSchema).max(1e4)
+}).strict();
+var AgentSnapshotContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.agentSnapshot.v2"),
+  id: ReleaseIdSchema,
+  sourceRelease: ImmutableReleaseRefSchema.nullable(),
+  instructions: z4.array(ImmutableAssetRefSchema).max(1e4),
+  skills: z4.array(ImmutableAssetRefSchema).max(1e4),
+  agents: z4.array(ImmutableAssetRefSchema).max(1e4),
+  toolDeclarations: z4.array(ToolDeclarationSchema).max(200),
+  capabilityRequirements: z4.array(CapabilityRequirementSchema).max(200),
+  dependencyLock: ImmutableAssetRefSchema,
+  portability: PortabilityReportSchema,
+  metadata: MetadataSchema
+}).strict();
+var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var LifecycleContractSchema = z4.object({
+  create: z4.literal(true),
+  reset: z4.literal(true),
+  step: z4.literal(true),
+  collect: z4.literal(true),
+  destroy: z4.literal(true),
+  resetScope: z4.enum(["task", "attempt"])
+}).strict();
+var GraderInterfaceContractSchema = z4.object({
+  visibleEvidence: z4.array(ReleaseIdSchema).max(1e3),
+  privilegedEvidence: z4.array(ReleaseIdSchema).max(1e3),
+  privateVerifierIsolation: z4.boolean()
+}).strict();
+var HarnessReleaseContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessRelease.v2"),
+  id: ReleaseIdSchema,
+  agentSnapshot: ImmutableReleaseRefSchema,
+  program: ImmutableAssetRefSchema,
+  tools: z4.array(ToolDeclarationSchema).max(200),
+  lifecycle: LifecycleContractSchema,
+  graderInterface: GraderInterfaceContractSchema,
+  files: z4.array(ImmutableAssetRefSchema).max(1e5),
+  metadata: MetadataSchema
+}).strict();
+var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var ModelActionSchema = z4.object({
+  id: ReleaseIdSchema,
+  turn: z4.number().int().nonnegative(),
+  kind: z4.enum(["message", "tool_call", "terminal"]),
+  name: ReleaseIdSchema.nullable(),
+  arguments: z4.record(z4.string(), z4.unknown()),
+  content: z4.string().max(1e6).nullable()
+}).strict();
+var ToolObservationSchema = z4.object({
+  actionId: ReleaseIdSchema,
+  turn: z4.number().int().nonnegative(),
+  terminal: z4.boolean(),
+  output: z4.record(z4.string(), z4.unknown()),
+  artifactRefs: z4.array(ImmutableArtifactRefSchema).max(1e5)
+}).strict();
+var HarnessLifecycleEventSchema = z4.object({
+  sequence: z4.number().int().nonnegative(),
+  type: z4.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
+  payloadHash: ReleaseHashSchema,
+  metadata: MetadataSchema
+}).strict();
+var HarnessTraceSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessTrace.v1"),
+  manifest: ImmutableReleaseRefSchema,
+  taskId: ReleaseIdSchema,
+  seed: z4.string().trim().min(1).max(500),
+  events: z4.array(HarnessLifecycleEventSchema).max(1e6),
+  actions: z4.array(ModelActionSchema).max(1e5),
+  observations: z4.array(ToolObservationSchema).max(1e5),
+  terminal: z4.boolean(),
+  failureClass: FailureClassSchema.nullable(),
+  output: z4.record(z4.string(), z4.unknown()),
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/harness-improvements.js
+import { z as z6 } from "zod";
+
+// ../harness/dist/harness-workspaces.js
+import { z as z5 } from "zod";
+var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
+var RevisionSchema = z5.number().int().nonnegative();
+var BoundedTextSchema2 = z5.string().trim().min(1).max(1e5);
+var HarnessOwnerScopeSchema = z5.object({
+  kind: z5.enum(["personal", "team"]),
+  id: ReleaseIdSchema
+}).strict();
+var HarnessCurrentChannelSchema = z5.object({
+  name: ReleaseIdSchema,
+  release: ImmutableReleaseRefSchema.nullable(),
+  revision: RevisionSchema
+}).strict();
+var HarnessWorkspaceSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessWorkspace.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessOwnerScopeSchema,
+  name: z5.string().trim().min(1).max(240),
+  location: z5.enum(["local", "hosted"]),
+  sourceRevision: z5.string().trim().min(1).max(500),
+  revision: RevisionSchema,
+  dirty: z5.boolean(),
+  currentChannel: HarnessCurrentChannelSchema,
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessImprovementRouteSchema = z5.enum([
+  "runtime",
+  "memory",
+  "prompt",
+  "skill",
+  "agent",
+  "product",
+  "taskset",
+  "training"
+]);
+var HarnessChangeEffectSchema = z5.enum([
+  "text_instruction",
+  "memory",
+  "dependency_selection",
+  "executable_code",
+  "business_logic",
+  "financial_logic",
+  "permission",
+  "connected_app",
+  "publication",
+  "deployment",
+  "training",
+  "model_binding",
+  "team_or_global"
+]);
+var HarnessOverlayEditSchema = z5.object({
+  id: ReleaseIdSchema,
+  route: HarnessImprovementRouteSchema,
+  operation: z5.enum(["create", "update", "delete"]),
+  target: z5.string().trim().min(1).max(2e3),
+  summary: z5.string().trim().min(1).max(2e3),
+  content: z5.string().max(1e6).nullable(),
+  contentHash: ReleaseHashSchema.nullable(),
+  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20)
+}).strict().superRefine((edit, context) => {
+  if (edit.operation === "delete") {
+    if (edit.content !== null || edit.contentHash !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "delete edits cannot include replacement content",
+        path: ["content"]
+      });
+    }
+    return;
+  }
+  if (edit.content === null || edit.contentHash === null) {
+    context.addIssue({
+      code: "custom",
+      message: "create and update edits require content and contentHash",
+      path: ["content"]
+    });
+    return;
+  }
+  const expected = contentHash(edit.content);
+  if (edit.contentHash !== expected) {
+    context.addIssue({
+      code: "custom",
+      message: `edit contentHash is ${edit.contentHash}; expected ${expected}`,
+      path: ["contentHash"]
+    });
+  }
+});
+var HarnessWorkspaceRevisionRefSchema = z5.object({
+  workspaceId: ReleaseIdSchema,
+  revision: RevisionSchema,
+  sourceRevision: z5.string().trim().min(1).max(500),
+  channelRevision: RevisionSchema
+}).strict();
+var HarnessOverlaySnapshotRefSchema = z5.object({
+  id: ReleaseIdSchema,
+  revision: RevisionSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessTurnSnapshotSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessTurnSnapshot.v1"),
+  workspaceId: ReleaseIdSchema,
+  workspaceRevision: RevisionSchema,
+  sourceRevision: z5.string().trim().min(1).max(500),
+  channelName: ReleaseIdSchema,
+  channelRevision: RevisionSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  toolCatalogHash: ReleaseHashSchema.nullable().optional(),
+  overlay: HarnessOverlaySnapshotRefSchema.nullable().optional().default(null)
+}).strict();
+var HarnessRunOverlayContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessRunOverlay.v1"),
+  id: ReleaseIdSchema,
+  runId: ReleaseIdSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  workspace: HarnessWorkspaceRevisionRefSchema,
+  revision: RevisionSchema,
+  status: z5.enum(["active", "frozen", "abandoned"]),
+  edits: z5.array(HarnessOverlayEditSchema).max(1e3),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessProposalEvidenceRefSchema = z5.object({
+  kind: z5.enum([
+    "tool_event",
+    "recovery",
+    "validation",
+    "user_turn",
+    "work_output",
+    "work_receipt"
+  ]),
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema.nullable()
+}).strict();
+var HarnessValidationPlanItemSchema = z5.object({
+  id: ReleaseIdSchema,
+  kind: z5.enum([
+    "dependency",
+    "schema",
+    "package",
+    "file_render",
+    "skill",
+    "prompt",
+    "business_formula",
+    "targeted_evaluation",
+    "observed_recovery",
+    "memory",
+    "component_activation"
+  ]),
+  description: BoundedTextSchema2,
+  required: z5.boolean()
+}).strict();
+var HarnessImprovementProposalContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessImprovementProposal.v1"),
+  id: ReleaseIdSchema,
+  overlay: HarnessOverlaySnapshotRefSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
+  requestedScope: z5.enum(["personal", "team", "global"]),
+  route: HarnessImprovementRouteSchema,
+  risk: z5.enum(["low", "review", "restricted"]),
+  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20),
+  evidence: z5.array(HarnessProposalEvidenceRefSchema).min(1).max(1e3),
+  edits: z5.array(HarnessOverlayEditSchema).min(1).max(1e3),
+  validationPlan: z5.array(HarnessValidationPlanItemSchema).min(1).max(100),
+  expectedOutcome: BoundedTextSchema2,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((proposal, context) => {
+  const declaredEffects = new Set(proposal.effects);
+  for (const [index, edit] of proposal.edits.entries()) {
+    if (edit.route !== proposal.route) {
+      context.addIssue({
+        code: "custom",
+        message: "every edit route must match the proposal route",
+        path: ["edits", index, "route"]
+      });
+    }
+    for (const effect of edit.effects) {
+      if (!declaredEffects.has(effect)) {
+        context.addIssue({
+          code: "custom",
+          message: `edit effect ${effect} is missing from proposal effects`,
+          path: ["edits", index, "effects"]
+        });
+      }
+    }
+  }
+  if (new Set(proposal.validationPlan.map((item) => item.id)).size !== proposal.validationPlan.length) {
+    context.addIssue({
+      code: "custom",
+      message: "validation plan ids must be unique",
+      path: ["validationPlan"]
+    });
+  }
+});
+var HarnessImprovementProposalSchema = HarnessImprovementProposalContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessTargetedValidationReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessTargetedValidationReceipt.v1"),
+  id: ReleaseIdSchema,
+  proposal: ImmutableReleaseRefSchema,
+  validationId: ReleaseIdSchema,
+  kind: HarnessValidationPlanItemSchema.shape.kind,
+  status: z5.enum(["passed", "failed", "blocked", "skipped"]),
+  summary: BoundedTextSchema2,
+  evidenceRefs: z5.array(HarnessProposalEvidenceRefSchema).max(1e3),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessAdvanceDecisionSchema = z5.enum([
+  "advanced",
+  "retained",
+  "conflict",
+  "rolled_back"
+]);
+var HarnessAdvanceReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessAdvanceReceipt.v1"),
+  id: ReleaseIdSchema,
+  workspaceId: ReleaseIdSchema,
+  ownerScope: HarnessOwnerScopeSchema,
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  expectedWorkspaceRevision: RevisionSchema,
+  observedWorkspaceRevision: RevisionSchema,
+  previousChannelRevision: RevisionSchema,
+  nextChannelRevision: RevisionSchema,
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema.nullable(),
+  validationReceipts: z5.array(ImmutableReleaseRefSchema).max(100),
+  decision: HarnessAdvanceDecisionSchema,
+  reason: BoundedTextSchema2,
+  rollbackOf: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((receipt, context) => {
+  const changed = receipt.nextChannelRevision === receipt.previousChannelRevision + 1;
+  if (["advanced", "rolled_back"].includes(receipt.decision) !== changed) {
+    context.addIssue({
+      code: "custom",
+      message: "only successful advancement or rollback increments the channel revision",
+      path: ["nextChannelRevision"]
+    });
+  }
+  if (receipt.decision === "rolled_back" && receipt.rollbackOf === null) {
+    context.addIssue({
+      code: "custom",
+      message: "rollback receipts require rollbackOf",
+      path: ["rollbackOf"]
+    });
+  }
+  if (receipt.decision !== "rolled_back" && receipt.rollbackOf !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "rollbackOf is only valid for rollback receipts",
+      path: ["rollbackOf"]
+    });
+  }
+});
+var HarnessAdvanceReceiptSchema = HarnessAdvanceReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessOverlayMergeReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessOverlayMergeReceipt.v1"),
+  id: ReleaseIdSchema,
+  workspaceId: ReleaseIdSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  leftOverlay: HarnessOverlaySnapshotRefSchema,
+  rightOverlay: HarnessOverlaySnapshotRefSchema,
+  decision: z5.enum(["merged", "conflict"]),
+  mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  conflictTargets: z5.array(z5.string().trim().min(1).max(2e3)).max(1e3),
+  requiresRevalidation: z5.literal(true),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "merged" !== (receipt.mergedOverlay !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "merged decisions require a merged overlay; conflicts cannot provide one",
+      path: ["mergedOverlay"]
+    });
+  }
+  if (receipt.decision === "conflict" !== receipt.conflictTargets.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "conflict decisions require conflict targets and merged decisions cannot include them",
+      path: ["conflictTargets"]
+    });
+  }
+});
+var HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/harness-improvements.js
+var BoundedTextSchema3 = z6.string().trim().min(1).max(1e5);
+var MetadataSchema3 = z6.record(z6.string(), z6.unknown()).default({});
+var ImprovementSafeBoundaryKindSchema = z6.enum([
+  "completed_tool_batch",
+  "before_model_step",
+  "turn_completed",
+  "turn_paused"
+]);
+var ImprovementSafeBoundarySchema = z6.object({
+  kind: ImprovementSafeBoundaryKindSchema,
+  eventSequence: z6.number().int().nonnegative(),
+  occurredAt: ReleaseTimestampSchema
+}).strict();
+var ImprovementEventRefSchema = z6.object({
+  id: ReleaseIdSchema,
+  sequence: z6.number().int().nonnegative().nullable(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementObservationKindSchema = z6.enum([
+  "tool_failure",
+  "retry",
+  "recovery",
+  "validation",
+  "user_turn",
+  "reusable_success",
+  "completion_detour"
+]);
+var ImprovementObservationStateSchema = z6.enum([
+  "open",
+  "recovered",
+  "terminal"
+]);
+var ImprovementToolIdentitySchema = z6.object({
+  name: z6.string().trim().min(1).max(500),
+  invocationKey: ReleaseHashSchema
+}).strict();
+var ImprovementObservationContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementObservation.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  eventRefs: z6.array(ImprovementEventRefSchema).min(1).max(100),
+  kind: ImprovementObservationKindSchema,
+  state: ImprovementObservationStateSchema,
+  tool: ImprovementToolIdentitySchema.nullable(),
+  deterministicClass: z6.string().trim().min(1).max(500).nullable(),
+  summary: BoundedTextSchema3,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((observation, context) => {
+  if (new Set(observation.eventRefs.map((reference) => reference.id)).size !== observation.eventRefs.length) {
+    context.addIssue({
+      code: "custom",
+      message: "observation event refs must be unique",
+      path: ["eventRefs"]
+    });
+  }
+  if (["tool_failure", "retry", "recovery", "completion_detour"].includes(observation.kind) && observation.tool === null) {
+    context.addIssue({
+      code: "custom",
+      message: `${observation.kind} observations require a tool identity`,
+      path: ["tool"]
+    });
+  }
+});
+var ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinementTriggerPolicySchema = z6.object({
+  schemaVersion: z6.literal("openpond.refinementTriggerPolicy.v1"),
+  maxEstimatedCostUsd: z6.number().finite().nonnegative(),
+  cooldownMs: z6.number().int().nonnegative(),
+  maxPendingPlans: z6.number().int().min(1).max(100),
+  maxEvidenceEvents: z6.number().int().min(1).max(1e3),
+  maxProposalEdits: z6.number().int().min(1).max(1e3),
+  maxProposalBytes: z6.number().int().min(1).max(1e7)
+}).strict();
+var RefinementTriggerDecisionKindSchema = z6.enum([
+  "no_action",
+  "route_deterministically",
+  "queue_refiner"
+]);
+var RefinementTriggerDecisionContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.refinementTriggerDecision.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  observations: z6.array(ImmutableReleaseRefSchema).max(100),
+  decision: RefinementTriggerDecisionKindSchema,
+  deterministicRoute: HarnessImprovementRouteSchema.nullable(),
+  suggestedRoutes: z6.array(HarnessImprovementRouteSchema).max(8),
+  reason: BoundedTextSchema3,
+  deduplicationKey: ReleaseHashSchema,
+  policy: RefinementTriggerPolicySchema,
+  estimatedMaxCostUsd: z6.number().finite().nonnegative(),
+  pendingPlanCount: z6.number().int().nonnegative(),
+  boundary: ImprovementSafeBoundarySchema,
+  cooldownUntil: ReleaseTimestampSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((trigger, context) => {
+  if (trigger.estimatedMaxCostUsd > trigger.policy.maxEstimatedCostUsd) {
+    context.addIssue({
+      code: "custom",
+      message: "estimated Refiner cost exceeds the trigger policy budget",
+      path: ["estimatedMaxCostUsd"]
+    });
+  }
+  if (trigger.pendingPlanCount > trigger.policy.maxPendingPlans) {
+    context.addIssue({
+      code: "custom",
+      message: "pending plan count exceeds the trigger policy limit",
+      path: ["pendingPlanCount"]
+    });
+  }
+  if (trigger.observations.length > trigger.policy.maxEvidenceEvents) {
+    context.addIssue({
+      code: "custom",
+      message: "trigger observations exceed the evidence budget",
+      path: ["observations"]
+    });
+  }
+  if (trigger.decision === "route_deterministically" && trigger.deterministicRoute === null) {
+    context.addIssue({
+      code: "custom",
+      message: "deterministic decisions require a route",
+      path: ["deterministicRoute"]
+    });
+  }
+  if (trigger.decision !== "route_deterministically" && trigger.deterministicRoute !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "only deterministic decisions may declare a deterministic route",
+      path: ["deterministicRoute"]
+    });
+  }
+  if (trigger.decision === "no_action" && trigger.suggestedRoutes.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "no-action decisions cannot suggest routes",
+      path: ["suggestedRoutes"]
+    });
+  }
+  if (trigger.decision !== "no_action" && trigger.observations.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable trigger decisions require observations",
+      path: ["observations"]
+    });
+  }
+});
+var RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementRouteAuthoritySchema = z6.enum([
+  "runtime_service",
+  "refiner_model",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var ImprovementRouteDecisionContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementRouteDecision.v1"),
+  id: ReleaseIdSchema,
+  trigger: ImmutableReleaseRefSchema,
+  route: HarnessImprovementRouteSchema,
+  authority: ImprovementRouteAuthoritySchema,
+  automatic: z6.boolean(),
+  reason: BoundedTextSchema3,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((decision, context) => {
+  if (decision.automatic && ["human_review", "evaluation_system", "training_system"].includes(decision.authority)) {
+    context.addIssue({
+      code: "custom",
+      message: `${decision.authority} routes cannot be marked automatic`,
+      path: ["automatic"]
+    });
+  }
+  if (decision.route === "training" && decision.automatic && decision.authority !== "training_system") {
+    context.addIssue({
+      code: "custom",
+      message: "automatic training routes require training-system authority",
+      path: ["authority"]
+    });
+  }
+});
+var ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinerOutcomeContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessRefinerOutcome.v1"),
+  id: ReleaseIdSchema,
+  trigger: ImmutableReleaseRefSchema,
+  decision: z6.enum(["no_action", "proposed"]),
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  reason: BoundedTextSchema3,
+  evidenceRefs: z6.array(ImmutableReleaseRefSchema).max(100),
+  estimatedCostUsd: z6.number().finite().nonnegative(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((outcome, context) => {
+  if (outcome.decision === "proposed" !== (outcome.proposal !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "proposed Refiner outcomes require a proposal; no-action outcomes cannot include one",
+      path: ["proposal"]
+    });
+  }
+});
+var HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementApplyDecisionSchema = z6.enum([
+  "applied",
+  "retained",
+  "declined",
+  "conflict",
+  "rolled_back"
+]);
+var ImprovementApplyReceiptContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementApplyReceipt.v1"),
+  id: ReleaseIdSchema,
+  proposal: ImmutableReleaseRefSchema,
+  beforeOverlay: HarnessOverlaySnapshotRefSchema,
+  afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  decision: ImprovementApplyDecisionSchema,
+  boundary: ImprovementSafeBoundarySchema,
+  validationRefs: z6.array(ImmutableReleaseRefSchema).max(100),
+  outcomeEvidenceRefs: z6.array(ImprovementEventRefSchema).max(1e3),
+  rollbackOf: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "applied" !== (receipt.afterOverlay !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "applied receipts require an after-overlay; other decisions cannot include one",
+      path: ["afterOverlay"]
+    });
+  }
+  if (receipt.decision === "rolled_back" !== (receipt.rollbackOf !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only rollback receipts require rollbackOf",
+      path: ["rollbackOf"]
+    });
+  }
+});
+var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/refinement-lifecycle.js
+import { z as z7 } from "zod";
+var ShortTextSchema = z7.string().trim().min(1).max(2e3);
+var BoundedTextSchema4 = z7.string().trim().min(1).max(1e5);
+var HarnessRefinerOperationSchema = z7.enum(["create", "update", "delete"]);
+var HarnessRefinerInternalRouteSchema = z7.enum([
+  "memory",
+  "prompt",
+  "skill",
+  "agent"
+]);
+var HarnessRefinerExternalRouteSchema = z7.enum([
+  "runtime",
+  "product",
+  "taskset",
+  "training"
+]);
+var HarnessRefinerActivityResultSchema = z7.enum([
+  "no_action",
+  "routed",
+  "applied",
+  "retained",
+  "failed"
+]);
+var HarnessRefinerCritiqueStatusSchema = z7.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "rejected",
+  "failed"
+]);
+var HarnessRefinerValidationStatusSchema = z7.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "failed"
+]);
+var HarnessRefinerActivityReceiptContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessRefinerActivityReceipt.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  result: HarnessRefinerActivityResultSchema,
+  decision: z7.enum(["no_action", "route", "propose"]).nullable(),
+  route: HarnessImprovementRouteSchema.nullable(),
+  operation: HarnessRefinerOperationSchema.nullable(),
+  target: z7.string().trim().min(1).max(2e3).nullable(),
+  summary: ShortTextSchema,
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema.nullable(),
+  critiqueStatus: HarnessRefinerCritiqueStatusSchema,
+  validationStatus: HarnessRefinerValidationStatusSchema,
+  trigger: ImmutableReleaseRefSchema,
+  outcome: ImmutableReleaseRefSchema.nullable(),
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  applyReceipt: ImmutableReleaseRefSchema.nullable(),
+  inputHarness: ImmutableReleaseRefSchema,
+  outputHarness: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((receipt, context) => {
+  const proposalResult = receipt.result === "applied" || receipt.result === "retained";
+  if (receipt.result === "no_action") {
+    requireFields(context, receipt, {
+      decision: "no_action",
+      route: null,
+      operation: null,
+      target: null,
+      evidenceBasis: null,
+      proposal: null,
+      applyReceipt: null,
+      outputHarness: null,
+      critiqueStatus: "not_applicable",
+      validationStatus: "not_applicable"
+    });
+  } else if (receipt.result === "routed") {
+    if (receipt.decision !== "route" || !HarnessRefinerExternalRouteSchema.safeParse(receipt.route).success || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis === null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "routed activity requires an external route and evidence basis without proposal state"
+      });
+    }
+    requireFields(context, receipt, {
+      critiqueStatus: "not_applicable",
+      validationStatus: "not_applicable"
+    });
+  } else if (proposalResult) {
+    if (receipt.decision !== "propose" || !HarnessRefinerInternalRouteSchema.safeParse(receipt.route).success || receipt.operation === null || receipt.target === null || receipt.evidenceBasis === null || receipt.proposal === null || receipt.applyReceipt === null) {
+      context.addIssue({
+        code: "custom",
+        message: "applied and retained activity requires complete proposal state"
+      });
+    }
+    if (receipt.result === "applied" && receipt.outputHarness === null) {
+      context.addIssue({
+        code: "custom",
+        message: "applied activity requires the advanced Harness release",
+        path: ["outputHarness"]
+      });
+    }
+    if (receipt.result === "applied" && (receipt.critiqueStatus !== "passed" || receipt.validationStatus !== "passed")) {
+      context.addIssue({
+        code: "custom",
+        message: "applied activity requires passed critique and validation"
+      });
+    }
+    if (receipt.result === "retained" && receipt.outputHarness !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "retained activity cannot report a new Harness release",
+        path: ["outputHarness"]
+      });
+    }
+  } else if (receipt.decision !== null || receipt.route !== null || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis !== null || receipt.outcome !== null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "failed activity cannot claim a decision, route, proposal, or release transition"
+    });
+  }
+  if (receipt.result !== "failed" && receipt.outcome === null) {
+    context.addIssue({
+      code: "custom",
+      message: "terminal Refiner decisions require an outcome reference",
+      path: ["outcome"]
+    });
+  }
+});
+var HarnessRefinerActivityReceiptSchema = HarnessRefinerActivityReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinementCandidateStatusSchema = z7.enum([
+  "unresolved",
+  "confirmed",
+  "resolved",
+  "rejected",
+  "expired"
+]);
+var HarnessRefinementCandidateResolutionSchema = z7.object({
+  kind: z7.enum([
+    "applied_change",
+    "later_success",
+    "manual_rejection",
+    "source_revoked",
+    "expired"
+  ]),
+  reason: BoundedTextSchema4,
+  evidenceRefs: z7.array(ImmutableReleaseRefSchema).max(1e3),
+  resolvedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessRefinementCandidateContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessRefinementCandidate.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z7.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema4,
+  status: HarnessRefinementCandidateStatusSchema,
+  occurrences: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  counterevidence: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  sourceReviews: z7.array(ImmutableReleaseRefSchema).min(1).max(100),
+  relatedHarnessReleases: z7.array(ImmutableReleaseRefSchema).max(100),
+  firstSeenAt: ReleaseTimestampSchema,
+  lastSeenAt: ReleaseTimestampSchema,
+  lastReviewedAt: ReleaseTimestampSchema,
+  expiresAt: ReleaseTimestampSchema,
+  resolution: HarnessRefinementCandidateResolutionSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((candidate, context) => {
+  requireUniqueRefs(context, candidate.occurrences, "occurrences");
+  requireUniqueRefs(context, candidate.counterevidence, "counterevidence");
+  requireUniqueRefs(context, candidate.sourceReviews, "sourceReviews");
+  requireUniqueRefs(context, candidate.relatedHarnessReleases, "relatedHarnessReleases");
+  const supportingKeys = new Set(candidate.occurrences.map((item) => item.occurrenceKey));
+  if (candidate.counterevidence.some((item) => supportingKeys.has(item.occurrenceKey))) {
+    context.addIssue({
+      code: "custom",
+      message: "supporting occurrences and counterevidence must be disjoint",
+      path: ["counterevidence"]
+    });
+  }
+  const actionable = candidate.status === "unresolved" || candidate.status === "confirmed";
+  if (actionable && candidate.occurrences.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable candidates require at least one supporting occurrence",
+      path: ["occurrences"]
+    });
+  }
+  if (actionable && [...candidate.occurrences, ...candidate.counterevidence].some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable candidates may contain only currently authorized evidence",
+      path: ["occurrences"]
+    });
+  }
+  if (actionable !== (candidate.resolution === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only resolved, rejected, or expired candidates require a resolution",
+      path: ["resolution"]
+    });
+  }
+  if (candidate.status === "expired" && candidate.resolution?.kind !== "expired") {
+    context.addIssue({
+      code: "custom",
+      message: "expired candidates require an expired resolution",
+      path: ["resolution", "kind"]
+    });
+  }
+  if (candidate.status === "rejected" && candidate.resolution && !["manual_rejection", "source_revoked"].includes(candidate.resolution.kind)) {
+    context.addIssue({
+      code: "custom",
+      message: "rejected candidates require a rejection or revocation resolution",
+      path: ["resolution", "kind"]
+    });
+  }
+  if (candidate.status === "resolved" && candidate.resolution && !["applied_change", "later_success"].includes(candidate.resolution.kind)) {
+    context.addIssue({
+      code: "custom",
+      message: "resolved candidates require applied-change or later-success evidence",
+      path: ["resolution", "kind"]
+    });
+  }
+  requireChronology(context, candidate);
+});
+var HarnessRefinementCandidateSchema = HarnessRefinementCandidateContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinementCandidateLifecycleDecisionSchema = z7.enum([
+  "created",
+  "merged",
+  "rejected",
+  "expired",
+  "reopened",
+  "resolved"
+]);
+var HarnessRefinementCandidateLifecycleReceiptContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
+  id: ReleaseIdSchema,
+  candidateId: ReleaseIdSchema,
+  decision: HarnessRefinementCandidateLifecycleDecisionSchema,
+  beforeCandidate: ImmutableReleaseRefSchema.nullable(),
+  afterCandidate: ImmutableReleaseRefSchema,
+  review: ImmutableReleaseRefSchema,
+  addedEvidence: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  removedEvidence: z7.array(ImmutableReleaseRefSchema).max(1e3),
+  reason: BoundedTextSchema4,
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "created" !== (receipt.beforeCandidate === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only candidate creation omits the previous candidate reference",
+      path: ["beforeCandidate"]
+    });
+  }
+  if (receipt.beforeCandidate && receipt.beforeCandidate.contentHash === receipt.afterCandidate.contentHash) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate lifecycle transitions must change candidate content",
+      path: ["afterCandidate"]
+    });
+  }
+  if (["created", "reopened"].includes(receipt.decision) && receipt.addedEvidence.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: `${receipt.decision} candidate transitions require added evidence`,
+      path: ["addedEvidence"]
+    });
+  }
+  if (receipt.addedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate transitions may add only authorized evidence",
+      path: ["addedEvidence"]
+    });
+  }
+  requireUniqueRefs(context, receipt.addedEvidence, "addedEvidence");
+  requireUniqueRefs(context, receipt.removedEvidence, "removedEvidence");
+  const removedKeys = new Set(receipt.removedEvidence.map((item) => refKey(item)));
+  if (receipt.addedEvidence.some((item) => removedKeys.has(refKey(item.evidence)))) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate lifecycle evidence cannot be added and removed together",
+      path: ["removedEvidence"]
+    });
+  }
+});
+var HarnessRefinementCandidateLifecycleReceiptSchema = HarnessRefinementCandidateLifecycleReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessCrossRunRefinementRequestContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessCrossRunRefinementRequest.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  candidate: ImmutableReleaseRefSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  review: ImmutableReleaseRefSchema,
+  admittedHarness: ImmutableReleaseRefSchema,
+  evidence: z7.array(HarnessReviewEvidenceRefSchema).min(1).max(1e3),
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  deduplicationKey: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((request, context) => {
+  if (request.evidence.some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "cross-run refinement requires currently authorized evidence",
+      path: ["evidence"]
+    });
+  }
+  requireUniqueRefs(context, request.evidence, "evidence");
+  if (!Object.values(request.capabilities).some(Boolean)) {
+    context.addIssue({
+      code: "custom",
+      message: "cross-run refinement requires at least one available Harness capability",
+      path: ["capabilities"]
+    });
+  }
+  const expected = harnessCrossRunRefinementDeduplicationKey(request);
+  if (request.deduplicationKey !== expected) {
+    context.addIssue({
+      code: "custom",
+      message: `cross-run refinement deduplicationKey is ${request.deduplicationKey}; expected ${expected}`,
+      path: ["deduplicationKey"]
+    });
+  }
+});
+var HarnessCrossRunRefinementRequestSchema = HarnessCrossRunRefinementRequestContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+function harnessCrossRunRefinementDeduplicationKey(input) {
+  return contentHash({
+    schemaVersion: "openpond.harnessCrossRunRefinementIdentity.v1",
+    workspaceRef: input.workspaceRef,
+    candidateFingerprint: input.candidateFingerprint,
+    admittedHarness: input.admittedHarness
+  });
+}
+function requireFields(context, value, expected) {
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    if (value[key] === expectedValue)
+      continue;
+    context.addIssue({
+      code: "custom",
+      message: `${key} must be ${String(expectedValue)}`,
+      path: [key]
+    });
+  }
+}
+function requireUniqueRefs(context, values, path) {
+  const keys = values.map((value) => refKey(value));
+  if (new Set(keys).size === keys.length)
+    return;
+  context.addIssue({
+    code: "custom",
+    message: `${path} references must be unique`,
+    path: [path]
+  });
+}
+function refKey(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return String(value);
+  const record = value;
+  if (typeof record.occurrenceKey === "string")
+    return record.occurrenceKey;
+  const nested = record.evidence;
+  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+    const evidence = nested;
+    return `${String(evidence.id)}:${String(evidence.contentHash)}`;
+  }
+  return `${String(record.id)}:${String(record.contentHash)}`;
+}
+function requireChronology(context, candidate) {
+  const chronology = [
+    ["firstSeenAt", candidate.firstSeenAt],
+    ["lastSeenAt", candidate.lastSeenAt],
+    ["lastReviewedAt", candidate.lastReviewedAt],
+    ["updatedAt", candidate.updatedAt],
+    ["expiresAt", candidate.expiresAt]
+  ];
+  for (let index = 1; index < chronology.length; index += 1) {
+    const previous = chronology[index - 1];
+    const current = chronology[index];
+    if (Date.parse(previous[1]) <= Date.parse(current[1]))
+      continue;
+    context.addIssue({
+      code: "custom",
+      message: `${current[0]} must not precede ${previous[0]}`,
+      path: [current[0]]
+    });
+  }
+  if (Date.parse(candidate.createdAt) > Date.parse(candidate.updatedAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "updatedAt must not precede createdAt",
+      path: ["updatedAt"]
+    });
+  }
+}
+
+export {
+  ToolDeclarationSchema,
+  CapabilityRequirementSchema,
+  ChatModelRefSchema
+};
+//# sourceMappingURL=chunk-IVEXCIHO.js.map