openpond-sdk 0.2.1 → 0.2.2

package/dist/taskset-packages.js

@@ -0,0 +1,2424 @@
+// src/taskset-package-contracts.ts
+import { z as z15 } from "zod";
+
+// ../harness/dist/common.js
+import { z } from "zod";
+
+// ../harness/dist/sha256.js
+var INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var ROUND_CONSTANTS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(value) {
+  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.byteLength] = 128;
+  const bitLength = bytes.byteLength * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = new Uint32Array(INITIAL_STATE);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      words[index] = view.getUint32(offset + index * 4, false);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const previous = words[index - 15];
+      const recent = words[index - 2];
+      const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
+      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+      words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0; index < 64; index += 1) {
+      const choice = e & f ^ ~e & g;
+      const majority = a & b ^ a & c ^ b & c;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const first = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
+      const second = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + first >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = first + second >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+
+// ../harness/dist/common.js
+var MAX_PORTABLE_PATH_BYTES = 2e3;
+var MAX_PORTABLE_ASSET_BYTES = 25e7;
+var ReleaseIdSchema = z.string().trim().min(1).max(240);
+var ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseTimestampSchema = z.string().datetime({ offset: true });
+var MetadataSchema = z.record(z.string(), z.unknown()).default({});
+var ImmutableReleaseRefSchema = z.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImmutableAssetRefSchema = z.object({
+  id: ReleaseIdSchema,
+  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
+  contentHash: ReleaseHashSchema,
+  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
+  mediaType: z.string().trim().min(1).max(200),
+  visibility: z.enum(["policy", "verifier", "host_private"])
+}).strict();
+var ImmutableArtifactRefSchema = z.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema,
+  mediaType: z.string().trim().min(1).max(200).nullable().default(null),
+  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
+}).strict();
+var FailureClassSchema = z.enum([
+  "policy_failure",
+  "grader_failure",
+  "environment_failure",
+  "infrastructure_failure",
+  "timeout",
+  "cancelled"
+]);
+function canonicalJson(value) {
+  return `${JSON.stringify(sortValue(value), null, 2)}
+`;
+}
+function sha256(value) {
+  return sha256Hex(value);
+}
+function contentHash(value) {
+  return sha256(canonicalJson(value));
+}
+function safeRelativePath(value) {
+  const normalized = value.replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
+    return false;
+  return !normalized.split("/").some((part) => !part || part === "." || part === "..");
+}
+function sortValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortValue);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)]));
+}
+
+// ../harness/dist/evaluation-review.js
+import { z as z2 } from "zod";
+var BoundedTextSchema = z2.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = z2.enum([
+  "no_action",
+  "harness_maintenance",
+  "runtime",
+  "product",
+  "taskset",
+  "model_improvement"
+]);
+var HarnessEvaluationReviewAuthoritySchema = z2.enum([
+  "none",
+  "runtime_service",
+  "product_team",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var HarnessReviewEvidenceKindSchema = z2.enum([
+  "observation",
+  "trigger",
+  "route_decision",
+  "refiner_outcome",
+  "proposal",
+  "validation",
+  "apply_receipt",
+  "harness_advance",
+  "rollback",
+  "work_outcome",
+  "taskset",
+  "evaluation",
+  "training_qualification",
+  "model_candidate"
+]);
+var HarnessReviewOwnerScopeSchema = z2.object({
+  kind: z2.enum(["personal", "team"]),
+  id: ReleaseIdSchema
+}).strict();
+var HarnessReviewSourcePolicyRefSchema = z2.object({
+  policy: ImmutableReleaseRefSchema,
+  state: z2.enum(["authorized", "revoked", "deleted", "expired"]),
+  checkedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewEvidenceRefSchema = z2.object({
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
+  occurrenceKey: ReleaseHashSchema,
+  occurredAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewExcludedEvidenceSchema = z2.object({
+  evidence: ImmutableReleaseRefSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
+  reason: z2.enum([
+    "outside_scope",
+    "before_watermark",
+    "duplicate",
+    "resolved",
+    "revoked",
+    "deleted",
+    "expired",
+    "sensitive",
+    "unverified",
+    "budget"
+  ])
+}).strict();
+var HarnessReviewWatermarkSchema = z2.object({
+  cursor: ReleaseHashSchema,
+  throughCreatedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewClaimSchema = z2.object({
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z2.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  candidateDisposition: z2.enum(["observe", "confirm"]).optional(),
+  independentOccurrences: z2.number().int().positive().max(1e6),
+  unresolvedOccurrences: z2.number().int().positive().max(1e6)
+}).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
+var HarnessReviewTriageLayerSchema = z2.enum([
+  "harness",
+  "runtime",
+  "product",
+  "retrieval",
+  "tools",
+  "evaluation",
+  "model"
+]);
+var HarnessReviewTriageDecisionSchema = z2.object({
+  layer: HarnessReviewTriageLayerSchema,
+  status: z2.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  reason: BoundedTextSchema,
+  evidenceRefs: z2.array(ImmutableReleaseRefSchema).max(1e3)
+}).strict();
+var HarnessEvaluationReviewReceiptContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
+  nextWatermark: HarnessReviewWatermarkSchema,
+  selectedEvidence: z2.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: z2.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  claim: HarnessReviewClaimSchema.nullable(),
+  classification: HarnessEvaluationReviewClassificationSchema,
+  triage: z2.array(HarnessReviewTriageDecisionSchema).max(16),
+  reason: BoundedTextSchema,
+  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
+  maxEstimatedCostUsd: z2.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 = z2.object({
+  id: ReleaseIdSchema,
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  occurredAt: ReleaseTimestampSchema,
+  payload: z2.record(z2.string(), z2.unknown())
+}).strict();
+var HarnessEvaluationReviewModelNoActionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("no_action"),
+  reason: BoundedTextSchema,
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3)
+}).strict();
+var HarnessEvaluationReviewModelActionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("review"),
+  classification: z2.enum([
+    "harness_maintenance",
+    "runtime",
+    "product",
+    "taskset"
+  ]),
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  recurrenceFamily: z2.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  triageLayer: HarnessReviewTriageLayerSchema,
+  expectedOutcome: BoundedTextSchema,
+  counterevidence: z2.string().trim().max(1e4),
+  confidence: z2.number().min(0).max(1),
+  candidateDisposition: z2.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 = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("resolve_candidate"),
+  candidateId: ReleaseIdSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  confidence: z2.number().min(0).max(1),
+  reason: BoundedTextSchema
+}).strict();
+var HarnessEvaluationReviewModelDecisionSchema = z2.discriminatedUnion("decision", [
+  HarnessEvaluationReviewModelNoActionSchema,
+  HarnessEvaluationReviewModelActionSchema,
+  HarnessEvaluationReviewModelResolutionSchema
+]);
+var HarnessEvaluationReviewNavigationDecisionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(50),
+  reason: BoundedTextSchema
+}).strict();
+
+// ../harness/dist/harness.js
+import { z as z4 } from "zod";
+
+// ../harness/dist/tools.js
+import { z as z3 } from "zod";
+var ToolDeclarationSchema = z3.object({
+  name: z3.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z3.string().trim().min(1).max(2e3),
+  inputSchema: z3.record(z3.string(), z3.unknown()),
+  inputSchemaHash: ReleaseHashSchema,
+  sideEffect: z3.enum(["read", "write"]),
+  timeoutMs: z3.number().int().positive().max(36e5)
+}).strict();
+var CapabilityRequirementSchema = z3.object({
+  id: ReleaseIdSchema,
+  required: z3.boolean(),
+  scopes: z3.array(z3.string().trim().min(1).max(500)).max(100).default([]),
+  portability: z3.enum(["portable", "host_adapter", "local_only", "hosted_only"])
+}).strict();
+
+// ../harness/dist/harness.js
+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/models.js
+import { z as z7 } from "zod";
+var ModelRefSchema = z7.object({
+  provider: ReleaseIdSchema,
+  model: ReleaseIdSchema,
+  revision: z7.string().trim().min(1).max(500).nullable().default(null),
+  artifactHash: ReleaseHashSchema.nullable().default(null),
+  tokenizerRevision: z7.string().trim().min(1).max(500).nullable().default(null),
+  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
+}).strict();
+
+// ../harness/dist/refiner.js
+import { z as z9 } from "zod";
+
+// ../harness/dist/refiner-profiles.js
+import { z as z8 } from "zod";
+var RefinerProposalRouteSchema = z8.enum(["memory", "prompt", "skill", "agent"]);
+var RefinerExternalRouteSchema = z8.enum(["runtime", "product", "taskset", "training"]);
+var RefinerReviewInstructionSchema = z8.object({
+  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  text: z8.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerReviewProfileSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerReviewProfile.v1"),
+  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  version: z8.string().trim().min(1).max(120),
+  name: z8.string().trim().min(1).max(200),
+  objective: z8.string().trim().min(1).max(1e4),
+  instructions: z8.array(RefinerReviewInstructionSchema).max(100),
+  allowedProposalRoutes: z8.array(RefinerProposalRouteSchema).max(4),
+  allowedExternalRoutes: z8.array(RefinerExternalRouteSchema).max(4)
+}).strict().superRefine((profile, context) => {
+  const instructionIds = profile.instructions.map((instruction) => instruction.id);
+  if (new Set(instructionIds).size !== instructionIds.length) {
+    context.addIssue({ code: "custom", message: "instruction IDs must be unique", path: ["instructions"] });
+  }
+  if (new Set(profile.allowedProposalRoutes).size !== profile.allowedProposalRoutes.length) {
+    context.addIssue({ code: "custom", message: "proposal routes must be unique", path: ["allowedProposalRoutes"] });
+  }
+  if (new Set(profile.allowedExternalRoutes).size !== profile.allowedExternalRoutes.length) {
+    context.addIssue({ code: "custom", message: "external routes must be unique", path: ["allowedExternalRoutes"] });
+  }
+});
+var RefinerReleaseSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerRelease.v1"),
+  id: z8.string().trim().min(1).max(240),
+  coreVersion: z8.string().trim().min(1).max(120),
+  coreHash: ReleaseHashSchema,
+  profile: RefinerReviewProfileSchema,
+  profileHash: ReleaseHashSchema,
+  composedPromptHash: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinerBindingSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerBinding.v1"),
+  channel: z8.literal("active"),
+  revision: z8.number().int().nonnegative(),
+  release: ImmutableReleaseRefSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict();
+var RefinerTransitionReceiptSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerTransitionReceipt.v1"),
+  id: z8.string().trim().min(1).max(240),
+  operation: z8.enum(["initialize", "update", "activate", "rollback"]),
+  bindingChanged: z8.boolean(),
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema,
+  actor: z8.string().trim().min(1).max(240),
+  reason: z8.string().trim().min(1).max(1e4),
+  authoringSkillHash: ReleaseHashSchema.nullable(),
+  validation: z8.object({ valid: z8.boolean(), messages: z8.array(z8.string().max(2e3)).max(100) }).strict(),
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/refiner.js
+var RefinerNoActionDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("no_action"),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerExternalRouteDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("route"),
+  route: z9.enum(["runtime", "product", "taskset", "training"]),
+  summary: z9.string().trim().min(1).max(2e3),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerProposalDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("propose"),
+  route: z9.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z9.enum(["create", "update", "delete"]),
+  target: z9.string().trim().min(1).max(2e3),
+  summary: z9.string().trim().min(1).max(2e3),
+  createContent: z9.string().min(1).max(2e4).nullable(),
+  find: z9.string().min(1).max(8e3).nullable(),
+  replace: z9.string().max(8e3).nullable(),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip().superRefine((decision, context) => {
+  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "create proposals require createContent and null find/replace",
+      path: ["createContent"]
+    });
+  }
+  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "update proposals require one exact find/replace edit and null createContent",
+      path: ["find"]
+    });
+  }
+  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "delete proposals require null createContent/find/replace",
+      path: ["createContent"]
+    });
+  }
+});
+var LocalHarnessRefinerDecisionSchema = z9.discriminatedUnion("decision", [
+  RefinerNoActionDecisionSchema,
+  RefinerExternalRouteDecisionSchema,
+  RefinerProposalDecisionSchema
+]);
+var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
+var HarnessRefinerEvidenceBasisSchema = z9.object({
+  kind: z9.enum(["single_deterministic", "recurrent_independent"]),
+  supportingEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).min(1).max(100),
+  counterevidence: z9.array(z9.string().trim().min(1).max(2e3)).max(20)
+}).strict().superRefine((basis, context) => {
+  if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "supporting evidence IDs must be unique",
+      path: ["supportingEvidenceIds"]
+    });
+  }
+  if (basis.kind === "recurrent_independent" && basis.supportingEvidenceIds.length < 2) {
+    context.addIssue({
+      code: "custom",
+      message: "recurrent independent evidence requires at least two supplied incidents",
+      path: ["supportingEvidenceIds"]
+    });
+  }
+});
+var RefinerNoActionDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("no_action"),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerExternalRouteDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("route"),
+  route: z9.enum(["runtime", "product", "taskset", "training"]),
+  summary: z9.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerProposalDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("propose"),
+  route: z9.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z9.enum(["create", "update", "delete"]),
+  target: z9.string().trim().min(1).max(2e3),
+  summary: z9.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  createContent: z9.string().min(1).max(2e4).nullable(),
+  find: z9.string().min(1).max(8e3).nullable(),
+  replace: z9.string().max(8e3).nullable(),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict().superRefine((decision, context) => {
+  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "create proposals require createContent and null find/replace",
+      path: ["createContent"]
+    });
+  }
+  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "update proposals require one exact find/replace edit and null createContent",
+      path: ["find"]
+    });
+  }
+  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "delete proposals require null createContent/find/replace",
+      path: ["createContent"]
+    });
+  }
+});
+var LocalHarnessRefinerDecisionV2Schema = z9.discriminatedUnion("decision", [
+  RefinerNoActionDecisionV2Schema,
+  RefinerExternalRouteDecisionV2Schema,
+  RefinerProposalDecisionV2Schema
+]);
+var LocalHarnessRefinerDecisionAnySchema = z9.union([
+  LocalHarnessRefinerDecisionV1Schema,
+  LocalHarnessRefinerDecisionV2Schema
+]);
+var HarnessRefinerCapabilitiesSchema = z9.object({
+  memory: z9.boolean(),
+  prompt: z9.boolean(),
+  skill: z9.boolean(),
+  agent: z9.boolean()
+}).strict();
+var SourceKindSchema = z9.enum(["memory", "instruction", "skill", "agent"]);
+var RefinerSourceFileSchema = z9.object({
+  path: z9.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  content: z9.string().max(6e4),
+  loaded: z9.boolean()
+}).strict();
+var RefinerSourceCatalogEntrySchema = z9.object({
+  path: z9.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  loaded: z9.boolean()
+}).strict();
+var LocalHarnessRefinerEvidenceSchema = z9.object({
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  trigger: z9.record(z9.string(), z9.unknown()),
+  observations: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
+  admissibleEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).max(1e4),
+  reviewPacket: z9.object({
+    currentTurn: z9.object({
+      id: z9.string().trim().min(1).max(2e3),
+      status: z9.string().trim().min(1).max(100).nullable(),
+      error: z9.string().max(2100).nullable(),
+      prompt: z9.string().max(8100).nullable(),
+      assistantOutput: z9.string().max(8100).nullable(),
+      assistantOutputLinkCount: z9.number().int().nonnegative()
+    }).strict(),
+    priorConversation: z9.array(z9.object({
+      turnId: z9.string().trim().min(1).max(2e3),
+      status: z9.string().trim().min(1).max(100).nullable(),
+      prompt: z9.string().max(3100).nullable(),
+      assistantOutput: z9.string().max(3100).nullable()
+    }).strict()).max(3),
+    timeline: z9.array(z9.record(z9.string(), z9.unknown())).max(60),
+    artifacts: z9.array(z9.record(z9.string(), z9.unknown())).max(30),
+    artifactDiagnostics: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
+    executionProfile: z9.object({
+      modelRequestCount: z9.number().int().nonnegative(),
+      failedModelRequestCount: z9.number().int().nonnegative(),
+      promptTokens: z9.number().int().nonnegative(),
+      completionTokens: z9.number().int().nonnegative(),
+      totalTokens: z9.number().int().nonnegative(),
+      toolFailureCount: z9.number().int().nonnegative(),
+      retryCount: z9.number().int().nonnegative(),
+      recoveryCount: z9.number().int().nonnegative()
+    }).strict(),
+    priorIncidents: z9.array(z9.record(z9.string(), z9.unknown())).max(3),
+    truncation: z9.object({
+      timelineEventCount: z9.number().int().nonnegative(),
+      includedTimelineEventCount: z9.number().int().nonnegative(),
+      timelineTruncated: z9.boolean()
+    }).strict()
+  }).strict(),
+  runtimeActivation: z9.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    rebasedOntoCurrent: z9.boolean(),
+    admittedSourceFiles: z9.array(RefinerSourceFileSchema).max(100),
+    admittedSourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3)
+  }).strict(),
+  sourceFiles: z9.array(RefinerSourceFileSchema).max(100),
+  sourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3),
+  additionalEvidence: z9.unknown().nullable().optional()
+}).strict();
+var OverlayRefSchema = z9.object({
+  id: z9.string().trim().min(1).max(240),
+  revision: z9.number().int().nonnegative(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var HostedHarnessRefinerRequestSchema = z9.object({
+  schemaVersion: z9.literal("openpond.hostedHarnessRefinerRequest.v2"),
+  requestId: z9.string().trim().min(1).max(240),
+  idempotencyKey: z9.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  harness: z9.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    overlay: OverlayRefSchema,
+    workspace: z9.object({
+      id: z9.string().trim().min(1).max(240),
+      revision: z9.number().int().nonnegative(),
+      sourceRevision: ReleaseHashSchema,
+      channelRevision: z9.number().int().nonnegative()
+    }).strict(),
+    capabilities: HarnessRefinerCapabilitiesSchema
+  }).strict(),
+  evidence: LocalHarnessRefinerEvidenceSchema
+}).strict();
+var HostedHarnessRefinerUsageSchema = z9.object({
+  promptTokens: z9.number().int().nonnegative(),
+  completionTokens: z9.number().int().nonnegative(),
+  totalTokens: z9.number().int().nonnegative()
+}).strict();
+var HostedHarnessRefinerResponseSchema = z9.object({
+  schemaVersion: z9.literal("openpond.hostedHarnessRefinerResponse.v2"),
+  requestId: z9.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  admittedRelease: ImmutableReleaseRefSchema,
+  currentRelease: ImmutableReleaseRefSchema,
+  decision: LocalHarnessRefinerDecisionV2Schema,
+  serviceRevision: z9.string().trim().min(1).max(240),
+  usage: HostedHarnessRefinerUsageSchema
+}).strict();
+
+// ../harness/dist/refinement-lifecycle.js
+import { z as z10 } from "zod";
+var ShortTextSchema = z10.string().trim().min(1).max(2e3);
+var BoundedTextSchema4 = z10.string().trim().min(1).max(1e5);
+var HarnessRefinerOperationSchema = z10.enum(["create", "update", "delete"]);
+var HarnessRefinerInternalRouteSchema = z10.enum([
+  "memory",
+  "prompt",
+  "skill",
+  "agent"
+]);
+var HarnessRefinerExternalRouteSchema = z10.enum([
+  "runtime",
+  "product",
+  "taskset",
+  "training"
+]);
+var HarnessRefinerActivityResultSchema = z10.enum([
+  "no_action",
+  "routed",
+  "applied",
+  "retained",
+  "failed"
+]);
+var HarnessRefinerCritiqueStatusSchema = z10.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "rejected",
+  "failed"
+]);
+var HarnessRefinerValidationStatusSchema = z10.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "failed"
+]);
+var HarnessRefinerActivityReceiptContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinerActivityReceipt.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  result: HarnessRefinerActivityResultSchema,
+  decision: z10.enum(["no_action", "route", "propose"]).nullable(),
+  route: HarnessImprovementRouteSchema.nullable(),
+  operation: HarnessRefinerOperationSchema.nullable(),
+  target: z10.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 = z10.enum([
+  "unresolved",
+  "confirmed",
+  "resolved",
+  "rejected",
+  "expired"
+]);
+var HarnessRefinementCandidateResolutionSchema = z10.object({
+  kind: z10.enum([
+    "applied_change",
+    "later_success",
+    "manual_rejection",
+    "source_revoked",
+    "expired"
+  ]),
+  reason: BoundedTextSchema4,
+  evidenceRefs: z10.array(ImmutableReleaseRefSchema).max(1e3),
+  resolvedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessRefinementCandidateContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinementCandidate.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z10.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema4,
+  status: HarnessRefinementCandidateStatusSchema,
+  occurrences: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  counterevidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  sourceReviews: z10.array(ImmutableReleaseRefSchema).min(1).max(100),
+  relatedHarnessReleases: z10.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 = z10.enum([
+  "created",
+  "merged",
+  "rejected",
+  "expired",
+  "reopened",
+  "resolved"
+]);
+var HarnessRefinementCandidateLifecycleReceiptContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
+  id: ReleaseIdSchema,
+  candidateId: ReleaseIdSchema,
+  decision: HarnessRefinementCandidateLifecycleDecisionSchema,
+  beforeCandidate: ImmutableReleaseRefSchema.nullable(),
+  afterCandidate: ImmutableReleaseRefSchema,
+  review: ImmutableReleaseRefSchema,
+  addedEvidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  removedEvidence: z10.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 = z10.object({
+  schemaVersion: z10.literal("openpond.harnessCrossRunRefinementRequest.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  candidate: ImmutableReleaseRefSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  review: ImmutableReleaseRefSchema,
+  admittedHarness: ImmutableReleaseRefSchema,
+  evidence: z10.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"]
+    });
+  }
+}
+
+// src/taskset-package-contracts.ts
+import { EnvironmentReleaseSchema as EnvironmentReleaseSchema3, VerifierSetReleaseSchema as VerifierSetReleaseSchema3, verifyEnvironmentRelease as verifyEnvironmentRelease3, verifyVerifierSetRelease as verifyVerifierSetRelease3 } from "@openpond/evals";
+import { assertTasksetRelease as assertTasksetRelease2, TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
+import { assertBoundedTaskJson as assertBoundedTaskJson3 } from "@openpond/evals/task-schema";
+
+// src/model-taskset-derivation.ts
+import { z as z14 } from "zod";
+import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
+import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
+import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
+import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
+import { validateTaskValue } from "@openpond/evals/task-schema";
+
+// src/model-projects.ts
+import { z as z11 } from "zod";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+var IdSchema = z11.string().trim().min(1).max(500);
+var HashSchema = z11.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z11.string().datetime({ offset: true });
+var ModelProjectImmutableRefSchema = z11.object({
+  id: IdSchema,
+  contentHash: HashSchema
+}).strict();
+var ModelProjectVersionedRefSchema = ModelProjectImmutableRefSchema.extend({
+  revision: z11.number().int().positive()
+}).strict();
+var ModelProjectBaseModelSchema = z11.object({
+  schemaVersion: z11.literal("openpond.baseModelPreference.v1"),
+  modelId: IdSchema,
+  revision: z11.string().trim().min(1).max(256).nullable(),
+  tokenizerRevision: z11.string().trim().min(1).max(256).nullable(),
+  chatTemplateHash: z11.string().trim().min(8).max(256).nullable(),
+  modelAssetId: IdSchema.nullable(),
+  source: z11.enum(["managed", "local", "builtin"])
+}).strict();
+var ModelProjectTrainingMethodSchema = z11.enum([
+  "sft",
+  "dpo",
+  "grpo",
+  "ppo",
+  "sdft",
+  "opd",
+  "opsd",
+  "sdpo"
+]);
+var ModelProjectRecipeDocumentSchema = z11.object({
+  schemaVersion: z11.string().regex(/^openpond\.[A-Za-z0-9]+Recipe\.v\d+$/),
+  method: ModelProjectTrainingMethodSchema,
+  parameterization: z11.enum(["lora", "full"])
+}).catchall(z11.unknown());
+var ModelProjectTrainingSetupSchema = z11.object({
+  tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),
+  rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),
+  tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),
+  harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),
+  baseModel: ModelProjectBaseModelSchema.nullable().default(null),
+  method: ModelProjectTrainingMethodSchema.nullable().default(null),
+  destinationId: IdSchema.nullable().default(null),
+  managedRolloutPlacement: z11.enum(["local", "remote"]).default("remote"),
+  managedGpuPlacementObjective: z11.enum(["fast", "balanced", "economical"]).default("balanced"),
+  managedGpuRequirement: z11.enum(["any", "h100_hbm3"]).default("any"),
+  runPreset: z11.enum(["small", "standard", "custom", "small_experiment"]).nullable().default(null),
+  recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),
+  preferredMaximumSpendUsd: z11.number().nonnegative().nullable().default(null),
+  preferredRetentionDays: z11.number().int().nonnegative().nullable().default(null)
+}).strict();
+var HostedModelProjectTrainingSetupSchema = ModelProjectTrainingSetupSchema.omit({ managedGpuRequirement: true });
+var HostedModelProjectLinkSchema = z11.object({
+  schemaVersion: z11.literal("openpond.hostedModelProjectLink.v1"),
+  teamId: IdSchema,
+  projectId: IdSchema,
+  portableProjectId: IdSchema,
+  revision: z11.number().int().positive(),
+  etag: HashSchema,
+  syncedSourceRevision: z11.number().int().positive(),
+  syncedAt: TimestampSchema,
+  tasksets: z11.array(
+    z11.object({
+      localTasksetId: IdSchema,
+      releaseId: IdSchema,
+      releaseRevision: z11.number().int().positive(),
+      releaseHash: HashSchema,
+      hostedTasksetId: IdSchema,
+      syncedAt: TimestampSchema
+    }).strict()
+  ).max(1e4).default([])
+}).strict();
+var ModelProjectTasksetSyncSchema = z11.object({
+  localTasksetId: IdSchema,
+  releaseId: IdSchema,
+  releaseRevision: z11.number().int().positive(),
+  releaseHash: HashSchema,
+  state: z11.enum(["syncing", "synced", "sync_failed"]),
+  hostedTasksetId: IdSchema.nullable().default(null),
+  lastAttemptAt: TimestampSchema,
+  syncedAt: TimestampSchema.nullable().default(null),
+  lastError: z11.string().trim().min(1).max(5e3).nullable().default(null)
+}).strict();
+var ModelProjectSchema = z11.object({
+  schemaVersion: z11.literal("openpond.modelProject.v2"),
+  id: IdSchema,
+  profileId: IdSchema,
+  revision: z11.number().int().positive().default(1),
+  name: z11.string().trim().min(1).max(200),
+  objective: z11.string().trim().max(5e3).nullable(),
+  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
+  defaultDestinationId: IdSchema.nullable(),
+  trainingSetup: ModelProjectTrainingSetupSchema,
+  hosted: HostedModelProjectLinkSchema.nullable().default(null),
+  tasksetSyncs: z11.array(ModelProjectTasksetSyncSchema).max(1e4).default([]),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+}).strict();
+var ModelProjectEditableSchema = ModelProjectSchema.pick({
+  id: true,
+  profileId: true,
+  name: true,
+  objective: true,
+  defaultBaseModel: true,
+  defaultDestinationId: true,
+  trainingSetup: true
+});
+var ModelProjectSaveRequestSchema = z11.object({
+  schemaVersion: z11.literal("openpond.modelProjectSave.v1"),
+  operationId: IdSchema,
+  expectedRevision: z11.number().int().nonnegative(),
+  project: ModelProjectEditableSchema
+}).strict();
+var ModelProjectConfigurationCheckSchema = z11.object({
+  schemaVersion: z11.literal("openpond.modelProjectConfigurationCheck.v1"),
+  configurationHash: HashSchema,
+  projectId: IdSchema,
+  expectedRevision: z11.number().int().nonnegative(),
+  checkedAt: TimestampSchema,
+  canSave: z11.boolean(),
+  deferred: z11.array(z11.enum(["base_model", "taskset"])).max(2),
+  findings: z11.array(z11.object({
+    code: IdSchema,
+    severity: z11.enum(["error", "warning"]),
+    message: z11.string().min(1).max(5e3),
+    field: z11.string().min(1).max(500).nullable()
+  }).strict()).max(100)
+}).strict();
+var ModelProjectBaseModelCandidateSchema = z11.object({
+  id: IdSchema,
+  name: z11.string().min(1).max(500),
+  available: z11.boolean(),
+  preference: ModelProjectBaseModelSchema
+}).strict();
+var HostedModelProjectSyncSchema = z11.object({
+  schemaVersion: z11.literal("openpond.hostedModelProjectSync.v2"),
+  portableProjectId: IdSchema,
+  name: z11.string().trim().min(1).max(200),
+  objective: z11.string().trim().max(5e3).nullable(),
+  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
+  defaultDestinationId: IdSchema.nullable(),
+  trainingSetup: HostedModelProjectTrainingSetupSchema,
+  sourceRevision: z11.number().int().positive(),
+  sourceUpdatedAt: TimestampSchema,
+  expectedEtag: HashSchema.nullable().default(null)
+}).strict();
+var HostedModelProjectSummarySchema = z11.object({
+  id: IdSchema,
+  teamId: IdSchema,
+  portableProjectId: IdSchema,
+  name: z11.string().trim().min(1).max(200),
+  objective: z11.string().trim().max(5e3).nullable(),
+  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
+  defaultDestinationId: IdSchema.nullable(),
+  trainingSetup: HostedModelProjectTrainingSetupSchema,
+  sourceRevision: z11.number().int().positive(),
+  sourceUpdatedAt: TimestampSchema,
+  revision: z11.number().int().positive(),
+  etag: HashSchema,
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+}).strict();
+var ModelProjectResourceSummarySchema = z11.object({
+  kind: z11.enum([
+    "taskset_release",
+    "harness_release",
+    "dataset_release",
+    "evidence_set",
+    "model_version",
+    "reward_model_version",
+    "evaluation_receipt"
+  ]),
+  ref: ModelProjectImmutableRefSchema,
+  role: z11.string().trim().min(1).max(200).nullable().default(null),
+  updatedAt: TimestampSchema
+}).strict();
+var HostedModelProjectDetailSchema = z11.object({
+  project: HostedModelProjectSummarySchema,
+  resources: z11.array(ModelProjectResourceSummarySchema).max(1e4),
+  jobCount: z11.number().int().nonnegative(),
+  latestJobIds: z11.array(IdSchema).max(100)
+}).strict();
+var ModelProjectApiErrorSchema = z11.object({
+  schemaVersion: z11.literal("openpond.modelProjectApiError.v2"),
+  code: z11.string().trim().min(1).max(200),
+  message: z11.string().trim().min(1).max(5e3),
+  retryable: z11.boolean().default(false),
+  requestId: z11.string().trim().min(1).max(500).nullable().default(null),
+  details: z11.record(z11.string(), z11.unknown()).default({})
+}).strict();
+
+// src/model-starter-execution.ts
+import { z as z12 } from "zod";
+import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
+import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment";
+import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
+import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
+var HashSchema2 = z12.string().regex(/^[a-f0-9]{64}$/);
+var ModelStarterEnvironmentAttemptSchema = z12.object({
+  schemaVersion: z12.literal("openpond.javascriptEnvironmentAttempt.v1"),
+  taskId: z12.string(),
+  status: z12.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
+  output: z12.string().nullable(),
+  collected: z12.boolean(),
+  environmentCleanupComplete: z12.boolean(),
+  snapshot: z12.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema2, seed: z12.number().int(), initialStateHash: HashSchema2, finalStateHash: HashSchema2, state: z12.record(z12.string(), z12.unknown()), events: z12.array(z12.record(z12.string(), z12.unknown())) }).strict().nullable(),
+  messages: z12.array(z12.unknown()),
+  error: z12.string().nullable(),
+  contentHash: HashSchema2
+}).strict();
+var ModelStarterExecutionSchema = z12.object({
+  environment: EnvironmentReleaseSchema,
+  verifierSet: VerifierSetReleaseSchema,
+  javascript: JavaScriptEnvironmentDefinitionSchema
+}).strict();
+var ModelStarterToolFixtureScriptSchema = z12.object({
+  actions: z12.array(z12.object({ name: z12.string().min(1).max(64), arguments: z12.record(z12.string(), z12.unknown()) }).strict()).max(1e3)
+}).strict();
+function equal(left, right) {
+  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
+}
+function assertExecutionIntegrity(execution) {
+  assertJavaScriptEnvironmentDefinition(execution.javascript);
+  for (const resource of [execution.environment, execution.verifierSet]) {
+    const { contentHash: contentHash2, ...content } = resource;
+    if (sealLearningContent(content).contentHash !== contentHash2) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);
+  }
+  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error("Starter execution resources differ from its declared task context.");
+}
+function validateModelStarterExecution(execution, taskset, assets) {
+  if (!execution) {
+    if (taskset.environment.entrypoint === "openpond.javascript-environment.v1") throw new Error("Starter JavaScript execution resources are missing.");
+    return;
+  }
+  const { environment, verifierSet, javascript } = execution;
+  assertExecutionIntegrity(execution);
+  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) || !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {
+    throw new Error("Starter execution resources differ from its declared task context.");
+  }
+  const contract = environment.contract;
+  if (contract.entrypoint !== "openpond.javascript-environment.v1" || contract.kind !== "agent" || !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== "none" || new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {
+    throw new Error("Starter JavaScript environment declares unsupported host capabilities.");
+  }
+  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {
+    if (!reference) continue;
+    const asset = assets.find((asset2) => asset2.id === reference.id);
+    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);
+    verifyLearningTextAsset(asset, reference);
+  }
+  for (const task of taskset.tasks) {
+    const asset = assets.find((asset2) => asset2.id === task.privilegedContextRef);
+    if (!asset || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") {
+      throw new Error(`Starter private initial state is missing: ${task.id}.`);
+    }
+    const state = JSON.parse(verifyLearningTextAsset(asset, asset.asset));
+    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);
+    assertBoundedTaskJson2(state, javascript.maxStateBytes);
+  }
+}
+
+// src/model-taskset-resources.ts
+import { z as z13 } from "zod";
+import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
+import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+var ModelTasksetExecutionResourcesSchema = z13.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
+
+// src/model-taskset-derivation.ts
+var OwnerSchema = z14.object({ scopeId: z14.string().trim().min(1).max(500), modelId: z14.string().trim().min(1).max(500) }).strict();
+var ModelTasksetDerivationSchema = z14.object({
+  schemaVersion: z14.literal("openpond.modelTasksetDerivation.v1"),
+  owner: OwnerSchema,
+  root: ModelProjectVersionedRefSchema,
+  parent: ModelProjectVersionedRefSchema
+}).strict();
+var ModelTasksetPackageSchema = z14.object({
+  taskset: TasksetReleaseSchema,
+  taskDefinition: TaskDefinitionSchema,
+  rewardBinding: RewardBindingSchema,
+  rewards: z14.array(RewardReleaseSchema).min(1).max(100),
+  assets: z14.array(LearningTextAssetSchema).max(1e3),
+  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
+  execution: ModelStarterExecutionSchema.optional()
+}).strict();
+var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
+function validateModelTasksetPackage(value) {
+  const result = ModelTasksetPackageSchema.parse(value);
+  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;
+  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);
+  assertTasksetRelease(taskset);
+  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
+  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset definition differs from its Reward binding.");
+  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
+  if (!same(taskDefinition.execution, { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} })) throw new Error("Taskset definition differs from its execution resources.");
+  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error("Taskset graders differ from its Reward binding.");
+  if (taskset.metadata.starter !== void 0) {
+    const metadata = z14.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
+    if (!sameLearningRef(metadata.taskDefinition, learningRef2(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset metadata differs from its immutable grading resources.");
+  }
+  if (taskset.metadata.rewardExecution !== void 0 && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error("Taskset embedded Rewards differ from its immutable grading resources.");
+  if (taskset.metadata.rewardBinding !== void 0 && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef2(rewardBinding))) throw new Error("Taskset Reward reference differs from its immutable grading resources.");
+  const resources = result.executionResources ?? execution;
+  if (taskset.environmentRelease && !resources) throw new Error("Deriving a Taskset requires its pinned execution resources.");
+  if (resources && (!verifyEnvironmentRelease2(resources.environment) || !verifyVerifierSetRelease2(resources.verifierSet) || !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) || !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) || !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error("Taskset differs from its pinned execution resources.");
+  validateModelStarterExecution(execution, taskset, assets);
+  if (new Set(assets.map((asset) => asset.id)).size !== assets.length) throw new Error("Taskset asset identities must be unique.");
+  for (const asset of assets) verifyLearningTextAsset3(asset, asset.asset);
+  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {
+    if (!reference) continue;
+    const asset = assets.find((asset2) => asset2.id === reference.id);
+    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);
+    verifyLearningTextAsset3(asset, reference);
+  }
+  for (const task of taskset.tasks) {
+    if (task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid || task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);
+    if (task.privilegedContextRef && !assets.some((asset) => asset.id === task.privilegedContextRef && asset.asset.visibility === "host_private")) throw new Error(`Taskset private context is missing: ${task.id}.`);
+  }
+  for (const reward of rewards) {
+    const implementation = reward.implementation;
+    const references = [...reward.assets, ..."verifierRef" in implementation ? [implementation.verifierRef] : [], ..."rubricRef" in implementation ? [implementation.rubricRef] : [], ..."inputContract" in implementation ? [implementation.inputContract] : []];
+    for (const reference of references) {
+      const asset = assets.find((asset2) => asset2.id === reference.id);
+      if (!asset || reference.visibility === "policy") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);
+      verifyLearningTextAsset3(asset, reference);
+    }
+  }
+  return result;
+}
+
+// src/taskset-package-contracts.ts
+var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
+var TasksetPackageFileSchema = z15.object({
+  asset: ImmutableAssetRefSchema,
+  base64: z15.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
+}).strict();
+var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
+var TasksetPackageContentSchema = z15.object({
+  schemaVersion: z15.literal("openpond.tasksetPackage.v1"),
+  taskset: TasksetReleaseSchema2,
+  environment: EnvironmentReleaseSchema3,
+  verifierSet: VerifierSetReleaseSchema3,
+  files: z15.array(TasksetPackageFileSchema).max(1e4),
+  modelResources: BoundModelResourcesSchema.optional()
+}).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z15.string().regex(/^[a-f0-9]{64}$/) }).strict();
+function decodeTasksetPackageFile(value) {
+  const file = TasksetPackageFileSchema.parse(value);
+  const raw = atob(file.base64);
+  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
+  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
+  return bytes;
+}
+function validateTasksetPackage(value) {
+  assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
+  const result = TasksetPackageSchema.parse(value);
+  const { contentHash: hash, ...content } = result;
+  if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
+  const { taskset, environment, verifierSet } = result;
+  assertTasksetRelease2(taskset);
+  if (!verifyEnvironmentRelease3(environment) || !verifyVerifierSetRelease3(verifierSet) || !same2(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same2(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same2(taskset.environment, environment.contract) || !same2(taskset.graders, verifierSet.graders)) {
+    throw new Error("Taskset package execution releases do not match its Taskset.");
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const file of result.files) {
+    if (files.has(file.asset.id)) throw new Error(`Duplicate Taskset asset identity: ${file.asset.id}.`);
+    decodeTasksetPackageFile(file);
+    files.set(file.asset.id, file);
+  }
+  function requireAsset(ref) {
+    const file = files.get(ref.id);
+    if (!file || !same2(file.asset, ref)) throw new Error(`Taskset package asset is missing or mismatched: ${ref.id}.`);
+  }
+  for (const task of taskset.tasks) {
+    for (const asset of task.artifactRefs) requireAsset(asset);
+    for (const output of task.requiredOutputs ?? []) if (output.schemaRef) requireAsset(output.schemaRef);
+    if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
+      throw new Error(`Taskset package private context is missing: ${task.id}.`);
+    }
+  }
+  for (const ref of [environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) if (ref) requireAsset(ref);
+  for (const grader of taskset.graders) {
+    const ref = "verifierRef" in grader ? grader.verifierRef : "rubricRef" in grader ? grader.rubricRef : null;
+    if (ref) {
+      requireAsset(ref);
+      if (ref.visibility === "policy") throw new Error(`Taskset grader asset must be private: ${ref.id}.`);
+    }
+  }
+  for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
+    if (declarations === void 0) continue;
+    for (const resource of z15.array(z15.object({ path: z15.string().min(1) }).passthrough()).parse(declarations)) {
+      if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
+    }
+  }
+  if (result.modelResources) {
+    const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
+    for (const asset of model.assets) requireAsset(asset.asset);
+  } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
+    throw new Error("Bound Taskset publication requires its complete model resources.");
+  }
+  return result;
+}
+function createTasksetPackage(value) {
+  assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
+  const content = TasksetPackageContentSchema.parse(value);
+  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
+}
+function same2(left, right) {
+  return contentHash({ value: left }) === contentHash({ value: right });
+}
+
+// src/taskset-package-client.ts
+import { z as z17 } from "zod";
+
+// src/taskset-catalog.ts
+import { z as z16 } from "zod";
+var IdSchema2 = z16.string().trim().min(1).max(500);
+var HashSchema3 = z16.string().regex(/^[a-f0-9]{64}$/);
+var TasksetCatalogReleaseRefSchema = z16.object({ id: IdSchema2, revision: z16.number().int().positive(), contentHash: HashSchema3 }).strict();
+var HostedTasksetSummarySchema = z16.object({
+  schemaVersion: z16.literal("openpond.hostedTasksetSummary.v1"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  release: TasksetCatalogReleaseRefSchema,
+  name: z16.string().min(1).max(500),
+  description: z16.string().max(2e4),
+  taskCount: z16.number().int().nonnegative(),
+  buildIntent: z16.string().min(1).max(100),
+  methodHint: z16.string().min(1).max(100).nullable(),
+  packageBytes: z16.number().int().nonnegative().nullable(),
+  storedBytes: z16.number().int().nonnegative().nullable(),
+  createdAt: z16.string().datetime({ offset: true })
+}).strict();
+var TasksetCatalogQuerySchema = z16.object({
+  afterId: IdSchema2.optional(),
+  limit: z16.number().int().min(1).max(100).default(30),
+  modelProjectId: IdSchema2.optional()
+}).strict();
+var TasksetCatalogPageSchema = z16.object({
+  items: z16.array(HostedTasksetSummarySchema).max(100),
+  nextCursor: IdSchema2.nullable()
+}).strict();
+var TasksetCatalogErrorSchema = z16.object({
+  code: z16.string().min(1),
+  message: z16.string().min(1)
+}).strict();
+
+// src/taskset-package-client.ts
+var IdSchema3 = z17.string().trim().min(1).max(500);
+var HashSchema4 = z17.string().regex(/^[a-f0-9]{64}$/);
+var TasksetPackagePublicationSchema = z17.object({
+  schemaVersion: z17.literal("openpond.tasksetPackagePublication.v1"),
+  operationId: IdSchema3,
+  modelProjectId: IdSchema3,
+  expectedProjectEtag: HashSchema4.nullable(),
+  name: z17.string().trim().min(1).max(200),
+  description: z17.string().max(5e3),
+  buildIntent: z17.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
+  methodHint: z17.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
+  package: TasksetPackageSchema
+}).strict();
+var TasksetPackageReceiptSchema = z17.object({
+  schemaVersion: z17.literal("openpond.tasksetPackageReceipt.v1"),
+  teamId: IdSchema3,
+  modelProjectId: IdSchema3,
+  operationId: IdSchema3,
+  taskset: TasksetCatalogReleaseRefSchema,
+  packageHash: HashSchema4,
+  hostedTasksetId: IdSchema3,
+  projectEtag: HashSchema4
+}).strict();
+var TasksetPackageReadbackSchema = z17.object({
+  schemaVersion: z17.literal("openpond.tasksetPackageReadback.v1"),
+  teamId: IdSchema3,
+  modelProjectId: IdSchema3,
+  package: TasksetPackageSchema
+}).strict();
+var OpenPondTasksetPackageError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "OpenPondTasksetPackageError";
+  }
+  status;
+  code;
+};
+var OpenPondTasksetPackageClient = class {
+  #options;
+  constructor(options) {
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim()) throw new Error("Taskset package client requires a clean HTTP(S) endpoint and workspace credentials.");
+    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
+  }
+  async publish(input, options = {}) {
+    const request = TasksetPackagePublicationSchema.parse(input);
+    validateTasksetPackage(request.package);
+    const receipt = TasksetPackageReceiptSchema.parse(await this.#request("", "POST", request, options.signal));
+    const release = request.package.taskset;
+    if (receipt.teamId !== this.#options.teamId || receipt.modelProjectId !== request.modelProjectId || receipt.operationId !== request.operationId || receipt.packageHash !== request.package.contentHash || receipt.taskset.id !== release.id || receipt.taskset.revision !== release.revision || receipt.taskset.contentHash !== release.contentHash) {
+      throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication receipt did not match the requested package and owner.");
+    }
+    return receipt;
+  }
+  async get(modelProjectId, reference, options = {}) {
+    const project = IdSchema3.parse(modelProjectId);
+    const ref = TasksetCatalogReleaseRefSchema.parse(reference);
+    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema4.parse(options.expectedPackageHash);
+    const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
+    const taskset = response.package.taskset;
+    if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
+    if (expectedPackageHash !== void 0 && response.package.contentHash !== expectedPackageHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the saved publication receipt.");
+    return validateTasksetPackage(response.package);
+  }
+  async #request(path, method, body, signal) {
+    const serialized = body === void 0 ? void 0 : JSON.stringify(body);
+    if (serialized && new TextEncoder().encode(serialized).byteLength > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset publication exceeds the 64 MiB envelope.");
+    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/taskset-packages${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "X-OpenPond-Team-Id": this.#options.teamId, Accept: "application/json", ...serialized ? { "Content-Type": "application/json" } : {} },
+      body: serialized,
+      signal,
+      redirect: "error"
+    });
+    const reader = response.body?.getReader();
+    if (!reader) throw new OpenPondTasksetPackageError(response.status, "empty_response", "Taskset package response was empty.");
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let bytes = 0;
+    let text = "";
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        bytes += chunk.value.byteLength;
+        if (bytes > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset response exceeds the 64 MiB envelope.");
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+      text += decoder.decode();
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+    const payload = JSON.parse(text);
+    if (!response.ok) {
+      const error = z17.object({ code: z17.string(), message: z17.string() }).safeParse(payload);
+      throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
+    }
+    return payload;
+  }
+};
+export {
+  MAX_TASKSET_PACKAGE_BYTES,
+  OpenPondTasksetPackageClient,
+  OpenPondTasksetPackageError,
+  TasksetPackageContentSchema,
+  TasksetPackageFileSchema,
+  TasksetPackagePublicationSchema,
+  TasksetPackageReadbackSchema,
+  TasksetPackageReceiptSchema,
+  TasksetPackageSchema,
+  createTasksetPackage,
+  decodeTasksetPackageFile,
+  validateTasksetPackage
+};
+//# sourceMappingURL=taskset-packages.js.map