reeval 0.10.0 → 0.12.0

package/dist/commands-CjpGBUWr.js

@@ -0,0 +1,666 @@
+import { a as fromCwd, l as sha256 } from "./ids-Bp6ut7ZD.js";
+import { u as hasAnalysisModel } from "./config-Dv5MG7Rp.js";
+import { r as fenced } from "./text-CrVy5ioL.js";
+import { n as gitText, t as git } from "./git-DhykwgKF.js";
+import { St as compare, bt as addedRow, tt as effortChangeLabel, wt as stackChanges } from "./model-CWlAqmbU.js";
+import { l as suiteResult } from "./suite-C8sw2pox.js";
+import { a as fromModel } from "./insights-B2Xmhz9o.js";
+import { _ as t, a as assertionOf, c as errorKind, d as labeller, f as plural, h as show, l as errorText, m as renderBlocks, n as renderSummary, o as checkCount, s as checkLabel, u as evalBlock, v as table } from "./summary-0oQNGskv.js";
+import { a as listRuns, d as recordRun, p as scratchDir, s as readRecord } from "./files-B-eUpCZ1.js";
+import { t as colors } from "./colors-QV9dFVhN.js";
+import { a as pickBaseline, i as history, n as formatHistory, o as resolveRun, r as formatShow, s as unreachable } from "./views-BoUoX4_A.js";
+import { i as runInsightsFile, n as readInsights } from "./files-BsQbYz2i.js";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/ui/compare-layout.ts
+const WORD = {
+	regressed: "regressed",
+	fixed: "fixed",
+	drift: "can't compare",
+	infra: "infra error",
+	added: "new",
+	removed: "removed",
+	same: "same"
+};
+/** The tally's order: what needs a look first. */
+const TALLY = [
+	"regressed",
+	"fixed",
+	"drift",
+	"infra",
+	"added",
+	"removed",
+	"same"
+];
+const paintStatus = (c, s) => s === "regressed" ? c.red : s === "fixed" ? c.green : s === "same" ? c.dim : c.yellow;
+const OUTCOME = {
+	pass: "pass",
+	fail: "fail",
+	infra_error: "infra error",
+	cancelled: "cancelled",
+	skipped: "skipped"
+};
+const paintOutcome = (c, o) => o === "pass" ? c.green : o === "fail" ? c.red : o === "infra_error" || o === "cancelled" ? c.yellow : c.dim;
+/** One side's outcome as `reeval show` reads it: a fail the interrupt caused is `cancelled`. */
+const sideOutcome = (row, side) => row.cancelled?.includes(side) ? "cancelled" : row[side];
+/**
+* Every eval and family case in a run, by eval id, in file-path then source order. A case is
+* given as an eval of its own, its name the family's with the case filled in.
+*/
+function unitsOf(suite) {
+	const out = /* @__PURE__ */ new Map();
+	for (const file of suite.files) for (const e of [...file.evals].sort((a, b) => a.order - b.order)) {
+		if (!e.cases) {
+			out.set(e.id, {
+				file: file.path,
+				result: e
+			});
+			continue;
+		}
+		for (const k of e.cases) out.set(k.id, {
+			file: file.path,
+			result: caseAsEval(e, k)
+		});
+	}
+	return out;
+}
+const caseAsEval = (family, k) => ({
+	...family,
+	path: k.path,
+	id: k.id,
+	name: k.name,
+	template: null,
+	order: k.order,
+	family: false,
+	outcome: k.outcome,
+	cells: k.cells,
+	cases: null,
+	pooled: null,
+	questions: []
+});
+/**
+* The rows file by file, in head's source order, each eval only base has placed after the eval
+* before it in base's, so a removed eval sits where it was (beside the one renamed from it).
+*/
+function ordered(rows, units) {
+	const byId = new Map(rows.map((r) => [r.id, r]));
+	const all = [...units.head.values(), ...units.base.values()];
+	const files = [...new Set(all.map((u) => u.file))].sort();
+	const out = [];
+	for (const file of files) {
+		const inFile = (side) => [...side].filter(([id, u]) => u.file === file && byId.has(id));
+		const ids = inFile(units.head).map(([id]) => id);
+		let at = -1;
+		for (const [id] of inFile(units.base)) {
+			const i = ids.indexOf(id);
+			if (i >= 0) at = i;
+			else ids.splice(++at, 0, id);
+		}
+		for (const id of ids) {
+			const unit = units.head.get(id) ?? units.base.get(id);
+			out.push({
+				row: byId.get(id),
+				...unit ? { unit } : {}
+			});
+		}
+	}
+	const seen = new Set(out.map((e) => e.row.id));
+	for (const row of rows) if (!seen.has(row.id)) out.push({ row });
+	return out;
+}
+const nameOf = (row, unit) => {
+	if (!unit) return row.id;
+	const e = unit.result;
+	return `${e.group.length ? `${e.group.join(" › ")} › ` : ""}${e.name}`;
+};
+const headLine = (word, name) => `${show(word)}${" ".repeat(Math.max(2, 17 - word.text.length))}${name}`;
+/**
+* A check's state in one cell. A comparable eval runs the same checks on both sides, so a check
+* the cell never recorded is one no attempt reached: not run, never a failure.
+*/
+function stateOf(k) {
+	if (!k || k.outcome.status === "not run") return "not run";
+	return k.outcome.failed + k.outcome.errored > 0 ? "fail" : "pass";
+}
+/** A check's side of a flip: its state, or its counts when a side answered it more than once. */
+function sideText(k, counts) {
+	const state = stateOf(k);
+	return counts && k && state !== "not run" ? checkCount(k, false) : state;
+}
+const answered = (k) => k?.outcome.status === "ran" ? k.outcome.passed + k.outcome.failed + k.outcome.errored : 0;
+/** Every check label either cell has, head's first. */
+const labelsOf = (base, head) => [...new Set([...head.checks, ...base.checks].map((k) => k.label))];
+/**
+* A regressed cell: each check head didn't pass, as `pass → fail` (with its assertion) or `not
+* run`, then the errors no check explains and how many more passed.
+*/
+function regressedItems(c, base, head, indent) {
+	const items = [];
+	let passed = 0;
+	for (const label of labelsOf(base, head)) {
+		const h = head.checks.find((k) => k.label === label);
+		const b = base.checks.find((k) => k.label === label);
+		const state = stateOf(h);
+		if (state === "pass") {
+			passed++;
+			continue;
+		}
+		if (state === "not run") {
+			items.push({
+				indent,
+				cells: [checkLabel(label), t("not run", c.dim)]
+			});
+			continue;
+		}
+		const counts = answered(h) > 1 || answered(b) > 1;
+		const was = stateOf(b) === "fail" && !counts ? null : sideText(b, counts);
+		const now = sideText(h, counts);
+		items.push({
+			indent,
+			cells: [checkLabel(label), t(was ? `${was} → ${now}` : now, c.red)]
+		});
+		const assertion = h ? assertionOf(h) : "";
+		if (assertion) items.push({
+			indent: indent + 2,
+			free: t(assertion, c.dim)
+		});
+	}
+	for (const err of head.errors) items.push({
+		indent,
+		cells: [errorKind(err), t(errorText(err), c.dim)]
+	});
+	if (passed && items.length) items.push({
+		indent,
+		free: t(`+${passed} more passed`, c.dim)
+	});
+	return items;
+}
+/** A fixed cell: each check that passes now and didn't before, as `fail → pass` or `not run → pass`. */
+function fixedItems(c, base, head, indent) {
+	const items = [];
+	for (const label of labelsOf(base, head)) {
+		const h = head.checks.find((k) => k.label === label);
+		const b = base.checks.find((k) => k.label === label);
+		if (stateOf(h) !== "pass" || stateOf(b) === "pass") continue;
+		const counts = answered(h) > 1 || answered(b) > 1;
+		items.push({
+			indent,
+			cells: [checkLabel(label), t(`${sideText(b, counts)} → ${sideText(h, counts)}`, c.green)]
+		});
+	}
+	return items;
+}
+/** The cells both runs ran, as `[base, head]`; under a heading each when there's more than one. */
+function flips(c, base, head, rows) {
+	const before = new Map((base.cells ?? []).map((x) => [x.key, x]));
+	const pairs = (head.cells ?? []).flatMap((h) => {
+		const b = before.get(h.key);
+		return b ? [[b, h]] : [];
+	});
+	if (pairs.length === 1) {
+		const [b, h] = pairs[0];
+		return rows(b, h, 2);
+	}
+	const label = labeller(pairs.map(([, h]) => h), [
+		"harness",
+		"arm",
+		"sandbox"
+	]);
+	return pairs.flatMap(([b, h]) => {
+		const items = rows(b, h, 4);
+		return items.length ? [{
+			indent: 2,
+			free: t(label(h), c.dim)
+		}, ...items] : [];
+	});
+}
+const idRow = (c, side, id, outcome) => ({
+	indent: 2,
+	cells: [
+		side,
+		id,
+		...outcome ? [t(OUTCOME[outcome], paintOutcome(c, outcome))] : []
+	]
+});
+/** `environment`, `evals/helpers.ts`: what made an eval not comparable, as the row says it. */
+function changedParts(row, changes) {
+	const parts = (row.changes ?? []).map((p) => p.replace(/ changed$/, ""));
+	if (parts.length) return parts.join(", ");
+	return changes.filter((x) => x.outsideFingerprint).map((x) => x.label).join(", ");
+}
+/** The cells only one run ran, when the runs ran different cells of the eval. */
+function cellRows(row) {
+	return [...row.cells?.added.length ? [{
+		indent: 2,
+		cells: ["cells added", row.cells.added.join(", ")]
+	}] : [], ...row.cells?.removed.length ? [{
+		indent: 2,
+		cells: ["cells removed", row.cells.removed.join(", ")]
+	}] : []];
+}
+/** The eval's own rows as `reeval run` prints them under its head: its evidence when it failed. */
+const resultBody = (c, e) => e && e.outcome !== "pass" ? evalBlock(c, e).slice(1) : [];
+const liftShort = (l) => l ? `${signed(l.points)} (${signed(l.lo)}…${signed(l.hi)})${l.withinNoise ? " noise" : ""}` : "–";
+const signed = (x) => `${x >= 0 ? "+" : "−"}${Math.round(Math.abs(x) * 100)}`;
+/** `-v`: a cell's lift and effort, base → head. */
+function cellStats(cell) {
+	return [cell.base.lift || cell.head.lift ? `lift ${liftShort(cell.base.lift)} → ${liftShort(cell.head.lift)}` : "", cell.base.effort && cell.head.effort ? effortChangeLabel(cell.base.effort, cell.head.effort) : ""].filter(Boolean).join(" · ");
+}
+function statsRows(c, row) {
+	return (row.perCell ?? []).flatMap((cell) => {
+		const stats = cellStats(cell);
+		return stats ? [{
+			indent: 2,
+			cells: [cell.key, t(stats, c.dim)]
+		}] : [];
+	});
+}
+function block(c, input, units, { row, unit }, opts) {
+	const base = units.base.get(row.id)?.result;
+	const head = units.head.get(row.id)?.result;
+	const word = t(WORD[row.status], paintStatus(c, row.status));
+	const top = headLine(word, nameOf(row, unit));
+	const baseId = input.base?.runId ?? "";
+	const headId = input.head.runId;
+	const stats = opts.verbose ? statsRows(c, row) : [];
+	if (row.status === "regressed" || row.status === "fixed") {
+		const evidence = base && head ? flips(c, base, head, (b, h, indent) => row.status === "regressed" ? regressedItems(c, b, h, indent) : fixedItems(c, b, h, indent)) : [];
+		const ids = row.status === "regressed";
+		const items = [
+			...ids ? [idRow(c, "base", baseId), idRow(c, "head", headId)] : [],
+			...cellRows(row),
+			...evidence
+		];
+		return {
+			lines: [
+				top,
+				...table(items),
+				...table(stats)
+			],
+			ids
+		};
+	}
+	if (row.status === "drift" || row.status === "infra") {
+		const changed = row.status === "drift" ? changedParts(row, input.changes) : "";
+		return {
+			lines: [
+				top,
+				...changed ? table([{
+					indent: 2,
+					cells: ["changed", changed]
+				}]) : [],
+				...table([idRow(c, "base", baseId, sideOutcome(row, "base")), idRow(c, "head", headId, sideOutcome(row, "head"))]),
+				...table([...cellRows(row), ...stats]),
+				...resultBody(c, head)
+			],
+			ids: true
+		};
+	}
+	if (row.status === "added") return {
+		lines: [
+			top,
+			...table([idRow(c, "head", headId, sideOutcome(row, "head"))]),
+			...resultBody(c, head)
+		],
+		ids: true
+	};
+	if (row.status === "removed") return {
+		lines: [top, ...table([idRow(c, "base", baseId, sideOutcome(row, "base"))])],
+		ids: true
+	};
+	return {
+		lines: [top, ...table(stats)],
+		ids: false
+	};
+}
+/** `1 regressed · 1 fixed · 1 can't compare · 4 same`: what needs a look first, zeros left out. */
+function compareTally(c, rows) {
+	const parts = TALLY.flatMap((s) => {
+		const n = rows.filter((r) => r.status === s).length;
+		return n ? [paintStatus(c, s)(`${n} ${WORD[s]}`)] : [];
+	});
+	return parts.length ? parts.join(c.dim(" · ")) : "no evals to compare";
+}
+const UNFINISHED = {
+	interrupted: "was interrupted, so some of its evals were cancelled before they finished",
+	budget: "stopped at its duration budget, so some of its evals never ran"
+};
+/** What makes the compare suspect: a run whose commit isn't in HEAD's history, or that didn't finish. */
+function sideNotes(c, input) {
+	return ["base", "head"].flatMap((side) => {
+		const s = input[side];
+		if (!s) return [];
+		const unfinished = s.status && UNFINISHED[s.status];
+		return [...s.unreachable ? [`${side} ${s.runId} ran on a commit that isn't in HEAD's history (rebased or dropped?)`] : [], ...unfinished ? [`${side} ${s.runId} ${unfinished}`] : []].map((note) => c.yellow(note));
+	});
+}
+function stackNotes(c, changes) {
+	return changes.map((x) => c.dim(`stack changed: ${x.label} ${x.base} → ${x.head}`));
+}
+/** Head on its own: no earlier recorded run, so every eval is new, shown as `reeval run` shows it. */
+function noBaseline(c, input, opts) {
+	const { suite, runId } = input.head;
+	const blocks = renderBlocks(suite, {
+		color: opts.color,
+		verbose: opts.verbose,
+		hint: false
+	});
+	const counts = [
+		"fail",
+		"infra_error",
+		"cancelled",
+		"pass",
+		"skipped"
+	].flatMap((o) => {
+		const n = input.rows.filter((r) => sideOutcome(r, "head") === o).length;
+		return n ? [paintOutcome(c, o)(`${n} ${OUTCOME[o]}`)] : [];
+	});
+	return [
+		`No earlier recorded run to compare ${runId} with, so every eval is new.`,
+		...blocks.length ? ["", ...blocks] : [],
+		"",
+		...sideNotes(c, input),
+		`${plural(input.rows.length, "new eval")}${counts.length ? ` (${counts.join(c.dim(" · "))})` : ""}`
+	];
+}
+/** `reeval compare`'s lines: the blocks, a blank line around each, then the tally. */
+function renderCompare(input, opts) {
+	const c = colors(opts.color);
+	if (!input.base) return noBaseline(c, input, opts);
+	const units = {
+		base: unitsOf(input.base.suite),
+		head: unitsOf(input.head.suite)
+	};
+	const blocks = [];
+	let ids = false;
+	let same = 0;
+	const flush = () => {
+		if (same) blocks.push([c.dim(`+${same} same`)]);
+		same = 0;
+	};
+	for (const entry of ordered(input.rows, units)) {
+		if (entry.row.status === "same" && !(opts.verbose && entry.row.perCell?.length)) {
+			same++;
+			continue;
+		}
+		flush();
+		const b = block(c, input, units, entry, opts);
+		ids ||= b.ids;
+		blocks.push(b.lines);
+	}
+	flush();
+	if (!ids) blocks.unshift(table([{
+		indent: 0,
+		cells: ["base", input.base.runId]
+	}, {
+		indent: 0,
+		cells: ["head", input.head.runId]
+	}], 15));
+	const notes = [...sideNotes(c, input), ...opts.verbose ? stackNotes(c, input.changes) : []];
+	return [
+		...blocks.flatMap((b) => [...b, ""]),
+		...notes,
+		compareTally(c, input.rows)
+	];
+}
+/** `reeval compare --md`: a heading with both run ids, and the layout in a text block. */
+function renderCompareMarkdown(input, opts) {
+	return [
+		input.base ? `### reeval compare: ${input.head.runId} vs ${input.base.runId}` : `### reeval compare: ${input.head.runId}`,
+		"",
+		...fenced(renderCompare(input, {
+			...opts,
+			color: false
+		}), "text"),
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/commands.ts
+var CommandError = class extends Error {
+	name = "CommandError";
+};
+const recorded = (config) => listRuns(config.root, config.history.dir, true);
+const scratch = (config) => listRuns(config.root, scratchDir(config.root), false);
+/** Recorded runs plus scratch runs that weren't recorded, sorted by run id. */
+async function allRuns(config) {
+	const kept = await recorded(config);
+	const ids = new Set(kept.map((e) => e.runId));
+	return [...kept, ...(await scratch(config)).filter((e) => !ids.has(e.runId))].sort((a, b) => a.runId < b.runId ? -1 : 1);
+}
+async function lines(root, args) {
+	const r = await git(root, args);
+	if (r.code !== 0) return null;
+	return r.stdout.toString("utf8").split("\n").filter(Boolean);
+}
+/** Commits reachable from HEAD; null when git can't tell (no repo, or a shallow clone). */
+async function reachability(root) {
+	const shallow = await lines(root, ["rev-parse", "--is-shallow-repository"]);
+	if (!shallow || shallow[0] === "true") return null;
+	const shas = await lines(root, [
+		"rev-list",
+		"--max-count=20000",
+		"HEAD"
+	]);
+	return shas ? new Set(shas) : null;
+}
+const rel = (path) => fromCwd(path) || path;
+function parseLevel(value, fallback) {
+	if (value === void 0) return fallback;
+	if (value === "all" || value === "failures" || value === "none") return value;
+	throw new CommandError(`--artifacts is all, failures or none (got ${value})`);
+}
+async function record(config, runId, flags) {
+	const result = await recordRun({
+		root: config.root,
+		historyDir: config.history.dir,
+		runId,
+		artifacts: parseLevel(flags.artifacts, config.history.artifacts),
+		allowIncomplete: flags["allow-incomplete"],
+		skipSecretScan: flags["skip-secret-scan"],
+		hint: !hasAnalysisModel(config)
+	});
+	const where = rel(result.recordPath);
+	if (!result.created) return `${where} is already recorded`;
+	const kb = (result.bytes / 1024).toFixed(1);
+	const recorded = `recorded ${where}${result.artifactDir ? ` + ${result.files} artifact files in ${rel(result.artifactDir)}/` : ""} (${kb} KB). Commit it with git.`;
+	const ignored = result.ignored.length === 0 ? [] : [`warning: git ignores ${result.ignored.length} recorded file(s); they won't be committed:`, ...result.ignored.map((i) => `  ${i.path}  ignored by ${i.rule} (${i.source})`)];
+	if (result.droppedPatch.length === 0) return ignored.length === 0 ? recorded : `${ignored.join("\n")}\n${recorded}`;
+	const artifacts = result.artifactDir ? `${rel(result.artifactDir)}/` : "";
+	return [
+		`warning: left worktree.patch out of ${runId}: it looks like it holds a secret.`,
+		...result.droppedPatch.map((line) => `  ${line}`),
+		"  worktree.patch is your checkout's uncommitted changes when the run started (git status), not the agents' work.",
+		"  Nothing was committed. Take the key out of those files, or add them to .gitignore, so a later commit doesn't carry it; rotate the key only if it's already been committed or pushed. The record says the patch was left out, so reeval checkout recreates the commit alone.",
+		`  To keep it after checking by hand: delete ${where} and ${artifacts || "its artifacts"}, then reeval record ${runId} --skip-secret-scan.`,
+		...ignored,
+		recorded
+	].join("\n");
+}
+async function recordCommand(ctx, refs) {
+	const runs = await scratch(ctx.config);
+	for (const ref of refs.length ? refs : ["latest"]) ctx.out(await record(ctx.config, resolveRun(runs, ref).runId, ctx.flags));
+	return 0;
+}
+/** `reeval history --json`: recent runs (recorded, or with `all` scratch ones too) and each eval's strip. */
+async function historyView(config, options = {}) {
+	const entries = options.all ? await allRuns(config) : await recorded(config);
+	const limit = options.limit ?? 20;
+	if (!(limit > 0)) throw new CommandError(`--limit must be a number above 0 (got ${options.limit})`);
+	const reach = await reachability(config.root);
+	return history(entries, {
+		filter: options.filter || void 0,
+		limit,
+		reach
+	});
+}
+async function historyCommand(ctx, filter) {
+	const view = await historyView(ctx.config, {
+		filter: filter.join(" "),
+		limit: ctx.flags.limit ? Number(ctx.flags.limit) : void 0,
+		all: ctx.flags.all
+	});
+	ctx.out(ctx.flags.json ? JSON.stringify(view, null, 2) : formatHistory(view));
+	return 0;
+}
+/** A listed run's record, from the history folder or the scratch runs. */
+const recordOf = (config, entry) => readRecord(join(entry.recorded ? config.history.dir : scratchDir(config.root), `${entry.runId}.json`));
+/** The record of the run `ref` names (default latest), recorded or scratch. */
+async function showRecord(config, ref) {
+	return recordOf(config, resolveRun(await allRuns(config), ref));
+}
+async function showCommand(ctx, refs) {
+	const { config } = ctx;
+	const entry = resolveRun(await allRuns(config), refs[0]);
+	const dir = entry.recorded ? config.history.dir : scratchDir(config.root);
+	const run = await readRecord(join(dir, `${entry.runId}.json`));
+	if (ctx.flags.json) {
+		ctx.out(JSON.stringify(run, null, 2));
+		return 0;
+	}
+	const insights = await readInsights(runInsightsFile(config, entry));
+	const hint = !(insights && fromModel(insights)) && !hasAnalysisModel(config);
+	if (ctx.flags.md) ctx.out(renderSummary(run, {
+		hint,
+		insights
+	}).trimEnd());
+	else ctx.out(formatShow(run, {
+		hint,
+		insights
+	}));
+	return 0;
+}
+/**
+* Two runs and their rows: `base` and `head` when both are given, else `head` (default latest)
+* against its nearest recorded ancestor. `json` is what `reeval compare --json` prints.
+*/
+async function compareView(config, refs) {
+	const { root } = config;
+	const entries = await allRuns(config);
+	const reach = await reachability(root);
+	let base;
+	let head;
+	if (refs.length >= 2) {
+		base = resolveRun(entries, refs[0]);
+		head = resolveRun(entries, refs[1]);
+	} else {
+		head = resolveRun(entries, refs[0] ?? "latest");
+		const ancestry = await lines(root, [
+			"rev-list",
+			"--max-count=5000",
+			head.git && (!reach || reach.has(head.git.sha)) ? head.git.sha : "HEAD"
+		]);
+		const candidates = entries.filter((e) => e.recorded && e.runId !== head.runId);
+		base = pickBaseline(candidates, head, ancestry);
+	}
+	const rows = base ? compare(base, head) : head.evals.map(addedRow);
+	const flag = (e) => ({
+		runId: e.runId,
+		recorded: e.recorded,
+		inHistory: !reach || !e.git ? null : reach.has(e.git.sha)
+	});
+	const json = base ? {
+		base: flag(base),
+		head: flag(head),
+		changes: stackChanges(base, head),
+		rows
+	} : {
+		base: null,
+		head: { runId: head.runId },
+		changes: [],
+		rows
+	};
+	return {
+		base,
+		head,
+		rows,
+		reach,
+		json
+	};
+}
+async function compareCommand(ctx, refs) {
+	const { base, head, rows, reach, json } = await compareView(ctx.config, refs);
+	const failing = regressions(rows);
+	if (ctx.flags.json) ctx.out(JSON.stringify(json, null, 2));
+	else {
+		const side = async (e) => {
+			const record = await recordOf(ctx.config, e);
+			return {
+				runId: e.runId,
+				suite: suiteResult(record),
+				unreachable: unreachable(e, reach),
+				status: record.status
+			};
+		};
+		const input = {
+			base: base ? await side(base) : null,
+			head: await side(head),
+			rows,
+			changes: base ? stackChanges(base, head) : []
+		};
+		const opts = {
+			color: false,
+			verbose: !!ctx.flags.verbose?.length
+		};
+		ctx.out(ctx.flags.md ? renderCompareMarkdown(input, opts).trimEnd() : renderCompare(input, opts).join("\n"));
+	}
+	return ctx.flags["fail-on-regression"] && failing.length ? 1 : 0;
+}
+/**
+* What `--fail-on-regression` fails on: an eval that went from pass to fail, and a new or
+* changed (can't compare) eval that fails, since nothing earlier vouches for it. A head the run's
+* interrupt cancelled didn't fail.
+*/
+const regressions = (rows) => rows.filter((r) => r.status === "regressed" || (r.status === "added" || r.status === "drift") && r.head === "fail" && !r.cancelled?.includes("head"));
+/** Recreates the state a run executed in: its commit, plus its uncommitted changes if any. */
+async function checkoutCommand(ctx, args) {
+	const { root } = ctx.config;
+	const entry = resolveRun(await allRuns(ctx.config), args[0] ?? "latest");
+	const dir = entry.recorded ? ctx.config.history.dir : scratchDir(root);
+	const run = await readRecord(join(dir, `${entry.runId}.json`));
+	if (!run.git) throw new CommandError(`${run.runId} didn't run in a git repository`);
+	const { sha } = run.git;
+	if ((await git(root, [
+		"cat-file",
+		"-e",
+		`${sha}^{commit}`
+	])).code !== 0) throw new CommandError(`Commit ${sha.slice(0, 12)} isn't in this clone (rebased or not fetched). Fetch it, then try again.`);
+	const target = resolve(args[1] ?? join(root, ".reeval", "checkouts", run.runId));
+	if (existsSync(target)) throw new CommandError(`${rel(target)} already exists`);
+	const patchRef = run.git.worktreePatch;
+	const patchPath = patchRef && join(dir, run.runId, patchRef.path);
+	if (patchRef && patchPath) {
+		const bytes = await readFile(patchPath).catch((error) => {
+			if (error.code !== "ENOENT") throw error;
+			return null;
+		});
+		if (!bytes) throw new CommandError(`${rel(patchPath)} is missing, but the record says the run's uncommitted changes are in it. ${entry.recorded ? "Restore it from git, where it's committed with the record, then try again." : "It's gone from .reeval/runs, so those changes can't be recreated."}`);
+		if (sha256(bytes) !== patchRef.sha256) throw new CommandError(`${rel(patchPath)} doesn't match the hash in the record`);
+	}
+	await gitText(root, [
+		"worktree",
+		"add",
+		"--detach",
+		"-q",
+		target,
+		sha
+	]);
+	let applied = "";
+	if (patchPath) {
+		const r = await git(target, [
+			"apply",
+			"--binary",
+			"--whitespace=nowarn",
+			patchPath
+		]);
+		if (r.code !== 0) throw new CommandError(`Applying worktree.patch failed: ${r.stderr.trim()}`);
+		applied = " and applied worktree.patch";
+	} else if (run.git.dirty) applied = `, without the run's uncommitted changes: they weren't saved (${run.git.worktreePatchNote ?? "unknown"})`;
+	ctx.out(`checked out ${sha.slice(0, 12)} into ${rel(target)}${applied}.\nRemove it with: git worktree remove ${rel(target)}`);
+	return 0;
+}
+//#endregion
+export { compareView as a, lines as c, record as d, recordCommand as f, showRecord as h, compareCommand as i, parseLevel as l, showCommand as m, allRuns as n, historyCommand as o, regressions as p, checkoutCommand as r, historyView as s, CommandError as t, reachability as u };
+
+//# sourceMappingURL=commands-CjpGBUWr.js.map