openpond-sdk 0.5.6 → 0.5.8

package/dist/{chunk-EV4PKJWN.js → chunk-UKVK7MRJ.js}

@@ -9,10 +9,18 @@ import {
   ReleaseHashSchema,
   ReleaseIdSchema,
   ReleaseTimestampSchema,
-  contentHash
-} from "./chunk-NF63YMOL.js";
+  assertContentHash,
+  contentHash,
+  sha256
+} from "./chunk-QUOW6URQ.js";
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/tools.js
+// ../harness/dist/source-package.js
+import { z as z3 } from "zod";
+
+// ../harness/dist/harness.js
+import { z as z2 } from "zod";
+
+// ../harness/dist/tools.js
 import { z } from "zod";
 var ToolDeclarationSchema = z.object({
   name: z.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
@@ -29,41 +37,186 @@ var CapabilityRequirementSchema = z.object({
   portability: z.enum(["portable", "host_adapter", "local_only", "hosted_only"])
 }).strict();
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/models.js
-import { z as z2 } from "zod";
-var ModelRefSchema = z2.object({
-  provider: ReleaseIdSchema,
-  model: ReleaseIdSchema,
-  revision: z2.string().trim().min(1).max(500).nullable().default(null),
-  artifactHash: ReleaseHashSchema.nullable().default(null),
-  tokenizerRevision: z2.string().trim().min(1).max(500).nullable().default(null),
-  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
+// ../harness/dist/harness.js
+var PortabilityReportSchema = z2.object({
+  portable: z2.boolean(),
+  blockers: z2.array(z2.string().trim().min(1).max(2e3)).max(1e3),
+  localOnlyAssetRefs: z2.array(ReleaseIdSchema).max(1e4),
+  hostPrivateAssetRefs: z2.array(ReleaseIdSchema).max(1e4)
 }).strict();
-var PROVIDER_IDS = [
-  "openpond",
-  "codex",
-  "anthropic",
-  "openai",
-  "xai",
-  "google",
-  "openrouter",
-  "deepseek",
-  "zai",
-  "moonshot",
-  "together",
-  "groq",
-  "custom-openai-compatible"
-];
-var ProviderIdSchema = z2.enum(PROVIDER_IDS);
-var ChatModelRefSchema = z2.object({
-  providerId: ProviderIdSchema,
-  modelId: z2.string().trim().min(1).max(300)
+var AgentSnapshotContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.agentSnapshot.v2"),
+  id: ReleaseIdSchema,
+  sourceRelease: ImmutableReleaseRefSchema.nullable(),
+  instructions: z2.array(ImmutableAssetRefSchema).max(1e4),
+  skills: z2.array(ImmutableAssetRefSchema).max(1e4),
+  agents: z2.array(ImmutableAssetRefSchema).max(1e4),
+  toolDeclarations: z2.array(ToolDeclarationSchema).max(200),
+  capabilityRequirements: z2.array(CapabilityRequirementSchema).max(200),
+  dependencyLock: ImmutableAssetRefSchema,
+  portability: PortabilityReportSchema,
+  metadata: MetadataSchema
+}).strict();
+var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var LifecycleContractSchema = z2.object({
+  create: z2.literal(true),
+  reset: z2.literal(true),
+  step: z2.literal(true),
+  collect: z2.literal(true),
+  destroy: z2.literal(true),
+  resetScope: z2.enum(["task", "attempt"])
+}).strict();
+var GraderInterfaceContractSchema = z2.object({
+  visibleEvidence: z2.array(ReleaseIdSchema).max(1e3),
+  privilegedEvidence: z2.array(ReleaseIdSchema).max(1e3),
+  privateVerifierIsolation: z2.boolean()
+}).strict();
+var HarnessReleaseContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessRelease.v2"),
+  id: ReleaseIdSchema,
+  agentSnapshot: ImmutableReleaseRefSchema,
+  program: ImmutableAssetRefSchema,
+  tools: z2.array(ToolDeclarationSchema).max(200),
+  lifecycle: LifecycleContractSchema,
+  graderInterface: GraderInterfaceContractSchema,
+  files: z2.array(ImmutableAssetRefSchema).max(1e5),
+  metadata: MetadataSchema
+}).strict();
+var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var ModelActionSchema = z2.object({
+  id: ReleaseIdSchema,
+  turn: z2.number().int().nonnegative(),
+  kind: z2.enum(["message", "tool_call", "terminal"]),
+  name: ReleaseIdSchema.nullable(),
+  arguments: z2.record(z2.string(), z2.unknown()),
+  content: z2.string().max(1e6).nullable()
+}).strict();
+var ToolObservationSchema = z2.object({
+  actionId: ReleaseIdSchema,
+  turn: z2.number().int().nonnegative(),
+  terminal: z2.boolean(),
+  output: z2.record(z2.string(), z2.unknown()),
+  artifactRefs: z2.array(ImmutableArtifactRefSchema).max(1e5)
+}).strict();
+var HarnessLifecycleEventSchema = z2.object({
+  sequence: z2.number().int().nonnegative(),
+  type: z2.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
+  payloadHash: ReleaseHashSchema,
+  metadata: MetadataSchema
+}).strict();
+var HarnessTraceSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessTrace.v1"),
+  manifest: ImmutableReleaseRefSchema,
+  taskId: ReleaseIdSchema,
+  seed: z2.string().trim().min(1).max(500),
+  events: z2.array(HarnessLifecycleEventSchema).max(1e6),
+  actions: z2.array(ModelActionSchema).max(1e5),
+  observations: z2.array(ToolObservationSchema).max(1e5),
+  terminal: z2.boolean(),
+  failureClass: FailureClassSchema.nullable(),
+  output: z2.record(z2.string(), z2.unknown()),
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/source-package.js
+var MAX_HARNESS_SOURCE_PACKAGE_BYTES = 25 * 1024 * 1024;
+var HarnessSourceFileSchema = z3.object({
+  path: ImmutableAssetRefSchema.shape.path,
+  base64: z3.string().max(Math.ceil(MAX_HARNESS_SOURCE_PACKAGE_BYTES / 3) * 4)
+}).strict();
+var HarnessSourcePackageContentSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessSourcePackage.v1"),
+  agentSnapshot: AgentSnapshotSchema,
+  harnessRelease: HarnessReleaseSchema,
+  files: z3.array(HarnessSourceFileSchema).max(1e4)
+}).strict();
+var HarnessSourcePackageSchema = HarnessSourcePackageContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessSourceSelectionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessSourceSelection.v1"),
+  mode: z3.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 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));
+}
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/evaluation-review.js
-import { z as z3 } from "zod";
-var BoundedTextSchema = z3.string().trim().min(1).max(1e5);
-var HarnessEvaluationReviewClassificationSchema = z3.enum([
+// ../harness/dist/evaluation-review.js
+import { z as z4 } from "zod";
+var BoundedTextSchema = z4.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = z4.enum([
   "no_action",
   "harness_maintenance",
   "runtime",
@@ -71,7 +224,7 @@ var HarnessEvaluationReviewClassificationSchema = z3.enum([
   "taskset",
   "model_improvement"
 ]);
-var HarnessEvaluationReviewAuthoritySchema = z3.enum([
+var HarnessEvaluationReviewAuthoritySchema = z4.enum([
   "none",
   "runtime_service",
   "product_team",
@@ -79,7 +232,7 @@ var HarnessEvaluationReviewAuthoritySchema = z3.enum([
   "evaluation_system",
   "training_system"
 ]);
-var HarnessReviewEvidenceKindSchema = z3.enum([
+var HarnessReviewEvidenceKindSchema = z4.enum([
   "observation",
   "trigger",
   "route_decision",
@@ -95,16 +248,16 @@ var HarnessReviewEvidenceKindSchema = z3.enum([
   "training_qualification",
   "model_candidate"
 ]);
-var HarnessReviewOwnerScopeSchema = z3.object({
-  kind: z3.enum(["personal", "team"]),
+var HarnessReviewOwnerScopeSchema = z4.object({
+  kind: z4.enum(["personal", "team"]),
   id: ReleaseIdSchema
 }).strict();
-var HarnessReviewSourcePolicyRefSchema = z3.object({
+var HarnessReviewSourcePolicyRefSchema = z4.object({
   policy: ImmutableReleaseRefSchema,
-  state: z3.enum(["authorized", "revoked", "deleted", "expired"]),
+  state: z4.enum(["authorized", "revoked", "deleted", "expired"]),
   checkedAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewEvidenceRefSchema = z3.object({
+var HarnessReviewEvidenceRefSchema = z4.object({
   evidence: ImmutableReleaseRefSchema,
   kind: HarnessReviewEvidenceKindSchema,
   sourceRef: ReleaseIdSchema,
@@ -112,10 +265,10 @@ var HarnessReviewEvidenceRefSchema = z3.object({
   occurrenceKey: ReleaseHashSchema,
   occurredAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewExcludedEvidenceSchema = z3.object({
+var HarnessReviewExcludedEvidenceSchema = z4.object({
   evidence: ImmutableReleaseRefSchema,
   sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
-  reason: z3.enum([
+  reason: z4.enum([
     "outside_scope",
     "before_watermark",
     "duplicate",
@@ -128,19 +281,19 @@ var HarnessReviewExcludedEvidenceSchema = z3.object({
     "budget"
   ])
 }).strict();
-var HarnessReviewWatermarkSchema = z3.object({
+var HarnessReviewWatermarkSchema = z4.object({
   cursor: ReleaseHashSchema,
   throughCreatedAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewClaimSchema = z3.object({
+var HarnessReviewClaimSchema = z4.object({
   fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z3.string().trim().min(1).max(1e3),
+  recurrenceFamily: z4.string().trim().min(1).max(1e3),
   statement: BoundedTextSchema,
-  candidateDisposition: z3.enum(["observe", "confirm"]).optional(),
-  independentOccurrences: z3.number().int().positive().max(1e6),
-  unresolvedOccurrences: z3.number().int().positive().max(1e6)
+  candidateDisposition: z4.enum(["observe", "confirm"]).optional(),
+  independentOccurrences: z4.number().int().positive().max(1e6),
+  unresolvedOccurrences: z4.number().int().positive().max(1e6)
 }).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
-var HarnessReviewTriageLayerSchema = z3.enum([
+var HarnessReviewTriageLayerSchema = z4.enum([
   "harness",
   "runtime",
   "product",
@@ -149,28 +302,28 @@ var HarnessReviewTriageLayerSchema = z3.enum([
   "evaluation",
   "model"
 ]);
-var HarnessReviewTriageDecisionSchema = z3.object({
+var HarnessReviewTriageDecisionSchema = z4.object({
   layer: HarnessReviewTriageLayerSchema,
-  status: z3.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  status: z4.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
   reason: BoundedTextSchema,
-  evidenceRefs: z3.array(ImmutableReleaseRefSchema).max(1e3)
+  evidenceRefs: z4.array(ImmutableReleaseRefSchema).max(1e3)
 }).strict();
-var HarnessEvaluationReviewReceiptContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+var HarnessEvaluationReviewReceiptContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessEvaluationReviewReceipt.v1"),
   id: ReleaseIdSchema,
   ownerScope: HarnessReviewOwnerScopeSchema,
   workspaceRef: ReleaseIdSchema,
   harnessRelease: ImmutableReleaseRefSchema,
   previousWatermark: HarnessReviewWatermarkSchema.nullable(),
   nextWatermark: HarnessReviewWatermarkSchema,
-  selectedEvidence: z3.array(HarnessReviewEvidenceRefSchema).max(1e4),
-  excludedEvidence: z3.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  selectedEvidence: z4.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: z4.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
   claim: HarnessReviewClaimSchema.nullable(),
   classification: HarnessEvaluationReviewClassificationSchema,
-  triage: z3.array(HarnessReviewTriageDecisionSchema).max(16),
+  triage: z4.array(HarnessReviewTriageDecisionSchema).max(16),
   reason: BoundedTextSchema,
   nextAuthority: HarnessEvaluationReviewAuthoritySchema,
-  maxEstimatedCostUsd: z3.number().finite().nonnegative(),
+  maxEstimatedCostUsd: z4.number().finite().nonnegative(),
   tasksetProposal: ImmutableReleaseRefSchema.nullable(),
   evaluation: ImmutableReleaseRefSchema.nullable(),
   trainingQualification: ImmutableReleaseRefSchema.nullable(),
@@ -243,44 +396,44 @@ var HarnessEvaluationReviewReceiptContentSchema = z3.object({
 var HarnessEvaluationReviewReceiptSchema = HarnessEvaluationReviewReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessEvaluationReviewModelEvidenceSchema = z3.object({
+var HarnessEvaluationReviewModelEvidenceSchema = z4.object({
   id: ReleaseIdSchema,
   evidence: ImmutableReleaseRefSchema,
   kind: HarnessReviewEvidenceKindSchema,
   sourceRef: ReleaseIdSchema,
   occurredAt: ReleaseTimestampSchema,
-  payload: z3.record(z3.string(), z3.unknown())
+  payload: z4.record(z4.string(), z4.unknown())
 }).strict();
-var HarnessEvaluationReviewModelNoActionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z3.literal("no_action"),
+var HarnessEvaluationReviewModelNoActionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z4.literal("no_action"),
   reason: BoundedTextSchema,
-  ignoredEvidence: z3.array(z3.object({
+  ignoredEvidence: z4.array(z4.object({
     id: ReleaseIdSchema,
-    reason: z3.string().trim().min(1).max(2e3)
+    reason: z4.string().trim().min(1).max(2e3)
   }).strict()).max(1e3)
 }).strict();
-var HarnessEvaluationReviewModelActionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z3.literal("review"),
-  classification: z3.enum([
+var HarnessEvaluationReviewModelActionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z4.literal("review"),
+  classification: z4.enum([
     "harness_maintenance",
     "runtime",
     "product",
     "taskset"
   ]),
-  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z3.array(z3.object({
+  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z4.array(z4.object({
     id: ReleaseIdSchema,
-    reason: z3.string().trim().min(1).max(2e3)
+    reason: z4.string().trim().min(1).max(2e3)
   }).strict()).max(1e3),
-  recurrenceFamily: z3.string().trim().min(1).max(1e3),
+  recurrenceFamily: z4.string().trim().min(1).max(1e3),
   statement: BoundedTextSchema,
   triageLayer: HarnessReviewTriageLayerSchema,
   expectedOutcome: BoundedTextSchema,
-  counterevidence: z3.string().trim().max(1e4),
-  confidence: z3.number().min(0).max(1),
-  candidateDisposition: z3.enum(["observe", "confirm"]).nullable(),
+  counterevidence: z4.string().trim().max(1e4),
+  confidence: z4.number().min(0).max(1),
+  candidateDisposition: z4.enum(["observe", "confirm"]).nullable(),
   reason: BoundedTextSchema
 }).strict().superRefine((decision, context) => {
   const requiresDisposition = decision.classification === "harness_maintenance";
@@ -292,116 +445,34 @@ var HarnessEvaluationReviewModelActionSchema = z3.object({
     });
   }
 });
-var HarnessEvaluationReviewModelResolutionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z3.literal("resolve_candidate"),
+var HarnessEvaluationReviewModelResolutionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z4.literal("resolve_candidate"),
   candidateId: ReleaseIdSchema,
   candidateFingerprint: ReleaseHashSchema,
-  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z3.array(z3.object({
+  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z4.array(z4.object({
     id: ReleaseIdSchema,
-    reason: z3.string().trim().min(1).max(2e3)
+    reason: z4.string().trim().min(1).max(2e3)
   }).strict()).max(1e3),
-  confidence: z3.number().min(0).max(1),
+  confidence: z4.number().min(0).max(1),
   reason: BoundedTextSchema
 }).strict();
-var HarnessEvaluationReviewModelDecisionSchema = z3.discriminatedUnion("decision", [
+var HarnessEvaluationReviewModelDecisionSchema = z4.discriminatedUnion("decision", [
   HarnessEvaluationReviewModelNoActionSchema,
   HarnessEvaluationReviewModelActionSchema,
   HarnessEvaluationReviewModelResolutionSchema
 ]);
-var HarnessEvaluationReviewNavigationDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
-  selectedEvidenceIds: z3.array(ReleaseIdSchema).min(1).max(50),
+var HarnessEvaluationReviewNavigationDecisionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
+  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(50),
   reason: BoundedTextSchema
 }).strict();
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/harness.js
-import { z as z4 } from "zod";
-var PortabilityReportSchema = z4.object({
-  portable: z4.boolean(),
-  blockers: z4.array(z4.string().trim().min(1).max(2e3)).max(1e3),
-  localOnlyAssetRefs: z4.array(ReleaseIdSchema).max(1e4),
-  hostPrivateAssetRefs: z4.array(ReleaseIdSchema).max(1e4)
-}).strict();
-var AgentSnapshotContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.agentSnapshot.v2"),
-  id: ReleaseIdSchema,
-  sourceRelease: ImmutableReleaseRefSchema.nullable(),
-  instructions: z4.array(ImmutableAssetRefSchema).max(1e4),
-  skills: z4.array(ImmutableAssetRefSchema).max(1e4),
-  agents: z4.array(ImmutableAssetRefSchema).max(1e4),
-  toolDeclarations: z4.array(ToolDeclarationSchema).max(200),
-  capabilityRequirements: z4.array(CapabilityRequirementSchema).max(200),
-  dependencyLock: ImmutableAssetRefSchema,
-  portability: PortabilityReportSchema,
-  metadata: MetadataSchema
-}).strict();
-var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var LifecycleContractSchema = z4.object({
-  create: z4.literal(true),
-  reset: z4.literal(true),
-  step: z4.literal(true),
-  collect: z4.literal(true),
-  destroy: z4.literal(true),
-  resetScope: z4.enum(["task", "attempt"])
-}).strict();
-var GraderInterfaceContractSchema = z4.object({
-  visibleEvidence: z4.array(ReleaseIdSchema).max(1e3),
-  privilegedEvidence: z4.array(ReleaseIdSchema).max(1e3),
-  privateVerifierIsolation: z4.boolean()
-}).strict();
-var HarnessReleaseContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessRelease.v2"),
-  id: ReleaseIdSchema,
-  agentSnapshot: ImmutableReleaseRefSchema,
-  program: ImmutableAssetRefSchema,
-  tools: z4.array(ToolDeclarationSchema).max(200),
-  lifecycle: LifecycleContractSchema,
-  graderInterface: GraderInterfaceContractSchema,
-  files: z4.array(ImmutableAssetRefSchema).max(1e5),
-  metadata: MetadataSchema
-}).strict();
-var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var ModelActionSchema = z4.object({
-  id: ReleaseIdSchema,
-  turn: z4.number().int().nonnegative(),
-  kind: z4.enum(["message", "tool_call", "terminal"]),
-  name: ReleaseIdSchema.nullable(),
-  arguments: z4.record(z4.string(), z4.unknown()),
-  content: z4.string().max(1e6).nullable()
-}).strict();
-var ToolObservationSchema = z4.object({
-  actionId: ReleaseIdSchema,
-  turn: z4.number().int().nonnegative(),
-  terminal: z4.boolean(),
-  output: z4.record(z4.string(), z4.unknown()),
-  artifactRefs: z4.array(ImmutableArtifactRefSchema).max(1e5)
-}).strict();
-var HarnessLifecycleEventSchema = z4.object({
-  sequence: z4.number().int().nonnegative(),
-  type: z4.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
-  payloadHash: ReleaseHashSchema,
-  metadata: MetadataSchema
-}).strict();
-var HarnessTraceSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessTrace.v1"),
-  manifest: ImmutableReleaseRefSchema,
-  taskId: ReleaseIdSchema,
-  seed: z4.string().trim().min(1).max(500),
-  events: z4.array(HarnessLifecycleEventSchema).max(1e6),
-  actions: z4.array(ModelActionSchema).max(1e5),
-  observations: z4.array(ToolObservationSchema).max(1e5),
-  terminal: z4.boolean(),
-  failureClass: FailureClassSchema.nullable(),
-  output: z4.record(z4.string(), z4.unknown()),
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/harness-improvements.js
+// ../harness/dist/harness-improvements.js
 import { z as z6 } from "zod";
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/harness-workspaces.js
+// ../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();
@@ -705,7 +776,7 @@ var HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.e
   contentHash: ReleaseHashSchema
 }).strict();
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/harness-improvements.js
+// ../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([
@@ -963,53 +1034,84 @@ var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend(
   contentHash: ReleaseHashSchema
 }).strict();
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.6/node_modules/@openpond/harness/dist/refinement-lifecycle.js
+// ../harness/dist/models.js
 import { z as z7 } from "zod";
-var ShortTextSchema = z7.string().trim().min(1).max(2e3);
-var BoundedTextSchema4 = z7.string().trim().min(1).max(1e5);
-var HarnessRefinerOperationSchema = z7.enum(["create", "update", "delete"]);
-var HarnessRefinerInternalRouteSchema = z7.enum([
+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();
+var PROVIDER_IDS = [
+  "openpond",
+  "codex",
+  "anthropic",
+  "openai",
+  "xai",
+  "google",
+  "openrouter",
+  "deepseek",
+  "zai",
+  "moonshot",
+  "together",
+  "groq",
+  "custom-openai-compatible"
+];
+var ProviderIdSchema = z7.enum(PROVIDER_IDS);
+var ChatModelRefSchema = z7.object({
+  providerId: ProviderIdSchema,
+  modelId: z7.string().trim().min(1).max(300)
+});
+
+// ../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 = z7.enum([
+var HarnessRefinerExternalRouteSchema = z8.enum([
   "runtime",
   "product",
   "taskset",
   "training"
 ]);
-var HarnessRefinerActivityResultSchema = z7.enum([
+var HarnessRefinerActivityResultSchema = z8.enum([
   "no_action",
   "routed",
   "applied",
   "retained",
   "failed"
 ]);
-var HarnessRefinerCritiqueStatusSchema = z7.enum([
+var HarnessRefinerCritiqueStatusSchema = z8.enum([
   "not_applicable",
   "pending",
   "passed",
   "rejected",
   "failed"
 ]);
-var HarnessRefinerValidationStatusSchema = z7.enum([
+var HarnessRefinerValidationStatusSchema = z8.enum([
   "not_applicable",
   "pending",
   "passed",
   "failed"
 ]);
-var HarnessRefinerActivityReceiptContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.harnessRefinerActivityReceipt.v1"),
+var HarnessRefinerActivityReceiptContentSchema = z8.object({
+  schemaVersion: z8.literal("openpond.harnessRefinerActivityReceipt.v1"),
   id: ReleaseIdSchema,
   runRef: ReleaseIdSchema,
   turnId: ReleaseIdSchema,
   result: HarnessRefinerActivityResultSchema,
-  decision: z7.enum(["no_action", "route", "propose"]).nullable(),
+  decision: z8.enum(["no_action", "route", "propose"]).nullable(),
   route: HarnessImprovementRouteSchema.nullable(),
   operation: HarnessRefinerOperationSchema.nullable(),
-  target: z7.string().trim().min(1).max(2e3).nullable(),
+  target: z8.string().trim().min(1).max(2e3).nullable(),
   summary: ShortTextSchema,
   evidenceBasis: HarnessRefinerEvidenceBasisSchema.nullable(),
   critiqueStatus: HarnessRefinerCritiqueStatusSchema,
@@ -1091,15 +1193,15 @@ var HarnessRefinerActivityReceiptContentSchema = z7.object({
 var HarnessRefinerActivityReceiptSchema = HarnessRefinerActivityReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessRefinementCandidateStatusSchema = z7.enum([
+var HarnessRefinementCandidateStatusSchema = z8.enum([
   "unresolved",
   "confirmed",
   "resolved",
   "rejected",
   "expired"
 ]);
-var HarnessRefinementCandidateResolutionSchema = z7.object({
-  kind: z7.enum([
+var HarnessRefinementCandidateResolutionSchema = z8.object({
+  kind: z8.enum([
     "applied_change",
     "later_success",
     "manual_rejection",
@@ -1107,22 +1209,22 @@ var HarnessRefinementCandidateResolutionSchema = z7.object({
     "expired"
   ]),
   reason: BoundedTextSchema4,
-  evidenceRefs: z7.array(ImmutableReleaseRefSchema).max(1e3),
+  evidenceRefs: z8.array(ImmutableReleaseRefSchema).max(1e3),
   resolvedAt: ReleaseTimestampSchema
 }).strict();
-var HarnessRefinementCandidateContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.harnessRefinementCandidate.v1"),
+var HarnessRefinementCandidateContentSchema = z8.object({
+  schemaVersion: z8.literal("openpond.harnessRefinementCandidate.v1"),
   id: ReleaseIdSchema,
   ownerScope: HarnessReviewOwnerScopeSchema,
   workspaceRef: ReleaseIdSchema,
   fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z7.string().trim().min(1).max(1e3),
+  recurrenceFamily: z8.string().trim().min(1).max(1e3),
   statement: BoundedTextSchema4,
   status: HarnessRefinementCandidateStatusSchema,
-  occurrences: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  counterevidence: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  sourceReviews: z7.array(ImmutableReleaseRefSchema).min(1).max(100),
-  relatedHarnessReleases: z7.array(ImmutableReleaseRefSchema).max(100),
+  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,
@@ -1191,7 +1293,7 @@ var HarnessRefinementCandidateContentSchema = z7.object({
 var HarnessRefinementCandidateSchema = HarnessRefinementCandidateContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessRefinementCandidateLifecycleDecisionSchema = z7.enum([
+var HarnessRefinementCandidateLifecycleDecisionSchema = z8.enum([
   "created",
   "merged",
   "rejected",
@@ -1199,16 +1301,16 @@ var HarnessRefinementCandidateLifecycleDecisionSchema = z7.enum([
   "reopened",
   "resolved"
 ]);
-var HarnessRefinementCandidateLifecycleReceiptContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
+var HarnessRefinementCandidateLifecycleReceiptContentSchema = z8.object({
+  schemaVersion: z8.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
   id: ReleaseIdSchema,
   candidateId: ReleaseIdSchema,
   decision: HarnessRefinementCandidateLifecycleDecisionSchema,
   beforeCandidate: ImmutableReleaseRefSchema.nullable(),
   afterCandidate: ImmutableReleaseRefSchema,
   review: ImmutableReleaseRefSchema,
-  addedEvidence: z7.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  removedEvidence: z7.array(ImmutableReleaseRefSchema).max(1e3),
+  addedEvidence: z8.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  removedEvidence: z8.array(ImmutableReleaseRefSchema).max(1e3),
   reason: BoundedTextSchema4,
   createdAt: ReleaseTimestampSchema
 }).strict().superRefine((receipt, context) => {
@@ -1254,8 +1356,8 @@ var HarnessRefinementCandidateLifecycleReceiptContentSchema = z7.object({
 var HarnessRefinementCandidateLifecycleReceiptSchema = HarnessRefinementCandidateLifecycleReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessCrossRunRefinementRequestContentSchema = z7.object({
-  schemaVersion: z7.literal("openpond.harnessCrossRunRefinementRequest.v1"),
+var HarnessCrossRunRefinementRequestContentSchema = z8.object({
+  schemaVersion: z8.literal("openpond.harnessCrossRunRefinementRequest.v1"),
   id: ReleaseIdSchema,
   ownerScope: HarnessReviewOwnerScopeSchema,
   workspaceRef: ReleaseIdSchema,
@@ -1263,7 +1365,7 @@ var HarnessCrossRunRefinementRequestContentSchema = z7.object({
   candidateFingerprint: ReleaseHashSchema,
   review: ImmutableReleaseRefSchema,
   admittedHarness: ImmutableReleaseRefSchema,
-  evidence: z7.array(HarnessReviewEvidenceRefSchema).min(1).max(1e3),
+  evidence: z8.array(HarnessReviewEvidenceRefSchema).min(1).max(1e3),
   capabilities: HarnessRefinerCapabilitiesSchema,
   deduplicationKey: ReleaseHashSchema,
   createdAt: ReleaseTimestampSchema
@@ -1365,9 +1467,19 @@ function requireChronology(context, candidate) {
   }
 }
 
+// ../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();
+
 export {
   ToolDeclarationSchema,
   CapabilityRequirementSchema,
-  ChatModelRefSchema
+  ChatModelRefSchema,
+  HarnessSourceSelectionSchema,
+  validateHarnessSourcePackage
 };
-//# sourceMappingURL=chunk-EV4PKJWN.js.map
+//# sourceMappingURL=chunk-UKVK7MRJ.js.map