@tangle-network/agent-eval 0.221.7 → 0.222.0

package/dist/{schema-CvhfLjtZ.js → schema-YUIXT8iW.js}

@@ -1,5 +1,35 @@
-import { n as isRecord } from "./json-BhdsJaOQ.js";
-//#region src/rollout/gate-checks.ts
+import { n as isRecord } from "./json-DtvZNAU9.js";
+// src/rollout/license.ts
+const LICENSE_CLASSES = [
+	"open-weight-api",
+	"restricted",
+	"evaluation-only",
+	"human"
+];
+const RESTRICTED = /claude|anthropic|\b(?:opus|sonnet|haiku|fable)\b|codex|\bjev\b/i;
+const OPEN_WEIGHT = /\b(?:glm|deepseek|kimi|moonshot|qwen|llama|mistral|mixtral|gemma|minimax|gpt-oss|olmo|phi)/i;
+/** Classify a model or harness name; `null` when it names no known family. */
+function licenseClassOfName(name) {
+	if (!name) return null;
+	if (RESTRICTED.test(name)) return "restricted";
+	if (OPEN_WEIGHT.test(name)) return "open-weight-api";
+	return null;
+}
+/** The line's stated class, else the class its model or harness implies. */
+function licenseClassOf(line) {
+	const { license_class, model, harness } = line.policy;
+	if (license_class !== void 0) return license_class;
+	const byHarness = licenseClassOfName(harness);
+	if (byHarness === "restricted") return byHarness;
+	return licenseClassOfName(model) ?? byHarness;
+}
+/** Every line passes without `allowed`; with it, the line's class must be listed. */
+function isLicenseEligible(line, allowed) {
+	if (allowed === void 0) return true;
+	const license = licenseClassOf(line);
+	return license !== null && allowed.includes(license);
+}
+// src/rollout/gate-checks.ts
 /**
 * Every gate check in the package, in the order they are applied.
 *
@@ -341,8 +371,7 @@ function gateErrors(subject, policy) {
 	}
 	return errors;
 }
-//#endregion
-//#region src/rollout/schema.ts
+// src/rollout/schema.ts
 /**
 * `tangle.rollout.v1` — THE canonical rollout serialization, owned by
 * agent-eval. One JSONL line per agent invocation (a solo eval run, a
@@ -621,6 +650,8 @@ function validateRolloutIdentity(value, errors) {
 			"config_hash",
 			"agent_profile_cell_id"
 		]) if (value.policy[key] !== void 0 && !isStringOrNull(value.policy[key])) errors.push(`policy.${key}: expected string|null when present`);
+		const license = value.policy.license_class;
+		if (license !== void 0 && !LICENSE_CLASSES.includes(license)) errors.push(`policy.license_class: expected one of ${LICENSE_CLASSES.join("|")}`);
 	}
 }
 /** Check the messages, tool definitions and steps arrays. */
