openpond-sdk 0.10.0 → 0.11.2

package/dist/{chunk-Y4NGWGTA.js → chunk-4NZW4LFB.js}

@@ -14,89 +14,123 @@ import {
   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 z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../harness/dist/harness.js
-import { z as z2 } from "zod";
+import { z as z3 } 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_-]*$/),
-  description: z.string().trim().min(1).max(2e3),
-  inputSchema: z.record(z.string(), z.unknown()),
+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: z.enum(["read", "write"]),
-  timeoutMs: z.number().int().positive().max(36e5)
+  sideEffect: z2.enum(["read", "write"]),
+  timeoutMs: z2.number().int().positive().max(36e5)
 }).strict();
-var CapabilityRequirementSchema = z.object({
+var CapabilityRequirementSchema = z2.object({
   id: ReleaseIdSchema,
-  required: z.boolean(),
-  scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([]),
-  portability: z.enum(["portable", "host_adapter", "local_only", "hosted_only"])
+  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 = 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 AgentSnapshotContentSchema = z2.object({
-  schemaVersion: z2.literal("openpond.agentSnapshot.v2"),
+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: 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),
+  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 = 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"),
+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: z2.array(ToolDeclarationSchema).max(200),
+  tools: z3.array(ToolDeclarationSchema).max(200),
   lifecycle: LifecycleContractSchema,
   graderInterface: GraderInterfaceContractSchema,
-  files: z2.array(ImmutableAssetRefSchema).max(1e5),
+  files: z3.array(ImmutableAssetRefSchema).max(1e5),
   metadata: MetadataSchema
 }).strict();
 var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var ModelActionSchema = z2.object({
+var ModelActionSchema = z3.object({
   id: ReleaseIdSchema,
-  turn: z2.number().int().nonnegative(),
-  kind: z2.enum(["message", "tool_call", "terminal"]),
+  turn: z3.number().int().nonnegative(),
+  kind: z3.enum(["message", "tool_call", "terminal"]),
   name: ReleaseIdSchema.nullable(),
-  arguments: z2.record(z2.string(), z2.unknown()),
-  content: z2.string().max(1e6).nullable()
+  arguments: z3.record(z3.string(), z3.unknown()),
+  content: z3.string().max(1e6).nullable()
 }).strict();
-var ToolObservationSchema = z2.object({
+var ToolObservationSchema = z3.object({
   actionId: ReleaseIdSchema,
-  turn: z2.number().int().nonnegative(),
-  terminal: z2.boolean(),
-  output: z2.record(z2.string(), z2.unknown()),
-  artifactRefs: z2.array(ImmutableArtifactRefSchema).max(1e5)
+  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);
@@ -106,48 +140,48 @@ function createHarnessRelease(input) {
   const content = HarnessReleaseContentSchema.parse(input);
   return HarnessReleaseSchema.parse({ ...content, contentHash: contentHash(content) });
 }
-var HarnessLifecycleEventSchema = z2.object({
-  sequence: z2.number().int().nonnegative(),
-  type: z2.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
+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 = z2.object({
-  schemaVersion: z2.literal("openpond.harnessTrace.v1"),
+var HarnessTraceSchema = z3.object({
+  schemaVersion: z3.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(),
+  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: z2.record(z2.string(), z2.unknown()),
+  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 = z3.object({
+var HarnessSourceFileSchema = z4.object({
   path: ImmutableAssetRefSchema.shape.path,
-  base64: z3.string().max(Math.ceil(MAX_HARNESS_SOURCE_PACKAGE_BYTES / 3) * 4)
+  base64: z4.string().max(Math.ceil(MAX_HARNESS_SOURCE_PACKAGE_BYTES / 3) * 4)
 }).strict();
-var HarnessSourcePackageContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessSourcePackage.v1"),
+var HarnessSourcePackageContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessSourcePackage.v1"),
   agentSnapshot: AgentSnapshotSchema,
   harnessRelease: HarnessReleaseSchema,
-  files: z3.array(HarnessSourceFileSchema).max(1e4)
+  files: z4.array(HarnessSourceFileSchema).max(1e4)
 }).strict();
 var HarnessSourcePackageSchema = HarnessSourcePackageContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
 var HarnessPolicySourcePackageSchema = HarnessSourcePackageContentSchema.extend({
-  schemaVersion: z3.literal("openpond.harnessPolicySourcePackage.v1"),
+  schemaVersion: z4.literal("openpond.harnessPolicySourcePackage.v1"),
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessSourceSelectionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.harnessSourceSelection.v1"),
-  mode: z3.enum(["taskset_owned", "selected_release"]),
+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) => {
@@ -287,9 +321,9 @@ function decode(base64) {
 }
 
 // ../harness/dist/evaluation-review.js
-import { z as z4 } from "zod";
-var BoundedTextSchema = z4.string().trim().min(1).max(1e5);
-var HarnessEvaluationReviewClassificationSchema = z4.enum([
+import { z as z5 } from "zod";
+var BoundedTextSchema = z5.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = z5.enum([
   "no_action",
   "harness_maintenance",
   "runtime",
@@ -297,7 +331,7 @@ var HarnessEvaluationReviewClassificationSchema = z4.enum([
   "taskset",
   "model_improvement"
 ]);
-var HarnessEvaluationReviewAuthoritySchema = z4.enum([
+var HarnessEvaluationReviewAuthoritySchema = z5.enum([
   "none",
   "runtime_service",
   "product_team",
@@ -305,7 +339,7 @@ var HarnessEvaluationReviewAuthoritySchema = z4.enum([
   "evaluation_system",
   "training_system"
 ]);
-var HarnessReviewEvidenceKindSchema = z4.enum([
+var HarnessReviewEvidenceKindSchema = z5.enum([
   "observation",
   "trigger",
   "route_decision",
@@ -321,16 +355,16 @@ var HarnessReviewEvidenceKindSchema = z4.enum([
   "training_qualification",
   "model_candidate"
 ]);
-var HarnessReviewOwnerScopeSchema = z4.object({
-  kind: z4.enum(["personal", "team"]),
+var HarnessReviewOwnerScopeSchema = z5.object({
+  kind: z5.enum(["personal", "team"]),
   id: ReleaseIdSchema
 }).strict();
-var HarnessReviewSourcePolicyRefSchema = z4.object({
+var HarnessReviewSourcePolicyRefSchema = z5.object({
   policy: ImmutableReleaseRefSchema,
-  state: z4.enum(["authorized", "revoked", "deleted", "expired"]),
+  state: z5.enum(["authorized", "revoked", "deleted", "expired"]),
   checkedAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewEvidenceRefSchema = z4.object({
+var HarnessReviewEvidenceRefSchema = z5.object({
   evidence: ImmutableReleaseRefSchema,
   kind: HarnessReviewEvidenceKindSchema,
   sourceRef: ReleaseIdSchema,
@@ -338,10 +372,10 @@ var HarnessReviewEvidenceRefSchema = z4.object({
   occurrenceKey: ReleaseHashSchema,
   occurredAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewExcludedEvidenceSchema = z4.object({
+var HarnessReviewExcludedEvidenceSchema = z5.object({
   evidence: ImmutableReleaseRefSchema,
   sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
-  reason: z4.enum([
+  reason: z5.enum([
     "outside_scope",
     "before_watermark",
     "duplicate",
@@ -354,19 +388,19 @@ var HarnessReviewExcludedEvidenceSchema = z4.object({
     "budget"
   ])
 }).strict();
-var HarnessReviewWatermarkSchema = z4.object({
+var HarnessReviewWatermarkSchema = z5.object({
   cursor: ReleaseHashSchema,
   throughCreatedAt: ReleaseTimestampSchema
 }).strict();
-var HarnessReviewClaimSchema = z4.object({
+var HarnessReviewClaimSchema = z5.object({
   fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z4.string().trim().min(1).max(1e3),
+  recurrenceFamily: z5.string().trim().min(1).max(1e3),
   statement: BoundedTextSchema,
-  candidateDisposition: z4.enum(["observe", "confirm"]).optional(),
-  independentOccurrences: z4.number().int().positive().max(1e6),
-  unresolvedOccurrences: z4.number().int().positive().max(1e6)
+  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 = z4.enum([
+var HarnessReviewTriageLayerSchema = z5.enum([
   "harness",
   "runtime",
   "product",
@@ -375,28 +409,28 @@ var HarnessReviewTriageLayerSchema = z4.enum([
   "evaluation",
   "model"
 ]);
-var HarnessReviewTriageDecisionSchema = z4.object({
+var HarnessReviewTriageDecisionSchema = z5.object({
   layer: HarnessReviewTriageLayerSchema,
-  status: z4.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  status: z5.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
   reason: BoundedTextSchema,
-  evidenceRefs: z4.array(ImmutableReleaseRefSchema).max(1e3)
+  evidenceRefs: z5.array(ImmutableReleaseRefSchema).max(1e3)
 }).strict();
-var HarnessEvaluationReviewReceiptContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+var HarnessEvaluationReviewReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessEvaluationReviewReceipt.v1"),
   id: ReleaseIdSchema,
   ownerScope: HarnessReviewOwnerScopeSchema,
   workspaceRef: ReleaseIdSchema,
   harnessRelease: ImmutableReleaseRefSchema,
   previousWatermark: HarnessReviewWatermarkSchema.nullable(),
   nextWatermark: HarnessReviewWatermarkSchema,
-  selectedEvidence: z4.array(HarnessReviewEvidenceRefSchema).max(1e4),
-  excludedEvidence: z4.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  selectedEvidence: z5.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: z5.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
   claim: HarnessReviewClaimSchema.nullable(),
   classification: HarnessEvaluationReviewClassificationSchema,
-  triage: z4.array(HarnessReviewTriageDecisionSchema).max(16),
+  triage: z5.array(HarnessReviewTriageDecisionSchema).max(16),
   reason: BoundedTextSchema,
   nextAuthority: HarnessEvaluationReviewAuthoritySchema,
-  maxEstimatedCostUsd: z4.number().finite().nonnegative(),
+  maxEstimatedCostUsd: z5.number().finite().nonnegative(),
   tasksetProposal: ImmutableReleaseRefSchema.nullable(),
   evaluation: ImmutableReleaseRefSchema.nullable(),
   trainingQualification: ImmutableReleaseRefSchema.nullable(),
@@ -469,44 +503,44 @@ var HarnessEvaluationReviewReceiptContentSchema = z4.object({
 var HarnessEvaluationReviewReceiptSchema = HarnessEvaluationReviewReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessEvaluationReviewModelEvidenceSchema = z4.object({
+var HarnessEvaluationReviewModelEvidenceSchema = z5.object({
   id: ReleaseIdSchema,
   evidence: ImmutableReleaseRefSchema,
   kind: HarnessReviewEvidenceKindSchema,
   sourceRef: ReleaseIdSchema,
   occurredAt: ReleaseTimestampSchema,
-  payload: z4.record(z4.string(), z4.unknown())
+  payload: z5.record(z5.string(), z5.unknown())
 }).strict();
-var HarnessEvaluationReviewModelNoActionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z4.literal("no_action"),
+var HarnessEvaluationReviewModelNoActionSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z5.literal("no_action"),
   reason: BoundedTextSchema,
-  ignoredEvidence: z4.array(z4.object({
+  ignoredEvidence: z5.array(z5.object({
     id: ReleaseIdSchema,
-    reason: z4.string().trim().min(1).max(2e3)
+    reason: z5.string().trim().min(1).max(2e3)
   }).strict()).max(1e3)
 }).strict();
-var HarnessEvaluationReviewModelActionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z4.literal("review"),
-  classification: z4.enum([
+var HarnessEvaluationReviewModelActionSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z5.literal("review"),
+  classification: z5.enum([
     "harness_maintenance",
     "runtime",
     "product",
     "taskset"
   ]),
-  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z4.array(z4.object({
+  selectedEvidenceIds: z5.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z5.array(z5.object({
     id: ReleaseIdSchema,
-    reason: z4.string().trim().min(1).max(2e3)
+    reason: z5.string().trim().min(1).max(2e3)
   }).strict()).max(1e3),
-  recurrenceFamily: z4.string().trim().min(1).max(1e3),
+  recurrenceFamily: z5.string().trim().min(1).max(1e3),
   statement: BoundedTextSchema,
   triageLayer: HarnessReviewTriageLayerSchema,
   expectedOutcome: BoundedTextSchema,
-  counterevidence: z4.string().trim().max(1e4),
-  confidence: z4.number().min(0).max(1),
-  candidateDisposition: z4.enum(["observe", "confirm"]).nullable(),
+  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";
@@ -518,62 +552,62 @@ var HarnessEvaluationReviewModelActionSchema = z4.object({
     });
   }
 });
-var HarnessEvaluationReviewModelResolutionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z4.literal("resolve_candidate"),
+var HarnessEvaluationReviewModelResolutionSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z5.literal("resolve_candidate"),
   candidateId: ReleaseIdSchema,
   candidateFingerprint: ReleaseHashSchema,
-  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z4.array(z4.object({
+  selectedEvidenceIds: z5.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z5.array(z5.object({
     id: ReleaseIdSchema,
-    reason: z4.string().trim().min(1).max(2e3)
+    reason: z5.string().trim().min(1).max(2e3)
   }).strict()).max(1e3),
-  confidence: z4.number().min(0).max(1),
+  confidence: z5.number().min(0).max(1),
   reason: BoundedTextSchema
 }).strict();
-var HarnessEvaluationReviewModelDecisionSchema = z4.discriminatedUnion("decision", [
+var HarnessEvaluationReviewModelDecisionSchema = z5.discriminatedUnion("decision", [
   HarnessEvaluationReviewModelNoActionSchema,
   HarnessEvaluationReviewModelActionSchema,
   HarnessEvaluationReviewModelResolutionSchema
 ]);
-var HarnessEvaluationReviewNavigationDecisionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
-  selectedEvidenceIds: z4.array(ReleaseIdSchema).min(1).max(50),
+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 z6 } from "zod";
+import { z as z7 } from "zod";
 
 // ../harness/dist/harness-workspaces.js
-import { z as z5 } from "zod";
-var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
-var RevisionSchema = z5.number().int().nonnegative();
-var BoundedTextSchema2 = z5.string().trim().min(1).max(1e5);
-var HarnessOwnerScopeSchema = z5.object({
-  kind: z5.enum(["personal", "team"]),
+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 = z5.object({
+var HarnessCurrentChannelSchema = z6.object({
   name: ReleaseIdSchema,
   release: ImmutableReleaseRefSchema.nullable(),
   revision: RevisionSchema
 }).strict();
-var HarnessWorkspaceSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessWorkspace.v1"),
+var HarnessWorkspaceSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessWorkspace.v1"),
   id: ReleaseIdSchema,
   ownerScope: HarnessOwnerScopeSchema,
-  name: z5.string().trim().min(1).max(240),
-  location: z5.enum(["local", "hosted"]),
-  sourceRevision: z5.string().trim().min(1).max(500),
+  name: z6.string().trim().min(1).max(240),
+  location: z6.enum(["local", "hosted"]),
+  sourceRevision: z6.string().trim().min(1).max(500),
   revision: RevisionSchema,
-  dirty: z5.boolean(),
+  dirty: z6.boolean(),
   currentChannel: HarnessCurrentChannelSchema,
   createdAt: ReleaseTimestampSchema,
   updatedAt: ReleaseTimestampSchema,
   metadata: MetadataSchema2
 }).strict();
-var HarnessImprovementRouteSchema = z5.enum([
+var HarnessImprovementRouteSchema = z6.enum([
   "runtime",
   "memory",
   "prompt",
@@ -583,7 +617,7 @@ var HarnessImprovementRouteSchema = z5.enum([
   "taskset",
   "training"
 ]);
-var HarnessChangeEffectSchema = z5.enum([
+var HarnessChangeEffectSchema = z6.enum([
   "text_instruction",
   "memory",
   "dependency_selection",
@@ -598,15 +632,15 @@ var HarnessChangeEffectSchema = z5.enum([
   "model_binding",
   "team_or_global"
 ]);
-var HarnessOverlayEditSchema = z5.object({
+var HarnessOverlayEditSchema = z6.object({
   id: ReleaseIdSchema,
   route: HarnessImprovementRouteSchema,
-  operation: z5.enum(["create", "update", "delete"]),
-  target: z5.string().trim().min(1).max(2e3),
-  summary: z5.string().trim().min(1).max(2e3),
-  content: z5.string().max(1e6).nullable(),
+  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: z5.array(HarnessChangeEffectSchema).min(1).max(20)
+  effects: z6.array(HarnessChangeEffectSchema).min(1).max(20)
 }).strict().superRefine((edit, context) => {
   if (edit.operation === "delete") {
     if (edit.content !== null || edit.contentHash !== null) {
@@ -635,37 +669,37 @@ var HarnessOverlayEditSchema = z5.object({
     });
   }
 });
-var HarnessWorkspaceRevisionRefSchema = z5.object({
+var HarnessWorkspaceRevisionRefSchema = z6.object({
   workspaceId: ReleaseIdSchema,
   revision: RevisionSchema,
-  sourceRevision: z5.string().trim().min(1).max(500),
+  sourceRevision: z6.string().trim().min(1).max(500),
   channelRevision: RevisionSchema
 }).strict();
-var HarnessOverlaySnapshotRefSchema = z5.object({
+var HarnessOverlaySnapshotRefSchema = z6.object({
   id: ReleaseIdSchema,
   revision: RevisionSchema,
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessTurnSnapshotSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessTurnSnapshot.v1"),
+var HarnessTurnSnapshotSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessTurnSnapshot.v1"),
   workspaceId: ReleaseIdSchema,
   workspaceRevision: RevisionSchema,
-  sourceRevision: z5.string().trim().min(1).max(500),
+  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 = z5.object({
-  schemaVersion: z5.literal("openpond.harnessRunOverlay.v1"),
+var HarnessRunOverlayContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessRunOverlay.v1"),
   id: ReleaseIdSchema,
   runId: ReleaseIdSchema,
   baseHarnessRelease: ImmutableReleaseRefSchema,
   workspace: HarnessWorkspaceRevisionRefSchema,
   revision: RevisionSchema,
-  status: z5.enum(["active", "frozen", "abandoned"]),
-  edits: z5.array(HarnessOverlayEditSchema).max(1e3),
+  status: z6.enum(["active", "frozen", "abandoned"]),
+  edits: z6.array(HarnessOverlayEditSchema).max(1e3),
   createdAt: ReleaseTimestampSchema,
   updatedAt: ReleaseTimestampSchema,
   metadata: MetadataSchema2
@@ -673,8 +707,8 @@ var HarnessRunOverlayContentSchema = z5.object({
 var HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessProposalEvidenceRefSchema = z5.object({
-  kind: z5.enum([
+var HarnessProposalEvidenceRefSchema = z6.object({
+  kind: z6.enum([
     "tool_event",
     "recovery",
     "validation",
@@ -685,9 +719,9 @@ var HarnessProposalEvidenceRefSchema = z5.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema.nullable()
 }).strict();
-var HarnessValidationPlanItemSchema = z5.object({
+var HarnessValidationPlanItemSchema = z6.object({
   id: ReleaseIdSchema,
-  kind: z5.enum([
+  kind: z6.enum([
     "dependency",
     "schema",
     "package",
@@ -701,21 +735,21 @@ var HarnessValidationPlanItemSchema = z5.object({
     "component_activation"
   ]),
   description: BoundedTextSchema2,
-  required: z5.boolean()
+  required: z6.boolean()
 }).strict();
-var HarnessImprovementProposalContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessImprovementProposal.v1"),
+var HarnessImprovementProposalContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessImprovementProposal.v1"),
   id: ReleaseIdSchema,
   overlay: HarnessOverlaySnapshotRefSchema,
   baseHarnessRelease: ImmutableReleaseRefSchema,
   expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
-  requestedScope: z5.enum(["personal", "team", "global"]),
+  requestedScope: z6.enum(["personal", "team", "global"]),
   route: HarnessImprovementRouteSchema,
-  risk: z5.enum(["low", "review", "restricted"]),
-  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20),
-  evidence: z5.array(HarnessProposalEvidenceRefSchema).min(1).max(1e3),
-  edits: z5.array(HarnessOverlayEditSchema).min(1).max(1e3),
-  validationPlan: z5.array(HarnessValidationPlanItemSchema).min(1).max(100),
+  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
@@ -750,29 +784,29 @@ var HarnessImprovementProposalContentSchema = z5.object({
 var HarnessImprovementProposalSchema = HarnessImprovementProposalContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessTargetedValidationReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessTargetedValidationReceipt.v1"),
+var HarnessTargetedValidationReceiptContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessTargetedValidationReceipt.v1"),
   id: ReleaseIdSchema,
   proposal: ImmutableReleaseRefSchema,
   validationId: ReleaseIdSchema,
   kind: HarnessValidationPlanItemSchema.shape.kind,
-  status: z5.enum(["passed", "failed", "blocked", "skipped"]),
+  status: z6.enum(["passed", "failed", "blocked", "skipped"]),
   summary: BoundedTextSchema2,
-  evidenceRefs: z5.array(HarnessProposalEvidenceRefSchema).max(1e3),
+  evidenceRefs: z6.array(HarnessProposalEvidenceRefSchema).max(1e3),
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema2
 }).strict();
 var HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessAdvanceDecisionSchema = z5.enum([
+var HarnessAdvanceDecisionSchema = z6.enum([
   "advanced",
   "retained",
   "conflict",
   "rolled_back"
 ]);
-var HarnessAdvanceReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessAdvanceReceipt.v1"),
+var HarnessAdvanceReceiptContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessAdvanceReceipt.v1"),
   id: ReleaseIdSchema,
   workspaceId: ReleaseIdSchema,
   ownerScope: HarnessOwnerScopeSchema,
@@ -783,7 +817,7 @@ var HarnessAdvanceReceiptContentSchema = z5.object({
   nextChannelRevision: RevisionSchema,
   previousRelease: ImmutableReleaseRefSchema.nullable(),
   nextRelease: ImmutableReleaseRefSchema.nullable(),
-  validationReceipts: z5.array(ImmutableReleaseRefSchema).max(100),
+  validationReceipts: z6.array(ImmutableReleaseRefSchema).max(100),
   decision: HarnessAdvanceDecisionSchema,
   reason: BoundedTextSchema2,
   rollbackOf: ImmutableReleaseRefSchema.nullable(),
@@ -816,17 +850,17 @@ var HarnessAdvanceReceiptContentSchema = z5.object({
 var HarnessAdvanceReceiptSchema = HarnessAdvanceReceiptContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessOverlayMergeReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessOverlayMergeReceipt.v1"),
+var HarnessOverlayMergeReceiptContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessOverlayMergeReceipt.v1"),
   id: ReleaseIdSchema,
   workspaceId: ReleaseIdSchema,
   baseHarnessRelease: ImmutableReleaseRefSchema,
   leftOverlay: HarnessOverlaySnapshotRefSchema,
   rightOverlay: HarnessOverlaySnapshotRefSchema,
-  decision: z5.enum(["merged", "conflict"]),
+  decision: z6.enum(["merged", "conflict"]),
   mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  conflictTargets: z5.array(z5.string().trim().min(1).max(2e3)).max(1e3),
-  requiresRevalidation: z5.literal(true),
+  conflictTargets: z6.array(z6.string().trim().min(1).max(2e3)).max(1e3),
+  requiresRevalidation: z6.literal(true),
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema2
 }).strict().superRefine((receipt, context) => {
@@ -850,25 +884,25 @@ var HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.e
 }).strict();
 
 // ../harness/dist/harness-improvements.js
-var BoundedTextSchema3 = z6.string().trim().min(1).max(1e5);
-var MetadataSchema3 = z6.record(z6.string(), z6.unknown()).default({});
-var ImprovementSafeBoundaryKindSchema = z6.enum([
+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 = z6.object({
+var ImprovementSafeBoundarySchema = z7.object({
   kind: ImprovementSafeBoundaryKindSchema,
-  eventSequence: z6.number().int().nonnegative(),
+  eventSequence: z7.number().int().nonnegative(),
   occurredAt: ReleaseTimestampSchema
 }).strict();
-var ImprovementEventRefSchema = z6.object({
+var ImprovementEventRefSchema = z7.object({
   id: ReleaseIdSchema,
-  sequence: z6.number().int().nonnegative().nullable(),
+  sequence: z7.number().int().nonnegative().nullable(),
   contentHash: ReleaseHashSchema
 }).strict();
-var ImprovementObservationKindSchema = z6.enum([
+var ImprovementObservationKindSchema = z7.enum([
   "tool_failure",
   "retry",
   "recovery",
@@ -877,27 +911,27 @@ var ImprovementObservationKindSchema = z6.enum([
   "reusable_success",
   "completion_detour"
 ]);
-var ImprovementObservationStateSchema = z6.enum([
+var ImprovementObservationStateSchema = z7.enum([
   "open",
   "recovered",
   "terminal"
 ]);
-var ImprovementToolIdentitySchema = z6.object({
-  name: z6.string().trim().min(1).max(500),
+var ImprovementToolIdentitySchema = z7.object({
+  name: z7.string().trim().min(1).max(500),
   invocationKey: ReleaseHashSchema
 }).strict();
-var ImprovementObservationContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementObservation.v1"),
+var ImprovementObservationContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.improvementObservation.v1"),
   id: ReleaseIdSchema,
   runRef: ReleaseIdSchema,
   turnId: ReleaseIdSchema,
   harnessRelease: ImmutableReleaseRefSchema,
   overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  eventRefs: z6.array(ImprovementEventRefSchema).min(1).max(100),
+  eventRefs: z7.array(ImprovementEventRefSchema).min(1).max(100),
   kind: ImprovementObservationKindSchema,
   state: ImprovementObservationStateSchema,
   tool: ImprovementToolIdentitySchema.nullable(),
-  deterministicClass: z6.string().trim().min(1).max(500).nullable(),
+  deterministicClass: z7.string().trim().min(1).max(500).nullable(),
   summary: BoundedTextSchema3,
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
@@ -920,36 +954,36 @@ var ImprovementObservationContentSchema = z6.object({
 var ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var RefinementTriggerPolicySchema = z6.object({
-  schemaVersion: z6.literal("openpond.refinementTriggerPolicy.v1"),
-  maxEstimatedCostUsd: z6.number().finite().nonnegative(),
-  cooldownMs: z6.number().int().nonnegative(),
-  maxPendingPlans: z6.number().int().min(1).max(100),
-  maxEvidenceEvents: z6.number().int().min(1).max(1e3),
-  maxProposalEdits: z6.number().int().min(1).max(1e3),
-  maxProposalBytes: z6.number().int().min(1).max(1e7)
+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 = z6.enum([
+var RefinementTriggerDecisionKindSchema = z7.enum([
   "no_action",
   "route_deterministically",
   "queue_refiner"
 ]);
-var RefinementTriggerDecisionContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.refinementTriggerDecision.v1"),
+var RefinementTriggerDecisionContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.refinementTriggerDecision.v1"),
   id: ReleaseIdSchema,
   runRef: ReleaseIdSchema,
   turnId: ReleaseIdSchema,
   harnessRelease: ImmutableReleaseRefSchema,
   overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  observations: z6.array(ImmutableReleaseRefSchema).max(100),
+  observations: z7.array(ImmutableReleaseRefSchema).max(100),
   decision: RefinementTriggerDecisionKindSchema,
   deterministicRoute: HarnessImprovementRouteSchema.nullable(),
-  suggestedRoutes: z6.array(HarnessImprovementRouteSchema).max(8),
+  suggestedRoutes: z7.array(HarnessImprovementRouteSchema).max(8),
   reason: BoundedTextSchema3,
   deduplicationKey: ReleaseHashSchema,
   policy: RefinementTriggerPolicySchema,
-  estimatedMaxCostUsd: z6.number().finite().nonnegative(),
-  pendingPlanCount: z6.number().int().nonnegative(),
+  estimatedMaxCostUsd: z7.number().finite().nonnegative(),
+  pendingPlanCount: z7.number().int().nonnegative(),
   boundary: ImprovementSafeBoundarySchema,
   cooldownUntil: ReleaseTimestampSchema.nullable(),
   createdAt: ReleaseTimestampSchema,
@@ -1008,20 +1042,20 @@ var RefinementTriggerDecisionContentSchema = z6.object({
 var RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var ImprovementRouteAuthoritySchema = z6.enum([
+var ImprovementRouteAuthoritySchema = z7.enum([
   "runtime_service",
   "refiner_model",
   "human_review",
   "evaluation_system",
   "training_system"
 ]);
-var ImprovementRouteDecisionContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementRouteDecision.v1"),
+var ImprovementRouteDecisionContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.improvementRouteDecision.v1"),
   id: ReleaseIdSchema,
   trigger: ImmutableReleaseRefSchema,
   route: HarnessImprovementRouteSchema,
   authority: ImprovementRouteAuthoritySchema,
-  automatic: z6.boolean(),
+  automatic: z7.boolean(),
   reason: BoundedTextSchema3,
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
@@ -1044,15 +1078,15 @@ var ImprovementRouteDecisionContentSchema = z6.object({
 var ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var HarnessRefinerOutcomeContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.harnessRefinerOutcome.v1"),
+var HarnessRefinerOutcomeContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.harnessRefinerOutcome.v1"),
   id: ReleaseIdSchema,
   trigger: ImmutableReleaseRefSchema,
-  decision: z6.enum(["no_action", "proposed"]),
+  decision: z7.enum(["no_action", "proposed"]),
   proposal: ImmutableReleaseRefSchema.nullable(),
   reason: BoundedTextSchema3,
-  evidenceRefs: z6.array(ImmutableReleaseRefSchema).max(100),
-  estimatedCostUsd: z6.number().finite().nonnegative(),
+  evidenceRefs: z7.array(ImmutableReleaseRefSchema).max(100),
+  estimatedCostUsd: z7.number().finite().nonnegative(),
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
 }).strict().superRefine((outcome, context) => {
@@ -1067,23 +1101,23 @@ var HarnessRefinerOutcomeContentSchema = z6.object({
 var HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
   contentHash: ReleaseHashSchema
 }).strict();
-var ImprovementApplyDecisionSchema = z6.enum([
+var ImprovementApplyDecisionSchema = z7.enum([
   "applied",
   "retained",
   "declined",
   "conflict",
   "rolled_back"
 ]);
-var ImprovementApplyReceiptContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementApplyReceipt.v1"),
+var ImprovementApplyReceiptContentSchema = z7.object({
+  schemaVersion: z7.literal("openpond.improvementApplyReceipt.v1"),
   id: ReleaseIdSchema,
   proposal: ImmutableReleaseRefSchema,
   beforeOverlay: HarnessOverlaySnapshotRefSchema,
   afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
   decision: ImprovementApplyDecisionSchema,
   boundary: ImprovementSafeBoundarySchema,
-  validationRefs: z6.array(ImmutableReleaseRefSchema).max(100),
-  outcomeEvidenceRefs: z6.array(ImprovementEventRefSchema).max(1e3),
+  validationRefs: z7.array(ImmutableReleaseRefSchema).max(100),
+  outcomeEvidenceRefs: z7.array(ImprovementEventRefSchema).max(1e3),
   rollbackOf: ImmutableReleaseRefSchema.nullable(),
   createdAt: ReleaseTimestampSchema,
   metadata: MetadataSchema3
@@ -1107,37 +1141,6 @@ var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend(
   contentHash: ReleaseHashSchema
 }).strict();
 
-// ../harness/dist/models.js
-import { z as z7 } from "zod";
-var ModelRefSchema = z7.object({
-  provider: ReleaseIdSchema,
-  model: ReleaseIdSchema,
-  revision: z7.string().trim().min(1).max(500).nullable().default(null),
-  artifactHash: ReleaseHashSchema.nullable().default(null),
-  tokenizerRevision: z7.string().trim().min(1).max(500).nullable().default(null),
-  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
-}).strict();
-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);
@@ -1624,8 +1627,9 @@ export {
   createAgentSnapshot,
   createHarnessRelease,
   ChatModelRefSchema,
+  HarnessPolicySourcePackageSchema,
   HarnessSourceSelectionSchema,
   validateHarnessPolicySourcePackage,
   validateHarnessSourcePackage
 };
-//# sourceMappingURL=chunk-Y4NGWGTA.js.map
+//# sourceMappingURL=chunk-4NZW4LFB.js.map