openpond-sdk 0.3.3 → 0.5.0

package/dist/learning.js

@@ -1,2050 +1,24 @@
-// src/learning.ts
-import { z as z12 } from "zod";
 import {
-  LearningCommandRequestSchema,
-  LearningOperationResultSchema,
-  LearningReadRequestSchema,
-  TaskEvidenceInspectionResultSchema,
-  sameLearningRef,
-  assertLearningRequestJson,
-  learningResourceSchemas
-} from "@openpond/evals/learning";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-
-// src/learning-credentials.ts
-import { z as z11 } 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/learning-credentials.ts
-import { LearningRevisionRefSchema } from "@openpond/evals/learning";
-import { TaskSplitSchema } from "@openpond/evals/tasksets";
-var LearningSourceCredentialSchema = z11.object({
-  id: ReleaseIdSchema,
-  scope: ReleaseIdSchema,
-  sourceId: ReleaseIdSchema,
-  name: z11.string().trim().min(1).max(100),
-  keyPrefix: z11.string().min(1).max(100),
-  createdAt: z11.iso.datetime(),
-  expiresAt: z11.iso.datetime(),
-  revokedAt: z11.iso.datetime().nullable()
-}).strict();
-var LearningSourceCredentialSecretSchema = z11.string().regex(/^opk_key_[A-Za-z0-9]{16}_[A-Za-z0-9]{48}$/);
-var LearningSourceCredentialRequestSchema = z11.discriminatedUnion("action", [
-  z11.object({ action: z11.literal("create"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, name: z11.string().trim().min(1).max(100), expiresAt: z11.iso.datetime(), operationId: ReleaseIdSchema, apiKey: LearningSourceCredentialSecretSchema }).strict(),
-  z11.object({ action: z11.literal("list"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, afterId: ReleaseIdSchema.optional(), limit: z11.number().int().min(1).max(100).default(30) }).strict(),
-  z11.object({ action: z11.literal("revoke"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, id: ReleaseIdSchema }).strict()
-]);
-var LearningSourceCredentialCreatedSchema = z11.object({ credential: LearningSourceCredentialSchema, apiKey: LearningSourceCredentialSecretSchema }).strict();
-var LearningSourceCredentialPageSchema = z11.object({ items: z11.array(LearningSourceCredentialSchema).max(100), nextCursor: ReleaseIdSchema.nullable() }).strict();
-var LearningSourceConfigurationRequestSchema = z11.object({ scope: ReleaseIdSchema, sourceId: ReleaseIdSchema }).strict();
-var LearningSourceConfigurationSchema = z11.object({
-  scope: ReleaseIdSchema,
-  source: LearningRevisionRefSchema,
-  taskDefinition: LearningRevisionRefSchema,
-  enabled: z11.boolean(),
-  allowedSplits: z11.array(TaskSplitSchema).min(1).max(4)
-}).strict();
-function createSourceCredentialRequest(input) {
-  return { ...input, operationId: crypto.randomUUID(), apiKey: `opk_key_${randomToken(16)}_${randomToken(48)}` };
-}
-function randomToken(length) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let value = "";
-  while (value.length < length) {
-    for (const byte of crypto.getRandomValues(new Uint8Array(64))) {
-      if (byte < 248) value += alphabet[byte % 62];
-      if (value.length === length) return value;
-    }
-  }
-  return value;
-}
-function assertLearningCredentialExpiry(expiresAt, now) {
-  const expires = Date.parse(z11.iso.datetime().parse(expiresAt));
-  if (expires <= now.getTime() || expires > now.getTime() + 90 * 24 * 60 * 60 * 1e3) throw new Error("Source credentials must expire within 90 days.");
-}
+  LearningBatchPublicationResultSchema,
+  LearningBatchPublicationSchema,
+  LearningSourceConfigurationRequestSchema,
+  LearningSourceConfigurationSchema,
+  LearningSourceCredentialCreatedSchema,
+  LearningSourceCredentialPageSchema,
+  LearningSourceCredentialRequestSchema,
+  LearningSourceCredentialSchema,
+  LearningSourceCredentialSecretSchema,
+  OpenPondLearningClient,
+  OpenPondLearningError,
+  assertLearningCredentialExpiry,
+  createSourceCredentialRequest
+} from "./chunk-25TBEGXB.js";
+import "./chunk-EV4PKJWN.js";
+import "./chunk-NF63YMOL.js";
 
 // src/learning.ts
 export * from "@openpond/evals/learning";
 export * from "@openpond/evals/rewards";
-var LearningBatchPublicationSchema = z12.object({
-  batchId: z12.string().trim().min(1).max(500),
-  modelProjectId: z12.string().trim().min(1).max(500)
-}).strict();
-var LearningBatchPublicationResultSchema = z12.object({
-  batchId: z12.string().min(1),
-  projectId: z12.string().min(1),
-  tasksetId: z12.string().min(1),
-  releaseId: z12.string().min(1),
-  revision: z12.number().int().positive(),
-  contentHash: z12.string().regex(/^[a-f0-9]{64}$/)
-}).strict();
-var OpenPondLearningError = class extends Error {
-  constructor(status, code, message, details) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.name = "OpenPondLearningError";
-  }
-  status;
-  code;
-  details;
-};
-var OpenPondLearningClient = class {
-  #options;
-  constructor(options) {
-    if (!options.apiKey.trim() || !options.scope.trim()) throw new Error("Learning API key and scope are required.");
-    const url = new URL(options.baseUrl);
-    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("Learning base URL must be an HTTP(S) endpoint without credentials, query, or fragment.");
-    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
-  }
-  async command(command, options = {}) {
-    assertLearningRequestJson(command);
-    const request = LearningCommandRequestSchema.parse({ scope: this.#options.scope, command });
-    const result = LearningOperationResultSchema.parse(await this.#request("commands", request, options));
-    if (result.operationId !== command.operationId) throw new OpenPondLearningError(502, "operation_identity_mismatch", "Learning response did not match the submitted operation.", null);
-    return result;
-  }
-  submitExample(example, options = {}) {
-    return this.command({ action: "submit_example", operationId: example.idempotencyKey, example }, options);
-  }
-  submitFeedback(feedback, options = {}) {
-    return this.command({ action: "submit_feedback", operationId: feedback.idempotencyKey, feedback }, options);
-  }
-  async get(kind, id, revision, options = {}) {
-    const request = LearningReadRequestSchema.parse({ action: "get", scope: this.#options.scope, kind, id, ...revision === void 0 ? {} : { revision } });
-    return learningResourceSchemas[kind].parse(await this.#request("read", request, options));
-  }
-  async inspectEvidence(evidence, options = {}) {
-    const request = LearningReadRequestSchema.parse({ action: "inspect_evidence", scope: this.#options.scope, evidence });
-    const result = TaskEvidenceInspectionResultSchema.parse(await this.#request("read", request, options));
-    if (!sameLearningRef(result.evidence, evidence)) throw new OpenPondLearningError(502, "evidence_identity_mismatch", "Inspection did not match the requested evidence release.", null);
-    return result;
-  }
-  /** Prepare once with createSourceCredentialRequest and reuse it for retries. */
-  async createSourceCredential(input, options = {}) {
-    const request = LearningSourceCredentialRequestSchema.parse({ ...input, action: "create", scope: this.#options.scope });
-    const result = LearningSourceCredentialCreatedSchema.parse(await this.#request("credentials", request, options));
-    this.#assertCredentialScope(result.credential, input.sourceId);
-    if (result.apiKey !== input.apiKey || !input.apiKey.startsWith(`${result.credential.keyPrefix}_`)) throw new OpenPondLearningError(502, "credential_identity_mismatch", "Credential response did not match the prepared credential.", null);
-    return result;
-  }
-  async listSourceCredentials(sourceId, query = {}, options = {}) {
-    const request = LearningSourceCredentialRequestSchema.parse({ ...query, action: "list", scope: this.#options.scope, sourceId });
-    const result = LearningSourceCredentialPageSchema.parse(await this.#request("credentials", request, options));
-    if (result.items.length > (query.limit ?? 30)) throw new OpenPondLearningError(502, "credential_page_invalid", "Credential response exceeded the requested page size.", null);
-    for (const item of result.items) this.#assertCredentialScope(item, sourceId);
-    return result;
-  }
-  async revokeSourceCredential(sourceId, id, options = {}) {
-    const request = LearningSourceCredentialRequestSchema.parse({ action: "revoke", scope: this.#options.scope, sourceId, id });
-    const result = LearningSourceCredentialSchema.parse(await this.#request("credentials", request, options));
-    this.#assertCredentialScope(result, sourceId);
-    if (result.id !== id || result.revokedAt === null) throw new OpenPondLearningError(502, "credential_revocation_mismatch", "Credential revocation did not match the requested credential.", null);
-    return result;
-  }
-  async sourceConfiguration(sourceId, options = {}) {
-    const request = LearningSourceConfigurationRequestSchema.parse({ scope: this.#options.scope, sourceId });
-    const result = LearningSourceConfigurationSchema.parse(await this.#request("source-config", request, options));
-    if (result.scope !== this.#options.scope || result.source.id !== sourceId) throw new OpenPondLearningError(502, "source_identity_mismatch", "Source configuration did not match the requested source.", null);
-    return result;
-  }
-  #assertCredentialScope(value, sourceId) {
-    if (value.scope !== this.#options.scope || value.sourceId !== sourceId) throw new OpenPondLearningError(502, "credential_scope_mismatch", "Credential response did not match the requested source.", null);
-  }
-  async list(kind, query = {}, options = {}) {
-    const request = LearningReadRequestSchema.parse({ action: "list", scope: this.#options.scope, kind, ...query });
-    return z12.object({ items: z12.array(learningResourceSchemas[kind]).max(100), nextCursor: z12.string().nullable() }).strict().parse(await this.#request("read", request, options));
-  }
-  /** Hosted publication only: stores an immutable package and attaches it, without starting training. */
-  async publishBatch(input, options = {}) {
-    const request = LearningBatchPublicationSchema.parse(input);
-    const result = LearningBatchPublicationResultSchema.parse(await this.#request("publish-batch", { ...request, scope: this.#options.scope }, options));
-    if (result.batchId !== request.batchId) throw new OpenPondLearningError(502, "batch_identity_mismatch", "Published batch response did not match the requested batch.", null);
-    return result;
-  }
-  async #request(endpoint, body, options) {
-    assertBoundedTaskJson(body, 16777216);
-    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/learning/${endpoint}`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "Content-Type": "application/json", Accept: "application/json", "X-OpenPond-Team-Id": this.#options.scope },
-      body: JSON.stringify(body),
-      signal: options.signal,
-      redirect: "error"
-    });
-    const payload = await readBoundedLearningResponse(response);
-    if (!response.ok) {
-      const error = z12.object({ code: z12.string().optional(), error: z12.string().optional() }).passthrough().safeParse(payload);
-      throw new OpenPondLearningError(response.status, error.success ? error.data.code ?? "learning_request_failed" : "learning_request_failed", error.success ? error.data.error ?? `Learning request failed (${response.status}).` : `Learning request failed (${response.status}).`, payload);
-    }
-    return payload;
-  }
-};
-async function readBoundedLearningResponse(response) {
-  const maximumBytes = 16777216;
-  const reader = response.body?.getReader();
-  if (!reader) throw new OpenPondLearningError(response.status, "empty_response", "Learning response was empty.", null);
-  const decoder = new TextDecoder();
-  let bytes = 0;
-  let text = "";
-  try {
-    while (true) {
-      const next = await reader.read();
-      if (next.done) break;
-      bytes += next.value.byteLength;
-      if (bytes > maximumBytes) throw new OpenPondLearningError(response.status, "response_too_large", "Learning response exceeded 16 MiB; request a smaller page.", null);
-      text += decoder.decode(next.value, { stream: true });
-    }
-    text += decoder.decode();
-    const value = JSON.parse(text);
-    assertBoundedTaskJson(value, maximumBytes);
-    return value;
-  } finally {
-    await reader.cancel();
-    reader.releaseLock();
-  }
-}
 export {
   LearningBatchPublicationResultSchema,
   LearningBatchPublicationSchema,