reeval 0.0.1

package/dist/cli--CQ3Iy9q.js

@@ -0,0 +1,1865 @@
+import { t as UsageError } from "./errors-CSxfJ4qu.js";
+import { x as parseDuration, y as workspaceLabel } from "./environment-Mz7wvrtD.js";
+import { n as loadEnvFiles, t as inCI } from "./env-BQqj93gu.js";
+import { a as registerSecret, i as redactSecrets } from "./redact-C4fL_bZP.js";
+import { o as PACKAGE_VERSION } from "./root-CFDjpWuc.js";
+import { a as fromCwd, i as evalSlug, n as attemptKey, o as newRunId } from "./ids-Bp6ut7ZD.js";
+import { I as LABEL, X as imageInfo } from "./src-DwwiVLqv.js";
+import { s as harnessId, u as sandboxId } from "./options-CAQhu--C.js";
+import { c as hostCapacity, d as missingCredentials, f as resolveConcurrency, i as configPathFor, l as loadConfig, p as selectProfile, r as configLabel, s as findConfig, u as malformedCredentials } from "./config-Cuj0kVYj.js";
+import { s as debugTime } from "./debug-D24NOQH1.js";
+import { i as sandboxWarningLine, n as clip, r as formatDuration } from "./text-gEcKjAyp.js";
+import { t as PrepareError } from "./provider-CmAYTQQs.js";
+import { N as effortLabel, O as cellContrast, b as runOutcome, h as hasUngatedCells, p as formatUsage, v as isUngatedMiss } from "./model-CDL98xue.js";
+import { n as LIVE_FILE, o as liveCounts } from "./live-Bs3LReMV.js";
+import { n as FLAGS, o as helpText, r as GLOBAL, t as COMMANDS } from "./cli-spec-DKAu09Gi.js";
+import { i as liftLabel, r as gateLabel } from "./summary-D7Ttky0z.js";
+import { n as gitInfo, r as runnerInfo, t as author } from "./provenance-Dfb8YY5Y.js";
+import { t as budgetMarker } from "./budget-DBUrH4jX.js";
+import { n as prepareAll, o as writePrepared, r as prepareTargets, t as RunStopError } from "./preflight-BypZMNBG.js";
+import { r as imageHarness } from "./prepare-D6Uzcubb.js";
+import { n as createProviders } from "./providers-2p3ylMHI.js";
+import { a as redactArgv, r as commandOf, t as logInvocation } from "./invocations-rXktgSAn.js";
+import { n as stripAnsi, t as colors } from "./colors-QV9dFVhN.js";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { appendFile, readFile, rm } from "node:fs/promises";
+import { inspect } from "node:util";
+import { detectAgent } from "std-env";
+import { Command, Option } from "commander";
+//#region src/cli-parse.ts
+const OPTIONS = Object.fromEntries(Object.entries(FLAGS).map(([name, spec]) => {
+	const short = "short" in spec ? `-${spec.short}, ` : "";
+	const value = spec.type === "string" ? " <value>" : "";
+	return [name, () => {
+		const option = new Option(`${short}--${name}${value}`);
+		if ("multiple" in spec && spec.multiple) option.argParser((v, prev = []) => [...prev, spec.type === "string" ? v : true]);
+		return option;
+	}];
+}));
+/**
+* Parses `argv` against the CLI spec with commander. A flag belongs to the commands that list it
+* (and `--config`, `--help` and `--version` to all of them); a flag of another command, a
+* missing value or too many arguments is a UsageError. `--help` and `--version` skip the
+* argument count, so the dispatcher can print them.
+*/
+function parseCli(argv) {
+	let parsed;
+	const program = configure(new Command("reeval"), "reeval", GLOBAL);
+	program.argument("[args...]").action(() => {
+		parsed = {
+			positionals: program.args,
+			values: valuesOf(program, GLOBAL)
+		};
+	});
+	for (const [name, spec] of Object.entries(COMMANDS)) {
+		const command = configure(program.command(name), `reeval ${name}`, spec.flags);
+		command.argument("[args...]").action(() => {
+			const max = spec.sub && !spec.help ? Number.POSITIVE_INFINITY : spec.positionals;
+			parsed = done(program, command, [name], spec.flags, max);
+		});
+		for (const [subName, sub] of Object.entries(spec.sub ?? {})) {
+			const subcommand = configure(command.command(subName), `reeval ${name} ${subName}`, sub.flags);
+			subcommand.argument("[args...]").action(() => {
+				const [stray] = Object.keys(valuesOf(command, spec.flags));
+				if (stray) throw new UsageError(`--${stray} isn't an option of reeval ${name} ${subName}`);
+				parsed = done(program, subcommand, [name, subName], sub.flags, sub.positionals);
+			});
+		}
+	}
+	program.parse(argv, { from: "user" });
+	if (!parsed) throw new UsageError("Run reeval --help.");
+	return parsed;
+}
+function configure(command, name, flags) {
+	command.helpOption(false).helpCommand(false).allowExcessArguments().configureOutput({
+		writeOut: () => {},
+		writeErr: () => {},
+		outputError: () => {}
+	}).exitOverride((error) => {
+		throw usageError(error, name);
+	});
+	for (const flag of flags) command.addOption(OPTIONS[flag]());
+	return command;
+}
+function done(program, command, path, flags, max) {
+	const values = {
+		...valuesOf(program, GLOBAL),
+		...valuesOf(command, flags)
+	};
+	const args = command.args;
+	if (!values.help && !values.version && args.length > max) {
+		const name = `reeval ${path.join(" ")}`;
+		throw new UsageError(max === 0 ? `${name} takes no arguments (got ${args.join(" ")})` : `${name} takes at most ${max} argument${max === 1 ? "" : "s"} (got ${args.join(" ")})`);
+	}
+	return {
+		positionals: [...path, ...args],
+		values
+	};
+}
+/** The flags given, under their spec names; a `--no-*` flag is true when given. */
+function valuesOf(command, flags) {
+	const opts = command.opts();
+	const values = {};
+	for (const flag of flags) {
+		const option = command.options.find((o) => o.long === `--${flag}`);
+		const value = option && opts[option.attributeName()];
+		if (option?.negate) {
+			if (value === false) values[flag] = true;
+		} else if (value !== void 0) values[flag] = value;
+	}
+	return values;
+}
+/** Commander's error, in reeval's words, naming the command whose flag it is. */
+function usageError(error, command) {
+	const [first = "", ...rest] = error.message.replace(/^error: /, "").split("\n");
+	if (error.code === "commander.unknownOption") {
+		const arg = /'([^']+)'/.exec(first)?.[1] ?? "";
+		const [flag = "", value] = arg.replace(/^--?/, "").split("=");
+		const known = arg.startsWith("--") ? FLAGS[flag] : Object.entries(FLAGS).find(([, s]) => "short" in s && s.short === flag)?.[1];
+		const long = arg.startsWith("--") ? flag : Object.entries(FLAGS).find(([, s]) => "short" in s && s.short === flag)?.[0];
+		if (known && value !== void 0 && known.type === "boolean") return new UsageError(`Option '--${flag}' does not take an argument`);
+		if (known) return new UsageError(`--${long} isn't an option of ${command}. Run reeval --help.`);
+		const hint = rest.join(" ").replace(/^\(|\)$/g, "");
+		return new UsageError(`Unknown option '${arg}'. ${hint ? `${hint} ` : ""}Run reeval --help.`);
+	}
+	return new UsageError(first.charAt(0).toUpperCase() + first.slice(1));
+}
+function finished(result) {
+	const outcome = result.meta?.outcome;
+	if (result.state === "skipped") return outcome === "fail" || outcome === "infra_error" ? outcome : "skipped";
+	if (outcome === "infra_error") return "infra_error";
+	return result.state === "passed" ? "pass" : "fail";
+}
+/**
+* Renames `from` over `to`. Windows refuses while a reader (`reeval studio`) has `to` open, for a
+* moment: try again briefly rather than drop the update.
+*/
+function replace(from, to, rename = renameSync) {
+	for (let attempt = 1;; attempt++) try {
+		rename(from, to);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (attempt >= 20 || !(code === "EPERM" || code === "EACCES" || code === "EBUSY")) throw error;
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, attempt);
+	}
+}
+/** Writes the file at once, then on every change and heartbeat. Write errors never fail the run. */
+function writeLiveProgress(options) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const file = join(options.dir, LIVE_FILE);
+	const tmp = `${file}.${process.pid}.tmp`;
+	const attempts = new Map(options.planned.map((p) => [p.key, {
+		key: p.key,
+		evalId: p.id,
+		name: p.attempt.name,
+		file: p.file,
+		cell: p.attempt.cell.key,
+		n: p.attempt.n,
+		status: p.attempt.plan.skip ? "skipped" : "queued",
+		startedAt: null,
+		durationMs: null
+	}]));
+	let phase = "running";
+	let stopped = false;
+	const read = () => {
+		const list = [...attempts.values()];
+		return {
+			schemaVersion: 1,
+			runId: options.runId,
+			startedAt: options.startedAt.toISOString(),
+			pid: process.pid,
+			host: hostname(),
+			heartbeatAt: now().toISOString(),
+			phase,
+			planned: list.length,
+			counts: liveCounts(list),
+			attempts: list
+		};
+	};
+	const write = () => {
+		if (stopped) return;
+		try {
+			writeFileSync(tmp, JSON.stringify(read()));
+			replace(tmp, file);
+		} catch {}
+	};
+	try {
+		mkdirSync(options.dir, { recursive: true });
+	} catch {}
+	write();
+	const heartbeat = setInterval(write, options.heartbeatMs ?? 2e3);
+	heartbeat.unref();
+	const stop = () => {
+		stopped = true;
+		clearInterval(heartbeat);
+	};
+	return {
+		start(key, at) {
+			const a = attempts.get(key);
+			if (!a) return;
+			a.status = "running";
+			a.startedAt = new Date(at).toISOString();
+			write();
+		},
+		end(result) {
+			const a = attempts.get(result.key);
+			if (!a) return;
+			a.status = finished(result);
+			a.durationMs = result.durationMs;
+			write();
+		},
+		phase(next) {
+			phase = next;
+			write();
+		},
+		stop,
+		remove() {
+			stop();
+			rmSync(file, { force: true });
+			rmSync(tmp, { force: true });
+		},
+		read
+	};
+}
+//#endregion
+//#region src/preflight.ts
+/** How the terminal names a sandbox to prepare: its cell id, `+ install`, and a harness other than Cursor. */
+function prepareLabel({ sandbox, harness }) {
+	if (sandbox.kind !== "docker") return sandboxId(sandbox);
+	const baked = imageHarness(harness);
+	const install = sandbox.install?.length ? " + install" : "";
+	return `${sandboxId(sandbox)}${install}${baked === "cursor" ? "" : ` · ${baked}`}`;
+}
+/** A run that stopped in preflight on an infra failure: exit 3. */
+var PreflightInfraError = class extends Error {
+	name = "PreflightInfraError";
+};
+/**
+* Before any eval starts: checks each sandbox provider, then prepares every distinct sandbox the
+* planned attempts need (building Docker images), in parallel, and writes the results for the
+* run's workers. A config-level sandbox that fails stops the run (exit 2 for a mistake in the
+* config, exit 3 otherwise); any other failure fails only the attempts that need it.
+*/
+async function preflight(uses, options) {
+	const providers = options.providers ?? createProviders();
+	const targets = prepareTargets(uses, providers, prepareLabel);
+	if (!targets.some((t) => t.kind !== "fake")) return { images: [] };
+	let outcomes;
+	try {
+		outcomes = await prepareAll(targets, {
+			providers,
+			root: options.root,
+			...options.signal ? { signal: options.signal } : {},
+			...options.delays ? { delays: options.delays } : {},
+			...options.onEvent ? { onEvent: options.onEvent } : {},
+			log: (line) => process.env.REEVAL_DEBUG && console.error(line)
+		});
+	} catch (error) {
+		if (error instanceof PrepareError) throw error.failure.usage ? new UsageError(error.message) : new PreflightInfraError(error.message);
+		if (error instanceof RunStopError) throw error.outcome.failure.usage ? new UsageError(error.message) : new PreflightInfraError(error.message);
+		throw error;
+	}
+	writePrepared(options.root, options.runId, outcomes);
+	const images = [];
+	for (const o of outcomes) {
+		if (!o.ok || o.target.kind !== "docker") continue;
+		const { ref, id, agentCli } = o.handle;
+		if (images.some((i) => i.id === id)) continue;
+		const info = await imageInfo(ref);
+		images.push({
+			ref,
+			id,
+			repoDigests: info?.repoDigests ?? [],
+			agentCli: agentCli ?? info?.labels[LABEL.agentVersion] ?? null
+		});
+	}
+	return { images };
+}
+//#endregion
+//#region src/ui/format.ts
+/** Most detail lines a `-vv` payload prints under its line. */
+const DEBUG_DETAIL_LINES = 40;
+/**
+* A debug line as the terminal shows it, `12:50:01 image     cache hit …` (with milliseconds under
+* `-vv`), then its detail indented under it.
+*/
+function debugLines(c, line, ms) {
+	const phase = line.phase.padEnd(9);
+	const head = `${c.dim(debugTime(line.at, ms))} ${c.dim(phase)} ${line.level === 2 ? c.dim(line.text) : line.text}`;
+	const detail = (line.detail ?? "").split("\n").filter((l) => l.trim());
+	const shown = detail.slice(0, DEBUG_DETAIL_LINES).map((l) => c.dim(`    ${l}`));
+	const more = detail.length - shown.length;
+	return [
+		head,
+		...shown,
+		...more > 0 ? [c.dim(`    … ${more} more lines in trace.ndjson`)] : []
+	];
+}
+/** Offset into an attempt, `+1:05`. */
+function offset(ms) {
+	const s = Math.max(0, Math.floor(ms / 1e3));
+	return `+${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+function outcomeOf(e) {
+	if (e.state === "skipped") return "skipped";
+	if (e.meta?.errorKind === "aborted") return "cancelled";
+	return e.meta?.outcome ?? (e.state === "passed" ? "pass" : "fail");
+}
+function attemptOutcome(a) {
+	return a.error?.kind === "aborted" ? "cancelled" : a.outcome;
+}
+/** What tells an eval's attempts apart: the axes that vary (`cursor:composer-2.5 · with-skill`), else the harness. */
+function attemptAxes(a, fallback) {
+	return a?.label.replace(/\s*#\d+$/, "") || a?.harness.kind || fallback;
+}
+function mark(c, outcome) {
+	return {
+		pass: c.green("✓"),
+		fail: c.red("✗"),
+		infra_error: c.yellow("!"),
+		skipped: c.dim("↓"),
+		cancelled: c.yellow("✗")
+	}[outcome];
+}
+/** An expected miss's mark: neutral, since it doesn't fail the run. */
+const MISS_MARK = (c) => c.dim("○");
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+/** A command on one line: the first line, cut to 80 characters at a word boundary. */
+function oneLine(text, max = 80) {
+	const [first = ""] = text.trim().split("\n");
+	const cut = clip(first, max);
+	return cut === first && text.trim().includes("\n") ? `${first}…` : cut;
+}
+/** One line per worker progress event, without prefix or offset. */
+function progressLine(c, p) {
+	switch (p.kind) {
+		case "sandbox": return c.dim("sandbox starting");
+		case "sandbox-ready": return `sandbox ready ${c.dim(formatDuration(p.ms))}`;
+		case "turn-start": return `turn ${p.turn} started`;
+		case "turn-end": {
+			const status = p.status === "completed" ? "done" : c.red(p.status);
+			const activity = [plural(p.tools, "tool call"), plural(p.fileEdits, "file edit")].join(", ");
+			const error = p.error ? `: ${c.red(oneLine(p.error, 160))}` : "";
+			return `turn ${p.turn} ${status}${error} ${c.dim(`${formatDuration(p.ms)} · ${activity}`)}`;
+		}
+		case "check-start": return c.dim(`$ ${oneLine(p.command)}`);
+		case "check-end": {
+			const exit = p.exitCode === 0 ? c.dim("exit 0") : c.red(`exit ${p.exitCode}`);
+			return `$ ${oneLine(p.command)}  ${exit} ${c.dim(formatDuration(p.ms))}`;
+		}
+		case "judge-start": return c.dim(`judging: ${oneLine(p.question, 120)}`);
+		case "judge-end": return judgeLine(c, p);
+		case "cleanup": return c.dim("cleaning up");
+	}
+}
+function judgeLine(c, j) {
+	const verdict = j.verdict === "pass" ? c.green("pass") : c.red(j.verdict);
+	const score = j.score === null ? "" : ` ${j.score.toFixed(2)}`;
+	const threshold = j.threshold === null ? "" : ` ${c.dim(`(≥ ${j.threshold})`)}`;
+	return `${c.dim("judge")}  ${verdict}${score}${threshold}  ${j.question}`;
+}
+/** The phase a running attempt is in, for the heartbeat. */
+function phaseOf(p) {
+	switch (p?.kind) {
+		case void 0: return "starting";
+		case "sandbox": return "sandbox";
+		case "sandbox-ready": return "sandbox ready";
+		case "turn-start": return `turn ${p.turn}`;
+		case "turn-end": return `turn ${p.turn} done`;
+		case "check-start":
+		case "check-end": return "checks";
+		case "judge-start":
+		case "judge-end": return "judging";
+		case "cleanup": return "cleanup";
+	}
+}
+function capLines(text, max) {
+	const lines = text.replace(/\s+$/, "").split("\n");
+	if (lines.length <= max) return lines;
+	return [...lines.slice(0, max), `(+${lines.length - max} more lines)`];
+}
+/** An infra error's headline, then its last lines: the cause is at the end. */
+function tailLines(text, max) {
+	const lines = text.replace(/\s+$/, "").split("\n");
+	if (lines.length <= max) return lines;
+	const rest = Math.max(1, max - 1);
+	return [
+		lines[0] ?? "",
+		`(${lines.length - 1 - rest} more lines)`,
+		...lines.slice(-rest)
+	];
+}
+/**
+* Why an eval failed, as lines: the judge verdict (and reason) for judge failures, Vitest's
+* formatted error (diff, code frame) for assertions, the tail of the message for infra errors.
+*/
+function failureLines(c, e, options) {
+	const outcome = outcomeOf(e);
+	if (outcome === "cancelled") return [c.yellow("cancelled")];
+	const message = e.errors[0] ?? "";
+	const turns = (e.meta?.turnErrors ?? []).filter((t) => !message.includes(t.replace(/^turn \d+ error: /, ""))).map((t) => c.yellow(t));
+	return [...failureBody(c, e, outcome, message, options), ...turns];
+}
+function failureBody(c, e, outcome, message, options) {
+	if (outcome === "infra_error") {
+		if (e.meta?.prepare) {
+			const lines = message.trimEnd().split("\n");
+			return [
+				c.yellow("infra error"),
+				lines[0] ?? "",
+				lines.at(-1) ?? ""
+			].filter((l, i, all) => all.indexOf(l) === i);
+		}
+		return [`${c.yellow("infra error")}`, ...tailLines(message, options.max)];
+	}
+	const failed = (e.meta?.judgements ?? []).filter((j) => j.verdict !== "pass");
+	if (e.meta?.errorKind === "judge" && failed.length) return failed.flatMap((j, i) => {
+		const reason = options.reasons?.[i];
+		return [judgeLine(c, {
+			...j,
+			threshold: j.threshold
+		}), ...reason ? [`  ${reason}`] : []];
+	});
+	const formatted = e.formattedErrors[0];
+	const body = formatted && e.meta?.errorKind !== "timeout" ? formatted : message;
+	return capLines((c.enabled ? body : stripAnsi(body)).replace(/^\n+/, ""), options.max).map((l) => c.enabled && body === message ? c.red(l) : l);
+}
+/** Preflight's lines: which sandboxes it prepares, the slow ones when ready, and each failure. */
+function prepareLines(c, e, max) {
+	if (e.state === "start") {
+		const n = e.targets.length;
+		const names = e.targets.map((t) => t.label).join(", ");
+		return [c.dim(`preparing ${n} sandbox${n === 1 ? "" : "es"}: ${names}`)];
+	}
+	const { outcome } = e;
+	if (outcome.ok) return outcome.ms >= 1e3 ? [c.dim(`${c.green("✓")} ${outcome.target.label} ready ${formatDuration(outcome.ms)}`)] : [];
+	const who = outcome.target.setBy.join(", ");
+	return [`${c.red("✗")} ${outcome.target.label} failed to prepare ${c.dim(`(set by ${who}; only its attempts fail)`)}`, ...tailLines(outcome.failure.message, max).map((l) => `  ${c.yellow(l)}`)];
+}
+//#endregion
+//#region src/ui/summary.ts
+const FAILURE_LINES = 30;
+const KINDS = [
+	{
+		title: "Judge failures",
+		test: (a) => a.error?.kind === "judge"
+	},
+	{
+		title: "Assertion failures",
+		test: (a) => a.error?.kind === "assertion"
+	},
+	{
+		title: "Timeouts",
+		test: (a) => a.error?.kind === "timeout"
+	},
+	{
+		title: "Infra errors",
+		test: (_, o) => o === "infra_error"
+	},
+	{
+		title: "Cancelled",
+		test: (_, o) => o === "cancelled"
+	}
+];
+/** The engine's result for an attempt, or one rebuilt from the record (e.g. cancelled ones). */
+function resultFor(entry, attempt, results) {
+	const key = attemptKey(entry.id, attempt.cell, attempt.n);
+	const found = results.find((r) => r.key === key);
+	const errorKind = attempt.error?.kind ?? null;
+	const meta = {
+		outcome: attempt.outcome === "skipped" ? "pass" : attempt.outcome,
+		errorKind,
+		judgements: attempt.judgements.map((j) => ({ ...j })),
+		turnErrors: attempt.turns.flatMap((t, i) => t.error ? [`turn ${i + 1} error: ${t.error}`] : []),
+		recordPath: ""
+	};
+	if (found) return {
+		...found,
+		meta: found.meta ? {
+			...found.meta,
+			errorKind
+		} : meta
+	};
+	return {
+		id: entry.id,
+		key,
+		file: entry.file,
+		group: entry.group,
+		name: entry.name,
+		attempt: void 0,
+		state: attempt.outcome === "pass" ? "passed" : attempt.outcome === "skipped" ? "skipped" : "failed",
+		durationMs: attempt.durationMs,
+		errors: attempt.error ? [attempt.error.message] : [],
+		formattedErrors: [],
+		meta
+	};
+}
+function entryOutcome(e) {
+	const outcomes = e.attempts.map(attemptOutcome);
+	if (outcomes.length && outcomes.every((o) => o === "cancelled")) return "cancelled";
+	return e.outcome;
+}
+const pct = (rate) => rate === null ? "  – " : `${Math.round(rate * 100)}%`.padStart(4);
+function evalColumns(c, e) {
+	const [attempt, ...more] = e.attempts;
+	if (e.todo) return c.dim("todo");
+	if (!attempt || e.outcome === "skipped") return c.dim("skipped");
+	if (more.length) {
+		const pass = e.attempts.filter((a) => a.outcome === "pass").length;
+		const counted = e.attempts.filter((a) => a.outcome === "pass" || a.outcome === "fail").length;
+		const rate = hasUngatedCells(e.cells) ? ` · ${pct(e.passRate).trim()} gated` : `  ${pct(e.passRate)}`;
+		return c.dim(`${`${pass}/${counted}`.padStart(7)}${rate}  ${e.attempts.length} attempts`);
+	}
+	if (attemptOutcome(attempt) === "cancelled") return c.yellow("cancelled");
+	const cols = [formatDuration(attempt.durationMs).padStart(7)];
+	const scores = attempt.judgements.map((j) => j.score);
+	if (scores.length) cols.push(`judge ${Math.min(...scores).toFixed(2)}`);
+	const turns = attempt.turns.length;
+	cols.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+	return c.dim(cols.join("  "));
+}
+/** Pass rate per cell for evals with several attempts; with compare, each cell's role and lift. */
+function cellRows(c, e, indent) {
+	if (e.attempts.length < 2) return [];
+	const compare = e.cells.some((cell) => cell.role === "variant");
+	const width = Math.max(...e.cells.map((cell) => cell.key.length));
+	return e.cells.flatMap((cell) => {
+		const role = compare ? `  ${cell.role.padEnd(7)}` : "";
+		const counts = `${cell.pass}/${cell.pass + cell.fail}`.padStart(5);
+		const infra = cell.infraError ? c.yellow(`   ${cell.infraError} infra`) : "";
+		let note = "";
+		if (cell.lift) {
+			const { minLift } = cell.lift;
+			const below = minLift !== void 0 && cell.lift.interval.lo < minLift;
+			const text = `${liftLabel(cell.lift)}${minLift !== void 0 ? ` (minLift ${Math.round(minLift * 100)})` : ""}`;
+			note = `   ${below ? c.red(`${text} ✗`) : text}`;
+		} else if (compare && cell.gate === "none" && cell.fail > 0) note = `   ${c.dim("not gated")}`;
+		if (cell.gate !== "all" && cell.gate !== "none") note += `   ${c.dim(`gate ${gateLabel(cell.gate)}`)}`;
+		const rows = [`${indent}${c.dim(cell.key.padEnd(width))}${role}  ${counts}  ${pct(cell.passRate)}${note}${infra}`];
+		const effort = cellContrast(e, cell.key);
+		if (effort) rows.push(`${indent}  ${c.dim(`effort: ${effortLabel(effort)}`)}`);
+		if (cell.overrides.length) rows.push(`${indent}  ${c.dim(`overrides: ${cell.overrides.join(", ")}`)}`);
+		return rows;
+	});
+}
+/** The run's evals as a file › group tree, one row per eval and per cell of a matrix. */
+function tree(c, evals) {
+	const rows = [];
+	let path = [];
+	for (const e of evals) {
+		const next = [e.file, ...e.group];
+		let same = 0;
+		while (same < path.length && same < next.length && path[same] === next[same]) same++;
+		for (let i = same; i < next.length; i++) rows.push({
+			indent: i,
+			text: i === 0 ? c.bold(next[i] ?? "") : next[i] ?? ""
+		});
+		path = next;
+		rows.push({
+			indent: next.length,
+			text: e.name,
+			entry: e
+		});
+	}
+	const width = Math.max(...rows.filter((r) => r.entry).map((r) => r.indent * 2 + 2 + r.text.length));
+	return rows.flatMap(({ indent, text, entry }) => {
+		const pad = "  ".repeat(indent);
+		if (!entry) return [` ${pad}${text}`];
+		return [` ${pad}${`${mark(c, entryOutcome(entry))} ${text}`}${" ".repeat(Math.max(0, width - indent * 2 - 2 - text.length))}  ${evalColumns(c, entry)}`, ...cellRows(c, entry, ` ${pad}    `)];
+	});
+}
+function totals(c, s, cancelled = 0) {
+	const fail = s.fail - s.notGated - cancelled;
+	const parts = [
+		s.pass && c.green(`${s.pass} passed`),
+		fail > 0 && c.red(`${fail} failed`),
+		s.notGated > 0 && c.dim(`${s.notGated} missed, not gated`),
+		s.infraError && c.yellow(`${s.infraError} infra error`),
+		cancelled && c.yellow(`${cancelled} cancelled`),
+		s.skipped && c.dim(`${s.skipped} skipped`)
+	].filter(Boolean);
+	const scope = s.attempts === s.evals ? `${s.evals}` : `${s.attempts} attempts, ${s.evals} evals`;
+	return parts.length ? `${parts.join(c.dim(" · "))} ${c.dim(`(${scope})`)}` : "no evals ran";
+}
+/** Failing attempts, in run order, including expected misses. */
+function failingAttempts(evals) {
+	return evals.flatMap((entry) => entry.attempts.map((attempt) => ({
+		entry,
+		attempt,
+		outcome: attemptOutcome(attempt)
+	})).filter(({ outcome }) => outcome !== "pass" && outcome !== "skipped"));
+}
+function renderSummary(c, e, attemptDir) {
+	const { record } = e;
+	const lines = [];
+	if (record.evals.length) lines.push(c.bold("Summary"), ...tree(c, record.evals));
+	const all = failingAttempts(record.evals);
+	const missed = all.filter(({ entry, attempt }) => isUngatedMiss(entry, attempt));
+	const failing = all.filter((f) => !missed.includes(f));
+	if (failing.length) {
+		lines.push("", c.bold(c.red(`Failures (${failing.length})`)));
+		for (const kind of KINDS) {
+			const members = failing.filter(({ attempt, outcome }) => kind.test(attempt, outcome));
+			if (!members.length) continue;
+			lines.push("", c.bold(`${kind.title} (${members.length})`));
+			for (const { entry, attempt, outcome } of members) {
+				const result = resultFor(entry, attempt, e.results);
+				const which = entry.attempts.length > 1 ? `  ${c.dim(attempt.id)}` : "";
+				const gated = entry.cells.find((x) => x.key === attempt.cell)?.gate !== "none";
+				lines.push(` ${mark(c, outcome)} ${entry.id}${which}${gated ? "" : `  ${c.dim("(not gated)")}`}`);
+				if (outcome !== "cancelled") for (const line of failureLines(c, result, { max: FAILURE_LINES })) lines.push(`   ${line}`);
+				if (!attempt.error?.prepare) lines.push(`   ${c.dim("record")}  ${attemptDir(entry.id, attempt.cell, attempt.n)}`);
+			}
+		}
+	}
+	if (missed.length) {
+		lines.push("", c.bold(`Expected misses, not gated (${missed.length})`));
+		for (const { entry, attempt } of missed) {
+			const which = entry.attempts.length > 1 ? `  ${c.dim(attempt.id)}` : "";
+			const [reason] = failureLines(colors(false), resultFor(entry, attempt, e.results), { max: 1 }).filter((l) => l.trim());
+			lines.push(` ${MISS_MARK(c)} ${entry.id}${which}`);
+			if (reason) lines.push(`   ${c.dim(reason.trim())}`);
+			lines.push(`   ${c.dim("record")}  ${attemptDir(entry.id, attempt.cell, attempt.n)}`);
+		}
+	}
+	for (const error of e.unhandledErrors) lines.push("", c.red(`error: ${error}`));
+	const cancelled = failing.filter((f) => f.outcome === "cancelled").length;
+	const label = record.summary.attempts === record.summary.evals ? "   Evals" : "Attempts";
+	const lifted = record.evals.flatMap((entry) => entry.cells.flatMap((cell) => cell.lift?.minLift !== void 0 && cell.lift.interval.lo < cell.lift.minLift ? [`${entry.id}  ${cell.key} ${liftLabel(cell.lift)}: its lower bound is below minLift ${Math.round(cell.lift.minLift * 100)}`] : []));
+	if (lifted.length) {
+		lines.push("", c.bold(c.red(`Lift below minLift (${lifted.length})`)));
+		for (const line of lifted) lines.push(` ${c.red("✗")} ${line}`);
+	}
+	if (record.status === "budget") lines.push("", c.yellow("Budget reached: attempts that hadn’t started were skipped"));
+	lines.push("", `${c.dim(label)}  ${totals(c, record.summary, cancelled)}`, `${c.dim("Duration")}  ${formatDuration(record.durationMs)}`);
+	const tokens = formatUsage(record.cost.usage);
+	if (tokens) lines.push(`  ${c.dim("Tokens")}  ${tokens}`);
+	lines.push(` ${c.dim("Results")}  ${e.summaryPath}`);
+	return lines;
+}
+//#endregion
+//#region src/ui/tags.ts
+const STOPWORDS = new Set("a an the and or of to in on for with without from by at as is are be it its that this when than then into via not no".split(" "));
+const MAX_WORDS = 3;
+const MAX_LENGTH = 24;
+const words = (name) => name.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w && !STOPWORDS.has(w));
+/**
+* Short handles for the evals of one file, e.g. `greet`: the first distinctive words of each
+* name, where words shared by most of the file's evals ("recommends Genkit over …") don't
+* count. Depends only on the file's evals, so a tag stays the same across runs and filters.
+*/
+function fileTags(evals, taken) {
+	const lists = evals.map((e) => words(e.name));
+	const df = /* @__PURE__ */ new Map();
+	for (const list of lists) for (const w of new Set(list)) df.set(w, (df.get(w) ?? 0) + 1);
+	const common = (w) => evals.length > 1 && (df.get(w) ?? 0) > evals.length / 2;
+	const candidates = lists.map((list) => {
+		const rare = list.filter((w) => !common(w));
+		return rare.length ? rare : list.length ? list : ["eval"];
+	});
+	const tags = /* @__PURE__ */ new Map();
+	const clip = (tag) => tag.slice(0, MAX_LENGTH).replace(/-+$/, "");
+	const prefix = (list, n) => clip(list.slice(0, n).join("-"));
+	evals.forEach((e, i) => {
+		const own = candidates[i] ?? ["eval"];
+		let tag = prefix(own, 1);
+		for (let n = 1; n <= MAX_WORDS; n++) {
+			tag = prefix(own, n);
+			if (!candidates.some((other, j) => j !== i && prefix(other, n) === tag) && !taken.has(tag)) break;
+		}
+		let unique = tag;
+		for (let k = 2; taken.has(unique); k++) unique = `${tag}-${k}`;
+		taken.add(unique);
+		tags.set(e.id, unique);
+	});
+	return tags;
+}
+/** Tags evals as their files are collected; later files never rename earlier tags. */
+var Tagger = class {
+	#tags = /* @__PURE__ */ new Map();
+	#taken = /* @__PURE__ */ new Set();
+	addFile(attempts) {
+		const fresh = [...new Map(attempts.map((a) => [a.id, a])).values()].filter((e) => !this.#tags.has(e.id));
+		for (const [id, tag] of fileTags(fresh, this.#taken)) this.#tags.set(id, tag);
+	}
+	/** `greet#1`: the eval's tag and run number. */
+	label(id, attempt) {
+		let tag = this.#tags.get(id);
+		if (!tag) {
+			this.addFile([{
+				id,
+				name: id.split(" › ").at(-1) ?? id
+			}]);
+			tag = this.#tags.get(id) ?? "eval";
+		}
+		return `${tag}#${attempt}`;
+	}
+};
+//#endregion
+//#region src/ui/agent.ts
+const MAX_LINES = 12;
+const WORD = {
+	fail: "FAIL",
+	infra_error: "INFRA",
+	cancelled: "CANCELLED"
+};
+var AgentRenderer = class {
+	#o;
+	#c = colors(false);
+	#logs = /* @__PURE__ */ new Map();
+	#printed = /* @__PURE__ */ new Set();
+	/** `[key]` prefixes for `-v` lines, from each attempt's start. */
+	#labels = /* @__PURE__ */ new Map();
+	#tags = new Tagger();
+	constructor(options) {
+		this.#o = options;
+	}
+	#write(text) {
+		this.#o.out.write(`${text.trimEnd()}\n`);
+	}
+	#failure(result, cell, n) {
+		const outcome = outcomeOf(result);
+		if (outcome === "pass" || outcome === "skipped") return;
+		this.#printed.add(result.key);
+		const kind = outcome === "fail" ? result.meta?.errorKind ?? "assertion" : null;
+		const detail = [
+			formatDuration(result.durationMs),
+			kind,
+			result.attempt?.gate === "none" ? "not gated" : ""
+		].filter(Boolean).join(", ");
+		const which = result.attempt?.label ? ` [${result.attempt.label}]` : "";
+		const missed = outcome === "fail" && result.attempt?.gate === "none";
+		this.#write(`${missed ? "MISS" : WORD[outcome]} ${result.id}${which} (${detail})`);
+		if (outcome !== "cancelled") {
+			const lines = failureLines(this.#c, result, { max: MAX_LINES });
+			for (const line of missed ? lines.filter((l) => l.trim()).slice(0, 1) : lines) this.#write(`  ${line}`);
+		}
+		const logs = missed ? void 0 : this.#logs.get(result.key);
+		if (logs?.length) {
+			this.#write("  console:");
+			for (const line of capLines(logs.join("\n"), MAX_LINES)) this.#write(`    ${line}`);
+		}
+		if (!result.meta?.prepare) this.#write(`  record: ${this.#o.attemptDir(result.id, cell, n)}`);
+	}
+	onEvent(e) {
+		switch (e.type) {
+			case "plan":
+				for (const line of e.lines) this.#write(line);
+				for (const w of e.sandboxWarnings ?? []) this.#write(sandboxWarningLine(w));
+				return;
+			case "run-start":
+				this.#write(`reeval run: ${e.files} eval file${e.files === 1 ? "" : "s"}`);
+				return;
+			case "collected":
+				this.#tags.addFile(e.evals);
+				return;
+			case "eval-start": {
+				const tag = this.#tags.label(e.id, e.attempt?.n ?? 1);
+				this.#labels.set(e.key, `[${tag} ${attemptAxes(e.attempt, "agent")}]`);
+				return;
+			}
+			case "debug": {
+				const label = this.#labels.get(e.key) ?? `[${e.key}]`;
+				for (const line of debugLines(this.#c, e.line, this.#o.verbosity === 2)) this.#write(`${label} ${line}`);
+				return;
+			}
+			case "log": {
+				if (!e.key) return;
+				const logs = this.#logs.get(e.key) ?? [];
+				logs.push(...e.text.replace(/\n$/, "").split("\n"));
+				this.#logs.set(e.key, logs);
+				return;
+			}
+			case "eval-end": {
+				const { attempt } = e.result;
+				this.#failure(e.result, attempt?.cell.key ?? "", attempt?.n ?? 1);
+				return;
+			}
+			case "prepare":
+				for (const line of prepareLines(this.#c, e, MAX_LINES)) this.#write(line);
+				return;
+			case "notice":
+				if (e.level !== "info") this.#write(e.text);
+				return;
+			case "run-end": {
+				const failing = failingAttempts(e.record.evals);
+				for (const { entry, attempt, outcome } of failing) {
+					const result = resultFor(entry, attempt, e.results);
+					if (outcome === "cancelled" && !this.#printed.has(result.key)) this.#failure(result, attempt.cell, attempt.n);
+				}
+				for (const error of e.unhandledErrors) this.#write(`ERROR ${error}`);
+				const s = e.record.summary;
+				const cancelled = failing.filter((f) => f.outcome === "cancelled").length;
+				const parts = [
+					s.pass && `${s.pass} passed`,
+					s.fail - s.notGated - cancelled > 0 && `${s.fail - s.notGated - cancelled} failed`,
+					s.notGated > 0 && `${s.notGated} missed, not gated`,
+					s.infraError && `${s.infraError} infra error`,
+					cancelled && `${cancelled} cancelled`,
+					s.skipped && `${s.skipped} skipped`
+				].filter(Boolean);
+				const scope = s.attempts === s.evals ? "" : ` (${s.attempts} attempts, ${s.evals} evals)`;
+				this.#write(parts.length ? `${parts.join(", ")}${scope}` : "no evals ran");
+				this.#write(`summary: ${e.summaryPath}`);
+				return;
+			}
+			default: return;
+		}
+	}
+	close() {}
+};
+//#endregion
+//#region src/ui/plain.ts
+/** In a grouped block, an end line replaces its start line and keeps its start time. */
+const STARTS = {
+	"sandbox-ready": "sandbox",
+	"turn-end": "turn-start",
+	"check-end": "check-start",
+	"judge-end": "judge-start"
+};
+const ERROR_LINES = 12;
+/** GitHub Actions workflow-command escaping. */
+const ghEscape = (s, property = false) => {
+	const out = s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+	return property ? out.replace(/:/g, "%3A").replace(/,/g, "%2C") : out;
+};
+/** The eval file's line in Vitest's formatted error (`❯ evals/a.eval.ts:7:33`), if any. */
+function locate(result) {
+	const text = stripAnsi(result.formattedErrors[0] ?? "");
+	const file = result.file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const match = new RegExp(`❯ ${file}:(\\d+):(\\d+)`).exec(text);
+	return match?.[1] && match[2] ? {
+		line: match[1],
+		col: match[2]
+	} : void 0;
+}
+var PlainRenderer = class {
+	#o;
+	#c;
+	#tags = new Tagger();
+	#running = /* @__PURE__ */ new Map();
+	#now;
+	#queued = /* @__PURE__ */ new Set();
+	#runStartedAt = 0;
+	#lastWrite = 0;
+	#timer;
+	constructor(options) {
+		this.#o = options;
+		this.#c = options.colors;
+		this.#now = options.now ?? Date.now;
+		const { heartbeatMs } = options.output;
+		if (options.timers !== false && heartbeatMs > 0) {
+			this.#timer = setInterval(() => this.tick(), Math.min(heartbeatMs, 5e3));
+			this.#timer.unref();
+		}
+	}
+	#write(text) {
+		this.#o.out.write(`${text.trimEnd()}\n`);
+		this.#lastWrite = this.#now();
+	}
+	#attempt(ref, startedAt) {
+		const n = ref.attempt?.n ?? 1;
+		const label = `[${this.#tags.label(ref.id, n)} ${attemptAxes(ref.attempt, this.#o.harness)}]`;
+		const ungated = ref.attempt?.gate === "none";
+		return {
+			key: ref.key,
+			id: ref.id,
+			label,
+			startedAt,
+			lines: [],
+			last: void 0,
+			ungated
+		};
+	}
+	#prefix(a) {
+		return this.#c.tag(a.label)(a.label);
+	}
+	#detail(a, line, prefixed) {
+		const body = line.debug ? `  ${line.text}` : `  ${this.#c.dim(offset(line.at - a.startedAt))} ${line.text}`;
+		return prefixed ? `${this.#prefix(a)}${body}` : body.slice(1);
+	}
+	get #streaming() {
+		return this.#o.output.logOrder === "stream" && this.#o.output.outputLogs === "full";
+	}
+	#add(a, line) {
+		a.lines.push(line);
+		if (this.#streaming) this.#write(this.#detail(a, line, true));
+	}
+	onEvent(e) {
+		const c = this.#c;
+		switch (e.type) {
+			case "run-start": {
+				this.#runStartedAt = e.at;
+				const files = `${e.files} eval file${e.files === 1 ? "" : "s"}`;
+				const order = `${this.#o.output.logOrder} logs`;
+				const setup = `harness ${e.harness} · sandbox ${e.sandbox} · concurrency ${e.concurrency}`;
+				this.#write(c.dim(`reeval ${e.version} · ${files} · ${setup} · ${order}`));
+				return;
+			}
+			case "plan":
+				for (const [i, line] of e.lines.entries()) this.#write(line.startsWith("warning:") ? c.yellow(line) : i === 0 ? line : c.dim(line));
+				for (const w of e.sandboxWarnings ?? []) this.#sandboxWarning(w);
+				return;
+			case "collected":
+				this.#tags.addFile(e.evals);
+				for (const x of e.evals) if (!x.skipped) this.#queued.add(x.key);
+				return;
+			case "eval-start": {
+				const a = this.#attempt(e, e.at);
+				a.last = e;
+				this.#queued.delete(e.key);
+				this.#running.set(e.key, a);
+				this.#write(`${this.#prefix(a)} ${c.dim("▶")} ${e.id}`);
+				return;
+			}
+			case "eval-progress": {
+				const a = this.#running.get(e.key);
+				if (!a) return;
+				a.last = e;
+				const { progress } = e;
+				const paint = a.ungated ? {
+					...c,
+					red: c.dim
+				} : c;
+				const line = {
+					at: progress.at,
+					text: progressLine(paint, progress),
+					kind: progress.kind
+				};
+				const start = STARTS[progress.kind];
+				const open = start && a.lines.findLastIndex((l) => l.kind === start);
+				if (!this.#streaming && open !== void 0 && open >= 0) {
+					line.at = a.lines[open]?.at ?? line.at;
+					a.lines.splice(open, 1);
+				}
+				this.#add(a, line);
+				return;
+			}
+			case "debug": {
+				const a = this.#running.get(e.key);
+				if (!a) return;
+				for (const text of debugLines(c, e.line, this.#o.verbosity === 2)) this.#add(a, {
+					at: e.line.at,
+					text,
+					debug: true
+				});
+				return;
+			}
+			case "log": {
+				const a = e.key ? this.#running.get(e.key) : void 0;
+				const label = e.stream === "stderr" ? c.yellow("stderr |") : c.dim("stdout |");
+				for (const text of e.text.replace(/\n$/, "").split("\n")) if (a) this.#add(a, {
+					at: e.at,
+					text: `${label} ${text}`
+				});
+				else this.#write(`${label} ${text}`);
+				return;
+			}
+			case "eval-end":
+				this.#end(e.result, e.at);
+				return;
+			case "prepare":
+				for (const line of prepareLines(c, e, ERROR_LINES)) this.#write(line);
+				if (e.state === "failed" && this.#o.output.githubActions) {
+					const { target, failure } = e.outcome;
+					const what = target.kind === "workspace" ? "The" : "Sandbox";
+					const title = ghEscape(`${what} ${target.label} failed to prepare`, true);
+					this.#write(`::error title=${title}::${ghEscape(failure.message)}`);
+				}
+				return;
+			case "notice": {
+				const paint = {
+					info: c.dim,
+					warn: c.yellow,
+					error: c.red
+				}[e.level];
+				this.#write(paint(e.text));
+				return;
+			}
+			case "run-end":
+				this.#write("");
+				for (const line of renderSummary(c, e, this.#o.attemptDir)) this.#write(line);
+				return;
+		}
+	}
+	#sandboxWarning(w) {
+		const c = this.#c;
+		const line = sandboxWarningLine(w);
+		this.#write(w.kind === "root" ? c.bold(c.red(line)) : c.yellow(line));
+		if (!this.#o.output.githubActions) return;
+		const file = w.file ? `file=${ghEscape(w.file, true)},` : "";
+		const title = w.kind === "root" ? "Sandbox runs as root" : "Sandbox has extra capabilities";
+		this.#write(`::warning ${file}title=${ghEscape(title, true)}::${ghEscape(w.message)}`);
+	}
+	#end(result, at) {
+		const c = this.#c;
+		const a = this.#running.get(result.key) ?? this.#attempt(result, at - result.durationMs);
+		this.#running.delete(result.key);
+		this.#queued.delete(result.key);
+		const outcome = outcomeOf(result);
+		const failed = outcome !== "pass" && outcome !== "skipped";
+		const time = outcome === "skipped" ? "" : `  ${c.dim(formatDuration(result.durationMs))}`;
+		const ungated = failed && result.attempt?.gate === "none" ? `  ${c.dim("(not gated)")}` : "";
+		const missed = ungated !== "" && outcome === "fail";
+		const head = `${this.#prefix(a)} ${missed ? MISS_MARK(c) : mark(c, outcome)} ${result.id}${time}${ungated}`;
+		const { outputLogs, githubActions, logPrefix } = this.#o.output;
+		const showDetail = !this.#streaming && a.lines.length > 0 && (outputLogs === "full" || outputLogs === "errors-only" && failed);
+		const judged = result.meta?.errorKind === "judge" && (showDetail || this.#streaming);
+		const errors = failed && outputLogs !== "none" && !judged ? missed ? failureLines(colors(false), result, { max: 1 }).filter((l) => l.trim()).slice(0, 1).map((l) => c.dim(l)) : failureLines(c, result, { max: ERROR_LINES }) : [];
+		const lines = a.lines.filter((l) => l.kind !== "cleanup").sort((x, y) => x.at - y.at);
+		const prefixed = logPrefix === "task";
+		const group = githubActions && showDetail && (!failed || missed);
+		this.#write(group ? `::group::${stripAnsi(head)}` : head);
+		if (showDetail) for (const line of lines) this.#write(this.#detail(a, line, prefixed));
+		for (const line of errors) this.#write(prefixed ? `${this.#prefix(a)}  ${line}` : ` ${line}`);
+		if (group) this.#write("::endgroup::");
+		if (githubActions && failed && !ungated && !result.meta?.prepare) {
+			const which = result.attempt?.label ? ` [${result.attempt.label}]` : "";
+			const title = ghEscape(`${result.id}${which}`, true);
+			const message = ghEscape(failureLines(colors(false), result, { max: ERROR_LINES }).join("\n"));
+			const at = locate(result);
+			const where = at ? `,line=${at.line},col=${at.col}` : "";
+			this.#write(`::error file=${ghEscape(result.file, true)}${where},title=${title}::${message}`);
+		}
+	}
+	/** Prints the heartbeat if nothing was written for `heartbeatMs` and evals are running. */
+	tick(now = this.#now()) {
+		const { heartbeatMs } = this.#o.output;
+		if (heartbeatMs <= 0 || this.#running.size === 0) return;
+		if (now - this.#lastWrite < heartbeatMs) return;
+		const c = this.#c;
+		const running = [...this.#running.values()].map((a) => {
+			const progress = a.last?.type === "eval-progress" ? a.last.progress : void 0;
+			return `${this.#prefix(a)} ${phaseOf(progress)} ${c.dim(formatDuration(now - a.startedAt))}`;
+		});
+		const queued = this.#queued.size ? `, ${this.#queued.size} queued` : "";
+		const elapsed = formatDuration(now - this.#runStartedAt);
+		this.#write(`${c.dim(`… ${this.#running.size} running${queued} after ${elapsed}:`)} ${running.join(c.dim(", "))}`);
+	}
+	close() {
+		clearInterval(this.#timer);
+	}
+};
+//#endregion
+//#region src/ui/mode.ts
+const set = (env, name) => {
+	const value = env[name];
+	return !!value && value !== "false" && value !== "0";
+};
+const CI_VARS = [
+	"BUILD_ID",
+	"BUILD_NUMBER",
+	"CI",
+	"CI_APP_ID",
+	"CI_BUILD_ID",
+	"CI_BUILD_NUMBER",
+	"CI_NAME",
+	"CONTINUOUS_INTEGRATION",
+	"RUN_ID",
+	"TEAMCITY_VERSION",
+	"GITHUB_ACTIONS"
+];
+const isCI = (env) => CI_VARS.some((name) => set(env, name));
+function pick(name, value, allowed) {
+	if (value === void 0 || value === "") return void 0;
+	if (value === "auto" || allowed.includes(value)) return value;
+	throw new UsageError(`${name} must be one of ${[...allowed, "auto"].join(", ")}`);
+}
+function parseHeartbeat(value) {
+	if (!value) return 6e4;
+	const match = /^(\d+(?:\.\d+)?)(ms|s|m)?$/.exec(value);
+	if (!match) throw new UsageError(`REEVAL_HEARTBEAT must be a duration like 30s or 0`);
+	const unit = {
+		ms: 1,
+		s: 1e3,
+		m: 6e4
+	}[match[2] ?? "s"] ?? 1e3;
+	return Number(match[1]) * unit;
+}
+function resolveOutput(input) {
+	const { flags, env } = input;
+	const ci = isCI(env);
+	const githubActions = set(env, "GITHUB_ACTIONS");
+	const ui = pick("--ui", flags.ui ?? env.REEVAL_UI, [
+		"live",
+		"plain",
+		"agent"
+	]);
+	const requested = ui && ui !== "auto" ? ui : input.agent ? "agent" : ci || !input.isTTY ? "plain" : "live";
+	const mode = requested === "live" ? "plain" : requested;
+	const order = pick("--log-order", flags.logOrder ?? env.REEVAL_LOG_ORDER, ["stream", "grouped"]);
+	const logOrder = order && order !== "auto" ? order : ci ? "grouped" : "stream";
+	const prefix = pick("--log-prefix", flags.logPrefix ?? env.REEVAL_LOG_PREFIX, ["task", "none"]);
+	const logPrefix = prefix && prefix !== "auto" ? prefix : githubActions && logOrder === "grouped" ? "none" : "task";
+	const logs = pick("--output-logs", flags.outputLogs ?? env.REEVAL_OUTPUT_LOGS, [
+		"full",
+		"errors-only",
+		"none"
+	]);
+	return {
+		requested,
+		mode,
+		logOrder,
+		logPrefix,
+		outputLogs: logs && logs !== "auto" ? logs : "full",
+		color: env.NO_COLOR ? false : env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" ? set(env, "FORCE_COLOR") : mode === "agent" ? false : input.isTTY || githubActions,
+		githubActions,
+		heartbeatMs: mode === "agent" ? 0 : parseHeartbeat(env.REEVAL_HEARTBEAT)
+	};
+}
+//#endregion
+//#region src/ui/index.ts
+function createRenderer(options) {
+	const out = { write: (text) => options.out.write(redactSecrets(text)) };
+	if (options.output.mode === "agent") return new AgentRenderer({
+		...options,
+		out
+	});
+	return new PlainRenderer({
+		...options,
+		out,
+		colors: colors(options.output.color)
+	});
+}
+//#endregion
+//#region src/cli.ts
+const HISTORY_COMMANDS = {
+	record: 1,
+	history: 1,
+	show: 1,
+	compare: 1,
+	checkout: 1,
+	query: 1,
+	analyze: 1
+};
+const EXPECTED_ERRORS = [
+	"CommandError",
+	"RefError",
+	"HistoryError",
+	"StudioBuildError"
+];
+const EXIT = {
+	ok: 0,
+	failed: 1,
+	usage: 2,
+	infra: 3,
+	interrupted: 130,
+	terminated: 143
+};
+const version = PACKAGE_VERSION;
+const HELP = helpText(version);
+const { green, red, dim } = colors(!!process.stdout.isTTY && !process.env.NO_COLOR);
+const startedAt = Date.now();
+const argv = process.argv.slice(2);
+/** What the invocation log needs from the command as it goes. */
+const invocation = {
+	runId: null,
+	unhandledErrors: []
+};
+/** Set by the first Ctrl-C or SIGTERM of `reeval run`. */
+let interrupted = false;
+/** The last signal that cancelled the run: 130 after SIGINT, 143 after SIGTERM. */
+let stopCode = EXIT.interrupted;
+async function run(argv) {
+	const { values, positionals } = parseCli(argv);
+	invocation.flags = values;
+	if (values.version) {
+		console.log(version);
+		return EXIT.ok;
+	}
+	const [command, ...filters] = positionals;
+	if (values.help || !command) {
+		console.log(HELP);
+		return values.help ? EXIT.ok : EXIT.usage;
+	}
+	if (command === "init") {
+		const { initCommand } = await import("./init-z2ZPn9Tj.js");
+		return initCommand(values, filters, {
+			out: (s) => console.log(s),
+			input: process.stdin,
+			output: process.stdout,
+			cwd: process.cwd()
+		});
+	}
+	if (command === "doctor") {
+		const { doctorCommand } = await import("./doctor-CxlH1pDM.js");
+		return doctorCommand(values, {
+			out: (s) => console.log(s),
+			color: !!process.stdout.isTTY && !process.env.NO_COLOR,
+			confirm: process.stdin.isTTY && process.stdout.isTTY ? confirm : void 0
+		});
+	}
+	if (command === "report") {
+		const { reportCommand } = await import("./command-D-jnQWVG.js");
+		return reportCommand(values, filters, {
+			out: (s) => console.log(s),
+			err: (s) => console.error(dim(s)),
+			interactive: !!process.stdin.isTTY && !!process.stdout.isTTY,
+			confirm: process.stdin.isTTY && process.stdout.isTTY ? confirm : void 0
+		});
+	}
+	const configPath = configPathFor(values.config);
+	if (command === "image") {
+		if (filters[0] !== "build") throw new UsageError(`Unknown command "image ${filters[0] ?? ""}". Did you mean reeval image build?`);
+		return imageBuildCommand(values, configPath, filters.slice(1));
+	}
+	if (command === "studio") {
+		const config = await loadConfig(configPath, "studio");
+		const { studioCommand } = await import("./command-BSJzHMtP.js");
+		return studioCommand({
+			config,
+			flags: values,
+			version,
+			build: filters[0] === "build"
+		});
+	}
+	if (command === "mcp") {
+		if (!values.http) console.log = console.info = console.debug = console.error;
+		const config = await loadConfig(configPath, "mcp");
+		const { mcpCommand } = await import("./command-DQAvbG7d.js");
+		return mcpCommand({
+			config,
+			flags: values,
+			version
+		});
+	}
+	if (command in HISTORY_COMMANDS) {
+		const config = await loadConfig(configPath, command);
+		const commands = await import("./commands-A4udfyKZ.js");
+		const ctx = {
+			config,
+			flags: values,
+			out: (s) => console.log(s)
+		};
+		switch (command) {
+			case "record": return commands.recordCommand(ctx, filters);
+			case "history": return commands.historyCommand(ctx, filters);
+			case "show": return commands.showCommand(ctx, filters);
+			case "compare": return commands.compareCommand(ctx, filters);
+			case "checkout": return commands.checkoutCommand(ctx, filters);
+			case "query": {
+				const { queryCommand } = await import("./query-DR4m6CXf.js");
+				return queryCommand({
+					...ctx,
+					err: (s) => console.error(dim(s))
+				}, filters);
+			}
+			case "analyze": {
+				loadEnvFiles(configPath);
+				const { analyzeCommand } = await import("./command-CEm8PZ1N.js");
+				return analyzeCommand({
+					...ctx,
+					err: (s) => console.error(dim(s))
+				}, filters);
+			}
+		}
+	}
+	if (command === "clean") return cleanCommand(values, configPath);
+	if (command !== "run") throw new UsageError(`Unknown command "${command}". Run reeval --help.`);
+	return runCommand(values, configPath, filters);
+}
+/** Asks a yes/no question on the terminal; anything but y or yes is no. */
+async function confirm(question) {
+	const { createInterface } = await import("node:readline/promises");
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return /^y(es)?$/i.test((await rl.question(question)).trim());
+	} finally {
+		rl.close();
+	}
+}
+/** `reeval clean`: removes local debug data, all of it or all but the newest `--keep` runs. */
+async function cleanCommand(flags, configPath) {
+	const config = await loadConfig(configPath, "clean");
+	let keep = 0;
+	if (flags.keep !== void 0) {
+		keep = Number(flags.keep);
+		if (!(Number.isInteger(keep) && keep >= 0)) throw new UsageError(`--keep must be a whole number (got ${flags.keep})`);
+	}
+	const { debugRoot, pruneDebug } = await import("./files-BvHCFWgD.js");
+	const { formatBytes } = await import("./debug-SEmW4w8f.js");
+	const { runs, bytes } = await pruneDebug(config.root, keep);
+	const where = fromCwd(debugRoot(config.root)) || ".";
+	console.log(runs.length ? `Removed debug data for ${runs.length} run${runs.length === 1 ? "" : "s"} (${formatBytes(bytes)}) from ${where}` : `No debug data to remove in ${where}`);
+	if (flags.images) {
+		const { pruneImages } = await import("./src-N7E_mfcZ.js");
+		const { requireDocker } = await import("./providers-BUOxitcT.js");
+		await requireDocker();
+		const removed = await pruneImages();
+		console.log(removed ? `Removed ${removed} image${removed === 1 ? "" : "s"} reeval built that nothing uses` : "No leftover images to remove");
+	}
+	return EXIT.ok;
+}
+/** `-v` is 1 and `-vv` (or `--trace`) is 2. */
+function verbosityOf(flags) {
+	if (flags.trace) return 2;
+	return Math.min(2, flags.verbose?.length ?? 0);
+}
+/**
+* `reeval image build`: collects the evals (as `--dry-run` does) and builds every image their Docker
+* sandboxes need; with `--dry-run`, lists them instead. Without a config, just reeval's image.
+*/
+async function imageBuildCommand(flags, configPath, filters) {
+	const { buildImages, imagePlanLines, imageTargets } = await import("./images-Cc1-coFc.js");
+	const { docker } = await import("./sandbox.js");
+	let root = process.cwd();
+	const { fakeHarness } = await import("./harness.js");
+	let uses = [{
+		id: "",
+		harness: fakeHarness(),
+		sandbox: docker()
+	}];
+	if (configPath) {
+		const { runId, stagingDir, config, runs, tags, concurrency, profile } = await startRun(await prepareRun({
+			...flags,
+			"dry-run": true
+		}, configPath));
+		root = config.root;
+		const { runEngine } = await import("./node-kG64XxdE.js");
+		let planned = [];
+		await runEngine({
+			run: JSON.parse(JSON.stringify({
+				runId,
+				stagingDir,
+				config,
+				runs,
+				tags,
+				concurrency,
+				profile
+			})),
+			filters,
+			onPlan: async (collected) => {
+				if (collected.unmatched.length) throw unmatchedFilter(config, collected.unmatched);
+				planned = collected.planned.filter((p) => !p.attempt.plan.skip);
+				return false;
+			}
+		});
+		uses = planned.length ? planned.map((p) => ({
+			id: p.id,
+			harness: p.attempt.harness,
+			sandbox: p.attempt.sandbox
+		})) : config.harness.map((harness) => ({
+			id: "",
+			harness,
+			sandbox: config.sandbox
+		}));
+	}
+	const targets = imageTargets(uses);
+	if (targets.length === 0) {
+		console.log("No eval runs in a Docker sandbox, so there are no images to build.");
+		return EXIT.ok;
+	}
+	if (flags["dry-run"]) {
+		for (const line of await imagePlanLines(targets, root)) console.log(line);
+		return EXIT.ok;
+	}
+	const { PrepareError } = await import("./provider-BDbNOQhQ.js");
+	let built;
+	try {
+		built = await buildImages(targets, root, {
+			log: (line) => console.log(dim(line)),
+			force: !!flags.force
+		});
+	} catch (error) {
+		if (error instanceof PrepareError && error.failure.usage) throw new UsageError(error.message);
+		throw error;
+	}
+	for (const b of built) {
+		if (b.ok) {
+			const id = b.image.id.replace(/^sha256:/, "").slice(0, 12);
+			console.log(`${green("✓")} ${green(`${b.id}: ${b.image.ref}`)}${dim(` ${id}`)}`);
+			continue;
+		}
+		const uses = b.evals ? ` (${b.evals} eval${b.evals === 1 ? "" : "s"})` : "";
+		const [headline = "", ...rest] = b.failure.message.split("\n");
+		console.log(`${red("✗")} ${red(`${b.id}${uses}: ${headline}`)}`);
+		for (const line of rest) console.log(`  ${line}`);
+	}
+	const failed = built.filter((b) => !b.ok);
+	const n = built.length;
+	console.log(failed.length ? red(`${failed.length} of ${n} image${n === 1 ? "" : "s"} failed to build`) : dim(`${n} image${n === 1 ? "" : "s"} ready`));
+	if (!failed.length) return EXIT.ok;
+	return failed.every((b) => !b.ok && b.failure.usage) ? EXIT.usage : EXIT.infra;
+}
+/** `reeval run`: check, plan, run the engine, then write the run and pick the exit code. */
+async function runCommand(flags, configPath, filters) {
+	const setup = await prepareRun(flags, configPath);
+	const ctx = await startRun(setup);
+	invocation.runId = ctx.runId;
+	const { engineVersions } = await import("./node-kG64XxdE.js");
+	const renderer = createRenderer({
+		out: setup.json ? { write: () => true } : process.stdout,
+		output: setup.output,
+		verbosity: ctx.verbosity ?? 0,
+		harness: setup.config.harness[0]?.kind ?? "agent",
+		attemptDir: (id, cell, n) => fromCwd(join(ctx.scratch, ctx.runId, evalSlug(id), evalSlug(cell), String(n)))
+	});
+	let executed;
+	try {
+		executed = await executeRun(ctx, setup, filters, renderer);
+	} catch (error) {
+		renderer.close();
+		await rm(ctx.stagingDir, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+	const { engineRun, plan, sandboxVersions, budgetReached, live } = executed;
+	invocation.unhandledErrors = engineRun.unhandledErrors;
+	if ((interrupted || engineRun.cancelled) && plan?.sandboxes.some((s) => s.kind === "docker")) {
+		const { removeRunContainers } = await import("./docker-DnWAVdEm.js");
+		await removeRunContainers(ctx.runId);
+	}
+	if (engineRun.stopped || !plan) {
+		live?.remove();
+		renderer.close();
+		return EXIT.ok;
+	}
+	const { lockfiles } = await import("./state-Cyw3QTsN.js");
+	const { writeScratchRun } = await import("./results-CeXb8Wde.js");
+	const run = await writeScratchRun({
+		ctx,
+		author: ctx.author,
+		engine: engineRun,
+		startedAt: ctx.startedAt,
+		endedAt: /* @__PURE__ */ new Date(),
+		interrupted: interrupted || engineRun.cancelled,
+		budgetReached: budgetReached(),
+		plan,
+		es: version,
+		enginePackages: engineVersions,
+		sandbox: sandboxVersions,
+		worktreePatch: ctx.worktreePatch,
+		lockfiles: await lockfiles(ctx.config.root),
+		git: ctx.git,
+		runner: runnerInfo()
+	}, () => live?.stop());
+	const { record } = run;
+	const { pruneDebug } = await import("./files-BvHCFWgD.js");
+	await pruneDebug(ctx.config.root, ctx.config.debug.keep).catch(() => {});
+	const summary = run.artifactDir ? join(run.artifactDir, "summary.md") : run.recordPath;
+	renderer.onEvent({
+		type: "run-end",
+		at: Date.now(),
+		record,
+		summaryPath: fromCwd(summary),
+		results: engineRun.evals,
+		unhandledErrors: engineRun.unhandledErrors
+	});
+	renderer.close();
+	const stepSummary = process.env.GITHUB_STEP_SUMMARY;
+	if (stepSummary && run.artifactDir) await appendFile(stepSummary, await readFile(summary)).catch(() => {});
+	const { config } = ctx;
+	const mode = setup.record;
+	if ((flags.record || mode === "always" || mode === "ci" && inCI()) && record.status !== "interrupted") {
+		const { record: recordCmd } = await import("./commands-A4udfyKZ.js");
+		const allow = record.status === "budget" ? { "allow-incomplete": true } : {};
+		console.log(await recordCmd(config, record.runId, {
+			...flags,
+			...allow
+		}));
+	}
+	if (interrupted || engineRun.cancelled) return stopCode;
+	if (engineRun.unhandledErrors.length > 0) return EXIT.failed;
+	const outcome = runOutcome(record);
+	return outcome === "fail" ? EXIT.failed : outcome === "infra_error" ? EXIT.infra : EXIT.ok;
+}
+/** Everything that can fail before the evals are collected: output mode, config, profile, flags. */
+async function prepareRun(flags, configPath) {
+	const output = resolveOutput({
+		flags: {
+			ui: flags.ui,
+			logOrder: flags["log-order"],
+			logPrefix: flags["log-prefix"],
+			outputLogs: flags["output-logs"]
+		},
+		env: process.env,
+		isTTY: !!process.stdout.isTTY,
+		agent: detectAgent().name
+	});
+	if (flags.json && !flags["dry-run"]) throw new UsageError("reeval run --json only prints the plan: add --dry-run. A run writes its record to .reeval/runs; read it with reeval show --json.");
+	loadEnvFiles(configPath);
+	const named = flags.profile ?? (process.env.REEVAL_PROFILE || void 0);
+	const config = await loadConfig(configPath, "run", named);
+	const profile = selectProfile(config, flags.profile);
+	let runs;
+	if (flags.runs !== void 0) {
+		runs = Number(flags.runs);
+		if (!(Number.isInteger(runs) && runs >= 1)) throw new UsageError(`--runs must be a whole number of at least 1 (got ${flags.runs})`);
+	}
+	const sandboxes = [config.sandbox, ...profile?.defaults.sandbox ? [profile.defaults.sandbox] : []];
+	const concurrency = await resolveConcurrency(config, flags.concurrency, async () => {
+		if (!sandboxes.some((s) => s.kind === "docker")) return hostCapacity();
+		const { dockerCapacity } = await import("./src-N7E_mfcZ.js");
+		return await dockerCapacity() ?? hostCapacity();
+	});
+	return {
+		output,
+		config,
+		profile,
+		runs,
+		tags: [...flags.tag ?? [], ...profile?.tags ?? []],
+		concurrency,
+		budget: profile?.budget ?? config.budget,
+		record: profile?.record ?? config.record,
+		dryRun: !!flags["dry-run"],
+		json: !!flags.json,
+		force: !!flags.force,
+		verbosity: verbosityOf(flags),
+		configFile: configPath && configLabel(configPath),
+		/** Named in the plan line when the project root isn't the current directory. */
+		configElsewhere: !!configPath && dirname(configPath) !== process.cwd()
+	};
+}
+/** The run's id and the state it starts from: commit, uncommitted changes, author. */
+async function startRun({ config, profile, runs, tags, concurrency, verbosity, configFile }) {
+	const startedAt = /* @__PURE__ */ new Date();
+	const git = await gitInfo(config.root, [config.history.dir]);
+	const { worktreePatch } = await import("./state-Cyw3QTsN.js");
+	const patch = git?.dirty ? await worktreePatch(config.root, [config.history.dir]) : null;
+	const who = await author(config.root);
+	const { stagingDir, sweepStaging } = await import("./results-CeXb8Wde.js");
+	const { scratchDir } = await import("./files--6CEUXm7.js");
+	const scratch = scratchDir(config.root);
+	const stamps = new Set([scratch, config.history.dir].flatMap((dir) => existsSync(dir) ? readdirSync(dir).map((name) => name.slice(0, 16)) : []));
+	let runId = newRunId(startedAt, git?.sha ?? null, who);
+	for (let n = 1; stamps.has(runId.slice(0, 16)); n++) runId = newRunId(new Date(startedAt.getTime() + n * 1e3), git?.sha ?? null, who);
+	await sweepStaging(config.root);
+	return {
+		runId,
+		stagingDir: stagingDir(config.root, runId),
+		config,
+		runs,
+		tags,
+		concurrency,
+		profile,
+		verbosity,
+		configFile,
+		startedAt,
+		git,
+		worktreePatch: patch,
+		author: who,
+		scratch
+	};
+}
+function noMatch(config, filters, tags) {
+	const narrowed = [filters.length ? `filter "${filters.join(" ")}"` : "", tags.length ? `tags ${tags.join(", ")}` : ""].filter(Boolean);
+	return new UsageError(`No evals matched ${config.include.join(", ")}${narrowed.length ? ` with ${narrowed.join(" and ")}` : ""}`);
+}
+function unmatchedFilter(config, parts) {
+	const which = parts.map((p) => `"${p}"`).join(", ");
+	return new UsageError(`filter ${which} ${parts.length === 1 ? "matches" : "match"} no eval file, eval name or cell in ${config.include.join(", ")}`);
+}
+/**
+* Collects the evals and prints the plan; stops there for `--dry-run`, or on a budget, credential
+* or Docker problem (exit 2). Then runs the engine with live output and Ctrl-C handling.
+*/
+async function executeRun(ctx, setup, filters, renderer) {
+	const { runId, stagingDir, config, runs, tags, concurrency, profile, verbosity, configFile } = ctx;
+	const { runEngine } = await import("./node-kG64XxdE.js");
+	const { buildPlan, checkAttemptBudget, planDocument, planLine, planTable } = await import("./plan-gwk6dJ8c.js");
+	let plan;
+	let sandboxVersions = { images: [] };
+	let preflightStop;
+	let reached = false;
+	let budgetTimer;
+	let toRun = [];
+	let live;
+	const onPlan = async ({ planned, excluded, matched, unmatched }) => {
+		if (unmatched.length) throw unmatchedFilter(config, unmatched);
+		if (matched === 0) throw noMatch(config, filters, tags);
+		toRun = planned;
+		for (const p of planned) for (const name of p.attempt.secretVars) registerSecret(process.env[name]);
+		plan = await buildPlan({
+			planned,
+			profile,
+			budget: setup.budget,
+			concurrency,
+			root: config.root,
+			historyDir: config.history.dir
+		});
+		const { imageStages, imageTargets } = await import("./images-Cc1-coFc.js");
+		const targets = imageTargets(planned.filter((p) => !p.attempt.plan.skip).map((p) => ({
+			id: p.id,
+			harness: p.attempt.harness,
+			sandbox: p.attempt.sandbox
+		})));
+		if (setup.json) {
+			const images = await Promise.all(targets.map(async (t) => ({
+				id: t.id,
+				harness: t.harness,
+				evals: t.evals,
+				stages: await imageStages(t, config.root)
+			})));
+			const doc = planDocument(plan, planned, excluded, images);
+			process.stdout.write(`${JSON.stringify(doc, null, 2)}\n`);
+			return false;
+		}
+		const lines = [planLine(plan, setup.configElsewhere ? configFile : void 0)];
+		if (setup.dryRun) {
+			const todos = excluded.filter((e) => e.mode === "todo").map((e) => e.id);
+			lines.push(...planTable(plan, todos));
+			const { imageStatusLines } = await import("./images-Cc1-coFc.js");
+			const { dockerAvailable } = await import("./src-N7E_mfcZ.js");
+			if (targets.length && await dockerAvailable()) lines.push(...await imageStatusLines(targets, config.root));
+			else if (targets.length) lines.push("images  not checked: Docker is not running");
+		}
+		lines.push(...plan.warnings.map((w) => `warning: ${w}`));
+		lines.push(...plan.hints.map((h) => `hint: ${h}`));
+		renderer.onEvent({
+			type: "plan",
+			at: Date.now(),
+			lines,
+			sandboxWarnings: plan.sandboxWarnings
+		});
+		if (setup.dryRun) return false;
+		checkAttemptBudget(plan, setup.force, config.file);
+		const missing = missingCredentials(config, process.env, {
+			harnesses: plan.harnessDescriptors,
+			profile
+		});
+		if (missing.length) throw new UsageError(`Missing credentials: ${missing.join(", ")}. Set them in the environment or .env.local.`);
+		const malformed = malformedCredentials(config, process.env, { harnesses: plan.harnessDescriptors });
+		if (malformed.length) throw new UsageError(`Credentials with whitespace or a line break in them: ${malformed.join(", ")}. A key copied from a wrapped terminal line picks these up; set it again as one line.`);
+		const { prepareWorkspaces, workspaceKey } = await import("./workspace-CyoXG6CY.js");
+		const live = planned.filter((p) => !p.attempt.plan.skip);
+		const outcomes = await prepareWorkspaces(live.flatMap(({ attempt: a }) => a.workspace ? [{
+			workspace: a.workspace,
+			environment: a.cell.environment
+		}] : []), {
+			root: config.root,
+			runId
+		});
+		for (const o of outcomes) {
+			const at = Date.now();
+			if (o.ok) {
+				const text = `workspace ${workspaceLabel(o.workspace)} at ${o.prepared.commit.slice(0, 12)}`;
+				renderer.onEvent({
+					type: "notice",
+					at,
+					level: "info",
+					text
+				});
+				continue;
+			}
+			const key = workspaceKey(o.workspace);
+			const user = live.find((p) => p.attempt.workspace && workspaceKey(p.attempt.workspace) === key);
+			if (!user) continue;
+			const target = {
+				kind: "workspace",
+				key: o.label,
+				label: `workspace ${o.label}`,
+				sandbox: user.attempt.sandbox,
+				harness: user.attempt.harness,
+				setBy: o.setBy,
+				runWide: false
+			};
+			renderer.onEvent({
+				type: "prepare",
+				at,
+				state: "failed",
+				outcome: {
+					target,
+					ok: false,
+					failure: o.failure,
+					ms: 0
+				}
+			});
+		}
+		try {
+			sandboxVersions = await preflight(planned.filter((p) => !p.attempt.plan.skip).map((p) => ({
+				harness: p.attempt.harness,
+				sandbox: p.attempt.sandbox,
+				setBy: p.attempt.setBy
+			})), {
+				root: config.root,
+				runId,
+				onEvent: (e) => renderer.onEvent({
+					type: "prepare",
+					at: Date.now(),
+					...e
+				})
+			});
+		} catch (error) {
+			if (error.name !== "PreflightInfraError") throw error;
+			preflightStop = error;
+			return false;
+		}
+		return true;
+	};
+	const startBudget = () => {
+		const { duration } = setup.budget;
+		if (duration === void 0 || budgetTimer) return;
+		budgetTimer = setTimeout(() => {
+			reached = true;
+			mkdirSync(stagingDir, { recursive: true });
+			writeFileSync(budgetMarker(stagingDir), `The run reached budget.duration ${duration} before this attempt started`);
+			renderer.onEvent({
+				type: "notice",
+				at: Date.now(),
+				level: "warn",
+				text: `Budget: ${duration} reached; running attempts finish, queued ones are skipped`
+			});
+		}, parseDuration(duration));
+		budgetTimer.unref();
+	};
+	let engineRun;
+	try {
+		engineRun = await runEngine({
+			run: JSON.parse(JSON.stringify({
+				runId,
+				stagingDir,
+				config,
+				runs,
+				tags,
+				concurrency,
+				profile,
+				verbosity,
+				configFile
+			})),
+			filters,
+			onPlan,
+			onRunStart: (files) => {
+				live = writeLiveProgress({
+					dir: stagingDir,
+					runId,
+					startedAt: ctx.startedAt,
+					planned: toRun
+				});
+				renderer.onEvent({
+					type: "run-start",
+					at: Date.now(),
+					version,
+					files,
+					harness: (plan?.harnesses ?? config.harness.map(harnessId)).join(", "),
+					sandbox: sandboxId(config.sandbox),
+					concurrency
+				});
+			},
+			onEvent: (e) => {
+				if (e.type === "eval-start") {
+					startBudget();
+					live?.start(e.key, e.at);
+				}
+				if (e.type === "eval-end") live?.end(e.result);
+				if (interrupted && e.type === "eval-end" && e.result.state === "skipped") return;
+				renderer.onEvent(e);
+			},
+			onCancellable: (cancel) => {
+				const onSignal = (signal) => {
+					stopCode = signal === "SIGTERM" ? EXIT.terminated : EXIT.interrupted;
+					if (interrupted) {
+						renderer.close();
+						process.exit(stopCode);
+					}
+					interrupted = true;
+					live?.phase("cancelling");
+					renderer.onEvent({
+						type: "notice",
+						at: Date.now(),
+						level: "warn",
+						text: "Cancelling: stopping agents and destroying sandboxes (Ctrl-C again to force)"
+					});
+					cancel();
+				};
+				process.on("SIGINT", onSignal);
+				process.on("SIGTERM", onSignal);
+			}
+		});
+		live?.phase("finishing");
+	} catch (error) {
+		live?.remove();
+		throw error;
+	} finally {
+		clearTimeout(budgetTimer);
+		const { removePrepared } = await import("./preflight-BtubXKQ8.js");
+		removePrepared(config.root, runId);
+		const { removePreparedWorkspaces } = await import("./workspace-CyoXG6CY.js");
+		removePreparedWorkspaces(config.root, runId);
+	}
+	if (preflightStop) throw preflightStop;
+	if (engineRun.noFiles || !engineRun.stopped && engineRun.evals.length === 0 && !interrupted) live?.remove();
+	if (engineRun.noFiles && !filters.length && !tags.length) throw new UsageError(`No eval files match ${config.include.join(", ")} (config.include) in ${config.root}. Name eval files to match it, or set include in ${config.file}.`);
+	if (engineRun.noFiles || !engineRun.stopped && engineRun.evals.length === 0 && !interrupted) throw noMatch(config, filters, tags);
+	return {
+		engineRun,
+		plan,
+		sandboxVersions,
+		budgetReached: () => reached,
+		live
+	};
+}
+process.stdout.on("error", (error) => {
+	if (error.code !== "EPIPE") throw error;
+});
+/**
+* Logs the command for `reeval report` and, when it looks like reeval broke (a crash, an unexpected
+* error or an infra error), prints one line suggesting `reeval report`. Not for agents or JSON.
+*/
+function finish(code, error, kind) {
+	const flags = invocation.flags;
+	let root = process.cwd();
+	try {
+		const configPath = flags ? configPathFor(flags.config) : findConfig();
+		if (configPath) root = dirname(configPath);
+	} catch {}
+	const command = commandOf(argv);
+	logInvocation(root, {
+		at: new Date(startedAt).toISOString(),
+		es: version,
+		argv: redactArgv(argv),
+		command,
+		exitCode: code,
+		durationMs: Date.now() - startedAt,
+		runId: invocation.runId,
+		error: error && kind ? {
+			kind,
+			name: error instanceof Error ? error.name : "Error",
+			message: redactSecrets(error instanceof Error ? error.message : String(error)),
+			stack: error instanceof Error && error.stack ? redactSecrets(error.stack) : null
+		} : null,
+		unhandledErrors: invocation.unhandledErrors.map((e) => redactSecrets(e))
+	});
+	const broke = kind === "crash" || code === EXIT.infra || invocation.unhandledErrors.length > 0;
+	const quiet = !!process.env.REEVAL_NO_REPORT_HINT || command === "report" || !!flags?.json || flags?.ui === "agent" || process.env.REEVAL_UI === "agent" || !flags?.ui && !process.env.REEVAL_UI && !!detectAgent().name;
+	if (broke && !quiet) console.error(dim("hint: if this looks like a bug in reeval, reeval report collects a redacted report to file (REEVAL_NO_REPORT_HINT=1 hides this)"));
+}
+const crash = (error) => {
+	console.error(red(`reeval: ${redactSecrets(error instanceof Error ? error.message : String(error))}`));
+	if (process.env.REEVAL_DEBUG) console.error(redactSecrets(inspect(error)));
+	finish(EXIT.infra, error, "crash");
+	process.exit(EXIT.infra);
+};
+process.on("unhandledRejection", crash);
+process.on("uncaughtException", crash);
+let settled = false;
+process.on("exit", (code) => {
+	if (settled || code !== 0) return;
+	process.stderr.write(red("reeval: stopped before it finished: nothing was left for it to wait on. That's a bug in reeval, or in code the config or an eval ran; reeval report collects a redacted report.\n"));
+	process.exitCode = EXIT.infra;
+});
+run(process.argv.slice(2)).finally(() => {
+	settled = true;
+}).then((code) => {
+	finish(code);
+	process.exitCode = code;
+}, (error) => {
+	const name = error.name;
+	const expected = error instanceof UsageError || EXPECTED_ERRORS.includes(name) || name === "PreflightInfraError";
+	console.error(red(`reeval: ${redactSecrets(error.message)}`));
+	if (!expected && process.env.REEVAL_DEBUG) console.error(redactSecrets(inspect(error)));
+	const code = name === "PreflightInfraError" ? EXIT.infra : EXIT.usage;
+	finish(code, error, error instanceof UsageError ? "usage" : expected ? "expected" : "crash");
+	process.exitCode = code;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli--CQ3Iy9q.js.map