@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/schema-C6DW4ZHR.js

@@ -0,0 +1,821 @@
+//#region src/rollout/gate-checks.ts
+/**
+* Every gate check in the package, in the order they are applied.
+*
+* Order is load-bearing only for which message a caller sees first: a line that
+* trips two checks reports the earlier one, and `reward-relationship` is first
+* because it is the invariant the other three protect.
+*/
+const GATE_CHECK_IDS = [
+	"reward-relationship",
+	"gated-evidence",
+	"undeclared-step-payload",
+	"unscreened-reward"
+];
+/** One untyped field read off the outcome, so every check narrows from the same place. */
+const field = (subject, name) => subject.outcome?.[name];
+function readReward(value) {
+	if (value === null || value === void 0) return { kind: "absent" };
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) return {
+			kind: "unreadable",
+			shown: "NaN"
+		};
+		return value > 0 ? {
+			kind: "positive",
+			shown: String(value)
+		} : { kind: "cleared" };
+	}
+	return {
+		kind: "unreadable",
+		shown: `${JSON.stringify(value) ?? String(value)} (${typeof value})`
+	};
+}
+const isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Whether a reward-derived field carries anything at all.
+*
+* The previous emptiness test was `Object.keys(value).length > 0`, which reads
+* `[]` for a NUMBER, a BOOLEAN and the empty string — so `metrics: 0.95` on a
+* gated line counted as empty and shipped verbatim in the verifiers format's
+* per-rubric score dict. `Object.keys` being total over primitives is not the
+* same property as being CORRECT over them.
+*
+* The rule that has no such hole: only `undefined`, `null` and a record with no
+* keys are empty. Everything else is payload, whatever its type.
+*/
+function payloadIsPopulated(value) {
+	if (value === void 0 || value === null) return false;
+	if (isPlainRecord(value)) return Object.keys(value).length > 0;
+	return true;
+}
+/**
+* Every key `tangle.rollout.v1` declares on a step, as a TOTAL map over the
+* interface: a field added to `RolloutStep` and not to this list does not
+* compile, so the list cannot silently fall behind the schema it mirrors.
+*
+* This is the producer's OWN classification, which is the only partition
+* `gatedEvidenceOf` accepts — a key-name heuristic ("strip anything matching
+* /reward|score/") holds until someone names a field `credit` and the next
+* per-step signal ships at full value.
+*/
+const DECLARED_STEP_KEYS = {
+	kind: true,
+	name: true,
+	input: true,
+	output: true,
+	status: true,
+	durationMs: true,
+	llm_call_count: true,
+	prompt_token_ids: true,
+	completion_token_ids: true,
+	logprobs: true
+};
+/**
+* The part of `steps` the wire format has no name for — a per-step reward, a
+* per-step score, whatever a producer decided to hang there.
+*
+* `undefined` when the steps carry nothing undeclared.
+*/
+function undeclaredStepPayload(steps) {
+	if (steps === void 0 || steps === null) return void 0;
+	if (!Array.isArray(steps)) return steps;
+	const extras = [];
+	let found = false;
+	for (const step of steps) {
+		const extra = {};
+		if (isPlainRecord(step)) for (const [key, value] of Object.entries(step)) {
+			if (key in DECLARED_STEP_KEYS) continue;
+			extra[key] = value;
+			found = true;
+		}
+		else if (step !== void 0 && step !== null) {
+			extras.push({ step });
+			found = true;
+			continue;
+		}
+		extras.push(extra);
+	}
+	return found ? extras : void 0;
+}
+/** `steps` projected down to the keys the wire format declares. */
+function declaredSteps(steps) {
+	if (!Array.isArray(steps)) return void 0;
+	const kept = [];
+	for (const step of steps) {
+		if (!isPlainRecord(step)) continue;
+		const projected = {};
+		for (const [key, value] of Object.entries(step)) if (key in DECLARED_STEP_KEYS) projected[key] = value;
+		kept.push(projected);
+	}
+	return kept;
+}
+/**
+* THE anti-Goodhart invariant, checked as a RELATIONSHIP between two fields
+* rather than as two independent type checks.
+*
+* Everything upstream of a training export is allowed to be wrong; this is the
+* one thing that cannot be. `realness_gated: true` means the run faked its
+* success signal, so its reward is a fabrication, and a fabrication above zero
+* is precisely what a trainer would learn to reproduce. Validating only that
+* `reward` is a number and `realness_gated` is a boolean is what let a line
+* claiming `{reward: 0.95, realness_gated: true}` validate clean and walk
+* through every exporter.
+*/
+const rewardRelationship = {
+	id: "reward-relationship",
+	refuses: "a positive — or unreadable — reward on a line the authenticity screen flagged as gamed",
+	tripwires: [{ outcome: {
+		reward: .95,
+		realness_gated: true
+	} }, { outcome: {
+		reward: "0.95",
+		realness_gated: true
+	} }],
+	errors: (subject) => {
+		if (field(subject, "realness_gated") !== true) return [];
+		const reading = readReward(field(subject, "reward"));
+		if (reading.kind === "absent" || reading.kind === "cleared") return [];
+		if (reading.kind === "unreadable") return [`outcome.reward: ${reading.shown} with outcome.realness_gated: true — the wire format declares this field \`number | null\`, so the gate cannot read this value as a number and cannot establish that the reward was cleared. On a run flagged as gamed that is not evidence of a zero, it is the absence of it, and a consumer that coerces the value (\`"0.95"\`, \`"2"\`) reads a positive reward off a faked success. Emit a number or null — \`trainingReward\` / \`trainingScore\` from \`rollout/reward.ts\` produce one.`];
+		return [`outcome.reward: ${reading.shown} with outcome.realness_gated: true — a run flagged as gamed may not carry a positive reward. The anti-Goodhart gate forces the reward to 0 (a real verdict: the gate decided) before the line is written, so a fine-tune cannot learn from a faked success. Derive the reward with \`trainingReward\` / \`trainingScore\` from \`rollout/reward.ts\`, or drop the line.`];
+	}
+};
+/**
+* The reward-bearing outcome fields that are NOT the scalar: the numbers the
+* reward was computed from, and the verdict record that claimed it.
+*
+* Returned as one block rather than filtered key-by-key. A key-name heuristic
+* ("zero anything matching `layer.*` or `/score/`") is the same defect shape as
+* the line-oriented regex the AST score guard replaced: it holds until someone
+* names a metric `pass_fraction`, and the next reward-shaped key ships at full
+* value. The producer's OWN classification — "this is the scalar, that is
+* everything else" — is the only partition that cannot be out-guessed.
+*/
+function gatedEvidenceOf(subject) {
+	const evidence = {};
+	const metrics = field(subject, "metrics");
+	if (payloadIsPopulated(metrics)) evidence.metrics = metrics;
+	const verdict = field(subject, "verdict");
+	if (verdict !== null && verdict !== void 0) evidence.verdict = verdict;
+	const steps = undeclaredStepPayload(subject.steps);
+	if (steps !== void 0) evidence.steps = steps;
+	return evidence.metrics === void 0 && evidence.verdict === void 0 && steps === void 0 ? void 0 : evidence;
+}
+/**
+* The invariant is about the OUTCOME, not about one field of it.
+*
+* `mintRolloutRows` bulk-copied `RunRecord.outcome.raw` into `outcome.metrics`
+* with no gate, so a gated run exported `reward: 0` (correct) while the
+* deterministic per-layer scores that reward was COMPUTED FROM — the `layer.*`
+* keys `rl/verifiable-reward.ts` calls the RL training signal — shipped at 1.0,
+* in the top-level `metrics` dict of the Prime Intellect verifiers format, which
+* IS that format's per-rubric score dict. `verdict` leaks the same way into
+* `toRftItem`'s `reference.verdict`, where a grader author reads
+* `resolved: true` off a run that faked it.
+*/
+const gatedEvidence = {
+	id: "gated-evidence",
+	refuses: "the numbers a fabricated reward was computed from, riding along at reward 0",
+	tripwires: [{ outcome: {
+		reward: 0,
+		realness_gated: true,
+		metrics: { "layer.tests": 1 }
+	} }, { outcome: {
+		reward: 0,
+		realness_gated: true,
+		metrics: .95
+	} }],
+	errors: (subject) => {
+		if (field(subject, "realness_gated") !== true) return [];
+		const evidence = gatedEvidenceOf(subject);
+		if (evidence === void 0) return [];
+		if (evidence.metrics === void 0 && evidence.verdict === void 0) return [];
+		return [`${evidence.metrics !== void 0 ? "outcome.metrics" : "outcome.verdict"} is populated with outcome.realness_gated: true — a run flagged as gamed may not ship the numbers its fabricated reward was computed from, even at reward 0. The per-layer scores in \`metrics\` ARE the reward signal in the verifiers format, and \`verdict\` is the record that claimed the success. Mint through \`assertMinted\`, which relocates both to \`provenance.gated_evidence\` (see \`gateGamedOutcome\`), or drop the line.`];
+	}
+};
+/**
+* A reward-bearing field hung on `steps[]`, where the gate was not looking.
+*
+* The first three checks all read `outcome`, so the whole apparatus was blind to
+* anything a producer wrote elsewhere on the line — and `toRewardRows` emits
+* `steps` verbatim beside the scalar it just forced to 0. A generated corpus
+* found it in twenty cases: a gated line carrying
+* `steps: [{kind, name, reward: 0.86}]` exported `{"reward": 0, "steps":
+* [{"reward": 0.86}]}`, which is the per-step credit assignment of a run that
+* faked its success, at full value, through the MINTED door.
+*
+* `RolloutStep` declares ten keys and none of them is a reward, so the partition
+* needs no judgement call: whatever the format does not name is unclassified
+* payload, and on a gated line unclassified payload is exactly what the gate
+* refuses. `assertMinted` relocates it rather than rejecting, like the sibling
+* check, so an already-published ledger stays readable.
+*/
+const undeclaredStepPayloadCheck = {
+	id: "undeclared-step-payload",
+	refuses: "per-step reward signal hung on a gated line’s steps, outside every field the gate read",
+	tripwires: [{
+		outcome: {
+			reward: 0,
+			realness_gated: true
+		},
+		steps: [{
+			kind: "tool",
+			name: "edit",
+			reward: .9
+		}]
+	}],
+	errors: (subject) => {
+		if (field(subject, "realness_gated") !== true) return [];
+		const extra = undeclaredStepPayload(subject.steps);
+		if (extra === void 0) return [];
+		return [`steps[] carries fields \`${ROLLOUT_SCHEMA_NAME}\` does not declare (${JSON.stringify(extra).slice(0, 120)}) with outcome.realness_gated: true — a per-step reward is training signal exactly like the scalar, and the exporters copy \`steps\` through verbatim, so zeroing \`outcome.reward\` while leaving it in place ships the gamed run’s step-level credit assignment at full value. Mint through \`assertMinted\`, which projects the steps down to the declared keys and relocates the rest to \`provenance.gated_evidence.steps\` (see \`gateGamedOutcome\`).`];
+	}
+};
+/** Named here rather than imported, so `gate-checks` stays free of schema cycles. */
+const ROLLOUT_SCHEMA_NAME = "tangle.rollout.v1";
+/**
+* The registry. Total over `GateCheckId`, so an id with no check does not
+* compile, and `GATE_CHECK_IDS` stays the single enumeration everything
+* iterates.
+*/
+const GATE_CHECKS = {
+	"reward-relationship": rewardRelationship,
+	"gated-evidence": gatedEvidence,
+	"undeclared-step-payload": undeclaredStepPayloadCheck,
+	"unscreened-reward": {
+		id: "unscreened-reward",
+		refuses: "a positive reward whose producer declares that no authenticity screen ever ran",
+		tripwires: [{ outcome: {
+			reward: 1,
+			realness_gated: false,
+			realness_screened: false
+		} }, { outcome: {
+			reward: "2",
+			realness_gated: false,
+			realness_screened: false
+		} }],
+		errors: (subject) => {
+			if (field(subject, "realness_screened") !== false) return [];
+			const reading = readReward(field(subject, "reward"));
+			if (reading.kind === "absent" || reading.kind === "cleared") return [];
+			return [`outcome.reward: ${reading.shown} with outcome.realness_screened: false — this producer declares that NO authenticity screen ran on this reward, so nothing has established the success is real, and an unscreened positive reward is exactly the signal the anti-Goodhart gate exists to qualify. Screen the run and write the verdict (\`rolloutRewardFields\` from a \`RunRecord\` carrying \`outcome.realness\`), or emit \`reward: null\` — an unqualified verdict is a labeled gap, not a measured success.`];
+		}
+	}
+};
+const enforced = { kind: "enforce" };
+const repairedBy = (by) => ({
+	kind: "repair",
+	by
+});
+const omittedBecause = (because) => ({
+	kind: "omit",
+	because
+});
+/**
+* Every entry point that decides about the gate, and what it decides.
+*
+* Read this as the package's gate policy in one screen. The four entry points
+* are not interchangeable — a validator that rejects, a mint funnel that
+* repairs, a runtime backstop for untyped callers, and a release certifier over
+* emitted rows — and the dispositions say which is which.
+*/
+const GATE_POLICIES = {
+	/**
+	* The schema validator. Rejects the reward relationship and NOTHING ELSE, on
+	* purpose: it runs on every line read off disk, and the other two conditions
+	* describe artifacts that already exist.
+	*/
+	validateRolloutLine: {
+		"reward-relationship": enforced,
+		"gated-evidence": omittedBecause("a ledger written before the relocation existed carries `metrics` on its gated lines; rejecting those would make every already-published artifact unreadable. The condition is REPAIRED at `assertMinted` (`gateGamedOutcome`) instead, which is the only door into the training path, so the artifact stays readable and the leak still closes."),
+		"undeclared-step-payload": omittedBecause("identical reasoning to `gated-evidence`, one field over: a foreign or pre-unification ledger may carry producer-invented keys on its steps, and refusing to READ those files buys nothing the relocation at `assertMinted` does not already buy. Promotion into training is where it closes."),
+		"unscreened-reward": omittedBecause("supervision-journal rows legitimately carry an unscreened positive reward (there is no `RunRecord.outcome.realness` behind them) and must stay writable, readable and reportable. Only PROMOTION into training is closed, at `assertMinted`.")
+	},
+	/**
+	* The mint funnel — the single door every `MintedRolloutLine` passes. Validates
+	* first (so the reward relationship has already been rejected), then refuses
+	* what cannot be repaired, then repairs what can.
+	*/
+	assertMinted: {
+		"reward-relationship": enforced,
+		"gated-evidence": repairedBy("gateGamedOutcome"),
+		"undeclared-step-payload": repairedBy("gateGamedOutcome"),
+		"unscreened-reward": enforced
+	},
+	/**
+	* The runtime backstop, and the one entry point with no license to omit
+	* anything: it exists for callers the type system never saw (plain JavaScript
+	* handing an object literal to a published exporter), so a check it skips is a
+	* check that does not run at all for them. This is where the fourth leak was.
+	*/
+	assertRewardGate: {
+		"reward-relationship": enforced,
+		"gated-evidence": enforced,
+		"undeclared-step-payload": enforced,
+		"unscreened-reward": enforced
+	},
+	/**
+	* The release certifier. Same checks, measured over the rows a release is
+	* ABOUT TO WRITE rather than over one line's outcome — see `REPORT_MEASURES`
+	* in `release/gate-report.ts`, which is the second total map this policy
+	* drives.
+	*/
+	assertGateReport: {
+		"reward-relationship": enforced,
+		"gated-evidence": enforced,
+		"undeclared-step-payload": enforced,
+		"unscreened-reward": enforced
+	}
+};
+/**
+* Run the checks one entry point enforces. The ONLY way an entry point should
+* obtain gate errors — hand-composing two of the three is the bug this module
+* exists to remove.
+*/
+function gateErrors(subject, policy) {
+	const errors = [];
+	for (const id of GATE_CHECK_IDS) {
+		if (policy[id].kind !== "enforce") continue;
+		errors.push(...GATE_CHECKS[id].errors(subject));
+	}
+	return errors;
+}
+//#endregion
+//#region 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
+* supervisor episode, a worker session, a proposer shot, a judge call, an
+* analyst pass), labeled with its task/split coordinates and a single
+* scalar reward, carrying the FULL message transcript inline.
+*
+* This schema is the reconciliation of two prior producers:
+*   - agent-eval's RunRecord-joined rollout rows (PR #410): identity,
+*     provenance hashes, the realness gate travelling into the reward,
+*     trace-derived steps.
+*   - the bench rollout-ledger (agent-runtime PR #591): the wire shape —
+*     role, task.split/rep, parent_rollout_id, policy provenance, capture
+*     provenance, inline canonical chat-with-tools messages.
+* Where the two conflicted, RunRecord-derived semantics won; the wire
+* field names follow the ledger (snake_case). See `docs/rollout.md` for
+* the field-by-field decision table.
+*
+* Messages are inlined — never referenced — because every harness store a
+* rollout can be recovered from is mutable or garbage-collected. A line
+* must stay a complete training/eval example on its own.
+*
+* `outcome.reward` is THE single scalar (null = no verdict exists — a
+* labeled gap, never 0). `outcome.realness_gated` is the anti-Goodhart
+* flag: a gated line must never export as a positive training example.
+*
+* That last sentence is enforced here, by `validateRolloutLine`, not merely
+* documented. Validating `reward` and `realness_gated` independently — each a
+* well-typed field, their COMBINATION unchecked — is what let a line claiming
+* `{reward: 0.95, realness_gated: true}` validate clean and walk into every
+* training export. The relationship between the two IS the invariant, so it is
+* checked where every other structural claim about a line is checked.
+*
+* The invariant is about the OUTCOME, not about one field of it. Zeroing
+* `reward` while `outcome.metrics` still carried the per-layer scores that
+* reward was computed from exported the gamed signal anyway, in the dict the
+* verifiers format reads as its per-rubric scores. So `gateGamedOutcome`
+* transforms the whole outcome once, at `assertMinted` — the funnel every
+* minted line passes — and the reward-bearing components are relocated to
+* `provenance.gated_evidence`, which no exporter projects.
+*
+* WHICH checks each door applies is not decided in this file. `./gate-checks`
+* owns the canonical list and the total per-entry-point policy; the three doors
+* below (`validateRolloutLine`, `assertRewardGate`, `assertMinted`) each call
+* `gateErrors` with their declared policy, so a check added to that list applies
+* here without anyone editing this file, and a check deliberately skipped has to
+* name itself there.
+*/
+const ROLLOUT_SCHEMA = "tangle.rollout.v1";
+const ROLLOUT_ROLES = [
+	"agent",
+	"supervisor",
+	"worker",
+	"proposer",
+	"judge",
+	"analyst"
+];
+const ROLLOUT_SPLITS = [
+	"search",
+	"dev",
+	"holdout",
+	"canary"
+];
+/** Splits that may ship in training exports. Everything else is fail-closed excluded. */
+const TRAINABLE_SPLITS = ["search"];
+function isTrainableSplit(split) {
+	return TRAINABLE_SPLITS.includes(split);
+}
+const ROLLOUT_CAPTURES = [
+	"mint",
+	"settle-time",
+	"backfill"
+];
+const CHAT_ROLES = [
+	"system",
+	"user",
+	"assistant",
+	"tool"
+];
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isNumberOrNull = (v) => v === null || typeof v === "number";
+const isNumberArray = (v) => Array.isArray(v) && v.every((n) => typeof n === "number" && Number.isFinite(n));
+const isIntegerArray = (v) => Array.isArray(v) && v.every((n) => Number.isInteger(n));
+const isStringOrNull = (v) => v === null || typeof v === "string";
+const isIntegerOrNull = (v) => v === null || Number.isInteger(v);
+function validateChatMessage(value, path, errors) {
+	if (!isRecord(value)) {
+		errors.push(`${path}: not an object`);
+		return;
+	}
+	if (!CHAT_ROLES.includes(value.role)) errors.push(`${path}.role: invalid role ${String(value.role)}`);
+	if (!isStringOrNull(value.content)) errors.push(`${path}.content: must be string|null`);
+	if (value.reasoning_content !== void 0 && typeof value.reasoning_content !== "string") errors.push(`${path}.reasoning_content: must be string when present`);
+	if (value.tool_call_id !== void 0 && typeof value.tool_call_id !== "string") errors.push(`${path}.tool_call_id: must be string when present`);
+	if (value.role === "tool" && typeof value.tool_call_id !== "string") errors.push(`${path}.tool_call_id: required on role:"tool"`);
+	if (value.is_copied_context !== void 0 && typeof value.is_copied_context !== "boolean") errors.push(`${path}.is_copied_context: must be boolean when present`);
+	if (value.tool_calls !== void 0) if (!Array.isArray(value.tool_calls)) errors.push(`${path}.tool_calls: must be an array when present`);
+	else value.tool_calls.forEach((call, i) => {
+		if (!isRecord(call) || typeof call.id !== "string" || call.type !== "function") {
+			errors.push(`${path}.tool_calls[${i}]: must be {id, type:"function", function}`);
+			return;
+		}
+		const fn = call.function;
+		if (!isRecord(fn) || typeof fn.name !== "string" || typeof fn.arguments !== "string") errors.push(`${path}.tool_calls[${i}].function: must be {name: string, arguments: string}`);
+	});
+}
+function validateSection(value, path, fields, errors) {
+	if (!isRecord(value)) {
+		errors.push(`${path}: not an object`);
+		return;
+	}
+	for (const [name, check, expect] of fields) if (!check(value[name])) errors.push(`${path}.${name}: expected ${expect}`);
+}
+/**
+* THE anti-Goodhart gate, applied to the WHOLE outcome as a TRANSFORMATION.
+*
+* Two prior rounds enforced the gate as a CHECK ON ONE FIELD at N call sites,
+* and each round the next reward-bearing field leaked. The one that shipped:
+* `mintRolloutRows` bulk-copied `RunRecord.outcome.raw` into `outcome.metrics`
+* with no gate, so a gated run exported `reward: 0` (correct) while the
+* deterministic per-layer scores that reward was COMPUTED FROM — the
+* `layer.*` keys `rl/verifiable-reward.ts` calls the RL training signal —
+* shipped at 1.0, in the top-level `metrics` dict of the Prime Intellect
+* verifiers format, which IS that format's per-rubric score dict. `verdict`
+* leaks the same way into `toRftItem`'s `reference.verdict`, where a grader
+* author reads `resolved: true` off a run that faked it.
+*
+* So the rule is no longer "zero the field we remembered". It is: if the gate
+* fired, the outcome that leaves here carries NOTHING positive that was derived
+* from the reward, whichever field a present or future exporter decides to
+* read. `reward` is already forced to 0 upstream (`trainingReward`) and
+* REJECTED here if it is not; `metrics` and `verdict` are relocated.
+*
+* WHERE they go, and why relocation rather than deletion: zeroing destroys the
+* audit trail that shows why the run was gated and what it claimed, which is
+* the row an auditor most wants and the labeled example a gaming DETECTOR
+* trains on. `provenance.gated_evidence` keeps every byte, at a path no
+* training exporter reads — all four release configs and every `rl/exporters`
+* shape project from `outcome`, `messages`, `cost` and `task`; none projects
+* `provenance`. Auditability preserved, training signal removed, and a future
+* exporter that reads a field nobody thought of is safe by construction because
+* the field is empty rather than because the exporter remembered to check.
+*
+* Idempotent: a second application finds nothing left to move and returns the
+* line unchanged, so re-minting a line read back off a ledger cannot clobber
+* the evidence it already carries.
+*/
+function gateGamedOutcome(line) {
+	if (line.outcome.realness_gated !== true) return line;
+	const moved = gatedEvidenceOf(line);
+	if (moved === void 0) return line;
+	const kept = line.provenance.gated_evidence;
+	const evidence = {};
+	const metrics = {
+		...kept?.metrics,
+		...moved.metrics
+	};
+	if (Object.keys(metrics).length > 0) evidence.metrics = metrics;
+	if (moved.verdict !== void 0) evidence.verdict = moved.verdict;
+	else if (kept?.verdict !== void 0) evidence.verdict = kept.verdict;
+	if (moved.steps !== void 0) evidence.steps = moved.steps;
+	else if (kept?.steps !== void 0) evidence.steps = kept.steps;
+	const steps = moved.steps === void 0 ? line.steps : declaredSteps(line.steps);
+	return {
+		...line,
+		...steps === void 0 ? {} : { steps },
+		outcome: {
+			...line.outcome,
+			metrics: {},
+			verdict: null
+		},
+		provenance: {
+			...line.provenance,
+			gated_evidence: evidence
+		}
+	};
+}
+/**
+* EVERY gate check, for the export path — the runtime backstop.
+*
+* `validateRolloutLine` checks the reward relationship too, but an exporter
+* cannot afford to re-validate every field of every line, and more importantly
+* it is not the exporter's job to re-check the schema — it is its job never to
+* emit a signal it was told is fabricated. Thrown rather than filtered: an
+* exporter silently dropping a poisoned line would hide the producer that made
+* it, and the producer is the actual defect.
+*
+* This is the third layer, and it exists for exactly one caller: JavaScript.
+* The brand stops TypeScript callers at compile time and `assertMinted` fixes
+* data arriving from disk, but neither is present for a plain JS consumer of
+* the published package handing an object literal to `toRewardRows`. Which is
+* exactly why this entry point's policy omits nothing: a check it skips is a
+* check that never runs for those callers at all. It composed two of the three
+* for one round, and a never-screened positive reward walked through all four
+* waist exporters at full value. `GATE_POLICIES.assertRewardGate` is now the
+* only place that list is written down.
+*/
+function assertRewardGate(line, context) {
+	const errors = gateErrors(line, GATE_POLICIES.assertRewardGate);
+	if (errors.length > 0) throw new Error(`${context}: rollout ${line.rollout_id} — ${errors[0]}`);
+}
+function validateRolloutLine(value) {
+	const errors = [];
+	if (!isRecord(value)) return ["line: not an object"];
+	if (value.schema !== "tangle.rollout.v1") errors.push(`schema: expected "${ROLLOUT_SCHEMA}"`);
+	if (typeof value.rollout_id !== "string" || value.rollout_id.length === 0) errors.push("rollout_id: expected non-empty string");
+	if (!isStringOrNull(value.parent_rollout_id)) errors.push("parent_rollout_id: expected string|null");
+	if (typeof value.run_id !== "string" || value.run_id.length === 0) errors.push("run_id: expected non-empty string");
+	if (!isStringOrNull(value.experiment_id)) errors.push("experiment_id: expected string|null");
+	if (!isStringOrNull(value.candidate_id)) errors.push("candidate_id: expected string|null");
+	if (!isIntegerOrNull(value.generation)) errors.push("generation: expected integer|null");
+	if (!isIntegerOrNull(value.candidate_index)) errors.push("candidate_index: expected integer|null");
+	if (!ROLLOUT_ROLES.includes(value.role)) errors.push(`role: invalid role ${String(value.role)}`);
+	validateSection(value.task, "task", [
+		[
+			"suite",
+			(v) => typeof v === "string" && v.length > 0,
+			"non-empty string"
+		],
+		[
+			"instance_id",
+			(v) => typeof v === "string" && v.length > 0,
+			"non-empty string"
+		],
+		[
+			"split",
+			(v) => ROLLOUT_SPLITS.includes(v),
+			`one of ${ROLLOUT_SPLITS.join("|")}`
+		],
+		[
+			"seed",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"rep",
+			(v) => Number.isInteger(v),
+			"integer"
+		]
+	], errors);
+	validateSection(value.policy, "policy", [
+		[
+			"harness",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"harness_version",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"model",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"provider",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"profile_commit",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"sampling",
+			(v) => v === null || isRecord(v),
+			"object|null"
+		]
+	], errors);
+	if (isRecord(value.policy)) {
+		for (const key of [
+			"prompt_hash",
+			"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`);
+	}
+	if (!Array.isArray(value.messages)) errors.push("messages: expected array");
+	else for (const [i, m] of value.messages.entries()) validateChatMessage(m, `messages[${i}]`, errors);
+	if (!Array.isArray(value.tool_defs)) errors.push("tool_defs: expected array");
+	else value.tool_defs.forEach((d, i) => {
+		if (!isRecord(d) || d.type !== "function" || !isRecord(d.function) || typeof d.function.name !== "string") errors.push(`tool_defs[${i}]: must be {type:"function", function:{name}}`);
+	});
+	if (value.steps !== void 0) if (!Array.isArray(value.steps)) errors.push("steps: expected array when present");
+	else value.steps.forEach((s, i) => {
+		if (!isRecord(s) || typeof s.kind !== "string" || typeof s.name !== "string") {
+			errors.push(`steps[${i}]: must be {kind: string, name: string, …}`);
+			return;
+		}
+		if (s.llm_call_count !== void 0 && !Number.isInteger(s.llm_call_count)) errors.push(`steps[${i}].llm_call_count: expected integer when present`);
+		for (const key of ["prompt_token_ids", "completion_token_ids"]) if (s[key] !== void 0 && !isIntegerArray(s[key])) errors.push(`steps[${i}].${key}: expected integer[] when present`);
+		if (s.logprobs !== void 0 && !isNumberArray(s.logprobs)) errors.push(`steps[${i}].logprobs: expected number[] when present`);
+	});
+	validateSection(value.outcome, "outcome", [
+		[
+			"reward",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"reward_source",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"metrics",
+			isRecord,
+			"object"
+		],
+		[
+			"is_completed",
+			(v) => typeof v === "boolean",
+			"boolean"
+		],
+		[
+			"is_truncated",
+			(v) => typeof v === "boolean",
+			"boolean"
+		],
+		[
+			"error",
+			isStringOrNull,
+			"string|null"
+		]
+	], errors);
+	if (isRecord(value.outcome)) {
+		if (!("verdict" in value.outcome)) errors.push("outcome.verdict: field required (may be null)");
+		if (typeof value.outcome.realness_gated !== "boolean") errors.push("outcome.realness_gated: expected boolean");
+		if (value.outcome.realness_screened !== void 0 && typeof value.outcome.realness_screened !== "boolean") errors.push("outcome.realness_screened: expected boolean when present");
+		errors.push(...gateErrors({
+			outcome: value.outcome,
+			steps: value.steps
+		}, GATE_POLICIES.validateRolloutLine));
+	}
+	validateSection(value.cost, "cost", [
+		[
+			"usd",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"tokens_in",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"tokens_out",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"tokens_reasoning",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"cache_read",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"cache_write",
+			isNumberOrNull,
+			"number|null"
+		],
+		[
+			"wall_s",
+			isNumberOrNull,
+			"number|null"
+		]
+	], errors);
+	if (isRecord(value.cost) && value.cost.llm_call_count !== void 0 && !(value.cost.llm_call_count === null || Number.isInteger(value.cost.llm_call_count))) errors.push("cost.llm_call_count: expected integer|null when present");
+	validateSection(value.artifacts, "artifacts", [
+		[
+			"patch_path",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"run_dir",
+			isStringOrNull,
+			"string|null"
+		],
+		[
+			"transcript_ref",
+			isStringOrNull,
+			"string|null"
+		]
+	], errors);
+	validateSection(value.provenance, "provenance", [[
+		"captured_at",
+		(v) => typeof v === "string" && !Number.isNaN(Date.parse(v)),
+		"ISO-8601 timestamp"
+	], [
+		"capture",
+		(v) => ROLLOUT_CAPTURES.includes(v),
+		`one of ${ROLLOUT_CAPTURES.join("|")}`
+	]], errors);
+	if (isRecord(value.provenance)) {
+		if (value.provenance.gap !== void 0 && typeof value.provenance.gap !== "string") errors.push("provenance.gap: must be string when present");
+		const evidence = value.provenance.gated_evidence;
+		if (evidence !== void 0) {
+			if (!isRecord(evidence)) errors.push("provenance.gated_evidence: must be an object when present");
+			else if (evidence.metrics !== void 0 && !isRecord(evidence.metrics)) errors.push("provenance.gated_evidence.metrics: must be an object when present");
+		}
+	}
+	if (Array.isArray(value.messages) && isRecord(value.provenance)) {
+		if (value.messages.length === 0 && typeof value.provenance.gap !== "string") errors.push("provenance.gap: required when messages is empty");
+	}
+	return errors;
+}
+function assertRolloutLine(value, context = "rollout line") {
+	const errors = validateRolloutLine(value);
+	if (errors.length > 0) throw new Error(`invalid ${context}:\n  ${errors.join("\n  ")}`);
+}
+function isRolloutLine(value) {
+	return validateRolloutLine(value).length === 0;
+}
+/**
+* Promote a line to the type the training exporters accept, applying the
+* anti-Goodhart gate to the WHOLE outcome on the way through. THE escape hatch
+* — grep `assertMinted` to enumerate every place a line enters the training
+* path without coming from mint or a ledger.
+*
+* The gate runs HERE, once, rather than at each producer, because this is the
+* single funnel every minted line passes: `mintRolloutRows` calls it,
+* `readRolloutLedger` calls it per line off disk, `scrubLines` calls it on the
+* way out of a release, and a hand-built line has no other door. One
+* transformation at the funnel means an already-published ledger holding a
+* gated line with populated `metrics` is RE-GATED when it is read, instead of
+* being rejected (which would make every such artifact unreadable) or trusted
+* (which is the leak). Three steps, in this order:
+*
+*   1. VALIDATE the schema.
+*   2. REFUSE every check `GATE_POLICIES.assertMinted` marks `enforce` — today
+*      the reward relationship (which stays a REJECTION: a caller claiming
+*      `{reward: 0.95, realness_gated: true}` is a producer defect and must fail
+*      loudly, since laundering it into `reward: 0` here would hide the
+*      producer) and a positive reward the producer declared it never screened.
+*   3. TRANSFORM the one check that policy marks `repair` — relocate the
+*      reward's components off `outcome` (`gateGamedOutcome`), so no exporter
+*      can leak them whichever field it reads.
+*
+* Step 2 enumerates nothing by hand: a check added to `GATE_CHECKS` is enforced
+* here the moment its disposition in that policy says so.
+*
+* Also normalizes the optional wire flag to an explicit boolean.
+* `realness_gated` is absent on pre-unification ledgers and absent means "not
+* flagged" per the schema, so filling it in states a claim the line was already
+* making, and makes the flag readable on every published row instead of most of
+* them. `realness_screened` is NOT filled in: absent means "unknown", and
+* inventing either value there would be the same overclaim this round removed.
+*/
+function assertMinted(value, context = "rollout line") {
+	assertRolloutLine(value, context);
+	const refused = gateErrors(value, GATE_POLICIES.assertMinted);
+	if (refused.length > 0) throw new Error(`invalid ${context}: rollout ${value.rollout_id} — ${refused[0]}`);
+	const gated = gateGamedOutcome(value);
+	if (gated.outcome.realness_gated === void 0) return {
+		...gated,
+		outcome: {
+			...gated.outcome,
+			realness_gated: false
+		}
+	};
+	return gated;
+}
+/** `assertMinted` over a batch, naming the offending index in the error. */
+function assertMintedLines(values, context = "rollout line") {
+	return values.map((value, i) => assertMinted(value, `${context} [${i}]`));
+}
+//#endregion
+export { GATE_POLICIES as _, ROLLOUT_SPLITS as a, undeclaredStepPayload as b, assertMintedLines as c, gateGamedOutcome as d, isRolloutLine as f, GATE_CHECK_IDS as g, GATE_CHECKS as h, ROLLOUT_SCHEMA as i, assertRewardGate as l, validateRolloutLine as m, ROLLOUT_CAPTURES as n, TRAINABLE_SPLITS as o, isTrainableSplit as p, ROLLOUT_ROLES as r, assertMinted as s, CHAT_ROLES as t, assertRolloutLine as u, gateErrors as v, gatedEvidenceOf as y };
+
+//# sourceMappingURL=schema-C6DW4ZHR.js.map