reeval 0.0.1

package/dist/command-CEm8PZ1N.js

@@ -0,0 +1,1043 @@
+import { t as UsageError } from "./errors-CSxfJ4qu.js";
+import { a as fromCwd, l as sha256 } from "./ids-Bp6ut7ZD.js";
+import { a as isFakeJudge, c as judgeRoute } from "./judge-D8Uf4dA9.js";
+import { n as clip } from "./text-gEcKjAyp.js";
+import { t as ANALYSIS_PROMPT_VERSION } from "./analysis-CxSCt1YY.js";
+import { H as compare } from "./model-CDL98xue.js";
+import { t as runHeader } from "./header-DzFDoMCI.js";
+import { a as commandSummary, i as checkCommand } from "./cli-spec-DKAu09Gi.js";
+import { a as parseRecord, f as scratchDir } from "./files-D2-qn_Dl.js";
+import { c as resolveRun, s as pickBaseline, t as RefError } from "./views-BrHOv6wg.js";
+import { c as lines, n as allRuns, t as CommandError, u as reachability } from "./commands-CF8mOfiu.js";
+import { s as openHistoryDb } from "./db-DxDzMhtB.js";
+import { t as author } from "./provenance-Dfb8YY5Y.js";
+import { i as saveAnalysis, o as writeCached, r as readCached } from "./files-bF2fPuT9.js";
+import { basename, join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+import { Output, generateText } from "ai";
+//#region src/analysis/digest.ts
+const RULES = [
+	"Pass-rate lift is an effect only when its 95% interval (Newcombe) excludes 0; otherwise it is within noise, whatever the point estimate.",
+	"Effort (tool calls, agent time) is compared with an exact Mann-Whitney test: \"fewer\"/\"more\" at p < 0.05; \"insufficient\" when the attempt counts can never reach it (2 vs 2 cannot); pooled across evals it is an effect only when at least 2/3 of strata agree.",
+	"Each factor claim has a tier: controlled (two cells in one run that differ in one factor), pooled (the same contrast over comparable runs, and across evals), observed (a change between runs, which is weaker; \"confounded\" when several parts changed), not_measured (one level only).",
+	`A cell with mixed outcomes is flaky only with at least 6 counted attempts over comparable runs; below that it is "insufficient", not flaky.`,
+	"Drift marked noise changed only an agent CLI's own runtime state (e.g. ~/.cursor/cli-config.json): not a real change, and those runs stay comparable.",
+	"An eval where every cell passes at least 95% is saturated: pass rate cannot tell cells apart there, effort can.",
+	"Judge verdicts carry no recorded reason; an explanation of a failed verdict is your reading of the cited output, and must say so."
+];
+const pts = (x) => x === null || x === void 0 ? null : `${x >= 0 ? "+" : "−"}${Math.round(Math.abs(x) * 100)}`;
+const liftText = (points, lo, hi) => `${pts(points)} pts (95% ${pts(lo)}…${pts(hi)})`;
+/** Short tags for the evals in scope: the file's base name, numbered when a file has several. */
+function evalTags(evals) {
+	const tags = /* @__PURE__ */ new Map();
+	const bases = evals.map((e) => basename(e.file).replace(/\.(?:eval|es)\.ts$|\.[jt]s$/, ""));
+	evals.forEach((e, i) => {
+		const b = bases[i];
+		const same = bases.filter((x) => x === b).length;
+		tags.set(e.key, same > 1 ? `${b}-${bases.slice(0, i + 1).filter((x) => x === b).length}` : b);
+	});
+	return tags;
+}
+/** A cell's tag within its eval: its variant or `control`, prefixed by harness when there are several. */
+function cellTags(e) {
+	const harnesses = [...new Set(e.cells.map((c) => c.harness))];
+	const kinds = [...new Set(e.cells.map((c) => c.harnessKind))];
+	const prefix = (c) => harnesses.length < 2 ? "" : `${kinds.length === harnesses.length ? c.harnessKind : c.harness}:`;
+	return new Map(e.cells.map((c) => [c.key, `${prefix(c)}${c.variant ?? "control"}`]));
+}
+const counted = (a) => a.outcome === "pass" || a.outcome === "fail";
+async function buildDigest(input) {
+	const { head, base, db } = input;
+	const runs = base ? [base, head] : [head];
+	const short = new Map(runs.map((r, i) => [r.record.runId, `r${i + 1}`]));
+	const needle = input.evalFilter?.toLowerCase() ?? null;
+	const inScope = (e) => !needle || e.id.toLowerCase().includes(needle);
+	const scopeEvals = head.record.evals.filter(inScope);
+	const tags = evalTags(scopeEvals);
+	const evalKeys = new Set(scopeEvals.map((e) => e.key));
+	const tagOf = (key) => tags.get(key) ?? key;
+	const runIds = runs.map((r) => r.record.runId);
+	const attempts = {};
+	const idOf = /* @__PURE__ */ new Map();
+	const cellTagOf = /* @__PURE__ */ new Map();
+	for (const r of runs) for (const e of r.record.evals) {
+		if (!evalKeys.has(e.key)) continue;
+		const cells = cellTags(e);
+		for (const [key, tag] of cells) cellTagOf.set(`${r.record.runId}\0${e.key}\0${key}`, tag);
+		for (const a of e.attempts) {
+			const id = `${short.get(r.record.runId)}/${tagOf(e.key)}/${cells.get(a.cell)}#${a.n}`;
+			idOf.set(`${r.record.runId}\0${a.key}`, id);
+			const judge = a.judgements[0];
+			const any = a.files.transcript ?? a.files.judgeInput ?? a.checks.find((c) => c.log)?.log;
+			attempts[id] = {
+				run: short.get(r.record.runId),
+				runId: r.record.runId,
+				key: a.key,
+				eval: tagOf(e.key),
+				evalSlug: e.slug,
+				cell: cells.get(a.cell),
+				attempt: a.id,
+				outcome: a.outcome,
+				tools: a.activity.tools,
+				agentS: Math.round(a.timings.agentMs / 1e3),
+				...judge ? { judge: Math.round(judge.score * 100) / 100 } : {},
+				checks: a.checks.length,
+				artifacts: any ? `${r.record.runId}/${any.path.split("/").slice(0, 3).join("/")}` : null
+			};
+		}
+	}
+	const cellTag = (runId, evalKey, cell) => cellTagOf.get(`${runId}\0${evalKey}\0${cell}`) ?? cell;
+	const facts = [];
+	const fact = (kind, body) => facts.push({
+		id: `F${facts.length + 1}`,
+		kind,
+		...body
+	});
+	const q = (sql) => db.query(sql).rows;
+	const list = (values) => values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+	const runList = list(runIds);
+	const evalList = list([...evalKeys]);
+	for (const r of runs) for (const e of r.record.evals) {
+		if (!evalKeys.has(e.key)) continue;
+		fact("pass-rate", {
+			run: short.get(r.record.runId),
+			eval: tagOf(e.key),
+			cells: e.cells.map((c) => ({
+				cell: cellTag(r.record.runId, e.key, c.key),
+				pass: `${c.pass}/${c.pass + c.fail}`,
+				...c.infraError ? { infraError: c.infraError } : {},
+				gated: c.gate !== "none",
+				...c.lift ? {
+					lift: liftText(c.lift.points, c.lift.interval.lo, c.lift.interval.hi),
+					verdict: c.lift.withinNoise ? "within noise" : "effect"
+				} : {}
+			}))
+		});
+	}
+	const effort = q(`SELECT * FROM effort_m WHERE run_id IN (${runList}) AND eval_key IN (${evalList}) ORDER BY run_id, rowid`);
+	const effortGroups = /* @__PURE__ */ new Map();
+	for (const row of effort) {
+		const id = `${row.run_id}\0${row.eval_key}`;
+		effortGroups.set(id, [...effortGroups.get(id) ?? [], row]);
+	}
+	for (const rows of effortGroups.values()) {
+		const first = rows[0];
+		const runId = first.run_id;
+		fact("effort", {
+			run: short.get(runId),
+			eval: tagOf(first.eval_key),
+			cells: rows.map((row) => ({
+				cell: cellTag(runId, row.eval_key, row.cell_key),
+				n: row.n,
+				medianToolCalls: row.tools_median,
+				medianAgentS: row.agent_s_median,
+				...row.control_key ? { vsControl: {
+					toolCalls: `${row.tools_median} vs ${row.control_tools_median} (×${Number(row.tools_ratio).toFixed(2)})`,
+					agentS: `${row.agent_s_median} vs ${row.control_agent_s_median}`,
+					p: row.tools_p,
+					verdict: row.verdict
+				} } : {}
+			}))
+		});
+	}
+	const harnesses = [...new Set(runs.flatMap((r) => r.record.stack.harnesses.map((h) => h.id)))];
+	const factors = q(`SELECT * FROM factor_effects WHERE
+      (tier = 'pooled' AND (eval_key IS NULL OR eval_key IN (${evalList})))
+      OR (tier = 'controlled' AND factor != 'environment' AND run_id IN (${runList}) AND eval_key IN (${evalList}))
+      OR (tier = 'observed' AND run_id IN (${runList}) AND eval_key IN (${evalList}))
+      OR tier = 'not_measured'
+     ORDER BY CASE tier WHEN 'pooled' THEN 0 WHEN 'controlled' THEN 1 WHEN 'observed' THEN 2 ELSE 3 END,
+       factor, level, eval_key`).filter((f) => f.tier !== "pooled" || f.factor !== "environment" || harnesses.includes(f.context));
+	for (const f of factors) {
+		if (f.tier === "not_measured") {
+			fact("factor", {
+				tier: f.tier,
+				factor: f.factor,
+				level: f.level,
+				note: f.note
+			});
+			continue;
+		}
+		fact("factor", {
+			tier: f.tier,
+			factor: f.factor,
+			level: f.tier === "observed" ? short.get(f.level) ?? f.level : f.level,
+			baseline: f.tier === "observed" ? short.get(f.baseline) ?? f.baseline : f.baseline,
+			...f.tier === "observed" ? {} : { context: f.context },
+			eval: f.eval_key ? tagOf(f.eval_key) : "all evals",
+			...f.run_id && f.tier !== "observed" ? { run: short.get(f.run_id) } : {},
+			...f.strata && f.strata > 1 ? { strata: f.strata } : {},
+			...f.runs ? { runs: f.runs } : {},
+			passRate: `${f.variant_pass}/${f.variant_counted} vs ${f.control_pass}/${f.control_counted}`,
+			lift: liftText(f.points, f.lo, f.hi),
+			passVerdict: f.pass_verdict,
+			toolCalls: f.tools_ratios,
+			toolsP: f.tools_p,
+			effortVerdict: f.effort_verdict,
+			...f.strata && f.strata > 1 ? {
+				consistentStrata: `${f.consistent}/${f.strata}`,
+				separatedStrata: `${f.separated}/${f.strata}`
+			} : { separated: f.separated === 1 },
+			...f.note ? { note: f.note } : {}
+		});
+	}
+	const reads = q(`SELECT run_id, eval_key, cell_key, skill, COUNT(*) AS attempts, SUM(read_line IS NOT NULL) AS read,
+       GROUP_CONCAT(DISTINCT read_line) AS lines
+     FROM skill_reads WHERE run_id IN (${runList}) AND eval_key IN (${evalList})
+     GROUP BY run_id, eval_key, cell_key, skill ORDER BY run_id, eval_key, cell_key, skill`);
+	const byCell = /* @__PURE__ */ new Map();
+	for (const r of reads) {
+		const cell = cellTag(r.run_id, r.eval_key, r.cell_key);
+		const id = `${cell}\0${r.skill}`;
+		const entry = byCell.get(id) ?? {
+			cell,
+			skill: r.skill,
+			attempts: 0,
+			read: 0,
+			lines: /* @__PURE__ */ new Set()
+		};
+		entry.attempts += r.attempts;
+		entry.read += r.read;
+		for (const l of String(r.lines ?? "").split(",").filter(Boolean)) entry.lines.add(Number(l));
+		byCell.set(id, entry);
+	}
+	if (byCell.size) fact("skill-reads", {
+		note: "Attempts that read their placed skill (a tool call on skills/<name>/), and the transcript lines of the first read.",
+		cells: [...byCell.values()].map((c) => ({
+			cell: c.cell,
+			skill: c.skill,
+			read: `${c.read}/${c.attempts}`,
+			firstReadAtLines: [...c.lines].sort((a, b) => a - b)
+		}))
+	});
+	const pooled = /* @__PURE__ */ new Map();
+	for (const r of runs) for (const e of r.record.evals) {
+		if (!evalKeys.has(e.key)) continue;
+		const p = pooled.get(e.key) ?? {
+			pass: 0,
+			counted: 0,
+			cells: /* @__PURE__ */ new Map()
+		};
+		for (const c of e.cells) {
+			const [cp, cn] = p.cells.get(c.key) ?? [0, 0];
+			p.cells.set(c.key, [cp + c.pass, cn + c.pass + c.fail]);
+			p.pass += c.pass;
+			p.counted += c.pass + c.fail;
+		}
+		pooled.set(e.key, p);
+	}
+	const saturated = [...pooled].filter(([, p]) => [...p.cells.values()].every(([cp, cn]) => cn > 0 && cp / cn >= .95)).map(([key]) => tagOf(key));
+	fact("saturation", {
+		evals: [...pooled].map(([key, p]) => ({
+			eval: tagOf(key),
+			pass: `${p.pass}/${p.counted}`
+		})),
+		saturated
+	});
+	const judged = runs.flatMap((r) => r.record.evals.filter((e) => evalKeys.has(e.key)).flatMap((e) => e.attempts.flatMap((a) => a.judgements.map((j) => ({
+		r,
+		a,
+		j
+	})))));
+	if (judged.length) fact("judge", {
+		models: [...new Set(judged.map(({ j }) => j.resolvedModel ?? j.model))],
+		threshold: [...new Set(judged.map(({ j }) => j.threshold))],
+		verdicts: judged.length,
+		pass: judged.filter(({ j }) => j.verdict === "pass").length,
+		scoresAtLeast098: judged.filter(({ j }) => j.score >= .98).length,
+		nearThreshold: judged.filter(({ j }) => Math.abs(j.score - j.threshold) <= .1).length,
+		failures: judged.filter(({ j }) => j.verdict === "fail").map(({ r, a, j }) => ({
+			attempt: idOf.get(`${r.record.runId}\0${a.key}`),
+			score: j.score
+		})),
+		reasons: "not recorded"
+	});
+	const failures = runs.slice().reverse().flatMap((r) => r.record.evals.filter((e) => evalKeys.has(e.key)).flatMap((e) => e.attempts.filter((a) => a.outcome === "fail" || a.outcome === "infra_error").map((a) => ({
+		r,
+		e,
+		a
+	}))));
+	for (const { r, e, a } of failures.slice(0, 8)) {
+		const j = a.judgements.find((x) => x.verdict === "fail");
+		fact("failure", {
+			attempt: idOf.get(`${r.record.runId}\0${a.key}`),
+			outcome: a.outcome,
+			errorKind: a.error?.kind ?? null,
+			message: a.error ? clip(a.error.message.split("\n")[0] ?? "", 300) : null,
+			gated: e.cells.find((c) => c.key === a.cell)?.gate !== "none",
+			...j ? { judge: {
+				question: j.question,
+				score: j.score,
+				threshold: j.threshold
+			} } : {},
+			failingChecks: a.checks.map((c, i) => ({
+				check: i + 1,
+				exit: c.exitCode,
+				command: c.command
+			})).filter((c) => c.exit !== 0)
+		});
+	}
+	for (const f of q(`SELECT * FROM flaky_cells WHERE eval_key IN (${evalList})`)) {
+		const cell = cellTag(head.record.runId, f.eval_key, f.cell_key);
+		fact("flaky", {
+			eval: tagOf(f.eval_key),
+			cell,
+			pass: `${f.pass}/${f.counted}`,
+			runs: f.runs,
+			wilson95: `${Math.round(f.lo * 100)}…${Math.round(f.hi * 100)}%`,
+			verdict: f.verdict,
+			cause: f.cause
+		});
+	}
+	if (base) {
+		const drift = q(`SELECT changed, changed_paths, noise, real_changed, COUNT(*) AS cells FROM drift
+       WHERE run_id = '${head.record.runId}' AND prev_run_id = '${base.record.runId}' AND eval_key IN (${evalList})
+       GROUP BY changed, changed_paths, noise, real_changed`);
+		for (const d of drift) fact("drift", {
+			from: "r1",
+			to: "r2",
+			cells: d.cells,
+			changed: d.changed,
+			...d.changed_paths ? { paths: String(d.changed_paths).split(", ") } : {},
+			verdict: d.noise ? "noise: agent runtime state only" : `real change: ${d.real_changed}`
+		});
+		fact("compare", {
+			base: "r1",
+			head: "r2",
+			rows: compare(runHeader(base.record, true), runHeader(head.record, true)).filter((row) => scopeEvals.some((e) => e.id === row.id)).map((row) => ({
+				eval: tagOf(scopeEvals.find((e) => e.id === row.id)?.key ?? row.id),
+				status: row.status,
+				...row.changes?.length ? { changes: row.changes } : {}
+			}))
+		});
+	}
+	const evidence = [];
+	const add = (ref, why, lines, priority) => {
+		if (lines.length) evidence.push({
+			id: `E${evidence.length + 1}`,
+			ref,
+			why,
+			lines,
+			priority
+		});
+	};
+	const runOf = new Map(runs.map((r) => [r.record.runId, r]));
+	const transcriptOf = async (runId, a) => {
+		const r = runOf.get(runId);
+		if (!r || !a.files.transcript) return null;
+		return readFile(join(r.dir, runId, ...a.files.transcript.path.split("/")), "utf8").catch(() => null);
+	};
+	const lastText = async (runId, a) => {
+		const text = await transcriptOf(runId, a);
+		if (!text) return a.turns.at(-1)?.text ? [`final: ${clip(a.turns.at(-1)?.text ?? "", 1400)}`] : [];
+		const lines = text.split("\n");
+		for (let i = lines.length - 1; i >= 0; i--) try {
+			const event = JSON.parse(lines[i]);
+			if (event.type === "text") return [`L${i + 1} text: ${clip(String(event.text), 1400)}`];
+		} catch {}
+		return [];
+	};
+	for (const { r, e, a } of failures.slice(0, 3)) {
+		const id = idOf.get(`${r.record.runId}\0${a.key}`);
+		const lines = await lastText(r.record.runId, a);
+		const j = a.judgements.find((x) => x.verdict === "fail");
+		if (j) lines.push(`judge question: ${j.question}`, `judge score: ${j.score} (threshold ${j.threshold})`);
+		for (const [i, c] of a.checks.entries()) {
+			if (c.exitCode === 0 || !c.log) continue;
+			const log = await readFile(join(r.dir, r.record.runId, ...c.log.path.split("/")), "utf8").catch(() => "");
+			lines.push(`check ${i + 1} (exit ${c.exitCode}) ${c.command}:`, ...log.trimEnd().split("\n").slice(-15));
+		}
+		add(`attempt:${id}`, `a failing attempt: its final message${j ? " and the judge question it failed" : ""}`, lines, 1);
+		if (j) {
+			const twin = e.attempts.find((x) => x.cell === a.cell && x.outcome === "pass");
+			if (twin) add(`attempt:${idOf.get(`${r.record.runId}\0${twin.key}`)}`, `the passing twin of ${id} (same cell): its final message`, await lastText(r.record.runId, twin), 2);
+		}
+	}
+	const strip = (runId, a) => q(`SELECT line, tool, target FROM tool_calls WHERE run_id = '${runId}' AND attempt_key = '${a.key.replace(/'/g, "''")}' ORDER BY line LIMIT 20`).map((t) => `L${t.line} ${t.tool} ${clip(String(t.target), 90)}`);
+	const medianAttempt = (list) => [...list].sort((x, y) => x.activity.tools - y.activity.tools)[Math.floor((list.length - 1) / 2)];
+	let strips = 0;
+	for (const e of scopeEvals) {
+		if (strips >= 3) break;
+		const contrast = effort.find((row) => row.run_id === head.record.runId && row.eval_key === e.key && row.control_key && (row.verdict === "fewer" || row.verdict === "more" || row.tools_ratio !== null && (row.tools_ratio <= .5 || row.tools_ratio >= 2)));
+		if (!contrast) continue;
+		strips++;
+		for (const cell of [contrast.cell_key, contrast.control_key]) {
+			const a = medianAttempt(e.attempts.filter((x) => x.cell === cell && counted(x)));
+			if (!a) continue;
+			add(`tool-strip:${idOf.get(`${head.record.runId}\0${a.key}`)}`, `the median-effort attempt of ${cellTag(head.record.runId, e.key, cell)} on ${tagOf(e.key)}: its first tool calls`, strip(head.record.runId, a), 3);
+		}
+	}
+	const digest = {
+		digestVersion: 1,
+		scope: {
+			kind: "run",
+			head: short.get(head.record.runId),
+			base: base ? "r1" : null,
+			evals: input.evalFilter
+		},
+		runs: Object.fromEntries(runs.map((r) => [short.get(r.record.runId), {
+			runId: r.record.runId,
+			commit: r.record.git?.sha.slice(0, 7) ?? null,
+			branch: r.record.git?.branch ?? null,
+			status: r.record.status,
+			summary: `${r.record.summary.pass}/${r.record.summary.attempts} attempts passed (${r.record.summary.notGated} failed, not gated)`
+		}])),
+		setup: {
+			harnesses,
+			judge: `${head.record.stack.judge.model ?? "none"} threshold ${head.record.stack.judge.threshold}`,
+			environments: head.record.environments.map((env) => ({
+				name: env.name,
+				skills: env.skills.map((s) => s.name)
+			})),
+			evals: scopeEvals.map((e) => ({
+				tag: tagOf(e.key),
+				id: e.id,
+				task: clip(e.attempts[0]?.turns[0]?.prompt ?? "", 400)
+			}))
+		},
+		rules: RULES,
+		cli: commandSummary(),
+		instructions: input.instructions ?? null,
+		attempts,
+		facts,
+		evidence,
+		dropped: []
+	};
+	while (digestChars(digest) > input.maxChars && digest.evidence.length) {
+		const worst = digest.evidence.reduce((a, b) => b.priority >= a.priority ? b : a);
+		digest.evidence = digest.evidence.filter((x) => x !== worst);
+		digest.dropped.push(worst.id);
+	}
+	return digest;
+}
+const digestChars = (d) => JSON.stringify(d).length;
+/** Content hash of the digest: the cache key's input side. */
+const digestHash = (d) => sha256(JSON.stringify(d));
+/** Every id a citation may name, and the transcript lines each evidence item holds. */
+function citable(d) {
+	return {
+		ids: /* @__PURE__ */ new Set([
+			...d.facts.map((f) => f.id),
+			...d.evidence.map((e) => e.id),
+			...Object.keys(d.attempts)
+		]),
+		lines: new Map(d.evidence.map((e) => [e.id, new Set(e.lines.flatMap((l) => /^L(\d+) /.exec(l) ? [Number(/^L(\d+) /.exec(l)?.[1])] : []))]))
+	};
+}
+//#endregion
+//#region src/analysis/schema.ts
+const confidence = z.enum([
+	"high",
+	"medium",
+	"low"
+]);
+const cites = z.array(z.string()).describe("Ids from the digest: F<n>, E<n>, E<n>:L<line>, an attempt id, or <attempt id>:check<n>");
+const claim = z.object({
+	text: z.string(),
+	cites,
+	confidence,
+	quotes: z.array(z.string()).optional().describe("Exact spans copied from the cited evidence, if the claim quotes any")
+});
+const analysisSchema = z.object({
+	tldr: z.string().describe("2-3 sentences: what happened, and does the thing under test help"),
+	whatHappened: z.array(claim),
+	results: z.array(claim).describe("Pass rate and effort, each with its noise verdict"),
+	why: z.array(claim).describe("Causes: the thing under test, the eval itself, or reeval/infrastructure"),
+	anomalies: z.array(z.object({
+		text: z.string(),
+		kind: z.enum([
+			"es-bug",
+			"eval-design",
+			"judge",
+			"noise",
+			"other"
+		]),
+		cites
+	})),
+	actions: z.array(z.object({
+		title: z.string(),
+		target: z.string().describe("The file, skill, eval or reeval setting to change"),
+		kind: z.enum([
+			"skill",
+			"docs",
+			"eval",
+			"judge",
+			"es",
+			"harness"
+		]),
+		change: z.string(),
+		expectedEffect: z.string().describe("What should measurably change"),
+		verify: z.string().describe("One reeval command from the CLI list that would show the effect"),
+		impact: z.enum([
+			"high",
+			"medium",
+			"low"
+		]),
+		effort: z.enum([
+			"low",
+			"medium",
+			"high"
+		]),
+		cites
+	})).max(5),
+	confidence: z.object({
+		overall: confidence,
+		why: z.string()
+	})
+});
+const SYSTEM_PROMPT = `You analyse the results of a reeval run for the engineer who wrote the evals.
+reeval runs coding agents in sandboxes. A compare eval runs a control cell and variant cells (with a skill, docs or MCP, say) and reports pass-rate lift with a 95% interval, and effort (tool calls, agent time) next to it.
+
+You get a DIGEST: facts computed deterministically by reeval (ids F1...), evidence excerpts (ids E1...; transcript lines start with their line number L<n>), an attempts table (ids like r2/fix-config/control#1), the RULES reeval used for every verdict, and the CLI.
+
+Rules:
+- Every claim cites at least one id from the digest: F<n>, E<n>, E<n>:L<line> for a line the evidence shows, an attempt id, or <attempt id>:check<n>. Never cite anything that isn't in the digest.
+- Take numbers from the facts. Don't compute new statistics beyond simple ratios of cited numbers.
+- The verdicts in the facts are final: if a lift or effort verdict says within noise or insufficient, say so; never call it an effect. Name each factor claim's tier (controlled, pooled, observed).
+- Say what can't be attributed (factors that are not_measured).
+- Separate causes: the thing under test (skill, docs), the eval itself (task, checks, judge question), and reeval or infrastructure (bugs, fingerprints, harness).
+- Explain a failed judge verdict by comparing the cited output with the judge question, and say it's your reading: judges record no reason.
+- Actions: at most 5, each with a concrete target, the change, the expected measurable effect, and a verify command that is exactly one of the reeval commands in the CLI list, with only the flags listed for it. "No actions" is a valid answer when nothing is worth doing. No generic advice ("add more tests") without a concrete target.
+- Quotes, if any, must be copied exactly from the cited evidence.
+- Plain, direct English. No hype.`;
+//#endregion
+//#region src/analysis/model.ts
+const isFake = (m) => typeof m === "object" && m !== null && m.kind === "fake-analysis";
+/** Which model analyses: `analysis.model`, else the judge's when it's a language model. */
+function analysisModelName(config) {
+	const model = config.analysis.model;
+	if (model !== void 0) return model;
+	const judge = config.judge.model;
+	if (typeof judge === "string" && !judge.startsWith("typesafe-ai/")) return judge;
+	throw new UsageError(`reeval analyze needs a language model. Set analysis: { model: 'google/gemini-3.8-flash' } in ${config.file}${typeof judge === "string" || isFakeJudge(judge) ? ` (the judge, ${isFakeJudge(judge) ? "a fake judge" : judge}, is an evaluation model: it scores yes/no questions and can't write an analysis)` : ""}, or run reeval analyze --context to hand the digest to your own coding agent.`);
+}
+/** Checks the model and its credentials before any work; throws a UsageError (exit 2). */
+function resolveAnalysisModel(config) {
+	const model = analysisModelName(config);
+	if (isFake(model)) return {
+		name: "fake",
+		route: "fake",
+		fake: model
+	};
+	if (model.startsWith("typesafe-ai/")) throw new UsageError(`config.analysis.model "${model}" is an evaluation model: it scores yes/no questions and can't write an analysis. Use a language model, e.g. 'google/gemini-3.8-flash'.`);
+	try {
+		return {
+			name: model,
+			route: judgeRoute(model).kind
+		};
+	} catch (error) {
+		throw new UsageError(`${error.message.replace("judge model", "analysis model")} Or run reeval analyze --context, which needs no key.`);
+	}
+}
+/** A language model that answers with the fake's output, through the AI SDK's own parsing. */
+function fakeModel(fake, digest) {
+	const output = typeof fake.output === "function" ? fake.output(digest) : fake.output;
+	const text = typeof output === "string" ? output : JSON.stringify(output);
+	return {
+		specificationVersion: "v4",
+		provider: "fake",
+		modelId: "fake-analysis",
+		supportedUrls: {},
+		doGenerate: async () => ({
+			content: [{
+				type: "text",
+				text
+			}],
+			finishReason: {
+				unified: "stop",
+				raw: "stop"
+			},
+			usage: {
+				inputTokens: {
+					total: 0,
+					noCache: 0,
+					cacheRead: 0,
+					cacheWrite: 0
+				},
+				outputTokens: {
+					total: 0,
+					text: 0,
+					reasoning: 0
+				}
+			},
+			warnings: [],
+			response: { modelId: "fake-analysis" }
+		}),
+		doStream: async () => {
+			throw new Error("the fake analysis model does not stream");
+		}
+	};
+}
+async function languageModel(model, digest) {
+	if (model.fake) return fakeModel(model.fake, digest);
+	if (model.route === "gateway") return model.name;
+	const provider = model.name.slice(0, model.name.indexOf("/"));
+	const id = model.name.slice(provider.length + 1);
+	if (provider === "google") {
+		const { google } = await import("@ai-sdk/google");
+		return google(id);
+	}
+	return model.name;
+}
+async function callAnalysisModel(model, digest, prompt, maxOutputTokens) {
+	const started = Date.now();
+	const result = await generateText({
+		model: await languageModel(model, digest),
+		system: SYSTEM_PROMPT,
+		prompt,
+		output: Output.object({
+			schema: analysisSchema,
+			name: "analysis"
+		}),
+		temperature: .2,
+		maxOutputTokens,
+		maxRetries: 3
+	});
+	return {
+		output: result.output,
+		resolvedModel: result.response?.modelId ?? null,
+		usage: {
+			inputTokens: result.usage?.inputTokens ?? null,
+			outputTokens: result.usage?.outputTokens ?? null
+		},
+		latencyMs: Date.now() - started
+	};
+}
+//#endregion
+//#region src/analysis/render.ts
+const cite = (cs) => cs.length ? ` ${cs.map((c) => `[${c}]`).join(" ")}` : "";
+const note = (c) => [c.confidence === "high" ? "" : `${c.confidence} confidence`, c.unverifiedNumbers?.length ? `unverified: ${c.unverifiedNumbers.join(", ")}` : ""].filter(Boolean).join("; ");
+function footer(doc) {
+	const v = doc.validation;
+	const tokens = doc.usage.inputTokens !== null ? `${doc.usage.inputTokens} in / ${doc.usage.outputTokens ?? "?"} out tokens · ` : "";
+	return `${doc.resolvedModel ?? doc.model} · ${doc.promptVersion} · digest v${doc.inputs.digestVersion} · ${tokens}${Math.round(doc.latencyMs / 1e3)}s · ${v.citations} citations checked, ${v.invalid.length} invalid, ${v.dropped} dropped · ${v.commands} commands checked, ${v.invalidCommands.length} rejected`;
+}
+/** The analysis as Markdown (`--md`, and the `.md` twin of a saved analysis). */
+function renderMarkdown(doc) {
+	const a = doc.analysis;
+	const md = [
+		`## reeval analysis · ${doc.scope.head}${doc.scope.base ? ` vs ${doc.scope.base}` : ""}`,
+		"",
+		`**TL;DR.** ${a.tldr}`,
+		""
+	];
+	for (const [title, items] of [
+		["What happened", a.whatHappened],
+		["Results", a.results],
+		["Why", a.why]
+	]) {
+		if (!items.length) continue;
+		md.push(`### ${title}`, "");
+		for (const c of items) md.push(`- ${c.text}${cite(c.cites)}${note(c) ? ` *(${note(c)})*` : ""}`);
+		md.push("");
+	}
+	if (a.anomalies.length) {
+		md.push("### Anomalies", "");
+		for (const x of a.anomalies) md.push(`- **${x.kind}**: ${x.text}${cite(x.cites)}`);
+		md.push("");
+	}
+	md.push("### Suggested actions", "");
+	if (!a.actions.length) md.push("None: nothing here is worth acting on.");
+	a.actions.forEach((x, i) => {
+		md.push(`${i + 1}. **${x.title}** (${x.kind} · impact ${x.impact} · effort ${x.effort})  `, `   Target: \`${x.target}\`. ${x.change}  `, `   Expect: ${x.expectedEffect}  `, x.verify ? `   Verify: \`${x.verify}\`${cite(x.cites)}` : `   Verify: none (the suggested command isn't reeval's CLI: ${x.verifyProblem ?? "unknown"})${cite(x.cites)}`);
+	});
+	md.push("", `**Confidence: ${a.confidence.overall}.** ${a.confidence.why}`, "", `<sub>${footer(doc)}</sub>`, "");
+	return md.join("\n");
+}
+/** The analysis for a terminal: the same sections, plain. */
+function renderText(doc) {
+	const a = doc.analysis;
+	const lines = [
+		`analysis ${doc.scope.head}${doc.scope.base ? ` vs ${doc.scope.base}` : ""}`,
+		"",
+		`TL;DR  ${a.tldr}`
+	];
+	for (const [title, items] of [
+		["What happened", a.whatHappened],
+		["Results", a.results],
+		["Why", a.why]
+	]) {
+		if (!items.length) continue;
+		lines.push("", title);
+		for (const c of items) lines.push(`  - ${c.text}${cite(c.cites)}${note(c) ? ` (${note(c)})` : ""}`);
+	}
+	if (a.anomalies.length) {
+		lines.push("", "Anomalies");
+		for (const x of a.anomalies) lines.push(`  - ${x.kind}: ${x.text}${cite(x.cites)}`);
+	}
+	lines.push("", "Suggested actions");
+	if (!a.actions.length) lines.push("  none: nothing here is worth acting on");
+	a.actions.forEach((x, i) => {
+		lines.push(`  ${i + 1}. ${x.title} (${x.kind} · impact ${x.impact} · effort ${x.effort})${cite(x.cites)}`, `     target: ${x.target}. ${x.change}`, `     expect: ${x.expectedEffect}`, x.verify ? `     verify: ${x.verify}` : `     verify: none (${x.verifyProblem ?? "rejected"})`);
+	});
+	lines.push("", `Confidence: ${a.confidence.overall}. ${a.confidence.why}`, "", footer(doc));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/analysis/validate.ts
+const CHECK = /^(.+):check(\d+)$/;
+const LINE = /^(E\d+):L(\d+)$/;
+const TRANSCRIPT = /^transcript:(.+)#L(\d+)$/;
+const normal = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
+const NUMBER = /(?<![\w.#/:-])[−-]?\d+(?:\.\d+)?(?![\w/])/g;
+/** A digest's citation checker: whether an id is valid, and the text it names. */
+function citations(digest) {
+	const { ids, lines } = citable(digest);
+	const factText = new Map(digest.facts.map((f) => [f.id, JSON.stringify(f)]));
+	const evidenceText = new Map(digest.evidence.map((e) => [e.id, e.lines.join("\n")]));
+	const evidenceOf = (attempt) => digest.evidence.filter((e) => e.ref.endsWith(`:${attempt}`)).map((e) => e.id);
+	/** The text a citation names, or null when it names nothing in the digest. */
+	const resolve = (cite) => {
+		const c = cite.trim().replace(/^\[|\]$/g, "");
+		if (ids.has(c)) return factText.get(c) ?? evidenceText.get(c) ?? JSON.stringify(digest.attempts[c]);
+		const line = LINE.exec(c);
+		if (line) {
+			const [, id, n] = line;
+			if (!lines.get(id)?.has(Number(n))) return null;
+			return digest.evidence.find((e) => e.id === id)?.lines.find((l) => l.startsWith(`L${n} `)) ?? null;
+		}
+		const transcript = TRANSCRIPT.exec(c);
+		if (transcript) {
+			const [, attempt, n] = transcript;
+			for (const id of evidenceOf(attempt)) if (lines.get(id)?.has(Number(n))) return resolve(`${id}:L${n}`);
+			return null;
+		}
+		const check = CHECK.exec(c);
+		if (check) {
+			const [, attempt, n] = check;
+			const a = digest.attempts[attempt];
+			return a && Number(n) >= 1 && Number(n) <= a.checks ? JSON.stringify(a) : null;
+		}
+		return null;
+	};
+	return { resolve };
+}
+const ANY_NUMBER = /[−-]?\d+(?:\.\d+)?/g;
+const FRACTION = /(\d+)\/(\d+)/g;
+/**
+* Numbers in `text` that none of `sources` contains: within rounding, as a percentage, or as the
+* percentage of a `pass/counted` fraction there.
+*/
+function unverifiedNumbers(text, sources) {
+	const known = sources.flatMap((s) => [...[...s.matchAll(ANY_NUMBER)].map((m) => Number(m[0].replace("−", "-"))), ...[...s.matchAll(FRACTION)].flatMap((m) => Number(m[2]) ? [100 * Number(m[1]) / Number(m[2]), Number(m[2]) - Number(m[1])] : [])]);
+	const close = (n) => known.some((k) => [
+		k,
+		k * 100,
+		k / 100,
+		-k
+	].some((v) => Math.abs(v - n) <= Math.max(.01, Math.abs(v) * .01) || Math.round(v) === n || Math.round(v * 10) / 10 === n));
+	return [...new Set([...text.matchAll(NUMBER)].map((m) => m[0]))].filter((raw) => {
+		const n = Number(raw.replace("−", "-"));
+		if (Number.isInteger(n) && Math.abs(n) <= 5) return false;
+		return !close(n);
+	});
+}
+function validateAnalysis(output, digest, tables, evals) {
+	const { resolve } = citations(digest);
+	const validation = {
+		citations: 0,
+		invalid: [],
+		dropped: 0,
+		commands: 0,
+		invalidCommands: [],
+		unverifiedNumbers: 0
+	};
+	/** The item's valid citations and their texts; null (and counted) when none is valid. */
+	const cited = (where, cites) => {
+		const good = [];
+		const texts = [];
+		for (const c of cites) {
+			validation.citations++;
+			const text = resolve(c);
+			if (text === null) validation.invalid.push(`${where}: ${c}`);
+			else {
+				good.push(c.trim().replace(/^\[|\]$/g, ""));
+				texts.push(text);
+			}
+		}
+		if (good.length === 0) {
+			validation.dropped++;
+			return null;
+		}
+		return {
+			good,
+			texts
+		};
+	};
+	const claims = (where, items) => items.flatMap((item, i) => {
+		const c = cited(`${where}[${i}]`, item.cites);
+		if (!c) return [];
+		const haystack = normal(c.texts.join("\n"));
+		const invented = (item.quotes ?? []).find((quote) => !haystack.includes(normal(quote)));
+		if (invented !== void 0) {
+			validation.invalid.push(`${where}[${i}]: "${invented.slice(0, 120)}" isn't in the cited evidence`);
+			validation.dropped++;
+			return [];
+		}
+		const numbers = unverifiedNumbers(item.text, [...c.texts, ...digest.rules]);
+		validation.unverifiedNumbers += numbers.length;
+		return [{
+			text: item.text,
+			cites: c.good,
+			confidence: item.confidence,
+			...item.quotes?.length ? { quotes: item.quotes } : {},
+			...numbers.length ? { unverifiedNumbers: numbers } : {}
+		}];
+	});
+	const whatHappened = claims("whatHappened", output.whatHappened);
+	const results = claims("results", output.results);
+	const why = claims("why", output.why);
+	const anomalies = output.anomalies.flatMap((a, i) => {
+		const c = cited(`anomalies[${i}]`, a.cites);
+		return c ? [{
+			text: a.text,
+			kind: a.kind,
+			cites: c.good
+		}] : [];
+	});
+	const actions = output.actions.flatMap((a, i) => {
+		const c = cited(`actions[${i}]`, a.cites);
+		if (!c) return [];
+		const verify = a.verify.trim().replace(/^`+|`+$/g, "");
+		validation.commands++;
+		const problem = verify ? checkCommand(verify, tables, evals) : "no command";
+		if (problem) validation.invalidCommands.push(`${verify}: ${problem}`);
+		return [{
+			title: a.title,
+			target: a.target,
+			kind: a.kind,
+			change: a.change,
+			expectedEffect: a.expectedEffect,
+			verify: problem ? null : verify,
+			...problem ? { verifyProblem: `${verify}: ${problem}` } : {},
+			impact: a.impact,
+			effort: a.effort,
+			cites: c.good
+		}];
+	});
+	return {
+		body: {
+			tldr: output.tldr,
+			whatHappened,
+			results,
+			why,
+			anomalies,
+			actions,
+			confidence: output.confidence
+		},
+		validation
+	};
+}
+//#endregion
+//#region src/analysis/command.ts
+async function load(config, entry) {
+	const dir = entry.recorded ? config.history.dir : scratchDir(config.root);
+	const bytes = await readFile(join(dir, `${entry.runId}.json`));
+	return {
+		record: parseRecord(bytes, entry.runId),
+		dir,
+		bytes
+	};
+}
+/** The model's input: the digest as JSON, after the project's own instructions. */
+const promptOf = (d) => `${d.instructions ? `PROJECT INSTRUCTIONS: ${d.instructions}\n\n` : ""}DIGEST:\n${JSON.stringify(d)}`;
+/** `--context`: the same digest and rules, for the user's own coding agent. */
+function contextMarkdown(d, head, base) {
+	return [
+		`# reeval analysis context: ${head}${base ? ` vs ${base}` : ""}`,
+		"",
+		"Analyse this reeval run for the engineer who wrote the evals. The digest below holds facts reeval computed (F…), evidence excerpts (E…, transcript lines as L<n>) and the attempts table. Cite those ids for every claim, keep to the verdicts in the facts, and suggest at most 5 concrete actions, each verified with a reeval command from the CLI list.",
+		"",
+		"## How reeval decided each verdict",
+		"",
+		...RULES.map((r) => `- ${r}`),
+		"",
+		"## Instructions reeval gives its own analysis model",
+		"",
+		SYSTEM_PROMPT,
+		"",
+		"## reeval CLI (verify commands must be one of these)",
+		"",
+		...commandSummary().map((c) => `- \`${c}\``),
+		"",
+		"## To dig further",
+		"",
+		"- `reeval query effort`, `reeval query factor_effects`, `reeval query skill_reads`, `reeval query flaky_cells`, `reeval query drift`",
+		`- \`reeval query "SELECT line, tool, target FROM tool_calls WHERE attempt_key = '<key>'"\`: an attempt's tool calls`,
+		"- `reeval show <run> --json`: the whole record; transcripts are under the run's artifact folder",
+		"",
+		"## Digest",
+		"",
+		"```json",
+		JSON.stringify(d, null, 1),
+		"```",
+		""
+	].join("\n");
+}
+function citedSummary(d, cites) {
+	const out = {};
+	for (const c of cites) {
+		const fact = d.facts.find((f) => f.id === c);
+		const evidence = d.evidence.find((e) => e.id === c || c.startsWith(`${e.id}:`));
+		const attempt = d.attempts[c.replace(/:check\d+$/, "")];
+		if (fact) {
+			const { id: _id, ...rest } = fact;
+			out[c] = clip(JSON.stringify(rest), 400);
+		} else if (evidence) {
+			const line = /:L(\d+)$/.exec(c);
+			out[c] = line ? clip(evidence.lines.find((l) => l.startsWith(`L${line[1]} `)) ?? evidence.ref, 400) : `${evidence.ref}: ${evidence.why}`;
+		} else if (attempt) out[c] = `${attempt.runId} · ${attempt.attempt} · ${attempt.outcome} · ${attempt.tools} tool calls`;
+	}
+	return out;
+}
+async function analyzeCommand(ctx, args) {
+	const { config, flags } = ctx;
+	if (flags.json && flags.md) throw new UsageError("reeval analyze takes --json or --md, not both");
+	if (flags.context && flags.save) throw new UsageError("reeval analyze --context makes no analysis to save; drop --save");
+	const entries = await allRuns(config);
+	let evalFilter = flags.eval ?? null;
+	let head;
+	try {
+		head = resolveRun(entries, args[0] ?? "latest");
+	} catch (error) {
+		const needle = args[0]?.toLowerCase();
+		const latest = entries.at(-1);
+		if (!(error instanceof RefError) || !needle || !latest?.evals.some((e) => e.id.toLowerCase().includes(needle))) throw error;
+		evalFilter ??= args[0];
+		head = latest;
+	}
+	let base;
+	if (flags.vs) base = resolveRun(entries, flags.vs);
+	else {
+		const reach = await reachability(config.root);
+		const from = head.git && (!reach || reach.has(head.git.sha)) ? head.git.sha : "HEAD";
+		const ancestry = await lines(config.root, [
+			"rev-list",
+			"--max-count=5000",
+			from
+		]);
+		base = pickBaseline(entries.filter((e) => e.recorded && e.runId !== head.runId), head, ancestry);
+	}
+	if (base?.runId === head.runId) throw new UsageError("reeval analyze --vs names the run itself");
+	if (flags.save && !head.recorded) throw new CommandError(`${head.runId} isn't recorded, so there's no history folder to save into. Run reeval record ${head.runId} first, then reeval analyze ${head.runId} --save.`);
+	const model = flags.context || flags["dry-run"] ? null : resolveAnalysisModel(config);
+	const headRun = await load(config, head);
+	const baseRun = base ? await load(config, base) : null;
+	const db = await openHistoryDb(config.root, config.history.dir);
+	let digest;
+	let tables;
+	try {
+		digest = await buildDigest({
+			head: headRun,
+			base: baseRun,
+			evalFilter,
+			db,
+			maxChars: config.analysis.maxInputTokens * 4,
+			...config.analysis.instructions ? { instructions: config.analysis.instructions } : {}
+		});
+		tables = db.schema().map((o) => o.name);
+	} finally {
+		db.close();
+	}
+	if (evalFilter && digest.setup.evals.length === 0) throw new UsageError(`No eval in ${head.runId} matches "${evalFilter}"`);
+	if (flags.context) {
+		ctx.out(contextMarkdown(digest, head.runId, base?.runId ?? null));
+		return 0;
+	}
+	const modelName = (() => {
+		try {
+			const m = analysisModelName(config);
+			return typeof m === "string" ? m : "fake";
+		} catch {
+			return "none";
+		}
+	})();
+	const hash = digestHash(digest);
+	const scope = {
+		kind: "run",
+		head: head.runId,
+		base: base?.runId ?? null,
+		evals: evalFilter
+	};
+	const key = sha256(JSON.stringify({
+		scope,
+		hash,
+		prompt: ANALYSIS_PROMPT_VERSION,
+		model: modelName
+	})).replace(/^sha256:/, "");
+	const cached = flags["no-cache"] ? null : await readCached(config.root, key);
+	if (flags["dry-run"]) {
+		const chars = digestChars(digest);
+		ctx.out([
+			`digest ${head.runId}${base ? ` vs ${base.runId}` : ""}: ${digest.facts.length} facts, ${digest.evidence.length} evidence items${digest.dropped.length ? ` (${digest.dropped.length} dropped to fit)` : ""}, ${Object.keys(digest.attempts).length} attempts`,
+			`size ${chars} characters ≈ ${Math.ceil(chars / 4)} tokens (cap ${config.analysis.maxInputTokens} in, ${config.analysis.maxOutputTokens} out)`,
+			`model ${modelName} · ${ANALYSIS_PROMPT_VERSION} · cache ${cached ? "hit" : "miss"} (.reeval/analysis/${key}.json)`
+		].join("\n"));
+		return 0;
+	}
+	let doc;
+	if (cached) {
+		doc = cached;
+		ctx.err(`cached analysis from ${cached.createdAt} (.reeval/analysis/${key}.json); --no-cache calls the model again`);
+	} else {
+		const resolved = model ?? resolveAnalysisModel(config);
+		ctx.err(`analysing ${head.runId}${base ? ` vs ${base.runId}` : ""} with ${resolved.name}…`);
+		const answer = await callAnalysisModel(resolved, digest, promptOf(digest), config.analysis.maxOutputTokens);
+		const evals = headRun.record.evals.map((e) => ({
+			file: e.file,
+			name: [...e.group, e.name].join(" "),
+			tags: e.tags,
+			cells: e.cells.map((c) => c.key)
+		}));
+		const { body, validation } = validateAnalysis(answer.output, digest, tables, evals);
+		const cites = [
+			...body.whatHappened,
+			...body.results,
+			...body.why,
+			...body.anomalies,
+			...body.actions
+		].flatMap((x) => x.cites);
+		doc = {
+			kind: "es-analysis",
+			schemaVersion: 1,
+			scope,
+			anchor: head.runId,
+			inputs: {
+				records: [baseRun, headRun].flatMap((r) => r ? [{
+					runId: r.record.runId,
+					sha256: sha256(r.bytes)
+				}] : []),
+				digestVersion: digest.digestVersion,
+				digestHash: hash
+			},
+			promptVersion: ANALYSIS_PROMPT_VERSION,
+			model: resolved.name,
+			resolvedModel: answer.resolvedModel,
+			route: resolved.route,
+			usage: answer.usage,
+			latencyMs: answer.latencyMs,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			author: await author(config.root),
+			validation,
+			analysis: body,
+			attempts: Object.fromEntries(Object.entries(digest.attempts).map(([id, a]) => [id, {
+				runId: a.runId,
+				evalSlug: a.evalSlug,
+				attempt: a.attempt
+			}])),
+			cited: citedSummary(digest, [...new Set(cites)])
+		};
+		await writeCached(config.root, key, doc);
+	}
+	if (flags.save) {
+		const saved = await saveAnalysis(config.history.dir, doc, key, renderMarkdown(doc));
+		ctx.err(`saved ${saved.map((p) => fromCwd(p)).join(" and ")}. Commit them with git.`);
+	}
+	ctx.out(flags.json ? JSON.stringify(doc, null, 2) : flags.md ? renderMarkdown(doc) : renderText(doc));
+	return 0;
+}
+//#endregion
+export { analyzeCommand };
+
+//# sourceMappingURL=command-CEm8PZ1N.js.map