openpond-sdk 0.11.4 → 0.11.6

package/dist/chunk-4NZW4LFB.js

@@ -1,1635 +0,0 @@
-import {
-  FailureClassSchema,
-  HarnessRefinerCapabilitiesSchema,
-  HarnessRefinerEvidenceBasisSchema,
-  ImmutableArtifactRefSchema,
-  ImmutableAssetRefSchema,
-  ImmutableReleaseRefSchema,
-  MetadataSchema,
-  ReleaseHashSchema,
-  ReleaseIdSchema,
-  ReleaseTimestampSchema,
-  assertContentHash,
-  contentHash,
-  sha256
-} from "./chunk-QUOW6URQ.js";
-
-// ../harness/dist/models.js
-import { z } from "zod";
-var ModelRefSchema = z.object({
-  provider: ReleaseIdSchema,
-  model: ReleaseIdSchema,
-  revision: z.string().trim().min(1).max(500).nullable().default(null),
-  artifactHash: ReleaseHashSchema.nullable().default(null),
-  tokenizerRevision: z.string().trim().min(1).max(500).nullable().default(null),
-  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
-}).strict();
-var PROVIDER_IDS = [
-  "openpond",
-  "codex",
-  "claude-code",
-  "grok-build",
-  "opencode",
-  "anthropic",
-  "openai",
-  "xai",
-  "google",
-  "openrouter",
-  "deepseek",
-  "zai",
-  "moonshot",
-  "together",
-  "groq",
-  "custom-openai-compatible"
-];
-var ProviderIdSchema = z.enum(PROVIDER_IDS);
-var ChatModelRefSchema = z.object({
-  providerId: ProviderIdSchema,
-  modelId: z.string().trim().min(1).max(300)
-});
-
-// ../harness/dist/source-package.js
-import { z as z4 } from "zod";
-
-// ../harness/dist/harness.js
-import { z as z3 } from "zod";
-
-// ../harness/dist/tools.js
-import { z as z2 } from "zod";
-var ToolDeclarationSchema = z2.object({
-  name: z2.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-  description: z2.string().trim().min(1).max(2e3),
-  inputSchema: z2.record(z2.string(), z2.unknown()),
-  inputSchemaHash: ReleaseHashSchema,
-  sideEffect: z2.enum(["read", "write"]),
-  timeoutMs: z2.number().int().positive().max(36e5)
-}).strict();
-var CapabilityRequirementSchema = z2.object({
-  id: ReleaseIdSchema,
-  required: z2.boolean(),
-  scopes: z2.array(z2.string().trim().min(1).max(500)).max(100).default([]),
-  portability: z2.enum(["portable", "host_adapter", "local_only", "hosted_only"])
-}).strict();
-
-// ../harness/dist/harness.js
-var PortabilityReportSchema = z3.object({
-  portable: z3.boolean(),
-  blockers: z3.array(z3.string().trim().min(1).max(2e3)).max(1e3),
-  localOnlyAssetRefs: z3.array(ReleaseIdSchema).max(1e4),
-  hostPrivateAssetRefs: z3.array(ReleaseIdSchema).max(1e4)
-}).strict();
-var AgentSnapshotContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.agentSnapshot.v2"),
-  id: ReleaseIdSchema,
-  sourceRelease: ImmutableReleaseRefSchema.nullable(),
-  instructions: z3.array(ImmutableAssetRefSchema).max(1e4),
-  skills: z3.array(ImmutableAssetRefSchema).max(1e4),
-  agents: z3.array(ImmutableAssetRefSchema).max(1e4),
-  toolDeclarations: z3.array(ToolDeclarationSchema).max(200),
-  capabilityRequirements: z3.array(CapabilityRequirementSchema).max(200),
-  dependencyLock: ImmutableAssetRefSchema,
-  portability: PortabilityReportSchema,
-  metadata: MetadataSchema
-}).strict();
-var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var LifecycleContractSchema = z3.object({
-  create: z3.literal(true),
-  reset: z3.literal(true),
-  step: z3.literal(true),
-  collect: z3.literal(true),
-  destroy: z3.literal(true),
-  resetScope: z3.enum(["task", "attempt"])
-}).strict();
-var GraderInterfaceContractSchema = z3.object({
-  visibleEvidence: z3.array(ReleaseIdSchema).max(1e3),
-  privilegedEvidence: z3.array(ReleaseIdSchema).max(1e3),
-  privateVerifierIsolation: z3.boolean()
-}).strict();
-var HarnessReleaseContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessRelease.v2"),
-  id: ReleaseIdSchema,
-  agentSnapshot: ImmutableReleaseRefSchema,
-  program: ImmutableAssetRefSchema,
-  tools: z3.array(ToolDeclarationSchema).max(200),
-  lifecycle: LifecycleContractSchema,
-  graderInterface: GraderInterfaceContractSchema,
-  files: z3.array(ImmutableAssetRefSchema).max(1e5),
-  metadata: MetadataSchema
-}).strict();
-var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var ModelActionSchema = z3.object({
-  id: ReleaseIdSchema,
-  turn: z3.number().int().nonnegative(),
-  kind: z3.enum(["message", "tool_call", "terminal"]),
-  name: ReleaseIdSchema.nullable(),
-  arguments: z3.record(z3.string(), z3.unknown()),
-  content: z3.string().max(1e6).nullable()
-}).strict();
-var ToolObservationSchema = z3.object({
-  actionId: ReleaseIdSchema,
-  turn: z3.number().int().nonnegative(),
-  terminal: z3.boolean(),
-  output: z3.record(z3.string(), z3.unknown()),
-  artifactRefs: z3.array(ImmutableArtifactRefSchema).max(1e5)
-}).strict();
-function createAgentSnapshot(input) {
-  const content = AgentSnapshotContentSchema.parse(input);
-  return AgentSnapshotSchema.parse({ ...content, contentHash: contentHash(content) });
-}
-function createHarnessRelease(input) {
-  const content = HarnessReleaseContentSchema.parse(input);
-  return HarnessReleaseSchema.parse({ ...content, contentHash: contentHash(content) });
-}
-var HarnessLifecycleEventSchema = z3.object({
-  sequence: z3.number().int().nonnegative(),
-  type: z3.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
-  payloadHash: ReleaseHashSchema,
-  metadata: MetadataSchema
-}).strict();
-var HarnessTraceSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessTrace.v1"),
-  manifest: ImmutableReleaseRefSchema,
-  taskId: ReleaseIdSchema,
-  seed: z3.string().trim().min(1).max(500),
-  events: z3.array(HarnessLifecycleEventSchema).max(1e6),
-  actions: z3.array(ModelActionSchema).max(1e5),
-  observations: z3.array(ToolObservationSchema).max(1e5),
-  terminal: z3.boolean(),
-  failureClass: FailureClassSchema.nullable(),
-  output: z3.record(z3.string(), z3.unknown()),
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/source-package.js
-var MAX_HARNESS_SOURCE_PACKAGE_BYTES = 25 * 1024 * 1024;
-var HarnessSourceFileSchema = z4.object({
-  path: ImmutableAssetRefSchema.shape.path,
-  base64: z4.string().max(Math.ceil(MAX_HARNESS_SOURCE_PACKAGE_BYTES / 3) * 4)
-}).strict();
-var HarnessSourcePackageContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessSourcePackage.v1"),
-  agentSnapshot: AgentSnapshotSchema,
-  harnessRelease: HarnessReleaseSchema,
-  files: z4.array(HarnessSourceFileSchema).max(1e4)
-}).strict();
-var HarnessSourcePackageSchema = HarnessSourcePackageContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessPolicySourcePackageSchema = HarnessSourcePackageContentSchema.extend({
-  schemaVersion: z4.literal("openpond.harnessPolicySourcePackage.v1"),
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessSourceSelectionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessSourceSelection.v1"),
-  mode: z4.enum(["taskset_owned", "selected_release"]),
-  harnessRelease: ImmutableReleaseRefSchema,
-  sourcePackageHash: ReleaseHashSchema.nullable()
-}).strict().superRefine((selection, context) => {
-  if (selection.mode === "selected_release" !== (selection.sourcePackageHash !== null)) {
-    context.addIssue({ code: "custom", path: ["sourcePackageHash"], message: "Only a selected release binds a source package." });
-  }
-});
-function validateHarnessPolicySourcePackage(value, expected) {
-  const source = HarnessPolicySourcePackageSchema.parse(value);
-  assertContentHash(source, "Harness policy source package");
-  assertContentHash(source.agentSnapshot, "Harness policy source Agent snapshot");
-  assertContentHash(source.harnessRelease, "Harness policy source release");
-  const { agentSnapshot, harnessRelease } = source;
-  if (expected && (expected.id !== harnessRelease.id || expected.contentHash !== harnessRelease.contentHash)) {
-    throw new Error("Harness policy source package differs from the selected release.");
-  }
-  if (harnessRelease.agentSnapshot.id !== agentSnapshot.id || harnessRelease.agentSnapshot.contentHash !== agentSnapshot.contentHash) {
-    throw new Error("Harness policy source release does not bind its Agent snapshot.");
-  }
-  const assets = /* @__PURE__ */ new Map();
-  for (const asset of harnessRelease.files) {
-    if (assets.has(asset.path))
-      throw new Error("Harness policy source contains duplicate asset paths.");
-    assets.set(asset.path, asset);
-  }
-  for (const asset of [
-    harnessRelease.program,
-    agentSnapshot.dependencyLock,
-    ...agentSnapshot.instructions,
-    ...agentSnapshot.skills,
-    ...agentSnapshot.agents
-  ]) {
-    if (contentHash(assets.get(asset.path) ?? null) !== contentHash(asset)) {
-      throw new Error(`Harness policy source dependency ${asset.path} is absent or differs from its release inventory.`);
-    }
-  }
-  for (const asset of [
-    harnessRelease.program,
-    agentSnapshot.dependencyLock,
-    ...agentSnapshot.instructions,
-    ...agentSnapshot.skills
-  ]) {
-    if (asset.visibility !== "policy")
-      throw new Error(`Harness policy source dependency ${asset.path} is private.`);
-  }
-  const expectedPaths = new Set(harnessRelease.files.filter((asset) => asset.visibility === "policy").map((asset) => asset.path));
-  const paths = /* @__PURE__ */ new Set();
-  let totalBytes = 0;
-  for (const file of source.files) {
-    if (paths.has(file.path))
-      throw new Error("Harness policy source contains duplicate files.");
-    paths.add(file.path);
-    const asset = assets.get(file.path);
-    if (!asset || asset.visibility !== "policy")
-      throw new Error(`Harness policy source file ${file.path} is not policy-visible.`);
-    const bytes = decode(file.base64);
-    totalBytes += bytes.byteLength;
-    if (totalBytes > MAX_HARNESS_SOURCE_PACKAGE_BYTES)
-      throw new Error("Harness policy source exceeds its byte limit.");
-    if (bytes.byteLength !== asset.sizeBytes || sha256(bytes) !== asset.contentHash) {
-      throw new Error(`Harness policy source file ${file.path} differs from its immutable bytes.`);
-    }
-  }
-  if (paths.size !== expectedPaths.size || [...expectedPaths].some((path) => !paths.has(path))) {
-    throw new Error("Harness policy source is missing released policy files.");
-  }
-  return source;
-}
-function validateHarnessSourcePackage(value, expected) {
-  const source = HarnessSourcePackageSchema.parse(value);
-  assertContentHash(source, "Harness source package");
-  assertContentHash(source.agentSnapshot, "Harness source Agent snapshot");
-  assertContentHash(source.harnessRelease, "Harness source release");
-  const { agentSnapshot, harnessRelease } = source;
-  if (expected && (expected.id !== harnessRelease.id || expected.contentHash !== harnessRelease.contentHash)) {
-    throw new Error("Harness source package differs from the selected release.");
-  }
-  if (harnessRelease.agentSnapshot.id !== agentSnapshot.id || harnessRelease.agentSnapshot.contentHash !== agentSnapshot.contentHash) {
-    throw new Error("Harness source release does not bind its Agent snapshot.");
-  }
-  const assets = /* @__PURE__ */ new Map();
-  const ids = /* @__PURE__ */ new Set();
-  for (const asset of harnessRelease.files) {
-    if (asset.path.includes("\\") || asset.path.includes(":"))
-      throw new Error("Harness source requires portable relative file paths.");
-    if (assets.has(asset.path) || ids.has(asset.id))
-      throw new Error("Harness source contains duplicate asset paths or identities.");
-    assets.set(asset.path, asset);
-    ids.add(asset.id);
-  }
-  for (const asset of [
-    harnessRelease.program,
-    agentSnapshot.dependencyLock,
-    ...agentSnapshot.instructions,
-    ...agentSnapshot.skills,
-    ...agentSnapshot.agents
-  ]) {
-    if (contentHash(assets.get(asset.path) ?? null) !== contentHash(asset)) {
-      throw new Error(`Harness source dependency ${asset.path} is absent or differs from its release inventory.`);
-    }
-  }
-  for (const asset of [...agentSnapshot.instructions, ...agentSnapshot.skills]) {
-    if (asset.visibility !== "policy")
-      throw new Error(`Harness policy source ${asset.path} is private.`);
-  }
-  const paths = /* @__PURE__ */ new Set();
-  let totalBytes = 0;
-  for (const file of source.files) {
-    if (paths.has(file.path))
-      throw new Error("Harness source package contains duplicate files.");
-    paths.add(file.path);
-    const asset = assets.get(file.path);
-    if (!asset)
-      throw new Error(`Harness source file ${file.path} is not declared by its release.`);
-    const bytes = decode(file.base64);
-    totalBytes += bytes.byteLength;
-    if (totalBytes > MAX_HARNESS_SOURCE_PACKAGE_BYTES)
-      throw new Error("Harness source package exceeds its byte limit.");
-    if (bytes.byteLength !== asset.sizeBytes || sha256(bytes) !== asset.contentHash) {
-      throw new Error(`Harness source file ${file.path} differs from its immutable bytes.`);
-    }
-  }
-  if (paths.size !== assets.size)
-    throw new Error("Harness source package is missing released files.");
-  return source;
-}
-function decode(base64) {
-  let binary;
-  try {
-    binary = atob(base64);
-  } catch {
-    throw new Error("Harness source file is not valid base64.");
-  }
-  if (btoa(binary) !== base64)
-    throw new Error("Harness source file is not canonical base64.");
-  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
-}
-
-// ../harness/dist/evaluation-review.js
-import { z as z5 } from "zod";
-var BoundedTextSchema = z5.string().trim().min(1).max(1e5);
-var HarnessEvaluationReviewClassificationSchema = z5.enum([
-  "no_action",
-  "harness_maintenance",
-  "runtime",
-  "product",
-  "taskset",
-  "model_improvement"
-]);
-var HarnessEvaluationReviewAuthoritySchema = z5.enum([
-  "none",
-  "runtime_service",
-  "product_team",
-  "human_review",
-  "evaluation_system",
-  "training_system"
-]);
-var HarnessReviewEvidenceKindSchema = z5.enum([
-  "observation",
-  "trigger",
-  "route_decision",
-  "refiner_outcome",
-  "proposal",
-  "validation",
-  "apply_receipt",
-  "harness_advance",
-  "rollback",
-  "work_outcome",
-  "taskset",
-  "evaluation",
-  "training_qualification",
-  "model_candidate"
-]);
-var HarnessReviewOwnerScopeSchema = z5.object({
-  kind: z5.enum(["personal", "team"]),
-  id: ReleaseIdSchema
-}).strict();
-var HarnessReviewSourcePolicyRefSchema = z5.object({
-  policy: ImmutableReleaseRefSchema,
-  state: z5.enum(["authorized", "revoked", "deleted", "expired"]),
-  checkedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewEvidenceRefSchema = z5.object({
-  evidence: ImmutableReleaseRefSchema,
-  kind: HarnessReviewEvidenceKindSchema,
-  sourceRef: ReleaseIdSchema,
-  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
-  occurrenceKey: ReleaseHashSchema,
-  occurredAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewExcludedEvidenceSchema = z5.object({
-  evidence: ImmutableReleaseRefSchema,
-  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
-  reason: z5.enum([
-    "outside_scope",
-    "before_watermark",
-    "duplicate",
-    "resolved",
-    "revoked",
-    "deleted",
-    "expired",
-    "sensitive",
-    "unverified",
-    "budget"
-  ])
-}).strict();
-var HarnessReviewWatermarkSchema = z5.object({
-  cursor: ReleaseHashSchema,
-  throughCreatedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewClaimSchema = z5.object({
-  fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z5.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema,
-  candidateDisposition: z5.enum(["observe", "confirm"]).optional(),
-  independentOccurrences: z5.number().int().positive().max(1e6),
-  unresolvedOccurrences: z5.number().int().positive().max(1e6)
-}).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
-var HarnessReviewTriageLayerSchema = z5.enum([
-  "harness",
-  "runtime",
-  "product",
-  "retrieval",
-  "tools",
-  "evaluation",
-  "model"
-]);
-var HarnessReviewTriageDecisionSchema = z5.object({
-  layer: HarnessReviewTriageLayerSchema,
-  status: z5.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
-  reason: BoundedTextSchema,
-  evidenceRefs: z5.array(ImmutableReleaseRefSchema).max(1e3)
-}).strict();
-var HarnessEvaluationReviewReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessEvaluationReviewReceipt.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
-  nextWatermark: HarnessReviewWatermarkSchema,
-  selectedEvidence: z5.array(HarnessReviewEvidenceRefSchema).max(1e4),
-  excludedEvidence: z5.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
-  claim: HarnessReviewClaimSchema.nullable(),
-  classification: HarnessEvaluationReviewClassificationSchema,
-  triage: z5.array(HarnessReviewTriageDecisionSchema).max(16),
-  reason: BoundedTextSchema,
-  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
-  maxEstimatedCostUsd: z5.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 = z5.object({
-  id: ReleaseIdSchema,
-  evidence: ImmutableReleaseRefSchema,
-  kind: HarnessReviewEvidenceKindSchema,
-  sourceRef: ReleaseIdSchema,
-  occurredAt: ReleaseTimestampSchema,
-  payload: z5.record(z5.string(), z5.unknown())
-}).strict();
-var HarnessEvaluationReviewModelNoActionSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z5.literal("no_action"),
-  reason: BoundedTextSchema,
-  ignoredEvidence: z5.array(z5.object({
-    id: ReleaseIdSchema,
-    reason: z5.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3)
-}).strict();
-var HarnessEvaluationReviewModelActionSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z5.literal("review"),
-  classification: z5.enum([
-    "harness_maintenance",
-    "runtime",
-    "product",
-    "taskset"
-  ]),
-  selectedEvidenceIds: z5.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z5.array(z5.object({
-    id: ReleaseIdSchema,
-    reason: z5.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3),
-  recurrenceFamily: z5.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema,
-  triageLayer: HarnessReviewTriageLayerSchema,
-  expectedOutcome: BoundedTextSchema,
-  counterevidence: z5.string().trim().max(1e4),
-  confidence: z5.number().min(0).max(1),
-  candidateDisposition: z5.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 = z5.object({
-  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z5.literal("resolve_candidate"),
-  candidateId: ReleaseIdSchema,
-  candidateFingerprint: ReleaseHashSchema,
-  selectedEvidenceIds: z5.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z5.array(z5.object({
-    id: ReleaseIdSchema,
-    reason: z5.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3),
-  confidence: z5.number().min(0).max(1),
-  reason: BoundedTextSchema
-}).strict();
-var HarnessEvaluationReviewModelDecisionSchema = z5.discriminatedUnion("decision", [
-  HarnessEvaluationReviewModelNoActionSchema,
-  HarnessEvaluationReviewModelActionSchema,
-  HarnessEvaluationReviewModelResolutionSchema
-]);
-var HarnessEvaluationReviewNavigationDecisionSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
-  selectedEvidenceIds: z5.array(ReleaseIdSchema).min(1).max(50),
-  reason: BoundedTextSchema
-}).strict();
-
-// ../harness/dist/harness-improvements.js
-import { z as z7 } from "zod";
-
-// ../harness/dist/harness-workspaces.js
-import { z as z6 } from "zod";
-var MetadataSchema2 = z6.record(z6.string(), z6.unknown()).default({});
-var RevisionSchema = z6.number().int().nonnegative();
-var BoundedTextSchema2 = z6.string().trim().min(1).max(1e5);
-var HarnessOwnerScopeSchema = z6.object({
-  kind: z6.enum(["personal", "team"]),
-  id: ReleaseIdSchema
-}).strict();
-var HarnessCurrentChannelSchema = z6.object({
-  name: ReleaseIdSchema,
-  release: ImmutableReleaseRefSchema.nullable(),
-  revision: RevisionSchema
-}).strict();
-var HarnessWorkspaceSchema = z6.object({
-  schemaVersion: z6.literal("openpond.harnessWorkspace.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessOwnerScopeSchema,
-  name: z6.string().trim().min(1).max(240),
-  location: z6.enum(["local", "hosted"]),
-  sourceRevision: z6.string().trim().min(1).max(500),
-  revision: RevisionSchema,
-  dirty: z6.boolean(),
-  currentChannel: HarnessCurrentChannelSchema,
-  createdAt: ReleaseTimestampSchema,
-  updatedAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessImprovementRouteSchema = z6.enum([
-  "runtime",
-  "memory",
-  "prompt",
-  "skill",
-  "agent",
-  "product",
-  "taskset",
-  "training"
-]);
-var HarnessChangeEffectSchema = z6.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 = z6.object({
-  id: ReleaseIdSchema,
-  route: HarnessImprovementRouteSchema,
-  operation: z6.enum(["create", "update", "delete"]),
-  target: z6.string().trim().min(1).max(2e3),
-  summary: z6.string().trim().min(1).max(2e3),
-  content: z6.string().max(1e6).nullable(),
-  contentHash: ReleaseHashSchema.nullable(),
-  effects: z6.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 = z6.object({
-  workspaceId: ReleaseIdSchema,
-  revision: RevisionSchema,
-  sourceRevision: z6.string().trim().min(1).max(500),
-  channelRevision: RevisionSchema
-}).strict();
-var HarnessOverlaySnapshotRefSchema = z6.object({
-  id: ReleaseIdSchema,
-  revision: RevisionSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessTurnSnapshotSchema = z6.object({
-  schemaVersion: z6.literal("openpond.harnessTurnSnapshot.v1"),
-  workspaceId: ReleaseIdSchema,
-  workspaceRevision: RevisionSchema,
-  sourceRevision: z6.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 = z6.object({
-  schemaVersion: z6.literal("openpond.harnessRunOverlay.v1"),
-  id: ReleaseIdSchema,
-  runId: ReleaseIdSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  workspace: HarnessWorkspaceRevisionRefSchema,
-  revision: RevisionSchema,
-  status: z6.enum(["active", "frozen", "abandoned"]),
-  edits: z6.array(HarnessOverlayEditSchema).max(1e3),
-  createdAt: ReleaseTimestampSchema,
-  updatedAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessProposalEvidenceRefSchema = z6.object({
-  kind: z6.enum([
-    "tool_event",
-    "recovery",
-    "validation",
-    "user_turn",
-    "work_output",
-    "work_receipt"
-  ]),
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema.nullable()
-}).strict();
-var HarnessValidationPlanItemSchema = z6.object({
-  id: ReleaseIdSchema,
-  kind: z6.enum([
-    "dependency",
-    "schema",
-    "package",
-    "file_render",
-    "skill",
-    "prompt",
-    "business_formula",
-    "targeted_evaluation",
-    "observed_recovery",
-    "memory",
-    "component_activation"
-  ]),
-  description: BoundedTextSchema2,
-  required: z6.boolean()
-}).strict();
-var HarnessImprovementProposalContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.harnessImprovementProposal.v1"),
-  id: ReleaseIdSchema,
-  overlay: HarnessOverlaySnapshotRefSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
-  requestedScope: z6.enum(["personal", "team", "global"]),
-  route: HarnessImprovementRouteSchema,
-  risk: z6.enum(["low", "review", "restricted"]),
-  effects: z6.array(HarnessChangeEffectSchema).min(1).max(20),
-  evidence: z6.array(HarnessProposalEvidenceRefSchema).min(1).max(1e3),
-  edits: z6.array(HarnessOverlayEditSchema).min(1).max(1e3),
-  validationPlan: z6.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 = z6.object({
-  schemaVersion: z6.literal("openpond.harnessTargetedValidationReceipt.v1"),
-  id: ReleaseIdSchema,
-  proposal: ImmutableReleaseRefSchema,
-  validationId: ReleaseIdSchema,
-  kind: HarnessValidationPlanItemSchema.shape.kind,
-  status: z6.enum(["passed", "failed", "blocked", "skipped"]),
-  summary: BoundedTextSchema2,
-  evidenceRefs: z6.array(HarnessProposalEvidenceRefSchema).max(1e3),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessAdvanceDecisionSchema = z6.enum([
-  "advanced",
-  "retained",
-  "conflict",
-  "rolled_back"
-]);
-var HarnessAdvanceReceiptContentSchema = z6.object({
-  schemaVersion: z6.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: z6.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 = z6.object({
-  schemaVersion: z6.literal("openpond.harnessOverlayMergeReceipt.v1"),
-  id: ReleaseIdSchema,
-  workspaceId: ReleaseIdSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  leftOverlay: HarnessOverlaySnapshotRefSchema,
-  rightOverlay: HarnessOverlaySnapshotRefSchema,
-  decision: z6.enum(["merged", "conflict"]),
-  mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  conflictTargets: z6.array(z6.string().trim().min(1).max(2e3)).max(1e3),
-  requiresRevalidation: z6.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 = z7.string().trim().min(1).max(1e5);
-var MetadataSchema3 = z7.record(z7.string(), z7.unknown()).default({});
-var ImprovementSafeBoundaryKindSchema = z7.enum([
-  "completed_tool_batch",
-  "before_model_step",
-  "turn_completed",
-  "turn_paused"
-]);
-var ImprovementSafeBoundarySchema = z7.object({
-  kind: ImprovementSafeBoundaryKindSchema,
-  eventSequence: z7.number().int().nonnegative(),
-  occurredAt: ReleaseTimestampSchema
-}).strict();
-var ImprovementEventRefSchema = z7.object({
-  id: ReleaseIdSchema,
-  sequence: z7.number().int().nonnegative().nullable(),
-  contentHash: ReleaseHashSchema
-}).strict();
-var ImprovementObservationKindSchema = z7.enum([
-  "tool_failure",
-  "retry",
-  "recovery",
-  "validation",
-  "user_turn",
-  "reusable_success",
-  "completion_detour"
-]);
-var ImprovementObservationStateSchema = z7.enum([
-  "open",
-  "recovered",
-  "terminal"
-]);
-var ImprovementToolIdentitySchema = z7.object({
-  name: z7.string().trim().min(1).max(500),
-  invocationKey: ReleaseHashSchema
-}).strict();
-var ImprovementObservationContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.improvementObservation.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  eventRefs: z7.array(ImprovementEventRefSchema).min(1).max(100),
-  kind: ImprovementObservationKindSchema,
-  state: ImprovementObservationStateSchema,
-  tool: ImprovementToolIdentitySchema.nullable(),
-  deterministicClass: z7.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 = z7.object({
-  schemaVersion: z7.literal("openpond.refinementTriggerPolicy.v1"),
-  maxEstimatedCostUsd: z7.number().finite().nonnegative(),
-  cooldownMs: z7.number().int().nonnegative(),
-  maxPendingPlans: z7.number().int().min(1).max(100),
-  maxEvidenceEvents: z7.number().int().min(1).max(1e3),
-  maxProposalEdits: z7.number().int().min(1).max(1e3),
-  maxProposalBytes: z7.number().int().min(1).max(1e7)
-}).strict();
-var RefinementTriggerDecisionKindSchema = z7.enum([
-  "no_action",
-  "route_deterministically",
-  "queue_refiner"
-]);
-var RefinementTriggerDecisionContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.refinementTriggerDecision.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  observations: z7.array(ImmutableReleaseRefSchema).max(100),
-  decision: RefinementTriggerDecisionKindSchema,
-  deterministicRoute: HarnessImprovementRouteSchema.nullable(),
-  suggestedRoutes: z7.array(HarnessImprovementRouteSchema).max(8),
-  reason: BoundedTextSchema3,
-  deduplicationKey: ReleaseHashSchema,
-  policy: RefinementTriggerPolicySchema,
-  estimatedMaxCostUsd: z7.number().finite().nonnegative(),
-  pendingPlanCount: z7.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 = z7.enum([
-  "runtime_service",
-  "refiner_model",
-  "human_review",
-  "evaluation_system",
-  "training_system"
-]);
-var ImprovementRouteDecisionContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.improvementRouteDecision.v1"),
-  id: ReleaseIdSchema,
-  trigger: ImmutableReleaseRefSchema,
-  route: HarnessImprovementRouteSchema,
-  authority: ImprovementRouteAuthoritySchema,
-  automatic: z7.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 = z7.object({
-  schemaVersion: z7.literal("openpond.harnessRefinerOutcome.v1"),
-  id: ReleaseIdSchema,
-  trigger: ImmutableReleaseRefSchema,
-  decision: z7.enum(["no_action", "proposed"]),
-  proposal: ImmutableReleaseRefSchema.nullable(),
-  reason: BoundedTextSchema3,
-  evidenceRefs: z7.array(ImmutableReleaseRefSchema).max(100),
-  estimatedCostUsd: z7.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 = z7.enum([
-  "applied",
-  "retained",
-  "declined",
-  "conflict",
-  "rolled_back"
-]);
-var ImprovementApplyReceiptContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.improvementApplyReceipt.v1"),
-  id: ReleaseIdSchema,
-  proposal: ImmutableReleaseRefSchema,
-  beforeOverlay: HarnessOverlaySnapshotRefSchema,
-  afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  decision: ImprovementApplyDecisionSchema,
-  boundary: ImprovementSafeBoundarySchema,
-  validationRefs: z7.array(ImmutableReleaseRefSchema).max(100),
-  outcomeEvidenceRefs: z7.array(ImprovementEventRefSchema).max(1e3),
-  rollbackOf: ImmutableReleaseRefSchema.nullable(),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((receipt, context) => {
-  if (receipt.decision === "applied" !== (receipt.afterOverlay !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "applied receipts require an after-overlay; other decisions cannot include one",
-      path: ["afterOverlay"]
-    });
-  }
-  if (receipt.decision === "rolled_back" !== (receipt.rollbackOf !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "only rollback receipts require rollbackOf",
-      path: ["rollbackOf"]
-    });
-  }
-});
-var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/refinement-lifecycle.js
-import { z as z8 } from "zod";
-var ShortTextSchema = z8.string().trim().min(1).max(2e3);
-var BoundedTextSchema4 = z8.string().trim().min(1).max(1e5);
-var HarnessRefinerOperationSchema = z8.enum(["create", "update", "delete"]);
-var HarnessRefinerInternalRouteSchema = z8.enum([
-  "memory",
-  "prompt",
-  "skill",
-  "agent"
-]);
-var HarnessRefinerExternalRouteSchema = z8.enum([
-  "runtime",
-  "product",
-  "taskset",
-  "training"
-]);
-var HarnessRefinerActivityResultSchema = z8.enum([
-  "no_action",
-  "routed",
-  "applied",
-  "retained",
-  "failed"
-]);
-var HarnessRefinerCritiqueStatusSchema = z8.enum([
-  "not_applicable",
-  "pending",
-  "passed",
-  "rejected",
-  "failed"
-]);
-var HarnessRefinerValidationStatusSchema = z8.enum([
-  "not_applicable",
-  "pending",
-  "passed",
-  "failed"
-]);
-var HarnessRefinerActivityReceiptContentSchema = z8.object({
-  schemaVersion: z8.literal("openpond.harnessRefinerActivityReceipt.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  result: HarnessRefinerActivityResultSchema,
-  decision: z8.enum(["no_action", "route", "propose"]).nullable(),
-  route: HarnessImprovementRouteSchema.nullable(),
-  operation: HarnessRefinerOperationSchema.nullable(),
-  target: z8.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 = z8.enum([
-  "unresolved",
-  "confirmed",
-  "resolved",
-  "rejected",
-  "expired"
-]);
-var HarnessRefinementCandidateResolutionSchema = z8.object({
-  kind: z8.enum([
-    "applied_change",
-    "later_success",
-    "manual_rejection",
-    "source_revoked",
-    "expired"
-  ]),
-  reason: BoundedTextSchema4,
-  evidenceRefs: z8.array(ImmutableReleaseRefSchema).max(1e3),
-  resolvedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessRefinementCandidateContentSchema = z8.object({
-  schemaVersion: z8.literal("openpond.harnessRefinementCandidate.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z8.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema4,
-  status: HarnessRefinementCandidateStatusSchema,
-  occurrences: z8.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  counterevidence: z8.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  sourceReviews: z8.array(ImmutableReleaseRefSchema).min(1).max(100),
-  relatedHarnessReleases: z8.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 = z8.enum([
-  "created",
-  "merged",
-  "rejected",
-  "expired",
-  "reopened",
-  "resolved"
-]);
-var HarnessRefinementCandidateLifecycleReceiptContentSchema = z8.object({
-  schemaVersion: z8.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
-  id: ReleaseIdSchema,
-  candidateId: ReleaseIdSchema,
-  decision: HarnessRefinementCandidateLifecycleDecisionSchema,
-  beforeCandidate: ImmutableReleaseRefSchema.nullable(),
-  afterCandidate: ImmutableReleaseRefSchema,
-  review: ImmutableReleaseRefSchema,
-  addedEvidence: z8.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  removedEvidence: z8.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 = z8.object({
-  schemaVersion: z8.literal("openpond.harnessCrossRunRefinementRequest.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  candidate: ImmutableReleaseRefSchema,
-  candidateFingerprint: ReleaseHashSchema,
-  review: ImmutableReleaseRefSchema,
-  admittedHarness: ImmutableReleaseRefSchema,
-  evidence: z8.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"]
-    });
-  }
-}
-
-// ../harness/dist/source-runtime.js
-import { z as z9 } from "zod";
-var ReadInputSchema = z9.object({
-  path: z9.string().min(1).max(2e3),
-  offset: z9.number().int().nonnegative().default(0),
-  length: z9.number().int().positive().max(65536).default(16384)
-}).strict();
-
-// ../harness/dist/profile-workflows.js
-import { z as z10 } from "zod";
-var WorkflowIdSchema = z10.string().regex(/^[a-z][a-z0-9_-]{0,119}$/);
-var SourcePathSchema = z10.string().min(1).max(2e3).refine((value) => !value.includes("\\") && !value.includes(":") && !value.startsWith("/") && value.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "workflow references require portable relative paths");
-var ProfileWorkflowSchema = z10.object({
-  id: WorkflowIdSchema,
-  label: z10.string().trim().min(1).max(240),
-  description: z10.string().max(4e3),
-  inputSchema: z10.record(z10.string(), z10.unknown()),
-  invocation: z10.discriminatedUnion("kind", [
-    z10.object({ kind: z10.literal("instructions"), instructions: z10.string().min(1).max(1e5).refine((value) => Boolean(value.trim())) }).strict(),
-    z10.object({ kind: z10.literal("agent_action"), actionId: z10.string().trim().min(1).max(240) }).strict()
-  ]),
-  skillPaths: z10.array(SourcePathSchema).max(100)
-}).strict();
-var ProfileWorkflowCatalogSchema = z10.object({
-  schemaVersion: z10.literal("openpond.profileWorkflows.v1"),
-  workflows: z10.array(ProfileWorkflowSchema).max(1e3)
-}).strict();
-var ProfileWorkflowActionSchema = z10.object({
-  id: z10.string().trim().min(1).max(240),
-  agentId: z10.string().regex(/^[a-zA-Z0-9_-]{1,240}$/),
-  sourceActionId: z10.string().trim().min(1).max(240),
-  inputSchema: z10.record(z10.string(), z10.unknown())
-}).strict();
-var ProfileWorkflowActionsSchema = z10.object({
-  schemaVersion: z10.literal("openpond.profileWorkflowActions.v1"),
-  actions: z10.array(ProfileWorkflowActionSchema).max(200)
-}).strict();
-var ProfileWorkflowBindingSchema = z10.object({
-  schemaVersion: z10.literal("openpond.profileWorkflowBinding.v1"),
-  profileId: z10.string().trim().min(1).max(240),
-  sourceRevision: z10.string().trim().min(1).max(240),
-  harnessRelease: ImmutableReleaseRefSchema,
-  catalogHash: ReleaseHashSchema,
-  workflowId: WorkflowIdSchema
-}).strict();
-var ProfileComponentBindingSchema = z10.object({
-  schemaVersion: z10.literal("openpond.profileComponentBinding.v1"),
-  profileId: z10.string().trim().min(1).max(240),
-  sourceRevision: z10.string().trim().min(1).max(240),
-  harnessRelease: ImmutableReleaseRefSchema,
-  target: z10.discriminatedUnion("kind", [
-    z10.object({ kind: z10.literal("profile") }).strict(),
-    z10.object({ kind: z10.literal("skill"), skillPath: SourcePathSchema }).strict(),
-    z10.object({ kind: z10.literal("agent_action"), actionId: z10.string().trim().min(1).max(240) }).strict()
-  ])
-}).strict();
-
-// ../harness/dist/profile-workflow-source.js
-import { parseDocument } from "yaml";
-import { z as z11 } from "zod";
-var PortablePathSchema = z11.string().min(1).max(2e3).refine((value) => !value.includes("\\") && !value.includes(":") && !value.startsWith("/") && value.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "source paths must be portable relative paths");
-var WorkflowIdSchema2 = z11.string().regex(/^[a-z][a-z0-9_-]{0,119}$/);
-var EmptyInputSchema = { type: "object", properties: {}, additionalProperties: false };
-var ProfileWorkflowPromptMetadataSchema = z11.object({
-  name: z11.string().trim().min(1).max(240).optional(),
-  description: z11.string().max(4e3).optional(),
-  skillPaths: z11.array(PortablePathSchema).max(100).optional(),
-  assetPaths: z11.array(PortablePathSchema).max(100).optional()
-}).strict();
-var ProfileWorkflowActionSourceSchema = z11.object({
-  actionId: z11.string().trim().min(1).max(240),
-  name: z11.string().trim().min(1).max(240),
-  description: z11.string().max(4e3).default(""),
-  inputSchema: z11.record(z11.string(), z11.unknown()).default(EmptyInputSchema),
-  skillPaths: z11.array(PortablePathSchema).max(100).default([]),
-  assetPaths: z11.array(PortablePathSchema).max(100).default([])
-}).strict();
-
-export {
-  ToolDeclarationSchema,
-  CapabilityRequirementSchema,
-  createAgentSnapshot,
-  createHarnessRelease,
-  ChatModelRefSchema,
-  HarnessPolicySourcePackageSchema,
-  HarnessSourceSelectionSchema,
-  validateHarnessPolicySourcePackage,
-  validateHarnessSourcePackage
-};
-//# sourceMappingURL=chunk-4NZW4LFB.js.map