reeval 0.0.1

package/dist/model-CDL98xue.js

@@ -0,0 +1,725 @@
+import { c as shardPath, i as manifestPath, s as shardOf } from "./paths-CBvm6pap.js";
+import { a as quantile, i as minimumP, n as mannWhitney, r as median } from "./stats-BNAHlNMD.js";
+import { s as readableTranscriptLine } from "./record-DQ8wzyco.js";
+import { n as promptTokens } from "./usage-DsYUqIUM.js";
+//#region src/view/compare.ts
+const STACK_FIELDS = [
+	{
+		field: "imageIds",
+		label: "image ids",
+		outside: false
+	},
+	{
+		field: "agentClis",
+		label: "agent CLI",
+		outside: false
+	},
+	{
+		field: "harnesses",
+		label: "harnesses",
+		outside: false
+	},
+	{
+		field: "environments",
+		label: "environments",
+		outside: false
+	},
+	{
+		field: "judgeModel",
+		label: "judge model",
+		outside: false
+	},
+	{
+		field: "threshold",
+		label: "judge threshold",
+		outside: false
+	},
+	{
+		field: "judgeServed",
+		label: "judge model served",
+		outside: true
+	},
+	{
+		field: "judgeVersion",
+		label: "judge version",
+		outside: false
+	},
+	{
+		field: "fingerprintScope",
+		label: "fingerprint scope",
+		outside: true
+	}
+];
+const show = (value) => Array.isArray(value) ? value.join(", ") || "none" : value === null ? "none" : String(value).replace(/^sha256:/, "").slice(0, 24);
+/** The stack fields that differ by which cells ran, read off each cell. */
+const PER_CELL = {
+	imageIds: (c) => c.fingerprintParts.image,
+	agentClis: (c) => c.fingerprintParts.agentCli,
+	harnesses: (c) => c.harness,
+	environments: (c) => `${c.environment}@${(c.environmentDigest ?? "").replace(/^sha256:/, "").slice(0, 12)}`
+};
+/** The cells both runs have (same eval, same cell key), as `[base, head]` pairs. */
+function sharedCells(base, head) {
+	if (![base, head].every((r) => r.evals?.every((e) => Array.isArray(e.cells)))) return null;
+	if (!base.evals || !head.evals) return null;
+	const before = new Map(base.evals.map((e) => [e.id, new Map(e.cells.map((c) => [c.key, c]))]));
+	return head.evals.flatMap((e) => e.cells.flatMap((c) => {
+		const b = before.get(e.id)?.get(c.key);
+		return b ? [[b, c]] : [];
+	}));
+}
+/**
+* What changed in the stack between two runs. With both runs' cells, images, agent CLIs,
+* harnesses and environments compare over the cells both have, so a run over fewer cells isn't
+* drift. Reported served-judge lists only compare when both have one.
+*/
+function stackChanges(base, head) {
+	const shared = sharedCells(base, head);
+	const changes = [];
+	for (const { field, label, outside } of STACK_FIELDS) {
+		const pick = PER_CELL[field];
+		const differ = pick && shared ? shared.filter(([x, y]) => pick(x) !== pick(y)) : [];
+		const over = (side) => [...new Set(differ.flatMap((pair) => pick?.(pair[side]) ?? []))].sort();
+		const b = pick && shared ? over(0) : base.stack[field];
+		const h = pick && shared ? over(1) : head.stack[field];
+		if (field === "judgeServed" && (!b.length || !h.length)) continue;
+		if (JSON.stringify(b) === JSON.stringify(h)) continue;
+		changes.push({
+			field,
+			label,
+			base: show(b),
+			head: show(h),
+			outsideFingerprint: outside
+		});
+	}
+	return changes;
+}
+/**
+* Whether any of these cells changed fingerprint since `seen` last had it, then records them.
+* A cell `seen` doesn't have yet is new coverage, not a change.
+*/
+function cellsChanged(seen, evalId, cells) {
+	let changed = false;
+	for (const c of cells) {
+		const key = `${evalId}\0${c.key}`;
+		const was = seen.get(key);
+		if (was !== void 0 && was !== c.fingerprint) changed = true;
+		seen.set(key, c.fingerprint);
+	}
+	return changed;
+}
+/** Which source files were added, removed or changed. */
+function sourceChanges(before, after) {
+	const a = new Map(before.map((s) => [s.path, s.sha256]));
+	const b = new Map(after.map((s) => [s.path, s.sha256]));
+	return [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])].sort().flatMap((path) => {
+		if (!a.has(path)) return [`${path} added`];
+		if (!b.has(path)) return [`${path} removed`];
+		return a.get(path) === b.get(path) ? [] : [`${path} changed`];
+	});
+}
+const PART_LABELS = {
+	harness: "harness config",
+	environment: "environment",
+	image: "image",
+	agentCli: "agent CLI",
+	judge: "judge",
+	context: "agent context"
+};
+/** Why two runs of an eval aren't comparable: the source files and fingerprint parts that differ. */
+function whyChanged(base, head) {
+	const out = sourceChanges(base.sources, head.sources);
+	const keys = [...new Set([...base.cells, ...head.cells].map((c) => c.key))];
+	const parts = /* @__PURE__ */ new Set();
+	for (const key of keys) {
+		const b = base.cells.find((c) => c.key === key);
+		const h = head.cells.find((c) => c.key === key);
+		if (!b || !h) {
+			out.push(`cell ${key} ${b ? "removed" : "added"}`);
+			continue;
+		}
+		for (const part of Object.keys(PART_LABELS)) if (b.fingerprintParts[part] !== h.fingerprintParts[part]) parts.add(PART_LABELS[part]);
+	}
+	return [...out, ...[...parts].map((p) => `${p} changed`)];
+}
+/** An eval's outcome from some of its cells, as the run rolls it up: ungated failures pass. */
+function outcomeOf(cells) {
+	const outcomes = cells.map((c) => c.gate === "none" && c.outcome === "fail" ? "pass" : c.outcome);
+	if (outcomes.includes("fail")) return "fail";
+	if (outcomes.includes("infra_error")) return "infra_error";
+	return outcomes.every((o) => o === "skipped") ? "skipped" : "pass";
+}
+/**
+* When two runs of an eval differ only in which cells ran (a filtered run, a harness added), its
+* outcome on the cells both have, and the cells only one has. Null when no cell is shared or a
+* shared cell changed.
+*/
+function sharedScope(b, h) {
+	const before = new Map(b.cells.map((c) => [c.key, c]));
+	const shared = h.cells.filter((c) => before.has(c.key));
+	if (!shared.length || shared.some((c) => before.get(c.key)?.fingerprint !== c.fingerprint)) return null;
+	const keys = new Set(h.cells.map((c) => c.key));
+	return {
+		base: outcomeOf(shared.map((c) => before.get(c.key) ?? c)),
+		head: outcomeOf(shared),
+		cells: {
+			added: h.cells.filter((c) => !before.has(c.key)).map((c) => c.key),
+			removed: b.cells.filter((c) => !keys.has(c.key)).map((c) => c.key)
+		}
+	};
+}
+/** Cells in both runs that have something to compare: a lift or effort on either side. */
+function compareCells(base, head) {
+	const pick = (c) => ({
+		...c.lift ? { lift: c.lift } : {},
+		effort: c.effort ?? null,
+		pass: c.pass,
+		fail: c.fail
+	});
+	return (head.cells ?? []).flatMap((h) => {
+		const b = base.cells?.find((c) => c.key === h.key);
+		if (!b || !(b.lift || h.lift || b.effort && h.effort)) return [];
+		return [{
+			key: h.key,
+			base: pick(b),
+			head: pick(h)
+		}];
+	});
+}
+function compare(base, head) {
+	const graderChanged = stackChanges(base, head).some((c) => c.outsideFingerprint);
+	return [.../* @__PURE__ */ new Set([...head.evals.map((e) => e.id), ...base.evals.map((e) => e.id)])].map((id) => {
+		const b = base.evals.find((e) => e.id === id);
+		const h = head.evals.find((e) => e.id === id);
+		if (!b) return {
+			id,
+			base: null,
+			head: h?.outcome ?? null,
+			status: "added"
+		};
+		if (!h) return {
+			id,
+			base: b.outcome,
+			head: null,
+			status: "removed"
+		};
+		const scoped = b.fingerprint === h.fingerprint ? null : sharedScope(b, h);
+		const row = scoped ? {
+			id,
+			...scoped
+		} : {
+			id,
+			base: b.outcome,
+			head: h.outcome
+		};
+		const perCell = compareCells(b, h);
+		if (perCell.length) row.perCell = perCell;
+		if (row.base === "infra_error" || row.head === "infra_error") return {
+			...row,
+			status: "infra"
+		};
+		if (b.fingerprint !== h.fingerprint && !scoped) return {
+			...row,
+			status: "drift",
+			changes: whyChanged(b, h)
+		};
+		if (graderChanged && row.base !== row.head) return {
+			...row,
+			status: "drift"
+		};
+		if (row.base === "pass" && row.head === "fail") return {
+			...row,
+			status: "regressed"
+		};
+		if (row.base === "fail" && row.head === "pass") return {
+			...row,
+			status: "fixed"
+		};
+		return {
+			...row,
+			status: "same"
+		};
+	});
+}
+//#endregion
+//#region src/view/effort.ts
+/** Below this two-sided p, an effort difference is an effect. */
+const EFFORT_ALPHA = .05;
+const effortSample = (a) => ({
+	tools: a.activity.tools,
+	agentMs: a.timings.agentMs,
+	fileEdits: a.activity.fileEdits
+});
+const counted = (a) => a.outcome === "pass" || a.outcome === "fail";
+const spread = (values) => ({
+	median: median(values) ?? 0,
+	q1: quantile(values, .25) ?? 0,
+	q3: quantile(values, .75) ?? 0
+});
+function effortOf(samples) {
+	if (samples.length === 0) return null;
+	return {
+		n: samples.length,
+		tools: spread(samples.map((s) => s.tools)),
+		agentMs: spread(samples.map((s) => s.agentMs)),
+		fileEdits: median(samples.map((s) => s.fileEdits)) ?? 0
+	};
+}
+/** The verdict of an exact rank test of `xs` (variant) against `ys` (control). */
+function effortVerdict(xs, ys) {
+	const p = mannWhitney(xs, ys);
+	if (minimumP(xs.length, ys.length) >= .05) return {
+		p,
+		verdict: "insufficient"
+	};
+	if (p === null || p >= .05) return {
+		p,
+		verdict: "noise"
+	};
+	return {
+		p,
+		verdict: (median(xs) ?? 0) < (median(ys) ?? 0) ? "fewer" : "more"
+	};
+}
+const ratio = (a, b) => b === 0 ? null : a / b;
+function contrastEffort(variant, control) {
+	const v = effortOf(variant);
+	const c = effortOf(control);
+	if (!v || !c) return null;
+	const tools = effortVerdict(variant.map((s) => s.tools), control.map((s) => s.tools));
+	const time = effortVerdict(variant.map((s) => s.agentMs), control.map((s) => s.agentMs));
+	const vt = variant.map((s) => s.tools);
+	const ct = control.map((s) => s.tools);
+	return {
+		variant: v,
+		control: c,
+		toolsRatio: ratio(v.tools.median, c.tools.median),
+		agentMsRatio: ratio(v.agentMs.median, c.agentMs.median),
+		agentMsDelta: v.agentMs.median - c.agentMs.median,
+		toolsP: tools.p,
+		agentMsP: time.p,
+		separated: Math.max(...vt) < Math.min(...ct) || Math.min(...vt) > Math.max(...ct),
+		verdict: tools.verdict,
+		timeVerdict: time.verdict
+	};
+}
+/** The counted attempts of one cell of an eval, as effort samples. */
+const cellSamples = (e, cellKey) => e.attempts.filter((a) => a.cell === cellKey && counted(a)).map(effortSample);
+const cellEffort = (e, cellKey) => effortOf(cellSamples(e, cellKey));
+/** A variant cell's effort against its control's, in the same run; null for controls. */
+function cellContrast(e, cellKey) {
+	const cell = e.cells.find((c) => c.key === cellKey);
+	if (!cell?.lift) return null;
+	return contrastEffort(cellSamples(e, cellKey), cellSamples(e, cell.lift.vs));
+}
+/** `4`, `4.5`: medians of counts are whole or halves. */
+const formatCount = (n) => Number.isInteger(n) ? String(n) : n.toFixed(1);
+const formatRatio = (r) => r === null ? "×–" : `×${r.toFixed(2)}`;
+/** Seconds for agent time: `21s`, `1m 05s`. */
+function formatSeconds(ms) {
+	if (ms < 9950) return ms < 50 ? "0s" : `${(ms / 1e3).toFixed(1)}s`;
+	const s = Math.round(ms / 1e3);
+	return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s`;
+}
+const formatP = (p) => p === null ? "" : ` (p = ${p < .001 ? "<0.001" : p.toFixed(3)})`;
+const VERDICT_TEXT = {
+	fewer: (what) => `fewer ${what}`,
+	more: (what) => `more ${what}`,
+	noise: () => "within noise",
+	insufficient: () => "too few attempts to test"
+};
+/**
+* `tools 5 vs 43 (×0.11), agent 21s vs 46s (×0.47): too few attempts to test` for a variant
+* against its control; with enough attempts, `fewer tool calls (p = 0.029)`.
+*/
+function effortLabel(c) {
+	return `${`tools ${formatCount(c.variant.tools.median)} vs ${formatCount(c.control.tools.median)} (${formatRatio(c.toolsRatio)})`}, ${`agent ${formatSeconds(c.variant.agentMs.median)} vs ${formatSeconds(c.control.agentMs.median)} (${formatRatio(c.agentMsRatio)})`}: ${c.verdict === "fewer" || c.verdict === "more" ? `${VERDICT_TEXT[c.verdict]("tool calls")}${formatP(c.toolsP)}` : VERDICT_TEXT[c.verdict]("")}`;
+}
+/** One cell's effort on its own: `tools 43 · agent 46s`. */
+const effortSummary = (e) => `tools ${formatCount(e.tools.median)} · agent ${formatSeconds(e.agentMs.median)}`;
+/** The same cell between two runs: `tools 44 → 10 (×0.23) · agent 45s → 21s (×0.47)`. */
+function effortChangeLabel(base, head) {
+	const t = ratio(head.tools.median, base.tools.median);
+	const a = ratio(head.agentMs.median, base.agentMs.median);
+	return `tools ${formatCount(base.tools.median)} → ${formatCount(head.tools.median)} (${formatRatio(t)}) · agent ${formatSeconds(base.agentMs.median)} → ${formatSeconds(head.agentMs.median)} (${formatRatio(a)})`;
+}
+//#endregion
+//#region src/view/model.ts
+/** Splits `file › group › … › name` back into its parts. */
+function splitEvalId(id) {
+	const [file = id, ...path] = id.split(" › ");
+	return {
+		file,
+		path: path.length ? path : [file]
+	};
+}
+/** Month shards (newest run first) and the manifest over them, from every run's header. */
+function buildIndex(entries, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+	const sorted = [...entries].sort((a, b) => a.runId < b.runId ? 1 : -1);
+	const shards = /* @__PURE__ */ new Map();
+	for (const entry of sorted) {
+		const id = shardOf(entry.startedAt);
+		const list = shards.get(id) ?? [];
+		list.push(entry);
+		shards.set(id, list);
+	}
+	const evals = /* @__PURE__ */ new Map();
+	for (const run of sorted) for (const e of run.evals) {
+		const known = evals.get(e.slug);
+		if (known) {
+			known.runs++;
+			continue;
+		}
+		evals.set(e.slug, {
+			slug: e.slug,
+			id: e.id,
+			...splitEvalId(e.id),
+			runs: 1,
+			latest: {
+				runId: run.runId,
+				outcome: e.outcome
+			}
+		});
+	}
+	return {
+		manifest: {
+			generatedAt,
+			shards: [...shards].map(([id, runs]) => ({
+				id,
+				runs: runs.length
+			})),
+			latest: sorted[0]?.runId ?? null,
+			evals: [...evals.values()].sort((a, b) => a.id < b.id ? -1 : 1)
+		},
+		shards
+	};
+}
+/** Every file the index consists of, by relative path. */
+function indexFiles(entries, generatedAt) {
+	const { manifest, shards } = buildIndex(entries, generatedAt);
+	const files = /* @__PURE__ */ new Map([[manifestPath, manifest]]);
+	for (const [id, list] of shards) files.set(shardPath(id), list);
+	return files;
+}
+function formatDuration(ms) {
+	if (ms === null || ms === void 0) return "–";
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(ms < 1e4 ? 1 : 0)}s`;
+	const m = Math.floor(ms / 6e4);
+	const s = Math.round(ms % 6e4 / 1e3);
+	if (m < 60) return s ? `${m}m ${s}s` : `${m}m`;
+	return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+const formatPercent = (rate) => rate === null ? "–" : `${Math.round(rate * 100)}%`;
+/**
+* A harness of the run's stack as `cursor (model composer-2.5, served composer-2.5[fast=true])`:
+* the configured model, then the variant the harness says it resolved.
+*/
+function harnessLabel(h) {
+	const parts = [...h.model ? [`model ${h.model}`] : [], ...h.resolvedModels.length ? [`served ${h.resolvedModels.join(", ")}`] : []];
+	return parts.length ? `${h.id} (${parts.join(", ")})` : h.id;
+}
+/** Harness-reported tokens as `127k in (98k cached) · 776 out`; null when none were reported. */
+function formatUsage(usage) {
+	if (!usage) return null;
+	const k = (n) => n >= 1e4 ? `${Math.round(n / 1e3)}k` : String(n);
+	const cached = usage.cacheRead ? ` (${k(usage.cacheRead)} cached)` : "";
+	return `${k(promptTokens(usage))} in${cached} · ${k(usage.output)} out`;
+}
+const shortSha = (sha) => sha ? sha.slice(0, 7) : "no git";
+/**
+* An attempt's effort, counted as the CLI's turn lines count it: tool calls, then file edits.
+* Edit calls become one file edit per file they change, so they're counted apart, never summed.
+*/
+function activityLabel(a) {
+	const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+	return `${plural(a.tools, "tool call")} · ${plural(a.fileEdits, "file edit")}`;
+}
+/**
+* A run's outcome, as `reeval run`'s exit code has it: a failed gated cell (or a budget stop) fails
+* the run, while failures in ungated cells (controls, by default) don't.
+*/
+function runOutcome(run) {
+	if (run.status === "interrupted") return "skipped";
+	const outcomes = run.evals.map((e) => e.outcome);
+	if (outcomes.includes("fail") || run.status === "budget") return "fail";
+	if (outcomes.includes("infra_error")) return "infra_error";
+	return "pass";
+}
+/**
+* Newest first. Drift is measured per cell, against the last run that had it: a run over fewer
+* cells (a filtered run) is no drift, and neither is the full run after it. The judge's settings
+* compare with the next older complete run.
+*/
+function runRows(entries) {
+	const oldest = [...entries].sort((a, b) => a.runId < b.runId ? -1 : 1);
+	const seen = /* @__PURE__ */ new Map();
+	const lastCells = /* @__PURE__ */ new Map();
+	let previous = null;
+	const rows = [];
+	for (const entry of oldest) {
+		const { pass, fail, infraError } = entry.summary;
+		const base = previous && {
+			stack: previous.stack,
+			evals: [...lastCells].map(([id, cells]) => ({
+				id,
+				cells: [...cells.values()]
+			}))
+		};
+		let changedEvals = 0;
+		for (const e of entry.evals) {
+			if (cellsChanged(seen, e.id, e.cells)) changedEvals++;
+			const cells = lastCells.get(e.id) ?? /* @__PURE__ */ new Map();
+			for (const c of e.cells) cells.set(c.key, c);
+			lastCells.set(e.id, cells);
+		}
+		rows.push({
+			entry,
+			passed: pass,
+			total: pass + fail + infraError,
+			drift: base ? stackChanges(base, entry) : [],
+			changedEvals
+		});
+		if (entry.status === "complete") previous = entry;
+	}
+	return rows.reverse();
+}
+const tallyOf = (e) => ({
+	pass: e.attempts.filter((a) => a.outcome === "pass").length,
+	fail: e.attempts.filter((a) => a.outcome === "fail" && !isUngatedMiss(e, a)).length,
+	missed: e.attempts.filter((a) => isUngatedMiss(e, a)).length,
+	infra: e.attempts.filter((a) => a.outcome === "infra_error").length,
+	skipped: e.attempts.filter((a) => a.outcome === "skipped").length
+});
+const addTally = (a, b) => ({
+	pass: a.pass + b.pass,
+	fail: a.fail + b.fail,
+	missed: a.missed + b.missed,
+	infra: a.infra + b.infra,
+	skipped: a.skipped + b.skipped
+});
+const ZERO = {
+	pass: 0,
+	fail: 0,
+	missed: 0,
+	infra: 0,
+	skipped: 0
+};
+/** Files, then groups, then evals, each with attempt counts; failing branches sort first. */
+function evalTree(record) {
+	const root = {
+		kind: "group",
+		key: "",
+		name: "",
+		tally: ZERO,
+		children: []
+	};
+	for (const e of record.evals) {
+		const trail = [e.file, ...e.group];
+		let node = root;
+		for (const [i, name] of trail.entries()) {
+			const key = trail.slice(0, i + 1).join(" › ");
+			let child = node.children.find((c) => c.kind === "group" && c.key === key);
+			if (!child) {
+				child = {
+					kind: "group",
+					key,
+					name,
+					tally: ZERO,
+					children: []
+				};
+				node.children.push(child);
+			}
+			node = child;
+		}
+		node.children.push({
+			kind: "eval",
+			key: e.id,
+			name: e.name,
+			tally: tallyOf(e),
+			eval: e
+		});
+	}
+	const finish = (n) => {
+		if (n.kind === "eval") return n;
+		const children = n.children.map(finish);
+		children.sort((a, b) => rank(a.tally) - rank(b.tally));
+		return {
+			...n,
+			children,
+			tally: children.reduce((t, c) => addTally(t, c.tally), ZERO)
+		};
+	};
+	return finish(root).children;
+}
+const rank = (t) => t.fail ? 0 : t.infra ? 1 : t.pass ? 2 : 3;
+/** One row per cell: controls and variants, with each variant's recorded lift. */
+function cellRows(e) {
+	return e.cells.map((cell) => ({
+		key: cell.key,
+		harness: cell.harness,
+		environment: cell.environment,
+		sandbox: cell.sandbox,
+		role: cell.role,
+		gated: cell.gate !== "none",
+		gate: cell.gate,
+		overrides: cell.overrides,
+		runs: cell.runs,
+		pass: cell.pass,
+		fail: cell.fail,
+		infraError: cell.infraError,
+		skipped: cell.skipped,
+		passRate: cell.passRate,
+		outcome: cell.outcome,
+		lift: cell.lift ? Math.round(cell.lift.points * 100) : null,
+		liftInterval: cell.lift ? {
+			lo: Math.round(cell.lift.interval.lo * 100),
+			hi: Math.round(cell.lift.interval.hi * 100),
+			withinNoise: cell.lift.withinNoise
+		} : null,
+		belowMinLift: cell.lift?.minLift !== void 0 && cell.lift.interval.lo < cell.lift.minLift,
+		effort: cellEffort(e, cell.key),
+		effortVsControl: cellContrast(e, cell.key),
+		attempts: e.attempts.filter((a) => a.cell === cell.key)
+	}));
+}
+/** Whether an eval needs the cells table: several cells, or several runs of one. */
+const isMatrix = (e) => e.cells.length > 1 || e.cells.some((c) => c.runs > 1);
+/** One eval across runs, oldest first. */
+function evalHistory(entries, slug) {
+	const oldest = [...entries].sort((a, b) => a.runId < b.runId ? -1 : 1);
+	const points = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const run of oldest) {
+		const e = run.evals.find((x) => x.slug === slug);
+		if (!e) continue;
+		points.push({
+			run,
+			outcome: e.outcome,
+			passRate: e.passRate,
+			cells: e.cells,
+			changed: cellsChanged(seen, e.id, e.cells)
+		});
+	}
+	return points;
+}
+const meanScore = (e) => {
+	const scores = e?.attempts.flatMap((a) => a.judgements.map((j) => j.score)) ?? [];
+	return scores.length ? scores.reduce((a, b) => a + b, 0) / scores.length : null;
+};
+const COMPARE_ORDER = [
+	"regressed",
+	"fixed",
+	"drift",
+	"infra",
+	"added",
+	"removed",
+	"same"
+];
+/**
+* Whether some of an eval's cells aren't gated (`gate: 'none'`, e.g. controls under
+* `compare.gate: 'variants'`). Its pass rate then covers fewer attempts than its pass count, so
+* the eval line labels the rate `gated`: `2/4 · 100% gated`.
+*/
+const hasUngatedCells = (cells) => cells.some((c) => c.gate === "none");
+/**
+* An expected miss: a failed attempt in an ungated cell (a control, by default). It's reported
+* apart from failures, since it fails neither its eval nor the run.
+*/
+const isUngatedMiss = (e, a) => a.outcome === "fail" && a.error?.kind !== "aborted" && e.cells.find((c) => c.key === a.cell)?.gate === "none";
+/** Passes over passes and fails in the gated cells, as an eval's `passRate` counts them. */
+function gatedPassRate(cells) {
+	const gated = cells.filter((c) => c.gate !== "none");
+	const pass = gated.reduce((n, c) => n + c.pass, 0);
+	const counted = pass + gated.reduce((n, c) => n + c.fail, 0);
+	return counted ? pass / counted : null;
+}
+/** `reeval compare`'s classification, plus pass rates and judge-score deltas from the records. */
+function compareView(base, head, records = {}) {
+	const rows = compare(base, head).map((row) => {
+		const b = base.evals.find((e) => e.id === row.id);
+		const h = head.evals.find((e) => e.id === row.id);
+		const baseKeys = new Set(b?.cells.map((c) => c.key));
+		const shared = row.cells && new Set(h?.cells.filter((c) => baseKeys.has(c.key)).map((c) => c.key));
+		const passRate = (e) => {
+			if (!e) return null;
+			return shared ? gatedPassRate(e.cells.filter((c) => shared.has(c.key))) : e.passRate;
+		};
+		return {
+			...row,
+			slug: h?.slug ?? b?.slug ?? null,
+			basePassRate: passRate(b),
+			headPassRate: passRate(h),
+			baseScore: meanScore(records.base?.evals.find((e) => e.id === row.id)),
+			headScore: meanScore(records.head?.evals.find((e) => e.id === row.id)),
+			perCell: row.perCell ?? []
+		};
+	});
+	rows.sort((a, b) => COMPARE_ORDER.indexOf(a.status) - COMPARE_ORDER.indexOf(b.status));
+	return {
+		rows,
+		counts: Object.fromEntries(COMPARE_ORDER.map((s) => [s, rows.filter((r) => r.status === s).length])),
+		changes: stackChanges(base, head)
+	};
+}
+/** Parses `transcript.jsonl`, skipping lines that aren't JSON (a truncated tail, say). */
+function parseTranscript(text) {
+	const lines = [];
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const value = JSON.parse(line);
+			if (value && typeof value.type === "string") lines.push(readableTranscriptLine(value));
+		} catch {}
+	}
+	return lines;
+}
+function transcriptItems(lines) {
+	return lines.map((line) => {
+		if (line.type === "prompt") return {
+			kind: "turn",
+			turn: line.turn,
+			prompt: line.text,
+			ts: line.ts
+		};
+		if (line.type === "turn-end") return {
+			kind: "turn-end",
+			turn: line.turn,
+			status: line.status,
+			durationMs: line.durationMs
+		};
+		return {
+			kind: "event",
+			turn: line.turn,
+			event: line
+		};
+	});
+}
+const HEADER = /^diff --git a\/(.+?) b\/(.+)$/m;
+/** Splits a git patch into one entry per file, with line counts. */
+function splitPatch(patch) {
+	if (!patch.trim()) return [];
+	return patch.split(/(?=^diff --git )/m).filter((part) => part.startsWith("diff --git ")).map((text) => {
+		const header = HEADER.exec(text);
+		const path = header?.[2] ?? header?.[1] ?? "unknown";
+		let added = 0;
+		let removed = 0;
+		for (const line of text.split("\n")) if (line.startsWith("+") && !line.startsWith("+++ ")) added++;
+		else if (line.startsWith("-") && !line.startsWith("--- ")) removed++;
+		return {
+			path,
+			status: /^new file mode/m.test(text) ? "added" : /^deleted file mode/m.test(text) ? "deleted" : /^rename from/m.test(text) ? "renamed" : /^(Binary files|GIT binary patch)/m.test(text) ? "binary" : "modified",
+			added,
+			removed,
+			text
+		};
+	});
+}
+const findEval = (record, slug) => record.evals.find((e) => e.slug === slug);
+const findAttempt = (e, attemptId) => e.attempts.find((a) => a.id === attemptId);
+/** The attempt to open by default: the first failure, else the first attempt. */
+const defaultAttempt = (e) => e.attempts.find((a) => a.outcome === "fail" || a.outcome === "infra_error") ?? e.attempts[0];
+//#endregion
+export { cellSamples as A, formatSeconds as B, splitEvalId as C, VERDICT_TEXT as D, EFFORT_ALPHA as E, effortSample as F, whyChanged as G, compare as H, effortSummary as I, effortVerdict as L, effortChangeLabel as M, effortLabel as N, cellContrast as O, effortOf as P, formatCount as R, shortSha as S, transcriptItems as T, sourceChanges as U, cellsChanged as V, stackChanges as W, isMatrix as _, compareView as a, runOutcome as b, evalTree as c, formatDuration as d, formatPercent as f, indexFiles as g, hasUngatedCells as h, cellRows as i, contrastEffort as j, cellEffort as k, findAttempt as l, harnessLabel as m, activityLabel as n, defaultAttempt as o, formatUsage as p, buildIndex as r, evalHistory as s, COMPARE_ORDER as t, findEval as u, isUngatedMiss as v, splitPatch as w, runRows as x, parseTranscript as y, formatRatio as z };
+
+//# sourceMappingURL=model-CDL98xue.js.map