reeval 0.11.0 → 0.12.0

package/dist/db-DfhipHEF.js

@@ -1,1416 +0,0 @@
-import { n as toolTarget, t as SKILL_LOAD_TOOLS } from "./tool-target-D2mcYlSQ.js";
-import { n as UsageError } from "./errors-B6BSMs03.js";
-import { t as RUN_ID } from "./paths-BmR-7tx3.js";
-import { c as relativeFile, l as sha256 } from "./ids-Bp6ut7ZD.js";
-import { d as ownRequire, t as BUILD_ID } from "./root-DICDHCtp.js";
-import { n as isRuntimeState } from "./context-C1mxXh80.js";
-import { $ as contrastEffort, dt as liftInterval, gt as round3, mt as median, rt as effortOf, vt as wilson } from "./model-DaX4bNLZ.js";
-import { r as pairTallies } from "./pairs-CnInRu-G.js";
-import { m as warnUnreadable, p as scratchDir, s as readRecord, u as recordNames } from "./files-BpUYBwGu.js";
-import { n as contrastPairs, t as checkVerdict } from "./contrasts-5zsj32gk.js";
-import { dirname, join } from "node:path";
-import { mkdir, readFile, stat } from "node:fs/promises";
-//#region src/history/rows.ts
-/** A statement's rows as `Row`, the columns its SQL selects: SQLite checks none of them. */
-const rowsOf = (statement, ...params) => statement.all(...params);
-//#endregion
-//#region src/history/tool-class.ts
-const TOOL_CLASSES = [
-	"context",
-	"dependency",
-	"web",
-	"verify",
-	"workspace"
-];
-const SHELL_TOOL = /shell|bash|terminal|command|exec/i;
-const WEB_TOOL = /web|fetch|browse|url/i;
-const DEPENDENCY = /(^|\/)(node_modules|site-packages|dist-packages|vendor|\.venv|\.cargo\/registry|go\/pkg\/mod)(\/|$)/;
-const VERIFY = /\b(?:(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)|npx\s+(?:tsc|vitest|jest|eslint|biome)|tsc|vitest|jest|pytest|eslint|cargo\s+(?:test|build|check)|go\s+(?:test|build|vet))\b/;
-/** Words of a shell command, quotes removed; `;`, `|` and `&&` split words. */
-function shellWords(command) {
-	const words = [];
-	let word = "";
-	let quote = null;
-	let started = false;
-	const flush = () => {
-		if (started) words.push(word);
-		word = "";
-		started = false;
-	};
-	for (const ch of command) {
-		if (quote) {
-			if (ch === quote) quote = null;
-			else word += ch;
-			continue;
-		}
-		if (ch === "\"" || ch === "'") {
-			quote = ch;
-			started = true;
-		} else if (/\s/.test(ch)) flush();
-		else if (ch === ";" || ch === "|" || ch === "&") {
-			flush();
-			words.push(ch);
-		} else {
-			word += ch;
-			started = true;
-		}
-	}
-	flush();
-	return words;
-}
-/** A command's words, with a `bash -c '…'` (or `-lc`) script split into its own words. */
-function commandWords(command) {
-	const words = shellWords(command);
-	return words.flatMap((w, i) => i > 0 && /^-[a-z]*c$/.test(words[i - 1]) && /\s/.test(w) ? commandWords(w) : [w]);
-}
-const EXCLUDING_FLAG = /^--(?:exclude|exclude-dir|ignore|ignore-dir)(?:=|$)/;
-/** The words of a command that name something it reads, without the ones it excludes. */
-function readWords(words) {
-	const out = [];
-	let test = false;
-	for (let i = 0; i < words.length; i++) {
-		const w = words[i];
-		const prev = words[i - 1];
-		if (w === "[" || w === "[[" || w === "test") test = true;
-		else if (w === "]" || w === "]]" || w === ";" || w === "|" || w === "&") test = false;
-		if (test && /^-[defsrwx]$/.test(w)) {
-			i++;
-			continue;
-		}
-		if (EXCLUDING_FLAG.test(w)) {
-			if (!w.includes("=")) i++;
-			continue;
-		}
-		if ((w === "-path" || w === "-name" || w === "-ipath" || w === "-wholename") && i + 1 < words.length) {
-			const pruned = words[i + 2] === "-prune";
-			if (prev === "-not" || prev === "!" || pruned) {
-				i++;
-				continue;
-			}
-		}
-		if ((w === "-g" || w === "--glob" || w === "--iglob") && words[i + 1]?.startsWith("!")) {
-			i++;
-			continue;
-		}
-		if (/^--i?glob=!/.test(w)) continue;
-		if (w === "-v" && i > 0) {
-			i++;
-			continue;
-		}
-		out.push(w);
-	}
-	return out;
-}
-/** `/home/<user>/x` and `/root/x` as `~/x`; `./x` as `x`. */
-const normalise = (p) => p.replace(/^\/home\/[^/]+\//, "~/").replace(/^\/root\//, "~/").replace(/^\$HOME\//, "~/").replace(/^\.\//, "");
-const GLOB = /[*?[{]/;
-/** `*`, `**` and `?` as wildcards; every other character, `[` included, literally. */
-function wildcards(glob) {
-	let re = "";
-	for (let i = 0; i < glob.length; i++) {
-		const ch = glob[i];
-		if (ch === "*") {
-			if (glob[i + 1] === "*") {
-				re += ".*";
-				i++;
-			} else re += "[^/]*";
-		} else if (ch === "?") re += "[^/]";
-		else re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	}
-	return re;
-}
-/** A glob as a regex, with `{a,b}` alternatives. Words come from transcripts, so it never throws. */
-function globRegex(glob) {
-	let re = "";
-	let from = 0;
-	for (let i = 0; i < glob.length; i++) {
-		if (glob[i] !== "{") continue;
-		const end = glob.indexOf("}", i);
-		if (end < 0) break;
-		re += wildcards(glob.slice(from, i));
-		re += `(?:${glob.slice(i + 1, end).split(",").map(wildcards).join("|")})`;
-		from = end + 1;
-		i = end;
-	}
-	return new RegExp(`^${re}${wildcards(glob.slice(from))}$`);
-}
-/** The declared files one word names: the file itself, one of a glob's matches, or a directory's. */
-function filesOf(word, files) {
-	const w = normalise(word).replace(/\/+$/, "");
-	if (!w) return {
-		files: [],
-		dir: false
-	};
-	const forms = (f) => f.startsWith("~/") ? [f, f.slice(2)] : [f];
-	const matches = (f, test) => forms(f).some((form) => test(form) || !w.startsWith("~/") && test(`~/${form}`));
-	if (GLOB.test(w)) {
-		const re = globRegex(w);
-		const fromWorkspace = /^[*?[{]/.test(w);
-		return {
-			files: files.filter((f) => fromWorkspace ? !f.startsWith("~/") && re.test(f) : matches(f, (form) => re.test(form))),
-			dir: false
-		};
-	}
-	const exact = files.filter((f) => matches(f, (form) => form === w || form.endsWith(`/${w}`)));
-	if (exact.length) return {
-		files: exact,
-		dir: false
-	};
-	return {
-		files: [],
-		dir: files.filter((f) => matches(f, (form) => form.startsWith(`${w}/`))).length > 0
-	};
-}
-/** A tool call's class, and the declared files it read (for `skill_files`). */
-function classifyCall(tool, target, ctx) {
-	if (SKILL_LOAD_TOOLS.has(tool)) {
-		if (!ctx.skills.includes(target)) return {
-			class: "workspace",
-			files: []
-		};
-		return {
-			class: "context",
-			files: ctx.files.filter((f) => f.endsWith(`skills/${target}/SKILL.md`))
-		};
-	}
-	if (ctx.mcp.some((s) => tool.startsWith(`mcp__${s}__`) || tool.startsWith(`${s}__`))) return {
-		class: "context",
-		files: []
-	};
-	const shell = SHELL_TOOL.test(tool);
-	const words = shell ? readWords(commandWords(target)) : [target];
-	const files = /* @__PURE__ */ new Set();
-	let context = false;
-	for (const w of words) {
-		const hit = filesOf(w, ctx.files);
-		for (const f of hit.files) files.add(f);
-		if (hit.files.length || hit.dir) context = true;
-		if (ctx.skills.some((s) => normalise(w).includes(`skills/${s}/`) || normalise(w).endsWith(`skills/${s}`))) context = true;
-	}
-	if (context) return {
-		class: "context",
-		files: [...files]
-	};
-	if (words.some((w) => DEPENDENCY.test(normalise(w))) || shell && words.includes("--help")) return {
-		class: "dependency",
-		files: []
-	};
-	if (!shell && WEB_TOOL.test(tool)) return {
-		class: "web",
-		files: []
-	};
-	if (shell && words.some((w) => w === "curl" || w === "wget") && /https?:\/\//.test(target)) return {
-		class: "web",
-		files: []
-	};
-	if (shell) {
-		const command = target.trim();
-		if (ctx.verify.some((v) => v.trim().length >= 4 && command.includes(v.trim()))) return {
-			class: "verify",
-			files: []
-		};
-		if (VERIFY.test(command)) return {
-			class: "verify",
-			files: []
-		};
-	}
-	return {
-		class: "workspace",
-		files: []
-	};
-}
-/** A failing verdict this close to its threshold points at the judge, not the agent. */
-const JUDGE_MARGIN = .1;
-const DERIVED_TABLES = `
-CREATE TABLE effort_m (
-  run_id TEXT, eval_key TEXT, cell_key TEXT, role TEXT, variant TEXT, harness TEXT,
-  environment TEXT, n INTEGER, tools_median REAL, tools_q1 REAL, tools_q3 REAL,
-  agent_s_median REAL, agent_s_q1 REAL, agent_s_q3 REAL, file_edits_median REAL,
-  tokens_median REAL, tokens_q1 REAL, tokens_q3 REAL,
-  control_key TEXT, control_n INTEGER, control_tools_median REAL, control_agent_s_median REAL,
-  control_tokens_median REAL,
-  tools_ratio REAL, agent_s_ratio REAL, agent_s_delta REAL, tokens_ratio REAL,
-  tools_p REAL, agent_s_p REAL, tokens_p REAL,
-  separated INTEGER, time_separated INTEGER, tokens_separated INTEGER,
-  verdict TEXT, time_verdict TEXT, tokens_verdict TEXT, tokens_note TEXT,
-  context_calls_median REAL, dependency_calls_median REAL, web_calls_median REAL,
-  verify_calls_median REAL, workspace_calls_median REAL
-);
-CREATE TABLE contrasts_m (
-  run_id TEXT, eval_key TEXT, harness TEXT, sandbox TEXT, a_key TEXT, b_key TEXT,
-  a_environment TEXT, b_environment TEXT, a_pass INTEGER, a_counted INTEGER, b_pass INTEGER,
-  b_counted INTEGER, points REAL, lo REAL, hi REAL, pass_verdict TEXT,
-  a_tools_median REAL, b_tools_median REAL, tools_ratio REAL, tools_p REAL, separated INTEGER,
-  verdict TEXT, agent_s_ratio REAL, time_separated INTEGER, time_verdict TEXT,
-  tokens_ratio REAL, tokens_separated INTEGER, tokens_verdict TEXT,
-  checks INTEGER, discriminating TEXT
-);
-CREATE TABLE factor_effects_m (
-  factor TEXT, level TEXT, baseline TEXT, context TEXT, tier TEXT, run_id TEXT, eval_key TEXT,
-  strata INTEGER, runs INTEGER, variant_pass INTEGER, variant_counted INTEGER,
-  control_pass INTEGER, control_counted INTEGER, points REAL, lo REAL, hi REAL,
-  within_noise INTEGER, pass_verdict TEXT, tools_ratio REAL, tools_ratios TEXT,
-  agent_s_ratio REAL, tools_p REAL, consistent INTEGER, separated INTEGER, effort_verdict TEXT,
-  tokens_ratio REAL, tokens_p REAL, tokens_verdict TEXT, tokens_note TEXT,
-  note TEXT
-);
-CREATE TABLE flaky_m (
-  eval_key TEXT, cell_key TEXT, fingerprint TEXT, runs INTEGER, flaky_runs INTEGER,
-  first_seen TEXT, last_seen TEXT, pass INTEGER, counted INTEGER, infra_error INTEGER,
-  pass_at_1 REAL, lo REAL, hi REAL, verdict TEXT, cause TEXT, min_attempts INTEGER
-);
-CREATE TABLE drift_m (
-  run_id TEXT, prev_run_id TEXT, eval_key TEXT, cell_key TEXT, changed TEXT,
-  changed_paths TEXT, noise INTEGER, real_changed TEXT
-);
-`;
-const FAMILY_COLUMNS = [
-	"run_id",
-	"family_id",
-	"harness",
-	"variant",
-	"pairs",
-	"points",
-	"lo",
-	"hi",
-	"within_noise",
-	"verdict",
-	"tools_ratio",
-	"tools_p",
-	"effort_verdict",
-	"agent_s_ratio",
-	"tokens_ratio",
-	"tokens_p",
-	"tokens_verdict"
-];
-const DERIVED = [
-	"effort_m",
-	"contrasts_m",
-	"factor_effects_m",
-	"flaky_m",
-	"drift_m"
-];
-const PARTS = [
-	["sources", "fp_sources"],
-	["harness", "fp_harness"],
-	["environment", "fp_environment"],
-	["image", "fp_image"],
-	["agent_cli", "fp_agent_cli"],
-	["judge", "fp_judge"],
-	["context", "fp_context"]
-];
-const r4 = (x) => x === null ? null : Math.round(x * 1e4) / 1e4;
-const s1 = (ms) => Math.round(ms / 100) / 10;
-const cellId = (run, evalKey, cell) => `${run}\0${evalKey}\0${cell}`;
-function passCols(v, c) {
-	const lift = liftInterval({
-		pass: v.pass,
-		n: v.counted
-	}, {
-		pass: c.pass,
-		n: c.counted
-	});
-	const noise = lift.low <= 0 && lift.high >= 0;
-	return {
-		variant_pass: v.pass,
-		variant_counted: v.counted,
-		control_pass: c.pass,
-		control_counted: c.counted,
-		points: round3(lift.points),
-		lo: round3(lift.low),
-		hi: round3(lift.high),
-		within_noise: noise ? 1 : 0,
-		pass_verdict: Math.min(v.counted, c.counted) < 2 ? "insufficient" : noise ? "noise" : "effect"
-	};
-}
-function tokenCols(e) {
-	return {
-		tokens_ratio: r4(e?.tokensRatio ?? null),
-		tokens_p: r4(e?.tokensP ?? null),
-		tokens_verdict: e?.tokensVerdict ?? null,
-		tokens_note: e?.tokensNote ?? null
-	};
-}
-function effortCols(e) {
-	return {
-		tools_ratio: r4(e?.toolsRatio ?? null),
-		tools_ratios: e?.toolsRatio === null || !e ? null : `×${e.toolsRatio.toFixed(2)}`,
-		agent_s_ratio: r4(e?.agentMsRatio ?? null),
-		tools_p: r4(e?.toolsP ?? null),
-		consistent: e && (e.verdict === "fewer" || e.verdict === "more") ? 1 : 0,
-		separated: e?.separated ? 1 : 0,
-		effort_verdict: e?.verdict ?? null,
-		...tokenCols(e)
-	};
-}
-/** Across strata: an effect when ≥ 2/3 of them show it in the same direction at p < 0.05. */
-function pooledEffort(strata) {
-	const known = strata.filter((s) => s !== null);
-	const k = strata.length;
-	const count = (v) => known.filter((s) => s.verdict === v).length;
-	const needed = Math.ceil(2 * k / 3);
-	let verdict = "noise";
-	if (count("fewer") >= needed && count("more") === 0) verdict = "fewer";
-	else if (count("more") >= needed && count("fewer") === 0) verdict = "more";
-	else if (known.length && count("insufficient") === known.length) verdict = "insufficient";
-	const sorted = [...known.map((s) => s.toolsRatio).filter((r) => r !== null)].sort((a, b) => a - b);
-	const mid = sorted.length ? sorted.length % 2 ? sorted[(sorted.length - 1) / 2] : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2 : null;
-	return {
-		tools_ratio: r4(mid),
-		tools_ratios: known.map((s) => s.toolsRatio === null ? "×–" : `×${s.toolsRatio.toFixed(2)}`).join(" / "),
-		agent_s_ratio: null,
-		tools_p: r4(known.length ? Math.max(...known.map((s) => s.toolsP ?? 1)) : null),
-		consistent: verdict === "fewer" || verdict === "more" ? count(verdict) : 0,
-		separated: known.filter((s) => s.separated).length,
-		effort_verdict: verdict,
-		...pooledTokens(known)
-	};
-}
-/**
-* Token verdict over the strata that reported usage. A stratum without token samples is
-* dropped from this pool only — not `insufficient`, and it does not blank tokens on the rest.
-*/
-function pooledTokens(known) {
-	const withTokens = known.filter((s) => s.tokensVerdict !== null);
-	if (withTokens.length === 0) return {
-		tokens_ratio: null,
-		tokens_p: null,
-		tokens_verdict: null,
-		tokens_note: null
-	};
-	const k = withTokens.length;
-	const count = (v) => withTokens.filter((s) => s.tokensVerdict === v).length;
-	const needed = Math.ceil(2 * k / 3);
-	let verdict = "noise";
-	if (count("fewer") >= needed && count("more") === 0) verdict = "fewer";
-	else if (count("more") >= needed && count("fewer") === 0) verdict = "more";
-	else if (count("insufficient") === k) verdict = "insufficient";
-	const sorted = [...withTokens.map((s) => s.tokensRatio).filter((r) => r !== null)].sort((a, b) => a - b);
-	const mid = sorted.length ? sorted.length % 2 ? sorted[(sorted.length - 1) / 2] : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2 : null;
-	return {
-		tokens_ratio: r4(mid),
-		tokens_p: r4(Math.max(...withTokens.map((s) => s.tokensP ?? 1))),
-		tokens_verdict: verdict,
-		tokens_note: known.some((s) => s.tokensNote) || withTokens.length < known.length ? "some cells did not report usage" : null
-	};
-}
-const merge = (sides) => ({
-	pass: sides.reduce((n, s) => n + s.pass, 0),
-	counted: sides.reduce((n, s) => n + s.counted, 0),
-	samples: sides.flatMap((s) => s.samples)
-});
-function insertAll(db, table, rows) {
-	if (rows.length === 0) return;
-	const cols = rowsOf(db.prepare(`PRAGMA table_info("${table}")`)).map((c) => c.name);
-	const statement = db.prepare(`INSERT INTO ${table} (${cols.join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`);
-	for (const row of rows) statement.run(...cols.map((c) => row[c] ?? null));
-}
-/** Recomputes every derived table from the projected rows; run inside the sync's transaction. */
-function deriveFacts(db) {
-	for (const table of DERIVED) db.exec(`DELETE FROM ${table}`);
-	const cells = rowsOf(db.prepare("SELECT c.*, r.started_at FROM cells c JOIN runs r USING (run_id) ORDER BY c.run_id, c.rowid"));
-	const attempts = rowsOf(db.prepare(`SELECT run_id, eval_key, cell_key, key, outcome, error_kind, tools, agent_ms, file_edits,
-        input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, reasoning_tokens
-       FROM attempts ORDER BY run_id, rowid`));
-	const nearThreshold = new Set(rowsOf(db.prepare(`SELECT DISTINCT run_id, attempt_key FROM judgements WHERE verdict = 'fail' AND ABS(score - threshold) <= ${JUDGE_MARGIN}`)).map((r) => `${r.run_id}\0${r.attempt_key}`));
-	const diffs = new Map(rowsOf(db.prepare(`SELECT run_id, attempt_key, sha256 FROM artifacts WHERE kind = 'diff' AND bytes > 0`)).flatMap((r) => r.sha256 ? [[`${r.run_id}\0${r.attempt_key}`, r.sha256]] : []));
-	const samples = /* @__PURE__ */ new Map();
-	const byCell = /* @__PURE__ */ new Map();
-	for (const a of attempts) {
-		const id = cellId(a.run_id, a.eval_key, a.cell_key);
-		byCell.set(id, [...byCell.get(id) ?? [], a]);
-		if (a.outcome !== "pass" && a.outcome !== "fail") continue;
-		const tokens = a.input_tokens === null ? void 0 : a.input_tokens + (a.output_tokens ?? 0) + (a.cache_read_tokens ?? 0) + (a.cache_write_tokens ?? 0) + (a.reasoning_tokens ?? 0);
-		samples.set(id, [...samples.get(id) ?? [], {
-			tools: a.tools,
-			agentMs: a.agent_ms,
-			fileEdits: a.file_edits,
-			...tokens !== void 0 ? { tokens } : {}
-		}]);
-	}
-	const side = (c) => ({
-		pass: c.pass,
-		counted: c.pass + c.fail,
-		samples: samples.get(cellId(c.run_id, c.eval_key, c.key)) ?? []
-	});
-	const find = (run, evalKey, key) => cells.find((c) => c.run_id === run && c.eval_key === evalKey && c.key === key);
-	const classCounts = /* @__PURE__ */ new Map();
-	for (const r of rowsOf(db.prepare("SELECT run_id, attempt_key, class, COUNT(*) AS n FROM tool_calls GROUP BY run_id, attempt_key, class"))) {
-		const id = `${r.run_id}\0${r.attempt_key}`;
-		const m = classCounts.get(id) ?? /* @__PURE__ */ new Map();
-		m.set(r.class, r.n);
-		classCounts.set(id, m);
-	}
-	const classMedians = (c) => {
-		const known = (byCell.get(cellId(c.run_id, c.eval_key, c.key)) ?? []).filter((a) => a.outcome === "pass" || a.outcome === "fail").flatMap((a) => {
-			const m = classCounts.get(`${a.run_id}\0${a.key}`);
-			return m ? [m] : [];
-		});
-		return Object.fromEntries(TOOL_CLASSES.map((k) => [`${k}_calls_median`, known.length ? median(known.map((m) => m.get(k) ?? 0)) ?? null : null]));
-	};
-	insertAll(db, "effort_m", cells.map((c) => {
-		const own = effortOf(side(c).samples);
-		const control = c.lift_vs ? find(c.run_id, c.eval_key, c.lift_vs) : void 0;
-		const vs = control ? contrastEffort(side(c).samples, side(control).samples) : null;
-		return {
-			run_id: c.run_id,
-			eval_key: c.eval_key,
-			cell_key: c.key,
-			role: c.role,
-			variant: c.variant,
-			harness: c.harness,
-			environment: c.environment,
-			n: own?.n ?? 0,
-			tools_median: own?.tools.median ?? null,
-			tools_q1: own?.tools.q1 ?? null,
-			tools_q3: own?.tools.q3 ?? null,
-			agent_s_median: own ? s1(own.agentMs.median) : null,
-			agent_s_q1: own ? s1(own.agentMs.q1) : null,
-			agent_s_q3: own ? s1(own.agentMs.q3) : null,
-			file_edits_median: own?.fileEdits ?? null,
-			tokens_median: own?.tokens?.median ?? null,
-			tokens_q1: own?.tokens?.q1 ?? null,
-			tokens_q3: own?.tokens?.q3 ?? null,
-			control_key: control?.key ?? null,
-			control_n: vs?.control.n ?? null,
-			control_tools_median: vs?.control.tools.median ?? null,
-			control_agent_s_median: vs ? s1(vs.control.agentMs.median) : null,
-			control_tokens_median: vs?.control.tokens?.median ?? null,
-			tools_ratio: r4(vs?.toolsRatio ?? null),
-			agent_s_ratio: r4(vs?.agentMsRatio ?? null),
-			agent_s_delta: vs ? s1(vs.agentMsDelta) : null,
-			tokens_ratio: r4(vs?.tokensRatio ?? null),
-			tools_p: r4(vs?.toolsP ?? null),
-			agent_s_p: r4(vs?.agentMsP ?? null),
-			tokens_p: r4(vs?.tokensP ?? null),
-			separated: vs ? vs.separated ? 1 : 0 : null,
-			time_separated: vs ? vs.timeSeparated ? 1 : 0 : null,
-			tokens_separated: vs?.tokensSeparated == null ? null : vs.tokensSeparated ? 1 : 0,
-			verdict: vs?.verdict ?? null,
-			time_verdict: vs?.timeVerdict ?? null,
-			tokens_verdict: vs?.tokensVerdict ?? null,
-			tokens_note: vs?.tokensNote ?? null,
-			...classMedians(c)
-		};
-	}));
-	const checkRows = rowsOf(db.prepare("SELECT run_id, eval_key, cell_key, label, pass, fail, error, not_run FROM cell_checks"));
-	const checksOf = /* @__PURE__ */ new Map();
-	for (const k of checkRows) {
-		const id = cellId(k.run_id, k.eval_key, k.cell_key);
-		const m = checksOf.get(id) ?? /* @__PURE__ */ new Map();
-		m.set(k.label, {
-			pass: k.pass,
-			fail: k.fail,
-			error: k.error,
-			notRun: k.not_run
-		});
-		checksOf.set(id, m);
-	}
-	const evalCells = /* @__PURE__ */ new Map();
-	for (const c of cells) {
-		const id = `${c.run_id}\0${c.eval_key}`;
-		evalCells.set(id, [...evalCells.get(id) ?? [], c]);
-	}
-	const contrastRows = [];
-	for (const group of evalCells.values()) for (const [a, b] of contrastPairs(group)) {
-		const x = side(a);
-		const y = side(b);
-		const e = contrastEffort(x.samples, y.samples);
-		const ka = checksOf.get(cellId(a.run_id, a.eval_key, a.key)) ?? /* @__PURE__ */ new Map();
-		const kb = checksOf.get(cellId(b.run_id, b.eval_key, b.key)) ?? /* @__PURE__ */ new Map();
-		const verdicts = [...ka].flatMap(([label, t]) => {
-			const other = kb.get(label);
-			const verdict = other && checkVerdict(t, other);
-			return verdict ? [{
-				label,
-				verdict
-			}] : [];
-		});
-		const pass = passCols(x, y);
-		contrastRows.push({
-			run_id: a.run_id,
-			eval_key: a.eval_key,
-			harness: a.harness,
-			sandbox: a.sandbox,
-			a_key: a.key,
-			b_key: b.key,
-			a_environment: a.environment,
-			b_environment: b.environment,
-			a_pass: x.pass,
-			a_counted: x.counted,
-			b_pass: y.pass,
-			b_counted: y.counted,
-			points: pass.points ?? null,
-			lo: pass.lo ?? null,
-			hi: pass.hi ?? null,
-			pass_verdict: pass.pass_verdict ?? null,
-			a_tools_median: e?.variant.tools.median ?? null,
-			b_tools_median: e?.control.tools.median ?? null,
-			tools_ratio: r4(e?.toolsRatio ?? null),
-			tools_p: r4(e?.toolsP ?? null),
-			separated: e ? e.separated ? 1 : 0 : null,
-			verdict: e?.verdict ?? null,
-			agent_s_ratio: r4(e?.agentMsRatio ?? null),
-			time_separated: e ? e.timeSeparated ? 1 : 0 : null,
-			time_verdict: e?.timeVerdict ?? null,
-			tokens_ratio: r4(e?.tokensRatio ?? null),
-			tokens_separated: e?.tokensSeparated == null ? null : e.tokensSeparated ? 1 : 0,
-			tokens_verdict: e?.tokensVerdict ?? null,
-			checks: verdicts.length,
-			discriminating: verdicts.filter((v) => v.verdict === "discriminates").map((v) => v.label).join(" · ") || null
-		});
-	}
-	insertAll(db, "contrasts_m", contrastRows);
-	const pairs = [];
-	const groups = /* @__PURE__ */ new Map();
-	for (const c of cells) {
-		const id = `${c.run_id}\0${c.eval_key}`;
-		groups.set(id, [...groups.get(id) ?? [], c]);
-	}
-	for (const group of groups.values()) {
-		for (const v of group) {
-			const control = v.lift_vs ? group.find((c) => c.key === v.lift_vs) : void 0;
-			if (!control) continue;
-			pairs.push({
-				factor: "environment",
-				level: v.variant ?? v.environment,
-				baseline: "control",
-				context: v.harness,
-				run: v.run_id,
-				evalKey: v.eval_key,
-				pool: `${v.comparable}\0${control.comparable}`,
-				v: side(v),
-				c: side(control)
-			});
-		}
-		const bySetup = /* @__PURE__ */ new Map();
-		for (const c of group) {
-			const id = `${c.variant ?? c.role}\0${c.sandbox}`;
-			bySetup.set(id, [...bySetup.get(id) ?? [], c]);
-		}
-		for (const same of bySetup.values()) {
-			const base = same[0];
-			for (const other of same.slice(1)) {
-				if (other.harness === base.harness) continue;
-				pairs.push({
-					factor: other.harness_kind === base.harness_kind ? "model" : "harness",
-					level: other.harness,
-					baseline: base.harness,
-					context: other.variant ?? "control",
-					run: other.run_id,
-					evalKey: other.eval_key,
-					pool: `${other.comparable}\0${base.comparable}`,
-					v: side(other),
-					c: side(base)
-				});
-			}
-		}
-	}
-	const factorRows = [];
-	const head = (p) => ({
-		factor: p.factor,
-		level: p.level,
-		baseline: p.baseline,
-		context: p.context
-	});
-	for (const p of pairs) factorRows.push({
-		...head(p),
-		tier: "controlled",
-		run_id: p.run,
-		eval_key: p.evalKey,
-		strata: 1,
-		runs: 1,
-		...passCols(p.v, p.c),
-		...effortCols(contrastEffort(p.v.samples, p.c.samples)),
-		note: null
-	});
-	const pooled = /* @__PURE__ */ new Map();
-	for (const p of pairs) {
-		const id = [
-			p.factor,
-			p.level,
-			p.baseline,
-			p.context,
-			p.evalKey,
-			p.pool
-		].join("\0");
-		pooled.set(id, [...pooled.get(id) ?? [], p]);
-	}
-	const strata = /* @__PURE__ */ new Map();
-	for (const group of pooled.values()) {
-		const first = group[0];
-		const v = merge(group.map((p) => p.v));
-		const c = merge(group.map((p) => p.c));
-		if (group.length > 1) factorRows.push({
-			...head(first),
-			tier: "pooled",
-			run_id: null,
-			eval_key: first.evalKey,
-			strata: 1,
-			runs: group.length,
-			...passCols(v, c),
-			...effortCols(contrastEffort(v.samples, c.samples)),
-			note: null
-		});
-		const id = [
-			first.factor,
-			first.level,
-			first.baseline,
-			first.context
-		].join("\0");
-		strata.set(id, [...strata.get(id) ?? [], {
-			evalKey: first.evalKey,
-			pool: first.pool,
-			v,
-			c
-		}]);
-	}
-	for (const [id, list] of strata) {
-		const poolsByEval = /* @__PURE__ */ new Map();
-		for (const s of list) poolsByEval.set(s.evalKey, /* @__PURE__ */ new Set([...poolsByEval.get(s.evalKey) ?? [], s.pool]));
-		const comparable = list.filter((s) => (poolsByEval.get(s.evalKey)?.size ?? 0) === 1);
-		if (new Set(comparable.map((s) => s.evalKey)).size < 2) continue;
-		const [factor, level, baseline, context] = id.split("\0");
-		const v = merge(comparable.map((s) => s.v));
-		const c = merge(comparable.map((s) => s.c));
-		factorRows.push({
-			...head({
-				factor,
-				level,
-				baseline,
-				context
-			}),
-			tier: "pooled",
-			run_id: null,
-			eval_key: null,
-			strata: comparable.length,
-			runs: null,
-			...passCols(v, c),
-			...pooledEffort(comparable.map((s) => contrastEffort(s.v.samples, s.c.samples))),
-			note: "pass@1: summed counts; effort: an effect in at least 2/3 of strata"
-		});
-	}
-	const familyLifts = rowsOf(db.prepare(`SELECT ${FAMILY_COLUMNS.join(", ")} FROM family_lift_m`));
-	for (const f of familyLifts) factorRows.push({
-		factor: "environment",
-		level: f.variant,
-		baseline: "control",
-		context: f.harness,
-		tier: "paired",
-		run_id: f.run_id,
-		eval_key: f.family_id,
-		strata: f.pairs,
-		runs: 1,
-		points: f.points,
-		lo: f.lo,
-		hi: f.hi,
-		within_noise: f.within_noise,
-		pass_verdict: f.verdict === "insufficient" ? "insufficient" : f.within_noise ? "noise" : "effect",
-		tools_ratio: f.tools_ratio,
-		agent_s_ratio: f.agent_s_ratio,
-		tools_p: f.tools_p,
-		effort_verdict: f.effort_verdict,
-		tokens_ratio: f.tokens_ratio,
-		tokens_p: f.tokens_p,
-		tokens_verdict: f.tokens_verdict,
-		note: "paired by case over a pooled evaluate.each: strata is the paired cases"
-	});
-	const driftRows = [];
-	const series = /* @__PURE__ */ new Map();
-	for (const c of cells) {
-		const id = `${c.eval_key}\0${c.key}`;
-		series.set(id, [...series.get(id) ?? [], c]);
-	}
-	const contextOf = db.prepare("SELECT path, sha256 FROM attempt_context WHERE run_id = ? AND attempt_key = ?");
-	const cellContext = (c) => {
-		const files = /* @__PURE__ */ new Map();
-		for (const a of byCell.get(cellId(c.run_id, c.eval_key, c.key)) ?? []) for (const f of rowsOf(contextOf, c.run_id, a.key)) files.set(f.path, f.sha256);
-		return files;
-	};
-	for (const list of series.values()) {
-		list.sort((a, b) => a.run_id < b.run_id ? -1 : 1);
-		for (let i = 1; i < list.length; i++) {
-			const prev = list[i - 1];
-			const cur = list[i];
-			if (prev.fingerprint === cur.fingerprint) continue;
-			const changed = PARTS.filter(([, col]) => prev[col] !== cur[col]).map(([name]) => name);
-			let paths = [];
-			if (changed.includes("context")) {
-				const a = cellContext(prev);
-				const b = cellContext(cur);
-				paths = [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])].filter((p) => a.get(p) !== b.get(p)).sort();
-			}
-			const contextNoise = paths.length > 0 && paths.every(isRuntimeState);
-			const real = changed.filter((part) => part !== "context" || !contextNoise);
-			driftRows.push({
-				run_id: cur.run_id,
-				prev_run_id: prev.run_id,
-				eval_key: cur.eval_key,
-				cell_key: cur.key,
-				changed: changed.join(" "),
-				changed_paths: paths.length ? paths.join(", ") : null,
-				noise: real.length === 0 ? 1 : 0,
-				real_changed: real.join(" ") || null
-			});
-			if (real.length === 0) continue;
-			const judgeOnly = real.length === 1 && real[0] === "judge";
-			const sourcesChanged = real.includes("sources");
-			const cols = passCols(side(cur), side(prev));
-			if (sourcesChanged) cols.pass_verdict = "not_comparable";
-			factorRows.push({
-				factor: real.length === 1 ? real[0] : "confounded",
-				level: cur.run_id,
-				baseline: prev.run_id,
-				context: `${cur.eval_key} # ${cur.key}`,
-				tier: "observed",
-				run_id: cur.run_id,
-				eval_key: cur.eval_key,
-				strata: 1,
-				runs: 2,
-				...cols,
-				...effortCols(contrastEffort(side(cur).samples, side(prev).samples)),
-				note: sourcesChanged ? "the eval changed: not comparable, not an effect of the thing under test" : judgeOnly ? "the judge changed: a measurement change, not an effect of the thing under test" : real.length > 1 ? `confounded: ${real.join(", ")} changed together` : null
-			});
-		}
-	}
-	insertAll(db, "drift_m", driftRows);
-	const levels = (pick) => [...new Set(cells.map(pick))];
-	const single = [
-		["harness", levels((c) => c.harness_kind)],
-		["model", levels((c) => `${c.harness_kind}:${c.model ?? "-"}`)],
-		["sandbox", levels((c) => c.sandbox)]
-	];
-	if (cells.length && !cells.some((c) => c.role === "variant")) single.push(["environment", levels((c) => c.environment)]);
-	for (const [factor, values] of single) {
-		if (values.length !== 1) continue;
-		factorRows.push({
-			factor,
-			level: values[0],
-			baseline: null,
-			context: null,
-			tier: "not_measured",
-			note: "one level in every run, so its effect is not measured"
-		});
-	}
-	insertAll(db, "factor_effects_m", factorRows);
-	const flaky = /* @__PURE__ */ new Map();
-	for (const c of cells) {
-		const id = `${c.eval_key}\0${c.key}\0${c.comparable}`;
-		flaky.set(id, [...flaky.get(id) ?? [], c]);
-	}
-	const flakyRows = [];
-	for (const list of flaky.values()) {
-		const pass = list.reduce((n, c) => n + c.pass, 0);
-		const fail = list.reduce((n, c) => n + c.fail, 0);
-		if (!(pass > 0 && fail > 0)) continue;
-		const first = list[0];
-		const infra = list.reduce((n, c) => n + c.infra_error, 0);
-		const failing = list.flatMap((c) => (byCell.get(cellId(c.run_id, c.eval_key, c.key)) ?? []).filter((a) => a.outcome === "fail"));
-		const w = wilson(pass, pass + fail);
-		const passedDiffs = new Set(list.flatMap((c) => (byCell.get(cellId(c.run_id, c.eval_key, c.key)) ?? []).flatMap((a) => {
-			const sha = a.outcome === "pass" && diffs.get(`${a.run_id}\0${a.key}`);
-			return sha ? [sha] : [];
-		})));
-		const sameWork = failing.length > 0 && failing.every((a) => a.error_kind === "assertion" && passedDiffs.has(diffs.get(`${a.run_id}\0${a.key}`) ?? ""));
-		const cause = infra > 0 || failing.some((a) => a.error_kind === "infra") ? "infra" : failing.some((a) => nearThreshold.has(`${a.run_id}\0${a.key}`)) ? "judge" : sameWork ? "check" : "agent";
-		const starts = list.map((c) => c.started_at).sort();
-		flakyRows.push({
-			eval_key: first.eval_key,
-			cell_key: first.key,
-			fingerprint: first.comparable,
-			runs: list.length,
-			flaky_runs: list.filter((c) => c.pass > 0 && c.fail > 0).length,
-			first_seen: starts[0] ?? null,
-			last_seen: starts.at(-1) ?? null,
-			pass,
-			counted: pass + fail,
-			infra_error: infra,
-			pass_at_1: round3(pass / (pass + fail)),
-			lo: round3(w.low),
-			hi: round3(w.high),
-			verdict: pass + fail >= 6 ? "flaky" : "insufficient",
-			cause,
-			min_attempts: 6
-		});
-	}
-	flakyRows.sort((a, b) => String(a.first_seen).localeCompare(String(b.first_seen)));
-	insertAll(db, "flaky_m", flakyRows);
-}
-//#endregion
-//#region src/history/db.ts
-/** Bump when the tables or views change: a database from another version is rebuilt. */
-const DB_VERSION = 11;
-/** This build of reeval, like the header cache: another reeval re-derives every row. */
-const BUILD = BUILD_ID;
-const historyDbPath = (root) => join(root, ".reeval", "history.db");
-/** `node:sqlite` is in Node from 22.13 (package `engines`); before 24 it warns on load. */
-const SQLITE_NODE = "22.13.0";
-function nodeAtLeast(version, min = SQLITE_NODE) {
-	const [a = 0, b = 0, c = 0] = version.replace(/^v/, "").split(".").map(Number);
-	const [x = 0, y = 0, z = 0] = min.split(".").map(Number);
-	return a !== x ? a > x : b !== y ? b > y : c >= z;
-}
-function loadSqlite() {
-	if (!nodeAtLeast(process.versions.node)) throw new UsageError(`reeval query needs Node ${SQLITE_NODE} or later for node:sqlite (this is Node ${process.versions.node}).`);
-	const emit = process.emitWarning;
-	process.emitWarning = ((warning, ...rest) => {
-		const text = typeof warning === "string" ? warning : warning.message;
-		if (/SQLite/.test(text)) return;
-		return emit.call(process, warning, ...rest);
-	});
-	try {
-		return ownRequire("node:sqlite");
-	} finally {
-		process.emitWarning = emit;
-	}
-}
-const TABLES = `
-CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
--- The record file each run was read from, and its size and mtime when it was.
-CREATE TABLE files (run_id TEXT PRIMARY KEY, path TEXT NOT NULL, size INTEGER NOT NULL, mtime_ms REAL NOT NULL);
-CREATE TABLE runs (
-  run_id TEXT PRIMARY KEY, recorded INTEGER NOT NULL, status TEXT, started_at TEXT, ended_at TEXT,
-  duration_ms INTEGER, author TEXT, git_sha TEXT, branch TEXT, dirty INTEGER, runner TEXT,
-  ci_provider TEXT, ci_url TEXT, pr_number INTEGER, pr_base TEXT, reeval TEXT, judge_model TEXT,
-  judge_version TEXT, profile TEXT, evals INTEGER, attempts INTEGER, pass INTEGER, fail INTEGER,
-  not_gated INTEGER, infra_error INTEGER, skipped INTEGER
-);
-CREATE TABLE evals (
-  run_id TEXT NOT NULL, key TEXT NOT NULL, id TEXT, slug TEXT, file TEXT, groups TEXT, name TEXT,
-  tags TEXT, fingerprint TEXT, outcome TEXT, pass_at_1 REAL, sources TEXT, family_id TEXT,
-  case_index INTEGER,
-  PRIMARY KEY (run_id, key)
-);
--- Each pooled evaluate.each per run: its cases, and each cell's pass@1 over them (the mean of the
--- cases' pass@1).
-CREATE TABLE families (
-  run_id TEXT NOT NULL, family_id TEXT NOT NULL, file TEXT, groups TEXT, name TEXT,
-  cases INTEGER, ran INTEGER, cell_key TEXT NOT NULL, cell_cases INTEGER, pass INTEGER,
-  counted INTEGER, pass_at_1 REAL, lo REAL, hi REAL, method TEXT, outcome TEXT,
-  PRIMARY KEY (run_id, family_id, cell_key)
-);
--- Every compare-question vote: a pair of sides (arms within a harness, harnesses across an arm)
--- on one run, shown in one order (swapped = 1: b first), and the side picked or 'tie'.
-CREATE TABLE votes (
-  run_id TEXT NOT NULL, eval_key TEXT NOT NULL, question TEXT NOT NULL, cut TEXT, held TEXT,
-  pair_run INTEGER, a TEXT, b TEXT, winner TEXT, swapped INTEGER, reason TEXT
-);
--- Each pair of sides' head-to-head per question: a pair decides when both orders agree (or one
--- ties); a split is a pair whose orders picked opposite sides, split_first those that picked
--- the side shown first both times.
-CREATE TABLE question_pairs_m (
-  run_id TEXT NOT NULL, eval_key TEXT NOT NULL, question TEXT NOT NULL, cut TEXT, held TEXT,
-  a TEXT, b TEXT, pairs INTEGER, a_wins INTEGER, b_wins INTEGER, ties INTEGER, splits INTEGER,
-  splits_first INTEGER
-);
-CREATE TABLE family_lift_m (
-  run_id TEXT NOT NULL, family_id TEXT NOT NULL, name TEXT, harness TEXT, variant TEXT,
-  cell_key TEXT, control TEXT,
-  pairs INTEGER, variant_pass_at_1 REAL, control_pass_at_1 REAL, discordant_vc INTEGER,
-  discordant_cv INTEGER, points REAL, lo REAL, hi REAL, method TEXT, p REAL,
-  within_noise INTEGER, verdict TEXT, min_lift REAL, outcome TEXT, tools_ratio REAL,
-  tools_p REAL, effort_verdict TEXT, agent_s_ratio REAL, agent_s_p REAL, time_verdict TEXT,
-  tokens_ratio REAL, tokens_p REAL, tokens_verdict TEXT
-);
-CREATE TABLE cells (
-  run_id TEXT NOT NULL, eval_key TEXT NOT NULL, key TEXT NOT NULL, role TEXT, variant TEXT,
-  harness TEXT, harness_kind TEXT, model TEXT, reasoning_effort TEXT, environment TEXT,
-  environment_digest TEXT, sandbox TEXT, gate TEXT, gate_pass_rate REAL, fingerprint TEXT,
-  fp_sources TEXT, fp_harness TEXT, fp_environment TEXT, fp_image TEXT, fp_agent_cli TEXT,
-  fp_judge TEXT, fp_context TEXT, runs INTEGER, pass INTEGER, fail INTEGER, infra_error INTEGER,
-  skipped INTEGER, pass_at_1 REAL, outcome TEXT, lift_vs TEXT, lift_points REAL, lift_lo REAL,
-  lift_hi REAL, within_noise INTEGER, min_lift REAL, comparable TEXT,
-  PRIMARY KEY (run_id, eval_key, key)
-);
-CREATE TABLE attempts (
-  run_id TEXT NOT NULL, eval_key TEXT NOT NULL, cell_key TEXT NOT NULL, key TEXT NOT NULL,
-  id TEXT, n INTEGER, seq INTEGER, started_at TEXT, outcome TEXT, error_kind TEXT,
-  error_message TEXT, duration_ms INTEGER, image_id TEXT, turns INTEGER, tools INTEGER,
-  file_edits INTEGER, setup_ms INTEGER, agent_ms INTEGER, checks_ms INTEGER, judge_ms INTEGER,
-  last_text TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER,
-  cache_write_tokens INTEGER, reasoning_tokens INTEGER, served_model TEXT, oom_kills INTEGER,
-  reasoning_effort TEXT, served_reasoning_effort TEXT,
-  PRIMARY KEY (run_id, key)
-);
-CREATE TABLE judgements (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, key TEXT NOT NULL, question TEXT,
-  verdict TEXT, score REAL, threshold REAL, model TEXT, resolved_model TEXT, input_path TEXT,
-  PRIMARY KEY (run_id, attempt_key, key)
-);
-CREATE TABLE environments (
-  run_id TEXT NOT NULL, name TEXT NOT NULL, digest TEXT NOT NULL, parent TEXT, overrides TEXT,
-  PRIMARY KEY (run_id, digest)
-);
-CREATE TABLE env_skills (
-  run_id TEXT NOT NULL, digest TEXT NOT NULL, name TEXT NOT NULL, source TEXT, commit_sha TEXT,
-  sha256 TEXT, placement TEXT
-);
-CREATE TABLE artifacts (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, kind TEXT NOT NULL, path TEXT NOT NULL,
-  sha256 TEXT, bytes INTEGER
-);
--- What the agent could see, by content hash; runtime = 1 for an agent CLI's own session state,
--- declared = 1 for a file the environment declared (its skills' files, rules and config).
-CREATE TABLE attempt_context (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, path TEXT NOT NULL, sha256 TEXT, runtime INTEGER,
-  declared INTEGER
-);
--- Every tool call in each attempt's transcript: its line in transcript.jsonl (from 1), target and
--- class (context, dependency, web, verify or workspace: a heuristic, see tool-class.ts).
-CREATE TABLE tool_calls (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, line INTEGER NOT NULL, turn INTEGER,
-  tool TEXT, target TEXT, ok INTEGER, duration_ms INTEGER, class TEXT
-);
--- Each placed file a tool call named (directly or through a glob), by the call's line.
-CREATE TABLE context_reads (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, line INTEGER NOT NULL, path TEXT NOT NULL
-);
--- Every expect / expect.soft matcher call each attempt made, in call order (seq from 1).
-CREATE TABLE assertions (
-  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, eval_key TEXT NOT NULL, cell_key TEXT NOT NULL,
-  seq INTEGER NOT NULL, label TEXT NOT NULL, labelled INTEGER, matcher TEXT, status TEXT,
-  soft INTEGER, message TEXT, duration_ms INTEGER
-);
--- Each check (assertion label) per cell over its counted attempts; on a variant, its control's too.
-CREATE TABLE cell_checks (
-  run_id TEXT NOT NULL, eval_key TEXT NOT NULL, cell_key TEXT NOT NULL, label TEXT NOT NULL,
-  pass INTEGER, fail INTEGER, error INTEGER, not_run INTEGER, control_pass INTEGER,
-  control_fail INTEGER, control_error INTEGER, control_not_run INTEGER, verdict TEXT
-);
-${DERIVED_TABLES}
-CREATE INDEX assertions_by_attempt ON assertions (run_id, attempt_key);
-CREATE INDEX cells_by_eval ON cells (eval_key, key);
-CREATE INDEX tool_calls_by_attempt ON tool_calls (run_id, attempt_key);
-CREATE INDEX context_by_attempt ON attempt_context (run_id, attempt_key);
-CREATE INDEX context_reads_by_attempt ON context_reads (run_id, attempt_key);
-CREATE INDEX attempts_by_cell ON attempts (run_id, eval_key, cell_key);
-CREATE INDEX env_skills_by_digest ON env_skills (run_id, digest);
-`;
-/** Canned questions about the history, as views to filter. */
-const VIEWS = `
--- Variant against control, per harness, per run.
-CREATE VIEW lift AS
-  SELECT c.run_id, r.started_at, r.branch, c.eval_key, c.harness, c.model, c.variant,
-    c.lift_vs AS control, c.pass AS variant_pass, c.pass + c.fail AS variant_counted,
-    k.pass AS control_pass, k.pass + k.fail AS control_counted, c.pass_at_1 AS variant_pass_at_1,
-    k.pass_at_1 AS control_pass_at_1, c.lift_points AS points,
-    c.lift_lo AS lo, c.lift_hi AS hi, c.within_noise, c.min_lift, c.outcome, c.fingerprint
-  FROM cells c JOIN runs r USING (run_id)
-  JOIN cells k ON k.run_id = c.run_id AND k.eval_key = c.eval_key AND k.key = c.lift_vs
-  WHERE c.role = 'variant';
-
--- Each variant against its control over a pooled evaluate.each's cases, paired by case, per run.
-CREATE VIEW family_lift AS
-  SELECT f.*, r.started_at, r.branch
-  FROM family_lift_m f JOIN runs r USING (run_id);
-
--- Cells with mixed outcomes, pooled over runs whose fingerprints match once agent runtime state is
--- left out; 'flaky' needs FLAKY_MIN_ATTEMPTS counted attempts, else 'insufficient'.
-CREATE VIEW flaky_cells AS SELECT * FROM flaky_m;
-
--- Each run where a cell's fingerprint differs from its previous run: which parts, which context
--- paths, and noise = 1 when only agent runtime state changed (not a real change).
-CREATE VIEW drift AS SELECT * FROM drift_m;
-
--- Tool calls, agent time and tokens per cell, and a variant's against its control in the same run.
-CREATE VIEW effort AS SELECT * FROM effort_m;
-
--- Each pair of arms (cells a and b) on one harness and sandbox, when an eval has two variants or
--- more: pass@1 lift of a over b, effort with its verdicts and separation, and the checks that
--- tell them apart. A variant against its control is here too; gating stays variant vs control.
-CREATE VIEW contrasts AS SELECT * FROM contrasts_m;
-
--- Each compare question's pairs of sides, head to head: wins when both orders agree, and splits
--- when the order decided. The pooled win rate counts a split as a win for each side.
-CREATE VIEW question_pairs AS SELECT * FROM question_pairs_m;
-
--- What a factor (environment, harness, model) did, by evidence tier: controlled (one run),
--- pooled (comparable runs, and across evals), observed (over time), not_measured (one level).
-CREATE VIEW factor_effects AS SELECT * FROM factor_effects_m;
-
--- Whether each attempt read each skill its environment placed, and at which transcript line.
--- A read is a tool whose target is under skills/<name>/, or a dedicated load
--- (OpenCode skill, Goose load_skill) whose target is the skill name.
-CREATE VIEW skill_reads AS
-  SELECT a.run_id, a.eval_key, a.cell_key, a.key AS attempt_key, a.id AS attempt_id, c.variant,
-    s.name AS skill, s.placement,
-    (SELECT MIN(t.line) FROM tool_calls t WHERE t.run_id = a.run_id AND t.attempt_key = a.key
-      AND (t.target LIKE '%skills/' || s.name || '/%'
-        OR (t.tool IN ('skill', 'Skill', 'load_skill') AND t.target = s.name))) AS read_line,
-    (SELECT COUNT(*) FROM tool_calls t WHERE t.run_id = a.run_id AND t.attempt_key = a.key
-      AND (t.target LIKE '%skills/' || s.name || '/%'
-        OR (t.tool IN ('skill', 'Skill', 'load_skill') AND t.target = s.name))) AS reads
-  FROM attempts a
-  JOIN cells c ON c.run_id = a.run_id AND c.eval_key = a.eval_key AND c.key = a.cell_key
-  JOIN env_skills s ON s.run_id = c.run_id AND s.digest = c.environment_digest;
-
--- Tool calls per attempt by class: context (a placed skill, rules file or other placed file, a
--- skill load, an MCP tool of the environment), dependency (node_modules, site-packages, vendor,
--- --help), web, verify (a command the eval's checks run, or test/build/lint/tsc) and workspace.
--- A heuristic: shell commands are split into words and exclusions are not counted.
-CREATE VIEW context_use AS
-  SELECT a.run_id, a.eval_key, a.cell_key, c.environment, a.key AS attempt_key, a.id AS attempt_id,
-    t.class, COUNT(*) AS calls, MIN(t.line) AS first_line,
-    (SELECT x.target FROM tool_calls x WHERE x.run_id = a.run_id AND x.attempt_key = a.key
-      AND x.class = t.class ORDER BY x.line LIMIT 1) AS example
-  FROM tool_calls t
-  JOIN attempts a ON a.run_id = t.run_id AND a.key = t.attempt_key
-  JOIN cells c ON c.run_id = a.run_id AND c.eval_key = a.eval_key AND c.key = a.cell_key
-  GROUP BY a.run_id, a.key, t.class;
-
--- Each file the environment declared (its skills' files, rules), per attempt: how many tool calls
--- named it, directly or through a glob, and the first one's transcript line (null: never read).
-CREATE VIEW skill_files AS
-  SELECT a.run_id, a.eval_key, a.cell_key, c.environment, a.key AS attempt_key,
-    a.id AS attempt_id, x.path,
-    (SELECT COUNT(*) FROM context_reads r WHERE r.run_id = a.run_id AND r.attempt_key = a.key
-      AND r.path = x.path) AS reads,
-    (SELECT MIN(r.line) FROM context_reads r WHERE r.run_id = a.run_id AND r.attempt_key = a.key
-      AND r.path = x.path) AS first_line
-  FROM attempt_context x
-  JOIN attempts a ON a.run_id = x.run_id AND a.key = x.attempt_key
-  JOIN cells c ON c.run_id = a.run_id AND c.eval_key = a.eval_key AND c.key = a.cell_key
-  WHERE x.declared = 1;
-
--- Failed attempts and infra errors (an OOM kill among them) with the cell's harness, model, each
--- of its environment's skills and the label of the first check that failed.
-CREATE VIEW failing_attempts AS
-  SELECT a.run_id, r.started_at, a.eval_key, a.key AS attempt_key, a.cell_key, c.harness,
-    c.model, c.environment, s.name AS skill, a.outcome, a.error_kind, a.error_message,
-    a.duration_ms, a.oom_kills,
-    (SELECT x.label FROM assertions x WHERE x.run_id = a.run_id AND x.attempt_key = a.key
-      AND x.status = 'fail' ORDER BY x.seq LIMIT 1) AS first_failed_check
-  FROM attempts a JOIN runs r USING (run_id)
-  JOIN cells c ON c.run_id = a.run_id AND c.eval_key = a.eval_key AND c.key = a.cell_key
-  LEFT JOIN env_skills s ON s.run_id = c.run_id AND s.digest = c.environment_digest
-  WHERE a.outcome IN ('fail', 'infra_error');
-
--- Each check of a variant cell beside its control's: whether it tells them apart.
-CREATE VIEW check_discrimination AS
-  SELECT k.run_id, k.eval_key, c.harness, c.variant, c.key AS cell_key, k.label,
-    k.pass AS variant_pass, k.fail AS variant_fail, k.not_run AS variant_not_run,
-    k.control_pass, k.control_fail, k.control_not_run, k.verdict
-  FROM cell_checks k
-  JOIN cells c ON c.run_id = k.run_id AND c.eval_key = k.eval_key AND c.key = k.cell_key
-  WHERE c.role = 'variant' AND k.verdict IS NOT NULL;
-
--- Each check (expect label) per cell per run, on every cell (control and variant alike), over the
--- cell's counted attempts. rate = pass / (pass + fail): an error (the matcher couldn't answer) and
--- a not-run (a hard expect before it failed) are left out; null when neither passed nor failed.
-CREATE VIEW check_rates AS
-  SELECT k.run_id, k.eval_key, k.cell_key, c.harness, c.environment, c.role, k.label, k.pass,
-    k.fail, k.error, k.not_run, CAST(k.pass AS REAL) / NULLIF(k.pass + k.fail, 0) AS rate
-  FROM cell_checks k
-  JOIN cells c ON c.run_id = k.run_id AND c.eval_key = k.eval_key AND c.key = k.cell_key;
-
--- One eval per run: outcome and pass@1, with the branch and pull request.
-CREATE VIEW eval_trend AS
-  SELECT e.eval_key, r.run_id, r.started_at, r.branch, r.pr_number, r.recorded, e.outcome,
-    e.pass_at_1, e.fingerprint
-  FROM (SELECT key AS eval_key, * FROM evals) e JOIN runs r USING (run_id);
-
--- Each judge question's pass rate per cell per run, where it differs from that cell's last run.
-CREATE VIEW verdict_flips AS
-  WITH rates AS (
-    SELECT j.run_id, a.eval_key, a.cell_key, j.key AS judgement_key, j.question,
-      AVG(j.verdict = 'pass') AS pass_rate, COUNT(*) AS n
-    FROM judgements j JOIN attempts a ON a.run_id = j.run_id AND a.key = j.attempt_key
-    GROUP BY j.run_id, a.eval_key, a.cell_key, j.key
-  ), ordered AS (
-    SELECT *, LAG(pass_rate) OVER w AS prev_pass_rate, LAG(run_id) OVER w AS prev_run_id
-    FROM rates WINDOW w AS (PARTITION BY eval_key, cell_key, judgement_key ORDER BY run_id)
-  )
-  SELECT run_id, prev_run_id, eval_key, cell_key, judgement_key, question, prev_pass_rate,
-    pass_rate, n
-  FROM ordered WHERE prev_run_id IS NOT NULL AND pass_rate IS NOT prev_pass_rate;
-`;
-const VIEW_NAMES = [
-	"lift",
-	"family_lift",
-	"effort",
-	"contrasts",
-	"question_pairs",
-	"factor_effects",
-	"skill_reads",
-	"context_use",
-	"skill_files",
-	"flaky_cells",
-	"drift",
-	"failing_attempts",
-	"eval_trend",
-	"verdict_flips",
-	"check_discrimination",
-	"check_rates"
-];
-const json = (value) => JSON.stringify(value);
-/** The agent CLI's home config, which its harness writes (MCP servers, settings), not the eval. */
-const HARNESS_CONFIG = /^~\/.*(^|\/)(config\.(toml|ya?ml|json)|settings(\.local)?\.json|mcp\.json)$/;
-/**
-* A placed file the environment declared: under one of its skills, or a rules file outside any
-* skills directory. Not an agent CLI's own state or home config, its bundled skills or the
-* adapter's skill index.
-*/
-const declaredContext = (path, skills) => !isRuntimeState(path) && !path.endsWith("/.ai-sdk-harness-skills.json") && !HARNESS_CONFIG.test(path) && (skills.some((s) => path.includes(`skills/${s}/`)) || !/(^|\/)skills(-[^/]+)?\//.test(path));
-/** `attempts.last_text` is the agent's final message, capped: most "why" questions start there. */
-const LAST_TEXT_LIMIT = 2048;
-/** The tool calls in a transcript.jsonl, numbered by line from 1; lines that aren't JSON are skipped. */
-function toolCalls(transcript) {
-	const calls = [];
-	transcript.split("\n").forEach((line, i) => {
-		if (!line.trim()) return;
-		let event;
-		try {
-			event = JSON.parse(line);
-		} catch {
-			return;
-		}
-		if (event?.type !== "tool") return;
-		calls.push({
-			line: i + 1,
-			turn: typeof event.turn === "number" ? event.turn : null,
-			tool: String(event.tool ?? ""),
-			target: toolTarget(event.input, String(event.tool ?? "")),
-			ok: event.ok !== false,
-			durationMs: typeof event.durationMs === "number" ? event.durationMs : null
-		});
-	});
-	return calls;
-}
-/** `classifyCall`, but a call its heuristic can't read counts as workspace: one transcript line can't stop the sync. */
-function classifyOrWorkspace(tool, target, ctx) {
-	try {
-		return classifyCall(tool, target, ctx);
-	} catch {
-		return {
-			class: "workspace",
-			files: []
-		};
-	}
-}
-/**
-* What a cell's results can be pooled on across runs: its fingerprint parts, with the context
-* part replaced by the context files that aren't an agent CLI's own runtime state.
-*/
-function comparableFingerprint(cell, attempts) {
-	const { context: _context, ...parts } = cell.fingerprintParts;
-	const files = /* @__PURE__ */ new Map();
-	for (const a of attempts) {
-		if (a.cell !== cell.key) continue;
-		for (const c of a.context) if (!isRuntimeState(c.path)) files.set(c.path, c.sha256);
-	}
-	return sha256(json({
-		parts,
-		context: [...files].sort(([a], [b]) => a < b ? -1 : 1)
-	}));
-}
-function insertRun(db, record, recorded, transcripts) {
-	const run = (sql, ...values) => db.prepare(sql).run(...values);
-	const { runner, summary, git } = record;
-	run(`INSERT INTO runs VALUES (${Array(26).fill("?").join(", ")})`, record.runId, recorded ? 1 : 0, record.status, record.startedAt, record.endedAt, record.durationMs, record.author, git?.sha ?? null, git?.branch ?? null, git ? git.dirty ? 1 : 0 : null, runner.kind, runner.kind === "ci" ? runner.provider : null, runner.kind === "ci" ? runner.runUrl : null, runner.kind === "ci" ? runner.pr?.number ?? null : null, runner.kind === "ci" ? runner.pr?.baseRef ?? null : null, record.stack.reeval, record.stack.judge.model, record.stack.judge.version, record.profile?.name ?? null, summary.evals, summary.attempts, summary.pass, summary.fail, summary.notGated, summary.infraError, summary.skipped);
-	for (const env of record.environments) {
-		run("INSERT OR IGNORE INTO environments VALUES (?, ?, ?, ?, ?)", record.runId, env.name, env.digest, env.parent, json(env.overrides));
-		for (const s of env.skills) run("INSERT INTO env_skills VALUES (?, ?, ?, ?, ?, ?, ?)", record.runId, env.digest, s.name, s.source, s.commit, s.sha256, s.placement);
-	}
-	const envOf = new Map(record.environments.map((env) => [env.digest, env]));
-	for (const e of record.evals) {
-		const cellEnv = new Map(e.cells.map((c) => [c.key, c.environmentDigest ?? ""]));
-		run(`INSERT INTO evals VALUES (${Array(14).fill("?").join(", ")})`, record.runId, e.key, e.id, e.slug, e.file, json(e.group), e.name, json(e.tags), e.fingerprint, e.outcome, e.passRate, json(e.sources), e.family?.id ?? null, e.family?.case ?? null);
-		for (const c of e.cells) {
-			const p = c.fingerprintParts;
-			run(`INSERT INTO cells VALUES (${Array(36).fill("?").join(", ")})`, record.runId, e.key, c.key, c.role, c.variant ?? null, c.harness, c.harnessKind, c.model, c.effort ?? null, c.environment, c.environmentDigest, c.sandbox, typeof c.gate === "string" ? c.gate : "passRate", typeof c.gate === "string" ? null : c.gate.passRate, c.fingerprint, p.sources, p.harness, p.environment, p.image, p.agentCli, p.judge, p.context, c.runs, c.pass, c.fail, c.infraError, c.skipped, c.passRate, c.outcome, c.lift?.vs ?? null, c.lift?.points ?? null, c.lift?.interval.lo ?? null, c.lift?.interval.hi ?? null, c.lift ? c.lift.withinNoise ? 1 : 0 : null, c.lift?.minLift ?? null, comparableFingerprint(c, e.attempts));
-			for (const k of c.checks ?? []) run(`INSERT INTO cell_checks VALUES (${Array(13).fill("?").join(", ")})`, record.runId, e.key, c.key, k.label, k.pass, k.fail, k.error, k.notRun, k.control?.pass ?? null, k.control?.fail ?? null, k.control?.error ?? null, k.control?.notRun ?? null, k.verdict ?? null);
-		}
-		for (const answer of e.answers ?? []) {
-			for (const v of answer.votes) run(`INSERT INTO votes VALUES (${Array(11).fill("?").join(", ")})`, record.runId, e.key, answer.question, v.cut, v.harness ?? v.arm ?? null, v.run, v.a, v.b, v.winner, v.swapped ? 1 : 0, v.reason ?? null);
-			for (const t of pairTallies(answer.votes)) run(`INSERT INTO question_pairs_m VALUES (${Array(13).fill("?").join(", ")})`, record.runId, e.key, answer.question, t.cut, t.held, t.a, t.b, t.pairs, t.aWins, t.bWins, t.ties, t.splits, t.splitsFirst);
-		}
-		for (const a of e.attempts) {
-			run(`INSERT INTO attempts VALUES (${Array(30).fill("?").join(", ")})`, record.runId, e.key, a.cell, a.key, a.id, a.n, a.seq, a.startedAt, a.outcome, a.error?.kind ?? null, a.error?.message ?? null, a.durationMs, a.imageId, a.turns.length, a.activity.tools, a.activity.fileEdits, a.timings.setupMs, a.timings.agentMs, a.timings.checksMs, a.timings.judgeMs, a.turns.at(-1)?.text.slice(0, 2048) ?? null, a.usage?.input ?? null, a.usage?.output ?? null, a.usage?.cacheRead ?? null, a.usage?.cacheWrite ?? null, a.usage?.reasoning ?? null, a.turns.findLast((t) => t.model)?.model ?? null, a.error?.resource?.cause === "oom" ? a.error.resource.kills : 0, a.effort ?? null, a.servedEffort ?? null);
-			const env = envOf.get(cellEnv.get(a.cell) ?? "");
-			const skills = env?.skills.map((x) => x.name) ?? [];
-			for (const c of a.context) run("INSERT INTO attempt_context VALUES (?, ?, ?, ?, ?, ?)", record.runId, a.key, c.path, c.sha256, isRuntimeState(c.path) ? 1 : 0, declaredContext(c.path, skills) ? 1 : 0);
-			for (const [i, x] of (a.assertions ?? []).entries()) run(`INSERT INTO assertions VALUES (${Array(12).fill("?").join(", ")})`, record.runId, a.key, e.key, a.cell, i + 1, x.label, x.labelled ? 1 : 0, x.matcher, x.status, x.soft ? 1 : 0, x.message ?? null, x.durationMs ?? null);
-			const transcript = transcripts.get(a.key);
-			const ctx = {
-				skills,
-				files: a.context.map((c) => c.path).filter((p) => declaredContext(p, skills)),
-				mcp: env?.mcp ?? [],
-				verify: a.checks.map((c) => c.command)
-			};
-			for (const t of transcript ? toolCalls(transcript) : []) {
-				const call = classifyOrWorkspace(t.tool, t.target, ctx);
-				run("INSERT INTO tool_calls VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", record.runId, a.key, t.line, t.turn, t.tool, t.target, t.ok ? 1 : 0, t.durationMs, call.class);
-				for (const path of call.files) run("INSERT INTO context_reads VALUES (?, ?, ?, ?)", record.runId, a.key, t.line, path);
-			}
-			for (const j of a.judgements) run("INSERT OR IGNORE INTO judgements VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", record.runId, a.key, j.key, j.question, j.verdict, j.score, j.threshold, j.model, j.resolvedModel ?? null, a.files.judgeInput?.path ?? null);
-			for (const [kind, ref] of Object.entries(a.files)) {
-				if (ref == null || Array.isArray(ref) || typeof ref.path !== "string") continue;
-				run("INSERT INTO artifacts VALUES (?, ?, ?, ?, ?, ?)", record.runId, a.key, kind, ref.path, ref.sha256, ref.bytes);
-			}
-			a.checks.forEach((c, i) => {
-				if (!c.log) return;
-				run("INSERT INTO artifacts VALUES (?, ?, ?, ?, ?, ?)", record.runId, a.key, `check:${i + 1}`, c.log.path, c.log.sha256, c.log.bytes);
-			});
-		}
-	}
-	for (const f of record.families ?? []) {
-		for (const r of f.rates) run(`INSERT INTO families VALUES (${Array(16).fill("?").join(", ")})`, record.runId, f.id, f.file, json(f.group), f.name, f.cases, f.ran, r.cell, r.cases, r.pass, r.counted, r.rate, r.interval.lo, r.interval.hi, r.interval.method, f.outcome);
-		for (const l of f.lifts) {
-			const e = l.effort;
-			const cell = record.evals.find((x) => x.family?.id === f.id && x.cells.some((c) => c.key === l.variant))?.cells.find((c) => c.key === l.variant);
-			run(`INSERT INTO family_lift_m VALUES (${Array(30).fill("?").join(", ")})`, record.runId, f.id, f.name, cell?.harness ?? null, cell?.variant ?? cell?.environment ?? null, l.variant, l.vs, l.pairs, l.variantRate, l.controlRate, l.discordant?.variantOnly ?? null, l.discordant?.controlOnly ?? null, l.points, l.interval.lo, l.interval.hi, l.interval.method, l.p, l.withinNoise ? 1 : 0, l.verdict, l.minLift ?? null, l.outcome, e?.tools.ratio ?? null, e?.tools.p ?? null, e?.tools.verdict ?? null, e?.agentMs.ratio ?? null, e?.agentMs.p ?? null, e?.agentMs.verdict ?? null, e?.tokens?.ratio ?? null, e?.tokens?.p ?? null, e?.tokens?.verdict ?? null);
-		}
-	}
-}
-const DATA_TABLES = [
-	"runs",
-	"evals",
-	"families",
-	"family_lift_m",
-	"votes",
-	"question_pairs_m",
-	"cells",
-	"attempts",
-	"judgements",
-	"environments",
-	"env_skills",
-	"artifacts",
-	"attempt_context",
-	"tool_calls",
-	"context_reads",
-	"assertions",
-	"cell_checks"
-];
-function removeRun(db, runId) {
-	for (const table of DATA_TABLES) db.prepare(`DELETE FROM ${table} WHERE run_id = ?`).run(runId);
-	db.prepare("DELETE FROM files WHERE run_id = ?").run(runId);
-}
-function freshSchema(db) {
-	const objects = rowsOf(db.prepare("SELECT type, name FROM sqlite_schema WHERE type IN ('table', 'view')"));
-	for (const o of objects) {
-		if (o.name.startsWith("sqlite_")) continue;
-		db.exec(`DROP ${o.type === "view" ? "VIEW" : "TABLE"} IF EXISTS "${o.name}"`);
-	}
-	db.exec(TABLES);
-	db.exec(VIEWS);
-	db.prepare("INSERT INTO meta VALUES (?, ?), (?, ?)").run("version", String(DB_VERSION), "build", String(BUILD));
-}
-function current(db) {
-	try {
-		const rows = rowsOf(db.prepare("SELECT key, value FROM meta"));
-		const meta = Object.fromEntries(rows.map((r) => [r.key, r.value]));
-		return meta.version === String(DB_VERSION) && meta.build === String(BUILD);
-	} catch {
-		return false;
-	}
-}
-/** Each attempt's transcript.jsonl, by attempt key, where the run kept it. */
-async function readTranscripts(dir, record) {
-	const out = /* @__PURE__ */ new Map();
-	for (const e of record.evals) for (const a of e.attempts) {
-		const ref = a.files.transcript;
-		if (!ref) continue;
-		const text = await readFile(join(dir, record.runId, ...ref.path.split("/")), "utf8").catch(() => null);
-		if (text !== null) out.set(a.key, text);
-	}
-	return out;
-}
-/**
-* Brings the projection up to date with the record files: recorded runs in `historyDir` win over
-* the same run's scratch copy in `.reeval/runs`. Only new, changed or removed files are touched.
-*/
-async function sync(db, root, historyDir) {
-	const rebuilt = !current(db);
-	if (rebuilt) freshSchema(db);
-	const wanted = /* @__PURE__ */ new Map();
-	for (const [dir, recorded] of [[historyDir, true], [scratchDir(root), false]]) for (const name of await recordNames(dir) ?? []) {
-		const runId = name.slice(0, -5);
-		if (!RUN_ID.test(runId) || wanted.has(runId)) continue;
-		wanted.set(runId, {
-			path: join(dir, name),
-			recorded
-		});
-	}
-	const known = new Map(rowsOf(db.prepare("SELECT run_id, path, size, mtime_ms FROM files")).map((r) => [r.run_id, r]));
-	let added = 0;
-	let removed = 0;
-	db.exec("BEGIN");
-	try {
-		for (const runId of known.keys()) if (!wanted.has(runId)) {
-			removeRun(db, runId);
-			removed++;
-		}
-		for (const [runId, { path, recorded }] of wanted) {
-			const info = await stat(path);
-			const rel = relativeFile(root, path);
-			const had = known.get(runId);
-			if (had && had.path === rel && had.size === info.size && had.mtime_ms === info.mtimeMs) continue;
-			let record;
-			try {
-				record = await readRecord(path);
-			} catch (error) {
-				warnUnreadable(path, error);
-				continue;
-			}
-			if (had) removeRun(db, runId);
-			insertRun(db, record, recorded, await readTranscripts(dirname(path), record));
-			db.prepare("INSERT INTO files VALUES (?, ?, ?, ?)").run(runId, rel, info.size, info.mtimeMs);
-			added++;
-		}
-		if (added || removed || rebuilt) deriveFacts(db);
-		db.exec("COMMIT");
-	} catch (error) {
-		db.exec("ROLLBACK");
-		throw error;
-	}
-	return {
-		runs: wanted.size,
-		added,
-		removed,
-		rebuilt
-	};
-}
-/** Opens `.reeval/history.db`, synced with the records; statements after this are read-only. */
-async function openHistoryDb(root, historyDir, options = {}) {
-	const { DatabaseSync } = loadSqlite();
-	const path = historyDbPath(root);
-	await mkdir(dirname(path), { recursive: true });
-	const writer = new DatabaseSync(path);
-	let synced;
-	try {
-		writer.exec("PRAGMA busy_timeout = 5000");
-		if (options.rebuild) writer.exec("DROP TABLE IF EXISTS meta");
-		synced = await sync(writer, root, historyDir);
-	} finally {
-		writer.close();
-	}
-	const db = new DatabaseSync(path, { readOnly: true });
-	db.exec("PRAGMA busy_timeout = 5000");
-	return {
-		sync: synced,
-		query(sql, params = []) {
-			try {
-				const statement = db.prepare(sql);
-				const rows = Array.isArray(params) ? statement.all(...params) : statement.all(params);
-				return {
-					columns: typeof statement.columns === "function" ? statement.columns().map((c) => c.name) : Object.keys(rows[0] ?? {}),
-					rows
-				};
-			} catch (error) {
-				const message = error.message;
-				throw new UsageError(/readonly|read-only/i.test(message) ? `reeval query is read-only: .reeval/history.db is a projection of the run records (${message})` : `reeval query: ${message}`);
-			}
-		},
-		schema() {
-			return rowsOf(db.prepare(`SELECT name, type FROM sqlite_schema WHERE type IN ('table', 'view') AND name NOT IN ('meta', 'files', 'family_lift_m', ${DERIVED.map((d) => `'${d}'`).join(", ")}) AND name NOT LIKE 'sqlite_%' ORDER BY type, name`)).map((o) => ({
-				...o,
-				columns: rowsOf(db.prepare(`PRAGMA table_info("${o.name}")`)).map((c) => c.name)
-			}));
-		},
-		close: () => db.close()
-	};
-}
-//#endregion
-export { historyDbPath as a, toolCalls as c, comparableFingerprint as i, TOOL_CLASSES as l, SQLITE_NODE as n, nodeAtLeast as o, VIEW_NAMES as r, openHistoryDb as s, LAST_TEXT_LIMIT as t };
-
-//# sourceMappingURL=db-DfhipHEF.js.map