@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/hf-dataset-DBJXXoY1.js

@@ -0,0 +1,763 @@
+import { _ as GATE_POLICIES, b as undeclaredStepPayload, g as GATE_CHECK_IDS, i as ROLLOUT_SCHEMA, p as isTrainableSplit, r as ROLLOUT_ROLES, s as assertMinted, u as assertRolloutLine } from "./schema-C6DW4ZHR.js";
+import { l as toVerifiersRolloutOutputs, o as toRftItems, r as toJsonl, s as toSftRows } from "./exporters-q9iL-2Jf.js";
+import { basename, dirname, join } from "node:path";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+//#region src/rollout/ledger.ts
+/**
+* Rollout-ledger file API — append-only JSONL of validated `tangle.rollout.v1`
+* lines. Writes validate BEFORE touching disk (a bad line never lands);
+* reads validate line-by-line and fail loud with the line number, because a
+* silently-skipped rollout is a corrupted dataset.
+*
+* "Validate" includes the anti-Goodhart invariant (a realness-gated line may
+* not carry a positive reward), so a poisoned line can neither enter a ledger
+* nor leave one.
+*
+* Two read modes, matching the two write-side row classes: `readRolloutLedger`
+* re-validates under the mint policy (training data), `readRolloutJournal`
+* under the write policy (supervision journals, whose unscreened positive
+* rewards are writable and must stay readable).
+*/
+function serialize(lines) {
+	for (const [i, line] of lines.entries()) assertRolloutLine(line, `rollout line [${i}]`);
+	return lines.map((line) => JSON.stringify(line)).join("\n") + (lines.length > 0 ? "\n" : "");
+}
+/** Replace the ledger file with exactly `lines`. */
+async function writeRolloutLedger(path, lines) {
+	const payload = serialize(lines);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, payload);
+}
+/** Append `lines` to the ledger file (created if absent). */
+async function appendRolloutLines(path, lines) {
+	if (lines.length === 0) return;
+	const payload = serialize(lines);
+	await mkdir(dirname(path), { recursive: true });
+	await appendFile(path, payload);
+}
+/**
+* Read and validate every line. Throws on the first malformed/invalid line
+* (with its 1-based line number) — fail-closed, never a silent drop.
+*
+* Validation includes the anti-Goodhart invariant, which is why the result is
+* `MintedRolloutLine[]`: a ledger file is the main way a rollout reaches this
+* process from outside the type system (another run, another machine, a
+* hand-edited JSONL), so this read is the runtime boundary where a poisoned
+* line is refused rather than exported.
+*/
+async function readRolloutLedger(path) {
+	return readLines(path, (parsed, context) => assertMinted(parsed, context));
+}
+/**
+* Read a ledger under the WRITE-side policy (`validateRolloutLine`), which
+* omits the unscreened-reward check. `writeRolloutLedger` accepts a
+* supervision-journal row (`realness_screened: false` with a positive reward
+* — the documented `unscreenedRewardFields` shape), and `GATE_POLICIES` says
+* such rows "must stay writable, readable and reportable"; a read API that
+* only re-validated under `assertMinted` made every such file unreadable —
+* write-accepted but read-refused is a data-loss trap.
+*
+* The result is `RolloutLine[]`, NOT `MintedRolloutLine[]`: nothing read here
+* can reach a training exporter without passing `assertMinted`, so the
+* promotion gate (which DOES enforce unscreened-reward) is exactly as closed
+* as before. Use `readRolloutLedger` when the file is training data.
+*/
+async function readRolloutJournal(path) {
+	return readLines(path, (parsed, context) => {
+		assertRolloutLine(parsed, context);
+		return parsed;
+	});
+}
+async function readLines(path, admit) {
+	const raw = await readFile(path, "utf8");
+	const lines = [];
+	const rawLines = raw.split("\n");
+	for (let i = 0; i < rawLines.length; i++) {
+		const text = rawLines[i];
+		if (!text?.trim()) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch (error) {
+			throw new Error(`${path}:${i + 1}: malformed JSON — ${error instanceof Error ? error.message : String(error)}`);
+		}
+		lines.push(admit(parsed, `${path}:${i + 1}`));
+	}
+	return lines;
+}
+//#endregion
+//#region src/rollout/release/gate-report.ts
+const FORMAT_GATE_DISPOSITION = {
+	sft: "exclude",
+	verifiers: "zero-and-flag",
+	rft: "zero-and-flag",
+	raw: "zero-and-flag"
+};
+/** Rollout ids of every gated line, the key the emitted rows are matched on. */
+function gatedRolloutIds(lines) {
+	return new Set(lines.filter((line) => line.outcome.realness_gated).map((line) => line.rollout_id));
+}
+/**
+* Row refs per format. Written as one adapter per format so that the knowledge
+* of WHERE the id and reward live in each published shape sits next to the
+* assertion that uses it — an exporter that moves either field breaks here
+* rather than silently reporting zero gated rows.
+*/
+const releaseRowRefs = {
+	sft: (rows) => rows.map((row) => ({
+		rollout_id: row.metadata.rollout_id,
+		reward: row.metadata.reward,
+		realness_screened: row.metadata.realness_screened
+	})),
+	verifiers: (rows) => rows.map((row) => ({
+		rollout_id: row.info.rollout_id,
+		reward: row.reward,
+		evidence: row.metrics,
+		realness_screened: row.info.realness_screened
+	})),
+	rft: (rows) => rows.map((row) => ({
+		rollout_id: row.reference.rollout_id,
+		reward: row.reference.reward,
+		evidence: row.reference.verdict,
+		realness_screened: row.reference.realness_screened
+	})),
+	raw: (lines) => lines.map((line) => ({
+		rollout_id: line.rollout_id,
+		reward: line.outcome.reward,
+		evidence: {
+			metrics: line.outcome.metrics,
+			verdict: line.outcome.verdict
+		},
+		stepEvidence: undeclaredStepPayload(line.steps),
+		realness_screened: line.outcome.realness_screened ?? null
+	}))
+};
+/** Every positive finite number inside a row's reward-derived payload, with its path. */
+function positiveNumbersIn(value, path) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? [{
+		path,
+		value
+	}] : [];
+	if (Array.isArray(value)) return value.flatMap((item, i) => positiveNumbersIn(item, `${path}[${i}]`));
+	if (typeof value === "object" && value !== null) return Object.entries(value).flatMap(([key, child]) => positiveNumbersIn(child, path === "" ? key : `${path}.${key}`));
+	return [];
+}
+/** Measure one format's gated rows from the refs of the rows about to be written. */
+function measureFormatGate(gated, refs) {
+	const emitted = refs.filter((ref) => gated.has(ref.rollout_id));
+	const rewards = emitted.map((ref) => ref.reward).filter((r) => r !== null);
+	const evidence = emitted.flatMap((ref) => positiveNumbersIn(ref.evidence, ""));
+	const stepEvidence = emitted.flatMap((ref) => positiveNumbersIn(ref.stepEvidence, "steps"));
+	const unscreened = refs.filter((ref) => ref.realness_screened === false).map((ref) => ref.reward).filter((r) => r !== null && r > 0);
+	return {
+		input: gated.size,
+		emitted: emitted.length,
+		excluded: gated.size - emitted.length,
+		maxEmittedReward: rewards.length === 0 ? null : Math.max(...rewards),
+		maxEmittedEvidence: evidence.reduce((best, found) => best === null || found.value > best.value ? found : best, null),
+		unscreenedPositiveRows: unscreened.length,
+		maxUnscreenedReward: unscreened.length === 0 ? null : Math.max(...unscreened),
+		maxEmittedStepEvidence: stepEvidence.reduce((best, found) => best === null || found.value > best.value ? found : best, null)
+	};
+}
+/**
+* The measured form of each canonical gate check, over the rows a release is
+* ABOUT TO WRITE. Returns the failure message, or `null` when the format is
+* clean on that check.
+*
+* TOTAL over `GateCheckId` — this map and `GATE_POLICIES.assertGateReport` are
+* the two things a new check breaks here, so the release certifier cannot be
+* left behind by a check added anywhere else in the package. That is the whole
+* point: for four rounds each guard composed its own subset by hand, and a
+* release certifying CLEAN while leaking is the most expensive version of that
+* mistake, because it is the leak plus a document saying there isn't one.
+*/
+const REPORT_MEASURES = {
+	"reward-relationship": (format, counts) => counts.maxEmittedReward === null || counts.maxEmittedReward <= 0 ? null : `release format "${format}": ${counts.emitted} realness-gated row(s) carry a positive reward (max ${counts.maxEmittedReward}). A run flagged as gamed may not ship a positive reward in any config.`,
+	"gated-evidence": (format, counts) => {
+		if (counts.maxEmittedEvidence === null) return null;
+		const { path, value } = counts.maxEmittedEvidence;
+		return `release format "${format}": ${counts.emitted} realness-gated row(s) carry a positive reward-derived number (${path} = ${value}). Zeroing the scalar is not enough — the per-layer scores and judge verdict a fabricated reward was computed FROM are the same signal in component form, and in this format they are read as training input. They belong in \`provenance.gated_evidence\` (see \`gateGamedOutcome\`), not on the row.`;
+	},
+	"undeclared-step-payload": (format, counts) => {
+		if (counts.maxEmittedStepEvidence === null) return null;
+		const { path, value } = counts.maxEmittedStepEvidence;
+		return `release format "${format}": ${counts.emitted} realness-gated row(s) carry a positive per-step number under a field \`tangle.rollout.v1\` does not declare (${path} = ${value}). A per-step reward is the same training signal as the scalar, in credit-assignment form, and the exporters copy \`steps\` through verbatim — so the row ships it beside a \`reward\` of 0. It belongs in \`provenance.gated_evidence.steps\` (see \`gateGamedOutcome\`).`;
+	},
+	"unscreened-reward": (format, counts) => counts.maxUnscreenedReward === null ? null : `release format "${format}": ${counts.unscreenedPositiveRows} row(s) carry a positive reward (max ${counts.maxUnscreenedReward}) whose producer declares that NO authenticity screen ran on it (\`realness_screened: false\`). Nothing has established those successes are real, and a published dataset may not present an unqualified verdict as a measured one. Screen the runs, or publish them at \`reward: null\`.`
+};
+/**
+* Fail the build when the measurement disagrees with the declared policy.
+*
+* Throws, never filters: an emitted positive reward on a gated row means an
+* exporter upstream stopped applying the gate, and silently dropping the row
+* would hide the producer that made it — the producer is the actual defect.
+*
+* Certifies the whole emitted outcome, not `reward` alone. The earlier version
+* checked one field and therefore certified a release CLEAN while its
+* `verifiers/train.jsonl` shipped the gamed run's per-layer scores at 1.0 in
+* the top-level `metrics` dict — the card then rendered "max reward | 0" over
+* exactly that file. A certification that is wrong is worse than an
+* uncertified leak, so the checks it runs are no longer written down here at
+* all: it iterates `GATE_CHECK_IDS` under its own declared policy.
+*/
+function assertGateReport(report) {
+	for (const [format, counts] of Object.entries(report.byFormat)) {
+		for (const id of GATE_CHECK_IDS) {
+			if (GATE_POLICIES.assertGateReport[id].kind !== "enforce") continue;
+			const failure = REPORT_MEASURES[id](format, counts);
+			if (failure !== null) throw new Error(failure);
+		}
+		if (FORMAT_GATE_DISPOSITION[format] === "exclude" && counts.emitted > 0) throw new Error(`release format "${format}" declares gated lines EXCLUDED but wrote ${counts.emitted} of them.`);
+	}
+}
+//#endregion
+//#region src/rollout/release/card.ts
+/**
+* HuggingFace dataset-card (README.md) generation for a rollout-ledger release.
+*
+* The card is a pure function of the SCRUBBED lines plus the release options —
+* no timestamps, no environment reads — so rebuilding from the same ledger
+* yields byte-identical output. It documents the schema, provenance (run ids,
+* generations, the official judge), per-role reward semantics including the
+* inherited/contribution caveat, and a role × reward counts table.
+*/
+const RELEASE_FORMATS = [
+	"sft",
+	"verifiers",
+	"rft",
+	"raw"
+];
+/** Format → data file path inside the dataset dir (train split only). */
+const FORMAT_FILES = {
+	sft: "sft/train.jsonl",
+	verifiers: "verifiers/train.jsonl",
+	rft: "rft/train.jsonl",
+	raw: "raw/train.jsonl"
+};
+const FORMAT_DESCRIPTIONS = {
+	sft: "Successful trainable-split transcripts (`reward >= 1`, never realness-gated) as `{messages, metadata}` chat JSONL.",
+	verifiers: "Prime Intellect verifiers `RolloutOutput`: prompt/completion split at the first assistant turn, plus reward, metrics, tool defs, and token usage.",
+	rft: "OpenAI RFT items: prompt turns plus `reference.*` verdict fields for a grader (completions are re-sampled during RFT).",
+	raw: `Full \`${ROLLOUT_SCHEMA}\` ledger lines (scrubbed), one per agent invocation.`
+};
+function unique(values) {
+	return [...new Set(values.filter((v) => v !== null))].sort();
+}
+function formatReward(reward) {
+	if (reward === null) return "null";
+	return Number.isInteger(reward) ? String(reward) : reward.toFixed(4);
+}
+function markdownTable(header, rows) {
+	return [
+		`| ${header.join(" | ")} |`,
+		`| ${header.map(() => "---").join(" | ")} |`,
+		...rows.map((row) => `| ${row.join(" | ")} |`)
+	].join("\n");
+}
+/** Where the anti-Goodhart flag lives on each format's emitted row. */
+const GATE_FLAG_FIELD = {
+	sft: "— (no gated row is written)",
+	verifiers: "`info.realness_gated`",
+	rft: "`reference.realness_gated`",
+	raw: "`outcome.realness_gated`"
+};
+const GATE_POLICY_LABEL = {
+	sft: "EXCLUDED — an SFT row is an imitation target",
+	verifiers: "INCLUDED, reward forced to 0, flagged",
+	rft: "INCLUDED, reward forced to 0, flagged",
+	raw: "INCLUDED verbatim, flagged"
+};
+function gateSection(formats, gate, totalLines) {
+	const rows = formats.map((format) => {
+		const counts = gate.byFormat[format];
+		return [
+			format,
+			GATE_POLICY_LABEL[format],
+			String(counts?.emitted ?? 0),
+			String(counts?.excluded ?? 0),
+			counts?.maxEmittedReward === null || counts === void 0 ? "—" : formatReward(counts.maxEmittedReward),
+			counts?.maxEmittedEvidence == null ? "—" : `${counts.maxEmittedEvidence.path} = ${counts.maxEmittedEvidence.value}`,
+			GATE_FLAG_FIELD[format]
+		];
+	});
+	const mixedExclusion = formats.some((format) => FORMAT_GATE_DISPOSITION[format] === "zero-and-flag");
+	return [
+		`\`outcome.realness_gated: true\` marks a run whose success signal was faked (it satisfied the proxy without doing the work). **${gate.gatedLines} of ${totalLines} lines in this release are gated.**`,
+		"",
+		"The gate is enforced, not asserted. A line pairing `realness_gated: true` with a reward above 0 is rejected by the schema validator, so it cannot be read out of a source ledger or written into `raw/train.jsonl` at all; on a gated line the numbers the reward was computed from (`outcome.metrics`, the verbatim judge `outcome.verdict`, and any per-step field the schema does not declare — a per-step reward is the same signal in credit-assignment form) are moved out of `outcome` and `steps[]` and into `provenance.gated_evidence`, where no config reads them as training input; the exporters re-check the same invariant on every line; and the release build measures the rows it is about to write and refuses to write ANY file if a gated row carries a positive reward — or any positive number derived from one — in ANY config.",
+		"",
+		"The table below is **measured on the rows in this release**, not a description of intent — the build counts the emitted rows and this card renders those counts:",
+		"",
+		markdownTable([
+			"config",
+			"policy",
+			"gated rows written",
+			"gated rows not written",
+			"max reward",
+			"max reward-derived number",
+			"flag"
+		], rows),
+		"",
+		"Why gated rows are kept where they are kept: an SFT row is imitated verbatim, so a gamed trajectory must never appear in one at any weight. In `verifiers` the reward is a signed learning signal, and a gamed trajectory at reward 0 is a correct negative — dropping it would bias the negative population toward honest failures and leave a trainer no example of gaming being penalized. `rft` re-samples the completion, so only the prompt and the grader reference ship. `raw` is a faithful audit dump, where the gated row is the one an auditor most wants.",
+		"",
+		"Reward 0 is never the only label: every included config carries the flag on the row itself, because zeroing alone makes a faked success indistinguishable from an honest failure. Filter on the flag to drop the gamed population, or select on it to mine it. The gated run's own measurements are not destroyed either — they are parked verbatim under `provenance.gated_evidence` in `raw/train.jsonl`, which is where an auditor can see what the run claimed and why it was flagged.",
+		mixedExclusion ? "\n\"Gated rows not written\" is not all gate: `verifiers` also drops gap lines (empty transcript) and `rft` drops lines with no prompt turn, so that column can mix both causes." : ""
+	].join("\n").trimEnd();
+}
+function roleRewardRows(lines) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const byReward = counts.get(line.role) ?? /* @__PURE__ */ new Map();
+		const key = formatReward(line.outcome.reward);
+		byReward.set(key, (byReward.get(key) ?? 0) + 1);
+		counts.set(line.role, byReward);
+	}
+	const rows = [];
+	for (const role of ROLLOUT_ROLES) {
+		const byReward = counts.get(role);
+		if (!byReward) continue;
+		const keys = [...byReward.keys()].sort((a, b) => {
+			if (a === "null") return 1;
+			if (b === "null") return -1;
+			return Number(b) - Number(a);
+		});
+		for (const key of keys) rows.push([
+			role,
+			key,
+			String(byReward.get(key))
+		]);
+	}
+	return rows;
+}
+function buildDatasetCard(inputs) {
+	const { lines, formats, includeProposers, sourceFiles, scrubTotals, excluded, formatCounts, gate } = inputs;
+	assertGateReport(gate);
+	const runIds = unique(lines.map((line) => line.run_id));
+	const generations = [...new Set(lines.map((line) => line.generation))].filter((g) => g !== null).sort((a, b) => a - b);
+	const models = unique(lines.map((line) => line.policy.model));
+	const harnesses = unique(lines.map((line) => line.policy.harness));
+	const captures = unique(lines.map((line) => line.provenance.capture));
+	const rewardSources = unique(lines.map((line) => line.outcome.reward_source));
+	const gapLines = lines.filter((line) => line.messages.length === 0).length;
+	const gatedLines = lines.filter((line) => line.outcome.realness_gated).length;
+	if (gatedLines !== gate.gatedLines) throw new Error(`dataset card: gate report claims ${gate.gatedLines} realness-gated line(s) but the lines it describes contain ${gatedLines} — the card and the build measured different data.`);
+	const frontmatter = [
+		"---",
+		"license: unknown",
+		"pretty_name: Tangle rollout ledger — agent trajectories",
+		"configs:",
+		formats.map((format) => [
+			`  - config_name: ${format}`,
+			"    data_files:",
+			"      - split: train",
+			`        path: ${FORMAT_FILES[format]}`
+		].join("\n")).join("\n"),
+		"---"
+	].join("\n");
+	const formatsTable = markdownTable([
+		"config",
+		"path",
+		"rows",
+		"contents"
+	], formats.map((format) => [
+		format,
+		`\`${FORMAT_FILES[format]}\``,
+		String(formatCounts[format] ?? 0),
+		FORMAT_DESCRIPTIONS[format]
+	]));
+	const countsTable = markdownTable([
+		"role",
+		"reward",
+		"lines"
+	], roleRewardRows(lines));
+	const scrubTable = markdownTable(["rule", "rewrites"], Object.entries(scrubTotals).map(([rule, count]) => [rule, String(count)]));
+	const proposerNote = includeProposers ? "Proposer sessions are INCLUDED (`--include-proposers`); their transcripts contain improvement-loop harness source." : `Proposer sessions are excluded by default (${excluded.proposers} lines dropped); they contain improvement-loop harness source. Rebuild with \`--include-proposers\` to keep them.`;
+	return `${frontmatter}
+
+# Tangle rollout ledger — agent trajectories
+
+One line per agent invocation (supervisor episode, worker session, proposer shot, judge call, analyst pass) captured by the \`${ROLLOUT_SCHEMA}\` rollout ledger, labeled with improvement-loop coordinates and the official-judge reward, with the full message transcript inline.
+
+This release contains the **trainable split only** (\`search\`). Holdout, dev, and canary splits are structurally excluded at build time, and the build additionally drops any non-trainable line as a fail-closed filter (${excluded.nonTrain} dropped here).
+
+## Formats
+
+${formatsTable}
+
+## Anti-Goodhart gate (\`realness_gated\`)
+
+${gateSection(formats, gate, lines.length)}
+
+## Schema (\`${ROLLOUT_SCHEMA}\`)
+
+Each raw line carries:
+
+- \`rollout_id\` / \`parent_rollout_id\` — invocation identity; workers point at their spawning supervisor episode.
+- \`run_id\`, \`experiment_id\`, \`candidate_id\` — run/experiment/candidate identity from the producing RunRecord, when present.
+- \`generation\`, \`candidate_index\` — improvement-loop coordinates (\`-1\` = baseline campaign; \`null\` = not an improvement loop).
+- \`role\` — one of ${ROLLOUT_ROLES.map((role) => `\`${role}\``).join(", ")}.
+- \`task\` — suite, instance id, split, seed, replicate index.
+- \`policy\` — harness, model, provider, profile commit, prompt/config hashes, sampling params.
+- \`messages\` / \`tool_defs\` — full transcript in canonical OpenAI chat-with-tools form (including \`reasoning_content\`). An empty \`messages\` array is a labeled gap line; \`provenance.gap\` says why the transcript could not be recovered (${gapLines} gap lines in this release).
+- \`outcome\` — \`reward\` (the single scalar), \`reward_source\`, the verbatim judge \`verdict\`, non-scalar \`metrics\`, and \`realness_gated\` (anti-Goodhart flag; see [Anti-Goodhart gate](#anti-goodhart-gate-realness_gated) for the per-config treatment and the measured counts).
+- \`cost\` — usd, token counts, wall time.
+- \`artifacts\` / \`provenance\` — patch/run-dir/transcript pointers (scrubbed) and capture metadata.
+
+## Provenance
+
+- Source ledgers: ${sourceFiles.map((file) => `\`${file}\``).join(", ")}
+- Run ids: ${runIds.map((id) => `\`${id}\``).join(", ")}
+- Generations: ${generations.join(", ")} (\`-1\` = baseline campaign)
+- Models: ${models.map((m) => `\`${m}\``).join(", ")}
+- Harnesses: ${harnesses.map((h) => `\`${h}\``).join(", ")}
+- Capture modes: ${captures.join(", ")}
+- Every reward traces to a named source (reward sources in this release: ${rewardSources.map((s) => `\`${s}\``).join(", ")}).
+
+${proposerNote}
+
+## Reward semantics per role
+
+- **agent** — the producing RunRecord's holdout/search score, with the realness gate forcing gamed successes to 0.
+- **supervisor** — the official-judge verdict on the episode's delivered artifact (1 = resolved, 0 = not).
+- **worker** — INHERITED from the parent supervisor episode (\`…/inherited\`). Caveat: reward 1 does not establish this worker's individual contribution (sibling workers in the same episode share the episode outcome), and reward 0 does not prove this worker failed.
+- **proposer** — the fraction of improvement-set instances the proposed candidate resolved (\`…/candidate-resolved-fraction\`); a scalar in [0, 1], not a binary verdict.
+- **judge / analyst** — carry the episode verdict where one applies; otherwise \`reward: null\` (a labeled gap, never 0).
+
+## Counts
+
+${countsTable}
+
+Total lines: ${lines.length}
+
+## Scrubbing
+
+Absolute home paths were rewritten to \`$WORK\`, credential-shaped strings were replaced with \`[REDACTED:<kind>]\` markers, internal hostnames were normalized to \`*.internal.example\`, and username-bearing incidentals (\`ls -l\` owner columns, per-user pytest tmpdirs) were normalized to \`user\` / \`$USER\`. Rewrite counts for this release (full per-file breakdown in \`scrub-report.json\`):
+
+${scrubTable}
+
+## License
+
+\`license: unknown\` is a placeholder — the releasing operator must set the real SPDX license id in the frontmatter above before publishing.
+
+## Citation
+
+\`\`\`bibtex
+@misc{tangle_rollout_ledger,
+  title = {Tangle rollout ledger — agent trajectories},
+  author = {{Tangle Network}},
+  howpublished = {HuggingFace Datasets},
+  note = {Operator: fill in the repository URL, authors, and year before publishing}
+}
+\`\`\`
+`;
+}
+//#endregion
+//#region src/rollout/release/scrub.ts
+/**
+* Deterministic scrubbing pass over rollout-ledger lines before public release.
+*
+* Every rule is a pure regex rewrite applied to every string value in a line
+* (messages, artifacts, run ids, tool arguments — everywhere), so the scrubbed
+* line is still a valid `tangle.rollout.v1` line. Rules are idempotent:
+* scrub(scrub(x)) === scrub(x), and a second pass counts zero hits — that is
+* the property the release pipeline relies on to prove nothing half-scrubbed
+* ships. Rule order matters: whole `KEY=value` env pairs are redacted before
+* the bare-key rule so one secret is never counted twice.
+*/
+const SCRUB_RULES = [
+	{
+		name: "home-path",
+		pattern: /\/(?:home|Users)\/[A-Za-z0-9._-]+/g,
+		rewrite: () => "$WORK"
+	},
+	{
+		name: "home-path-encoded",
+		pattern: /(?<=\/)-(?:home|Users)-[A-Za-z0-9_.]+/g,
+		rewrite: () => "$WORK"
+	},
+	{
+		name: "tmp-user-dir",
+		pattern: /\/tmp\/pytest-of-[A-Za-z0-9._-]+/g,
+		rewrite: () => "/tmp/pytest-of-$USER"
+	},
+	{
+		name: "ls-owner",
+		pattern: /([-bcdlps][-rwxsStT]{9}[.+@]?\s+\d+\s+)(?!user user(?=\s))[A-Za-z0-9._-]+\s+[A-Za-z0-9._-]+(?=\s)/g,
+		rewrite: (_match, prefix) => `${prefix}user user`
+	},
+	{
+		name: "env-secret",
+		pattern: /\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?))=(?!\[REDACTED:)("[^"]*"|'[^']*'|[^\s"']+)/g,
+		rewrite: (_match, name) => `${name}=[REDACTED:env]`
+	},
+	{
+		name: "bearer-token",
+		pattern: /\b(Bearer|Basic)\s+(?!\[REDACTED:)[A-Za-z0-9\-._~+/=]{8,}/g,
+		rewrite: (_match, scheme) => `${scheme} [REDACTED:bearer]`
+	},
+	{
+		name: "api-key",
+		pattern: /\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|hf_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\b/g,
+		rewrite: () => "[REDACTED:api-key]"
+	},
+	{
+		name: "infra-host",
+		pattern: /(?<![A-Za-z0-9.-])((?:[A-Za-z0-9-]+\.)*)tangle\.(?:tools|network)(?![A-Za-z0-9-])/g,
+		rewrite: (_match, prefix) => `${prefix ?? ""}internal.example`
+	},
+	{
+		name: "machine-host",
+		pattern: /\b[A-Za-z0-9]+-GTR-Pro\b/g,
+		rewrite: () => "workstation"
+	}
+];
+function emptyScrubCounts() {
+	return Object.fromEntries(SCRUB_RULES.map((rule) => [rule.name, 0]));
+}
+function addScrubCounts(into, from) {
+	for (const [name, count] of Object.entries(from)) into[name] = (into[name] ?? 0) + count;
+	return into;
+}
+function scrubText(text, counts) {
+	let out = text;
+	for (const rule of SCRUB_RULES) out = out.replace(rule.pattern, (match, ...rest) => {
+		counts[rule.name] = (counts[rule.name] ?? 0) + 1;
+		return rule.rewrite(match, typeof rest[0] === "string" ? rest[0] : void 0);
+	});
+	return out;
+}
+function scrubValue(value, counts) {
+	if (typeof value === "string") return scrubText(value, counts);
+	if (Array.isArray(value)) return value.map((item) => scrubValue(item, counts));
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = scrubValue(item, counts);
+		return out;
+	}
+	return value;
+}
+/**
+* Scrub every string value in a line; structure and key order are preserved.
+*
+* `assertMinted` on the way out rather than a cast: scrubbing rebuilds the
+* object, so the brand has to be re-earned, and re-validating proves the rules
+* did not rewrite a field the schema constrains (`reward` is a number, not a
+* string, so no rule should ever touch it — this is what checks that).
+*/
+function scrubRolloutLine(line, counts) {
+	return assertMinted(scrubValue(line, counts), `scrubbed rollout line ${line.rollout_id}`);
+}
+function scrubLines(lines) {
+	const counts = emptyScrubCounts();
+	return {
+		lines: lines.map((line) => scrubRolloutLine(line, counts)),
+		counts
+	};
+}
+/**
+* A `RolloutScrubber` (text → text) applying the full rule set — the
+* default hook to pass to `mintRolloutRows({ scrub })` so lines are
+* scrubbed at mint time, before they ever reach a ledger file. Release
+* builds re-run `scrubLines` regardless (idempotent), so double-scrubbing
+* is safe and counted as zero.
+*/
+function defaultRolloutScrubber(text) {
+	return scrubText(text, emptyScrubCounts());
+}
+//#endregion
+//#region src/rollout/release/hf-dataset.ts
+/**
+* One-command HuggingFace dataset release from rollout ledgers:
+*
+*   agent-eval rollout-release <ledger.jsonl...> --out <dir> \
+*     [--formats sft,verifiers,rft,raw] [--include-proposers] [--push <org/name>]
+*
+* Pipeline per input ledger: read + validate → fail-closed filters
+* (trainable split only; proposer sessions dropped unless
+* --include-proposers, they contain improvement-loop harness source) →
+* deterministic scrub → export the requested formats + scrub-report.json +
+* auto-generated README.md card. Deterministic: same inputs and flags →
+* byte-identical output dir.
+*
+* --push uploads the built dir with `huggingface-cli upload` only when the
+* CLI exists on PATH and HF_TOKEN is present in the env; the token is
+* never printed. Everything else runs fully offline.
+*/
+async function buildHfDataset(inputs, options) {
+	if (inputs.length === 0) throw new Error("no input ledgers given");
+	if (options.formats.length === 0) throw new Error("no formats selected");
+	const report = {
+		files: {},
+		totals: emptyScrubCounts(),
+		excluded: {
+			proposers: 0,
+			nonTrain: 0
+		}
+	};
+	const kept = [];
+	let read = 0;
+	for (const input of inputs) {
+		const lines = await readRolloutLedger(input);
+		read += lines.length;
+		const scrubbed = scrubLines(lines.filter((line) => {
+			if (!isTrainableSplit(line.task.split)) {
+				report.excluded.nonTrain += 1;
+				return false;
+			}
+			if (!options.includeProposers && line.role === "proposer") {
+				report.excluded.proposers += 1;
+				return false;
+			}
+			return true;
+		}));
+		report.files[input] = scrubbed.counts;
+		addScrubCounts(report.totals, scrubbed.counts);
+		kept.push(...scrubbed.lines);
+	}
+	const formatCounts = {};
+	const files = [];
+	const gated = gatedRolloutIds(kept);
+	const gate = {
+		gatedLines: gated.size,
+		byFormat: {}
+	};
+	const pending = [];
+	for (const format of options.formats) {
+		const path = join(options.out, FORMAT_FILES[format]);
+		if (format === "raw") {
+			gate.byFormat.raw = measureFormatGate(gated, releaseRowRefs.raw(kept));
+			formatCounts.raw = kept.length;
+			pending.push({
+				path,
+				write: () => writeRolloutLedger(path, kept)
+			});
+		} else if (format === "sft") {
+			const rows = toSftRows(kept);
+			gate.byFormat.sft = measureFormatGate(gated, releaseRowRefs.sft(rows));
+			formatCounts.sft = rows.length;
+			pending.push({
+				path,
+				write: () => writeFile(path, toJsonl(rows))
+			});
+		} else if (format === "verifiers") {
+			const outputs = toVerifiersRolloutOutputs(kept, { gatedLines: FORMAT_GATE_DISPOSITION.verifiers });
+			gate.byFormat.verifiers = measureFormatGate(gated, releaseRowRefs.verifiers(outputs));
+			formatCounts.verifiers = outputs.length;
+			pending.push({
+				path,
+				write: () => writeFile(path, toJsonl(outputs))
+			});
+		} else {
+			const items = toRftItems(kept, { gatedLines: FORMAT_GATE_DISPOSITION.rft });
+			gate.byFormat.rft = measureFormatGate(gated, releaseRowRefs.rft(items));
+			formatCounts.rft = items.length;
+			pending.push({
+				path,
+				write: () => writeFile(path, toJsonl(items))
+			});
+		}
+	}
+	assertGateReport(gate);
+	for (const { path, write } of pending) {
+		await mkdir(dirname(path), { recursive: true });
+		await write();
+		files.push(path);
+	}
+	const reportPath = join(options.out, "scrub-report.json");
+	await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+	files.push(reportPath);
+	const cardPath = join(options.out, "README.md");
+	await writeFile(cardPath, buildDatasetCard({
+		lines: kept,
+		formats: options.formats,
+		includeProposers: options.includeProposers,
+		sourceFiles: inputs.map((input) => basename(input)),
+		scrubTotals: report.totals,
+		excluded: report.excluded,
+		formatCounts,
+		gate
+	}));
+	files.push(cardPath);
+	return {
+		inputs,
+		read,
+		kept: kept.length,
+		scrub: report,
+		formatCounts,
+		gate,
+		files
+	};
+}
+function planPushCommand(repo, outDir) {
+	return [
+		"huggingface-cli",
+		"upload",
+		repo,
+		outDir,
+		".",
+		"--repo-type",
+		"dataset"
+	];
+}
+function pushDataset(repo, outDir) {
+	if (spawnSync("which", ["huggingface-cli"], { stdio: "ignore" }).status !== 0) throw new Error("huggingface-cli not found on PATH — install huggingface_hub[cli] before --push");
+	if (!process.env.HF_TOKEN) throw new Error("HF_TOKEN not present in env — refusing to push");
+	const [command, ...args] = planPushCommand(repo, outDir);
+	const run = spawnSync(command, args, { stdio: "inherit" });
+	if (run.status !== 0) throw new Error(`huggingface-cli upload exited ${String(run.status)}`);
+}
+const ROLLOUT_RELEASE_USAGE = "usage: agent-eval rollout-release <ledger.jsonl...> --out <dir> [--formats sft,verifiers,rft,raw] [--include-proposers] [--push <org/name>]";
+function parseRolloutReleaseArgs(argv) {
+	const args = {
+		inputs: [],
+		out: "",
+		formats: [...RELEASE_FORMATS],
+		includeProposers: false,
+		push: null
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--out") args.out = argv[++i] ?? "";
+		else if (arg === "--formats") {
+			const raw = (argv[++i] ?? "").split(",").filter(Boolean);
+			for (const format of raw) if (!RELEASE_FORMATS.includes(format)) throw new Error(`unknown format "${format}" — expected one of ${RELEASE_FORMATS.join(",")}`);
+			args.formats = raw;
+		} else if (arg === "--include-proposers") args.includeProposers = true;
+		else if (arg === "--push") args.push = argv[++i] ?? null;
+		else if (arg.startsWith("--")) throw new Error(`unknown flag "${arg}"`);
+		else args.inputs.push(arg);
+	}
+	if (args.inputs.length === 0 || !args.out) throw new Error(ROLLOUT_RELEASE_USAGE);
+	if (args.push !== null && !/^[\w.-]+\/[\w.-]+$/.test(args.push)) throw new Error(`--push expects <org/name>, got "${args.push}"`);
+	return args;
+}
+/** CLI driver for `agent-eval rollout-release`. Returns the process exit code. */
+async function runRolloutReleaseCli(argv) {
+	let args;
+	try {
+		args = parseRolloutReleaseArgs(argv);
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	const summary = await buildHfDataset(args.inputs, args);
+	process.stdout.write(`${JSON.stringify({
+		read: summary.read,
+		kept: summary.kept,
+		formatCounts: summary.formatCounts,
+		gate: summary.gate,
+		scrub: summary.scrub
+	}, null, 2)}\n`);
+	process.stdout.write(`dataset → ${args.out} (${summary.files.length} files)\n`);
+	if (args.push !== null) {
+		pushDataset(args.push, args.out);
+		process.stdout.write(`pushed → ${args.push}\n`);
+	}
+	return 0;
+}
+//#endregion
+export { readRolloutJournal as C, appendRolloutLines as S, writeRolloutLedger as T, FORMAT_GATE_DISPOSITION as _, pushDataset as a, measureFormatGate as b, addScrubCounts as c, scrubLines as d, scrubRolloutLine as f, buildDatasetCard as g, RELEASE_FORMATS as h, planPushCommand as i, defaultRolloutScrubber as l, FORMAT_FILES as m, buildHfDataset as n, runRolloutReleaseCli as o, scrubText as p, parseRolloutReleaseArgs as r, SCRUB_RULES as s, ROLLOUT_RELEASE_USAGE as t, emptyScrubCounts as u, assertGateReport as v, readRolloutLedger as w, releaseRowRefs as x, gatedRolloutIds as y };
+
+//# sourceMappingURL=hf-dataset-DBJXXoY1.js.map