openpond-sdk 0.3.3 → 0.4.0

package/dist/taskset-packages.js

@@ -1,3089 +1,118 @@
-// src/taskset-package-contracts.ts
-import { z as z19 } from "zod";
-
-// ../harness/dist/common.js
-import { z } from "zod";
-
-// ../harness/dist/sha256.js
-var INITIAL_STATE = new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var ROUND_CONSTANTS = new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-function sha256Hex(value) {
-  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
-  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
-  const padded = new Uint8Array(paddedLength);
-  padded.set(bytes);
-  padded[bytes.byteLength] = 128;
-  const bitLength = bytes.byteLength * 8;
-  const view = new DataView(padded.buffer);
-  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
-  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
-  const state = new Uint32Array(INITIAL_STATE);
-  const words = new Uint32Array(64);
-  for (let offset = 0; offset < paddedLength; offset += 64) {
-    for (let index = 0; index < 16; index += 1) {
-      words[index] = view.getUint32(offset + index * 4, false);
-    }
-    for (let index = 16; index < 64; index += 1) {
-      const previous = words[index - 15];
-      const recent = words[index - 2];
-      const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
-      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
-      words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
-    }
-    let a = state[0];
-    let b = state[1];
-    let c = state[2];
-    let d = state[3];
-    let e = state[4];
-    let f = state[5];
-    let g = state[6];
-    let h = state[7];
-    for (let index = 0; index < 64; index += 1) {
-      const choice = e & f ^ ~e & g;
-      const majority = a & b ^ a & c ^ b & c;
-      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
-      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
-      const first = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
-      const second = sum0 + majority >>> 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + first >>> 0;
-      d = c;
-      c = b;
-      b = a;
-      a = first + second >>> 0;
-    }
-    state[0] = state[0] + a >>> 0;
-    state[1] = state[1] + b >>> 0;
-    state[2] = state[2] + c >>> 0;
-    state[3] = state[3] + d >>> 0;
-    state[4] = state[4] + e >>> 0;
-    state[5] = state[5] + f >>> 0;
-    state[6] = state[6] + g >>> 0;
-    state[7] = state[7] + h >>> 0;
-  }
-  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
-}
-function rotateRight(value, bits) {
-  return value >>> bits | value << 32 - bits;
-}
-
-// ../harness/dist/common.js
-var MAX_PORTABLE_PATH_BYTES = 2e3;
-var MAX_PORTABLE_ASSET_BYTES = 25e7;
-var ReleaseIdSchema = z.string().trim().min(1).max(240);
-var ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var ReleaseTimestampSchema = z.string().datetime({ offset: true });
-var MetadataSchema = z.record(z.string(), z.unknown()).default({});
-var ImmutableReleaseRefSchema = z.object({
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var ImmutableAssetRefSchema = z.object({
-  id: ReleaseIdSchema,
-  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
-  contentHash: ReleaseHashSchema,
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
-  mediaType: z.string().trim().min(1).max(200),
-  visibility: z.enum(["policy", "verifier", "host_private"])
-}).strict();
-var ImmutableArtifactRefSchema = z.object({
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema,
-  mediaType: z.string().trim().min(1).max(200).nullable().default(null),
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
-}).strict();
-var FailureClassSchema = z.enum([
-  "policy_failure",
-  "grader_failure",
-  "environment_failure",
-  "infrastructure_failure",
-  "timeout",
-  "cancelled"
-]);
-function canonicalJson(value) {
-  return `${JSON.stringify(sortValue(value), null, 2)}
-`;
-}
-function sha256(value) {
-  return sha256Hex(value);
-}
-function contentHash(value) {
-  return sha256(canonicalJson(value));
-}
-function safeRelativePath(value) {
-  const normalized = value.replaceAll("\\", "/");
-  if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
-    return false;
-  return !normalized.split("/").some((part) => !part || part === "." || part === "..");
-}
-function sortValue(value) {
-  if (Array.isArray(value))
-    return value.map(sortValue);
-  if (!value || typeof value !== "object")
-    return value;
-  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)]));
-}
-
-// ../harness/dist/evaluation-review.js
-import { z as z2 } from "zod";
-var BoundedTextSchema = z2.string().trim().min(1).max(1e5);
-var HarnessEvaluationReviewClassificationSchema = z2.enum([
-  "no_action",
-  "harness_maintenance",
-  "runtime",
-  "product",
-  "taskset",
-  "model_improvement"
-]);
-var HarnessEvaluationReviewAuthoritySchema = z2.enum([
-  "none",
-  "runtime_service",
-  "product_team",
-  "human_review",
-  "evaluation_system",
-  "training_system"
-]);
-var HarnessReviewEvidenceKindSchema = z2.enum([
-  "observation",
-  "trigger",
-  "route_decision",
-  "refiner_outcome",
-  "proposal",
-  "validation",
-  "apply_receipt",
-  "harness_advance",
-  "rollback",
-  "work_outcome",
-  "taskset",
-  "evaluation",
-  "training_qualification",
-  "model_candidate"
-]);
-var HarnessReviewOwnerScopeSchema = z2.object({
-  kind: z2.enum(["personal", "team"]),
-  id: ReleaseIdSchema
-}).strict();
-var HarnessReviewSourcePolicyRefSchema = z2.object({
-  policy: ImmutableReleaseRefSchema,
-  state: z2.enum(["authorized", "revoked", "deleted", "expired"]),
-  checkedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewEvidenceRefSchema = z2.object({
-  evidence: ImmutableReleaseRefSchema,
-  kind: HarnessReviewEvidenceKindSchema,
-  sourceRef: ReleaseIdSchema,
-  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
-  occurrenceKey: ReleaseHashSchema,
-  occurredAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewExcludedEvidenceSchema = z2.object({
-  evidence: ImmutableReleaseRefSchema,
-  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
-  reason: z2.enum([
-    "outside_scope",
-    "before_watermark",
-    "duplicate",
-    "resolved",
-    "revoked",
-    "deleted",
-    "expired",
-    "sensitive",
-    "unverified",
-    "budget"
-  ])
-}).strict();
-var HarnessReviewWatermarkSchema = z2.object({
-  cursor: ReleaseHashSchema,
-  throughCreatedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessReviewClaimSchema = z2.object({
-  fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z2.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema,
-  candidateDisposition: z2.enum(["observe", "confirm"]).optional(),
-  independentOccurrences: z2.number().int().positive().max(1e6),
-  unresolvedOccurrences: z2.number().int().positive().max(1e6)
-}).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
-var HarnessReviewTriageLayerSchema = z2.enum([
-  "harness",
-  "runtime",
-  "product",
-  "retrieval",
-  "tools",
-  "evaluation",
-  "model"
-]);
-var HarnessReviewTriageDecisionSchema = z2.object({
-  layer: HarnessReviewTriageLayerSchema,
-  status: z2.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
-  reason: BoundedTextSchema,
-  evidenceRefs: z2.array(ImmutableReleaseRefSchema).max(1e3)
-}).strict();
-var HarnessEvaluationReviewReceiptContentSchema = z2.object({
-  schemaVersion: z2.literal("openpond.harnessEvaluationReviewReceipt.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
-  nextWatermark: HarnessReviewWatermarkSchema,
-  selectedEvidence: z2.array(HarnessReviewEvidenceRefSchema).max(1e4),
-  excludedEvidence: z2.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
-  claim: HarnessReviewClaimSchema.nullable(),
-  classification: HarnessEvaluationReviewClassificationSchema,
-  triage: z2.array(HarnessReviewTriageDecisionSchema).max(16),
-  reason: BoundedTextSchema,
-  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
-  maxEstimatedCostUsd: z2.number().finite().nonnegative(),
-  tasksetProposal: ImmutableReleaseRefSchema.nullable(),
-  evaluation: ImmutableReleaseRefSchema.nullable(),
-  trainingQualification: ImmutableReleaseRefSchema.nullable(),
-  policyVersion: ReleaseIdSchema,
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema
-}).strict().superRefine((receipt, context) => {
-  const selectedKeys = receipt.selectedEvidence.map((item) => `${item.evidence.id}:${item.evidence.contentHash}`);
-  if (new Set(selectedKeys).size !== selectedKeys.length) {
-    context.addIssue({
-      code: "custom",
-      message: "selected review evidence must be unique",
-      path: ["selectedEvidence"]
-    });
-  }
-  if (receipt.selectedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
-    context.addIssue({
-      code: "custom",
-      message: "selected review evidence must be authorized at review time",
-      path: ["selectedEvidence"]
-    });
-  }
-  if (receipt.classification === "no_action") {
-    if (receipt.nextAuthority !== "none") {
-      context.addIssue({
-        code: "custom",
-        message: "no-action review receipts require no next authority",
-        path: ["nextAuthority"]
-      });
-    }
-    if (receipt.tasksetProposal || receipt.evaluation || receipt.trainingQualification) {
-      context.addIssue({
-        code: "custom",
-        message: "no-action review receipts cannot carry downstream refs"
-      });
-    }
-  } else if (!receipt.claim || receipt.selectedEvidence.length === 0) {
-    context.addIssue({
-      code: "custom",
-      message: "actionable review receipts require a claim and selected evidence"
-    });
-  }
-  if (receipt.classification === "runtime" && receipt.nextAuthority !== "runtime_service") {
-    context.addIssue({
-      code: "custom",
-      message: "runtime classifications route to runtime-service authority",
-      path: ["nextAuthority"]
-    });
-  }
-  if (receipt.classification === "product" && receipt.nextAuthority !== "product_team") {
-    context.addIssue({
-      code: "custom",
-      message: "product classifications route to product-team authority",
-      path: ["nextAuthority"]
-    });
-  }
-  if (receipt.classification === "taskset" && receipt.nextAuthority !== "human_review") {
-    context.addIssue({
-      code: "custom",
-      message: "Taskset classifications require human review"
-    });
-  }
-  if (receipt.classification === "model_improvement" && (!receipt.evaluation || !receipt.trainingQualification || !["human_review", "training_system"].includes(receipt.nextAuthority))) {
-    context.addIssue({
-      code: "custom",
-      message: "model-improvement classifications require Evaluation and qualification refs plus explicit authority"
-    });
-  }
-});
-var HarnessEvaluationReviewReceiptSchema = HarnessEvaluationReviewReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessEvaluationReviewModelEvidenceSchema = z2.object({
-  id: ReleaseIdSchema,
-  evidence: ImmutableReleaseRefSchema,
-  kind: HarnessReviewEvidenceKindSchema,
-  sourceRef: ReleaseIdSchema,
-  occurredAt: ReleaseTimestampSchema,
-  payload: z2.record(z2.string(), z2.unknown())
-}).strict();
-var HarnessEvaluationReviewModelNoActionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z2.literal("no_action"),
-  reason: BoundedTextSchema,
-  ignoredEvidence: z2.array(z2.object({
-    id: ReleaseIdSchema,
-    reason: z2.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3)
-}).strict();
-var HarnessEvaluationReviewModelActionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z2.literal("review"),
-  classification: z2.enum([
-    "harness_maintenance",
-    "runtime",
-    "product",
-    "taskset"
-  ]),
-  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z2.array(z2.object({
-    id: ReleaseIdSchema,
-    reason: z2.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3),
-  recurrenceFamily: z2.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema,
-  triageLayer: HarnessReviewTriageLayerSchema,
-  expectedOutcome: BoundedTextSchema,
-  counterevidence: z2.string().trim().max(1e4),
-  confidence: z2.number().min(0).max(1),
-  candidateDisposition: z2.enum(["observe", "confirm"]).nullable(),
-  reason: BoundedTextSchema
-}).strict().superRefine((decision, context) => {
-  const requiresDisposition = decision.classification === "harness_maintenance";
-  if (requiresDisposition !== (decision.candidateDisposition !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "Harness maintenance requires a candidate disposition; external routes require null",
-      path: ["candidateDisposition"]
-    });
-  }
-});
-var HarnessEvaluationReviewModelResolutionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
-  decision: z2.literal("resolve_candidate"),
-  candidateId: ReleaseIdSchema,
-  candidateFingerprint: ReleaseHashSchema,
-  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
-  ignoredEvidence: z2.array(z2.object({
-    id: ReleaseIdSchema,
-    reason: z2.string().trim().min(1).max(2e3)
-  }).strict()).max(1e3),
-  confidence: z2.number().min(0).max(1),
-  reason: BoundedTextSchema
-}).strict();
-var HarnessEvaluationReviewModelDecisionSchema = z2.discriminatedUnion("decision", [
-  HarnessEvaluationReviewModelNoActionSchema,
-  HarnessEvaluationReviewModelActionSchema,
-  HarnessEvaluationReviewModelResolutionSchema
-]);
-var HarnessEvaluationReviewNavigationDecisionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
-  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(50),
-  reason: BoundedTextSchema
-}).strict();
-
-// ../harness/dist/harness.js
-import { z as z4 } from "zod";
-
-// ../harness/dist/tools.js
-import { z as z3 } from "zod";
-var ToolDeclarationSchema = z3.object({
-  name: z3.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-  description: z3.string().trim().min(1).max(2e3),
-  inputSchema: z3.record(z3.string(), z3.unknown()),
-  inputSchemaHash: ReleaseHashSchema,
-  sideEffect: z3.enum(["read", "write"]),
-  timeoutMs: z3.number().int().positive().max(36e5)
-}).strict();
-var CapabilityRequirementSchema = z3.object({
-  id: ReleaseIdSchema,
-  required: z3.boolean(),
-  scopes: z3.array(z3.string().trim().min(1).max(500)).max(100).default([]),
-  portability: z3.enum(["portable", "host_adapter", "local_only", "hosted_only"])
-}).strict();
-
-// ../harness/dist/harness.js
-var PortabilityReportSchema = z4.object({
-  portable: z4.boolean(),
-  blockers: z4.array(z4.string().trim().min(1).max(2e3)).max(1e3),
-  localOnlyAssetRefs: z4.array(ReleaseIdSchema).max(1e4),
-  hostPrivateAssetRefs: z4.array(ReleaseIdSchema).max(1e4)
-}).strict();
-var AgentSnapshotContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.agentSnapshot.v2"),
-  id: ReleaseIdSchema,
-  sourceRelease: ImmutableReleaseRefSchema.nullable(),
-  instructions: z4.array(ImmutableAssetRefSchema).max(1e4),
-  skills: z4.array(ImmutableAssetRefSchema).max(1e4),
-  agents: z4.array(ImmutableAssetRefSchema).max(1e4),
-  toolDeclarations: z4.array(ToolDeclarationSchema).max(200),
-  capabilityRequirements: z4.array(CapabilityRequirementSchema).max(200),
-  dependencyLock: ImmutableAssetRefSchema,
-  portability: PortabilityReportSchema,
-  metadata: MetadataSchema
-}).strict();
-var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var LifecycleContractSchema = z4.object({
-  create: z4.literal(true),
-  reset: z4.literal(true),
-  step: z4.literal(true),
-  collect: z4.literal(true),
-  destroy: z4.literal(true),
-  resetScope: z4.enum(["task", "attempt"])
-}).strict();
-var GraderInterfaceContractSchema = z4.object({
-  visibleEvidence: z4.array(ReleaseIdSchema).max(1e3),
-  privilegedEvidence: z4.array(ReleaseIdSchema).max(1e3),
-  privateVerifierIsolation: z4.boolean()
-}).strict();
-var HarnessReleaseContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessRelease.v2"),
-  id: ReleaseIdSchema,
-  agentSnapshot: ImmutableReleaseRefSchema,
-  program: ImmutableAssetRefSchema,
-  tools: z4.array(ToolDeclarationSchema).max(200),
-  lifecycle: LifecycleContractSchema,
-  graderInterface: GraderInterfaceContractSchema,
-  files: z4.array(ImmutableAssetRefSchema).max(1e5),
-  metadata: MetadataSchema
-}).strict();
-var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-var ModelActionSchema = z4.object({
-  id: ReleaseIdSchema,
-  turn: z4.number().int().nonnegative(),
-  kind: z4.enum(["message", "tool_call", "terminal"]),
-  name: ReleaseIdSchema.nullable(),
-  arguments: z4.record(z4.string(), z4.unknown()),
-  content: z4.string().max(1e6).nullable()
-}).strict();
-var ToolObservationSchema = z4.object({
-  actionId: ReleaseIdSchema,
-  turn: z4.number().int().nonnegative(),
-  terminal: z4.boolean(),
-  output: z4.record(z4.string(), z4.unknown()),
-  artifactRefs: z4.array(ImmutableArtifactRefSchema).max(1e5)
-}).strict();
-var HarnessLifecycleEventSchema = z4.object({
-  sequence: z4.number().int().nonnegative(),
-  type: z4.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
-  payloadHash: ReleaseHashSchema,
-  metadata: MetadataSchema
-}).strict();
-var HarnessTraceSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessTrace.v1"),
-  manifest: ImmutableReleaseRefSchema,
-  taskId: ReleaseIdSchema,
-  seed: z4.string().trim().min(1).max(500),
-  events: z4.array(HarnessLifecycleEventSchema).max(1e6),
-  actions: z4.array(ModelActionSchema).max(1e5),
-  observations: z4.array(ToolObservationSchema).max(1e5),
-  terminal: z4.boolean(),
-  failureClass: FailureClassSchema.nullable(),
-  output: z4.record(z4.string(), z4.unknown()),
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/harness-improvements.js
-import { z as z6 } from "zod";
-
-// ../harness/dist/harness-workspaces.js
-import { z as z5 } from "zod";
-var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
-var RevisionSchema = z5.number().int().nonnegative();
-var BoundedTextSchema2 = z5.string().trim().min(1).max(1e5);
-var HarnessOwnerScopeSchema = z5.object({
-  kind: z5.enum(["personal", "team"]),
-  id: ReleaseIdSchema
-}).strict();
-var HarnessCurrentChannelSchema = z5.object({
-  name: ReleaseIdSchema,
-  release: ImmutableReleaseRefSchema.nullable(),
-  revision: RevisionSchema
-}).strict();
-var HarnessWorkspaceSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessWorkspace.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessOwnerScopeSchema,
-  name: z5.string().trim().min(1).max(240),
-  location: z5.enum(["local", "hosted"]),
-  sourceRevision: z5.string().trim().min(1).max(500),
-  revision: RevisionSchema,
-  dirty: z5.boolean(),
-  currentChannel: HarnessCurrentChannelSchema,
-  createdAt: ReleaseTimestampSchema,
-  updatedAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessImprovementRouteSchema = z5.enum([
-  "runtime",
-  "memory",
-  "prompt",
-  "skill",
-  "agent",
-  "product",
-  "taskset",
-  "training"
-]);
-var HarnessChangeEffectSchema = z5.enum([
-  "text_instruction",
-  "memory",
-  "dependency_selection",
-  "executable_code",
-  "business_logic",
-  "financial_logic",
-  "permission",
-  "connected_app",
-  "publication",
-  "deployment",
-  "training",
-  "model_binding",
-  "team_or_global"
-]);
-var HarnessOverlayEditSchema = z5.object({
-  id: ReleaseIdSchema,
-  route: HarnessImprovementRouteSchema,
-  operation: z5.enum(["create", "update", "delete"]),
-  target: z5.string().trim().min(1).max(2e3),
-  summary: z5.string().trim().min(1).max(2e3),
-  content: z5.string().max(1e6).nullable(),
-  contentHash: ReleaseHashSchema.nullable(),
-  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20)
-}).strict().superRefine((edit, context) => {
-  if (edit.operation === "delete") {
-    if (edit.content !== null || edit.contentHash !== null) {
-      context.addIssue({
-        code: "custom",
-        message: "delete edits cannot include replacement content",
-        path: ["content"]
-      });
-    }
-    return;
-  }
-  if (edit.content === null || edit.contentHash === null) {
-    context.addIssue({
-      code: "custom",
-      message: "create and update edits require content and contentHash",
-      path: ["content"]
-    });
-    return;
-  }
-  const expected = contentHash(edit.content);
-  if (edit.contentHash !== expected) {
-    context.addIssue({
-      code: "custom",
-      message: `edit contentHash is ${edit.contentHash}; expected ${expected}`,
-      path: ["contentHash"]
-    });
-  }
-});
-var HarnessWorkspaceRevisionRefSchema = z5.object({
-  workspaceId: ReleaseIdSchema,
-  revision: RevisionSchema,
-  sourceRevision: z5.string().trim().min(1).max(500),
-  channelRevision: RevisionSchema
-}).strict();
-var HarnessOverlaySnapshotRefSchema = z5.object({
-  id: ReleaseIdSchema,
-  revision: RevisionSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessTurnSnapshotSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessTurnSnapshot.v1"),
-  workspaceId: ReleaseIdSchema,
-  workspaceRevision: RevisionSchema,
-  sourceRevision: z5.string().trim().min(1).max(500),
-  channelName: ReleaseIdSchema,
-  channelRevision: RevisionSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  toolCatalogHash: ReleaseHashSchema.nullable().optional(),
-  overlay: HarnessOverlaySnapshotRefSchema.nullable().optional().default(null)
-}).strict();
-var HarnessRunOverlayContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessRunOverlay.v1"),
-  id: ReleaseIdSchema,
-  runId: ReleaseIdSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  workspace: HarnessWorkspaceRevisionRefSchema,
-  revision: RevisionSchema,
-  status: z5.enum(["active", "frozen", "abandoned"]),
-  edits: z5.array(HarnessOverlayEditSchema).max(1e3),
-  createdAt: ReleaseTimestampSchema,
-  updatedAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessProposalEvidenceRefSchema = z5.object({
-  kind: z5.enum([
-    "tool_event",
-    "recovery",
-    "validation",
-    "user_turn",
-    "work_output",
-    "work_receipt"
-  ]),
-  id: ReleaseIdSchema,
-  contentHash: ReleaseHashSchema.nullable()
-}).strict();
-var HarnessValidationPlanItemSchema = z5.object({
-  id: ReleaseIdSchema,
-  kind: z5.enum([
-    "dependency",
-    "schema",
-    "package",
-    "file_render",
-    "skill",
-    "prompt",
-    "business_formula",
-    "targeted_evaluation",
-    "observed_recovery",
-    "memory",
-    "component_activation"
-  ]),
-  description: BoundedTextSchema2,
-  required: z5.boolean()
-}).strict();
-var HarnessImprovementProposalContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessImprovementProposal.v1"),
-  id: ReleaseIdSchema,
-  overlay: HarnessOverlaySnapshotRefSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
-  requestedScope: z5.enum(["personal", "team", "global"]),
-  route: HarnessImprovementRouteSchema,
-  risk: z5.enum(["low", "review", "restricted"]),
-  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20),
-  evidence: z5.array(HarnessProposalEvidenceRefSchema).min(1).max(1e3),
-  edits: z5.array(HarnessOverlayEditSchema).min(1).max(1e3),
-  validationPlan: z5.array(HarnessValidationPlanItemSchema).min(1).max(100),
-  expectedOutcome: BoundedTextSchema2,
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict().superRefine((proposal, context) => {
-  const declaredEffects = new Set(proposal.effects);
-  for (const [index, edit] of proposal.edits.entries()) {
-    if (edit.route !== proposal.route) {
-      context.addIssue({
-        code: "custom",
-        message: "every edit route must match the proposal route",
-        path: ["edits", index, "route"]
-      });
-    }
-    for (const effect of edit.effects) {
-      if (!declaredEffects.has(effect)) {
-        context.addIssue({
-          code: "custom",
-          message: `edit effect ${effect} is missing from proposal effects`,
-          path: ["edits", index, "effects"]
-        });
-      }
-    }
-  }
-  if (new Set(proposal.validationPlan.map((item) => item.id)).size !== proposal.validationPlan.length) {
-    context.addIssue({
-      code: "custom",
-      message: "validation plan ids must be unique",
-      path: ["validationPlan"]
-    });
-  }
-});
-var HarnessImprovementProposalSchema = HarnessImprovementProposalContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessTargetedValidationReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessTargetedValidationReceipt.v1"),
-  id: ReleaseIdSchema,
-  proposal: ImmutableReleaseRefSchema,
-  validationId: ReleaseIdSchema,
-  kind: HarnessValidationPlanItemSchema.shape.kind,
-  status: z5.enum(["passed", "failed", "blocked", "skipped"]),
-  summary: BoundedTextSchema2,
-  evidenceRefs: z5.array(HarnessProposalEvidenceRefSchema).max(1e3),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict();
-var HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessAdvanceDecisionSchema = z5.enum([
-  "advanced",
-  "retained",
-  "conflict",
-  "rolled_back"
-]);
-var HarnessAdvanceReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessAdvanceReceipt.v1"),
-  id: ReleaseIdSchema,
-  workspaceId: ReleaseIdSchema,
-  ownerScope: HarnessOwnerScopeSchema,
-  proposal: ImmutableReleaseRefSchema.nullable(),
-  expectedWorkspaceRevision: RevisionSchema,
-  observedWorkspaceRevision: RevisionSchema,
-  previousChannelRevision: RevisionSchema,
-  nextChannelRevision: RevisionSchema,
-  previousRelease: ImmutableReleaseRefSchema.nullable(),
-  nextRelease: ImmutableReleaseRefSchema.nullable(),
-  validationReceipts: z5.array(ImmutableReleaseRefSchema).max(100),
-  decision: HarnessAdvanceDecisionSchema,
-  reason: BoundedTextSchema2,
-  rollbackOf: ImmutableReleaseRefSchema.nullable(),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict().superRefine((receipt, context) => {
-  const changed = receipt.nextChannelRevision === receipt.previousChannelRevision + 1;
-  if (["advanced", "rolled_back"].includes(receipt.decision) !== changed) {
-    context.addIssue({
-      code: "custom",
-      message: "only successful advancement or rollback increments the channel revision",
-      path: ["nextChannelRevision"]
-    });
-  }
-  if (receipt.decision === "rolled_back" && receipt.rollbackOf === null) {
-    context.addIssue({
-      code: "custom",
-      message: "rollback receipts require rollbackOf",
-      path: ["rollbackOf"]
-    });
-  }
-  if (receipt.decision !== "rolled_back" && receipt.rollbackOf !== null) {
-    context.addIssue({
-      code: "custom",
-      message: "rollbackOf is only valid for rollback receipts",
-      path: ["rollbackOf"]
-    });
-  }
-});
-var HarnessAdvanceReceiptSchema = HarnessAdvanceReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessOverlayMergeReceiptContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.harnessOverlayMergeReceipt.v1"),
-  id: ReleaseIdSchema,
-  workspaceId: ReleaseIdSchema,
-  baseHarnessRelease: ImmutableReleaseRefSchema,
-  leftOverlay: HarnessOverlaySnapshotRefSchema,
-  rightOverlay: HarnessOverlaySnapshotRefSchema,
-  decision: z5.enum(["merged", "conflict"]),
-  mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  conflictTargets: z5.array(z5.string().trim().min(1).max(2e3)).max(1e3),
-  requiresRevalidation: z5.literal(true),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema2
-}).strict().superRefine((receipt, context) => {
-  if (receipt.decision === "merged" !== (receipt.mergedOverlay !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "merged decisions require a merged overlay; conflicts cannot provide one",
-      path: ["mergedOverlay"]
-    });
-  }
-  if (receipt.decision === "conflict" !== receipt.conflictTargets.length > 0) {
-    context.addIssue({
-      code: "custom",
-      message: "conflict decisions require conflict targets and merged decisions cannot include them",
-      path: ["conflictTargets"]
-    });
-  }
-});
-var HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/harness-improvements.js
-var BoundedTextSchema3 = z6.string().trim().min(1).max(1e5);
-var MetadataSchema3 = z6.record(z6.string(), z6.unknown()).default({});
-var ImprovementSafeBoundaryKindSchema = z6.enum([
-  "completed_tool_batch",
-  "before_model_step",
-  "turn_completed",
-  "turn_paused"
-]);
-var ImprovementSafeBoundarySchema = z6.object({
-  kind: ImprovementSafeBoundaryKindSchema,
-  eventSequence: z6.number().int().nonnegative(),
-  occurredAt: ReleaseTimestampSchema
-}).strict();
-var ImprovementEventRefSchema = z6.object({
-  id: ReleaseIdSchema,
-  sequence: z6.number().int().nonnegative().nullable(),
-  contentHash: ReleaseHashSchema
-}).strict();
-var ImprovementObservationKindSchema = z6.enum([
-  "tool_failure",
-  "retry",
-  "recovery",
-  "validation",
-  "user_turn",
-  "reusable_success",
-  "completion_detour"
-]);
-var ImprovementObservationStateSchema = z6.enum([
-  "open",
-  "recovered",
-  "terminal"
-]);
-var ImprovementToolIdentitySchema = z6.object({
-  name: z6.string().trim().min(1).max(500),
-  invocationKey: ReleaseHashSchema
-}).strict();
-var ImprovementObservationContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementObservation.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  eventRefs: z6.array(ImprovementEventRefSchema).min(1).max(100),
-  kind: ImprovementObservationKindSchema,
-  state: ImprovementObservationStateSchema,
-  tool: ImprovementToolIdentitySchema.nullable(),
-  deterministicClass: z6.string().trim().min(1).max(500).nullable(),
-  summary: BoundedTextSchema3,
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((observation, context) => {
-  if (new Set(observation.eventRefs.map((reference) => reference.id)).size !== observation.eventRefs.length) {
-    context.addIssue({
-      code: "custom",
-      message: "observation event refs must be unique",
-      path: ["eventRefs"]
-    });
-  }
-  if (["tool_failure", "retry", "recovery", "completion_detour"].includes(observation.kind) && observation.tool === null) {
-    context.addIssue({
-      code: "custom",
-      message: `${observation.kind} observations require a tool identity`,
-      path: ["tool"]
-    });
-  }
-});
-var ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var RefinementTriggerPolicySchema = z6.object({
-  schemaVersion: z6.literal("openpond.refinementTriggerPolicy.v1"),
-  maxEstimatedCostUsd: z6.number().finite().nonnegative(),
-  cooldownMs: z6.number().int().nonnegative(),
-  maxPendingPlans: z6.number().int().min(1).max(100),
-  maxEvidenceEvents: z6.number().int().min(1).max(1e3),
-  maxProposalEdits: z6.number().int().min(1).max(1e3),
-  maxProposalBytes: z6.number().int().min(1).max(1e7)
-}).strict();
-var RefinementTriggerDecisionKindSchema = z6.enum([
-  "no_action",
-  "route_deterministically",
-  "queue_refiner"
-]);
-var RefinementTriggerDecisionContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.refinementTriggerDecision.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  harnessRelease: ImmutableReleaseRefSchema,
-  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  observations: z6.array(ImmutableReleaseRefSchema).max(100),
-  decision: RefinementTriggerDecisionKindSchema,
-  deterministicRoute: HarnessImprovementRouteSchema.nullable(),
-  suggestedRoutes: z6.array(HarnessImprovementRouteSchema).max(8),
-  reason: BoundedTextSchema3,
-  deduplicationKey: ReleaseHashSchema,
-  policy: RefinementTriggerPolicySchema,
-  estimatedMaxCostUsd: z6.number().finite().nonnegative(),
-  pendingPlanCount: z6.number().int().nonnegative(),
-  boundary: ImprovementSafeBoundarySchema,
-  cooldownUntil: ReleaseTimestampSchema.nullable(),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((trigger, context) => {
-  if (trigger.estimatedMaxCostUsd > trigger.policy.maxEstimatedCostUsd) {
-    context.addIssue({
-      code: "custom",
-      message: "estimated Refiner cost exceeds the trigger policy budget",
-      path: ["estimatedMaxCostUsd"]
-    });
-  }
-  if (trigger.pendingPlanCount > trigger.policy.maxPendingPlans) {
-    context.addIssue({
-      code: "custom",
-      message: "pending plan count exceeds the trigger policy limit",
-      path: ["pendingPlanCount"]
-    });
-  }
-  if (trigger.observations.length > trigger.policy.maxEvidenceEvents) {
-    context.addIssue({
-      code: "custom",
-      message: "trigger observations exceed the evidence budget",
-      path: ["observations"]
-    });
-  }
-  if (trigger.decision === "route_deterministically" && trigger.deterministicRoute === null) {
-    context.addIssue({
-      code: "custom",
-      message: "deterministic decisions require a route",
-      path: ["deterministicRoute"]
-    });
-  }
-  if (trigger.decision !== "route_deterministically" && trigger.deterministicRoute !== null) {
-    context.addIssue({
-      code: "custom",
-      message: "only deterministic decisions may declare a deterministic route",
-      path: ["deterministicRoute"]
-    });
-  }
-  if (trigger.decision === "no_action" && trigger.suggestedRoutes.length > 0) {
-    context.addIssue({
-      code: "custom",
-      message: "no-action decisions cannot suggest routes",
-      path: ["suggestedRoutes"]
-    });
-  }
-  if (trigger.decision !== "no_action" && trigger.observations.length === 0) {
-    context.addIssue({
-      code: "custom",
-      message: "actionable trigger decisions require observations",
-      path: ["observations"]
-    });
-  }
-});
-var RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var ImprovementRouteAuthoritySchema = z6.enum([
-  "runtime_service",
-  "refiner_model",
-  "human_review",
-  "evaluation_system",
-  "training_system"
-]);
-var ImprovementRouteDecisionContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementRouteDecision.v1"),
-  id: ReleaseIdSchema,
-  trigger: ImmutableReleaseRefSchema,
-  route: HarnessImprovementRouteSchema,
-  authority: ImprovementRouteAuthoritySchema,
-  automatic: z6.boolean(),
-  reason: BoundedTextSchema3,
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((decision, context) => {
-  if (decision.automatic && ["human_review", "evaluation_system", "training_system"].includes(decision.authority)) {
-    context.addIssue({
-      code: "custom",
-      message: `${decision.authority} routes cannot be marked automatic`,
-      path: ["automatic"]
-    });
-  }
-  if (decision.route === "training" && decision.automatic && decision.authority !== "training_system") {
-    context.addIssue({
-      code: "custom",
-      message: "automatic training routes require training-system authority",
-      path: ["authority"]
-    });
-  }
-});
-var ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessRefinerOutcomeContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.harnessRefinerOutcome.v1"),
-  id: ReleaseIdSchema,
-  trigger: ImmutableReleaseRefSchema,
-  decision: z6.enum(["no_action", "proposed"]),
-  proposal: ImmutableReleaseRefSchema.nullable(),
-  reason: BoundedTextSchema3,
-  evidenceRefs: z6.array(ImmutableReleaseRefSchema).max(100),
-  estimatedCostUsd: z6.number().finite().nonnegative(),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((outcome, context) => {
-  if (outcome.decision === "proposed" !== (outcome.proposal !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "proposed Refiner outcomes require a proposal; no-action outcomes cannot include one",
-      path: ["proposal"]
-    });
-  }
-});
-var HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var ImprovementApplyDecisionSchema = z6.enum([
-  "applied",
-  "retained",
-  "declined",
-  "conflict",
-  "rolled_back"
-]);
-var ImprovementApplyReceiptContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.improvementApplyReceipt.v1"),
-  id: ReleaseIdSchema,
-  proposal: ImmutableReleaseRefSchema,
-  beforeOverlay: HarnessOverlaySnapshotRefSchema,
-  afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-  decision: ImprovementApplyDecisionSchema,
-  boundary: ImprovementSafeBoundarySchema,
-  validationRefs: z6.array(ImmutableReleaseRefSchema).max(100),
-  outcomeEvidenceRefs: z6.array(ImprovementEventRefSchema).max(1e3),
-  rollbackOf: ImmutableReleaseRefSchema.nullable(),
-  createdAt: ReleaseTimestampSchema,
-  metadata: MetadataSchema3
-}).strict().superRefine((receipt, context) => {
-  if (receipt.decision === "applied" !== (receipt.afterOverlay !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "applied receipts require an after-overlay; other decisions cannot include one",
-      path: ["afterOverlay"]
-    });
-  }
-  if (receipt.decision === "rolled_back" !== (receipt.rollbackOf !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "only rollback receipts require rollbackOf",
-      path: ["rollbackOf"]
-    });
-  }
-});
-var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/models.js
-import { z as z7 } from "zod";
-var ModelRefSchema = z7.object({
-  provider: ReleaseIdSchema,
-  model: ReleaseIdSchema,
-  revision: z7.string().trim().min(1).max(500).nullable().default(null),
-  artifactHash: ReleaseHashSchema.nullable().default(null),
-  tokenizerRevision: z7.string().trim().min(1).max(500).nullable().default(null),
-  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
-}).strict();
-
-// ../harness/dist/refiner.js
-import { z as z9 } from "zod";
-
-// ../harness/dist/refiner-profiles.js
-import { z as z8 } from "zod";
-var RefinerProposalRouteSchema = z8.enum(["memory", "prompt", "skill", "agent"]);
-var RefinerExternalRouteSchema = z8.enum(["runtime", "product", "taskset", "training"]);
-var RefinerReviewInstructionSchema = z8.object({
-  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  text: z8.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerReviewProfileSchema = z8.object({
-  schemaVersion: z8.literal("openpond.refinerReviewProfile.v1"),
-  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  version: z8.string().trim().min(1).max(120),
-  name: z8.string().trim().min(1).max(200),
-  objective: z8.string().trim().min(1).max(1e4),
-  instructions: z8.array(RefinerReviewInstructionSchema).max(100),
-  allowedProposalRoutes: z8.array(RefinerProposalRouteSchema).max(4),
-  allowedExternalRoutes: z8.array(RefinerExternalRouteSchema).max(4)
-}).strict().superRefine((profile, context) => {
-  const instructionIds = profile.instructions.map((instruction) => instruction.id);
-  if (new Set(instructionIds).size !== instructionIds.length) {
-    context.addIssue({ code: "custom", message: "instruction IDs must be unique", path: ["instructions"] });
-  }
-  if (new Set(profile.allowedProposalRoutes).size !== profile.allowedProposalRoutes.length) {
-    context.addIssue({ code: "custom", message: "proposal routes must be unique", path: ["allowedProposalRoutes"] });
-  }
-  if (new Set(profile.allowedExternalRoutes).size !== profile.allowedExternalRoutes.length) {
-    context.addIssue({ code: "custom", message: "external routes must be unique", path: ["allowedExternalRoutes"] });
-  }
-});
-var RefinerReleaseSchema = z8.object({
-  schemaVersion: z8.literal("openpond.refinerRelease.v1"),
-  id: z8.string().trim().min(1).max(240),
-  coreVersion: z8.string().trim().min(1).max(120),
-  coreHash: ReleaseHashSchema,
-  profile: RefinerReviewProfileSchema,
-  profileHash: ReleaseHashSchema,
-  composedPromptHash: ReleaseHashSchema,
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-var RefinerBindingSchema = z8.object({
-  schemaVersion: z8.literal("openpond.refinerBinding.v1"),
-  channel: z8.literal("active"),
-  revision: z8.number().int().nonnegative(),
-  release: ImmutableReleaseRefSchema,
-  updatedAt: ReleaseTimestampSchema
-}).strict();
-var RefinerTransitionReceiptSchema = z8.object({
-  schemaVersion: z8.literal("openpond.refinerTransitionReceipt.v1"),
-  id: z8.string().trim().min(1).max(240),
-  operation: z8.enum(["initialize", "update", "activate", "rollback"]),
-  bindingChanged: z8.boolean(),
-  previousRelease: ImmutableReleaseRefSchema.nullable(),
-  nextRelease: ImmutableReleaseRefSchema,
-  actor: z8.string().trim().min(1).max(240),
-  reason: z8.string().trim().min(1).max(1e4),
-  authoringSkillHash: ReleaseHashSchema.nullable(),
-  validation: z8.object({ valid: z8.boolean(), messages: z8.array(z8.string().max(2e3)).max(100) }).strict(),
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
-}).strict();
-
-// ../harness/dist/refiner.js
-var RefinerNoActionDecisionSchema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z9.literal("no_action"),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerExternalRouteDecisionSchema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z9.literal("route"),
-  route: z9.enum(["runtime", "product", "taskset", "training"]),
-  summary: z9.string().trim().min(1).max(2e3),
-  expectedOutcome: z9.string().trim().min(1).max(1e4),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerProposalDecisionSchema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z9.literal("propose"),
-  route: z9.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z9.enum(["create", "update", "delete"]),
-  target: z9.string().trim().min(1).max(2e3),
-  summary: z9.string().trim().min(1).max(2e3),
-  createContent: z9.string().min(1).max(2e4).nullable(),
-  find: z9.string().min(1).max(8e3).nullable(),
-  replace: z9.string().max(8e3).nullable(),
-  expectedOutcome: z9.string().trim().min(1).max(1e4),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strip().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
-    });
-  }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
-    });
-  }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
-    });
-  }
-});
-var LocalHarnessRefinerDecisionSchema = z9.discriminatedUnion("decision", [
-  RefinerNoActionDecisionSchema,
-  RefinerExternalRouteDecisionSchema,
-  RefinerProposalDecisionSchema
-]);
-var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
-var HarnessRefinerEvidenceBasisSchema = z9.object({
-  kind: z9.enum(["single_deterministic", "recurrent_independent"]),
-  supportingEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).min(1).max(100),
-  counterevidence: z9.array(z9.string().trim().min(1).max(2e3)).max(20)
-}).strict().superRefine((basis, context) => {
-  if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "supporting evidence IDs must be unique",
-      path: ["supportingEvidenceIds"]
-    });
-  }
-  if (basis.kind === "recurrent_independent" && basis.supportingEvidenceIds.length < 2) {
-    context.addIssue({
-      code: "custom",
-      message: "recurrent independent evidence requires at least two supplied incidents",
-      path: ["supportingEvidenceIds"]
-    });
-  }
-});
-var RefinerNoActionDecisionV2Schema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z9.literal("no_action"),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerExternalRouteDecisionV2Schema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z9.literal("route"),
-  route: z9.enum(["runtime", "product", "taskset", "training"]),
-  summary: z9.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  expectedOutcome: z9.string().trim().min(1).max(1e4),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerProposalDecisionV2Schema = z9.object({
-  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z9.literal("propose"),
-  route: z9.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z9.enum(["create", "update", "delete"]),
-  target: z9.string().trim().min(1).max(2e3),
-  summary: z9.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  createContent: z9.string().min(1).max(2e4).nullable(),
-  find: z9.string().min(1).max(8e3).nullable(),
-  replace: z9.string().max(8e3).nullable(),
-  expectedOutcome: z9.string().trim().min(1).max(1e4),
-  reason: z9.string().trim().min(1).max(1e4)
-}).strict().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
-    });
-  }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
-    });
-  }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
-    });
-  }
-});
-var LocalHarnessRefinerDecisionV2Schema = z9.discriminatedUnion("decision", [
-  RefinerNoActionDecisionV2Schema,
-  RefinerExternalRouteDecisionV2Schema,
-  RefinerProposalDecisionV2Schema
-]);
-var LocalHarnessRefinerDecisionAnySchema = z9.union([
-  LocalHarnessRefinerDecisionV1Schema,
-  LocalHarnessRefinerDecisionV2Schema
-]);
-var HarnessRefinerCapabilitiesSchema = z9.object({
-  memory: z9.boolean(),
-  prompt: z9.boolean(),
-  skill: z9.boolean(),
-  agent: z9.boolean()
-}).strict();
-var SourceKindSchema = z9.enum(["memory", "instruction", "skill", "agent"]);
-var RefinerSourceFileSchema = z9.object({
-  path: z9.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  content: z9.string().max(6e4),
-  loaded: z9.boolean()
-}).strict();
-var RefinerSourceCatalogEntrySchema = z9.object({
-  path: z9.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  loaded: z9.boolean()
-}).strict();
-var LocalHarnessRefinerEvidenceSchema = z9.object({
-  capabilities: HarnessRefinerCapabilitiesSchema,
-  trigger: z9.record(z9.string(), z9.unknown()),
-  observations: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
-  admissibleEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).max(1e4),
-  reviewPacket: z9.object({
-    currentTurn: z9.object({
-      id: z9.string().trim().min(1).max(2e3),
-      status: z9.string().trim().min(1).max(100).nullable(),
-      error: z9.string().max(2100).nullable(),
-      prompt: z9.string().max(8100).nullable(),
-      assistantOutput: z9.string().max(8100).nullable(),
-      assistantOutputLinkCount: z9.number().int().nonnegative()
-    }).strict(),
-    priorConversation: z9.array(z9.object({
-      turnId: z9.string().trim().min(1).max(2e3),
-      status: z9.string().trim().min(1).max(100).nullable(),
-      prompt: z9.string().max(3100).nullable(),
-      assistantOutput: z9.string().max(3100).nullable()
-    }).strict()).max(3),
-    timeline: z9.array(z9.record(z9.string(), z9.unknown())).max(60),
-    artifacts: z9.array(z9.record(z9.string(), z9.unknown())).max(30),
-    artifactDiagnostics: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
-    executionProfile: z9.object({
-      modelRequestCount: z9.number().int().nonnegative(),
-      failedModelRequestCount: z9.number().int().nonnegative(),
-      promptTokens: z9.number().int().nonnegative(),
-      completionTokens: z9.number().int().nonnegative(),
-      totalTokens: z9.number().int().nonnegative(),
-      toolFailureCount: z9.number().int().nonnegative(),
-      retryCount: z9.number().int().nonnegative(),
-      recoveryCount: z9.number().int().nonnegative()
-    }).strict(),
-    priorIncidents: z9.array(z9.record(z9.string(), z9.unknown())).max(3),
-    truncation: z9.object({
-      timelineEventCount: z9.number().int().nonnegative(),
-      includedTimelineEventCount: z9.number().int().nonnegative(),
-      timelineTruncated: z9.boolean()
-    }).strict()
-  }).strict(),
-  runtimeActivation: z9.object({
-    admittedRelease: ImmutableReleaseRefSchema,
-    currentRelease: ImmutableReleaseRefSchema,
-    rebasedOntoCurrent: z9.boolean(),
-    admittedSourceFiles: z9.array(RefinerSourceFileSchema).max(100),
-    admittedSourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3)
-  }).strict(),
-  sourceFiles: z9.array(RefinerSourceFileSchema).max(100),
-  sourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3),
-  additionalEvidence: z9.unknown().nullable().optional()
-}).strict();
-var OverlayRefSchema = z9.object({
-  id: z9.string().trim().min(1).max(240),
-  revision: z9.number().int().nonnegative(),
-  contentHash: ReleaseHashSchema
-}).strict();
-var HostedHarnessRefinerRequestSchema = z9.object({
-  schemaVersion: z9.literal("openpond.hostedHarnessRefinerRequest.v2"),
-  requestId: z9.string().trim().min(1).max(240),
-  idempotencyKey: z9.string().trim().min(1).max(240),
-  evidenceHash: ReleaseHashSchema,
-  harness: z9.object({
-    admittedRelease: ImmutableReleaseRefSchema,
-    currentRelease: ImmutableReleaseRefSchema,
-    overlay: OverlayRefSchema,
-    workspace: z9.object({
-      id: z9.string().trim().min(1).max(240),
-      revision: z9.number().int().nonnegative(),
-      sourceRevision: ReleaseHashSchema,
-      channelRevision: z9.number().int().nonnegative()
-    }).strict(),
-    capabilities: HarnessRefinerCapabilitiesSchema
-  }).strict(),
-  evidence: LocalHarnessRefinerEvidenceSchema
-}).strict();
-var HostedHarnessRefinerUsageSchema = z9.object({
-  promptTokens: z9.number().int().nonnegative(),
-  completionTokens: z9.number().int().nonnegative(),
-  totalTokens: z9.number().int().nonnegative()
-}).strict();
-var HostedHarnessRefinerResponseSchema = z9.object({
-  schemaVersion: z9.literal("openpond.hostedHarnessRefinerResponse.v2"),
-  requestId: z9.string().trim().min(1).max(240),
-  evidenceHash: ReleaseHashSchema,
-  admittedRelease: ImmutableReleaseRefSchema,
-  currentRelease: ImmutableReleaseRefSchema,
-  decision: LocalHarnessRefinerDecisionV2Schema,
-  serviceRevision: z9.string().trim().min(1).max(240),
-  usage: HostedHarnessRefinerUsageSchema
-}).strict();
-
-// ../harness/dist/refinement-lifecycle.js
-import { z as z10 } from "zod";
-var ShortTextSchema = z10.string().trim().min(1).max(2e3);
-var BoundedTextSchema4 = z10.string().trim().min(1).max(1e5);
-var HarnessRefinerOperationSchema = z10.enum(["create", "update", "delete"]);
-var HarnessRefinerInternalRouteSchema = z10.enum([
-  "memory",
-  "prompt",
-  "skill",
-  "agent"
-]);
-var HarnessRefinerExternalRouteSchema = z10.enum([
-  "runtime",
-  "product",
-  "taskset",
-  "training"
-]);
-var HarnessRefinerActivityResultSchema = z10.enum([
-  "no_action",
-  "routed",
-  "applied",
-  "retained",
-  "failed"
-]);
-var HarnessRefinerCritiqueStatusSchema = z10.enum([
-  "not_applicable",
-  "pending",
-  "passed",
-  "rejected",
-  "failed"
-]);
-var HarnessRefinerValidationStatusSchema = z10.enum([
-  "not_applicable",
-  "pending",
-  "passed",
-  "failed"
-]);
-var HarnessRefinerActivityReceiptContentSchema = z10.object({
-  schemaVersion: z10.literal("openpond.harnessRefinerActivityReceipt.v1"),
-  id: ReleaseIdSchema,
-  runRef: ReleaseIdSchema,
-  turnId: ReleaseIdSchema,
-  result: HarnessRefinerActivityResultSchema,
-  decision: z10.enum(["no_action", "route", "propose"]).nullable(),
-  route: HarnessImprovementRouteSchema.nullable(),
-  operation: HarnessRefinerOperationSchema.nullable(),
-  target: z10.string().trim().min(1).max(2e3).nullable(),
-  summary: ShortTextSchema,
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema.nullable(),
-  critiqueStatus: HarnessRefinerCritiqueStatusSchema,
-  validationStatus: HarnessRefinerValidationStatusSchema,
-  trigger: ImmutableReleaseRefSchema,
-  outcome: ImmutableReleaseRefSchema.nullable(),
-  proposal: ImmutableReleaseRefSchema.nullable(),
-  applyReceipt: ImmutableReleaseRefSchema.nullable(),
-  inputHarness: ImmutableReleaseRefSchema,
-  outputHarness: ImmutableReleaseRefSchema.nullable(),
-  createdAt: ReleaseTimestampSchema
-}).strict().superRefine((receipt, context) => {
-  const proposalResult = receipt.result === "applied" || receipt.result === "retained";
-  if (receipt.result === "no_action") {
-    requireFields(context, receipt, {
-      decision: "no_action",
-      route: null,
-      operation: null,
-      target: null,
-      evidenceBasis: null,
-      proposal: null,
-      applyReceipt: null,
-      outputHarness: null,
-      critiqueStatus: "not_applicable",
-      validationStatus: "not_applicable"
-    });
-  } else if (receipt.result === "routed") {
-    if (receipt.decision !== "route" || !HarnessRefinerExternalRouteSchema.safeParse(receipt.route).success || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis === null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
-      context.addIssue({
-        code: "custom",
-        message: "routed activity requires an external route and evidence basis without proposal state"
-      });
-    }
-    requireFields(context, receipt, {
-      critiqueStatus: "not_applicable",
-      validationStatus: "not_applicable"
-    });
-  } else if (proposalResult) {
-    if (receipt.decision !== "propose" || !HarnessRefinerInternalRouteSchema.safeParse(receipt.route).success || receipt.operation === null || receipt.target === null || receipt.evidenceBasis === null || receipt.proposal === null || receipt.applyReceipt === null) {
-      context.addIssue({
-        code: "custom",
-        message: "applied and retained activity requires complete proposal state"
-      });
-    }
-    if (receipt.result === "applied" && receipt.outputHarness === null) {
-      context.addIssue({
-        code: "custom",
-        message: "applied activity requires the advanced Harness release",
-        path: ["outputHarness"]
-      });
-    }
-    if (receipt.result === "applied" && (receipt.critiqueStatus !== "passed" || receipt.validationStatus !== "passed")) {
-      context.addIssue({
-        code: "custom",
-        message: "applied activity requires passed critique and validation"
-      });
-    }
-    if (receipt.result === "retained" && receipt.outputHarness !== null) {
-      context.addIssue({
-        code: "custom",
-        message: "retained activity cannot report a new Harness release",
-        path: ["outputHarness"]
-      });
-    }
-  } else if (receipt.decision !== null || receipt.route !== null || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis !== null || receipt.outcome !== null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
-    context.addIssue({
-      code: "custom",
-      message: "failed activity cannot claim a decision, route, proposal, or release transition"
-    });
-  }
-  if (receipt.result !== "failed" && receipt.outcome === null) {
-    context.addIssue({
-      code: "custom",
-      message: "terminal Refiner decisions require an outcome reference",
-      path: ["outcome"]
-    });
-  }
-});
-var HarnessRefinerActivityReceiptSchema = HarnessRefinerActivityReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessRefinementCandidateStatusSchema = z10.enum([
-  "unresolved",
-  "confirmed",
-  "resolved",
-  "rejected",
-  "expired"
-]);
-var HarnessRefinementCandidateResolutionSchema = z10.object({
-  kind: z10.enum([
-    "applied_change",
-    "later_success",
-    "manual_rejection",
-    "source_revoked",
-    "expired"
-  ]),
-  reason: BoundedTextSchema4,
-  evidenceRefs: z10.array(ImmutableReleaseRefSchema).max(1e3),
-  resolvedAt: ReleaseTimestampSchema
-}).strict();
-var HarnessRefinementCandidateContentSchema = z10.object({
-  schemaVersion: z10.literal("openpond.harnessRefinementCandidate.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  fingerprint: ReleaseHashSchema,
-  recurrenceFamily: z10.string().trim().min(1).max(1e3),
-  statement: BoundedTextSchema4,
-  status: HarnessRefinementCandidateStatusSchema,
-  occurrences: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  counterevidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  sourceReviews: z10.array(ImmutableReleaseRefSchema).min(1).max(100),
-  relatedHarnessReleases: z10.array(ImmutableReleaseRefSchema).max(100),
-  firstSeenAt: ReleaseTimestampSchema,
-  lastSeenAt: ReleaseTimestampSchema,
-  lastReviewedAt: ReleaseTimestampSchema,
-  expiresAt: ReleaseTimestampSchema,
-  resolution: HarnessRefinementCandidateResolutionSchema.nullable(),
-  createdAt: ReleaseTimestampSchema,
-  updatedAt: ReleaseTimestampSchema
-}).strict().superRefine((candidate, context) => {
-  requireUniqueRefs(context, candidate.occurrences, "occurrences");
-  requireUniqueRefs(context, candidate.counterevidence, "counterevidence");
-  requireUniqueRefs(context, candidate.sourceReviews, "sourceReviews");
-  requireUniqueRefs(context, candidate.relatedHarnessReleases, "relatedHarnessReleases");
-  const supportingKeys = new Set(candidate.occurrences.map((item) => item.occurrenceKey));
-  if (candidate.counterevidence.some((item) => supportingKeys.has(item.occurrenceKey))) {
-    context.addIssue({
-      code: "custom",
-      message: "supporting occurrences and counterevidence must be disjoint",
-      path: ["counterevidence"]
-    });
-  }
-  const actionable = candidate.status === "unresolved" || candidate.status === "confirmed";
-  if (actionable && candidate.occurrences.length === 0) {
-    context.addIssue({
-      code: "custom",
-      message: "actionable candidates require at least one supporting occurrence",
-      path: ["occurrences"]
-    });
-  }
-  if (actionable && [...candidate.occurrences, ...candidate.counterevidence].some((item) => item.sourcePolicy.state !== "authorized")) {
-    context.addIssue({
-      code: "custom",
-      message: "actionable candidates may contain only currently authorized evidence",
-      path: ["occurrences"]
-    });
-  }
-  if (actionable !== (candidate.resolution === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "only resolved, rejected, or expired candidates require a resolution",
-      path: ["resolution"]
-    });
-  }
-  if (candidate.status === "expired" && candidate.resolution?.kind !== "expired") {
-    context.addIssue({
-      code: "custom",
-      message: "expired candidates require an expired resolution",
-      path: ["resolution", "kind"]
-    });
-  }
-  if (candidate.status === "rejected" && candidate.resolution && !["manual_rejection", "source_revoked"].includes(candidate.resolution.kind)) {
-    context.addIssue({
-      code: "custom",
-      message: "rejected candidates require a rejection or revocation resolution",
-      path: ["resolution", "kind"]
-    });
-  }
-  if (candidate.status === "resolved" && candidate.resolution && !["applied_change", "later_success"].includes(candidate.resolution.kind)) {
-    context.addIssue({
-      code: "custom",
-      message: "resolved candidates require applied-change or later-success evidence",
-      path: ["resolution", "kind"]
-    });
-  }
-  requireChronology(context, candidate);
-});
-var HarnessRefinementCandidateSchema = HarnessRefinementCandidateContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessRefinementCandidateLifecycleDecisionSchema = z10.enum([
-  "created",
-  "merged",
-  "rejected",
-  "expired",
-  "reopened",
-  "resolved"
-]);
-var HarnessRefinementCandidateLifecycleReceiptContentSchema = z10.object({
-  schemaVersion: z10.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
-  id: ReleaseIdSchema,
-  candidateId: ReleaseIdSchema,
-  decision: HarnessRefinementCandidateLifecycleDecisionSchema,
-  beforeCandidate: ImmutableReleaseRefSchema.nullable(),
-  afterCandidate: ImmutableReleaseRefSchema,
-  review: ImmutableReleaseRefSchema,
-  addedEvidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
-  removedEvidence: z10.array(ImmutableReleaseRefSchema).max(1e3),
-  reason: BoundedTextSchema4,
-  createdAt: ReleaseTimestampSchema
-}).strict().superRefine((receipt, context) => {
-  if (receipt.decision === "created" !== (receipt.beforeCandidate === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "only candidate creation omits the previous candidate reference",
-      path: ["beforeCandidate"]
-    });
-  }
-  if (receipt.beforeCandidate && receipt.beforeCandidate.contentHash === receipt.afterCandidate.contentHash) {
-    context.addIssue({
-      code: "custom",
-      message: "candidate lifecycle transitions must change candidate content",
-      path: ["afterCandidate"]
-    });
-  }
-  if (["created", "reopened"].includes(receipt.decision) && receipt.addedEvidence.length === 0) {
-    context.addIssue({
-      code: "custom",
-      message: `${receipt.decision} candidate transitions require added evidence`,
-      path: ["addedEvidence"]
-    });
-  }
-  if (receipt.addedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
-    context.addIssue({
-      code: "custom",
-      message: "candidate transitions may add only authorized evidence",
-      path: ["addedEvidence"]
-    });
-  }
-  requireUniqueRefs(context, receipt.addedEvidence, "addedEvidence");
-  requireUniqueRefs(context, receipt.removedEvidence, "removedEvidence");
-  const removedKeys = new Set(receipt.removedEvidence.map((item) => refKey(item)));
-  if (receipt.addedEvidence.some((item) => removedKeys.has(refKey(item.evidence)))) {
-    context.addIssue({
-      code: "custom",
-      message: "candidate lifecycle evidence cannot be added and removed together",
-      path: ["removedEvidence"]
-    });
-  }
-});
-var HarnessRefinementCandidateLifecycleReceiptSchema = HarnessRefinementCandidateLifecycleReceiptContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-var HarnessCrossRunRefinementRequestContentSchema = z10.object({
-  schemaVersion: z10.literal("openpond.harnessCrossRunRefinementRequest.v1"),
-  id: ReleaseIdSchema,
-  ownerScope: HarnessReviewOwnerScopeSchema,
-  workspaceRef: ReleaseIdSchema,
-  candidate: ImmutableReleaseRefSchema,
-  candidateFingerprint: ReleaseHashSchema,
-  review: ImmutableReleaseRefSchema,
-  admittedHarness: ImmutableReleaseRefSchema,
-  evidence: z10.array(HarnessReviewEvidenceRefSchema).min(1).max(1e3),
-  capabilities: HarnessRefinerCapabilitiesSchema,
-  deduplicationKey: ReleaseHashSchema,
-  createdAt: ReleaseTimestampSchema
-}).strict().superRefine((request, context) => {
-  if (request.evidence.some((item) => item.sourcePolicy.state !== "authorized")) {
-    context.addIssue({
-      code: "custom",
-      message: "cross-run refinement requires currently authorized evidence",
-      path: ["evidence"]
-    });
-  }
-  requireUniqueRefs(context, request.evidence, "evidence");
-  if (!Object.values(request.capabilities).some(Boolean)) {
-    context.addIssue({
-      code: "custom",
-      message: "cross-run refinement requires at least one available Harness capability",
-      path: ["capabilities"]
-    });
-  }
-  const expected = harnessCrossRunRefinementDeduplicationKey(request);
-  if (request.deduplicationKey !== expected) {
-    context.addIssue({
-      code: "custom",
-      message: `cross-run refinement deduplicationKey is ${request.deduplicationKey}; expected ${expected}`,
-      path: ["deduplicationKey"]
-    });
-  }
-});
-var HarnessCrossRunRefinementRequestSchema = HarnessCrossRunRefinementRequestContentSchema.extend({
-  contentHash: ReleaseHashSchema
-}).strict();
-function harnessCrossRunRefinementDeduplicationKey(input) {
-  return contentHash({
-    schemaVersion: "openpond.harnessCrossRunRefinementIdentity.v1",
-    workspaceRef: input.workspaceRef,
-    candidateFingerprint: input.candidateFingerprint,
-    admittedHarness: input.admittedHarness
-  });
-}
-function requireFields(context, value, expected) {
-  for (const [key, expectedValue] of Object.entries(expected)) {
-    if (value[key] === expectedValue)
-      continue;
-    context.addIssue({
-      code: "custom",
-      message: `${key} must be ${String(expectedValue)}`,
-      path: [key]
-    });
-  }
-}
-function requireUniqueRefs(context, values, path) {
-  const keys = values.map((value) => refKey(value));
-  if (new Set(keys).size === keys.length)
-    return;
-  context.addIssue({
-    code: "custom",
-    message: `${path} references must be unique`,
-    path: [path]
-  });
-}
-function refKey(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return String(value);
-  const record = value;
-  if (typeof record.occurrenceKey === "string")
-    return record.occurrenceKey;
-  const nested = record.evidence;
-  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-    const evidence = nested;
-    return `${String(evidence.id)}:${String(evidence.contentHash)}`;
-  }
-  return `${String(record.id)}:${String(record.contentHash)}`;
-}
-function requireChronology(context, candidate) {
-  const chronology = [
-    ["firstSeenAt", candidate.firstSeenAt],
-    ["lastSeenAt", candidate.lastSeenAt],
-    ["lastReviewedAt", candidate.lastReviewedAt],
-    ["updatedAt", candidate.updatedAt],
-    ["expiresAt", candidate.expiresAt]
-  ];
-  for (let index = 1; index < chronology.length; index += 1) {
-    const previous = chronology[index - 1];
-    const current = chronology[index];
-    if (Date.parse(previous[1]) <= Date.parse(current[1]))
-      continue;
-    context.addIssue({
-      code: "custom",
-      message: `${current[0]} must not precede ${previous[0]}`,
-      path: [current[0]]
-    });
-  }
-  if (Date.parse(candidate.createdAt) > Date.parse(candidate.updatedAt)) {
-    context.addIssue({
-      code: "custom",
-      message: "updatedAt must not precede createdAt",
-      path: ["updatedAt"]
-    });
-  }
-}
-
-// src/taskset-package-contracts.ts
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema3, VerifierSetReleaseSchema as VerifierSetReleaseSchema3, verifyEnvironmentRelease as verifyEnvironmentRelease3, verifyVerifierSetRelease as verifyVerifierSetRelease3 } from "@openpond/evals";
-import { assertTasksetRelease as assertTasksetRelease2, TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
-import { assertBoundedTaskJson as assertBoundedTaskJson3 } from "@openpond/evals/task-schema";
-
-// src/model-taskset-derivation.ts
-import { z as z14 } from "zod";
-import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
-import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
-import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
-import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
-import { validateTaskValue } from "@openpond/evals/task-schema";
-
-// src/model-projects.ts
-import { z as z11 } from "zod";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-
-// src/protocol.ts
-var OpenPondProtocolError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "OpenPondProtocolError";
-    this.code = code;
-  }
-};
-function canonicalJson2(value) {
-  return JSON.stringify(normalizeCanonicalJson(value));
-}
-function normalizeCanonicalJson(value) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON cannot contain a non-finite number."
-      );
-    }
-    return Object.is(value, -0) ? 0 : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeCanonicalJson(entry));
-  }
-  if (typeof value === "object") {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON accepts only plain objects."
-      );
-    }
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") {
-        throw new OpenPondProtocolError(
-          "non_json_value",
-          `Canonical JSON cannot contain ${typeof entry} at ${key}.`
-        );
-      }
-      result[key] = normalizeCanonicalJson(entry);
-    }
-    return result;
-  }
-  throw new OpenPondProtocolError(
-    "non_json_value",
-    `Canonical JSON cannot contain ${typeof value}.`
-  );
-}
-
-// src/model-projects.ts
-var IdSchema = z11.string().trim().min(1).max(500);
-var HashSchema = z11.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z11.string().datetime({ offset: true });
-var ModelProjectImmutableRefSchema = z11.object({
-  id: IdSchema,
-  contentHash: HashSchema
-}).strict();
-var ModelProjectVersionedRefSchema = ModelProjectImmutableRefSchema.extend({
-  revision: z11.number().int().positive()
-}).strict();
-var ModelProjectBaseModelSchema = z11.object({
-  schemaVersion: z11.literal("openpond.baseModelPreference.v1"),
-  modelId: IdSchema,
-  revision: z11.string().trim().min(1).max(256).nullable(),
-  tokenizerRevision: z11.string().trim().min(1).max(256).nullable(),
-  chatTemplateHash: z11.string().trim().min(8).max(256).nullable(),
-  modelAssetId: IdSchema.nullable(),
-  source: z11.enum(["managed", "local", "builtin"])
-}).strict();
-var ModelProjectTrainingMethodSchema = z11.enum([
-  "sft",
-  "dpo",
-  "grpo",
-  "ppo",
-  "sdft",
-  "opd",
-  "opsd",
-  "sdpo"
-]);
-var ModelProjectRecipeDocumentSchema = z11.object({
-  schemaVersion: z11.string().regex(/^openpond\.[A-Za-z0-9]+Recipe\.v\d+$/),
-  method: ModelProjectTrainingMethodSchema,
-  parameterization: z11.enum(["lora", "full"])
-}).catchall(z11.unknown());
-var ModelProjectTrainingSetupSchema = z11.object({
-  tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),
-  rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),
-  tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  baseModel: ModelProjectBaseModelSchema.nullable().default(null),
-  method: ModelProjectTrainingMethodSchema.nullable().default(null),
-  destinationId: IdSchema.nullable().default(null),
-  managedRolloutPlacement: z11.enum(["local", "remote"]).default("remote"),
-  managedGpuPlacementObjective: z11.enum(["fast", "balanced", "economical"]).default("balanced"),
-  managedGpuRequirement: z11.enum(["any", "h100_hbm3"]).default("any"),
-  runPreset: z11.enum(["small", "standard", "custom", "small_experiment"]).nullable().default(null),
-  recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),
-  preferredMaximumSpendUsd: z11.number().nonnegative().nullable().default(null),
-  preferredRetentionDays: z11.number().int().nonnegative().nullable().default(null)
-}).strict();
-var HostedModelProjectTrainingSetupSchema = ModelProjectTrainingSetupSchema.omit({ managedGpuRequirement: true });
-var HostedModelProjectLinkSchema = z11.object({
-  schemaVersion: z11.literal("openpond.hostedModelProjectLink.v1"),
-  apiOrigin: z11.string().url().refine((value) => new URL(value).origin === value, "Use a canonical API origin.").nullable().default(null),
-  teamId: IdSchema,
-  projectId: IdSchema,
-  portableProjectId: IdSchema,
-  revision: z11.number().int().positive(),
-  etag: HashSchema,
-  syncedSourceRevision: z11.number().int().positive(),
-  syncedAt: TimestampSchema,
-  tasksets: z11.array(
-    z11.object({
-      localTasksetId: IdSchema,
-      localTasksetHash: HashSchema.nullable().default(null),
-      releaseId: IdSchema,
-      releaseRevision: z11.number().int().positive(),
-      releaseHash: HashSchema,
-      packageHash: HashSchema.nullable().default(null),
-      hostedTasksetId: IdSchema,
-      syncedAt: TimestampSchema
-    }).strict()
-  ).max(1e4).default([])
-}).strict();
-var ModelProjectTasksetSyncSchema = z11.object({
-  localTasksetId: IdSchema,
-  releaseId: IdSchema,
-  releaseRevision: z11.number().int().positive(),
-  releaseHash: HashSchema,
-  state: z11.enum(["syncing", "synced", "sync_failed"]),
-  hostedTasksetId: IdSchema.nullable().default(null),
-  lastAttemptAt: TimestampSchema,
-  syncedAt: TimestampSchema.nullable().default(null),
-  lastError: z11.string().trim().min(1).max(5e3).nullable().default(null)
-}).strict();
-var ModelProjectSchema = z11.object({
-  schemaVersion: z11.literal("openpond.modelProject.v2"),
-  id: IdSchema,
-  profileId: IdSchema,
-  revision: z11.number().int().positive().default(1),
-  name: z11.string().trim().min(1).max(200),
-  objective: z11.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: ModelProjectTrainingSetupSchema,
-  hosted: HostedModelProjectLinkSchema.nullable().default(null),
-  tasksetSyncs: z11.array(ModelProjectTasksetSyncSchema).max(1e4).default([]),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectEditableSchema = ModelProjectSchema.pick({
-  id: true,
-  profileId: true,
-  name: true,
-  objective: true,
-  defaultBaseModel: true,
-  defaultDestinationId: true,
-  trainingSetup: true
-});
-var ModelProjectSaveRequestSchema = z11.object({
-  schemaVersion: z11.literal("openpond.modelProjectSave.v1"),
-  operationId: IdSchema,
-  expectedRevision: z11.number().int().nonnegative(),
-  project: ModelProjectEditableSchema
-}).strict();
-var ModelProjectConfigurationCheckSchema = z11.object({
-  schemaVersion: z11.literal("openpond.modelProjectConfigurationCheck.v1"),
-  configurationHash: HashSchema,
-  projectId: IdSchema,
-  expectedRevision: z11.number().int().nonnegative(),
-  checkedAt: TimestampSchema,
-  canSave: z11.boolean(),
-  deferred: z11.array(z11.enum(["base_model", "taskset"])).max(2),
-  findings: z11.array(z11.object({
-    code: IdSchema,
-    severity: z11.enum(["error", "warning"]),
-    message: z11.string().min(1).max(5e3),
-    field: z11.string().min(1).max(500).nullable()
-  }).strict()).max(100)
-}).strict();
-var ModelProjectBaseModelCandidateSchema = z11.object({
-  id: IdSchema,
-  name: z11.string().min(1).max(500),
-  available: z11.boolean(),
-  preference: ModelProjectBaseModelSchema
-}).strict();
-var HostedModelProjectSyncSchema = z11.object({
-  schemaVersion: z11.literal("openpond.hostedModelProjectSync.v2"),
-  portableProjectId: IdSchema,
-  name: z11.string().trim().min(1).max(200),
-  objective: z11.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z11.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  expectedEtag: HashSchema.nullable().default(null)
-}).strict();
-var HostedModelProjectSummarySchema = z11.object({
-  id: IdSchema,
-  teamId: IdSchema,
-  portableProjectId: IdSchema,
-  name: z11.string().trim().min(1).max(200),
-  objective: z11.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z11.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  revision: z11.number().int().positive(),
-  etag: HashSchema,
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectResourceSummarySchema = z11.object({
-  kind: z11.enum([
-    "taskset_release",
-    "harness_release",
-    "dataset_release",
-    "evidence_set",
-    "model_version",
-    "reward_model_version",
-    "evaluation_receipt"
-  ]),
-  ref: ModelProjectImmutableRefSchema,
-  role: z11.string().trim().min(1).max(200).nullable().default(null),
-  updatedAt: TimestampSchema
-}).strict();
-var HostedModelProjectDetailSchema = z11.object({
-  project: HostedModelProjectSummarySchema,
-  resources: z11.array(ModelProjectResourceSummarySchema).max(1e4),
-  jobCount: z11.number().int().nonnegative(),
-  latestJobIds: z11.array(IdSchema).max(100)
-}).strict();
-var ModelProjectApiErrorSchema = z11.object({
-  schemaVersion: z11.literal("openpond.modelProjectApiError.v2"),
-  code: z11.string().trim().min(1).max(200),
-  message: z11.string().trim().min(1).max(5e3),
-  retryable: z11.boolean().default(false),
-  requestId: z11.string().trim().min(1).max(500).nullable().default(null),
-  details: z11.record(z11.string(), z11.unknown()).default({})
-}).strict();
-
-// src/model-starter-execution.ts
-import { z as z12 } from "zod";
-import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
-import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment";
-import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
-import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
-var HashSchema2 = z12.string().regex(/^[a-f0-9]{64}$/);
-var ModelStarterEnvironmentAttemptSchema = z12.object({
-  schemaVersion: z12.literal("openpond.javascriptEnvironmentAttempt.v1"),
-  taskId: z12.string(),
-  status: z12.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
-  output: z12.string().nullable(),
-  collected: z12.boolean(),
-  environmentCleanupComplete: z12.boolean(),
-  snapshot: z12.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema2, seed: z12.number().int(), initialStateHash: HashSchema2, finalStateHash: HashSchema2, state: z12.record(z12.string(), z12.unknown()), events: z12.array(z12.record(z12.string(), z12.unknown())) }).strict().nullable(),
-  messages: z12.array(z12.unknown()),
-  error: z12.string().nullable(),
-  contentHash: HashSchema2
-}).strict();
-var ModelStarterExecutionSchema = z12.object({
-  environment: EnvironmentReleaseSchema,
-  verifierSet: VerifierSetReleaseSchema,
-  javascript: JavaScriptEnvironmentDefinitionSchema
-}).strict();
-var ModelStarterToolFixtureScriptSchema = z12.object({
-  actions: z12.array(z12.object({ name: z12.string().min(1).max(64), arguments: z12.record(z12.string(), z12.unknown()) }).strict()).max(1e3)
-}).strict();
-function modelStarterExecutionAssetId(context) {
-  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
-  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
-}
-function createModelStarterExecutionAsset(value) {
-  const execution = ModelStarterExecutionSchema.parse(value);
-  assertExecutionIntegrity(execution);
-  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });
-  const generated = createLearningTextAsset({ text: canonicalJson2(execution), path: "environment/execution.json", mediaType: "application/json", visibility: "host_private" });
-  const { contentHash: _hash, ...content } = generated;
-  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });
-}
-function equal(left, right) {
-  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
-}
-function assertExecutionIntegrity(execution) {
-  assertJavaScriptEnvironmentDefinition(execution.javascript);
-  for (const resource of [execution.environment, execution.verifierSet]) {
-    const { contentHash: contentHash2, ...content } = resource;
-    if (sealLearningContent(content).contentHash !== contentHash2) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);
-  }
-  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error("Starter execution resources differ from its declared task context.");
-}
-function validateModelStarterExecution(execution, taskset, assets) {
-  if (!execution) {
-    if (taskset.environment.entrypoint === "openpond.javascript-environment.v1") throw new Error("Starter JavaScript execution resources are missing.");
-    return;
-  }
-  const { environment, verifierSet, javascript } = execution;
-  assertExecutionIntegrity(execution);
-  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) || !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {
-    throw new Error("Starter execution resources differ from its declared task context.");
-  }
-  const contract = environment.contract;
-  if (contract.entrypoint !== "openpond.javascript-environment.v1" || contract.kind !== "agent" || !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== "none" || new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {
-    throw new Error("Starter JavaScript environment declares unsupported host capabilities.");
-  }
-  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    const asset = assets.find((asset2) => asset2.id === task.privilegedContextRef);
-    if (!asset || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") {
-      throw new Error(`Starter private initial state is missing: ${task.id}.`);
-    }
-    const state = JSON.parse(verifyLearningTextAsset(asset, asset.asset));
-    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);
-    assertBoundedTaskJson2(state, javascript.maxStateBytes);
-  }
-}
-
-// src/model-taskset-resources.ts
-import { z as z13 } from "zod";
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
-import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
-var ModelTasksetExecutionResourcesSchema = z13.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
-
-// src/model-taskset-derivation.ts
-var OwnerSchema = z14.object({ scopeId: z14.string().trim().min(1).max(500), modelId: z14.string().trim().min(1).max(500) }).strict();
-var ModelTasksetDerivationSchema = z14.object({
-  schemaVersion: z14.literal("openpond.modelTasksetDerivation.v1"),
-  owner: OwnerSchema,
-  root: ModelProjectVersionedRefSchema,
-  parent: ModelProjectVersionedRefSchema
-}).strict();
-var ModelTasksetPackageSchema = z14.object({
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z14.array(RewardReleaseSchema).min(1).max(100),
-  assets: z14.array(LearningTextAssetSchema).max(1e3),
-  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
-  execution: ModelStarterExecutionSchema.optional()
-}).strict();
-var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
-function validateModelTasksetPackage(value) {
-  const result = ModelTasksetPackageSchema.parse(value);
-  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;
-  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);
-  assertTasksetRelease(taskset);
-  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
-  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset definition differs from its Reward binding.");
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
-  if (!same(taskDefinition.execution, { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} })) throw new Error("Taskset definition differs from its execution resources.");
-  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error("Taskset graders differ from its Reward binding.");
-  if (taskset.metadata.starter !== void 0) {
-    const metadata = z14.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
-    if (!sameLearningRef(metadata.taskDefinition, learningRef2(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset metadata differs from its immutable grading resources.");
-  }
-  if (taskset.metadata.rewardExecution !== void 0 && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error("Taskset embedded Rewards differ from its immutable grading resources.");
-  if (taskset.metadata.rewardBinding !== void 0 && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef2(rewardBinding))) throw new Error("Taskset Reward reference differs from its immutable grading resources.");
-  const resources = result.executionResources ?? execution;
-  if (taskset.environmentRelease && !resources) throw new Error("Deriving a Taskset requires its pinned execution resources.");
-  if (resources && (!verifyEnvironmentRelease2(resources.environment) || !verifyVerifierSetRelease2(resources.verifierSet) || !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) || !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) || !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error("Taskset differs from its pinned execution resources.");
-  validateModelStarterExecution(execution, taskset, assets);
-  if (new Set(assets.map((asset) => asset.id)).size !== assets.length) throw new Error("Taskset asset identities must be unique.");
-  for (const asset of assets) verifyLearningTextAsset3(asset, asset.asset);
-  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset3(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    if (task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid || task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);
-    if (task.privilegedContextRef && !assets.some((asset) => asset.id === task.privilegedContextRef && asset.asset.visibility === "host_private")) throw new Error(`Taskset private context is missing: ${task.id}.`);
-  }
-  for (const reward of rewards) {
-    const implementation = reward.implementation;
-    const references = [...reward.assets, ..."verifierRef" in implementation ? [implementation.verifierRef] : [], ..."rubricRef" in implementation ? [implementation.rubricRef] : [], ..."inputContract" in implementation ? [implementation.inputContract] : []];
-    for (const reference of references) {
-      const asset = assets.find((asset2) => asset2.id === reference.id);
-      if (!asset || reference.visibility === "policy") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);
-      verifyLearningTextAsset3(asset, reference);
-    }
-  }
-  return result;
-}
-
-// src/taskset-package-contracts.ts
-import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
-
-// src/taskset-package-learning.ts
-import { z as z16 } from "zod";
 import {
-  TaskBatchSchema,
-  TaskEvidenceSchema,
-  TaskAdmissionDecisionSchema,
-  LearningSourceSchema,
-  LearningTextAssetSchema as LearningTextAssetSchema2,
-  assertLearningContentHash as assertLearningContentHash2,
-  compileTaskBatch,
-  learningRef as learningRef3,
-  sameLearningRef as sameLearningRef2,
-  taskBatchPackageMetadata,
-  verifyLearningTextAsset as verifyLearningTextAsset4
-} from "@openpond/evals/learning";
-
-// src/training.ts
-import { z as z15 } from "zod";
-var IdSchema2 = z15.string().trim().min(1).max(500);
-var HashSchema3 = z15.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema2 = z15.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z15.string().trim().min(1).max(500),
-  sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z15.unknown(),
-  contentHash: HashSchema3
-}).strict();
-var TrainingInputArtifactSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingInputArtifact.v2"),
-  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
-  sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z15.string().trim().min(1).max(2e3),
-  contentHash: HashSchema3,
-  sizeBytes: z15.number().int().positive(),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingJobKindSchema = z15.enum([
-  "reward_model_train",
-  "policy_optimize"
-]);
-var TrainingJobStateSchema = z15.enum([
-  "queued",
-  "admitting",
-  "provisioning",
-  "running",
-  "stopping",
-  "cancelling",
-  "succeeded",
-  "failed",
-  "cancelled"
-]);
-var TrainingCapabilityRequirementSchema = z15.object({
-  id: IdSchema2,
-  version: z15.string().trim().min(1).max(200).nullable().default(null),
-  required: z15.boolean().default(true)
-}).strict();
-var TrainingJobSourceSchema = z15.object({
-  modelProject: z15.object({
-    id: IdSchema2,
-    portableProjectId: IdSchema2,
-    revision: z15.number().int().positive(),
-    contentHash: HashSchema3
-  }).strict(),
-  harnessRunManifest: ModelProjectImmutableRefSchema,
-  harnessRelease: ModelProjectImmutableRefSchema,
-  taskset: ModelProjectVersionedRefSchema,
-  tasksetRelease: ModelProjectImmutableRefSchema,
-  dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z15.array(ModelProjectImmutableRefSchema).max(1e4)
-}).strict();
-var RewardModelTrainingRequestSchema = z15.object({
-  kind: z15.literal("reward_model_train"),
-  baseModel: ModelProjectBaseModelSchema,
-  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
-  processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z15.object({
-    schemaVersion: z15.literal("openpond.rewardModelRecipe.v1"),
-    method: z15.literal("reward_model"),
-    parameterization: z15.literal("lora_with_scalar_head")
-  }).catchall(z15.unknown())
-}).strict();
-var DeterministicRewardSourceSchema = z15.object({
-  kind: z15.literal("deterministic"),
-  grader: ModelProjectImmutableRefSchema,
-  composer: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var LearnedRewardSourceSchema = z15.object({
-  kind: z15.literal("learned_reward"),
-  rewardModelVersion: ModelProjectImmutableRefSchema,
-  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z15.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z15.object({
-    artifactRef: z15.string().trim().min(1).max(2e3),
-    contentHash: HashSchema3,
-    executionReceipt: ModelProjectImmutableRefSchema
-  }).strict(),
-  processorRelease: ModelProjectImmutableRefSchema,
-  rewardComposerRelease: ModelProjectImmutableRefSchema
-}).strict();
-var PolicyOptimizationRequestSchema = z15.object({
-  kind: z15.literal("policy_optimize"),
-  baseModel: ModelProjectBaseModelSchema,
-  recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z15.discriminatedUnion("kind", [
-    DeterministicRewardSourceSchema,
-    LearnedRewardSourceSchema
-  ]),
-  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var TrainingJobRequestSchema = z15.discriminatedUnion("kind", [
-  RewardModelTrainingRequestSchema,
-  PolicyOptimizationRequestSchema
-]);
-var TrainingJobApprovalSchema = z15.object({
-  approvalHash: HashSchema3,
-  approvedAt: TimestampSchema2,
-  exportApproved: z15.boolean(),
-  maximumSpendUsd: z15.number().nonnegative(),
-  retentionDays: z15.number().int().nonnegative().nullable(),
-  region: z15.string().trim().min(1).max(200).nullable().default(null)
-}).strict();
-var TrainingJobSubmissionSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z15.string().trim().min(1).max(500),
-  name: z15.string().trim().min(1).max(200),
-  source: TrainingJobSourceSchema,
-  job: TrainingJobRequestSchema,
-  requestedCapabilities: z15.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z15.enum(["fast", "balanced", "economical"]),
-  budget: z15.object({
-    maximumSpendUsd: z15.number().nonnegative(),
-    maximumWallSeconds: z15.number().int().positive()
-  }).strict(),
-  approval: TrainingJobApprovalSchema,
-  contentHash: HashSchema3
-}).strict().superRefine((submission, context) => {
-  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
-    context.addIssue({
-      code: "custom",
-      path: ["approval", "maximumSpendUsd"],
-      message: "Approved spend must equal the immutable Job budget."
-    });
-  }
-});
-var TrainingJobSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJob.v2"),
-  id: IdSchema2,
-  teamId: IdSchema2,
-  kind: TrainingJobKindSchema,
-  modelProjectId: IdSchema2,
-  portableProjectId: IdSchema2,
-  sourceProjectRevision: z15.number().int().positive(),
-  submissionHash: HashSchema3,
-  state: TrainingJobStateSchema,
-  phase: z15.string().trim().min(1).max(200),
-  version: z15.number().int().nonnegative(),
-  progress: z15.number().min(0).max(1),
-  rolloutProgress: z15.object({
-    groupsCompleted: z15.number().int().nonnegative(),
-    groupsTarget: z15.number().int().nonnegative(),
-    optimizerUpdatesApplied: z15.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z15.number().int().nonnegative()
-  }).strict(),
-  accruedSpendUsd: z15.number().nonnegative(),
-  terminalReason: z15.string().trim().min(1).max(5e3).nullable(),
-  createdAt: TimestampSchema2,
-  updatedAt: TimestampSchema2,
-  completedAt: TimestampSchema2.nullable()
-}).strict();
-var TrainingJobPageSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobPage.v2"),
-  jobs: z15.array(TrainingJobSchema).max(1e3),
-  nextCursor: z15.string().trim().min(1).max(2e3).nullable()
-}).strict();
-var TrainingJobEventSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobEvent.v2"),
-  id: IdSchema2,
-  jobId: IdSchema2,
-  sequence: z15.number().int().nonnegative(),
-  type: IdSchema2,
-  phase: z15.string().trim().min(1).max(200),
-  message: z15.string().trim().min(1).max(5e3).nullable(),
-  data: z15.record(z15.string(), z15.unknown()).default({}),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingJobLogSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobLog.v2"),
-  jobId: IdSchema2,
-  sequence: z15.number().int().nonnegative(),
-  level: z15.enum(["debug", "info", "warning", "error"]),
-  message: z15.string().max(2e4),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingJobControlRequestSchema = z15.object({ expectedVersion: z15.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobOutput.v2"),
-  id: IdSchema2,
-  jobId: IdSchema2,
-  kind: z15.enum([
-    "checkpoint",
-    "adapter",
-    "scorer",
-    "metrics",
-    "evaluation",
-    "trace",
-    "receipt"
-  ]),
-  artifactRef: z15.string().trim().min(1).max(2e3),
-  contentHash: HashSchema3,
-  sizeBytes: z15.number().int().nonnegative(),
-  metadata: z15.record(z15.string(), z15.unknown()).default({}),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingExecutionReceiptSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingExecutionReceipt.v2"),
-  id: IdSchema2,
-  teamId: IdSchema2,
-  jobId: IdSchema2,
-  submissionHash: HashSchema3,
-  manifestHash: HashSchema3,
-  recipeHash: HashSchema3,
-  capabilityHash: HashSchema3,
-  runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z15.number().nonnegative(),
-  durationSeconds: z15.number().nonnegative(),
-  cleanupComplete: z15.boolean(),
-  issuer: IdSchema2,
-  issuedAt: TimestampSchema2,
-  signature: z15.string().trim().min(1).max(1e4).nullable()
-}).strict();
-var TrainingJobOutputsSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z15.array(TrainingJobOutputSchema).max(1e4),
-  receipt: TrainingExecutionReceiptSchema.nullable()
-}).strict();
-var TrainingApiErrorSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingApiError.v2"),
-  code: z15.string().trim().min(1).max(200),
-  message: z15.string().trim().min(1).max(5e3),
-  retryable: z15.boolean().default(false),
-  requestId: z15.string().trim().min(1).max(500).nullable().default(null),
-  details: z15.record(z15.string(), z15.unknown()).default({})
-}).strict();
-var TrainingCapabilitiesSchema = z15.object({
-  schemaVersion: z15.literal("openpond.trainingCapabilities.v2"),
-  capabilityHash: HashSchema3,
-  jobKinds: z15.array(TrainingJobKindSchema),
-  methods: z15.array(z15.string().trim().min(1).max(200)),
-  placements: z15.array(
-    z15.enum(["local", "remote", "colocated", "provider_native"])
-  ),
-  controls: z15.object({
-    cancel: z15.boolean(),
-    stopAfterGroup: z15.boolean(),
-    resumeFromCheckpoint: z15.boolean()
-  }).strict(),
-  limits: z15.object({
-    maximumSpendUsd: z15.number().nonnegative(),
-    maximumWallSeconds: z15.number().int().positive(),
-    maximumArtifactBytes: z15.number().int().positive()
-  }).strict(),
-  checkedAt: TimestampSchema2,
-  expiresAt: TimestampSchema2
-}).strict();
-
-// src/taskset-package-learning.ts
-var TasksetPackageLearningResourcesSchema = z16.object({
-  batch: TaskBatchSchema,
-  evidence: z16.array(TaskEvidenceSchema).min(1).max(1e4),
-  decisions: z16.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
-  sources: z16.array(LearningSourceSchema).min(1).max(1e4),
-  assets: z16.array(LearningTextAssetSchema2).max(1e3)
-}).strict();
-function learningPackageContextFiles(resources) {
-  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
-    const text = canonicalJson2(evidence.submission.evaluatorContext);
-    const bytes = new TextEncoder().encode(text);
-    return {
-      asset: {
-        id: `task-evidence:${evidence.contentHash}`,
-        path: `learning/context/${evidence.contentHash}.json`,
-        contentHash: sha256(bytes),
-        sizeBytes: bytes.byteLength,
-        mediaType: "application/json",
-        visibility: "host_private"
-      },
-      base64: btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
-    };
-  });
-}
-function validateTasksetLearningResources(taskset, input) {
-  const resources = TasksetPackageLearningResourcesSchema.parse(input);
-  const metadata = taskBatchPackageMetadata(taskset);
-  if (!sameLearningRef2(learningRef3(resources.batch), metadata.batch)) throw new Error("Taskset learning batch differs from its admission metadata.");
-  for (const collection of [resources.evidence, resources.decisions, resources.sources, resources.assets]) {
-    const identities = /* @__PURE__ */ new Set();
-    for (const resource of collection) {
-      assertLearningContentHash2(resource);
-      const key = `${resource.id}:${resource.revision}`;
-      if (identities.has(key)) throw new Error("Taskset learning resource identities must be unique.");
-      identities.add(key);
-    }
-  }
-  if (resources.evidence.length !== resources.batch.examples.length || resources.decisions.length !== resources.batch.examples.length) throw new Error("Taskset learning snapshots must match the admitted batch inventory.");
-  for (const evidence of resources.evidence) {
-    const source = resources.sources.find((source2) => sameLearningRef2(learningRef3(source2), evidence.source));
-    if (!source || !sameLearningRef2(source.taskDefinition, learningRef3(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
-  }
-  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef2(evidence.source, learningRef3(source))))) throw new Error("Taskset package includes an unrelated learning source.");
-  const rewardAssets = metadata.rewards.flatMap((reward) => [
-    ...reward.assets,
-    ...reward.implementation.kind === "custom_verifier" ? [reward.implementation.verifierRef] : reward.implementation.kind === "model_judge" || reward.implementation.kind === "human" ? [reward.implementation.rubricRef] : [],
-    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
-  ]);
-  for (const ref of rewardAssets) {
-    const asset = resources.assets.find((asset2) => asset2.id === ref.id);
-    if (!asset) throw new Error("Taskset learning Reward asset is missing.");
-    verifyLearningTextAsset4(asset, ref);
-  }
-  if (resources.assets.some((asset) => !rewardAssets.some((ref) => ref.id === asset.id))) throw new Error("Taskset package includes an unrelated learning asset.");
-  const compiled = compileTaskBatch({
-    batch: resources.batch,
-    definition: metadata.definition,
-    binding: metadata.binding,
-    rewards: metadata.rewards,
-    evidence: resources.evidence,
-    decisions: resources.decisions
-  });
-  const compiledMetadata = taskBatchPackageMetadata(compiled);
-  if (contentHash(compiledMetadata) !== contentHash(metadata)) throw new Error("Taskset admission metadata differs from its reviewed snapshots.");
-  const execution = (release) => ({ policy: release.policy, environment: release.environment, tools: release.tools });
-  if (contentHash(execution(compiled)) !== contentHash(execution(taskset))) throw new Error("Taskset execution differs from its reviewed task definition.");
-  const taskContent = (task) => ({
-    id: task.id,
-    clusterKey: task.clusterKey,
-    split: task.split,
-    input: task.input,
-    expectedOutput: task.expectedOutput,
-    policyVisibleContext: task.policyVisibleContext,
-    privilegedContextRef: task.privilegedContextRef,
-    artifactRefs: task.artifactRefs,
-    requiredOutputs: task.requiredOutputs ?? [],
-    tags: task.tags
-  });
-  if (contentHash(compiled.tasks.map(taskContent)) !== contentHash(taskset.tasks.map(taskContent))) throw new Error("Taskset rows differ from their reviewed evidence.");
-  return resources;
-}
-
-// src/model-taskset-authoring-lineage.ts
-import { sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
-
-// src/model-taskset-authoring-contracts.ts
-import { z as z17 } from "zod";
-import { LearningRevisionRefSchema } from "@openpond/evals/learning";
-var IdSchema3 = LearningRevisionRefSchema.shape.id;
-var HashSchema4 = z17.string().regex(/^[a-f0-9]{64}$/);
-var ModelTasksetAuthoringOwnerSchema = z17.object({ scopeId: IdSchema3, modelId: IdSchema3 }).strict();
-var ModelTasksetAuthoringSchema = z17.object({
-  schemaVersion: z17.literal("openpond.modelTasksetAuthoring.v1"),
-  owner: ModelTasksetAuthoringOwnerSchema,
-  root: LearningRevisionRefSchema,
-  parent: LearningRevisionRefSchema
-}).strict();
-var ModelTasksetDraftRequestSchema = z17.object({
-  schemaVersion: z17.literal("openpond.modelTasksetDraftRequest.v1"),
-  operationId: IdSchema3,
-  modelId: IdSchema3,
-  expectedModelRevision: z17.number().int().positive(),
-  sourcePackageHash: HashSchema4
-}).strict();
-var ModelTasksetDraftPreparationSchema = z17.object({
-  schemaVersion: z17.literal("openpond.modelTasksetDraftPreparation.v1"),
-  draftId: IdSchema3,
-  requestHash: HashSchema4,
-  sourcePackageHash: HashSchema4,
-  sourceTasksetRef: LearningRevisionRefSchema,
-  tasksetId: IdSchema3,
-  tasksetRevision: z17.number().int().positive(),
-  lineage: ModelTasksetAuthoringSchema
-}).strict();
-var TasksetDraftFilePathSchema = z17.string().min(1).max(1024).refine((value) => !value.includes("\\") && !value.includes(":") && !value.includes("\0") && !value.startsWith("/") && !value.split("/").some((part) => !part || part === "." || part === ".." || part.startsWith(".env")), "Use a relative Taskset file path without environment files.");
-var TasksetDraftFileInfoSchema = z17.object({
-  path: TasksetDraftFilePathSchema,
-  sizeBytes: z17.number().int().nonnegative(),
-  writable: z17.boolean()
-}).strict();
-var TasksetDraftFileContentSchema = z17.object({ encoding: z17.enum(["utf8", "base64"]), data: z17.string().max(8e6) }).strict();
-var TasksetDraftFileSchema = TasksetDraftFileInfoSchema.extend({ contentHash: HashSchema4, content: TasksetDraftFileContentSchema }).strict();
-var TasksetDraftFileMutationSchema = z17.object({
-  draftId: IdSchema3,
-  expectedDraftRevision: z17.number().int().positive(),
-  path: TasksetDraftFilePathSchema,
-  expectedFileHash: HashSchema4.nullable(),
-  content: TasksetDraftFileContentSchema.nullable()
-}).strict();
-
-// src/model-taskset-authoring-lineage.ts
-function modelAuthoredTasksetId(lineage) {
-  return `model-authored-taskset-${contentHash({ owner: lineage.owner, root: lineage.root })}`;
-}
-function assertModelTasksetAuthoring(taskset) {
-  if (taskset.metadata.modelTasksetAuthoring === void 0) return null;
-  const lineage = ModelTasksetAuthoringSchema.parse(taskset.metadata.modelTasksetAuthoring);
-  if (taskset.id !== modelAuthoredTasksetId(lineage) || (taskset.revision === 1 ? !sameLearningRef3(lineage.parent, lineage.root) : lineage.parent.id !== taskset.id || lineage.parent.revision !== taskset.revision - 1)) {
-    throw new Error("Authored Taskset revision differs from its ownership lineage.");
-  }
-  return lineage;
-}
-
-// src/taskset-package-execution.ts
-import { LearningTextAssetSchema as LearningTextAssetSchema3, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
-
-// src/taskset-package-files.ts
-import { z as z18 } from "zod";
-var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z18.object({
-  asset: ImmutableAssetRefSchema,
-  base64: z18.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
-}).strict();
-function decodeTasksetPackageFile(value) {
-  const file = TasksetPackageFileSchema.parse(value);
-  const raw = atob(file.base64);
-  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
-  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
-  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
-  return bytes;
-}
-
-// src/taskset-package-execution.ts
-function resolveTasksetPackageExecution(input) {
-  if (input.taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return null;
-  const byId = new Map(input.files.map((file) => [file.asset.id, file]));
-  const read = (id) => {
-    const file = byId.get(id);
-    if (!file) throw new Error(`Taskset environment asset is missing: ${id}.`);
-    if (file.asset.sizeBytes > 524288) throw new Error("Taskset environment source exceeds the authored asset limit.");
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-    return LearningTextAssetSchema3.parse(sealLearningContent4({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text }));
-  };
-  let execution;
-  if (input.modelResources) {
-    if (!input.modelResources.execution) throw new Error("Bound Taskset JavaScript execution resources are missing.");
-    execution = ModelStarterExecutionSchema.parse(input.modelResources.execution);
-  } else {
-    const declaration = read(modelStarterExecutionAssetId(input.taskset));
-    if (declaration.asset.visibility !== "host_private" || declaration.asset.mediaType !== "application/json" || declaration.asset.path !== "environment/execution.json") throw new Error("Taskset execution declaration must be private JSON at environment/execution.json.");
-    execution = ModelStarterExecutionSchema.parse(JSON.parse(declaration.text));
-  }
-  const ids = /* @__PURE__ */ new Set([
-    execution.javascript.module.id,
-    ...[execution.environment.actionSchemaRef, execution.environment.observationSchemaRef, execution.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
-    ...input.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : [])
-  ]);
-  const assets = [...ids].map(read);
-  validateModelStarterExecution(execution, input.taskset, assets);
-  return { execution, assets };
-}
-function createTasksetPackageExecutionFile(execution) {
-  const asset = createModelStarterExecutionAsset(execution);
-  const bytes = new TextEncoder().encode(asset.text);
-  let raw = "";
-  for (const byte of bytes) raw += String.fromCharCode(byte);
-  return { asset: asset.asset, base64: btoa(raw) };
-}
-
-// src/taskset-package-contracts.ts
-var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z19.object({
-  schemaVersion: z19.literal("openpond.tasksetPackage.v1"),
-  taskset: TasksetReleaseSchema2,
-  environment: EnvironmentReleaseSchema3,
-  verifierSet: VerifierSetReleaseSchema3,
-  files: z19.array(TasksetPackageFileSchema).max(1e4),
-  modelResources: BoundModelResourcesSchema.optional(),
-  learningResources: TasksetPackageLearningResourcesSchema.optional()
-}).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z19.string().regex(/^[a-f0-9]{64}$/) }).strict();
-function tasksetPackageRewardBinding(value) {
-  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
-}
-function resolveTasksetPackageInstructions(value) {
-  if (value.learningResources) return taskBatchPackageMetadata2(value.taskset).definition.instructions;
-  if (value.modelResources) return value.modelResources.taskDefinition.instructions;
-  const authoring = z19.object({ instructions: z19.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
-  return authoring.instructions ?? "";
-}
-function validateTasksetPackage(value) {
-  assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
-  const result = TasksetPackageSchema.parse(value);
-  const { contentHash: hash, ...content } = result;
-  if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
-  const { taskset, environment, verifierSet } = result;
-  assertTasksetRelease2(taskset);
-  const authoring = assertModelTasksetAuthoring(taskset);
-  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
-  if (!verifyEnvironmentRelease3(environment) || !verifyVerifierSetRelease3(verifierSet) || !same2(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same2(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same2(taskset.environment, environment.contract) || !same2(taskset.graders, verifierSet.graders)) {
-    throw new Error("Taskset package execution releases do not match its Taskset.");
-  }
-  const files = /* @__PURE__ */ new Map();
-  for (const file of result.files) {
-    if (files.has(file.asset.id)) throw new Error(`Duplicate Taskset asset identity: ${file.asset.id}.`);
-    decodeTasksetPackageFile(file);
-    files.set(file.asset.id, file);
-  }
-  function requireAsset(ref) {
-    const file = files.get(ref.id);
-    if (!file || !same2(file.asset, ref)) throw new Error(`Taskset package asset is missing or mismatched: ${ref.id}.`);
-  }
-  for (const task of taskset.tasks) {
-    for (const asset of task.artifactRefs) requireAsset(asset);
-    for (const output of task.requiredOutputs ?? []) if (output.schemaRef) requireAsset(output.schemaRef);
-    if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
-      throw new Error(`Taskset package private context is missing: ${task.id}.`);
-    }
-  }
-  for (const ref of [environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) if (ref) requireAsset(ref);
-  for (const grader of taskset.graders) {
-    const ref = "verifierRef" in grader ? grader.verifierRef : "rubricRef" in grader ? grader.rubricRef : null;
-    if (ref) {
-      requireAsset(ref);
-      if (ref.visibility === "policy") throw new Error(`Taskset grader asset must be private: ${ref.id}.`);
-    }
-  }
-  if (taskset.metrics?.customAggregator) {
-    const aggregator = taskset.metrics.customAggregator;
-    const modules = result.files.filter((file) => file.asset.path === aggregator.module);
-    if (modules.length !== 1 || modules[0].asset.contentHash !== aggregator.contentHash || modules[0].asset.sizeBytes > 524288 || modules[0].asset.visibility === "policy") {
-      throw new Error("Taskset metric module is missing or mismatched, public, or exceeds the source limit.");
-    }
-  }
-  for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
-    if (declarations === void 0) continue;
-    for (const resource of z19.array(z19.object({ path: z19.string().min(1) }).passthrough()).parse(declarations)) {
-      if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
-    }
-  }
-  if (result.learningResources) {
-    if (result.modelResources) throw new Error("Taskset package cannot declare competing authoring graphs.");
-    const learning = validateTasksetLearningResources(taskset, result.learningResources);
-    for (const expected of learningPackageContextFiles(learning)) {
-      if (!same2(files.get(expected.asset.id), expected)) throw new Error("Taskset private context differs from its reviewed evidence.");
-    }
-    for (const asset of learning.assets) requireAsset(asset.asset);
-  } else if (result.modelResources) {
-    const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
-    for (const asset of model.assets) requireAsset(asset.asset);
-  } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
-    throw new Error("Bound Taskset publication requires its complete model resources.");
-  }
-  resolveTasksetPackageExecution(result);
-  resolveTasksetPackageInstructions(result);
-  return result;
-}
-function createTasksetPackage(value) {
-  assertBoundedTaskJson3(value, MAX_TASKSET_PACKAGE_BYTES);
-  const content = TasksetPackageContentSchema.parse(value);
-  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
-}
-function same2(left, right) {
-  return contentHash({ value: left }) === contentHash({ value: right });
-}
-
-// src/taskset-package-client.ts
-import { z as z21 } from "zod";
-
-// src/taskset-catalog.ts
-import { z as z20 } from "zod";
-var IdSchema4 = z20.string().trim().min(1).max(500);
-var HashSchema5 = z20.string().regex(/^[a-f0-9]{64}$/);
-var TasksetCatalogReleaseRefSchema = z20.object({ id: IdSchema4, revision: z20.number().int().positive(), contentHash: HashSchema5 }).strict();
-var HostedTasksetSummarySchema = z20.object({
-  schemaVersion: z20.literal("openpond.hostedTasksetSummary.v1"),
-  id: IdSchema4,
-  teamId: IdSchema4,
-  release: TasksetCatalogReleaseRefSchema,
-  name: z20.string().min(1).max(500),
-  description: z20.string().max(2e4),
-  taskCount: z20.number().int().nonnegative(),
-  buildIntent: z20.string().min(1).max(100),
-  methodHint: z20.string().min(1).max(100).nullable(),
-  packageBytes: z20.number().int().nonnegative().nullable(),
-  storedBytes: z20.number().int().nonnegative().nullable(),
-  createdAt: z20.string().datetime({ offset: true })
-}).strict();
-var TasksetCatalogQuerySchema = z20.object({
-  afterId: IdSchema4.optional(),
-  limit: z20.number().int().min(1).max(100).default(30),
-  modelProjectId: IdSchema4.optional()
-}).strict();
-var TasksetCatalogPageSchema = z20.object({
-  items: z20.array(HostedTasksetSummarySchema).max(100),
-  nextCursor: IdSchema4.nullable()
-}).strict();
-var TasksetCatalogErrorSchema = z20.object({
-  code: z20.string().min(1),
-  message: z20.string().min(1)
-}).strict();
-
-// src/taskset-package-client.ts
-import { learningRef as learningRef4 } from "@openpond/evals/learning";
-var IdSchema5 = z21.string().trim().min(1).max(500);
-var HashSchema6 = z21.string().regex(/^[a-f0-9]{64}$/);
-var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
-  portableProjectId: true,
-  name: true,
-  objective: true,
-  defaultBaseModel: true,
-  defaultDestinationId: true,
-  sourceRevision: true,
-  sourceUpdatedAt: true
-}).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true, recipe: true }) }).strict();
-var TasksetPackagePublicationSchema = z21.object({
-  schemaVersion: z21.literal("openpond.tasksetPackagePublication.v1"),
-  operationId: IdSchema5,
-  modelProjectId: IdSchema5,
-  expectedProjectEtag: HashSchema6.nullable(),
-  name: z21.string().trim().min(1).max(200),
-  description: z21.string().max(5e3),
-  buildIntent: z21.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
-  methodHint: z21.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
-  package: TasksetPackageSchema,
-  modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
-  selection: z21.enum(["select", "attach"]).optional()
-}).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.");
-var TasksetPackageReceiptSchema = z21.object({
-  schemaVersion: z21.literal("openpond.tasksetPackageReceipt.v1"),
-  teamId: IdSchema5,
-  modelProjectId: IdSchema5,
-  operationId: IdSchema5,
-  taskset: TasksetCatalogReleaseRefSchema,
-  packageHash: HashSchema6,
-  hostedTasksetId: IdSchema5,
-  projectEtag: HashSchema6,
-  project: HostedModelProjectSummarySchema.optional(),
-  selection: z21.enum(["select", "attach"]).optional()
-}).strict();
-var TasksetPackageReadbackSchema = z21.object({
-  schemaVersion: z21.literal("openpond.tasksetPackageReadback.v1"),
-  teamId: IdSchema5,
-  modelProjectId: IdSchema5,
-  package: TasksetPackageSchema
-}).strict();
-var OpenPondTasksetPackageError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.name = "OpenPondTasksetPackageError";
-  }
-  status;
-  code;
-};
-var OpenPondTasksetPackageClient = class {
-  #options;
-  constructor(options) {
-    const url = new URL(options.baseUrl);
-    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim()) throw new Error("Taskset package client requires a clean HTTP(S) endpoint and workspace credentials.");
-    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
-  }
-  async publish(input, options = {}) {
-    const request = TasksetPackagePublicationSchema.parse(input);
-    validateTasksetPackage(request.package);
-    const receipt = TasksetPackageReceiptSchema.parse(await this.#request("", "POST", request, options.signal));
-    const release = request.package.taskset;
-    if (receipt.teamId !== this.#options.teamId || receipt.modelProjectId !== request.modelProjectId || receipt.operationId !== request.operationId || receipt.packageHash !== request.package.contentHash || receipt.taskset.id !== release.id || receipt.taskset.revision !== release.revision || receipt.taskset.contentHash !== release.contentHash) {
-      throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication receipt did not match the requested package and owner.");
-    }
-    if (request.selection !== void 0 && receipt.selection !== request.selection) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain its selection mode.");
-    if (request.selection === "attach" && receipt.projectEtag !== request.expectedProjectEtag) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Attaching a historical Taskset changed the Model configuration.");
-    if (request.modelConfiguration) {
-      const expected = request.modelConfiguration;
-      const project = receipt.project;
-      const binding = tasksetPackageRewardBinding(request.package);
-      const setup = HostedModelProjectTrainingSetupSchema.parse({
-        ...expected.trainingSetup,
-        tasksetRef: learningRef4(release),
-        rewardBindingRef: binding ? learningRef4(binding) : null,
-        tasksetRelease: null,
-        recipe: null
-      });
-      if (!project || project.teamId !== this.#options.teamId || project.etag !== receipt.projectEtag || ![project.id, project.portableProjectId].includes(request.modelProjectId) || project.portableProjectId !== expected.portableProjectId || project.name !== expected.name || project.objective !== expected.objective || project.sourceRevision !== expected.sourceRevision || Date.parse(project.sourceUpdatedAt) !== Date.parse(expected.sourceUpdatedAt) || contentHash(project.defaultBaseModel) !== contentHash(expected.defaultBaseModel) || project.defaultDestinationId !== expected.defaultDestinationId || contentHash(project.trainingSetup) !== contentHash(setup)) {
-        throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain the requested Model configuration.");
-      }
-    }
-    return receipt;
-  }
-  async get(modelProjectId, reference, options = {}) {
-    const project = IdSchema5.parse(modelProjectId);
-    const ref = TasksetCatalogReleaseRefSchema.parse(reference);
-    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema6.parse(options.expectedPackageHash);
-    const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
-    const taskset = response.package.taskset;
-    if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
-    if (expectedPackageHash !== void 0 && response.package.contentHash !== expectedPackageHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the saved publication receipt.");
-    return validateTasksetPackage(response.package);
-  }
-  async #request(path, method, body, signal) {
-    const serialized = body === void 0 ? void 0 : JSON.stringify(body);
-    if (serialized && new TextEncoder().encode(serialized).byteLength > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset publication exceeds the 64 MiB envelope.");
-    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/taskset-packages${path}`, {
-      method,
-      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "X-OpenPond-Team-Id": this.#options.teamId, Accept: "application/json", ...serialized ? { "Content-Type": "application/json" } : {} },
-      body: serialized,
-      signal,
-      redirect: "error"
-    });
-    const reader = response.body?.getReader();
-    if (!reader) throw new OpenPondTasksetPackageError(response.status, "empty_response", "Taskset package response was empty.");
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    let bytes = 0;
-    let text = "";
-    try {
-      while (true) {
-        const chunk = await reader.read();
-        if (chunk.done) break;
-        bytes += chunk.value.byteLength;
-        if (bytes > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset response exceeds the 64 MiB envelope.");
-        text += decoder.decode(chunk.value, { stream: true });
-      }
-      text += decoder.decode();
-    } finally {
-      await reader.cancel();
-      reader.releaseLock();
-    }
-    const payload = JSON.parse(text);
-    if (!response.ok) {
-      const error = z21.object({ code: z21.string(), message: z21.string() }).safeParse(payload);
-      throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
-    }
-    return payload;
-  }
-};
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema
+} from "./chunk-K5ZCYOZO.js";
+import {
+  GraderFixtureSchema,
+  GraderSpecSchema,
+  MAX_TASKSET_PACKAGE_BYTES,
+  OpenPondTasksetPackageClient,
+  OpenPondTasksetPackageError,
+  TasksetDraftSchema,
+  TasksetEnvironmentResourceSchema,
+  TasksetPackageContentSchema,
+  TasksetPackageFileSchema,
+  TasksetPackageLearningResourcesSchema,
+  TasksetPackageModelConfigurationSchema,
+  TasksetPackagePublicationSchema,
+  TasksetPackageReadbackSchema,
+  TasksetPackageReceiptSchema,
+  TasksetPackageSchema,
+  TasksetSchema,
+  TasksetSourceRefSchema,
+  assertModelTasksetAuthoring,
+  computeTasksetHash,
+  configuredTasksetDraftFiles,
+  createTasksetDraft,
+  createTasksetDraftWorkspace,
+  createTasksetPackage,
+  createTasksetPackageExecutionFile,
+  decodeTasksetDraftWorkspaceFile,
+  decodeTasksetPackageFile,
+  isManagedTasksetDraftFilePath,
+  learningPackageContextFiles,
+  modelAuthoredTasksetId,
+  publishTasksetDraft,
+  renderTasksetDraftManifests,
+  resolveTasksetPackageExecution,
+  resolveTasksetPackageInstructions,
+  tasksetPackageRewardBinding,
+  validateTasksetDraftWorkspace,
+  validateTasksetLearningResources,
+  validateTasksetPackage
+} from "./chunk-AZUCY3E5.js";
+import {
+  ModelTasksetAuthoringOwnerSchema,
+  ModelTasksetAuthoringSchema,
+  ModelTasksetDraftPreparationSchema,
+  ModelTasksetDraftRequestSchema,
+  TasksetDraftFileContentSchema,
+  TasksetDraftFileInfoSchema,
+  TasksetDraftFileMutationSchema,
+  TasksetDraftFilePathSchema,
+  TasksetDraftFileSchema
+} from "./chunk-S7I45WJQ.js";
+import "./chunk-AVW35YOH.js";
+import "./chunk-A4ZDOZKP.js";
+import {
+  ModelStarterExecutionSchema,
+  modelStarterExecutionAssetId
+} from "./chunk-65D4C7HP.js";
+import {
+  CapabilityRequirementSchema,
+  ToolDeclarationSchema
+} from "./chunk-IVEXCIHO.js";
+import {
+  ImmutableAssetRefSchema,
+  contentHash,
+  sha256
+} from "./chunk-ZPCK222K.js";
+import "./chunk-5PRP457R.js";
 
 // src/model-batch-review.ts
 import {
   LearningDomainError as LearningDomainError2,
-  learningRef as learningRef6,
-  sameLearningRef as sameLearningRef5,
+  learningRef as learningRef2,
+  sameLearningRef as sameLearningRef2,
   requireLearningRelease,
   requireLearningResource,
-  taskBatchPackageMetadata as taskBatchPackageMetadata4
+  taskBatchPackageMetadata as taskBatchPackageMetadata2
 } from "@openpond/evals/learning";
 
-// src/model-batch-review-contracts.ts
-import { z as z22 } from "zod";
-import { LearningJsonObjectSchema, LearningRevisionRefSchema as LearningRevisionRefSchema2, LearningSourceSchema as LearningSourceSchema2, TaskEvidenceSchema as TaskEvidenceSchema2, TaskFeedbackSchema, TaskDefinitionSchema as TaskDefinitionSchema2, TaskAdmissionDecisionSchema as TaskAdmissionDecisionSchema2 } from "@openpond/evals/learning";
-import { RewardBindingSchema as RewardBindingSchema2 } from "@openpond/evals/rewards";
-var ReleaseIdSchema2 = LearningRevisionRefSchema2.shape.id;
-var ModelBatchReviewInspectionSchema = z22.object({
-  schemaVersion: z22.literal("openpond.modelBatchReviewInspection.v1"),
-  packageHash: z22.string().regex(/^[a-f0-9]{64}$/),
-  definition: TaskDefinitionSchema2,
-  binding: RewardBindingSchema2,
-  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
-  decisions: z22.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
-}).strict();
-var ModelBatchReviewRequestSchema = z22.object({
-  schemaVersion: z22.literal("openpond.modelBatchReviewRequest.v1"),
-  operationId: ReleaseIdSchema2,
-  modelId: ReleaseIdSchema2,
-  expectedModelRevision: z22.number().int().positive(),
-  tasksetRef: LearningRevisionRefSchema2,
-  rewardBindingRef: LearningRevisionRefSchema2.nullable(),
-  definition: z22.object({
-    name: z22.string().trim().min(1).max(500).optional(),
-    instructions: z22.string().trim().min(1).max(2e4).optional(),
-    inputSchema: LearningJsonObjectSchema.optional(),
-    outputSchema: LearningJsonObjectSchema.optional()
-  }).strict(),
-  examples: z22.array(z22.object({
-    evidence: LearningRevisionRefSchema2,
-    input: LearningJsonObjectSchema.optional(),
-    expected: LearningJsonObjectSchema.nullable().optional(),
-    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),
-    proposedTarget: LearningJsonObjectSchema.nullable().optional()
-  }).strict()).max(1e4)
-}).strict();
-var ModelBatchReviewReceiptSchema = z22.object({
-  schemaVersion: z22.literal("openpond.modelBatchReviewReceipt.v1"),
-  operationId: ReleaseIdSchema2,
-  modelId: ReleaseIdSchema2,
-  source: LearningSourceSchema2,
-  evidence: z22.array(TaskEvidenceSchema2).min(1).max(1e4),
-  proposals: z22.array(TaskFeedbackSchema).max(1e4)
-}).strict();
-
 // src/model-batch-review-preparation.ts
 import {
   LearningDomainError,
-  LearningSourceSchema as LearningSourceSchema3,
-  TaskDefinitionSchema as TaskDefinitionSchema3,
-  TaskEvidenceSchema as TaskEvidenceSchema3,
-  TaskFeedbackSchema as TaskFeedbackSchema2,
-  assertLearningContentHash as assertLearningContentHash3,
+  LearningSourceSchema,
+  TaskDefinitionSchema,
+  TaskEvidenceSchema,
+  TaskFeedbackSchema,
+  assertLearningContentHash,
   learningEvidenceId,
-  learningRef as learningRef5,
-  sameLearningRef as sameLearningRef4,
-  sealLearningContent as sealLearningContent5,
-  taskBatchPackageMetadata as taskBatchPackageMetadata3,
-  verifyLearningTextAsset as verifyLearningTextAsset5
+  learningRef,
+  sameLearningRef,
+  sealLearningContent,
+  taskBatchPackageMetadata,
+  verifyLearningTextAsset
 } from "@openpond/evals/learning";
-import { compileBoundGraders as compileBoundGraders2, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
+import { compileBoundGraders, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
 function prepareModelBatchReview(input) {
   const { request, package: value } = input;
   const learning = value.learningResources;
   if (!learning) throw new LearningDomainError("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata3(value.taskset);
+  const metadata = taskBatchPackageMetadata(value.taskset);
   const id = `model-review-${contentHash([input.scope, request.modelId, request.operationId])}`;
   const edits = new Map(request.examples.map((edit) => [contentHash(edit.evidence), edit]));
-  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef5(evidence2))));
+  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef(evidence2))));
   const decisions = new Map(learning.decisions.map((decision) => [contentHash(decision.evidence), decision]));
   if (edits.size !== request.examples.length || request.examples.some((edit) => !parentRefs.has(contentHash(edit.evidence)))) {
     throw new LearningDomainError("model_review_evidence_mismatch", 409);
   }
-  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash3(resource);
+  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash(resource);
   resolveBoundRewards(input.binding, input.rewards);
   const rewardByHash = /* @__PURE__ */ new Map();
   for (const source2 of input.binding.sources) {
-    const original = input.rewards.find((reward) => sameLearningRef4(learningRef5(reward), source2.reward));
+    const original = input.rewards.find((reward) => sameLearningRef(learningRef(reward), source2.reward));
     const { contentHash: _hash, ...content } = original;
     rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
   }
@@ -3093,7 +122,7 @@ function prepareModelBatchReview(input) {
     ...bindingContent,
     id: `${id}-binding`,
     revision: 1,
-    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef5(rewardByHash.get(source2.reward.contentHash)) }))
+    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef(rewardByHash.get(source2.reward.contentHash)) }))
   }, rewards);
   const assetRefs = rewards.flatMap((reward) => [
     ...reward.assets,
@@ -3104,30 +133,30 @@ function prepareModelBatchReview(input) {
   const assets = [...new Map(assetRefs.map((ref) => {
     const asset = input.assets.find((asset2) => asset2.id === ref.id);
     if (!asset) throw new LearningDomainError("model_review_reward_asset_missing", 422);
-    verifyLearningTextAsset5(asset, ref);
+    verifyLearningTextAsset(asset, ref);
     if (ref.visibility === "policy") throw new LearningDomainError("reward_asset_visibility_invalid", 422);
     return [asset.id, asset];
   })).values()];
   const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
   const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
-  const definition = TaskDefinitionSchema3.parse(sealLearningContent5({
+  const definition = TaskDefinitionSchema.parse(sealLearningContent({
     ...definitionContent,
     ...request.definition,
     id: `${id}-definition`,
     revision: 1,
-    rewardBinding: learningRef5(binding),
+    rewardBinding: learningRef(binding),
     execution: {
       ...execution,
-      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders2(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
+      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
     }
   }));
-  const source = LearningSourceSchema3.parse(sealLearningContent5({
+  const source = LearningSourceSchema.parse(sealLearningContent({
     schemaVersion: "openpond.learningSource.v1",
     id,
     revision: 1,
     name: `${definition.name} review`,
     kind: "direct",
-    taskDefinition: learningRef5(definition),
+    taskDefinition: learningRef(definition),
     enabled: true,
     allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
     mapping: null,
@@ -3135,13 +164,13 @@ function prepareModelBatchReview(input) {
     reviewOrigin: {
       modelId: request.modelId,
       packageHash: value.contentHash,
-      taskset: learningRef5(value.taskset),
-      batch: learningRef5(learning.batch),
-      rewardBinding: learningRef5(input.binding)
+      taskset: learningRef(value.taskset),
+      batch: learningRef(learning.batch),
+      rewardBinding: learningRef(input.binding)
     }
   }));
   const evidence = learning.evidence.map((parent) => {
-    const edit = edits.get(contentHash(learningRef5(parent)));
+    const edit = edits.get(contentHash(learningRef(parent)));
     const attemptId = `review-${parent.contentHash}`;
     const policyChanged = contentHash({
       instructions: definition.instructions,
@@ -3154,15 +183,15 @@ function prepareModelBatchReview(input) {
       outputSchema: metadata.definition.outputSchema,
       input: parent.submission.input
     });
-    return TaskEvidenceSchema3.parse(sealLearningContent5({
+    return TaskEvidenceSchema.parse(sealLearningContent({
       schemaVersion: "openpond.taskEvidence.v1",
       id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
       revision: 1,
-      source: learningRef5(source),
+      source: learningRef(source),
       submission: {
         ...parent.submission,
         sourceId: source.id,
-        taskDefinition: learningRef5(definition),
+        taskDefinition: learningRef(definition),
         attemptId,
         // The old response was observed under the old policy-visible task. Its
         // parent snapshot remains available, but it is not a run of new inputs.
@@ -3172,7 +201,7 @@ function prepareModelBatchReview(input) {
         ...edit?.expected === void 0 ? {} : { expected: edit.expected },
         ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
       },
-      supersedes: learningRef5(parent),
+      supersedes: learningRef(parent),
       correctionFeedbackId: null,
       receivedAt: input.now
     }));
@@ -3181,7 +210,7 @@ function prepareModelBatchReview(input) {
     const edit = edits.get(contentHash(item.supersedes));
     const decision = decisions.get(contentHash(item.supersedes));
     const target = edit?.proposedTarget === void 0 ? decision.approvedTarget : edit.proposedTarget;
-    return target === null ? [] : [TaskFeedbackSchema2.parse({
+    return target === null ? [] : [TaskFeedbackSchema.parse({
       schemaVersion: "openpond.taskFeedbackRecord.v1",
       id: `feedback-${contentHash([id, item.id])}`,
       revision: 1,
@@ -3198,7 +227,7 @@ function prepareModelBatchReview(input) {
         note: "Proposed target for the revised task. Grade and review before admission."
       },
       status: "pending_review",
-      evidence: learningRef5(item),
+      evidence: learningRef(item),
       createdAt: input.now,
       review: null
     })];
@@ -3212,7 +241,7 @@ var operation = (request) => `model-batch-review-${contentHash([request.modelId,
 function inspectModelBatchPackage(raw) {
   const value = validateTasksetPackage(raw);
   if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata4(value.taskset);
+  const metadata = taskBatchPackageMetadata2(value.taskset);
   return ModelBatchReviewInspectionSchema.parse({
     schemaVersion: "openpond.modelBatchReviewInspection.v1",
     packageHash: value.contentHash,
@@ -3235,9 +264,9 @@ async function beginModelBatchReview(transaction, input) {
   if (prior) return prior;
   const value = validateTasksetPackage(input.package);
   if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata4(value.taskset);
+  const metadata = taskBatchPackageMetadata2(value.taskset);
   const selected = request.rewardBindingRef;
-  const retained = !selected || sameLearningRef5(selected, learningRef6(metadata.binding));
+  const retained = !selected || sameLearningRef2(selected, learningRef2(metadata.binding));
   const binding = retained ? metadata.binding : await requireLearningRelease(transaction, "binding", selected);
   const rewards = retained ? metadata.rewards : await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
   const assetIds = new Set(rewards.flatMap((reward) => [
@@ -3283,9 +312,9 @@ async function readReceipt(transaction, request, pointers) {
 }
 
 // src/model-taskset-authoring.ts
-import { createVerifierSetRelease as createVerifierSetRelease2 } from "@openpond/evals";
-import { learningRef as learningRef7, sameLearningRef as sameLearningRef6, sealLearningContent as sealLearningContent6 } from "@openpond/evals/learning";
-import { TasksetReleaseSchema as TasksetReleaseSchema3 } from "@openpond/evals/tasksets";
+import { createVerifierSetRelease } from "@openpond/evals";
+import { learningRef as learningRef3, sameLearningRef as sameLearningRef3, sealLearningContent as sealLearningContent2 } from "@openpond/evals/learning";
+import { TasksetReleaseSchema } from "@openpond/evals/tasksets";
 function prepareModelTasksetDraft(input) {
   const request = ModelTasksetDraftRequestSchema.parse(input.request);
   const owner = ModelTasksetAuthoringOwnerSchema.parse(input.owner);
@@ -3293,14 +322,14 @@ function prepareModelTasksetDraft(input) {
   if (source.contentHash !== request.sourcePackageHash) throw new Error("Taskset draft source package changed.");
   const previous = assertModelTasksetAuthoring(source.taskset);
   const owned = previous && contentHash(previous.owner) === contentHash(owner);
-  const root = owned ? previous.root : learningRef7(source.taskset);
-  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef7(source.taskset) };
+  const root = owned ? previous.root : learningRef3(source.taskset);
+  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef3(source.taskset) };
   return ModelTasksetDraftPreparationSchema.parse({
     schemaVersion: "openpond.modelTasksetDraftPreparation.v1",
     draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,
     requestHash: contentHash(request),
     sourcePackageHash: source.contentHash,
-    sourceTasksetRef: learningRef7(source.taskset),
+    sourceTasksetRef: learningRef3(source.taskset),
     tasksetId: modelAuthoredTasksetId(lineage),
     tasksetRevision: owned ? source.taskset.revision + 1 : 1,
     lineage
@@ -3308,18 +337,18 @@ function prepareModelTasksetDraft(input) {
 }
 function publishModelTasksetDraftPackage(input) {
   const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (!sameLearningRef6(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
+  if (!sameLearningRef3(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
   const edited = requireOrdinaryPackage(input.edited);
   const { contentHash: _verifierHash, ...verifierContent } = edited.verifierSet;
-  const verifierSet = createVerifierSetRelease2({
+  const verifierSet = createVerifierSetRelease({
     ...verifierContent,
     id: `${prepared.tasksetId}-verifiers`,
     revision: prepared.tasksetRevision,
     calibrationReceiptRefs: [],
-    metadata: { sourceVerifierSet: learningRef7(edited.verifierSet) }
+    metadata: { sourceVerifierSet: learningRef3(edited.verifierSet) }
   });
   const { contentHash: _hash, ...content } = edited.taskset;
-  const taskset = TasksetReleaseSchema3.parse(sealLearningContent6({
+  const taskset = TasksetReleaseSchema.parse(sealLearningContent2({
     ...content,
     id: prepared.tasksetId,
     revision: prepared.tasksetRevision,
@@ -3342,7 +371,819 @@ function requireOrdinaryPackage(value) {
   if (result.modelResources || result.learningResources) throw new Error("This Taskset requires its bound or reviewed authoring workflow.");
   return result;
 }
+
+// src/taskset-authored-portable-release.ts
+import {
+  TaskRecordSchema,
+  GraderSpecSchema as PortableGraderSpecSchema,
+  TasksetReleaseContentSchema,
+  TasksetReleaseSchema as TasksetReleaseSchema2,
+  bindTasksetExecutionReleases,
+  createEnvironmentRelease,
+  createVerifierSetRelease as createVerifierSetRelease2,
+  EnvironmentReleaseSchema,
+  VerifierSetReleaseSchema,
+  verifyEnvironmentRelease,
+  verifyVerifierSetRelease,
+  verifyPreferenceComparisonRelease
+} from "@openpond/evals";
+import { TaskBatchPackageMetadataSchema } from "@openpond/evals/learning";
+import { compileBoundGraders as compileBoundGraders2, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
+import { portableDeterministicCheck } from "@openpond/evals/graders";
+function resolvePortableTasksetRewardExecution(taskset, supplied) {
+  const learning = taskset.metadata.learning === void 0 ? null : TaskBatchPackageMetadataSchema.parse(taskset.metadata.learning);
+  const embedded = taskset.metadata.rewardExecution;
+  const execution = supplied ?? (embedded ? {
+    binding: RewardBindingSchema.parse(embedded.binding),
+    rewards: RewardReleaseSchema.array().parse(embedded.rewards)
+  } : learning);
+  if (taskset.metadata.rewardBinding !== void 0) {
+    const reference = taskset.metadata.rewardBinding;
+    if (!execution || !reference || reference.id !== execution.binding.id || reference.revision !== execution.binding.revision || reference.contentHash !== execution.binding.contentHash) {
+      throw new Error("Portable Taskset requires its exact published Reward binding.");
+    }
+  }
+  if (execution) compileBoundGraders2(execution.binding, execution.rewards);
+  return execution ? { binding: execution.binding, rewards: execution.rewards } : null;
+}
+function materializePortableTasksetRelease(input) {
+  const environment = portableEnvironment(input.taskset);
+  const tools = portableTools(input.taskset);
+  const learning = input.taskset.metadata.learning === void 0 ? null : TaskBatchPackageMetadataSchema.parse(input.taskset.metadata.learning);
+  const embedded = input.taskset.metadata.rewardExecution;
+  const rewardExecution = resolvePortableTasksetRewardExecution(input.taskset, input.rewardExecution);
+  const graders = rewardExecution ? compileBoundGraders2(rewardExecution.binding, rewardExecution.rewards) : input.taskset.graders.map(portableGrader);
+  const tasks = input.selectedTasks?.length ? input.selectedTasks : input.taskset.tasks;
+  if (!tasks.length) throw new Error("A portable Taskset release requires at least one task.");
+  const pinned = input.taskset.environment.metadata.portableExecutionResources;
+  if (environment.entrypoint === "openpond.javascript-environment.v1" && !pinned) throw new Error("Tool Taskset publication requires its pinned execution resources.");
+  const environmentRelease = pinned ? EnvironmentReleaseSchema.parse(pinned.environment) : createEnvironmentRelease({
+    schemaVersion: "openpond.environmentRelease.v1",
+    id: `environment-release-${input.taskset.id}-r${input.taskset.revision}`,
+    revision: input.taskset.revision,
+    contract: environment,
+    actionSchemaRef: null,
+    observationSchemaRef: null,
+    stateSchemaRef: null,
+    artifactCollection: {
+      maxArtifacts: 1e5,
+      maxTotalBytes: 25e7
+    },
+    adapterConformanceHashes: {
+      [input.adapterId]: contentHash({ adapterId: input.adapterId, environment, tools })
+    },
+    metadata: {
+      sourceTasksetId: input.taskset.id,
+      sourcePackageHash: input.taskset.metadata.sourcePackageHash ?? null,
+      resources: input.taskset.environment.resources ?? []
+    }
+  });
+  const verifierSetRelease = pinned?.verifierSet !== void 0 ? VerifierSetReleaseSchema.parse(pinned.verifierSet) : createVerifierSetRelease2({
+    schemaVersion: "openpond.verifierSetRelease.v1",
+    id: `verifier-set-release-${input.taskset.id}-r${input.taskset.revision}`,
+    revision: input.taskset.revision,
+    graders,
+    isolation: {
+      processBoundary: "isolated_process",
+      networkPolicy: "none",
+      defaultTimeoutMs: Math.min(input.taskset.environment.defaultTimeoutMs, 3e5)
+    },
+    calibrationReceiptRefs: [],
+    metadata: { sourceTasksetId: input.taskset.id }
+  });
+  if (!verifyEnvironmentRelease(environmentRelease) || !verifyVerifierSetRelease(verifierSetRelease) || contentHash(environmentRelease.contract) !== contentHash(environment) || contentHash(verifierSetRelease.graders) !== contentHash(graders)) {
+    throw new Error("Taskset execution resources differ from its declared environment or graders.");
+  }
+  const tasksetContent = TasksetReleaseContentSchema.parse({
+    schemaVersion: "openpond.tasksetRelease.v2",
+    id: input.taskset.metadata.derivedPortableMetadata === void 0 ? `taskset-release-${input.taskset.id}-r${input.taskset.revision}` : input.taskset.id,
+    revision: input.taskset.revision,
+    policy: {
+      policyVisibleFields: input.taskset.policy.policyVisibleFields,
+      privilegedFields: input.taskset.policy.privilegedFields,
+      hiddenGraderRefs: input.taskset.policy.hiddenGraderRefs,
+      connectedAppScopes: input.taskset.policy.connectedAppScopes
+    },
+    environment,
+    tools,
+    capabilities: portableCapabilities(input.taskset),
+    tasks: tasks.map(projectPortableTaskRecord),
+    graders,
+    ...input.taskset.metrics ? { metrics: input.taskset.metrics } : {},
+    metadata: input.taskset.metadata.derivedPortableMetadata ?? {
+      sourceTasksetId: input.taskset.id,
+      sourceTasksetHash: input.taskset.contentHash,
+      sourcePackageHash: input.taskset.metadata.sourcePackageHash ?? null,
+      environmentResources: input.taskset.environment.resources ?? [],
+      ordinaryAuthoring: {
+        instructions: input.taskset.objective,
+        graderFixtures: input.taskset.graderFixtures,
+        judgeCalibrationFixtures: Object.fromEntries(input.taskset.graders.filter((grader) => grader.kind === "model_judge").map((grader) => [grader.id, grader.calibrationFixtureRefs]))
+      },
+      ...learning ? { learning } : {},
+      ...rewardExecution && (input.rewardExecution || embedded) ? { rewardExecution: { binding: rewardExecution.binding, rewards: rewardExecution.rewards } } : {}
+    }
+  });
+  const draft = input.admittedTasksetRelease ? TasksetReleaseSchema2.parse(input.admittedTasksetRelease) : TasksetReleaseSchema2.parse({
+    ...tasksetContent,
+    contentHash: contentHash(tasksetContent)
+  });
+  const tasksetRelease = draft.environmentRelease ? assertReleaseBindings({ draft, environmentRelease, verifierSetRelease }) : bindTasksetExecutionReleases({
+    taskset: draft,
+    environment: environmentRelease,
+    verifierSet: verifierSetRelease
+  });
+  return { environmentRelease, verifierSetRelease, tasksetRelease };
+}
+function projectPreferenceComparisonRelease(input) {
+  if (!verifyPreferenceComparisonRelease(input.preferenceComparison)) {
+    throw new Error("Preference comparison release failed immutable content verification.");
+  }
+  const release = input.preferenceComparison;
+  if (release.tasksetRelease.id !== input.tasksetRelease.id || release.tasksetRelease.contentHash !== input.tasksetRelease.contentHash) {
+    throw new Error("Preference comparison release must reference the admitted portable Taskset release.");
+  }
+  return release;
+}
+function portableTasksetEnvironment(taskset) {
+  return portableEnvironment(taskset);
+}
+function portableTasksetTools(taskset) {
+  return portableTools(taskset);
+}
+function projectPortableTaskRecord(task) {
+  const admitted = task.metadata.portableTaskRecord;
+  if (admitted !== void 0) {
+    const original = TaskRecordSchema.parse(admitted);
+    const projected = TaskRecordSchema.parse({
+      ...original,
+      id: task.id,
+      clusterKey: task.clusterKey,
+      split: task.split,
+      input: task.input,
+      expectedOutput: portableExpectedOutput(task),
+      policyVisibleContext: task.policyVisibleContext,
+      privilegedContextRef: task.privilegedContextRef,
+      tags: task.tags,
+      artifactRefs: task.assets === void 0 ? original.artifactRefs : task.assets.map((asset) => {
+        const previous = original.artifactRefs.find((item) => item.id === asset.id);
+        return {
+          id: asset.id,
+          path: previous?.path ?? `tasks/${segment(task.id)}/${segment(asset.fileName)}`,
+          contentHash: hash(asset.sha256),
+          sizeBytes: asset.sizeBytes,
+          mediaType: asset.mediaType,
+          visibility: previous?.visibility ?? "policy"
+        };
+      }),
+      requiredOutputs: task.requiredOutputs === void 0 ? original.requiredOutputs : task.requiredOutputs.map((output) => {
+        const previous = original.requiredOutputs?.find((item) => item.path === output.path);
+        return {
+          path: output.path,
+          mediaType: output.mediaType,
+          schemaRef: previous?.schemaRef && previous.schemaRef.id === output.schemaRef ? previous.schemaRef : null,
+          maxBytes: output.maxBytes ?? null,
+          metadata: {
+            ...output.metadata,
+            ...output.schemaRef && previous?.schemaRef?.id !== output.schemaRef ? { legacySchemaRef: output.schemaRef } : {}
+          }
+        };
+      })
+    });
+    if (projected.requiredOutputs === void 0) delete projected.requiredOutputs;
+    return projected;
+  }
+  return {
+    id: task.id,
+    clusterKey: task.clusterKey,
+    split: task.split,
+    input: task.input,
+    expectedOutput: portableExpectedOutput(task),
+    policyVisibleContext: task.policyVisibleContext,
+    privilegedContextRef: task.privilegedContextRef,
+    artifactRefs: (task.assets ?? []).map((item) => ({
+      id: item.id,
+      path: `tasks/${segment(task.id)}/${segment(item.fileName)}`,
+      contentHash: hash(item.sha256),
+      sizeBytes: item.sizeBytes,
+      mediaType: item.mediaType,
+      visibility: "policy"
+    })),
+    requiredOutputs: (task.requiredOutputs ?? []).map((output) => ({
+      path: output.path,
+      mediaType: output.mediaType,
+      schemaRef: null,
+      maxBytes: output.maxBytes ?? null,
+      metadata: {
+        ...output.metadata,
+        legacySchemaRef: output.schemaRef ?? null
+      }
+    })),
+    tags: task.tags
+  };
+}
+function portableExpectedOutput(task) {
+  if (!task.expectedOutput) return null;
+  if ("artifactRenderer" in task.expectedOutput) {
+    throw new Error(
+      `Task ${task.id} embeds an artifact renderer. Put shared renderer configuration in Environment resources and reference it from the Scenario.`
+    );
+  }
+  return task.expectedOutput;
+}
+function portableEnvironment(taskset) {
+  const kind = taskset.environment.kind === "chat" ? "text" : taskset.environment.kind === "work" ? "work" : taskset.environment.kind === "program" ? "custom_program" : "agent";
+  return {
+    protocolVersion: "openpond.environment.v1",
+    kind,
+    entrypoint: taskset.environment.entrypoint,
+    stateful: taskset.environment.stateful,
+    deterministicSeeds: taskset.environment.deterministicSeeds,
+    lifecycle: ["create", "reset", "step", "collect", "destroy"],
+    networkPolicy: taskset.environment.networkPolicy,
+    defaultTimeoutMs: taskset.environment.defaultTimeoutMs
+  };
+}
+function portableTools(taskset) {
+  const admitted = taskset.environment.metadata.portableTools;
+  if (admitted !== void 0) {
+    return ToolDeclarationSchema.array().max(200).parse(admitted);
+  }
+  const bindings = taskset.environment.actionBindings ?? [];
+  if (bindings.length) return bindings.map((binding) => ({
+    name: binding.modelToolName,
+    description: binding.description,
+    inputSchema: binding.inputSchema,
+    inputSchemaHash: hash(binding.actionSchemaHash),
+    sideEffect: binding.sideEffect,
+    timeoutMs: binding.timeoutMs
+  }));
+  return taskset.environment.toolNames.map((name) => ({
+    name,
+    description: `Host-provided ${name} tool.`,
+    inputSchema: {},
+    inputSchemaHash: contentHash({}),
+    sideEffect: "write",
+    timeoutMs: taskset.environment.defaultTimeoutMs
+  }));
+}
+function portableGrader(grader) {
+  const base = {
+    id: grader.id,
+    version: grader.version,
+    weight: grader.weight,
+    hardGate: grader.hardGate,
+    rewardEligible: grader.rewardEligible,
+    privileged: grader.privileged
+  };
+  if (grader.kind === "model_judge") return {
+    ...base,
+    kind: "model_judge",
+    rubricRef: rubricAsset(grader),
+    model: modelJudgeRef(grader),
+    temperature: grader.temperature,
+    calibrationStatus: grader.calibrationStatus
+  };
+  if (grader.kind === "custom_verifier") {
+    if (grader.metadata.portableVerifierRef === void 0) {
+      throw new Error(`Custom verifier ${grader.id} requires its immutable executable asset before publication.`);
+    }
+    const imported = PortableGraderSpecSchema.safeParse(grader.metadata.portableGrader);
+    const preserveDefault = imported.success && imported.data.kind === "custom_verifier" && imported.data.exportName === void 0 && grader.exportName === "verify";
+    return {
+      ...base,
+      kind: "custom_verifier",
+      verifierRef: ImmutableAssetRefSchema.parse(grader.metadata.portableVerifierRef),
+      timeoutMs: grader.timeoutMs,
+      ...preserveDefault ? {} : { exportName: grader.exportName },
+      networkPolicy: "none"
+    };
+  }
+  if (grader.kind === "human") return {
+    ...base,
+    kind: "human",
+    rubricRef: rubricAsset(grader),
+    reviewerRole: grader.reviewerRole
+  };
+  return {
+    ...base,
+    ...portableDeterministicCheck(grader)
+  };
+}
+function portableCapabilities(taskset) {
+  const admitted = taskset.metadata.portableCapabilities;
+  if (admitted !== void 0) {
+    return CapabilityRequirementSchema.array().max(200).parse(admitted);
+  }
+  return [
+    ...taskset.capabilities.requiresTools ? [{ id: "tools", required: true, scopes: taskset.environment.toolNames }] : [],
+    ...taskset.capabilities.requiresState ? [{ id: "local-state", required: true, scopes: [] }] : [],
+    ...taskset.capabilities.requiresPrivilegedGrading ? [{ id: "private-verifier", required: true, scopes: taskset.policy.hiddenGraderRefs }] : [],
+    ...taskset.policy.connectedAppScopes.map((scope) => ({
+      id: `connected-app-${segment(scope)}`,
+      required: true,
+      scopes: [scope]
+    }))
+  ].map((requirement) => ({
+    ...requirement,
+    portability: requirement.id === "local-state" ? "host_adapter" : "portable"
+  }));
+}
+function assertReleaseBindings(input) {
+  if (input.draft.environmentRelease?.id !== input.environmentRelease.id || input.draft.environmentRelease.contentHash !== input.environmentRelease.contentHash) {
+    throw new Error("Admitted Taskset Release binds a different Environment Release.");
+  }
+  if (input.draft.verifierSetRelease?.id !== input.verifierSetRelease.id || input.draft.verifierSetRelease.contentHash !== input.verifierSetRelease.contentHash) {
+    throw new Error("Admitted Taskset Release binds a different Verifier Set Release.");
+  }
+  if (contentHash(input.draft.environment) !== contentHash(input.environmentRelease.contract)) {
+    throw new Error("Admitted Taskset Environment differs from its bound Environment Release.");
+  }
+  if (contentHash(input.draft.graders) !== contentHash(input.verifierSetRelease.graders)) {
+    throw new Error("Admitted Taskset graders differ from its bound Verifier Set Release.");
+  }
+  return input.draft;
+}
+function modelJudgeRef(grader) {
+  const previous = grader.metadata.portableGrader === void 0 ? null : PortableGraderSpecSchema.parse(grader.metadata.portableGrader);
+  const revision = previous?.kind === "model_judge" && previous.model?.providerId === grader.judge.providerId && previous.model.modelId === grader.judge.modelId ? previous.model.revision : null;
+  return { ...grader.judge, revision };
+}
+function rubricAsset(grader) {
+  const contentHash2 = sha256(grader.rubric);
+  const sizeBytes = new TextEncoder().encode(grader.rubric).byteLength;
+  const reference = grader.metadata.portableRubricRef;
+  if (reference !== void 0) {
+    const asset = ImmutableAssetRefSchema.parse(reference);
+    if (asset.contentHash !== contentHash2 || asset.sizeBytes !== sizeBytes || asset.visibility === "policy") throw new Error("Taskset rubric differs from its published private source.");
+    return asset;
+  }
+  return { id: `rubric-${grader.id}`, path: `graders/${segment(grader.id)}/rubric.md`, contentHash: contentHash2, sizeBytes, mediaType: "text/markdown", visibility: "verifier" };
+}
+function hash(value) {
+  return /^[a-f0-9]{64}$/.test(value) ? value : contentHash(value);
+}
+function segment(value) {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "asset";
+}
+
+// src/taskset-package-projection.ts
+import { learningRef as learningRef5, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
+
+// src/taskset-package-grader-projection.ts
+import { compileBoundGraders as compileBoundGraders3, resolveBoundRewards as resolveBoundRewards2 } from "@openpond/evals/rewards";
+import { learningRef as learningRef4, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+import { z } from "zod";
+function importedPackageGraders(value) {
+  const authoring = value.taskset.metadata.ordinaryAuthoring;
+  const calibrationFixtures = z.record(z.string(), z.array(z.string().min(1)).max(1e5)).parse(authoring?.judgeCalibrationFixtures ?? {});
+  return value.taskset.graders.map((grader) => {
+    const base = { ...grader, label: grader.id, metadata: { portableGrader: grader } };
+    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
+      ...base,
+      module: learningVerifierModule(grader.verifierRef.contentHash),
+      exportName: grader.exportName ?? "verify",
+      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
+    });
+    if (grader.kind === "human" || grader.kind === "model_judge") {
+      const file = value.files.find((file2) => file2.asset.id === grader.rubricRef.id);
+      if (!file) throw new Error(`Imported rubric is missing: ${grader.id}.`);
+      const rubric = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
+      const metadata = { ...base.metadata, portableRubricRef: grader.rubricRef };
+      if (grader.kind === "human") return GraderSpecSchema.parse({ ...base, rubric, metadata });
+      if (!grader.model) throw new Error(`Imported judge ${grader.id} requires its declared model before local preparation.`);
+      return GraderSpecSchema.parse({
+        ...base,
+        rubric,
+        metadata,
+        judge: grader.model,
+        temperature: grader.temperature ?? 0,
+        calibrationStatus: "pending",
+        calibrationFixtureRefs: calibrationFixtures[grader.id] ?? []
+      });
+    }
+    return GraderSpecSchema.parse({
+      ...base,
+      kind: grader.kind === "artifact" ? "file" : grader.kind,
+      config: grader.kind === "artifact" ? { ...grader.config, ...grader.config.refIncludes === void 0 ? {} : { pathIncludes: grader.config.refIncludes } } : grader.config
+    });
+  });
+}
+function projectLearningBatchGraders(binding, rewards, assets = []) {
+  const resolved = resolveBoundRewards2(binding, rewards);
+  return compileBoundGraders3(binding, rewards).map((grader) => {
+    const reward = resolved.find(({ source }) => source.graderId === grader.id).reward;
+    const base = { ...grader, label: reward.name, metadata: { rewardBinding: learningRef4(binding) } };
+    if (grader.kind === "model_judge") throw new Error(`Reward ${grader.id} needs a calibrated model execution adapter before preparation.`);
+    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
+      ...base,
+      module: learningVerifierModule(grader.verifierRef.contentHash),
+      exportName: grader.exportName ?? "verify",
+      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
+    });
+    if (grader.kind === "human") {
+      const asset = assets.find((asset2) => asset2.id === grader.rubricRef.id);
+      if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable rubric.`);
+      return GraderSpecSchema.parse({ ...base, rubric: verifyLearningTextAsset2(asset, grader.rubricRef) });
+    }
+    return GraderSpecSchema.parse({ ...base, kind: grader.kind === "artifact" ? "file" : grader.kind });
+  });
+}
+function learningVerifierModule(hash2) {
+  return `graders/reward-${hash2}.js`;
+}
+
+// src/taskset-package-projection.ts
+function prepareImportedTasksetPackage(input) {
+  const value = validateTasksetPackage(input.package);
+  const release = value.taskset;
+  const resources = value.modelResources;
+  const learning = value.learningResources ? taskBatchPackageMetadata3(release) : void 0;
+  const source = TasksetSourceRefSchema.parse({
+    schemaVersion: "openpond.uploadedFileDatasetSource.v1",
+    kind: "uploaded_file",
+    id: `package-source-${contentHash({ profileId: input.profileId, packageHash: value.contentHash })}`,
+    profileId: input.profileId,
+    title: input.name,
+    sourceHash: value.contentHash,
+    occurredAt: input.createdAt,
+    licensingStatus: "pending",
+    secretScanStatus: "pending",
+    piiScanStatus: "pending",
+    originalFileNames: ["taskset-package.json"],
+    mediaTypes: ["application/json"],
+    sourceFileHashes: [value.contentHash],
+    totalBytes: new TextEncoder().encode(JSON.stringify(value)).byteLength,
+    parserVersion: "openpond.tasksetPackage.v1",
+    metadata: {}
+  });
+  const draft = createTasksetDraft({ profileId: input.profileId, id: `${release.id}-import`, name: input.name, now: input.createdAt });
+  const files = [];
+  for (const grader of release.graders) if (grader.kind === "custom_verifier") {
+    const asset = resources?.assets.find((asset2) => asset2.id === grader.verifierRef.id);
+    const file = value.files.find((file2) => file2.asset.id === grader.verifierRef.id);
+    if (!file) throw new Error(`Imported verifier source is missing: ${grader.id}.`);
+    const name = learningVerifierModule(grader.verifierRef.contentHash);
+    if (!files.some((file2) => file2.path === name)) files.push({ path: name, role: "verifier", content: asset ? verifyLearningTextAsset3(asset, grader.verifierRef) : new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file)) });
+  }
+  const authoring = release.metadata.ordinaryAuthoring ?? release.metadata.starterAuthoring;
+  const fixtures = GraderFixtureSchema.array().max(1e5).parse(authoring?.graderFixtures ?? []);
+  const kind = release.environment.kind === "text" ? "chat" : release.environment.kind === "custom_program" ? "program" : release.environment.kind;
+  const projected = TasksetSchema.parse({
+    schemaVersion: "openpond.taskset.v1",
+    id: release.id,
+    revision: release.revision,
+    profileId: input.profileId,
+    profileRelease: null,
+    createImproveRunId: null,
+    name: input.name,
+    objective: resolveTasksetPackageInstructions(value),
+    status: "needs_review",
+    sourceRefs: [source],
+    datasetArtifact: null,
+    policy: release.policy,
+    environment: {
+      ...draft.environment,
+      kind,
+      entrypoint: release.environment.entrypoint,
+      resources: TasksetEnvironmentResourceSchema.array().max(1e4).parse(release.metadata.environmentResources ?? []),
+      stateful: release.environment.stateful,
+      deterministicSeeds: release.environment.deterministicSeeds,
+      toolNames: release.tools.map((tool) => tool.name),
+      defaultTimeoutMs: release.environment.defaultTimeoutMs,
+      networkPolicy: release.environment.networkPolicy,
+      metadata: {
+        runtimeSourceTasksetId: tasksetPackageSourceId(input.profileId, value.contentHash),
+        portableEnvironment: release.environment,
+        portableTools: release.tools,
+        portableExecutionResources: { environment: value.environment, verifierSet: value.verifierSet }
+      }
+    },
+    capabilities: {
+      ...draft.capabilities,
+      taskKind: kind === "chat" ? "chat" : kind === "program" ? "custom_program" : "single_agent",
+      compatibleMethods: ["none"],
+      requiresTools: release.tools.length > 0,
+      requiresState: release.environment.stateful,
+      rewardKinds: [...new Set(release.graders.map((grader) => grader.kind === "human" ? "human" : grader.kind === "model_judge" ? "model_judge" : "deterministic"))]
+    },
+    tasks: release.tasks.map((task) => ({
+      ...task,
+      schemaVersion: "openpond.taskData.v1",
+      sourceRefs: [source.id],
+      assets: task.artifactRefs.map((asset) => ({
+        id: asset.id,
+        sourceRefId: source.id,
+        artifactRef: asset.path,
+        fileName: asset.path.split("/").at(-1),
+        mediaType: asset.mediaType,
+        sha256: asset.contentHash,
+        sizeBytes: asset.sizeBytes,
+        split: task.split,
+        metadata: { portableAsset: asset }
+      })),
+      ...task.requiredOutputs ? { requiredOutputs: task.requiredOutputs.map((output) => ({
+        ...output,
+        schemaRef: output.schemaRef?.id ?? null,
+        maxBytes: output.maxBytes ?? void 0
+      })) } : {},
+      metadata: { portableTaskRecord: task, exampleOrigin: "imported" }
+    })),
+    graders: resources ? projectLearningBatchGraders(resources.rewardBinding, resources.rewards, resources.assets) : learning ? projectLearningBatchGraders(learning.binding, learning.rewards, value.learningResources.assets) : importedPackageGraders(value),
+    graderFixtures: fixtures,
+    learningSignals: draft.learningSignals,
+    ...release.metrics ? { metrics: release.metrics } : {},
+    authoringProvenance: {
+      schemaVersion: "openpond.taskAuthoringProvenance.v1",
+      model: null,
+      modelConfig: {},
+      skillHash: contentHash("openpond-package-import-v1"),
+      promptTemplateVersion: "package-import-v1",
+      buildIntent: "discovery",
+      buildSpecification: null,
+      evidenceHashes: [value.contentHash],
+      tasksetSdkVersion: "package-import-v1",
+      sourceCommit: null,
+      repairHistory: [],
+      createdAt: input.createdAt
+    },
+    readiness: null,
+    contentHash: "00000000",
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    metadata: {
+      importedPackageHash: value.contentHash,
+      ...learning ? { learning } : {},
+      portableFileInventory: value.files.map((file) => ({ asset: file.asset, sourcePath: file.asset.path })),
+      ...resources ? {
+        taskDefinition: learningRef5(resources.taskDefinition),
+        rewardBinding: learningRef5(resources.rewardBinding),
+        rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards }
+      } : {},
+      portableCapabilities: release.capabilities,
+      derivedPortableMetadata: release.metadata,
+      ...release.metadata.modelTasksetDerivation ? { modelTasksetDerivation: release.metadata.modelTasksetDerivation } : {}
+    }
+  });
+  return { package: value, taskset: TasksetSchema.parse({ ...projected, contentHash: computeTasksetHash(projected) }), generatedFiles: files };
+}
+function tasksetPackageSourceId(profileId, packageHash) {
+  return `package-${contentHash({ profileId, packageHash })}`;
+}
+
+// src/taskset-authored-files.ts
+import { z as z2 } from "zod";
+
+// src/taskset-authored-tool-environment.ts
+import { createEnvironmentRelease as createEnvironmentRelease2 } from "@openpond/evals";
+import { JavaScriptEnvironmentDefinitionSchema } from "@openpond/evals/javascript-environment";
+import { learningRef as learningRef6, sealLearningContent as sealLearningContent3 } from "@openpond/evals/learning";
+function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
+  if (taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return { taskset, inventory, generatedFiles: [] };
+  const declarationPath = "environment/execution.json";
+  const declaration = bytes.get(declarationPath);
+  if (!declaration || declaration.length > 524288) throw new Error("Authored tool environment requires its bounded private execution declaration.");
+  const previous = ModelStarterExecutionSchema.parse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(declaration)));
+  const repin = (ref) => {
+    if (!ref) return null;
+    const file2 = inventory.find((file3) => file3.asset.id === ref.id && file3.asset.path === ref.path);
+    if (!file2) throw new Error(`Authored environment dependency is missing: ${ref.id}.`);
+    return file2.asset;
+  };
+  const { contentHash: _javascriptHash, ...javascriptContent } = previous.javascript;
+  const javascript = JavaScriptEnvironmentDefinitionSchema.parse(sealLearningContent3({
+    ...javascriptContent,
+    id: `javascript-${taskset.id}`,
+    revision: taskset.revision,
+    module: repin(previous.javascript.module)
+  }));
+  if (contentHash(javascript.tools) !== contentHash(taskset.environment.metadata.portableTools) || contentHash(javascript.tools.map((tool) => tool.name)) !== contentHash(taskset.environment.toolNames)) throw new Error("Authored environment tools differ from the Taskset's declared tools.");
+  const environment = createEnvironmentRelease2({
+    schemaVersion: "openpond.environmentRelease.v1",
+    id: `environment-${taskset.id}`,
+    revision: taskset.revision,
+    contract: portableTasksetEnvironment(taskset),
+    actionSchemaRef: repin(previous.environment.actionSchemaRef),
+    observationSchemaRef: repin(previous.environment.observationSchemaRef),
+    stateSchemaRef: repin(previous.environment.stateSchemaRef),
+    artifactCollection: previous.environment.artifactCollection,
+    adapterConformanceHashes: {},
+    metadata: { javascriptEnvironment: learningRef6(javascript), resources: taskset.environment.resources ?? [] }
+  });
+  const prepared = TasksetSchema.parse({ ...taskset, environment: {
+    ...taskset.environment,
+    metadata: { ...taskset.environment.metadata, portableExecutionResources: { environment } }
+  } });
+  const releases = materializePortableTasksetRelease({ taskset: prepared, adapterId });
+  const file = createTasksetPackageExecutionFile({ javascript, environment, verifierSet: releases.verifierSetRelease });
+  const nextInventory = [...inventory.filter((entry) => entry.sourcePath !== declarationPath), { asset: file.asset, sourcePath: declarationPath }];
+  const finalized = TasksetSchema.parse({ ...prepared, metadata: { ...prepared.metadata, portableFileInventory: nextInventory } });
+  return {
+    taskset: TasksetSchema.parse({ ...finalized, contentHash: computeTasksetHash(finalized) }),
+    inventory: nextInventory,
+    generatedFiles: [{ path: declarationPath, role: "environment", content: new TextDecoder().decode(decodeTasksetPackageFile(file)) }]
+  };
+}
+
+// src/taskset-authored-files.ts
+var AuthoredTasksetFileInventorySchema = z2.array(z2.object({
+  asset: ImmutableAssetRefSchema,
+  sourcePath: z2.string().min(1)
+}).strict()).max(1e4);
+var GENERATED_MANIFESTS = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "environment/taskset.ts"]);
+function isGeneratedTasksetPublicationFilePath(path) {
+  return GENERATED_MANIFESTS.has(path);
+}
+function prepareAuthoredTasksetSource(tasksetInput, sourceFiles, adapterId) {
+  const taskset = TasksetSchema.parse(tasksetInput);
+  if (taskset.metadata.taskDefinition !== void 0 || taskset.metadata.rewardBinding !== void 0) return { taskset, generatedFiles: [] };
+  const bytes = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const [name, data] of sourceFiles) {
+    TasksetDraftFilePathSchema.parse(name);
+    total += data.byteLength;
+    if (bytes.size >= 1e4 || total > MAX_TASKSET_PACKAGE_BYTES * 3 / 4) throw new Error("Taskset source exceeds the package byte limit.");
+    bytes.set(name, data.slice());
+  }
+  const aggregator = taskset.metrics?.customAggregator;
+  const aggregatorBytes = aggregator ? bytes.get(aggregator.module) : void 0;
+  if (aggregator && !aggregatorBytes) throw new Error("Declared Taskset metric module is missing.");
+  const metrics = aggregator && aggregatorBytes ? { ...taskset.metrics, customAggregator: { ...aggregator, contentHash: sha256(aggregatorBytes) } } : taskset.metrics;
+  const inventory = /* @__PURE__ */ new Map();
+  const declaredPaths = /* @__PURE__ */ new Set();
+  const generatedFiles = [];
+  const ref = (id, sourcePath, mediaType, visibility) => {
+    const source = bytes.get(sourcePath);
+    if (!source) throw new Error(`Declared Taskset file is missing: ${sourcePath}.`);
+    return { id, path: sourcePath, contentHash: sha256(source), sizeBytes: source.byteLength, mediaType, visibility };
+  };
+  const add = (asset, sourcePath = asset.path) => {
+    const previous = inventory.get(asset.id);
+    if (previous && contentHash(previous) !== contentHash({ asset, sourcePath })) throw new Error(`Conflicting Taskset file identity: ${asset.id}.`);
+    const source = bytes.get(sourcePath);
+    if (!source || source.length !== asset.sizeBytes || sha256(source) !== asset.contentHash) throw new Error(`Taskset file differs from its declared bytes: ${asset.id}.`);
+    inventory.set(asset.id, { asset, sourcePath });
+    declaredPaths.add(sourcePath);
+  };
+  for (const task of taskset.tasks) {
+    const portable = projectPortableTaskRecord(task);
+    for (const asset of portable.artifactRefs) add(asset, task.assets?.find((candidate) => candidate.id === asset.id)?.artifactRef ?? asset.path);
+    for (const output of portable.requiredOutputs ?? []) if (output.schemaRef) add(output.schemaRef);
+  }
+  for (const resource of taskset.environment.resources ?? []) add(ref(resource.id, resource.path, resource.mediaType ?? "application/octet-stream", resource.visibility === "policy_visible" ? "policy" : "host_private"));
+  const graders = taskset.graders.map((grader) => {
+    if (grader.kind === "custom_verifier") {
+      let asset = ref(`verifier-${grader.id}`, grader.module, "application/javascript", "host_private");
+      const previous = ImmutableAssetRefSchema.safeParse(grader.metadata.portableVerifierRef);
+      if (previous.success && previous.data.contentHash === asset.contentHash && previous.data.sizeBytes === asset.sizeBytes) asset = previous.data;
+      add(asset, grader.module);
+      return { ...grader, metadata: { ...grader.metadata, portableVerifierRef: asset } };
+    }
+    if (grader.kind === "human" || grader.kind === "model_judge") {
+      const content = new TextEncoder().encode(grader.rubric);
+      const sourcePath = `graders/rubric-${sha256(content)}.md`;
+      bytes.set(sourcePath, content);
+      const asset = ref(`rubric-${grader.id}`, sourcePath, "text/markdown", "verifier");
+      add(asset);
+      generatedFiles.push({ path: sourcePath, role: "verifier", content: grader.rubric });
+      return { ...grader, metadata: { ...grader.metadata, portableRubricRef: asset } };
+    }
+    return grader;
+  });
+  if (aggregator && ![...inventory.values()].some((file) => file.asset.path === aggregator.module && file.sourcePath === aggregator.module && file.asset.visibility !== "policy")) {
+    add(ref(`metric-${contentHash(aggregator.module)}`, aggregator.module, "application/javascript", "host_private"));
+  }
+  const previousInventory = AuthoredTasksetFileInventorySchema.parse(taskset.metadata.portableFileInventory ?? []);
+  for (const name of [...bytes.keys()].sort()) if (!declaredPaths.has(name)) {
+    const previous = previousInventory.find((file) => file.sourcePath === name && !inventory.has(file.asset.id));
+    add(previous ? { ...ref(previous.asset.id, name, previous.asset.mediaType, previous.asset.visibility), path: previous.asset.path } : ref(`taskset-file-${contentHash(name)}`, name, "application/octet-stream", "host_private"), name);
+  }
+  const { importedPackageHash, derivedPortableMetadata: _derived, ...metadata } = taskset.metadata;
+  const environmentMetadata = { ...taskset.environment.metadata };
+  if (environmentMetadata.portableExecutionResources !== void 0) {
+    const resources = z2.object({ environment: z2.unknown(), verifierSet: z2.unknown().optional() }).parse(environmentMetadata.portableExecutionResources);
+    environmentMetadata.portableExecutionResources = { environment: resources.environment };
+  }
+  const prepared = TasksetSchema.parse({
+    ...taskset,
+    graders,
+    metrics,
+    environment: { ...taskset.environment, metadata: environmentMetadata },
+    metadata: { ...metadata, ...importedPackageHash === void 0 ? {} : { sourceImportedPackageHash: importedPackageHash }, portableFileInventory: AuthoredTasksetFileInventorySchema.parse([...inventory.values()].sort((left, right) => left.asset.id.localeCompare(right.asset.id))) }
+  });
+  const executable = prepareAuthoredToolEnvironment(prepared, bytes, [...inventory.values()], adapterId);
+  return { taskset: TasksetSchema.parse({ ...executable.taskset, contentHash: computeTasksetHash(executable.taskset) }), generatedFiles: [...generatedFiles, ...executable.generatedFiles] };
+}
+
+// src/taskset-draft-package-compiler.ts
+function compileModelTasksetDraftWorkspace(input) {
+  const workspace = validateTasksetDraftWorkspace(input.workspace);
+  const preparation = ModelTasksetDraftPreparationSchema.parse(input.preparation);
+  if (workspace.draft.id !== preparation.draftId || workspace.draft.modelScope?.modelId !== preparation.lineage.owner.modelId || contentHash(workspace.draft.modelScope?.source ?? null) !== contentHash(preparation)) throw new Error("Taskset draft differs from its retained source preparation.");
+  const taskset = publishTasksetDraft({ draft: workspace.draft, now: input.now, sourcePackageHash: workspace.contentHash });
+  const files = new Map(workspace.files.map((file) => [file.path, decodeTasksetDraftWorkspaceFile(file)]));
+  for (const [path, source] of renderTasksetDraftManifests(workspace.draft)) if (!isGeneratedTasksetPublicationFilePath(path)) files.set(path, new TextEncoder().encode(source));
+  const authored = prepareAuthoredTasksetSource(taskset, files, input.adapterId);
+  for (const file of authored.generatedFiles) files.set(file.path, new TextEncoder().encode(file.content));
+  const releases = materializePortableTasksetRelease({ taskset: authored.taskset, adapterId: input.adapterId });
+  const inventory = AuthoredTasksetFileInventorySchema.parse(authored.taskset.metadata.portableFileInventory);
+  const edited = createTasksetPackage({
+    schemaVersion: "openpond.tasksetPackage.v1",
+    taskset: releases.tasksetRelease,
+    environment: releases.environmentRelease,
+    verifierSet: releases.verifierSetRelease,
+    files: inventory.map((entry) => {
+      const bytes = files.get(entry.sourcePath);
+      if (!bytes) throw new Error(`Captured Taskset file is missing: ${entry.sourcePath}.`);
+      return { asset: entry.asset, base64: Buffer.from(bytes).toString("base64") };
+    })
+  });
+  return publishModelTasksetDraftPackage({ preparation, edited });
+}
+
+// src/taskset-draft-source.ts
+import { z as z3 } from "zod";
+import { learningRef as learningRef7, sameLearningRef as sameLearningRef4 } from "@openpond/evals/learning";
+var TasksetDraftSourceInitializationSchema = z3.object({
+  draft: TasksetDraftSchema,
+  filePaths: z3.array(z3.object({ assetId: z3.string().min(1), paths: z3.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
+}).strict();
+function prepareTasksetDraftSource(input) {
+  const source = validateTasksetPackage(input.source);
+  const original = TasksetDraftSchema.parse(input.sourceDraft);
+  const preparation = ModelTasksetDraftPreparationSchema.parse(input.preparation);
+  if (source.contentHash !== preparation.sourcePackageHash || !sameLearningRef4(learningRef7(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
+  if (source.modelResources || source.learningResources) throw new Error("This Taskset requires its bound or reviewed authoring workflow.");
+  const inventory = AuthoredTasksetFileInventorySchema.parse(original.metadata.portableFileInventory ?? []);
+  const sourcePath = (relative) => isManagedTasksetDraftFilePath(relative) ? `source-artifacts/${source.contentHash}/${contentHash(relative)}/${relative.split("/").at(-1)}` : relative;
+  const references = [
+    ...original.tasks.flatMap((task) => (task.assets ?? []).map((asset) => asset.artifactRef)),
+    ...(original.environment.resources ?? []).map((resource) => resource.path),
+    ...source.taskset.tasks.flatMap((task) => (task.requiredOutputs ?? []).flatMap((output) => output.schemaRef ? [output.schemaRef.path] : [])),
+    ...original.metrics.customAggregator ? [original.metrics.customAggregator.module] : [],
+    ...original.graders.flatMap((grader) => grader.kind === "custom_verifier" ? [grader.module] : [])
+  ];
+  if (references.some(isManagedTasksetDraftFilePath)) throw new Error("A referenced source asset occupies a reserved Taskset authoring path.");
+  const filePaths = source.files.map((file) => {
+    const paths = /* @__PURE__ */ new Set([file.asset.path]);
+    for (const entry of inventory) if (entry.asset.id === file.asset.id) paths.add(entry.sourcePath);
+    for (const task of original.tasks) for (const asset of task.assets ?? []) if (asset.id === file.asset.id) paths.add(asset.artifactRef);
+    for (const grader of source.taskset.graders) if (grader.kind === "custom_verifier" && grader.verifierRef.id === file.asset.id) {
+      const projected = original.graders.find((candidate) => candidate.id === grader.id);
+      if (projected?.kind === "custom_verifier") paths.add(projected.module);
+    }
+    return { assetId: file.asset.id, paths: [...paths].map(sourcePath) };
+  });
+  const draft = TasksetDraftSchema.parse({
+    ...original,
+    id: preparation.draftId,
+    revision: 1,
+    status: "draft",
+    environment: { ...original.environment, metadata: { ...original.environment.metadata, portableExecutionResources: { environment: source.environment } } },
+    modelScope: { modelId: preparation.lineage.owner.modelId, expectedModelRevision: input.expectedModelRevision, source: preparation },
+    publishedTasksetRef: preparation.tasksetRevision > 1 ? preparation.sourceTasksetRef : null,
+    metadata: {
+      ...original.metadata,
+      modelTasksetAuthoring: preparation.lineage,
+      portableFileInventory: inventory.map((entry) => ({ ...entry, sourcePath: sourcePath(entry.sourcePath), asset: {
+        ...entry.asset,
+        id: isManagedTasksetDraftFilePath(entry.sourcePath) ? `source-artifact-${contentHash({ packageHash: source.contentHash, assetId: entry.asset.id })}` : entry.asset.id,
+        path: sourcePath(entry.asset.path)
+      } }))
+    }
+  });
+  return TasksetDraftSourceInitializationSchema.parse({ draft, filePaths });
+}
+function materializeTasksetDraftWorkspace(input) {
+  const initialized = TasksetDraftSourceInitializationSchema.parse(input.initialized);
+  const source = validateTasksetPackage(input.source);
+  if (initialized.draft.modelScope?.source?.sourcePackageHash !== source.contentHash) throw new Error("Taskset draft lost its source preparation.");
+  const files = /* @__PURE__ */ new Map();
+  for (const mapping of initialized.filePaths) {
+    const file = source.files.find((candidate) => candidate.asset.id === mapping.assetId);
+    if (!file) throw new Error("Taskset draft source asset is missing.");
+    for (const path of mapping.paths) {
+      const previous = files.get(path);
+      if (previous && previous.contentHash !== file.asset.contentHash) throw new Error("Taskset draft source paths conflict.");
+      files.set(path, { path, contentHash: file.asset.contentHash, sizeBytes: file.asset.sizeBytes, base64: file.base64 });
+    }
+  }
+  for (const configured of configuredTasksetDraftFiles(initialized.draft)) if (!files.has(configured.relativePath)) {
+    const bytes = new TextEncoder().encode(configured.source);
+    files.set(configured.relativePath, { path: configured.relativePath, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: Buffer.from(bytes).toString("base64") });
+  }
+  let draft = initialized.draft;
+  if (draft.metrics.customAggregator) {
+    const file = files.get(draft.metrics.customAggregator.module);
+    if (!file) throw new Error("Declared Taskset metric module is missing.");
+    decodeTasksetDraftWorkspaceFile(file);
+    draft = TasksetDraftSchema.parse({ ...draft, metrics: { ...draft.metrics, customAggregator: { ...draft.metrics.customAggregator, contentHash: file.contentHash } } });
+  }
+  return createTasksetDraftWorkspace({ schemaVersion: "openpond.tasksetDraftWorkspace.v1", draft, files: [...files.values()] });
+}
 export {
+  AuthoredTasksetFileInventorySchema,
   MAX_TASKSET_PACKAGE_BYTES,
   LearningDomainError3 as ModelBatchReviewError,
   ModelBatchReviewInspectionSchema,
@@ -3359,6 +1200,7 @@ export {
   TasksetDraftFileMutationSchema,
   TasksetDraftFilePathSchema,
   TasksetDraftFileSchema,
+  TasksetDraftSourceInitializationSchema,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
   TasksetPackageLearningResourcesSchema,
@@ -3368,17 +1210,32 @@ export {
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
   beginModelBatchReview,
+  compileModelTasksetDraftWorkspace,
   createTasksetPackage,
   createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
   findModelBatchReview,
   inspectModelBatchPackage,
+  isGeneratedTasksetPublicationFilePath,
   learningPackageContextFiles,
+  learningVerifierModule,
+  materializePortableTasksetRelease,
+  materializeTasksetDraftWorkspace,
+  portableTasksetEnvironment,
+  portableTasksetTools,
+  prepareAuthoredTasksetSource,
+  prepareImportedTasksetPackage,
   prepareModelTasksetDraft,
+  prepareTasksetDraftSource,
+  projectLearningBatchGraders,
+  projectPortableTaskRecord,
+  projectPreferenceComparisonRelease,
   publishModelTasksetDraftPackage,
+  resolvePortableTasksetRewardExecution,
   resolveTasksetPackageExecution,
   resolveTasksetPackageInstructions,
   tasksetPackageRewardBinding,
+  tasksetPackageSourceId,
   validateTasksetLearningResources,
   validateTasksetPackage
 };