@@ -885,7 +916,6 @@ function assertMinted(value, context = "rollout line") {
 function assertMintedLines(values, context = "rollout line") {
 	return values.map((value, i) => assertMinted(value, `${context} [${i}]`));
 }
-//#endregion
-export { gatedEvidenceOf as _, assertMinted as a, assertRolloutLine as c, isTrainableSplit as d, validateRolloutLine as f, gateErrors as g, GATE_POLICIES as h, ROLLOUT_SPLITS as i, gateGamedOutcome as l, GATE_CHECK_IDS as m, ROLLOUT_ROLES as n, assertMintedLines as o, GATE_CHECKS as p, ROLLOUT_SCHEMA as r, assertRewardGate as s, ROLLOUT_CAPTURES as t, isRolloutLine as u, undeclaredStepPayload as v };
+export { licenseClassOfName as S, gatedEvidenceOf as _, assertMinted as a, isLicenseEligible as b, assertRolloutLine as c, isTrainableSplit as d, validateRolloutLine as f, gateErrors as g, GATE_POLICIES as h, ROLLOUT_SPLITS as i, gateGamedOutcome as l, GATE_CHECK_IDS as m, ROLLOUT_ROLES as n, assertMintedLines as o, GATE_CHECKS as p, ROLLOUT_SCHEMA as r, assertRewardGate as s, ROLLOUT_CAPTURES as t, isRolloutLine as u, undeclaredStepPayload as v, licenseClassOf as x, LICENSE_CLASSES as y };
 
-//# sourceMappingURL=schema-CvhfLjtZ.js.map
+//# sourceMappingURL=schema-YUIXT8iW.js.map

package/dist/schema-YUIXT8iW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-YUIXT8iW.js","names":[],"sources":["../src/rollout/license.ts","../src/rollout/gate-checks.ts","../src/rollout/schema.ts"],"sourcesContent":["/**\n * The terms a rollout line's outputs carry, read from who produced it.\n *\n * `policy.model` and `policy.provider` already name the producer model and the\n * serving provider; `policy.license_class` states the terms those outputs carry:\n *\n *   - `open-weight-api` — an open-weight model (GLM, DeepSeek, Kimi, Qwen…),\n *                         whichever API served it.\n *   - `restricted`      — Claude, Codex and Jev outputs, whose provider terms\n *                         restrict training a competing model.\n *   - `evaluation-only` — data licensed for measurement.\n *   - `human`           — written by a person.\n *\n * Importers state the class. A line that does not is classified from its model\n * and harness names, restricted patterns first, so `claude-*` on any harness and\n * the `codex` harness on any model stay restricted. A line nothing classifies is\n * `null`.\n *\n * The class is provenance, not a default filter: every class trains unless a run\n * names the classes it accepts (Drew, 2026-10-25: train on everything), so a\n * dataset can be re-cut by class later without re-importing.\n */\n\nimport type { RolloutLine } from './schema'\n\nexport type LicenseClass = 'open-weight-api' | 'restricted' | 'evaluation-only' | 'human'\nexport const LICENSE_CLASSES: readonly LicenseClass[] = [\n  'open-weight-api',\n  'restricted',\n  'evaluation-only',\n  'human',\n]\n\nconst RESTRICTED = /claude|anthropic|\\b(?:opus|sonnet|haiku|fable)\\b|codex|\\bjev\\b/i\nconst OPEN_WEIGHT =\n  /\\b(?:glm|deepseek|kimi|moonshot|qwen|llama|mistral|mixtral|gemma|minimax|gpt-oss|olmo|phi)/i\n\n/** Classify a model or harness name; `null` when it names no known family. */\nexport function licenseClassOfName(name: string | null | undefined): LicenseClass | null {\n  if (!name) return null\n  if (RESTRICTED.test(name)) return 'restricted'\n  if (OPEN_WEIGHT.test(name)) return 'open-weight-api'\n  return null\n}\n\n/** The line's stated class, else the class its model or harness implies. */\nexport function licenseClassOf(line: Pick<RolloutLine, 'policy'>): LicenseClass | null {\n  const { license_class, model, harness } = line.policy\n  if (license_class !== undefined) return license_class\n  const byHarness = licenseClassOfName(harness)\n  if (byHarness === 'restricted') return byHarness\n  return licenseClassOfName(model) ?? byHarness\n}\n\n/** Every line passes without `allowed`; with it, the line's class must be listed. */\nexport function isLicenseEligible(\n  line: Pick<RolloutLine, 'policy'>,\n  allowed?: readonly LicenseClass[],\n): boolean {\n  if (allowed === undefined) return true\n  const license = licenseClassOf(line)\n  return license !== null && allowed.includes(license)\n}\n","/**\n * THE canonical list of anti-Goodhart gate checks, plus the TOTAL policy every\n * entry point has to declare over it.\n *\n * Four rounds of adversarial review found the same defect four times, and it\n * was never the check itself: it was the COMPOSITION. `validateRolloutLine`\n * composed one check, `assertMinted` composed two, `assertRewardGate` composed\n * two of the three, `assertGateReport` composed its own pair — each by hand, in\n * its own file. So a check added to the package applied wherever its author\n * happened to remember, and the guard that forgot it looked exactly like the\n * guard that didn't. The last leak was literally that: `assertRewardGate`\n * composed `reward-relationship` + `gated-evidence` and not `unscreened-reward`,\n * so a never-screened positive reward that `assertMinted` correctly REFUSED\n * walked through all four waist exporters at full value.\n *\n * The fix is to make hand-composition impossible rather than to add a third\n * call to the two places that had two:\n *\n *   - `GATE_CHECKS` is a TOTAL map over `GateCheckId`. A new id with no\n *     implementation does not compile.\n *   - `GatePolicy` is a TOTAL map over `GateCheckId`. Every entry point\n *     declares one, so a new id makes EVERY entry point's policy a type error\n *     until it is wired. Wiring it means writing `enforced`, `repairedBy(...)`\n *     or `omittedBecause(...)` — and the last two force a written reason, so a\n *     silent gap is not expressible.\n *   - every check carries a `tripwire`: the minimal outcome it must refuse.\n *     `gate-checks.test.ts` feeds each tripwire to every entry point that\n *     declares `enforced` and requires a rejection, so wiring a check to the\n *     wrong disposition is a TEST failure even when it type-checks.\n *\n * Adding a check is therefore: append the id, write the check, and the compiler\n * enumerates every place that has to decide about it.\n */\n\nimport type { GatedEvidence, RolloutOutcome, RolloutStep } from './schema'\n\n/**\n * Every gate check in the package, in the order they are applied.\n *\n * Order is load-bearing only for which message a caller sees first: a line that\n * trips two checks reports the earlier one, and `reward-relationship` is first\n * because it is the invariant the other three protect.\n */\nexport const GATE_CHECK_IDS = [\n  'reward-relationship',\n  'gated-evidence',\n  'undeclared-step-payload',\n  'unscreened-reward',\n] as const\n\nexport type GateCheckId = (typeof GATE_CHECK_IDS)[number]\n\n/**\n * An outcome as it reaches a check.\n *\n * Deliberately accepts a raw record as well as the typed shape: the checks are\n * the RUNTIME half of the gate, and the callers they exist for — JSON off a\n * ledger, a plain-JavaScript consumer of the published package — arrive with no\n * types at all. `Partial` because a tripwire states only the fields it trips on.\n */\nexport type GateCheckedOutcome = Partial<RolloutOutcome> | Readonly<Record<string, unknown>>\n\n/**\n * What a gate check reads: the reward-bearing surface of ONE LINE.\n *\n * For three rounds the subject was the OUTCOME alone, and that assumption is\n * what produced the next leak rather than any missing check: `steps[]` sits on\n * the LINE, outside `outcome`, so a per-step reward on a gated line was read by\n * no check at all while `toRewardRows` copied it out verbatim — through the\n * MINTED door, not merely the raw one. Widening the subject is what makes\n * \"somewhere else on the line\" a place the checks can see.\n *\n * `outcome` is REQUIRED, and that is the point: a bare `RolloutOutcome` is then\n * not assignable to a subject, so every call site that used to pass one is a\n * COMPILE error until it passes the line instead. A subject with an optional\n * `outcome` would have let the old call sites keep compiling while silently\n * checking nothing — the exact failure this module exists to make impossible.\n */\ninterface GateSubject {\n  outcome: GateCheckedOutcome\n  /** The line's trajectory steps, when it carries any. */\n  steps?: unknown\n}\n\n/** One untyped field read off the outcome, so every check narrows from the same place. */\nconst field = (subject: GateSubject, name: string): unknown =>\n  (subject.outcome as Readonly<Record<string, unknown>>)?.[name]\n\nexport interface GateCheck {\n  id: GateCheckId\n  /** One sentence: what this check refuses. */\n  refuses: string\n  /** One dotted-path message per defect; `[]` when the line is clean. */\n  errors: (subject: GateSubject) => string[]\n  /**\n   * Every minimal subject that MUST trip `errors` — the executable form of\n   * `refuses`, and the reason a check cannot be added without being provable.\n   * The calibration test feeds each one to every entry point declaring\n   * `enforced`.\n   *\n   * A LIST rather than one case: a check that refuses two distinct populations\n   * (a positive reward AND a reward it cannot read as a number) proved able to\n   * hold for the first while silently passing the second, so each population\n   * states its own tripwire and each is exercised separately.\n   */\n  tripwires: GateSubject[]\n}\n\n// ---------------------------------------------------------------------------\n// Total readers. Every \"is this positive?\" / \"is this populated?\" question the\n// checks ask goes through one of these.\n// ---------------------------------------------------------------------------\n\n/**\n * How the gate reads one `outcome.reward`.\n *\n * TOTAL over `unknown`, with an explicit `unreadable` case, because the\n * recurring defect across four rounds was a hand-written type test whose\n * NEGATIVE branch silently passed: `typeof reward !== 'number' || !(reward > 0)`\n * returned \"clean\" for `reward: \"0.95\"`, so a plain-JavaScript producer that\n * stringifies its numbers — the exact population the runtime backstop exists\n * for — shipped a gamed run at full value through three waist exporters.\n *\n * A value the gate cannot read as a number is not evidence the reward is\n * cleared; it is the absence of that evidence, and the gate fails closed on it.\n */\ntype RewardReading =\n  /** `null`/`undefined` — a labeled gap, which is never a positive signal. */\n  | { kind: 'absent' }\n  /** A number at or below zero: the gate's own verdict, applied. */\n  | { kind: 'cleared' }\n  /** A number above zero, `Infinity` and the 5e-324 denormal included. */\n  | { kind: 'positive'; shown: string }\n  /** Anything the wire format does not permit here, plus `NaN`. */\n  | { kind: 'unreadable'; shown: string }\n\nfunction readReward(value: unknown): RewardReading {\n  if (value === null || value === undefined) return { kind: 'absent' }\n  if (typeof value === 'number') {\n    if (Number.isNaN(value)) return { kind: 'unreadable', shown: 'NaN' }\n    return value > 0 ? { kind: 'positive', shown: String(value) } : { kind: 'cleared' }\n  }\n  return {\n    kind: 'unreadable',\n    shown: `${JSON.stringify(value) ?? String(value)} (${typeof value})`,\n  }\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/**\n * Whether a reward-derived field carries anything at all.\n *\n * The previous emptiness test was `Object.keys(value).length > 0`, which reads\n * `[]` for a NUMBER, a BOOLEAN and the empty string — so `metrics: 0.95` on a\n * gated line counted as empty and shipped verbatim in the verifiers format's\n * per-rubric score dict. `Object.keys` being total over primitives is not the\n * same property as being CORRECT over them.\n *\n * The rule that has no such hole: only `undefined`, `null` and a record with no\n * keys are empty. Everything else is payload, whatever its type.\n */\nfunction payloadIsPopulated(value: unknown): boolean {\n  if (value === undefined || value === null) return false\n  if (isPlainRecord(value)) return Object.keys(value).length > 0\n  return true\n}\n\n/**\n * Every key `tangle.rollout.v1` declares on a step, as a TOTAL map over the\n * interface: a field added to `RolloutStep` and not to this list does not\n * compile, so the list cannot silently fall behind the schema it mirrors.\n *\n * This is the producer's OWN classification, which is the only partition\n * `gatedEvidenceOf` accepts — a key-name heuristic (\"strip anything matching\n * /reward|score/\") holds until someone names a field `credit` and the next\n * per-step signal ships at full value.\n */\nconst DECLARED_STEP_KEYS: { readonly [K in keyof Required<RolloutStep>]: true } = {\n  kind: true,\n  name: true,\n  input: true,\n  output: true,\n  status: true,\n  durationMs: true,\n  llm_call_count: true,\n  prompt_token_ids: true,\n  completion_token_ids: true,\n  logprobs: true,\n}\n\n/**\n * The part of `steps` the wire format has no name for — a per-step reward, a\n * per-step score, whatever a producer decided to hang there.\n *\n * `undefined` when the steps carry nothing undeclared.\n */\nexport function undeclaredStepPayload(steps: unknown): unknown {\n  if (steps === undefined || steps === null) return undefined\n  // The format says `steps` is a list. Anything else is wholly unclassified.\n  if (!Array.isArray(steps)) return steps\n  const extras: Array<Record<string, unknown>> = []\n  let found = false\n  for (const step of steps) {\n    const extra: Record<string, unknown> = {}\n    if (isPlainRecord(step)) {\n      for (const [key, value] of Object.entries(step)) {\n        if (key in DECLARED_STEP_KEYS) continue\n        extra[key] = value\n        found = true\n      }\n    } else if (step !== undefined && step !== null) {\n      // A step that is not even a record carries no declared key to keep.\n      extras.push({ step } as Record<string, unknown>)\n      found = true\n      continue\n    }\n    extras.push(extra)\n  }\n  return found ? extras : undefined\n}\n\n/** `steps` projected down to the keys the wire format declares. */\nexport function declaredSteps(steps: unknown): RolloutStep[] | undefined {\n  if (!Array.isArray(steps)) return undefined\n  const kept: RolloutStep[] = []\n  for (const step of steps) {\n    if (!isPlainRecord(step)) continue\n    const projected: Record<string, unknown> = {}\n    for (const [key, value] of Object.entries(step)) {\n      if (key in DECLARED_STEP_KEYS) projected[key] = value\n    }\n    kept.push(projected as unknown as RolloutStep)\n  }\n  return kept\n}\n\n/**\n * THE anti-Goodhart invariant, checked as a RELATIONSHIP between two fields\n * rather than as two independent type checks.\n *\n * Everything upstream of a training export is allowed to be wrong; this is the\n * one thing that cannot be. `realness_gated: true` means the run faked its\n * success signal, so its reward is a fabrication, and a fabrication above zero\n * is precisely what a trainer would learn to reproduce. Validating only that\n * `reward` is a number and `realness_gated` is a boolean is what let a line\n * claiming `{reward: 0.95, realness_gated: true}` validate clean and walk\n * through every exporter.\n */\nconst rewardRelationship: GateCheck = {\n  id: 'reward-relationship',\n  refuses: 'a positive — or unreadable — reward on a line the authenticity screen flagged as gamed',\n  tripwires: [\n    { outcome: { reward: 0.95, realness_gated: true } },\n    // The second population, stated separately because the check held for the\n    // first while passing this one for a full round.\n    { outcome: { reward: '0.95' as unknown as number, realness_gated: true } },\n  ],\n  errors: (subject) => {\n    if (field(subject, 'realness_gated') !== true) return []\n    const reading = readReward(field(subject, 'reward'))\n    if (reading.kind === 'absent' || reading.kind === 'cleared') return []\n    if (reading.kind === 'unreadable') {\n      return [\n        `outcome.reward: ${reading.shown} with outcome.realness_gated: true — the wire format ` +\n          'declares this field `number | null`, so the gate cannot read this value as a number ' +\n          'and cannot establish that the reward was cleared. On a run flagged as gamed that is ' +\n          'not evidence of a zero, it is the absence of it, and a consumer that coerces the ' +\n          'value (`\"0.95\"`, `\"2\"`) reads a positive reward off a faked success. Emit a number ' +\n          'or null — `trainingReward` / `trainingScore` from `rollout/reward.ts` produce one.',\n      ]\n    }\n    return [\n      `outcome.reward: ${reading.shown} with outcome.realness_gated: true — a run flagged as ` +\n        'gamed may not carry a positive reward. The anti-Goodhart gate forces the reward to 0 (a ' +\n        'real verdict: the gate decided) before the line is written, so a fine-tune cannot learn ' +\n        'from a faked success. Derive the reward with `trainingReward` / `trainingScore` from ' +\n        '`rollout/reward.ts`, or drop the line.',\n    ]\n  },\n}\n\n/**\n * The reward-bearing outcome fields that are NOT the scalar: the numbers the\n * reward was computed from, and the verdict record that claimed it.\n *\n * Returned as one block rather than filtered key-by-key. A key-name heuristic\n * (\"zero anything matching `layer.*` or `/score/`\") is the same defect shape as\n * the line-oriented regex the AST score guard replaced: it holds until someone\n * names a metric `pass_fraction`, and the next reward-shaped key ships at full\n * value. The producer's OWN classification — \"this is the scalar, that is\n * everything else\" — is the only partition that cannot be out-guessed.\n */\nexport function gatedEvidenceOf(subject: GateSubject): GatedEvidence | undefined {\n  const evidence: GatedEvidence = {}\n  // `payloadIsPopulated`, not an inline key count: a plain-JavaScript caller can\n  // hand any value here, and a non-record `metrics` is still reward-derived\n  // payload. See that function for the primitives an `Object.keys` test missed.\n  const metrics = field(subject, 'metrics')\n  if (payloadIsPopulated(metrics)) evidence.metrics = metrics as Record<string, unknown>\n  const verdict = field(subject, 'verdict')\n  if (verdict !== null && verdict !== undefined) evidence.verdict = verdict\n  const steps = undeclaredStepPayload(subject.steps)\n  if (steps !== undefined) evidence.steps = steps\n  return evidence.metrics === undefined && evidence.verdict === undefined && steps === undefined\n    ? undefined\n    : evidence\n}\n\n/**\n * The invariant is about the OUTCOME, not about one field of it.\n *\n * `mintRolloutRows` bulk-copied `RunRecord.outcome.raw` into `outcome.metrics`\n * with no gate, so a gated run exported `reward: 0` (correct) while the\n * deterministic per-layer scores that reward was COMPUTED FROM — the `layer.*`\n * keys `rl/verifiable-reward.ts` calls the RL training signal — shipped at 1.0,\n * in the top-level `metrics` dict of the Prime Intellect verifiers format, which\n * IS that format's per-rubric score dict. `verdict` leaks the same way into\n * `toRftItem`'s `reference.verdict`, where a grader author reads\n * `resolved: true` off a run that faked it.\n */\nconst gatedEvidence: GateCheck = {\n  id: 'gated-evidence',\n  refuses: 'the numbers a fabricated reward was computed from, riding along at reward 0',\n  tripwires: [\n    { outcome: { reward: 0, realness_gated: true, metrics: { 'layer.tests': 1 } } },\n    // A PRIMITIVE `metrics`: `Object.keys(0.95)` is `[]`, so the emptiness test\n    // this check used to run reported it clean and the verifiers format shipped\n    // it as its per-rubric score dict.\n    { outcome: { reward: 0, realness_gated: true, metrics: 0.95 as unknown as never } },\n  ],\n  errors: (subject) => {\n    if (field(subject, 'realness_gated') !== true) return []\n    const evidence = gatedEvidenceOf(subject)\n    if (evidence === undefined) return []\n    // Each check reports only the fields it owns; `steps` is `undeclared-step-payload`.\n    if (evidence.metrics === undefined && evidence.verdict === undefined) return []\n    const path = evidence.metrics !== undefined ? 'outcome.metrics' : 'outcome.verdict'\n    return [\n      `${path} is populated with outcome.realness_gated: true — a run flagged as gamed may not ` +\n        'ship the numbers its fabricated reward was computed from, even at reward 0. The ' +\n        'per-layer scores in `metrics` ARE the reward signal in the verifiers format, and ' +\n        '`verdict` is the record that claimed the success. Mint through `assertMinted`, which ' +\n        'relocates both to `provenance.gated_evidence` (see `gateGamedOutcome`), or drop the line.',\n    ]\n  },\n}\n\n/**\n * A reward-bearing field hung on `steps[]`, where the gate was not looking.\n *\n * The first three checks all read `outcome`, so the whole apparatus was blind to\n * anything a producer wrote elsewhere on the line — and `toRewardRows` emits\n * `steps` verbatim beside the scalar it just forced to 0. A generated corpus\n * found it in twenty cases: a gated line carrying\n * `steps: [{kind, name, reward: 0.86}]` exported `{\"reward\": 0, \"steps\":\n * [{\"reward\": 0.86}]}`, which is the per-step credit assignment of a run that\n * faked its success, at full value, through the MINTED door.\n *\n * `RolloutStep` declares ten keys and none of them is a reward, so the partition\n * needs no judgement call: whatever the format does not name is unclassified\n * payload, and on a gated line unclassified payload is exactly what the gate\n * refuses. `assertMinted` relocates it rather than rejecting, like the sibling\n * check, so an already-published ledger stays readable.\n */\nconst undeclaredStepPayloadCheck: GateCheck = {\n  id: 'undeclared-step-payload',\n  refuses: 'per-step reward signal hung on a gated line’s steps, outside every field the gate read',\n  tripwires: [\n    {\n      outcome: { reward: 0, realness_gated: true },\n      steps: [{ kind: 'tool', name: 'edit', reward: 0.9 }],\n    },\n  ],\n  errors: (subject) => {\n    if (field(subject, 'realness_gated') !== true) return []\n    const extra = undeclaredStepPayload(subject.steps)\n    if (extra === undefined) return []\n    return [\n      `steps[] carries fields \\`${ROLLOUT_SCHEMA_NAME}\\` does not declare (${JSON.stringify(extra).slice(0, 120)}) ` +\n        'with outcome.realness_gated: true — a per-step reward is training signal exactly like ' +\n        'the scalar, and the exporters copy `steps` through verbatim, so zeroing `outcome.reward` ' +\n        'while leaving it in place ships the gamed run’s step-level credit assignment at full ' +\n        'value. Mint through `assertMinted`, which projects the steps down to the declared keys ' +\n        'and relocates the rest to `provenance.gated_evidence.steps` (see `gateGamedOutcome`).',\n    ]\n  },\n}\n\n/** Named here rather than imported, so `gate-checks` stays free of schema cycles. */\nconst ROLLOUT_SCHEMA_NAME = 'tangle.rollout.v1'\n\n/**\n * A positive reward whose producer DECLARED that no authenticity screen exists.\n *\n * `realness_gated: false` is the screen's VERDICT, so writing it with no screen\n * behind it claims \"we looked and nothing fired\" about a reward nobody looked\n * at. `realness_screened: false` is the producer saying so out loud, and a\n * positive reward carrying it is exactly the signal the gate exists to qualify\n * with nothing having qualified it.\n */\nconst unscreenedReward: GateCheck = {\n  id: 'unscreened-reward',\n  refuses: 'a positive reward whose producer declares that no authenticity screen ever ran',\n  tripwires: [\n    { outcome: { reward: 1, realness_gated: false, realness_screened: false } },\n    {\n      outcome: {\n        reward: '2' as unknown as number,\n        realness_gated: false,\n        realness_screened: false,\n      },\n    },\n  ],\n  errors: (subject) => {\n    if (field(subject, 'realness_screened') !== false) return []\n    const reading = readReward(field(subject, 'reward'))\n    if (reading.kind === 'absent' || reading.kind === 'cleared') return []\n    return [\n      `outcome.reward: ${reading.shown} with outcome.realness_screened: false — this producer declares ` +\n        'that NO authenticity screen ran on this reward, so nothing has established the success ' +\n        'is real, and an unscreened positive reward is exactly the signal the anti-Goodhart gate ' +\n        'exists to qualify. Screen the run and write the verdict (`rolloutRewardFields` from a ' +\n        '`RunRecord` carrying `outcome.realness`), or emit `reward: null` — an unqualified ' +\n        'verdict is a labeled gap, not a measured success.',\n    ]\n  },\n}\n\n/**\n * The registry. Total over `GateCheckId`, so an id with no check does not\n * compile, and `GATE_CHECK_IDS` stays the single enumeration everything\n * iterates.\n */\nexport const GATE_CHECKS: { readonly [K in GateCheckId]: GateCheck } = {\n  'reward-relationship': rewardRelationship,\n  'gated-evidence': gatedEvidence,\n  'undeclared-step-payload': undeclaredStepPayloadCheck,\n  'unscreened-reward': unscreenedReward,\n}\n\n/**\n * What ONE entry point does about ONE check.\n *\n * `repair` and `omit` both carry a mandatory sentence, which is the mechanism\n * that keeps a legitimate omission distinguishable from a forgotten one: you\n * cannot skip a check without writing down why, and the reasons are readable\n * side by side in `GATE_POLICIES`.\n */\nexport type GateCheckDisposition =\n  | { readonly kind: 'enforce' }\n  /** Resolved by TRANSFORMING the line instead of rejecting it; `by` names the function. */\n  | { readonly kind: 'repair'; readonly by: string }\n  /** Deliberately not applied here; `because` states the reason. */\n  | { readonly kind: 'omit'; readonly because: string }\n\nconst enforced: GateCheckDisposition = { kind: 'enforce' }\nconst repairedBy = (by: string): GateCheckDisposition => ({ kind: 'repair', by })\nconst omittedBecause = (because: string): GateCheckDisposition => ({\n  kind: 'omit',\n  because,\n})\n\n/** Total over `GateCheckId`: a new check makes every policy literal a type error. */\nexport type GatePolicy = { readonly [K in GateCheckId]: GateCheckDisposition }\n\n/**\n * Every entry point that decides about the gate, and what it decides.\n *\n * Read this as the package's gate policy in one screen. The four entry points\n * are not interchangeable — a validator that rejects, a mint funnel that\n * repairs, a runtime backstop for untyped callers, and a release certifier over\n * emitted rows — and the dispositions say which is which.\n */\nexport const GATE_POLICIES = {\n  /**\n   * The schema validator. Rejects the reward relationship and NOTHING ELSE, on\n   * purpose: it runs on every line read off disk, and the other two conditions\n   * describe artifacts that already exist.\n   */\n  validateRolloutLine: {\n    // Stays a REJECTION rather than a transformation. A caller emitting\n    // `{reward: 0.95, realness_gated: true}` is a producer defect and has to\n    // fail loudly; laundering it into `reward: 0` here would hide the producer,\n    // which is the actual bug.\n    'reward-relationship': enforced,\n    'gated-evidence': omittedBecause(\n      'a ledger written before the relocation existed carries `metrics` on its gated lines; ' +\n        'rejecting those would make every already-published artifact unreadable. The condition ' +\n        'is REPAIRED at `assertMinted` (`gateGamedOutcome`) instead, which is the only door into ' +\n        'the training path, so the artifact stays readable and the leak still closes.',\n    ),\n    'undeclared-step-payload': omittedBecause(\n      'identical reasoning to `gated-evidence`, one field over: a foreign or pre-unification ' +\n        'ledger may carry producer-invented keys on its steps, and refusing to READ those files ' +\n        'buys nothing the relocation at `assertMinted` does not already buy. Promotion into ' +\n        'training is where it closes.',\n    ),\n    'unscreened-reward': omittedBecause(\n      'supervision-journal rows legitimately carry an unscreened positive reward (there is no ' +\n        '`RunRecord.outcome.realness` behind them) and must stay writable, readable and ' +\n        'reportable. Only PROMOTION into training is closed, at `assertMinted`.',\n    ),\n  },\n  /**\n   * The mint funnel — the single door every `MintedRolloutLine` passes. Validates\n   * first (so the reward relationship has already been rejected), then refuses\n   * what cannot be repaired, then repairs what can.\n   */\n  assertMinted: {\n    // Re-run after `assertRolloutLine`, which already rejected it. Cheap, and it\n    // makes this entry point independently complete rather than complete only\n    // because of what it happens to call first.\n    'reward-relationship': enforced,\n    'gated-evidence': repairedBy('gateGamedOutcome'),\n    'undeclared-step-payload': repairedBy('gateGamedOutcome'),\n    'unscreened-reward': enforced,\n  },\n  /**\n   * The runtime backstop, and the one entry point with no license to omit\n   * anything: it exists for callers the type system never saw (plain JavaScript\n   * handing an object literal to a published exporter), so a check it skips is a\n   * check that does not run at all for them. This is where the fourth leak was.\n   */\n  assertRewardGate: {\n    'reward-relationship': enforced,\n    'gated-evidence': enforced,\n    'undeclared-step-payload': enforced,\n    'unscreened-reward': enforced,\n  },\n  /**\n   * The release certifier. Same checks, measured over the rows a release is\n   * ABOUT TO WRITE rather than over one line's outcome — see `REPORT_MEASURES`\n   * in `release/gate-report.ts`, which is the second total map this policy\n   * drives.\n   */\n  assertGateReport: {\n    'reward-relationship': enforced,\n    'gated-evidence': enforced,\n    'undeclared-step-payload': enforced,\n    'unscreened-reward': enforced,\n  },\n} as const satisfies Record<string, GatePolicy>\n\n/** Every entry point that declares a gate policy. */\nexport type GateEntryPoint = keyof typeof GATE_POLICIES\n\n/**\n * Run the checks one entry point enforces. The ONLY way an entry point should\n * obtain gate errors — hand-composing two of the three is the bug this module\n * exists to remove.\n */\nexport function gateErrors(subject: GateSubject, policy: GatePolicy): string[] {\n  const errors: string[] = []\n  for (const id of GATE_CHECK_IDS) {\n    if (policy[id].kind !== 'enforce') continue\n    errors.push(...GATE_CHECKS[id].errors(subject))\n  }\n  return errors\n}\n","/**\n * `tangle.rollout.v1` — THE canonical rollout serialization, owned by\n * agent-eval. One JSONL line per agent invocation (a solo eval run, a\n * supervisor episode, a worker session, a proposer shot, a judge call, an\n * analyst pass), labeled with its task/split coordinates and a single\n * scalar reward, carrying the FULL message transcript inline.\n *\n * This schema is the reconciliation of two prior producers:\n *   - agent-eval's RunRecord-joined rollout rows (PR #410): identity,\n *     provenance hashes, the realness gate travelling into the reward,\n *     trace-derived steps.\n *   - the bench rollout-ledger (agent-runtime PR #591): the wire shape —\n *     role, task.split/rep, parent_rollout_id, policy provenance, capture\n *     provenance, inline canonical chat-with-tools messages.\n * Where the two conflicted, RunRecord-derived semantics won; the wire\n * field names follow the ledger (snake_case). See `docs/rollout.md` for\n * the field-by-field decision table.\n *\n * Messages are inlined — never referenced — because every harness store a\n * rollout can be recovered from is mutable or garbage-collected. A line\n * must stay a complete training/eval example on its own.\n *\n * `outcome.reward` is THE single scalar (null = no verdict exists — a\n * labeled gap, never 0). `outcome.realness_gated` is the anti-Goodhart\n * flag: a gated line must never export as a positive training example.\n *\n * That last sentence is enforced here, by `validateRolloutLine`, not merely\n * documented. Validating `reward` and `realness_gated` independently — each a\n * well-typed field, their COMBINATION unchecked — is what let a line claiming\n * `{reward: 0.95, realness_gated: true}` validate clean and walk into every\n * training export. The relationship between the two IS the invariant, so it is\n * checked where every other structural claim about a line is checked.\n *\n * The invariant is about the OUTCOME, not about one field of it. Zeroing\n * `reward` while `outcome.metrics` still carried the per-layer scores that\n * reward was computed from exported the gamed signal anyway, in the dict the\n * verifiers format reads as its per-rubric scores. So `gateGamedOutcome`\n * transforms the whole outcome once, at `assertMinted` — the funnel every\n * minted line passes — and the reward-bearing components are relocated to\n * `provenance.gated_evidence`, which no exporter projects.\n *\n * WHICH checks each door applies is not decided in this file. `./gate-checks`\n * owns the canonical list and the total per-entry-point policy; the three doors\n * below (`validateRolloutLine`, `assertRewardGate`, `assertMinted`) each call\n * `gateErrors` with their declared policy, so a check added to that list applies\n * here without anyone editing this file, and a check deliberately skipped has to\n * name itself there.\n */\n\nimport { isRecord } from '../llm-client/json'\nimport { declaredSteps, GATE_POLICIES, gatedEvidenceOf, gateErrors } from './gate-checks'\nimport { LICENSE_CLASSES, type LicenseClass } from './license'\nexport const ROLLOUT_SCHEMA = 'tangle.rollout.v1'\n\n/** `agent` = a solo evaluation run (no multi-agent topology). */\nexport type RolloutRole = 'agent' | 'supervisor' | 'worker' | 'proposer' | 'judge' | 'analyst'\nexport const ROLLOUT_ROLES: readonly RolloutRole[] = [\n  'agent',\n  'supervisor',\n  'worker',\n  'proposer',\n  'judge',\n  'analyst',\n]\n\n/** Split vocabulary follows `RunRecord.splitTag`, extended with `canary`. */\nexport type RolloutSplit = 'search' | 'dev' | 'holdout' | 'canary'\nexport const ROLLOUT_SPLITS: readonly RolloutSplit[] = ['search', 'dev', 'holdout', 'canary']\n/** Splits that may ship in training exports. Everything else is fail-closed excluded. */\nconst TRAINABLE_SPLITS: readonly RolloutSplit[] = ['search']\n\nexport function isTrainableSplit(split: RolloutSplit): boolean {\n  return TRAINABLE_SPLITS.includes(split)\n}\n\n/** 'mint' = joined live from RunRecord + trace by `mintRolloutRows`. */\nexport type RolloutCapture = 'mint' | 'settle-time' | 'backfill'\nexport const ROLLOUT_CAPTURES: readonly RolloutCapture[] = ['mint', 'settle-time', 'backfill']\n\n// ---------------------------------------------------------------------------\n// Canonical message format — OpenAI chat-with-tools, full fidelity.\n// ---------------------------------------------------------------------------\n\nexport type ChatRole = 'system' | 'user' | 'assistant' | 'tool'\nconst CHAT_ROLES: readonly ChatRole[] = ['system', 'user', 'assistant', 'tool']\n\nexport interface ChatToolCall {\n  id: string\n  type: 'function'\n  function: {\n    name: string\n    /** JSON-encoded argument object, exactly as the model emitted it. */\n    arguments: string\n  }\n}\n\nexport interface ChatMessage {\n  role: ChatRole\n  content: string | null\n  /** Reasoning/thinking channel where the harness captured it (full fidelity). */\n  reasoning_content?: string\n  tool_calls?: ChatToolCall[]\n  /** Required on role:\"tool\" — the ChatToolCall this result answers. */\n  tool_call_id?: string\n  name?: string\n  /**\n   * Harbor ATIF `is_copied_context` (RFC 0001 rule 7): this turn was COPIED IN\n   * from another trajectory's context, not produced by the agent on this line.\n   * The RFC makes excluding it from SFT a MUST, and `toSftRows` does — training\n   * on it teaches the model to author text it never authored, and credits this\n   * run for another one's work. Absent = false (authored here).\n   */\n  is_copied_context?: boolean\n}\n\nexport interface ToolDef {\n  type: 'function'\n  function: {\n    name: string\n    description?: string\n    parameters?: Record<string, unknown>\n  }\n}\n\n/**\n * Compact trace-span projection (llm/tool step) carried alongside the\n * conversation when the line was minted from a trace. Optional: lines\n * recovered from harness stores have no span structure.\n */\nexport interface RolloutStep {\n  kind: string\n  name: string\n  /** llm: last-message summary · tool: stringified args. Scrubbed. */\n  input?: string\n  /** llm: output text · tool: stringified result. Scrubbed. */\n  output?: string\n  status?: 'ok' | 'error'\n  durationMs?: number\n  // The four fields below are lifted verbatim from Harbor ATIF's per-step\n  // `metrics` (see `interchange/harbor.ts`); the wire names stay snake_case to\n  // match that spec exactly, which is why they differ from `durationMs`.\n  // All optional and never back-filled: an absent field means \"not captured\",\n  // which is not the same claim as an empty array.\n  /**\n   * LLM inferences this span represents. 0 = deterministic dispatch with no\n   * model call — distinct from absent, which means the producer did not track it.\n   */\n  llm_call_count?: number\n  /** Exact prompt tokenization. Removes the ambiguity of re-tokenizing text at train time. */\n  prompt_token_ids?: number[]\n  /** Exact completion tokenization; aligns index-wise with `logprobs`. */\n  completion_token_ids?: number[]\n  /**\n   * Per-completion-token log probabilities under the sampling policy. Required\n   * for off-policy correction (importance weighting) when the rollout was\n   * generated by a policy other than the one being trained.\n   */\n  logprobs?: number[]\n}\n\n// ---------------------------------------------------------------------------\n// Ledger line sections.\n// ---------------------------------------------------------------------------\n\nexport interface RolloutTask {\n  /** Benchmark/suite id (e.g. \"swe-bench-verified\") or the experiment id. */\n  suite: string\n  instance_id: string\n  split: RolloutSplit\n  /** Sampling seed the campaign pinned; null = not recorded. */\n  seed: number | null\n  /** Replicate index (0-based). */\n  rep: number\n}\n\nexport interface RolloutPolicy {\n  /** Harness that drove the invocation (e.g. \"opencode\", \"claude\", \"pi-loops\"). */\n  harness: string | null\n  harness_version: string | null\n  model: string | null\n  provider: string | null\n  /** Commit of the agent profile / candidate under evaluation. */\n  profile_commit: string | null\n  /** sha256 of the effective prompt (post-steering), when recorded. */\n  prompt_hash?: string | null\n  /** sha256 of the effective run config, when recorded. */\n  config_hash?: string | null\n  /** Canonical agent-profile cell identity, when the run carries one. */\n  agent_profile_cell_id?: string | null\n  /** Sampling params (temperature, top_p, max_tokens…); null = not recorded. */\n  sampling: Record<string, unknown> | null\n  /** Terms the producer's outputs carry; absent = inferred (see `./license`). */\n  license_class?: LicenseClass\n}\n\nexport interface RolloutOutcome {\n  /**\n   * THE single scalar training signal — the official verdict.\n   * null = no verdict exists for this invocation (a labeled gap, never 0).\n   */\n  reward: number | null\n  /** Where the reward came from (judge id; \"/inherited\" = parent episode's). */\n  reward_source: string | null\n  /** Raw judge verdict record, verbatim. */\n  verdict: unknown\n  /** Everything that is NOT the scalar reward. */\n  metrics: Record<string, unknown>\n  is_completed: boolean\n  is_truncated: boolean\n  error: string | null\n  /**\n   * Anti-Goodhart flag from `RunRecord.outcome.realness.gated`: the run faked\n   * its success signal. `true` requires `reward` to be 0 or null — the\n   * validator rejects the line otherwise — and the line never qualifies for\n   * SFT. Required on the wire: a line that does not state the flag does not\n   * validate, so no producer can dodge the gate by omitting it.\n   *\n   * `true` ALSO requires `metrics` to be empty and `verdict` to be null: the\n   * numbers the reward was computed from are relocated to\n   * `provenance.gated_evidence` by `gateGamedOutcome`. See that function for\n   * why zeroing the scalar alone was not enough.\n   */\n  realness_gated: boolean\n  /**\n   * Whether an authenticity SCREEN ever RAN on this reward — a different claim\n   * from `realness_gated`, which is the screen's VERDICT.\n   *\n   * `realness_gated: false` reads as \"we looked and nothing fired\". A producer\n   * with no screen at all was emitting exactly that, so a never-screened reward\n   * was indistinguishable on the wire from a screened-clean one, and the whole\n   * anti-Goodhart apparatus silently treated the first as the second. The two\n   * claims are now separable:\n   *\n   *   - `true`   — a screen ran; `realness_gated` is its verdict.\n   *   - `false`  — the producer declares it HAS no screen (`unscreenedRewardFields`).\n   *                `assertMinted` REFUSES such a line when its reward is above\n   *                zero: an unscreened positive reward is precisely the signal\n   *                the gate exists to qualify, and nothing has qualified it.\n   *   - absent   — not stated. Pre-unification ledgers land here, as does a\n   *                `RunRecord` carrying no `outcome.realness` at all. Absent is\n   *                read as \"unknown\", never as `false` (which would refuse most\n   *                of the existing corpus) and never as `true`.\n   */\n  realness_screened?: boolean\n}\n\nexport interface RolloutCostBlock {\n  usd: number | null\n  tokens_in: number | null\n  tokens_out: number | null\n  tokens_reasoning: number | null\n  cache_read: number | null\n  cache_write: number | null\n  wall_s: number | null\n  /**\n   * Total LLM inferences across the invocation (ATIF `llm_call_count`,\n   * aggregated). Optional and additive: absent = not tracked, never 0.\n   */\n  llm_call_count?: number | null\n}\n\nexport interface RolloutArtifacts {\n  patch_path: string | null\n  run_dir: string | null\n  /** Source-of-truth transcript pointer (session id / jsonl path) for audit.\n   *  Minted lines point at the run's trace as `trace:<traceId>`. */\n  transcript_ref: string | null\n}\n\n/**\n * The reward-bearing half of a GATED line's outcome, moved off `outcome` and\n * parked here verbatim. Diagnostics, never training input — see\n * `gateGamedOutcome`.\n */\nexport interface GatedEvidence {\n  /** `outcome.metrics` exactly as the producer measured it. */\n  metrics?: Record<string, unknown>\n  /** `outcome.verdict` verbatim — the judge record that claimed the success. */\n  verdict?: unknown\n  /**\n   * The per-step fields `tangle.rollout.v1` does not declare, parked here when\n   * the gate projected `steps[]` down to the schema's own key set.\n   *\n   * A per-step reward is training signal exactly like the scalar, and `steps`\n   * rides through `toRewardRows` verbatim — so a gated line was shipping its\n   * step-level credit assignment at full value beside a `reward` of 0.\n   */\n  steps?: unknown\n}\n\nexport interface RolloutEvidenceAttempt {\n  executionId: string\n  ordinal: number\n  providerSessionId: string | null\n  nativeSessionIds: string[]\n  processIds: string[]\n  outcome: 'succeeded' | 'failed' | 'cancelled' | 'unknown'\n  missingReasons: string[]\n}\n\n/** One Runtime result blob and its unmodified provider capture receipt. */\nexport interface RolloutWorkspaceCapture {\n  readonly outRef: string | null\n  readonly blobPath: string | null\n  /** JSON pointer to the receipt within its Runtime result. */\n  readonly receiptPointer: string | null\n  readonly receipt: unknown | null\n  readonly attempts: readonly unknown[] | null\n  /** The provider's claim, not an Eval verification of the archive bytes. */\n  readonly coverageComplete: boolean | null\n  readonly incompleteReason: string | null\n  readonly projectionGap: string | null\n}\n\nexport interface RolloutProvenance {\n  captured_at: string\n  capture: RolloutCapture\n  /** Exact search-cell attempt; absent outside a search. */\n  search?: { searchId: string; nodeId: string; cellId: string; attempt: number }\n  /** Run-bound provider attempts; absent means this source was not observed. */\n  attempts?: RolloutEvidenceAttempt[]\n  /** Exact per-result receipts in source order. Null means Runtime had no result evidence. */\n  workspace_captures?: readonly RolloutWorkspaceCapture[] | null\n  /** A known lossy semantic projection. Training sinks refuse this line. */\n  lossy_projection?: true\n  /**\n   * Why this line is incomplete. Required when `messages` is empty and set\n   * for lossy last-context or capped-step projections. Importers also use it to\n   * name a MISSING LABEL — an imported trajectory carries no verdict, so\n   * `outcome.reward` is null and this says why.\n   */\n  gap?: string\n  /**\n   * Present only on a realness-gated line: the outcome fields the gate\n   * relocated, kept so an auditor can still see WHY the run was gated and what\n   * it claimed. Deliberately OUTSIDE `outcome`, because every training exporter\n   * reads `outcome` and none reads `provenance`.\n   */\n  gated_evidence?: GatedEvidence\n}\n\nexport interface RolloutLine {\n  schema: typeof ROLLOUT_SCHEMA\n  rollout_id: string\n  /** Spawning invocation within the same episode (worker → supervisor); for a\n   *  nested search run, the run of the cell that contains the search. */\n  parent_rollout_id: string | null\n  run_id: string\n  /** Logical experiment grouping from `RunRecord.experimentId`; null = not recorded. */\n  experiment_id: string | null\n  /** Stable candidate identity from `RunRecord.candidateId`; null = not recorded. */\n  candidate_id: string | null\n  /** Search depth of the run's node (0 = the search root); null = not a search run. */\n  generation: number | null\n  /** Registration order of the run's node in its search (0 = the root); null = not a search run. */\n  candidate_index: number | null\n  role: RolloutRole\n  task: RolloutTask\n  policy: RolloutPolicy\n  /** Inline conversation projection. Check provenance.gap before treating it as complete. */\n  messages: ChatMessage[]\n  tool_defs: ToolDef[]\n  /** Trace-span projections, when minted from a trace. */\n  steps?: RolloutStep[]\n  outcome: RolloutOutcome\n  cost: RolloutCostBlock\n  artifacts: RolloutArtifacts\n  provenance: RolloutProvenance\n}\n\n// ---------------------------------------------------------------------------\n// Validation — pure TS, no runtime schema dependency, mirroring the\n// run-record validator's fail-loud discipline. Returns [] when the value\n// is a valid RolloutLine; otherwise one dotted-path error per defect.\n// ---------------------------------------------------------------------------\n\nconst isNumberOrNull = (v: unknown): boolean => v === null || typeof v === 'number'\nconst isNumberArray = (v: unknown): boolean =>\n  Array.isArray(v) && v.every((n) => typeof n === 'number' && Number.isFinite(n))\nconst isIntegerArray = (v: unknown): boolean =>\n  Array.isArray(v) && v.every((n) => Number.isInteger(n))\nconst isStringOrNull = (v: unknown): boolean => v === null || typeof v === 'string'\nconst isIntegerOrNull = (v: unknown): boolean => v === null || Number.isInteger(v)\n\nfunction validateChatMessage(value: unknown, path: string, errors: string[]): void {\n  if (!isRecord(value)) {\n    errors.push(`${path}: not an object`)\n    return\n  }\n  if (!CHAT_ROLES.includes(value.role as ChatRole))\n    errors.push(`${path}.role: invalid role ${String(value.role)}`)\n  if (!isStringOrNull(value.content)) errors.push(`${path}.content: must be string|null`)\n  if (value.reasoning_content !== undefined && typeof value.reasoning_content !== 'string') {\n    errors.push(`${path}.reasoning_content: must be string when present`)\n  }\n  if (value.tool_call_id !== undefined && typeof value.tool_call_id !== 'string') {\n    errors.push(`${path}.tool_call_id: must be string when present`)\n  }\n  if (value.role === 'tool' && typeof value.tool_call_id !== 'string') {\n    errors.push(`${path}.tool_call_id: required on role:\"tool\"`)\n  }\n  if (value.is_copied_context !== undefined && typeof value.is_copied_context !== 'boolean') {\n    errors.push(`${path}.is_copied_context: must be boolean when present`)\n  }\n  if (value.tool_calls !== undefined) {\n    if (!Array.isArray(value.tool_calls)) {\n      errors.push(`${path}.tool_calls: must be an array when present`)\n    } else {\n      value.tool_calls.forEach((call, i) => {\n        if (!isRecord(call) || typeof call.id !== 'string' || call.type !== 'function') {\n          errors.push(`${path}.tool_calls[${i}]: must be {id, type:\"function\", function}`)\n          return\n        }\n        const fn = call.function\n        if (!isRecord(fn) || typeof fn.name !== 'string' || typeof fn.arguments !== 'string') {\n          errors.push(\n            `${path}.tool_calls[${i}].function: must be {name: string, arguments: string}`,\n          )\n        }\n      })\n    }\n  }\n}\n\nfunction validateSection(\n  value: unknown,\n  path: string,\n  fields: Array<[name: string, check: (v: unknown) => boolean, expect: string]>,\n  errors: string[],\n): void {\n  if (!isRecord(value)) {\n    errors.push(`${path}: not an object`)\n    return\n  }\n  for (const [name, check, expect] of fields) {\n    if (!check(value[name])) errors.push(`${path}.${name}: expected ${expect}`)\n  }\n}\n\n/**\n * THE anti-Goodhart gate, applied to the WHOLE outcome as a TRANSFORMATION.\n *\n * Two prior rounds enforced the gate as a CHECK ON ONE FIELD at N call sites,\n * and each round the next reward-bearing field leaked. The one that shipped:\n * `mintRolloutRows` bulk-copied `RunRecord.outcome.raw` into `outcome.metrics`\n * with no gate, so a gated run exported `reward: 0` (correct) while the\n * deterministic per-layer scores that reward was COMPUTED FROM — the\n * `layer.*` keys `rl/verifiable-reward.ts` calls the RL training signal —\n * shipped at 1.0, in the top-level `metrics` dict of the Prime Intellect\n * verifiers format, which IS that format's per-rubric score dict. `verdict`\n * leaks the same way into `toRftItem`'s `reference.verdict`, where a grader\n * author reads `resolved: true` off a run that faked it.\n *\n * So the rule is no longer \"zero the field we remembered\". It is: if the gate\n * fired, the outcome that leaves here carries NOTHING positive that was derived\n * from the reward, whichever field a present or future exporter decides to\n * read. `reward` is already forced to 0 upstream (`trainingReward`) and\n * REJECTED here if it is not; `metrics` and `verdict` are relocated.\n *\n * WHERE they go, and why relocation rather than deletion: zeroing destroys the\n * audit trail that shows why the run was gated and what it claimed, which is\n * the row an auditor most wants and the labeled example a gaming DETECTOR\n * trains on. `provenance.gated_evidence` keeps every byte, at a path no\n * training exporter reads — all four release configs and every `rl/exporters`\n * shape project from `outcome`, `messages`, `cost` and `task`; none projects\n * `provenance`. Auditability preserved, training signal removed, and a future\n * exporter that reads a field nobody thought of is safe by construction because\n * the field is empty rather than because the exporter remembered to check.\n *\n * Idempotent: a second application finds nothing left to move and returns the\n * line unchanged, so re-minting a line read back off a ledger cannot clobber\n * the evidence it already carries.\n */\nexport function gateGamedOutcome(line: RolloutLine): RolloutLine {\n  if (line.outcome.realness_gated !== true) return line\n  const moved = gatedEvidenceOf(line)\n  if (moved === undefined) return line\n  const kept = line.provenance.gated_evidence\n  const evidence: GatedEvidence = {}\n  const metrics = { ...kept?.metrics, ...moved.metrics }\n  if (Object.keys(metrics).length > 0) evidence.metrics = metrics\n  if (moved.verdict !== undefined) evidence.verdict = moved.verdict\n  else if (kept?.verdict !== undefined) evidence.verdict = kept.verdict\n  if (moved.steps !== undefined) evidence.steps = moved.steps\n  else if (kept?.steps !== undefined) evidence.steps = kept.steps\n  // The trajectory itself STAYS: a gamed transcript is the labeled example a\n  // gaming detector trains on, and the exporters are meant to ship it. Only the\n  // fields the wire format does not declare come off, which is the same\n  // partition `gatedEvidenceOf` applies to `metrics` — the producer's own,\n  // never a key-name guess.\n  const steps = moved.steps === undefined ? line.steps : declaredSteps(line.steps)\n  return {\n    ...line,\n    ...(steps === undefined ? {} : { steps }),\n    outcome: { ...line.outcome, metrics: {}, verdict: null },\n    provenance: { ...line.provenance, gated_evidence: evidence },\n  }\n}\n\n/**\n * EVERY gate check, for the export path — the runtime backstop.\n *\n * `validateRolloutLine` checks the reward relationship too, but an exporter\n * cannot afford to re-validate every field of every line, and more importantly\n * it is not the exporter's job to re-check the schema — it is its job never to\n * emit a signal it was told is fabricated. Thrown rather than filtered: an\n * exporter silently dropping a poisoned line would hide the producer that made\n * it, and the producer is the actual defect.\n *\n * This is the third layer, and it exists for exactly one caller: JavaScript.\n * The brand stops TypeScript callers at compile time and `assertMinted` fixes\n * data arriving from disk, but neither is present for a plain JS consumer of\n * the published package handing an object literal to `toRewardRows`. Which is\n * exactly why this entry point's policy omits nothing: a check it skips is a\n * check that never runs for those callers at all. It composed two of the three\n * for one round, and a never-screened positive reward walked through all four\n * waist exporters at full value. `GATE_POLICIES.assertRewardGate` is now the\n * only place that list is written down.\n */\nexport function assertRewardGate(line: RolloutLine, context: string): void {\n  const errors = gateErrors(line, GATE_POLICIES.assertRewardGate)\n  if (errors.length > 0) {\n    throw new Error(`${context}: rollout ${line.rollout_id} — ${errors[0]}`)\n  }\n}\n\n/** Check the line's identity fields and the policy section. */\nfunction validateRolloutIdentity(value: Record<string, unknown>, errors: string[]): void {\n  if (value.schema !== ROLLOUT_SCHEMA) errors.push(`schema: expected \"${ROLLOUT_SCHEMA}\"`)\n  if (typeof value.rollout_id !== 'string' || value.rollout_id.length === 0)\n    errors.push('rollout_id: expected non-empty string')\n  if (!isStringOrNull(value.parent_rollout_id))\n    errors.push('parent_rollout_id: expected string|null')\n  if (typeof value.run_id !== 'string' || value.run_id.length === 0)\n    errors.push('run_id: expected non-empty string')\n  if (!isStringOrNull(value.experiment_id)) errors.push('experiment_id: expected string|null')\n  if (!isStringOrNull(value.candidate_id)) errors.push('candidate_id: expected string|null')\n  if (!isIntegerOrNull(value.generation)) errors.push('generation: expected integer|null')\n  if (!isIntegerOrNull(value.candidate_index)) errors.push('candidate_index: expected integer|null')\n  if (!ROLLOUT_ROLES.includes(value.role as RolloutRole))\n    errors.push(`role: invalid role ${String(value.role)}`)\n\n  validateSection(\n    value.task,\n    'task',\n    [\n      ['suite', (v) => typeof v === 'string' && v.length > 0, 'non-empty string'],\n      ['instance_id', (v) => typeof v === 'string' && v.length > 0, 'non-empty string'],\n      [\n        'split',\n        (v) => ROLLOUT_SPLITS.includes(v as RolloutSplit),\n        `one of ${ROLLOUT_SPLITS.join('|')}`,\n      ],\n      ['seed', isNumberOrNull, 'number|null'],\n      ['rep', (v) => Number.isInteger(v), 'integer'],\n    ],\n    errors,\n  )\n\n  validateSection(\n    value.policy,\n    'policy',\n    [\n      ['harness', isStringOrNull, 'string|null'],\n      ['harness_version', isStringOrNull, 'string|null'],\n      ['model', isStringOrNull, 'string|null'],\n      ['provider', isStringOrNull, 'string|null'],\n      ['profile_commit', isStringOrNull, 'string|null'],\n      ['sampling', (v) => v === null || isRecord(v), 'object|null'],\n    ],\n    errors,\n  )\n  if (isRecord(value.policy)) {\n    for (const key of ['prompt_hash', 'config_hash', 'agent_profile_cell_id'] as const) {\n      if (value.policy[key] !== undefined && !isStringOrNull(value.policy[key])) {\n        errors.push(`policy.${key}: expected string|null when present`)\n      }\n    }\n    const license = value.policy.license_class\n    if (license !== undefined && !LICENSE_CLASSES.includes(license as LicenseClass)) {\n      errors.push(`policy.license_class: expected one of ${LICENSE_CLASSES.join('|')}`)\n    }\n  }\n}\n\n/** Check the messages, tool definitions and steps arrays. */\nfunction validateRolloutTranscript(value: Record<string, unknown>, errors: string[]): void {\n  if (!Array.isArray(value.messages)) {\n    errors.push('messages: expected array')\n  } else {\n    for (const [i, m] of value.messages.entries()) validateChatMessage(m, `messages[${i}]`, errors)\n  }\n\n  if (!Array.isArray(value.tool_defs)) {\n    errors.push('tool_defs: expected array')\n  } else {\n    value.tool_defs.forEach((d, i) => {\n      if (\n        !isRecord(d) ||\n        d.type !== 'function' ||\n        !isRecord(d.function) ||\n        typeof d.function.name !== 'string'\n      ) {\n        errors.push(`tool_defs[${i}]: must be {type:\"function\", function:{name}}`)\n      }\n    })\n  }\n\n  if (value.steps !== undefined) {\n    if (!Array.isArray(value.steps)) {\n      errors.push('steps: expected array when present')\n    } else {\n      value.steps.forEach((s, i) => {\n        if (!isRecord(s) || typeof s.kind !== 'string' || typeof s.name !== 'string') {\n          errors.push(`steps[${i}]: must be {kind: string, name: string, …}`)\n          return\n        }\n        // ATIF-lifted optionals: absent on every line written before they\n        // existed, so they are checked only when present — old ledgers stay valid.\n        if (s.llm_call_count !== undefined && !Number.isInteger(s.llm_call_count)) {\n          errors.push(`steps[${i}].llm_call_count: expected integer when present`)\n        }\n        for (const key of ['prompt_token_ids', 'completion_token_ids'] as const) {\n          if (s[key] !== undefined && !isIntegerArray(s[key])) {\n            errors.push(`steps[${i}].${key}: expected integer[] when present`)\n          }\n        }\n        if (s.logprobs !== undefined && !isNumberArray(s.logprobs)) {\n          errors.push(`steps[${i}].logprobs: expected number[] when present`)\n        }\n      })\n    }\n  }\n}\n\n/** Check the outcome section, the cost section and the reward gate. */\nfunction validateRolloutOutcomeAndCost(value: Record<string, unknown>, errors: string[]): void {\n  validateSection(\n    value.outcome,\n    'outcome',\n    [\n      ['reward', isNumberOrNull, 'number|null'],\n      ['reward_source', isStringOrNull, 'string|null'],\n      ['metrics', isRecord, 'object'],\n      ['is_completed', (v) => typeof v === 'boolean', 'boolean'],\n      ['is_truncated', (v) => typeof v === 'boolean', 'boolean'],\n      ['error', isStringOrNull, 'string|null'],\n    ],\n    errors,\n  )\n  if (isRecord(value.outcome)) {\n    if (!('verdict' in value.outcome)) errors.push('outcome.verdict: field required (may be null)')\n    if (typeof value.outcome.realness_gated !== 'boolean') {\n      errors.push('outcome.realness_gated: expected boolean')\n    }\n    if (\n      value.outcome.realness_screened !== undefined &&\n      typeof value.outcome.realness_screened !== 'boolean'\n    ) {\n      errors.push('outcome.realness_screened: expected boolean when present')\n    }\n    errors.push(\n      ...gateErrors(\n        { outcome: value.outcome, steps: value.steps },\n        GATE_POLICIES.validateRolloutLine,\n      ),\n    )\n  }\n\n  validateSection(\n    value.cost,\n    'cost',\n    [\n      ['usd', isNumberOrNull, 'number|null'],\n      ['tokens_in', isNumberOrNull, 'number|null'],\n      ['tokens_out', isNumberOrNull, 'number|null'],\n      ['tokens_reasoning', isNumberOrNull, 'number|null'],\n      ['cache_read', isNumberOrNull, 'number|null'],\n      ['cache_write', isNumberOrNull, 'number|null'],\n      ['wall_s', isNumberOrNull, 'number|null'],\n    ],\n    errors,\n  )\n  if (\n    isRecord(value.cost) &&\n    value.cost.llm_call_count !== undefined &&\n    !(value.cost.llm_call_count === null || Number.isInteger(value.cost.llm_call_count))\n  ) {\n    errors.push('cost.llm_call_count: expected integer|null when present')\n  }\n}\n\n/** Check the lossy-projection flag and its gap note. */\nfunction validateLossyProjection(provenance: Record<string, unknown>, errors: string[]): void {\n  if (provenance.lossy_projection !== undefined && provenance.lossy_projection !== true) {\n    errors.push('provenance.lossy_projection: expected true when present')\n  }\n  if (\n    provenance.lossy_projection === true &&\n    (typeof provenance.gap !== 'string' || provenance.gap.length === 0)\n  ) {\n    errors.push('provenance.gap: required for a lossy projection')\n  }\n}\n\n/** Check the search coordinates of a search-produced rollout. */\nfunction validateProvenanceSearch(search: unknown, errors: string[]): void {\n  if (search === undefined) return\n  if (\n    !isRecord(search) ||\n    typeof search.searchId !== 'string' ||\n    !search.searchId ||\n    typeof search.nodeId !== 'string' ||\n    !search.nodeId ||\n    typeof search.cellId !== 'string' ||\n    !search.cellId ||\n    !Number.isSafeInteger(search.attempt) ||\n    (search.attempt as number) < 1\n  ) {\n    errors.push('provenance.search: expected exact search, node, cell and positive attempt')\n  }\n}\n\n/** Check each workspace capture's evidence fields. */\nfunction validateWorkspaceCaptures(captures: unknown, errors: string[]): void {\n  if (captures === undefined || captures === null) return\n  if (!Array.isArray(captures)) {\n    errors.push('provenance.workspace_captures: expected array|null when present')\n    return\n  }\n  for (const [i, capture] of captures.entries()) {\n    if (\n      !isRecord(capture) ||\n      !isStringOrNull(capture.outRef) ||\n      !isStringOrNull(capture.blobPath) ||\n      !isStringOrNull(capture.receiptPointer) ||\n      !('receipt' in capture) ||\n      (capture.attempts !== null && !Array.isArray(capture.attempts)) ||\n      (capture.coverageComplete !== null && typeof capture.coverageComplete !== 'boolean') ||\n      !isStringOrNull(capture.incompleteReason) ||\n      !isStringOrNull(capture.projectionGap)\n    ) {\n      errors.push(`provenance.workspace_captures[${i}]: invalid capture evidence`)\n    }\n  }\n}\n\n/** Check each attempt's evidence and that every execution's ordinals are unique and contiguous from 1. */\nfunction validateProvenanceAttempts(attempts: unknown, errors: string[]): void {\n  if (attempts === undefined) return\n  if (!Array.isArray(attempts)) {\n    errors.push('provenance.attempts: expected array when present')\n    return\n  }\n  const ordinalsByExecution = new Map<string, Set<number>>()\n  for (const [i, attempt] of attempts.entries()) {\n    if (\n      !isRecord(attempt) ||\n      typeof attempt.executionId !== 'string' ||\n      !attempt.executionId ||\n      !Number.isSafeInteger(attempt.ordinal) ||\n      (attempt.ordinal as number) < 1 ||\n      !isStringOrNull(attempt.providerSessionId) ||\n      !Array.isArray(attempt.nativeSessionIds) ||\n      !attempt.nativeSessionIds.every((id) => typeof id === 'string' && id.length > 0) ||\n      !Array.isArray(attempt.processIds) ||\n      !attempt.processIds.every((id) => typeof id === 'string' && id.length > 0) ||\n      !['succeeded', 'failed', 'cancelled', 'unknown'].includes(attempt.outcome as string) ||\n      !Array.isArray(attempt.missingReasons) ||\n      !attempt.missingReasons.every((reason) => typeof reason === 'string' && reason.length > 0)\n    ) {\n      errors.push(`provenance.attempts[${i}]: invalid attempt evidence`)\n      continue\n    }\n    const executionId = attempt.executionId as string\n    const ordinal = attempt.ordinal as number\n    const seen = ordinalsByExecution.get(executionId) ?? new Set<number>()\n    if (seen.has(ordinal)) {\n      errors.push(`provenance.attempts[${i}]: duplicate execution/ordinal`)\n    }\n    seen.add(ordinal)\n    ordinalsByExecution.set(executionId, seen)\n  }\n  for (const [executionId, ordinals] of ordinalsByExecution) {\n    for (let ordinal = 1; ordinal <= ordinals.size; ordinal++) {\n      if (!ordinals.has(ordinal)) {\n        errors.push(`provenance.attempts: ${executionId} is missing ordinal ${ordinal}`)\n      }\n    }\n  }\n}\n\n/** Check the artifacts and provenance sections. */\nfunction validateRolloutProvenance(value: Record<string, unknown>, errors: string[]): void {\n  validateSection(\n    value.artifacts,\n    'artifacts',\n    [\n      ['patch_path', isStringOrNull, 'string|null'],\n      ['run_dir', isStringOrNull, 'string|null'],\n      ['transcript_ref', isStringOrNull, 'string|null'],\n    ],\n    errors,\n  )\n\n  validateSection(\n    value.provenance,\n    'provenance',\n    [\n      [\n        'captured_at',\n        (v) => typeof v === 'string' && !Number.isNaN(Date.parse(v)),\n        'ISO-8601 timestamp',\n      ],\n      [\n        'capture',\n        (v) => ROLLOUT_CAPTURES.includes(v as RolloutCapture),\n        `one of ${ROLLOUT_CAPTURES.join('|')}`,\n      ],\n    ],\n    errors,\n  )\n  if (!isRecord(value.provenance)) return\n  const provenance = value.provenance\n  validateLossyProjection(provenance, errors)\n  validateProvenanceSearch(provenance.search, errors)\n  validateWorkspaceCaptures(provenance.workspace_captures, errors)\n  validateProvenanceAttempts(provenance.attempts, errors)\n  if (provenance.gap !== undefined && typeof provenance.gap !== 'string') {\n    errors.push('provenance.gap: must be string when present')\n  }\n  const evidence = provenance.gated_evidence\n  if (evidence !== undefined) {\n    if (!isRecord(evidence)) {\n      errors.push('provenance.gated_evidence: must be an object when present')\n    } else if (evidence.metrics !== undefined && !isRecord(evidence.metrics)) {\n      errors.push('provenance.gated_evidence.metrics: must be an object when present')\n    }\n  }\n}\n\nexport function validateRolloutLine(value: unknown): string[] {\n  const errors: string[] = []\n  if (!isRecord(value)) return ['line: not an object']\n\n  validateRolloutIdentity(value, errors)\n  validateRolloutTranscript(value, errors)\n  validateRolloutOutcomeAndCost(value, errors)\n  validateRolloutProvenance(value, errors)\n\n  // A gap line must say WHY it is a gap; a full line must not carry a gap note.\n  if (Array.isArray(value.messages) && isRecord(value.provenance)) {\n    if (value.messages.length === 0 && typeof value.provenance.gap !== 'string') {\n      errors.push('provenance.gap: required when messages is empty')\n    }\n  }\n\n  return errors\n}\n\nexport function assertRolloutLine(\n  value: unknown,\n  context = 'rollout line',\n): asserts value is RolloutLine {\n  const errors = validateRolloutLine(value)\n  if (errors.length > 0) {\n    throw new Error(`invalid ${context}:\\n  ${errors.join('\\n  ')}`)\n  }\n}\n\nexport function isRolloutLine(value: unknown): value is RolloutLine {\n  return validateRolloutLine(value).length === 0\n}\n\n// ---------------------------------------------------------------------------\n// The minted brand — the COMPILE-TIME half of the anti-Goodhart gate.\n// ---------------------------------------------------------------------------\n\n/**\n * Phantom property. `declare const` means it exists only in the type system:\n * nothing is written at runtime, so a branded line still serializes to exactly\n * the same JSON as a plain one.\n */\ndeclare const MINTED_ROLLOUT: unique symbol\n\n/**\n * A minted outcome states the gate verdict — it is not allowed to stay silent —\n * and, when that verdict is `true`, carries nothing else the reward was derived\n * from (`gateGamedOutcome` has run).\n */\nexport interface MintedRolloutOutcome extends RolloutOutcome {\n  realness_gated: boolean\n}\n\n/**\n * A `RolloutLine` whose reward has been checked against the anti-Goodhart\n * invariant. The type every training-data exporter takes.\n *\n * Why a brand and not just the interface: `RolloutLine` is structural, so any\n * hand-built object literal of the right shape IS one — which is how a line\n * declaring `{reward: 0.95, realness_gated: true}` reached the exporters\n * despite them \"only accepting a minted line\". The phantom symbol makes the\n * type nominal: it cannot be produced by writing an object literal, only by\n * `mintRolloutRows` (which applies the gate), `readRolloutLedger` (which\n * validates every line off disk), or an explicit, greppable `assertMinted`.\n *\n * Belt and braces on purpose. The brand closes first-party call sites at\n * COMPILE time; `validateRolloutLine` closes data arriving at RUNTIME (ledger\n * files, foreign imports, JSON from another process) where types are absent.\n * Neither alone is enough.\n *\n * Assignable to `RolloutLine` in one direction only: readers, analysis, and\n * the ledger writer keep taking the plain type.\n */\nexport type MintedRolloutLine = Omit<RolloutLine, 'outcome'> & {\n  readonly [MINTED_ROLLOUT]: true\n  outcome: MintedRolloutOutcome\n}\n\n/**\n * Promote a line to the type the training exporters accept, applying the\n * anti-Goodhart gate to the WHOLE outcome on the way through. THE escape hatch\n * — grep `assertMinted` to enumerate every place a line enters the training\n * path without coming from mint or a ledger.\n *\n * The gate runs HERE, once, rather than at each producer, because this is the\n * single funnel every minted line passes: `mintRolloutRows` calls it,\n * `readRolloutLedger` calls it per line off disk, `scrubLines` calls it on the\n * way out of a release, and a hand-built line has no other door. One\n * transformation at the funnel means an already-published ledger holding a\n * gated line with populated `metrics` is RE-GATED when it is read, instead of\n * being rejected (which would make every such artifact unreadable) or trusted\n * (which is the leak). Three steps, in this order:\n *\n *   1. VALIDATE the schema.\n *   2. REFUSE every check `GATE_POLICIES.assertMinted` marks `enforce` — today\n *      the reward relationship (which stays a REJECTION: a caller claiming\n *      `{reward: 0.95, realness_gated: true}` is a producer defect and must fail\n *      loudly, since laundering it into `reward: 0` here would hide the\n *      producer) and a positive reward the producer declared it never screened.\n *   3. TRANSFORM the one check that policy marks `repair` — relocate the\n *      reward's components off `outcome` (`gateGamedOutcome`), so no exporter\n *      can leak them whichever field it reads.\n *\n * Step 2 enumerates nothing by hand: a check added to `GATE_CHECKS` is enforced\n * here the moment its disposition in that policy says so.\n *\n * Also normalizes the optional wire flag to an explicit boolean.\n * `realness_gated` is absent on pre-unification ledgers and absent means \"not\n * flagged\" per the schema, so filling it in states a claim the line was already\n * making, and makes the flag readable on every published row instead of most of\n * them. `realness_screened` is NOT filled in: absent means \"unknown\", and\n * inventing either value there would be the same overclaim this round removed.\n */\nexport function assertMinted(value: unknown, context = 'rollout line'): MintedRolloutLine {\n  assertRolloutLine(value, context)\n  const refused = gateErrors(value, GATE_POLICIES.assertMinted)\n  if (refused.length > 0) {\n    throw new Error(`invalid ${context}: rollout ${value.rollout_id} — ${refused[0]}`)\n  }\n  const gated = gateGamedOutcome(value)\n  if (gated.outcome.realness_gated === undefined) {\n    return {\n      ...gated,\n      outcome: { ...gated.outcome, realness_gated: false },\n    } as MintedRolloutLine\n  }\n  return gated as MintedRolloutLine\n}\n\n/** `assertMinted` over a batch, naming the offending index in the error. */\nexport function assertMintedLines(\n  values: readonly unknown[],\n  context = 'rollout line',\n): MintedRolloutLine[] {\n  return values.map((value, i) => assertMinted(value, `${context} [${i}]`))\n}\n"],"mappings":"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"}

package/dist/search/index.d.ts

@@ -1,8 +1,7 @@
-import { A as SearchLedgerHash, C as SearchEdgeOperator, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, T as SearchEstimateMethod, W as SearchSourceRef, i as SearchArtifactRef, j as SearchModelIdentity, l as SearchCandidateSurface, m as SearchClaim, t as NodeEstimate, y as SearchCloseReason } from "../search-ledger-types-p2xKfiDJ.js";
-import { X as SearchStateView, tt as SearchNode } from "../types-M6eF9m-r.js";
-import { $ as ExpansionOperator, I as SearchPolicy, R as SearchPolicyView, a as SearchArtifactCodec, at as OperatorYieldSignal, ct as LensSampleSummary, et as MIN_OUTCOMES_FOR_WEIGHT, h as SearchRunResult, i as RunSearchOptions, it as OperatorYieldRow, j as SearchUnitExtension, l as SearchLane, lt as LensSignal, nt as OperatorYieldData, ot as operatorYield, rt as OperatorYieldOptions, st as LensResult, tt as OperatorOutcomeCounts, ut as summarizeSamples } from "../search-kernel-CctpiDd2.js";
+import { A as SearchLedgerHash, C as SearchEdgeOperator, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, T as SearchEstimateMethod, W as SearchSourceRef, i as SearchArtifactRef, j as SearchModelIdentity, l as SearchCandidateSurface, m as SearchClaim, t as NodeEstimate, y as SearchCloseReason } from "../search-ledger-types-qiYRUo_N.js";
+import { X as SearchStateView, st as SearchNode } from "../types-C54Uk_a1.js";
+import { $ as ExpansionOperator, I as SearchPolicy, R as SearchPolicyView, a as SearchArtifactCodec, at as OperatorYieldSignal, ct as LensSampleSummary, et as MIN_OUTCOMES_FOR_WEIGHT, h as SearchRunResult, i as RunSearchOptions, it as OperatorYieldRow, j as SearchUnitExtension, l as SearchLane, lt as LensSignal, nt as OperatorYieldData, ot as operatorYield, rt as OperatorYieldOptions, st as LensResult, tt as OperatorOutcomeCounts, ut as summarizeSamples } from "../search-kernel-CBdwFZ05.js";
 import { AgentProfileResourceRef } from "@tangle-network/agent-interface";
-//#region src/search/lenses/edit-credit-contract.d.ts
 interface EditCreditOptions {
   /**
    * The parsed content a node's artifact reference names, or undefined when
@@ -203,22 +202,16 @@ interface EditCreditSignal extends LensSignal<number | null> {
 type EditCreditResult = LensResult<EditCreditData, number | null> & {
   signal: EditCreditSignal;
 };
-//#endregion
-//#region src/search/lenses/edit-credit-text.d.ts
 /** The lens as compact text: what `agent-eval search show --edit-credit`
  * prints and a proposer can read. */
 export declare function editCreditText(result: EditCreditResult, options?: {
   limit?: number;
 }): string;
-//#endregion
-//#region src/search/lenses/edit-credit.d.ts
 /**
  * The edit-credit lens. Pure: the result depends only on `state` and what
  * `readArtifact` returns for its references.
  */
 export declare function editCredit(state: SearchStateView, options: EditCreditOptions): EditCreditResult;
-//#endregion
-//#region src/search/lenses/front.d.ts
 interface FrontExtraAxis {
   name: string;
   direction: 'maximize' | 'minimize';
@@ -276,8 +269,6 @@ export declare function front(state: SearchStateView, options?: FrontOptions): {
     value: FrontSignal;
   };
 };
-//#endregion
-//#region src/search/lenses/geometry.d.ts
 /** The one number a geometry lens exposes to policies: the shared
  * `LensSignal`, with the noise model and sample it rests on. */
 interface GeometrySignal extends LensSignal<number | null> {
@@ -299,8 +290,6 @@ interface GeometryLensResult<TData> extends LensResult<TData, number | null> {
   sequence: number;
   signal: GeometrySignal;
 }
-//#endregion
-//#region src/search/lenses/plateau.d.ts
 /** What the plateau reads: a policy view, or the lens's own reading of one. */
 type SearchPlateauView = Pick<SearchPolicyView, 'direction' | 'rootNodeId' | 'screened' | 'complete' | 'unitScores'>;
 interface SearchPlateauOptions {
@@ -365,8 +354,6 @@ interface DraftOnPlateauOptions {
  * never refined.
  */
 export declare function draftOnPlateau(base: SearchPolicy, options?: DraftOnPlateauOptions): SearchPolicy;
-//#endregion
-//#region src/search/lenses/landscape-contract.d.ts
 /**
  * How the lens measures the distance between two nodes' profiles.
  *
@@ -533,8 +520,6 @@ interface LandscapeData {
   };
   plateau: SearchPlateau;
 }
-//#endregion
-//#region src/search/lenses/landscape-embeddings.d.ts
 /** The default: edits recorded between two profiles along the lineage. */
 export declare function lineageEdits(): LandscapeEmbedding;
 /**
@@ -548,16 +533,12 @@ export declare function lineageEdits(): LandscapeEmbedding;
 export declare function surfaceTextEdits(read: (surface: SearchCandidateSurface) => unknown): LandscapeEmbedding;
 /** A caller's vector per node, for example a model embedding of its profile. */
 export declare function vectorEmbedding(name: string, vector: (node: SearchNode) => readonly number[] | null): LandscapeEmbedding;
-//#endregion
-//#region src/search/lenses/landscape.d.ts
 /**
  * The landscape of a search: every node placed by `embed`, the interpolated
  * score over the placement, the basins of that surface, and the plateau
  * signal. Pure: it reads the state and calls `embed`.
  */
 export declare function landscape(state: SearchStateView, embed?: LandscapeEmbedding, options?: LandscapeOptions): GeometryLensResult<LandscapeData>;
-//#endregion
-//#region src/search/lenses/meta-search.d.ts
 /** The configuration that ran a search, as its ledger records it. */
 interface SearchPolicyGenome {
   /** `policy.expansion`: the policy's name with its parameters. A parameter
@@ -799,8 +780,6 @@ export declare const META_SEARCH_SCORE_SOURCE: SearchSourceRef;
 export declare function metaSearchScore(state: SearchStateView): MetaSearchScore;
 /** The lens: every search as a node of a search of searches. */
 export declare function metaSearch(searches: readonly SearchStateView[], options?: MetaSearchOptions): LensResult<MetaSearchData, BestPolicyConfiguration>;
-//#endregion
-//#region src/search/lenses/meta-search-text.d.ts
 interface MetaSearchTextOptions {
   /** Searches listed under each outer node or parent before the rest are
    * counted. Default 5. */
@@ -813,8 +792,6 @@ interface MetaSearchTextOptions {
  * --meta` prints it.
  */
 export declare function renderMetaSearchText(result: LensResult<MetaSearchData, BestPolicyConfiguration>, options?: MetaSearchTextOptions): string;
-//#endregion
-//#region src/search/lenses/skill-manifold-contract.d.ts
 interface SkillManifoldOptions {
   /** The split scores come from. Default: the ranked split. */
   split?: 'selection' | 'train';
@@ -982,8 +959,6 @@ interface SkillManifoldData {
   batch: string[] | null;
   insufficient: string | null;
 }
-//#endregion
-//#region src/search/lenses/skill-manifold.d.ts
 /**
  * The skill manifold of a search at rank `k` (`auto`: the cross-validated
  * intrinsic dimension, at least 1, and 1 when too few nodes cross-validate).
@@ -1007,8 +982,6 @@ export declare function skillCalibration(lens: GeometryLensResult<SkillManifoldD
 export declare function nextUnitExtension(calibration: SkillCalibration, options?: {
   leaders?: number;
 }): SearchUnitExtension;
-//#endregion
-//#region src/search/lenses/task-matrix.d.ts
 interface TaskMatrixCell {
   nodeId: string;
   unitId: string;
@@ -1067,8 +1040,6 @@ export declare function taskMatrix(state: SearchStateView, options?: TaskMatrixO
     value: TaskMatrixSignal;
   };
 };
-//#endregion
-//#region src/search/lenses/tree.d.ts
 interface TreeNode {
   nodeId: string;
   status: SearchNodeStatus | null;
@@ -1103,8 +1074,6 @@ export declare function tree(state: SearchStateView): {
     value: number;
   };
 };
-//#endregion
-//#region src/search/nested-search.d.ts
 /** The outer cell attempt an inner search runs as. */
 type NestedSearchContainment = NonNullable<SearchOpenedEvent['containment']>;
 /** One inner search to run: a configuration on one outer task. */
@@ -1152,6 +1121,5 @@ export declare function searchConfigCodec<TConfig>(): SearchArtifactCodec<TConfi
  * `META_SEARCH_SCORE_SOURCE`.
  */
 export declare function runNestedSearch<TConfig>(options: RunNestedSearchOptions<TConfig>): Promise<SearchRunResult>;
-//#endregion
 export { type BestPolicyConfiguration, type DraftOnPlateauOptions, type EditCreditData, type EditCreditOptions, type EditCreditResult, type EditCreditSignal, type EditGene, type EditGeneVerdict, type EditInteraction, type EditIntroduction, type EditLineageRow, type EditSkillCandidate, type ExpansionOperator, type FrontData, type FrontExtraAxis, type FrontOptions, type FrontRow, type FrontSignal, type GeometryLensResult, type GeometrySignal, type LandscapeBasin, type LandscapeData, type LandscapeEmbedding, type LandscapeGrid, type LandscapeNode, type LandscapeOptions, type LensResult, type LensSampleSummary, type LensSignal, MIN_OUTCOMES_FOR_WEIGHT, type MetaSearchConfiguration, type MetaSearchConfigurationEstimate, type MetaSearchData, type MetaSearchEntry, type MetaSearchLiftPerUsd, type MetaSearchOptions, type MetaSearchParent, type MetaSearchScore, type MetaSearchSpend, type MetaSearchTextOptions, type MetaSearchUnscoredReason, type NestedSearchContainment, type NestedSearchRunInput, type OperatorOutcomeCounts, type OperatorYieldData, type OperatorYieldOptions, type OperatorYieldRow, type OperatorYieldSignal, type RunNestedSearchOptions, type SearchPlateau, type SearchPlateauOptions, type SearchPlateauView, type SearchPolicyGenome, type SkillCalibration, type SkillManifoldData, type SkillManifoldNextUnit, type SkillManifoldNode, type SkillManifoldOptions, type SkillManifoldUnit, type TaskMatrixCell, type TaskMatrixCluster, type TaskMatrixData, type TaskMatrixOptions, type TaskMatrixSignal, type TaskMatrixSpecialistRow, type TreeData, type TreeNode, operatorYield, summarizeSamples };
 //# sourceMappingURL=index.d.ts.map

package/dist/search/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/search/lenses/edit-credit-contract.ts","../../src/search/lenses/edit-credit-text.ts","../../src/search/lenses/edit-credit.ts","../../src/search/lenses/front.ts","../../src/search/lenses/geometry.ts","../../src/search/lenses/plateau.ts","../../src/search/lenses/landscape-contract.ts","../../src/search/lenses/landscape-embeddings.ts","../../src/search/lenses/landscape.ts","../../src/search/lenses/meta-search.ts","../../src/search/lenses/meta-search-text.ts","../../src/search/lenses/skill-manifold-contract.ts","../../src/search/lenses/skill-manifold.ts","../../src/search/lenses/task-matrix.ts","../../src/search/lenses/tree.ts","../../src/search/nested-search.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/search/lenses/edit-credit-contract.ts","../../src/search/lenses/edit-credit-text.ts","../../src/search/lenses/edit-credit.ts","../../src/search/lenses/front.ts","../../src/search/lenses/geometry.ts","../../src/search/lenses/plateau.ts","../../src/search/lenses/landscape-contract.ts","../../src/search/lenses/landscape-embeddings.ts","../../src/search/lenses/landscape.ts","../../src/search/lenses/meta-search.ts","../../src/search/lenses/meta-search-text.ts","../../src/search/lenses/skill-manifold-contract.ts","../../src/search/lenses/skill-manifold.ts","../../src/search/lenses/task-matrix.ts","../../src/search/lenses/tree.ts","../../src/search/nested-search.ts"],"mappings":"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"}

package/dist/search/index.js

@@ -1,7 +1,7 @@
-import { a as hashCanonical } from "../canonical-Dq2hOQ8L.js";
-import { c as MIN_OUTCOMES_FOR_WEIGHT, f as summarizeSamples, i as runSearch, l as operatorYield } from "../pareto-BiBnQXAE.js";
-import { _ as vectorEmbedding, a as skillCalibration, b as editCreditText, c as META_SEARCH_SCORE_SOURCE, d as searchPolicyGenome, f as landscape, g as surfaceTextEdits, h as lineageEdits, i as nextUnitExtension, l as metaSearch, n as taskMatrix, o as skillManifold, p as draftOnPlateau, s as renderMetaSearchText, t as tree, u as metaSearchScore, v as front, y as editCredit } from "../tree-DSqwJpL9.js";
-//#region src/search/nested-search.ts
+import { a as hashCanonical } from "../canonical-CicJlINA.js";
+import { c as MIN_OUTCOMES_FOR_WEIGHT, f as summarizeSamples, i as runSearch, l as operatorYield } from "../pareto-B9udAt2i.js";
+import { _ as vectorEmbedding, a as skillCalibration, b as editCreditText, c as META_SEARCH_SCORE_SOURCE, d as searchPolicyGenome, f as landscape, g as surfaceTextEdits, h as lineageEdits, i as nextUnitExtension, l as metaSearch, n as taskMatrix, o as skillManifold, p as draftOnPlateau, s as renderMetaSearchText, t as tree, u as metaSearchScore, v as front, y as editCredit } from "../tree-DrIChF4a.js";
+// src/search/nested-search.ts
 /** The deterministic id of the inner search one outer cell attempt runs. */
 function nestedSearchId(containment) {
 	const { searchId, cellId, attempt } = containment;
@@ -181,7 +181,6 @@ function outerResult(recorder, request, inner, lane, wallMs) {
 function asRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : { value };
 }
-//#endregion
 export { META_SEARCH_SCORE_SOURCE, MIN_OUTCOMES_FOR_WEIGHT, draftOnPlateau, editCredit, editCreditText, front, landscape, lineageEdits, metaSearch, metaSearchScore, nestedSearchId, nextUnitExtension, operatorYield, renderMetaSearchText, runNestedSearch, searchConfigCodec, searchPolicyGenome, skillCalibration, skillManifold, summarizeSamples, surfaceTextEdits, taskMatrix, tree, vectorEmbedding };
 
 //# sourceMappingURL=index.js.map