openpond-sdk 0.12.5 → 0.12.7

package/dist/{chunk-EJZ7HOIS.js → chunk-2XLKMZH5.js}

@@ -7,7 +7,7 @@ import {
 import {
   ModelProjectVersionedRefSchema,
   canonicalJson as canonicalJson2
-} from "./chunk-CAMLCKSF.js";
+} from "./chunk-3SIGXGAE.js";
 import {
   ImmutableAssetRefSchema,
   ImmutableReleaseRefSchema,
@@ -442,9 +442,9 @@ var require_codegen = __commonJS({
       }
     };
     var Label = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
@@ -452,14 +452,14 @@ var require_codegen = __commonJS({
       }
     };
     var Break = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
-        const label = this.label ? ` ${this.label}` : "";
-        return `break${label};` + _n;
+        const label2 = this.label ? ` ${this.label}` : "";
+        return `break${label2};` + _n;
       }
     };
     var Throw = class extends Node {
@@ -871,12 +871,12 @@ var require_codegen = __commonJS({
         return this._endBlockNode(For);
       }
       // `label` statement
-      label(label) {
-        return this._leafNode(new Label(label));
+      label(label2) {
+        return this._leafNode(new Label(label2));
       }
       // `break` statement
-      break(label) {
-        return this._leafNode(new Break(label));
+      break(label2) {
+        return this._leafNode(new Break(label2));
       }
       // `return` statement
       return(value) {
@@ -2974,7 +2974,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3001,7 +3001,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3632,7 +3632,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3890,7 +3890,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal: equal2,
       serialize,
@@ -7408,13 +7408,218 @@ var ExternalDatasetSourceRefSchema = z3.discriminatedUnion("kind", [
 ]);
 
 // src/taskset-draft-harness-actions.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../harness/dist/structured-output.js
 var import__ = __toESM(require__(), 1);
+
+// ../harness/dist/structured-output-diagnostics.js
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var escape2 = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");
+var unescape2 = (value) => value.replaceAll("~1", "/").replaceAll("~0", "~");
+var label = (path) => path || "/";
+function literal(value) {
+  const text = JSON.stringify(value);
+  return text && text.length <= 160 ? text : "the value declared in the public schema";
+}
+function at(root, parts) {
+  let value = root;
+  for (const encoded of parts) {
+    const key = unescape2(encoded);
+    if (!object(value) && !Array.isArray(value) || !Object.hasOwn(value, key))
+      return void 0;
+    value = value[key];
+  }
+  return value;
+}
+function resolve(schema, root, depth = 0) {
+  if (!object(schema) || depth > 20)
+    return null;
+  if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/")) {
+    return resolve(at(root, schema.$ref.slice(2).split("/")), root, depth + 1);
+  }
+  return schema;
+}
+function describe(schema, path, data, root, depth = 0) {
+  const rule = resolve(schema, root);
+  if (!rule || depth > 6)
+    return null;
+  const where = label(path);
+  if (Object.hasOwn(rule, "const"))
+    return `${where} must equal ${literal(rule.const)}`;
+  if (Array.isArray(rule.enum) && rule.enum.length <= 12)
+    return `${where} must be one of ${literal(rule.enum)}`;
+  if (Array.isArray(data)) {
+    if (rule.maxItems === 0)
+      return `${where} must be an empty array`;
+    const negated = object(rule.not) ? rule.not : null;
+    const every = negated && object(negated.items) ? negated.items : null;
+    const predicate = every && object(every.not) ? resolve(every.not, root) : null;
+    const required = predicate?.required;
+    if (predicate && object(predicate.properties) && Array.isArray(required)) {
+      const fields = Object.entries(predicate.properties);
+      if (fields.length && fields.every(([key, value]) => object(value) && Object.hasOwn(value, "const") && required.includes(key))) {
+        const match = Object.fromEntries(fields.map(([key, value]) => [key, value.const]));
+        return `${where} must contain at least one item matching ${literal(match)}`;
+      }
+    }
+    if (typeof rule.maxItems === "number")
+      return `${where} must contain at most ${rule.maxItems} items`;
+    if (typeof rule.minItems === "number")
+      return `${where} must contain at least ${rule.minItems} items`;
+  }
+  if (object(rule.properties) && object(data)) {
+    const parts = Object.entries(rule.properties).flatMap(([key, child]) => {
+      if (!Object.hasOwn(data, key))
+        return [];
+      const message = describe(child, path + "/" + escape2(key), data[key], root, depth + 1);
+      return message ? [message] : [];
+    });
+    if (parts.length)
+      return parts.slice(0, 4).join("; ");
+  }
+  if (Array.isArray(rule.required) && object(data)) {
+    const missing = rule.required.filter((key) => typeof key === "string" && !Object.hasOwn(data, key));
+    if (missing.length)
+      return `${where} must include ${missing.slice(0, 4).map(literal).join(", ")}`;
+  }
+  return null;
+}
+function structuredOutputDiagnostic(schema, data, error) {
+  const path = error.instancePath + (error.keyword === "required" ? "/" + escape2(String(error.params.missingProperty)) : "");
+  const parts = error.schemaPath.startsWith("#/") ? error.schemaPath.slice(2).split("/") : [];
+  let message = error.message ?? "Schema assertion failed";
+  const owner = at(schema, parts.slice(0, -1));
+  const requirement = describe(owner, error.instancePath, at(data, error.instancePath ? error.instancePath.slice(1).split("/") : []), schema);
+  for (let index = parts.length - 1; index >= 0; index--) {
+    if (parts[index] !== "then" && parts[index] !== "else")
+      continue;
+    const conditional = at(schema, parts.slice(0, index));
+    if (!object(conditional) || !object(conditional.if))
+      continue;
+    const instance = error.instancePath ? error.instancePath.slice(1).split("/") : [];
+    const suffix = parts.slice(index + 1);
+    const descents = suffix.filter((part, offset) => offset > 0 && suffix[offset - 1] === "properties" || part === "items" && suffix[offset - 1] !== "properties").length;
+    const parent = descents <= instance.length ? instance.slice(0, instance.length - descents) : [];
+    const parentPath = parent.length ? "/" + parent.join("/") : "";
+    const condition = describe(conditional.if, parentPath, at(data, parent), schema);
+    if (condition && requirement) {
+      const observed = condition.replaceAll(" must be ", " is ").replaceAll(" must equal ", " equals ").replaceAll(" must contain ", " contains ").replaceAll(" must include ", " includes ");
+      message = `${parts[index] === "then" ? "When" : "When the following condition does not hold:"} ${observed}, ${requirement}.`;
+    }
+    break;
+  }
+  if (message === error.message && requirement && ["not", "enum", "const", "minItems", "maxItems"].includes(error.keyword)) {
+    message = requirement + ".";
+  }
+  return { path, message, keyword: error.keyword, schemaPath: error.schemaPath };
+}
+
+// ../harness/dist/structured-output-sampling.js
+import { z as z4 } from "zod";
+var StructuredSamplingSchemaDeclarationSchema = z4.object({
+  schemaVersion: z4.literal("openpond.structuredSamplingSchema.v1"),
+  validationSchemaHash: z4.string().regex(/^[a-f0-9]{64}$/),
+  schemaRef: ImmutableAssetRefSchema.refine((ref) => ref.visibility === "policy" && ref.sizeBytes <= 128e3 && ["application/json", "application/schema+json"].includes(ref.mediaType), "Sampling schemas must be bounded policy-visible JSON assets."),
+  postValidationOnly: z4.array(z4.object({
+    schemaPath: z4.string().min(1).max(2e3),
+    keyword: z4.literal("maxItems"),
+    enforcement: z4.literal("full_validation_only")
+  }).strict()).min(1).max(100)
+}).strict();
+var StructuredSamplingSchemaContractSchema = z4.object({
+  declaration: StructuredSamplingSchemaDeclarationSchema,
+  schema: z4.record(z4.string(), z4.unknown()),
+  schemaHash: z4.string().regex(/^[a-f0-9]{64}$/),
+  schemaSource: z4.string().max(128e3)
+}).strict();
+function structuredSamplingSchemaDeclaration(metadata) {
+  const value = metadata?.structuredSamplingSchema;
+  return value === void 0 ? void 0 : StructuredSamplingSchemaDeclarationSchema.parse(value);
+}
+var object2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var escape3 = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
+function projectStructuredSamplingSchema(full, declarationInput) {
+  const declaration = StructuredSamplingSchemaDeclarationSchema.parse(declarationInput);
+  if (declaration.validationSchemaHash !== full.schemaHash)
+    throw new Error("structured_sampling_validation_identity_changed");
+  if (sha256Hex(full.schemaSource) !== full.schemaHash || canonicalJson(JSON.parse(full.schemaSource)) !== canonicalJson(full.schema))
+    throw new Error("structured_sampling_validation_source_changed");
+  const result = JSON.parse(full.schemaSource);
+  const targets = /* @__PURE__ */ new Map();
+  function visit(schema, path, positive = true) {
+    if (!object2(schema))
+      return;
+    if (schema.$ref !== void 0)
+      throw new Error("structured_sampling_reference_unsupported");
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (positive && types.includes("array") && Number.isSafeInteger(schema.maxItems) && Number(schema.maxItems) >= 0) {
+      targets.set(`${path}/maxItems`, schema);
+    }
+    for (const key of ["properties", "$defs"])
+      if (object2(schema[key])) {
+        for (const [name, child] of Object.entries(schema[key]))
+          visit(child, `${path}/${key}/${escape3(name)}`, positive && key !== "$defs");
+      }
+    for (const key of ["items", "additionalProperties", "then", "else", "not", "if"]) {
+      if (schema[key] !== void 0)
+        visit(schema[key], `${path}/${key}`, positive && key !== "not" && key !== "if");
+    }
+    for (const key of ["allOf", "anyOf", "oneOf"])
+      if (Array.isArray(schema[key])) {
+        schema[key].forEach((child, index) => visit(child, `${path}/${key}/${index}`, positive && key !== "oneOf"));
+      }
+  }
+  visit(result, "");
+  const seen = /* @__PURE__ */ new Set();
+  for (const assertion of declaration.postValidationOnly) {
+    const target = targets.get(assertion.schemaPath);
+    if (!target || seen.has(assertion.schemaPath))
+      throw new Error("structured_sampling_assertion_path_invalid");
+    seen.add(assertion.schemaPath);
+    delete target.maxItems;
+  }
+  return result;
+}
+function assertStructuredSamplingSchema(full, input) {
+  const sampling = StructuredSamplingSchemaContractSchema.parse(input);
+  const derived = projectStructuredSamplingSchema(full, sampling.declaration);
+  const expectedSource = JSON.stringify(derived);
+  if (sampling.schemaSource !== expectedSource || canonicalJson(sampling.schema) !== canonicalJson(derived) || sha256Hex(expectedSource) !== sampling.schemaHash || sampling.schemaHash !== sampling.declaration.schemaRef.contentHash || new TextEncoder().encode(expectedSource).byteLength !== sampling.declaration.schemaRef.sizeBytes) {
+    throw new Error("structured_sampling_schema_identity_changed");
+  }
+}
+function resolveStructuredSamplingSchema(full, declarationInput, bytes) {
+  const declaration = StructuredSamplingSchemaDeclarationSchema.parse(declarationInput);
+  if (bytes.byteLength > 128e3 || bytes.byteLength !== declaration.schemaRef.sizeBytes || sha256Hex(bytes) !== declaration.schemaRef.contentHash)
+    throw new Error("structured_sampling_asset_mismatch");
+  const schemaSource = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const sampling = {
+    declaration,
+    schema: JSON.parse(schemaSource),
+    schemaHash: declaration.schemaRef.contentHash,
+    schemaSource
+  };
+  assertStructuredSamplingSchema(full, sampling);
+  return sampling;
+}
+function structuredSamplingSchemaAssertions(full, sampling) {
+  assertStructuredSamplingSchema(full, sampling);
+  const schema = JSON.parse(full.schemaSource);
+  return sampling.declaration.postValidationOnly.map((assertion) => {
+    let value = schema;
+    for (const part of assertion.schemaPath.slice(1).split("/")) {
+      const key = part.replaceAll("~1", "/").replaceAll("~0", "~");
+      value = object2(value) || Array.isArray(value) ? Reflect.get(value, key) : void 0;
+    }
+    return { ...assertion, value };
+  });
+}
+
+// ../harness/dist/structured-output.js
 var STRUCTURED_OUTPUT_CAPABILITY = "work.structured-output.v1";
 var keywords = /* @__PURE__ */ new Set(["$schema", "$id", "$defs", "$ref", "title", "description", "type", "properties", "required", "additionalProperties", "items", "minItems", "maxItems", "minLength", "maxLength", "minimum", "maximum", "enum", "const", "allOf", "anyOf", "oneOf", "not", "if", "then", "else", "uniqueItems", "pattern", "multipleOf", "exclusiveMinimum", "exclusiveMaximum", "minProperties", "maxProperties"]);
-var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var object3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var validators = /* @__PURE__ */ new Map();
 function compiled(schema) {
   const key = sha256Hex(JSON.stringify(schema));
@@ -7428,14 +7633,14 @@ function compiled(schema) {
   return validator;
 }
 function assertStructuredOutputSchema(schema) {
-  if (!object(schema) || schema.type !== "object" || JSON.stringify(schema).length > 128e3)
+  if (!object3(schema) || schema.type !== "object" || JSON.stringify(schema).length > 128e3)
     throw new Error("structured_schema_tool_root_or_size_invalid");
   const root = schema;
   let nodes = 0;
   function visit(value, depth, ancestors) {
     if (typeof value === "boolean")
       return;
-    if (!object(value) || depth > 20 || ++nodes > 2e3 || ancestors.has(value))
+    if (!object3(value) || depth > 20 || ++nodes > 2e3 || ancestors.has(value))
       throw new Error("structured_schema_complexity_or_shape");
     const next = new Set(ancestors).add(value);
     for (const key of Object.keys(value))
@@ -7448,7 +7653,7 @@ function assertStructuredOutputSchema(schema) {
         throw new Error("structured_schema_external_or_recursive_ref");
       let target = root;
       for (const part of value.$ref.slice(2).split("/"))
-        target = object(target) && Object.hasOwn(target, part.replaceAll("~1", "/").replaceAll("~0", "~")) ? target[part.replaceAll("~1", "/").replaceAll("~0", "~")] : void 0;
+        target = object3(target) && Object.hasOwn(target, part.replaceAll("~1", "/").replaceAll("~0", "~")) ? target[part.replaceAll("~1", "/").replaceAll("~0", "~")] : void 0;
       visit(target, depth + 1, next);
     }
     if (value.pattern !== void 0) {
@@ -7460,7 +7665,7 @@ function assertStructuredOutputSchema(schema) {
     }
     for (const key of ["properties", "$defs"])
       if (value[key] !== void 0) {
-        if (!object(value[key]))
+        if (!object3(value[key]))
           throw new Error("structured_schema_map_invalid");
         for (const child of Object.values(value[key]))
           visit(child, depth + 1, next);
@@ -7492,6 +7697,8 @@ function assertStructuredOutputContract(contract) {
     throw new Error("structured_schema_contract_changed");
   if (!/^[a-f0-9]{64}$/.test(contract.schemaHash))
     throw new Error("structured_schema_hash_invalid");
+  if (contract.sampling !== void 0)
+    assertStructuredSamplingSchema(contract, contract.sampling);
 }
 function structuredOutputTools(outputs) {
   const paths = /* @__PURE__ */ new Set();
@@ -7507,7 +7714,7 @@ function structuredOutputTools(outputs) {
     if (output.mediaType !== "application/json" || !output.structuredOutput)
       throw new Error("structured_output_contract_missing");
     assertStructuredOutputContract(output.structuredOutput);
-    return [{ type: "function", function: { name: `work_submit_output_${index + 1}`, description: `Validate and save ${output.path}. Supply the output fields directly; validation errors can be corrected and resubmitted.`, parameters: output.structuredOutput.schema } }];
+    return [{ type: "function", function: { name: `work_submit_output_${index + 1}`, description: `Validate and save ${output.path}. Supply the output fields directly; validation errors can be corrected and resubmitted.${output.structuredOutput.sampling ? " Full validation also enforces the postValidationOnly limits listed in requiredOutputs; a generated call can fail those submission limits." : ""}`, parameters: output.structuredOutput.sampling ? JSON.parse(output.structuredOutput.sampling.schemaSource) : output.structuredOutput.schema } }];
   });
 }
 function structuredToolOutput(outputs, name) {
@@ -7518,7 +7725,7 @@ function validateStructuredOutput(schema, data) {
   function bound(value, depth) {
     if (depth > 30 || ++nodes > 1e4 || Array.isArray(value) && value.length > 1e3)
       throw new Error("structured_output_payload_complexity");
-    if (object(value) || Array.isArray(value))
+    if (object3(value) || Array.isArray(value))
       for (const child of Object.values(value))
         bound(child, depth + 1);
   }
@@ -7526,7 +7733,7 @@ function validateStructuredOutput(schema, data) {
   const validator = compiled(schema);
   if (validator(data))
     return [];
-  return (validator.errors ?? []).slice(0, 20).map((error) => ({ path: error.instancePath + (error.keyword === "required" ? "/" + String(error.params.missingProperty).replaceAll("~", "~0").replaceAll("/", "~1") : ""), message: error.message ?? "Schema assertion failed" }));
+  return (validator.errors ?? []).slice(0, 20).map((error) => structuredOutputDiagnostic(schema, data, error));
 }
 function validateOutputBytes(output, bytes) {
   if (bytes.byteLength > (output.maxBytes ?? 1e7))
@@ -7545,7 +7752,17 @@ function validateOutputBytes(output, bytes) {
   const errors = validateStructuredOutput(output.structuredOutput.schema, data);
   if (errors.length)
     throw new Error("structured_output_invalid:" + JSON.stringify(errors));
-  return { status: "passed", schemaHash: output.structuredOutput.schemaHash, artifactHash: sha256Hex(bytes), capability: STRUCTURED_OUTPUT_CAPABILITY };
+  return {
+    status: "passed",
+    schemaHash: output.structuredOutput.schemaHash,
+    ...output.structuredOutput.sampling ? {
+      samplingSchemaHash: output.structuredOutput.sampling.schemaHash,
+      samplingSchemaDeclaration: output.structuredOutput.sampling.declaration,
+      postValidationOnly: structuredSamplingSchemaAssertions(output.structuredOutput, output.structuredOutput.sampling)
+    } : {},
+    artifactHash: sha256Hex(bytes),
+    capability: STRUCTURED_OUTPUT_CAPABILITY
+  };
 }
 function serializeStructuredOutput(output, data) {
   const bytes = new TextEncoder().encode(JSON.stringify(data, null, 2) + "\n");
@@ -7554,38 +7771,38 @@ function serializeStructuredOutput(output, data) {
 }
 
 // src/taskset-draft-harness-actions.ts
-var HarnessActionBindingSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessActionBinding.v1"),
+var HarnessActionBindingSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessActionBinding.v1"),
   actionId: ReleaseIdSchema,
-  modelToolName: z4.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-  description: z4.string().trim().min(1).max(1e3),
-  inputSchema: z4.record(z4.string(), z4.unknown()),
+  modelToolName: z5.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z5.string().trim().min(1).max(1e3),
+  inputSchema: z5.record(z5.string(), z5.unknown()),
   actionSchemaHash: ReleaseHashSchema,
   agentRelease: ImmutableReleaseRefSchema,
   implementationHash: ReleaseHashSchema,
   runtimeBindingId: ReleaseIdSchema,
   capabilityReceiptHash: ReleaseHashSchema,
-  sideEffect: z4.enum(["read", "write"]),
-  studentVisible: z4.boolean(),
-  timeoutMs: z4.number().int().positive().max(36e5),
-  episodeArgumentBindings: z4.array(
-    z4.object({
+  sideEffect: z5.enum(["read", "write"]),
+  studentVisible: z5.boolean(),
+  timeoutMs: z5.number().int().positive().max(36e5),
+  episodeArgumentBindings: z5.array(
+    z5.object({
       argument: ReleaseIdSchema,
-      source: z4.literal("case_id")
+      source: z5.literal("case_id")
     }).strict()
   ).max(20).default([])
 }).strict();
 
 // src/taskset-draft-core.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { CustomVerifierRuntimeSchema } from "@openpond/evals/tasksets";
 import { HumanFormSchema } from "@openpond/evals/human-review";
-var IdSchema3 = z5.string().trim().min(1).max(240);
-var TimestampSchema3 = z5.string().trim().min(1);
-var HashSchema3 = z5.string().trim().min(8).max(256);
-var Sha256Schema = z5.string().trim().regex(/^[a-f0-9]{64}$/);
-var CodeIdentifierSchema = z5.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
-var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
+var IdSchema3 = z6.string().trim().min(1).max(240);
+var TimestampSchema3 = z6.string().trim().min(1);
+var HashSchema3 = z6.string().trim().min(8).max(256);
+var Sha256Schema = z6.string().trim().regex(/^[a-f0-9]{64}$/);
+var CodeIdentifierSchema = z6.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema2 = z6.record(z6.string(), z6.unknown()).default({});
 var NullableIdSchema = IdSchema3.nullable();
 function safeRelativeFilePath(value) {
   const normalized = value.trim().replaceAll("\\", "/");
@@ -7601,175 +7818,175 @@ function safeFileName(value) {
   return normalized.length > 0 && normalized !== "." && normalized !== ".." && !normalized.includes("/") && !normalized.includes("\\") && !normalized.includes("\0");
 }
 var TasksetSplitSchema = DatasetSplitSchema;
-var TasksetPurposeSchema = z5.enum(["general", "benchmark"]);
-var TasksetBenchmarkBindingSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetBenchmark.v1"),
+var TasksetPurposeSchema = z6.enum(["general", "benchmark"]);
+var TasksetBenchmarkBindingSchema = z6.object({
+  schemaVersion: z6.literal("openpond.tasksetBenchmark.v1"),
   definitionId: IdSchema3,
   releaseId: IdSchema3,
   releaseHash: Sha256Schema,
-  managedReleasePath: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
+  managedReleasePath: z6.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
   adaptationSplit: TasksetSplitSchema,
   evaluationSplit: TasksetSplitSchema,
-  primaryMetric: z5.enum([
+  primaryMetric: z6.enum([
     "foreground_tokens",
     "success_rate",
     "latency_ms",
     "cost_usd"
   ]),
-  qualityGate: z5.enum(["none", "non_regression", "all_pass"]),
-  source: z5.enum(["builtin", "imported"]),
+  qualityGate: z6.enum(["none", "non_regression", "all_pass"]),
+  source: z6.enum(["builtin", "imported"]),
   metadata: MetadataSchema2
 });
-var TasksetPreferenceComparisonBindingSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
+var TasksetPreferenceComparisonBindingSchema = z6.object({
+  schemaVersion: z6.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
   releaseId: IdSchema3,
   releaseHash: Sha256Schema,
   publishedAt: TimestampSchema3,
   metadata: MetadataSchema2
 });
-var TrainingSourceConsentSchema = z5.object({
-  status: z5.enum(["pending", "granted", "denied", "revoked"]),
-  scope: z5.enum(["metadata_only", "selected_turns", "full_session"]),
+var TrainingSourceConsentSchema = z6.object({
+  status: z6.enum(["pending", "granted", "denied", "revoked"]),
+  scope: z6.enum(["metadata_only", "selected_turns", "full_session"]),
   grantedBy: NullableIdSchema,
   grantedAt: TimestampSchema3.nullable(),
-  purpose: z5.literal("task_authoring_and_evaluation")
+  purpose: z6.literal("task_authoring_and_evaluation")
 });
-var TrainingSourceRefSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingSource.v1"),
+var TrainingSourceRefSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingSource.v1"),
   id: IdSchema3,
   profileId: IdSchema3,
   sessionId: IdSchema3,
-  turnIds: z5.array(IdSchema3).max(1e3).default([]),
+  turnIds: z6.array(IdSchema3).max(1e3).default([]),
   workspaceId: NullableIdSchema,
   sourceHash: HashSchema3,
   clusterKey: IdSchema3,
-  title: z5.string().trim().min(1).max(500),
+  title: z6.string().trim().min(1).max(500),
   occurredAt: TimestampSchema3,
   consent: TrainingSourceConsentSchema,
-  connectedAppIds: z5.array(IdSchema3).max(100).default([]),
-  secretScanStatus: z5.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z5.enum(["pending", "passed", "review", "blocked"]),
-  licensingStatus: z5.enum(["pending", "approved", "review", "blocked"]),
+  connectedAppIds: z6.array(IdSchema3).max(100).default([]),
+  secretScanStatus: z6.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z6.enum(["pending", "passed", "review", "blocked"]),
+  licensingStatus: z6.enum(["pending", "approved", "review", "blocked"]),
   metadata: MetadataSchema2
 });
-var TasksetSourceRefSchema = z5.union([
+var TasksetSourceRefSchema = z6.union([
   TrainingSourceRefSchema,
   ExternalDatasetSourceRefSchema,
   ConnectedDatasetSourceRefSchema
 ]);
-var TaskPolicyBoundarySchema = z5.object({
-  policyVisibleFields: z5.array(IdSchema3).max(1e3).default([]),
-  privilegedFields: z5.array(IdSchema3).max(1e3).default([]),
-  hiddenGraderRefs: z5.array(IdSchema3).max(100).default([]),
-  connectedAppScopes: z5.array(IdSchema3).max(100).default([])
+var TaskPolicyBoundarySchema = z6.object({
+  policyVisibleFields: z6.array(IdSchema3).max(1e3).default([]),
+  privilegedFields: z6.array(IdSchema3).max(1e3).default([]),
+  hiddenGraderRefs: z6.array(IdSchema3).max(100).default([]),
+  connectedAppScopes: z6.array(IdSchema3).max(100).default([])
 });
-var TaskAssetRefSchema = z5.object({
+var TaskAssetRefSchema = z6.object({
   id: IdSchema3,
   sourceRefId: IdSchema3,
-  artifactRef: z5.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
-  fileName: z5.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
-  stagingPath: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Task asset staging paths must stay inside Work inputs.").optional(),
-  mediaType: z5.string().trim().min(1).max(200),
+  artifactRef: z6.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
+  fileName: z6.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
+  stagingPath: z6.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Task asset staging paths must stay inside Work inputs.").optional(),
+  mediaType: z6.string().trim().min(1).max(200),
   sha256: Sha256Schema,
-  sizeBytes: z5.number().int().nonnegative().max(25e7),
+  sizeBytes: z6.number().int().nonnegative().max(25e7),
   split: TasksetSplitSchema,
   metadata: MetadataSchema2
 }).superRefine((value, ctx) => {
   if (value.stagingPath && value.stagingPath.split("/").at(-1) !== value.fileName)
     ctx.addIssue({ code: "custom", message: "Staged task assets must preserve their source file name.", path: ["stagingPath"] });
 });
-var TaskRequiredOutputSchema = z5.object({
-  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
-  mediaType: z5.string().trim().min(1).max(200),
+var TaskRequiredOutputSchema = z6.object({
+  path: z6.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
+  mediaType: z6.string().trim().min(1).max(200),
   schemaRef: IdSchema3.nullable().optional(),
-  submissionMode: z5.literal("structured_json").optional(),
-  maxBytes: z5.number().int().positive().max(1e7).optional(),
+  submissionMode: z6.literal("structured_json").optional(),
+  maxBytes: z6.number().int().positive().max(1e7).optional(),
   metadata: MetadataSchema2
 });
-var TaskDataRecordSchema = z5.object({
-  schemaVersion: z5.literal("openpond.taskData.v1"),
+var TaskDataRecordSchema = z6.object({
+  schemaVersion: z6.literal("openpond.taskData.v1"),
   id: IdSchema3,
   clusterKey: IdSchema3,
   split: TasksetSplitSchema,
-  input: z5.record(z5.string(), z5.unknown()),
-  expectedOutput: z5.record(z5.string(), z5.unknown()).nullable(),
-  policyVisibleContext: z5.record(z5.string(), z5.unknown()).default({}),
+  input: z6.record(z6.string(), z6.unknown()),
+  expectedOutput: z6.record(z6.string(), z6.unknown()).nullable(),
+  policyVisibleContext: z6.record(z6.string(), z6.unknown()).default({}),
   privilegedContextRef: NullableIdSchema,
-  sourceRefs: z5.array(IdSchema3).min(1).max(100),
-  assets: z5.array(TaskAssetRefSchema).max(1e3).optional(),
-  resourceRefs: z5.array(IdSchema3).max(1e3).optional(),
-  requiredOutputs: z5.array(TaskRequiredOutputSchema).max(100).optional(),
-  tags: z5.array(IdSchema3).max(100).default([]),
+  sourceRefs: z6.array(IdSchema3).min(1).max(100),
+  assets: z6.array(TaskAssetRefSchema).max(1e3).optional(),
+  resourceRefs: z6.array(IdSchema3).max(1e3).optional(),
+  requiredOutputs: z6.array(TaskRequiredOutputSchema).max(100).optional(),
+  tags: z6.array(IdSchema3).max(100).default([]),
   metadata: MetadataSchema2
 });
-var TasksetEnvironmentResourceSchema = z5.object({
+var TasksetEnvironmentResourceSchema = z6.object({
   id: IdSchema3,
-  kind: z5.enum(["file", "catalog", "configuration", "code_module"]),
-  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
-  mediaType: z5.string().trim().min(1).max(200).nullable().optional(),
-  visibility: z5.enum(["policy_visible", "policy_hidden", "privileged"]),
-  required: z5.boolean(),
+  kind: z6.enum(["file", "catalog", "configuration", "code_module"]),
+  path: z6.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
+  mediaType: z6.string().trim().min(1).max(200).nullable().optional(),
+  visibility: z6.enum(["policy_visible", "policy_hidden", "privileged"]),
+  required: z6.boolean(),
   metadata: MetadataSchema2
 });
-var LearningSignalBaseSchema = z5.object({
+var LearningSignalBaseSchema = z6.object({
   id: IdSchema3,
   taskId: NullableIdSchema,
-  sourceRefs: z5.array(IdSchema3).min(1).max(100),
+  sourceRefs: z6.array(IdSchema3).min(1).max(100),
   artifactRef: IdSchema3,
-  approved: z5.boolean(),
-  confidence: z5.number().min(0).max(1),
+  approved: z6.boolean(),
+  confidence: z6.number().min(0).max(1),
   metadata: MetadataSchema2
 });
 var DemonstrationSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("demonstration"),
-  prompt: z5.string().max(1e5).nullable().default(null),
-  response: z5.string().max(2e5).nullable().default(null)
+  kind: z6.literal("demonstration"),
+  prompt: z6.string().max(1e5).nullable().default(null),
+  response: z6.string().max(2e5).nullable().default(null)
 });
 var PreferenceSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("preference"),
-  prompt: z5.string().max(1e5),
-  chosen: z5.string().max(2e5),
-  rejected: z5.string().max(2e5),
-  rationale: z5.string().max(1e5).nullable().default(null)
+  kind: z6.literal("preference"),
+  prompt: z6.string().max(1e5),
+  chosen: z6.string().max(2e5),
+  rejected: z6.string().max(2e5),
+  rationale: z6.string().max(1e5).nullable().default(null)
 });
 var CorrectionSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("correction"),
-  original: z5.string().max(2e5),
-  corrected: z5.string().max(2e5),
-  rationale: z5.string().max(1e5).nullable().default(null)
+  kind: z6.literal("correction"),
+  original: z6.string().max(2e5),
+  corrected: z6.string().max(2e5),
+  rationale: z6.string().max(1e5).nullable().default(null)
 });
 var FeedbackSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("feedback"),
-  feedback: z5.string().max(1e5),
-  polarity: z5.enum(["positive", "negative", "mixed", "neutral"])
+  kind: z6.literal("feedback"),
+  feedback: z6.string().max(1e5),
+  polarity: z6.enum(["positive", "negative", "mixed", "neutral"])
 });
 var RewardSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("reward"),
-  task: z5.string().max(1e5),
-  rules: z5.array(z5.object({
+  kind: z6.literal("reward"),
+  task: z6.string().max(1e5),
+  rules: z6.array(z6.object({
     id: IdSchema3,
-    points: z5.number().finite(),
-    condition: z5.string().trim().min(1).max(1e5)
+    points: z6.number().finite(),
+    condition: z6.string().trim().min(1).max(1e5)
   })).min(1).max(1e3),
-  otherwisePoints: z5.number().finite(),
-  executable: z5.boolean()
+  otherwisePoints: z6.number().finite(),
+  executable: z6.boolean()
 });
 var LabelSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("label"),
-  labelKind: z5.literal("rubric"),
-  task: z5.string().max(1e5),
-  criteria: z5.array(z5.object({
+  kind: z6.literal("label"),
+  labelKind: z6.literal("rubric"),
+  task: z6.string().max(1e5),
+  criteria: z6.array(z6.object({
     id: IdSchema3,
-    label: z5.string().trim().min(1).max(500),
-    description: z5.string().trim().min(1).max(1e5)
+    label: z6.string().trim().min(1).max(500),
+    description: z6.string().trim().min(1).max(1e5)
   })).min(1).max(1e3),
-  calibrationExamples: z5.object({
-    positive: z5.string().trim().min(1).max(2e5),
-    negative: z5.string().trim().min(1).max(2e5),
-    boundary: z5.string().trim().min(1).max(2e5)
+  calibrationExamples: z6.object({
+    positive: z6.string().trim().min(1).max(2e5),
+    negative: z6.string().trim().min(1).max(2e5),
+    boundary: z6.string().trim().min(1).max(2e5)
   })
 });
-var LearningSignalRefSchema = z5.discriminatedUnion("kind", [
+var LearningSignalRefSchema = z6.discriminatedUnion("kind", [
   DemonstrationSignalSchema,
   PreferenceSignalSchema,
   CorrectionSignalSchema,
@@ -7777,85 +7994,85 @@ var LearningSignalRefSchema = z5.discriminatedUnion("kind", [
   RewardSignalSchema,
   LabelSignalSchema
 ]);
-var LearningSignalInventorySchema = z5.object({
-  demonstrations: z5.array(DemonstrationSignalSchema).max(1e5).default([]),
-  preferences: z5.array(PreferenceSignalSchema).max(1e5).default([]),
-  corrections: z5.array(CorrectionSignalSchema).max(1e5).default([]),
-  feedback: z5.array(FeedbackSignalSchema).max(1e5).default([]),
-  rewards: z5.array(RewardSignalSchema).max(1e5).default([]),
-  labels: z5.array(LabelSignalSchema).max(1e5).default([])
-});
-var TasksetEnvironmentContractSchema = z5.object({
-  protocolVersion: z5.literal("openpond.taskEnvironment.v1"),
-  kind: z5.enum(["chat", "agent", "program", "stateful_harness", "work"]),
-  entrypoint: z5.string().trim().min(1).max(1e3),
-  stateful: z5.boolean(),
-  deterministicSeeds: z5.boolean(),
-  toolNames: z5.array(IdSchema3).max(200).default([]),
-  actionBindings: z5.array(HarnessActionBindingSchema).max(200).optional(),
-  lifecycle: z5.array(z5.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
-  defaultTimeoutMs: z5.number().int().positive().max(36e5),
-  networkPolicy: z5.enum(["none", "declared_read_only", "declared_scoped"]),
-  resources: z5.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
+var LearningSignalInventorySchema = z6.object({
+  demonstrations: z6.array(DemonstrationSignalSchema).max(1e5).default([]),
+  preferences: z6.array(PreferenceSignalSchema).max(1e5).default([]),
+  corrections: z6.array(CorrectionSignalSchema).max(1e5).default([]),
+  feedback: z6.array(FeedbackSignalSchema).max(1e5).default([]),
+  rewards: z6.array(RewardSignalSchema).max(1e5).default([]),
+  labels: z6.array(LabelSignalSchema).max(1e5).default([])
+});
+var TasksetEnvironmentContractSchema = z6.object({
+  protocolVersion: z6.literal("openpond.taskEnvironment.v1"),
+  kind: z6.enum(["chat", "agent", "program", "stateful_harness", "work"]),
+  entrypoint: z6.string().trim().min(1).max(1e3),
+  stateful: z6.boolean(),
+  deterministicSeeds: z6.boolean(),
+  toolNames: z6.array(IdSchema3).max(200).default([]),
+  actionBindings: z6.array(HarnessActionBindingSchema).max(200).optional(),
+  lifecycle: z6.array(z6.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
+  defaultTimeoutMs: z6.number().int().positive().max(36e5),
+  networkPolicy: z6.enum(["none", "declared_read_only", "declared_scoped"]),
+  resources: z6.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
   metadata: MetadataSchema2
 });
-var TasksetCapabilityManifestSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetCapabilities.v1"),
-  taskKind: z5.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
-  supportedSignals: z5.array(z5.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
-  compatibleMethods: z5.array(z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
-  rewardKinds: z5.array(z5.enum(["none", "exact", "deterministic", "model_judge", "human"])),
-  requiresTools: z5.boolean(),
-  requiresState: z5.boolean(),
-  requiresPrivilegedGrading: z5.boolean(),
-  environmentPlacements: z5.array(z5.enum(["local", "remote", "colocated", "provider_native"])),
-  exportable: z5.boolean(),
-  portabilityBlockers: z5.array(z5.string().trim().min(1).max(2e3)).default([])
-});
-var GraderBaseSchema = z5.object({
+var TasksetCapabilityManifestSchema = z6.object({
+  schemaVersion: z6.literal("openpond.tasksetCapabilities.v1"),
+  taskKind: z6.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
+  supportedSignals: z6.array(z6.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
+  compatibleMethods: z6.array(z6.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
+  rewardKinds: z6.array(z6.enum(["none", "exact", "deterministic", "model_judge", "human"])),
+  requiresTools: z6.boolean(),
+  requiresState: z6.boolean(),
+  requiresPrivilegedGrading: z6.boolean(),
+  environmentPlacements: z6.array(z6.enum(["local", "remote", "colocated", "provider_native"])),
+  exportable: z6.boolean(),
+  portabilityBlockers: z6.array(z6.string().trim().min(1).max(2e3)).default([])
+});
+var GraderBaseSchema = z6.object({
   id: IdSchema3,
-  taskIds: z5.array(IdSchema3).min(1).max(1e4).refine((ids) => new Set(ids).size === ids.length, "Grader task IDs must be unique.").optional(),
-  version: z5.string().trim().min(1).max(100),
-  label: z5.string().trim().min(1).max(500),
-  weight: z5.number().min(0).max(1e3).default(1),
-  hardGate: z5.boolean().default(false),
-  rewardEligible: z5.boolean().default(false),
-  privileged: z5.boolean().default(false),
+  taskIds: z6.array(IdSchema3).min(1).max(1e4).refine((ids) => new Set(ids).size === ids.length, "Grader task IDs must be unique.").optional(),
+  version: z6.string().trim().min(1).max(100),
+  label: z6.string().trim().min(1).max(500),
+  weight: z6.number().min(0).max(1e3).default(1),
+  hardGate: z6.boolean().default(false),
+  rewardEligible: z6.boolean().default(false),
+  privileged: z6.boolean().default(false),
   metadata: MetadataSchema2
 });
 var DeterministicGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
-  config: z5.record(z5.string(), z5.unknown())
+  kind: z6.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
+  config: z6.record(z6.string(), z6.unknown())
 });
 var RubricGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("model_judge"),
-  rubric: z5.string().trim().min(1).max(5e4),
+  kind: z6.literal("model_judge"),
+  rubric: z6.string().trim().min(1).max(5e4),
   judge: ChatModelRefSchema,
-  calibrationFixtureRefs: z5.array(IdSchema3).min(1).max(500),
-  calibrationStatus: z5.enum(["pending", "passed", "failed"]),
-  temperature: z5.number().min(0).max(2).default(0)
+  calibrationFixtureRefs: z6.array(IdSchema3).min(1).max(500),
+  calibrationStatus: z6.enum(["pending", "passed", "failed"]),
+  temperature: z6.number().min(0).max(2).default(0)
 });
 var HumanGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("human"),
+  kind: z6.literal("human"),
   form: HumanFormSchema.optional(),
-  rubric: z5.string().trim().min(1).max(5e4),
-  reviewerRole: z5.string().trim().min(1).max(500)
+  rubric: z6.string().trim().min(1).max(5e4),
+  reviewerRole: z6.string().trim().min(1).max(500)
 });
 var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("custom_verifier"),
+  kind: z6.literal("custom_verifier"),
   runtime: CustomVerifierRuntimeSchema.optional(),
-  module: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
+  module: z6.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
   exportName: CodeIdentifierSchema,
-  timeoutMs: z5.number().int().positive().max(3e5),
-  networkPolicy: z5.literal("none")
+  timeoutMs: z6.number().int().positive().max(3e5),
+  networkPolicy: z6.literal("none")
 });
-var GraderSpecSchema = z5.union([
+var GraderSpecSchema = z6.union([
   DeterministicGraderSpecSchema,
   RubricGraderSpecSchema,
   HumanGraderSpecSchema,
   CustomVerifierGraderSpecSchema
 ]);
-var GraderFixtureLabelSchema = z5.enum([
+var GraderFixtureLabelSchema = z6.enum([
   "positive",
   "negative",
   "boundary",
@@ -7863,19 +8080,19 @@ var GraderFixtureLabelSchema = z5.enum([
   "prompt_injection",
   "infrastructure_failure"
 ]);
-var GraderFixtureSchema = z5.object({
+var GraderFixtureSchema = z6.object({
   id: IdSchema3,
   taskId: IdSchema3,
   label: GraderFixtureLabelSchema,
-  output: z5.record(z5.string(), z5.unknown()),
-  infrastructureError: z5.string().trim().min(1).max(1e4).nullable(),
-  expectedPassed: z5.boolean(),
-  expectedRewardEligible: z5.boolean(),
+  output: z6.record(z6.string(), z6.unknown()),
+  infrastructureError: z6.string().trim().min(1).max(1e4).nullable(),
+  expectedPassed: z6.boolean(),
+  expectedRewardEligible: z6.boolean(),
   metadata: MetadataSchema2
 });
 
 // src/model-starter-execution.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
 import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment/contracts";
 import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
@@ -7884,17 +8101,17 @@ import {
   NativeHarnessExperimentAttemptSchema,
   verifyNativeHarnessExperimentAttempt
 } from "@openpond/evals/experiments";
-var HashSchema4 = z6.string().regex(/^[a-f0-9]{64}$/);
-var ModelStarterEnvironmentAttemptSchema = /* @__PURE__ */ (() => z6.object({
-  schemaVersion: z6.literal("openpond.javascriptEnvironmentAttempt.v1"),
-  taskId: z6.string(),
-  status: z6.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
-  output: z6.string().nullable(),
-  collected: z6.boolean(),
-  environmentCleanupComplete: z6.boolean(),
-  snapshot: z6.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema4, seed: z6.number().int(), initialStateHash: HashSchema4, finalStateHash: HashSchema4, state: z6.record(z6.string(), z6.unknown()), events: z6.array(z6.record(z6.string(), z6.unknown())) }).strict().nullable(),
-  messages: z6.array(z6.unknown()),
-  error: z6.string().nullable(),
+var HashSchema4 = z7.string().regex(/^[a-f0-9]{64}$/);
+var ModelStarterEnvironmentAttemptSchema = /* @__PURE__ */ (() => z7.object({
+  schemaVersion: z7.literal("openpond.javascriptEnvironmentAttempt.v1"),
+  taskId: z7.string(),
+  status: z7.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
+  output: z7.string().nullable(),
+  collected: z7.boolean(),
+  environmentCleanupComplete: z7.boolean(),
+  snapshot: z7.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema4, seed: z7.number().int(), initialStateHash: HashSchema4, finalStateHash: HashSchema4, state: z7.record(z7.string(), z7.unknown()), events: z7.array(z7.record(z7.string(), z7.unknown())) }).strict().nullable(),
+  messages: z7.array(z7.unknown()),
+  error: z7.string().nullable(),
   contentHash: HashSchema4
 }).strict())();
 function verifyModelStarterEnvironmentAttempt(value, context) {
@@ -7904,13 +8121,13 @@ function verifyModelStarterEnvironmentAttempt(value, context) {
   if (sealLearningContent(content).contentHash !== contentHash2 || result.taskId !== context.taskId || result.snapshot && (!equal(result.snapshot.definition, context.javascript) || result.snapshot.inputHash !== sealLearningContent(context.input).contentHash || result.snapshot.seed !== context.seed || result.snapshot.finalStateHash !== sealLearningContent(result.snapshot.state).contentHash)) throw new Error("Starter environment attempt differs from its admitted task or recorded bytes.");
   return result;
 }
-var ModelStarterExecutionSchema = z6.object({
+var ModelStarterExecutionSchema = z7.object({
   environment: EnvironmentReleaseSchema,
   verifierSet: VerifierSetReleaseSchema,
   javascript: JavaScriptEnvironmentDefinitionSchema
 }).strict();
-var ModelStarterToolFixtureScriptSchema = z6.object({
-  actions: z6.array(z6.object({ name: z6.string().min(1).max(64), arguments: z6.record(z6.string(), z6.unknown()) }).strict()).max(1e3)
+var ModelStarterToolFixtureScriptSchema = z7.object({
+  actions: z7.array(z7.object({ name: z7.string().min(1).max(64), arguments: z7.record(z7.string(), z7.unknown()) }).strict()).max(1e3)
 }).strict();
 function modelStarterExecutionAssetId(context) {
   if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
@@ -7973,10 +8190,10 @@ function validateModelStarterExecution(execution, taskset, assets) {
 }
 
 // src/model-taskset-resources.ts
-import { z as z7 } from "zod";
+import { z as z8 } 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 = z7.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
+var ModelTasksetExecutionResourcesSchema = z8.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
 function modelTasksetExecutionResourcesAssetId(context) {
   if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Taskset execution references are missing.");
   return `taskset-execution-${sealLearningContent2({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
@@ -8000,28 +8217,28 @@ function assertIntegrity(resources) {
 }
 
 // src/model-taskset-derivation.ts
-import { z as z8 } from "zod";
+import { z as z9 } 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";
-var OwnerSchema = z8.object({ scopeId: z8.string().trim().min(1).max(500), modelId: z8.string().trim().min(1).max(500) }).strict();
-var ModelTasksetDerivationSchema = z8.object({
-  schemaVersion: z8.literal("openpond.modelTasksetDerivation.v1"),
+var OwnerSchema = z9.object({ scopeId: z9.string().trim().min(1).max(500), modelId: z9.string().trim().min(1).max(500) }).strict();
+var ModelTasksetDerivationSchema = z9.object({
+  schemaVersion: z9.literal("openpond.modelTasksetDerivation.v1"),
   owner: OwnerSchema,
   root: ModelProjectVersionedRefSchema,
   parent: ModelProjectVersionedRefSchema
 }).strict();
-var ModelTasksetPackageSchema = z8.object({
+var ModelTasksetPackageSchema = z9.object({
   taskset: TasksetReleaseSchema,
   taskDefinition: TaskDefinitionSchema,
   rewardBinding: RewardBindingSchema,
-  rewards: z8.array(RewardReleaseSchema).min(1).max(100),
-  assets: z8.array(LearningTextAssetSchema).max(1e3),
+  rewards: z9.array(RewardReleaseSchema).min(1).max(100),
+  assets: z9.array(LearningTextAssetSchema).max(1e3),
   executionResources: ModelTasksetExecutionResourcesSchema.optional(),
   execution: ModelStarterExecutionSchema.optional(),
-  instructionMode: z8.literal("per_task").optional()
+  instructionMode: z9.literal("per_task").optional()
 }).strict();
 var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
 var identity = (owner, root) => `model-taskset-${sealLearningContent3({ owner, root }).contentHash}`;
@@ -8102,7 +8319,7 @@ function validateModelTasksetPackage(value) {
   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 = z8.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
+    const metadata = z9.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.");
@@ -8137,7 +8354,7 @@ function validateModelTasksetPackage(value) {
 }
 
 // src/taskset-package-learning.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import {
   TaskBatchSchema,
   TaskEvidenceSchema,
@@ -8151,12 +8368,12 @@ import {
   taskBatchPackageMetadata,
   verifyLearningTextAsset as verifyLearningTextAsset4
 } from "@openpond/evals/learning";
-var TasksetPackageLearningResourcesSchema = z9.object({
+var TasksetPackageLearningResourcesSchema = z10.object({
   batch: TaskBatchSchema,
-  evidence: z9.array(TaskEvidenceSchema).min(1).max(1e4),
-  decisions: z9.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
-  sources: z9.array(LearningSourceSchema).min(1).max(1e4),
-  assets: z9.array(LearningTextAssetSchema2).max(1e3)
+  evidence: z10.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z10.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
+  sources: z10.array(LearningSourceSchema).min(1).max(1e4),
+  assets: z10.array(LearningTextAssetSchema2).max(1e3)
 }).strict();
 function learningPackageContextFiles(resources) {
   return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
@@ -8234,11 +8451,11 @@ function validateTasksetLearningResources(taskset, input) {
 }
 
 // src/taskset-package-files.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z10.object({
+var TasksetPackageFileSchema = z11.object({
   asset: ImmutableAssetRefSchema,
-  base64: z10.string()
+  base64: z11.string()
 }).strict();
 function decodeTasksetPackageFile(value) {
   const file = TasksetPackageFileSchema.parse(value);
@@ -8289,7 +8506,7 @@ function createTasksetPackageExecutionFile(execution) {
 }
 
 // src/taskset-calibration-fixtures.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 import { compileBoundGraders as compileBoundGraders2, createRewardBinding, RewardReleaseRefSchema } from "@openpond/evals/rewards";
 import { TaskRecordSchema } from "@openpond/evals/tasksets";
 import {
@@ -8300,21 +8517,21 @@ import {
   rewardCalibrationClosureAsset,
   MAX_REWARD_CALIBRATION_CLOSURE_BYTES
 } from "@openpond/evals/learning/reward-calibration-closure";
-var ProjectionSchema = z11.object({
-  schemaVersion: z11.literal("openpond.connectedRewardCalibrationProjection.v1"),
+var ProjectionSchema = z12.object({
+  schemaVersion: z12.literal("openpond.connectedRewardCalibrationProjection.v1"),
   sourceReward: RewardReleaseRefSchema,
   fixtureSet: ImmutableAssetRefSchema,
   calibrationCheck: LearningRevisionRefSchema,
   fixture: RewardFixtureSchema,
-  fixtureHash: z11.string().regex(/^[a-f0-9]{64}$/),
-  checkResultHash: z11.string().regex(/^[a-f0-9]{64}$/),
-  independentCalibrationTask: z11.literal(true),
+  fixtureHash: z12.string().regex(/^[a-f0-9]{64}$/),
+  checkResultHash: z12.string().regex(/^[a-f0-9]{64}$/),
+  independentCalibrationTask: z12.literal(true),
   closureRef: ImmutableAssetRefSchema,
-  graderId: z11.string().min(1).max(240).optional()
+  graderId: z12.string().min(1).max(240).optional()
 }).strict();
 function authoredFixtures(value) {
   const authoring = value.taskset.metadata.ordinaryAuthoring ?? value.taskset.metadata.starterAuthoring;
-  return z11.object({ graderFixtures: GraderFixtureSchema.array().max(1e5).default([]) }).passthrough().parse(authoring ?? {}).graderFixtures;
+  return z12.object({ graderFixtures: GraderFixtureSchema.array().max(1e5).default([]) }).passthrough().parse(authoring ?? {}).graderFixtures;
 }
 function isIndependent(fixture) {
   const projection = fixture.metadata.rewardCalibration;
@@ -8432,7 +8649,7 @@ function readPrivateClosure(value, reference) {
     if (ref && isAlias(ref)) fail("calibration_closure_environment_schema_alias");
   for (const metadata of [value.taskset.metadata.environmentResources, value.environment.metadata.resources]) {
     if (metadata === void 0) continue;
-    const resources = z11.array(z11.object({ id: z11.string().optional(), path: z11.string(), visibility: z11.string().optional() }).passthrough()).parse(metadata);
+    const resources = z12.array(z12.object({ id: z12.string().optional(), path: z12.string(), visibility: z12.string().optional() }).passthrough()).parse(metadata);
     for (const resource of resources) {
       const file = value.files.find((item) => item.asset.path === resource.path);
       if (resource.id === reference.id || resource.path === reference.path || file && isAlias(file.asset))
@@ -8453,7 +8670,7 @@ function fail(code) {
 function assertJudgeFixtureMembership(value, grader, selected, closure) {
   const graderId = grader.id;
   const authoring = value.taskset.metadata.ordinaryAuthoring ?? value.taskset.metadata.starterAuthoring;
-  const mapping = z11.object({ judgeCalibrationFixtures: z11.record(z11.string(), z11.array(z11.string().min(1)).max(500)) }).passthrough().parse(authoring);
+  const mapping = z12.object({ judgeCalibrationFixtures: z12.record(z12.string(), z12.array(z12.string().min(1)).max(500)) }).passthrough().parse(authoring);
   const expected = closure.check.fixtureRefs.map((ref) => `calibration-${contentHash([selected.sourceReward, ref.id])}`);
   if (contentHash(mapping.judgeCalibrationFixtures[graderId] ?? []) !== contentHash(expected)) fail("calibration_judge_membership_changed");
   const fixtures = authoredFixtures(value);
@@ -8471,7 +8688,7 @@ function assertJudgeFixtureMembership(value, grader, selected, closure) {
 }
 
 // src/taskset-package-contracts.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 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 assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
@@ -8493,23 +8710,23 @@ function assertModelTasksetAuthoring(taskset) {
 
 // src/taskset-package-contracts.ts
 var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z12.object({
-  schemaVersion: z12.literal("openpond.tasksetPackage.v1"),
+var TasksetPackageContentSchema = z13.object({
+  schemaVersion: z13.literal("openpond.tasksetPackage.v1"),
   taskset: TasksetReleaseSchema2,
   environment: EnvironmentReleaseSchema3,
   verifierSet: VerifierSetReleaseSchema3,
-  files: z12.array(TasksetPackageFileSchema).max(1e4),
+  files: z13.array(TasksetPackageFileSchema).max(1e4),
   modelResources: BoundModelResourcesSchema.optional(),
   learningResources: TasksetPackageLearningResourcesSchema.optional()
 }).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z12.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z13.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 = z12.object({ instructions: z12.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
+  const authoring = z13.object({ instructions: z13.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
   return authoring.instructions ?? "";
 }
 function validateTasksetPackage(value, maximumBytes = MAX_TASKSET_PACKAGE_BYTES) {
@@ -8537,10 +8754,17 @@ function validateTasksetPackage(value, maximumBytes = MAX_TASKSET_PACKAGE_BYTES)
   for (const task of taskset.tasks) {
     for (const asset of task.artifactRefs) requireAsset(asset);
     for (const output of task.requiredOutputs ?? []) {
+      const sampling = structuredSamplingSchemaDeclaration(output.metadata);
+      if (sampling && output.submissionMode !== "structured_json") throw new Error("Sampling schema requires a structured output.");
       if (output.schemaRef) requireAsset(output.schemaRef);
       if (output.submissionMode === "structured_json") {
         if (!output.schemaRef || output.schemaRef.visibility !== "policy" || output.mediaType !== "application/json" || environment.contract.kind !== "work") throw new Error("Structured output requires a policy-visible JSON schema in Work.");
-        resolveStructuredOutput(decodeTasksetPackageFile(files.get(output.schemaRef.id)), output.schemaRef.contentHash);
+        const full = resolveStructuredOutput(decodeTasksetPackageFile(files.get(output.schemaRef.id)), output.schemaRef.contentHash);
+        if (sampling) {
+          requireAsset(sampling.schemaRef);
+          if (!task.artifactRefs.some((ref) => same2(ref, sampling.schemaRef))) throw new Error("Sampling schema must be an ordinary declared policy artifact.");
+          resolveStructuredSamplingSchema(full, sampling, decodeTasksetPackageFile(files.get(sampling.schemaRef.id)));
+        }
       }
     }
     if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
@@ -8564,7 +8788,7 @@ function validateTasksetPackage(value, maximumBytes = MAX_TASKSET_PACKAGE_BYTES)
   }
   for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
     if (declarations === void 0) continue;
-    for (const resource of z12.array(z12.object({ path: z12.string().min(1) }).passthrough()).parse(declarations)) {
+    for (const resource of z13.array(z13.object({ path: z13.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}.`);
     }
   }
@@ -8604,12 +8828,22 @@ function resolveTasksetWorkOutputs(input, taskId) {
     maxBytes: output.maxBytes,
     ...output.submissionMode === "structured_json" ? {
       submissionMode: "structured_json",
-      structuredOutput: resolveStructuredOutput(decodeTasksetPackageFile(value.files.find((file) => file.asset.id === output.schemaRef.id)), output.schemaRef.contentHash)
+      structuredOutput: (() => {
+        const full = resolveStructuredOutput(decodeTasksetPackageFile(value.files.find((file) => file.asset.id === output.schemaRef.id)), output.schemaRef.contentHash);
+        const sampling = structuredSamplingSchemaDeclaration(output.metadata);
+        return sampling ? { ...full, sampling: resolveStructuredSamplingSchema(
+          full,
+          sampling,
+          decodeTasksetPackageFile(value.files.find((file) => file.asset.id === sampling.schemaRef.id))
+        ) } : full;
+      })()
     } : {}
   }));
 }
 
 export {
+  structuredSamplingSchemaDeclaration,
+  resolveStructuredSamplingSchema,
   resolveStructuredOutput,
   structuredOutputTools,
   structuredToolOutput,
@@ -8706,4 +8940,4 @@ export {
   createTasksetPackage,
   resolveTasksetWorkOutputs
 };
-//# sourceMappingURL=chunk-EJZ7HOIS.js.map
+//# sourceMappingURL=chunk-2XLKMZH5.js.map