reeval 0.0.1

package/dist/db-DxDzMhtB.js

@@ -0,0 +1,827 @@
+import { t as UsageError } from "./errors-CSxfJ4qu.js";
+import { t as BUILD_ID, u as ownRequire } from "./root-CFDjpWuc.js";
+import { t as RUN_ID } from "./paths-CBvm6pap.js";
+import { c as relativeFile, l as sha256 } from "./ids-Bp6ut7ZD.js";
+import { n as isRuntimeState } from "./context-loi9OCZv.js";
+import { P as effortOf, j as contrastEffort } from "./model-CDL98xue.js";
+import { o as round3, s as wilson, t as liftInterval } from "./stats-BNAHlNMD.js";
+import { f as scratchDir, l as recordNames, o as readRecord, p as warnUnreadable } from "./files-D2-qn_Dl.js";
+import { dirname, join } from "node:path";
+import { mkdir, readFile, stat } from "node:fs/promises";
+/** 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,
+  control_key TEXT, control_n INTEGER, control_tools_median REAL, control_agent_s_median REAL,
+  tools_ratio REAL, agent_s_ratio REAL, agent_s_delta REAL, tools_p REAL, agent_s_p REAL,
+  separated INTEGER, verdict TEXT, time_verdict 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,
+  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,
+  rate 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 DERIVED = [
+	"effort_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: v.counted && c.counted ? noise ? "noise" : "effect" : "insufficient"
+	};
+}
+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
+	};
+}
+/** 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
+	};
+}
+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 = db.prepare(`PRAGMA table_info("${table}")`).all().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 = db.prepare("SELECT c.*, r.started_at FROM cells c JOIN runs r USING (run_id) ORDER BY c.run_id, c.rowid").all();
+	const attempts = db.prepare("SELECT run_id, eval_key, cell_key, key, outcome, error_kind, tools, agent_ms, file_edits FROM attempts ORDER BY run_id, rowid").all();
+	const nearThreshold = new Set(db.prepare(`SELECT DISTINCT run_id, attempt_key FROM judgements WHERE verdict = 'fail' AND ABS(score - threshold) <= ${JUDGE_MARGIN}`).all().map((r) => `${r.run_id}\0${r.attempt_key}`));
+	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;
+		samples.set(id, [...samples.get(id) ?? [], {
+			tools: a.tools,
+			agentMs: a.agent_ms,
+			fileEdits: a.file_edits
+		}]);
+	}
+	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);
+	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,
+			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,
+			tools_ratio: r4(vs?.toolsRatio ?? null),
+			agent_s_ratio: r4(vs?.agentMsRatio ?? null),
+			agent_s_delta: vs ? s1(vs.agentMsDelta) : null,
+			tools_p: r4(vs?.toolsP ?? null),
+			agent_s_p: r4(vs?.agentMsP ?? null),
+			separated: vs ? vs.separated ? 1 : 0 : null,
+			verdict: vs?.verdict ?? null,
+			time_verdict: vs?.timeVerdict ?? null
+		};
+	}));
+	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) ?? [], {
+			v,
+			c
+		}]);
+	}
+	for (const [id, list] of strata) {
+		if (list.length < 2) continue;
+		const [factor, level, baseline, context] = id.split("\0");
+		const v = merge(list.map((s) => s.v));
+		const c = merge(list.map((s) => s.c));
+		factorRows.push({
+			...head({
+				factor,
+				level,
+				baseline,
+				context
+			}),
+			tier: "pooled",
+			run_id: null,
+			eval_key: null,
+			strata: list.length,
+			runs: null,
+			...passCols(v, c),
+			...pooledEffort(list.map((s) => contrastEffort(s.v.samples, s.c.samples))),
+			note: "pass rate: summed counts; effort: an effect in at least 2/3 of strata"
+		});
+	}
+	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 contextOf.all(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";
+			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,
+				...passCols(side(cur), side(prev)),
+				...effortCols(contrastEffort(side(cur).samples, side(prev).samples)),
+				note: 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 cause = infra > 0 || failing.some((a) => a.error_kind === "infra") ? "infra" : failing.some((a) => nearThreshold.has(`${a.run_id}\0${a.key}`)) ? "judge" : "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,
+			rate: 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 = 2;
+/** 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, es 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_rate REAL, sources TEXT,
+  PRIMARY KEY (run_id, key)
+);
+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, 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_rate 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,
+  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.
+CREATE TABLE attempt_context (
+  run_id TEXT NOT NULL, attempt_key TEXT NOT NULL, path TEXT NOT NULL, sha256 TEXT, runtime INTEGER
+);
+-- Every tool call in each attempt's transcript: its line in transcript.jsonl (from 1) and target.
+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
+);
+${DERIVED_TABLES}
+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 attempts_by_cell ON attempts (run_id, eval_key, cell_key);
+CREATE INDEX env_skills_by_digest ON env_skills (run_id, digest);
+`;
+/** The canned questions of docs/history-observability-review.md §2, 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.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';
+
+-- 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 and agent time per cell, and a variant's against its control in the same run.
+CREATE VIEW effort AS SELECT * FROM effort_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.
+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 || '/%') 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 || '/%') 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;
+
+-- Failed attempts with the cell's harness, model and each of its environment's skills.
+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.error_kind, a.error_message, a.duration_ms
+  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 = 'fail';
+
+-- One eval per run: outcome and pass rate, 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_rate, 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",
+	"effort",
+	"factor_effects",
+	"skill_reads",
+	"flaky_cells",
+	"drift",
+	"failing_attempts",
+	"eval_trend",
+	"verdict_flips"
+];
+const json = (value) => JSON.stringify(value);
+/** `attempts.last_text` is the agent's final message, capped: most "why" questions start there. */
+const LAST_TEXT_LIMIT = 2048;
+/** A tool call's target: its path, pattern, command or URL, else its input, capped. */
+function toolTarget(input) {
+	if (typeof input !== "object" || input === null) return String(input ?? "").slice(0, 300);
+	const i = input;
+	for (const key of [
+		"path",
+		"file_path",
+		"filePath",
+		"pattern",
+		"glob_pattern",
+		"command",
+		"url",
+		"query"
+	]) if (typeof i[key] === "string") return i[key].slice(0, 300);
+	return JSON.stringify(input).slice(0, 300);
+}
+/** 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),
+			ok: event.ok !== false,
+			durationMs: typeof event.durationMs === "number" ? event.durationMs : null
+		});
+	});
+	return calls;
+}
+/**
+* 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.es, 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);
+	}
+	for (const e of record.evals) {
+		run(`INSERT INTO evals VALUES (${Array(12).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));
+		for (const c of e.cells) {
+			const p = c.fingerprintParts;
+			run(`INSERT INTO cells VALUES (${Array(35).fill("?").join(", ")})`, record.runId, e.key, c.key, c.role, c.variant ?? null, c.harness, c.harnessKind, c.model, 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 a of e.attempts) {
+			run(`INSERT INTO attempts VALUES (${Array(27).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);
+			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);
+			const transcript = transcripts.get(a.key);
+			for (const t of transcript ? toolCalls(transcript) : []) run("INSERT INTO tool_calls VALUES (?, ?, ?, ?, ?, ?, ?, ?)", record.runId, a.key, t.line, t.turn, t.tool, t.target, t.ok ? 1 : 0, t.durationMs);
+			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 (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);
+			});
+		}
+	}
+}
+const DATA_TABLES = [
+	"runs",
+	"evals",
+	"cells",
+	"attempts",
+	"judgements",
+	"environments",
+	"env_skills",
+	"artifacts",
+	"attempt_context",
+	"tool_calls"
+];
+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 = db.prepare("SELECT type, name FROM sqlite_schema WHERE type IN ('table', 'view')").all();
+	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 = db.prepare("SELECT key, value FROM meta").all();
+		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(db.prepare("SELECT run_id, path, size, mtime_ms FROM files").all().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 = 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 db.prepare(`SELECT name, type FROM sqlite_schema WHERE type IN ('table', 'view') AND name NOT IN ('meta', 'files', ${DERIVED.map((d) => `'${d}'`).join(", ")}) AND name NOT LIKE 'sqlite_%' ORDER BY type, name`).all().map((o) => ({
+				...o,
+				columns: db.prepare(`PRAGMA table_info("${o.name}")`).all().map((c) => c.name)
+			}));
+		},
+		close: () => db.close()
+	};
+}
+//#endregion
+export { historyDbPath as a, toolCalls as c, comparableFingerprint as i, SQLITE_NODE as n, nodeAtLeast as o, VIEW_NAMES as r, openHistoryDb as s, LAST_TEXT_LIMIT as t };
+
+//# sourceMappingURL=db-DxDzMhtB.js.map