@leostera/evalkit 0.1.0 → 0.3.0

package/dist/cli.mjs

@@ -2,8 +2,8 @@
 import { F as defineEvalMatrix, I as canonicalParameters, m as registerEvals, n as authoringId } from "./src-DrwwgaPn.mjs";
 import { a as readTrialEvents, c as readTrialSummary, i as readRunSummary, l as localReportStore, n as runMatrix, o as readTrialManifest, r as readRunManifest, t as runEval } from "./src-DluldGKn.mjs";
 import * as Schema from "effect/Schema";
-import { Effect, Option } from "effect";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { Effect, LogLevel, Logger, Option } from "effect";
+import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import * as Path from "node:path";
 import { basename, dirname, extname, relative, resolve, sep } from "node:path";
 import * as OS from "node:os";
@@ -43,11 +43,11 @@ import * as EffectSecret from "effect/Secret";
 import * as Effectable from "effect/Effectable";
 import * as Match from "effect/Match";
 import * as EffectNumber from "effect/Number";
-import * as LogLevel from "effect/LogLevel";
+import * as LogLevel$1 from "effect/LogLevel";
 import * as Config from "effect/Config";
 import * as HashMap from "effect/HashMap";
 import * as Order from "effect/Order";
-import * as Logger from "effect/Logger";
+import * as Logger$1 from "effect/Logger";
 import * as Unify from "effect/Unify";
 import * as HashSet from "effect/HashSet";
 import * as SynchronizedRef from "effect/SynchronizedRef";
@@ -392,13 +392,13 @@ const struct = (fields) => {
 /** @internal */
 const black = { _tag: "Black" };
 /** @internal */
-const red$3 = { _tag: "Red" };
+const red$4 = { _tag: "Red" };
 /** @internal */
-const green$2 = { _tag: "Green" };
+const green$3 = { _tag: "Green" };
 /** @internal */
 const magenta$1 = { _tag: "Magenta" };
 /** @internal */
-const cyan$1 = { _tag: "Cyan" };
+const cyan$2 = { _tag: "Cyan" };
 /** @internal */
 const white$3 = { _tag: "White" };
 /** @internal */
@@ -500,7 +500,7 @@ const ESC = "\x1B[";
 const BEL = "\x07";
 const SEP = ";";
 /** @internal */
-const bold$1 = /*#__PURE__*/ make$5({ bold: /*#__PURE__*/ Option$1.some(/*#__PURE__*/ setBold(true)) });
+const bold$2 = /*#__PURE__*/ make$5({ bold: /*#__PURE__*/ Option$1.some(/*#__PURE__*/ setBold(true)) });
 /** @internal */
 const italicized$1 = /*#__PURE__*/ make$5({ italicized: /*#__PURE__*/ Option$1.some(/*#__PURE__*/ setItalicized(true)) });
 /** @internal */
@@ -512,15 +512,15 @@ const brightColor = (color) => make$5({ foreground: Option$1.some(setColor(color
 /** @internal */
 const color$1 = (color) => make$5({ foreground: Option$1.some(setColor(color, false, "foreground")) });
 /** @internal */
-const red$2 = /*#__PURE__*/ color$1(red$3);
+const red$3 = /*#__PURE__*/ color$1(red$4);
 /** @internal */
-const green$1 = /*#__PURE__*/ color$1(green$2);
+const green$2 = /*#__PURE__*/ color$1(green$3);
 /** @internal */
 const white$2 = /*#__PURE__*/ color$1(white$3);
 /** @internal */
 const blackBright$1 = /*#__PURE__*/ brightColor(black);
 /** @internal */
-const cyanBright$1 = /*#__PURE__*/ brightColor(cyan$1);
+const cyanBright$1 = /*#__PURE__*/ brightColor(cyan$2);
 /** @internal */
 const beep$2 = /*#__PURE__*/ make$5({ commands: /*#__PURE__*/ Arr.of(BEL) });
 /** @internal */
@@ -587,7 +587,7 @@ const stringifyInternal = (self) => {
 * @since 1.0.0
 * @category constructors
 */
-const bold = bold$1;
+const bold$1 = bold$2;
 /**
 * @since 1.0.0
 * @category constructors
@@ -612,12 +612,12 @@ const color = color$1;
 * @since 1.0.0
 * @category colors
 */
-const red$1 = red$2;
+const red$2 = red$3;
 /**
 * @since 1.0.0
 * @category colors
 */
-const green = green$1;
+const green$1 = green$2;
 /**
 * @since 1.0.0
 * @category colors
@@ -2218,7 +2218,7 @@ const optimize = optimize$1;
 * @since 1.0.0
 * @category constructors
 */
-const red = red$3;
+const red$1 = red$4;
 /**
 * @since 1.0.0
 * @category constructors
@@ -2228,7 +2228,7 @@ const magenta = magenta$1;
 * @since 1.0.0
 * @category constructors
 */
-const cyan = cyan$1;
+const cyan$1 = cyan$2;
 /**
 * @since 1.0.0
 * @category constructors
@@ -2248,7 +2248,7 @@ const space = /*#__PURE__*/ text$6(" ");
 /** @internal */
 const code = (value) => highlight(value, white);
 /** @internal */
-const error = (value) => highlight(value, red);
+const error = (value) => highlight(value, red$1);
 /** @internal */
 const highlight = (value, color) => ({
 	_tag: "Highlight",
@@ -2307,7 +2307,7 @@ const toAnsiDoc$1 = (self) => {
 	switch (self._tag) {
 		case "Highlight": return annotate(toAnsiDoc$1(self.value), color(self.color));
 		case "Sequence": return cat(toAnsiDoc$1(self.left), toAnsiDoc$1(self.right));
-		case "Strong": return annotate(toAnsiDoc$1(self.value), bold);
+		case "Strong": return annotate(toAnsiDoc$1(self.value), bold$1);
 		case "Text": return text$7(self.value);
 		case "URI": return annotate(text$7(self.value), underlined);
 		case "Weak": return annotate(toAnsiDoc$1(self.value), blackBright);
@@ -2373,11 +2373,11 @@ const toAnsiText = (self) => render$1(toAnsiDoc(self), { style: "pretty" });
 const toAnsiDocInternal = (self) => {
 	switch (self._tag) {
 		case "Empty": return empty$3;
-		case "Header": return pipe(annotate(toAnsiDoc$1(self.value), bold), cat(hardLine));
+		case "Header": return pipe(annotate(toAnsiDoc$1(self.value), bold$1), cat(hardLine));
 		case "Paragraph": return pipe(toAnsiDoc$1(self.value), cat(hardLine));
 		case "DescriptionList": {
 			const definitions = self.definitions.map(([span, doc]) => cats([
-				annotate(toAnsiDoc$1(span), bold),
+				annotate(toAnsiDoc$1(span), bold$1),
 				empty$3,
 				indent(toAnsiDocInternal(doc), 2)
 			]));
@@ -2592,8 +2592,8 @@ function renderError$2(state, pointer) {
 		onSome: (error) => {
 			const errorLines = error.split(NEWLINE_REGEX$3);
 			if (Arr.isNonEmptyReadonlyArray(errorLines)) {
-				const annotateLine = (line) => annotate(text$7(line), combine(italicized, red$1));
-				const prefix = cat(annotate(pointer, red$1), space$1);
+				const annotateLine = (line) => annotate(text$7(line), combine(italicized, red$2));
+				const prefix = cat(annotate(pointer, red$2), space$1);
 				const lines = Arr.map(errorLines, (str) => annotateLine(str));
 				return cursorSavePosition.pipe(cat(hardLine), cat(prefix), cat(align(vsep(lines))), cat(cursorRestorePosition));
 			}
@@ -2612,7 +2612,7 @@ function renderParts(state, submitted = false) {
 	});
 }
 function renderOutput$4(leadingSymbol, trailingSymbol, parts, options) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const prefix = cat(leadingSymbol, space$1);
 	return Arr.match(options.message.split(/\r?\n/), {
 		onEmpty: () => hsep([
@@ -2642,7 +2642,7 @@ function renderSubmission$5(state, options) {
 	return Effect$1.gen(function* () {
 		const columns = yield* (yield* Terminal).columns;
 		const figures$11 = yield* figures;
-		return renderOutput$4(annotate(figures$11.tick, green), annotate(figures$11.ellipsis, blackBright), renderParts(state, true), options).pipe(cat(hardLine), optimize(Deep), render$1({
+		return renderOutput$4(annotate(figures$11.tick, green$1), annotate(figures$11.ellipsis, blackBright), renderParts(state, true), options).pipe(cat(hardLine), optimize(Deep), render$1({
 			style: "pretty",
 			options: { lineWidth: columns }
 		}));
@@ -3106,7 +3106,7 @@ function handleClear$4(options) {
 }
 const NEWLINE_REGEX$2 = /\r?\n/;
 function renderPrompt(confirm, message, leadingSymbol, trailingSymbol) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const prefix = cat(leadingSymbol, space$1);
 	return Arr.match(message.split(NEWLINE_REGEX$2), {
 		onEmpty: () => hsep([
@@ -3159,7 +3159,7 @@ function renderNextFrame$4(state, options) {
 				options: { lineWidth: columns }
 			}));
 		}
-		const leadingSymbol = annotate(figures$10.tick, green);
+		const leadingSymbol = annotate(figures$10.tick, green$1);
 		const trailingSymbol = annotate(figures$10.ellipsis, blackBright);
 		const promptMsg = renderPrompt(empty$3, options.message, leadingSymbol, trailingSymbol);
 		const files = renderFiles(state, state.files, figures$10, options);
@@ -3173,7 +3173,7 @@ function renderSubmission$4(value, options) {
 	return Effect$1.gen(function* () {
 		const columns = yield* (yield* Terminal).columns;
 		const figures$9 = yield* figures;
-		const leadingSymbol = annotate(figures$9.tick, green);
+		const leadingSymbol = annotate(figures$9.tick, green$1);
 		const trailingSymbol = annotate(figures$9.ellipsis, blackBright);
 		return renderPrompt(empty$3, options.message, leadingSymbol, trailingSymbol).pipe(cat(space$1), cat(annotate(text$7(value), white$1)), cat(hardLine), render$1({
 			style: "pretty",
@@ -3316,7 +3316,7 @@ function handleClear$3(options) {
 function renderInput$1(state, submitted) {
 	const annotation = Option$1.match(state.error, {
 		onNone: () => combine(underlined, cyanBright),
-		onSome: () => red$1
+		onSome: () => red$2
 	});
 	const value = state.value === "" ? empty$3 : text$7(`${state.value}`);
 	return submitted ? value : annotate(value, annotation);
@@ -3328,8 +3328,8 @@ function renderError$1(state, pointer) {
 		onSome: (error) => Arr.match(error.split(NEWLINE_REGEX$1), {
 			onEmpty: () => empty$3,
 			onNonEmpty: (errorLines) => {
-				const annotateLine = (line) => annotate(text$7(line), combine(italicized, red$1));
-				const prefix = cat(annotate(pointer, red$1), space$1);
+				const annotateLine = (line) => annotate(text$7(line), combine(italicized, red$2));
+				const prefix = cat(annotate(pointer, red$2), space$1);
 				const lines = Arr.map(errorLines, (str) => annotateLine(str));
 				return cursorSavePosition.pipe(cat(hardLine), cat(prefix), cat(align(vsep(lines))), cat(cursorRestorePosition));
 			}
@@ -3337,7 +3337,7 @@ function renderError$1(state, pointer) {
 	});
 }
 function renderOutput$3(state, leadingSymbol, trailingSymbol, options, submitted = false) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const prefix = cat(leadingSymbol, space$1);
 	return Arr.match(options.message.split(/\r?\n/), {
 		onEmpty: () => hsep([
@@ -3368,7 +3368,7 @@ function renderSubmission$3(nextState, options) {
 	return Effect$1.gen(function* () {
 		const columns = yield* (yield* Terminal).columns;
 		const figures$7 = yield* figures;
-		return renderOutput$3(nextState, annotate(figures$7.tick, green), annotate(figures$7.ellipsis, blackBright), options, true).pipe(cat(hardLine), optimize(Deep), render$1({
+		return renderOutput$3(nextState, annotate(figures$7.tick, green$1), annotate(figures$7.ellipsis, blackBright), options, true).pipe(cat(hardLine), optimize(Deep), render$1({
 			style: "pretty",
 			options: { lineWidth: columns }
 		}));
@@ -3551,7 +3551,7 @@ const float = (options) => {
 const renderBeep$2 = /*#__PURE__*/ render$1(beep, { style: "pretty" });
 const NEWLINE_REGEX = /\r?\n/;
 function renderOutput$2(leadingSymbol, trailingSymbol, options) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const prefix = cat(leadingSymbol, space$1);
 	return Arr.match(options.message.split(NEWLINE_REGEX), {
 		onEmpty: () => hsep([prefix, trailingSymbol]),
@@ -3566,7 +3566,7 @@ function renderChoicePrefix(state, choices, toDisplay, currentIndex, figures) {
 	if (currentIndex === toDisplay.startIndex && toDisplay.startIndex > 0) prefix = figures.arrowUp;
 	else if (currentIndex === toDisplay.endIndex - 1 && toDisplay.endIndex < choices.length) prefix = figures.arrowDown;
 	if (choices[currentIndex].disabled) {
-		const annotation = combine(bold, blackBright);
+		const annotation = combine(bold$1, blackBright);
 		return state === currentIndex ? figures.pointer.pipe(annotate(annotation), cat(prefix)) : prefix.pipe(cat(space$1));
 	}
 	return state === currentIndex ? figures.pointer.pipe(annotate(cyanBright), cat(prefix)) : prefix.pipe(cat(space$1));
@@ -3611,7 +3611,7 @@ function renderSubmission$2(state, options) {
 		const columns = yield* (yield* Terminal).columns;
 		const figures$6 = yield* figures;
 		const selected = text$7(options.choices[state].title);
-		return renderOutput$2(annotate(figures$6.tick, green), annotate(figures$6.ellipsis, blackBright), options).pipe(cat(space$1), cat(annotate(selected, white$1)), cat(hardLine), render$1({
+		return renderOutput$2(annotate(figures$6.tick, green$1), annotate(figures$6.ellipsis, blackBright), options).pipe(cat(space$1), cat(annotate(selected, white$1)), cat(hardLine), render$1({
 			style: "pretty",
 			options: { lineWidth: columns }
 		}));
@@ -3714,7 +3714,7 @@ function renderInput(nextState, options, submitted) {
 			if (nextState.value.length === 0) return blackBright;
 			return combine(underlined, cyanBright);
 		},
-		onSome: () => red$1
+		onSome: () => red$2
 	});
 	switch (options.type) {
 		case "hidden": return empty$3;
@@ -3728,8 +3728,8 @@ function renderError(nextState, pointer) {
 		onSome: (error) => Arr.match(error.split(/\r?\n/), {
 			onEmpty: () => empty$3,
 			onNonEmpty: (errorLines) => {
-				const annotateLine = (line) => text$7(line).pipe(annotate(combine(italicized, red$1)));
-				const prefix = cat(annotate(pointer, red$1), space$1);
+				const annotateLine = (line) => text$7(line).pipe(annotate(combine(italicized, red$2)));
+				const prefix = cat(annotate(pointer, red$2), space$1);
 				const lines = Arr.map(errorLines, (str) => annotateLine(str));
 				return cursorSavePosition.pipe(cat(hardLine), cat(prefix), cat(align(vsep(lines))), cat(cursorRestorePosition));
 			}
@@ -3737,7 +3737,7 @@ function renderError(nextState, pointer) {
 	});
 }
 function renderOutput$1(nextState, leadingSymbol, trailingSymbol, options, submitted = false) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const promptLines = options.message.split(/\r?\n/);
 	const prefix = cat(leadingSymbol, space$1);
 	if (Arr.isNonEmptyReadonlyArray(promptLines)) {
@@ -3767,7 +3767,7 @@ function renderSubmission$1(state, options) {
 	return Effect$1.gen(function* () {
 		const columns = yield* (yield* Terminal).columns;
 		const figures$4 = yield* figures;
-		return renderOutput$1(state, annotate(figures$4.tick, green), annotate(figures$4.ellipsis, blackBright), options, true).pipe(cat(hardLine), optimize(Deep), render$1({
+		return renderOutput$1(state, annotate(figures$4.tick, green$1), annotate(figures$4.ellipsis, blackBright), options, true).pipe(cat(hardLine), optimize(Deep), render$1({
 			style: "pretty",
 			options: { lineWidth: columns }
 		}));
@@ -3909,7 +3909,7 @@ function renderToggle(value, options, submitted = false) {
 	]);
 }
 function renderOutput(toggle, leadingSymbol, trailingSymbol, options) {
-	const annotateLine = (line) => annotate(text$7(line), bold);
+	const annotateLine = (line) => annotate(text$7(line), bold$1);
 	const promptLines = options.message.split(/\r?\n/);
 	const prefix = cat(leadingSymbol, space$1);
 	if (Arr.isNonEmptyReadonlyArray(promptLines)) {
@@ -3941,7 +3941,7 @@ function renderSubmission(value, options) {
 		const terminal = yield* Terminal;
 		const figures$2 = yield* figures;
 		const columns = yield* terminal.columns;
-		const leadingSymbol = annotate(figures$2.tick, green);
+		const leadingSymbol = annotate(figures$2.tick, green$1);
 		const trailingSymbol = annotate(figures$2.ellipsis, blackBright);
 		return renderOutput(renderToggle(value, options, true), leadingSymbol, trailingSymbol, options).pipe(cat(hardLine), optimize(Deep), render$1({
 			style: "pretty",
@@ -5919,7 +5919,7 @@ const completionsOptions = /*#__PURE__*/ choiceWithValue("completions", [
 	["zsh", "zsh"]
 ]).pipe(optional$1, /*#__PURE__*/ withDescription("Generate a completion script for a specific shell."));
 /** @internal */
-const logLevelOptions = /*#__PURE__*/ choiceWithValue("log-level", LogLevel.allLevels.map((level) => [level._tag.toLowerCase(), level])).pipe(optional$1, /*#__PURE__*/ withDescription("Sets the minimum log level for a command."));
+const logLevelOptions = /*#__PURE__*/ choiceWithValue("log-level", LogLevel$1.allLevels.map((level) => [level._tag.toLowerCase(), level])).pipe(optional$1, /*#__PURE__*/ withDescription("Sets the minimum log level for a command."));
 /** @internal */
 const helpOptions = /*#__PURE__*/ boolean$1("help").pipe(/*#__PURE__*/ withAlias("h"), /*#__PURE__*/ withDescription("Show the help documentation for a command."));
 /** @internal */
@@ -6294,7 +6294,7 @@ const wizardInternal = (self, prefix, config) => {
 			case "GetUserInput":
 			case "Standard": return Effect$1.gen(function* () {
 				const logCurrentCommand = Ref.get(commandLineRef).pipe(Effect$1.flatMap((commandLine) => {
-					const currentCommand = p(pipe(strong(highlight("COMMAND:", cyan)), concat$1(space), concat$1(highlight(Arr.join(commandLine, " "), magenta))));
+					const currentCommand = p(pipe(strong(highlight("COMMAND:", cyan$1)), concat$1(space), concat$1(highlight(Arr.join(commandLine, " "), magenta))));
 					return Console.log(toAnsiText(currentCommand));
 				}));
 				if (isStandard(self)) {
@@ -6634,7 +6634,7 @@ const handleBuiltInOption = (self, executable, args, builtIn, execute, config, o
 				filteredArgs.push(args[i]);
 			}
 			const nextArgs = Arr.appendAll(baseArgs, filteredArgs);
-			return run$2(self, nextArgs, execute).pipe(Logger.withMinimumLogLevel(builtIn.level));
+			return run$2(self, nextArgs, execute).pipe(Logger$1.withMinimumLogLevel(builtIn.level));
 		}
 		case "ShowHelp": {
 			const banner = h1(code(self.name));
@@ -6740,7 +6740,7 @@ const renderWizardArgs = (args) => {
 	return blocks([
 		p(strong(code("Wizard Mode Complete!"))),
 		p(executeMsg),
-		p(concat$1(text$6("    "), highlight(params, cyan)))
+		p(concat$1(text$6("    "), highlight(params, cyan$1)))
 	]);
 };
 const isLogLevelArg = (arg) => {
@@ -7775,7 +7775,7 @@ const ProcessProto = {
 		};
 	}
 };
-const runCommand = (fileSystem) => (command) => {
+const runCommand$1 = (fileSystem) => (command) => {
 	switch (command._tag) {
 		case "StandardCommand": {
 			const spawn = Effect$1.flatMap(Deferred.make(), (exitCode) => Effect$1.async((resume) => {
@@ -7851,13 +7851,13 @@ const runCommand = (fileSystem) => (command) => {
 		}
 		case "PipedCommand": {
 			const flattened = flatten(command);
-			if (flattened.length === 1) return pipe(flattened[0], runCommand(fileSystem));
+			if (flattened.length === 1) return pipe(flattened[0], runCommand$1(fileSystem));
 			const head = flattened[0];
 			const tail = flattened.slice(1);
 			const initial = tail.slice(0, tail.length - 1);
 			const last = tail[tail.length - 1];
-			const stream = initial.reduce((stdin$2, command) => pipe(stdin(command, stdin$2), runCommand(fileSystem), Effect$1.map((process) => process.stdout), Stream.unwrapScoped), pipe(runCommand(fileSystem)(head), Effect$1.map((process) => process.stdout), Stream.unwrapScoped));
-			return pipe(stdin(last, stream), runCommand(fileSystem));
+			const stream = initial.reduce((stdin$2, command) => pipe(stdin(command, stdin$2), runCommand$1(fileSystem), Effect$1.map((process) => process.stdout), Stream.unwrapScoped), pipe(runCommand$1(fileSystem)(head), Effect$1.map((process) => process.stdout), Stream.unwrapScoped));
+			return pipe(stdin(last, stream), runCommand$1(fileSystem));
 		}
 	}
 };
@@ -7867,7 +7867,7 @@ const runCommand = (fileSystem) => (command) => {
 * @since 1.0.0
 * @category layer
 */
-const layer$5 = /* @__PURE__ */ Layer.effect(CommandExecutor, /*#__PURE__*/ pipe(FileSystem, /*#__PURE__*/ Effect$1.map((fileSystem) => makeExecutor(runCommand(fileSystem)))));
+const layer$5 = /* @__PURE__ */ Layer.effect(CommandExecutor, /*#__PURE__*/ pipe(FileSystem, /*#__PURE__*/ Effect$1.map((fileSystem) => makeExecutor(runCommand$1(fileSystem)))));
 //#endregion
 //#region ../../node_modules/.bun/@effect+platform-node-shared@0.61.1+1edbab697a2570fc/node_modules/@effect/platform-node-shared/dist/esm/internal/path.js
 const fromFileUrl = (url) => Effect$1.try({
@@ -8048,65 +8048,10 @@ const layerManager = /* @__PURE__ */ Layer.provide(layerManager$2, layerWorker);
 */
 const layer = /*#__PURE__*/ pipe(/*#__PURE__*/ Layer.mergeAll(layer$3, layer$5, layer$1, layerManager), /*#__PURE__*/ Layer.provideMerge(layer$7));
 //#endregion
-//#region ../cli/src/dashboard-cells.ts
-const MAX_SCAN = 1e5;
-function display(value) {
-	return typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
-}
-/** Bounded report projection; both count and rows come from the core eligible-cell iterator. */
-function listMatrixCells(matrix, input) {
-	if (!Number.isSafeInteger(input.offset) || input.offset < 0 || !Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) throw new Error("Matrix page requires offset >= 0 and limit between 1 and 100");
-	if (![
-		"eval",
-		"agent",
-		"trials",
-		...[...Object.keys(matrix.cases?.[0] ?? {}), ...Object.keys(matrix.parameters)].map((key) => `axis:${key}`)
-	].includes(input.sort)) throw new Error(`Unknown matrix sort: ${input.sort}`);
-	const selection = input.evalIds.length ? { evals: input.evalIds } : {};
-	const planned = matrix.count(selection);
-	if (planned > MAX_SCAN) throw new Error(`Matrix has ${planned} eligible cells; narrow the selection in the CLI (dashboard limit ${MAX_SCAN})`);
-	const terms = input.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
-	const cells = [...matrix.cells(selection)].filter((cell) => {
-		const haystack = [
-			cell.eval.id,
-			cell.eval.name,
-			cell.eval.agent?.identity?.name,
-			cell.eval.agent?.identity?.kind,
-			...Object.entries(cell.parameters).flatMap(([key, value]) => [key, display(value)])
-		].map(display).join(" ").toLowerCase();
-		return terms.every((term) => haystack.includes(term));
-	});
-	function value(cell) {
-		if (input.sort.startsWith("axis:")) {
-			const parameter = cell.parameters[input.sort.slice(5)];
-			return typeof parameter === "number" ? parameter : canonicalParameters(parameter);
-		}
-		if (input.sort === "eval") return cell.eval.name ?? cell.eval.id;
-		if (input.sort === "agent") return cell.eval.agent?.identity?.name ?? cell.eval.agent?.identity?.kind ?? "";
-		return cell.eval.policy?.trials ?? 1;
-	}
-	cells.sort((left, right) => {
-		const a = value(left);
-		const b = value(right);
-		const comparison = typeof a === "number" && typeof b === "number" ? a - b : String(a).localeCompare(String(b), void 0, {
-			numeric: true,
-			sensitivity: "base"
-		});
-		return (input.direction === "asc" ? comparison : -comparison) || left.key.localeCompare(right.key);
-	});
-	return {
-		total: cells.length,
-		planned,
-		cells: cells.slice(input.offset, input.offset + input.limit).map((cell) => ({
-			evalId: cell.eval.id,
-			key: cell.key,
-			parameters: cell.parameters
-		}))
-	};
-}
-//#endregion
 //#region ../cli/src/dashboard-reports.ts
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** Written into a run directory by `evalkit tidy`; deleting it restores the run. */
+const ARCHIVE_MARKER = "archived.json";
 function isMissing(error) {
 	return error.code === "ENOENT";
 }
@@ -8143,15 +8088,35 @@ function fileContentType(file) {
 		".js": "text/javascript"
 	}[extname(file)] ?? "application/octet-stream";
 }
-/** Read saved local reports. A missing summary means "running"; malformed reports are errors. */
+/**
+* Read saved local reports. A missing summary means "running"; malformed reports are errors.
+* Runs written by an older EvalKit (manifest `schemaVersion` < 2) are skipped and counted.
+*/
 function createDashboardReportReader(root, registry) {
+	const legacyRuns = /* @__PURE__ */ new Set();
 	async function listRuns() {
 		const entries = await ifPresent(() => readdir(root, { withFileTypes: true }));
 		if (!entries) return [];
 		const ids = entries.filter((entry) => entry.isDirectory() && UUID_PATTERN.test(entry.name)).map((entry) => entry.name);
 		return (await Promise.all(ids.map(readRun))).filter((run) => run !== void 0);
 	}
+	/** True for a run from a report format this version cannot read; never for corrupt JSON. */
+	async function isLegacyRun(id) {
+		const text = await ifPresent(() => readFile(resolve(root, id, "manifest.json"), "utf8"));
+		if (text === void 0) return false;
+		let version;
+		try {
+			version = JSON.parse(text).schemaVersion;
+		} catch {
+			return false;
+		}
+		return typeof version === "number" && version < 2;
+	}
 	async function readRun(id) {
+		if (await isLegacyRun(id)) {
+			legacyRuns.add(id);
+			return;
+		}
 		const manifest = await ifPresent(() => readRunManifest(root, id));
 		if (!manifest) return void 0;
 		const summary = await ifPresent(() => readRunSummary(root, id));
@@ -8160,6 +8125,7 @@ function createDashboardReportReader(root, registry) {
 		const scores = trials.flatMap((trial) => trial?.scoring?.overall === void 0 ? [] : [trial.scoring.overall]);
 		return {
 			id,
+			...await ifPresent(() => stat(resolve(root, id, "archived.json"))) ? { archived: true } : {},
 			evalId: manifest.evalId,
 			...manifest.suiteId ? { suiteId: manifest.suiteId } : {},
 			...manifest.matrix ? {
@@ -8228,6 +8194,8 @@ function createDashboardReportReader(root, registry) {
 	}
 	return {
 		listRuns,
+		/** Run IDs skipped by the last `listRuns()` because an older EvalKit wrote them. */
+		legacyRunIds: () => [...legacyRuns],
 		listTrials,
 		trialDetail,
 		listArtifacts,
@@ -8259,6 +8227,235 @@ async function walkArtifacts(root) {
 	return result;
 }
 //#endregion
+//#region ../cli/src/dashboard-build.ts
+/** Marks a directory as EvalKit-owned so a rebuild may safely replace it. */
+const MARKER = ".evalkit-dashboard";
+const quietStep = (_label, work) => work(() => {});
+async function buildDashboard(options, step = quietStep) {
+	const { registry, reportRoot, dashboardRoot, outDir } = options;
+	const template = await readFile(resolve(dashboardRoot, "index.html"), "utf8");
+	const data = resolve(outDir, "data");
+	const write = async (path, value) => {
+		const file = resolve(data, path);
+		await mkdir(dirname(file), { recursive: true });
+		await writeFile(file, `${JSON.stringify(value)}\n`);
+	};
+	await step("Dashboard assets", async () => {
+		await prepareOutDir(outDir);
+		await cp(dashboardRoot, outDir, { recursive: true });
+		await writeFile(resolve(outDir, MARKER), "Generated by `evalkit build`.\n");
+		await writeFile(resolve(outDir, "index.html"), staticIndex(template));
+	}, () => "read-only UI with relative assets");
+	await step("Eval catalog", async () => {
+		await write("catalog.json", { evals: registry.catalog() });
+		await write("evals.json", { evals: registry.metadata() });
+		await write("suites.json", { suites: registry.suiteMetadata() });
+		return {
+			evals: registry.evals.length,
+			suites: registry.suites.length
+		};
+	}, ({ evals, suites }) => `${count(evals, "eval")} · ${count(suites, "suite")}`);
+	const reports = createDashboardReportReader(reportRoot, registry);
+	const snapshot = await step("Run reports", async (progress) => {
+		const all = await reports.listRuns();
+		const runs = all.filter((run) => !run.archived);
+		await write("runs.json", { runs });
+		let trials = 0;
+		let files = 0;
+		const trialIds = [];
+		for (const [index, run] of runs.entries()) {
+			progress(`run ${index + 1}/${runs.length} · ${run.id.slice(0, 8)}`);
+			const runTrials = await reports.listTrials(run.id);
+			await write(`runs/${run.id}/trials.json`, { trials: runTrials });
+			for (const trial of runTrials) {
+				trials += 1;
+				trialIds.push(trial.id);
+				files += await snapshotTrial(reports, write, data, run.id, trial.id);
+			}
+		}
+		return {
+			runs: runs.length,
+			trials,
+			files,
+			skipped: reports.legacyRunIds().length,
+			archived: all.length - runs.length,
+			runIds: runs.map((run) => run.id),
+			trialIds
+		};
+	}, ({ runs, trials, files, skipped, archived }) => `${count(runs, "run")} · ${count(trials, "trial")} · ${count(files, "candidate file")}` + (archived ? ` · ${archived} archived excluded` : "") + (skipped ? ` · ${skipped} older-format skipped` : ""));
+	await step("Route pages", async () => {
+		const routes = staticRoutes({
+			suites: registry.suites.map(authoringId),
+			evals: registry.catalog().map((entry) => entry.path),
+			runs: snapshot.runIds,
+			trials: snapshot.trialIds
+		});
+		for (const route of routes) {
+			const file = resolve(outDir, `${route}.html`);
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, staticIndex(template, baseFor(route)));
+		}
+		await writeFile(resolve(outDir, "404.html"), staticIndex(template, "/"));
+		return routes.length;
+	}, (pages) => `${count(pages, "page")} with clean /path URLs`);
+	const { runIds: _runs, trialIds: _trials, ...summary } = snapshot;
+	return {
+		outDir,
+		...summary
+	};
+}
+/**
+* Every dashboard URL known at build time, as file paths without `.html`.
+* Static hosts serve `/runs/abc` from `runs/abc.html`, so links and reloads
+* work without SPA rewrite rules. IDs that cannot be a safe file name are
+* skipped; those pages still open by navigating inside the app.
+*/
+function staticRoutes(ids) {
+	const safe = (id) => id.length > 0 && !/[/\\\0]/.test(id) && id !== "." && id !== "..";
+	const under = (prefix, values) => values.filter(safe).map((id) => `${prefix}/${id}`);
+	return [
+		"suites",
+		"agents",
+		"fixtures",
+		"runs",
+		...under("suites", ids.suites),
+		...under("evals", ids.evals),
+		...under("runs", ids.runs),
+		...under("trials", ids.trials),
+		...under("workspaces", ids.trials)
+	];
+}
+/** `runs/abc.html` is served at `<mount>/runs/abc`; its base is one level up. */
+function baseFor(route) {
+	const depth = route.split("/").length - 1;
+	return depth ? "../".repeat(depth) : "./";
+}
+function count(value, noun) {
+	return `${value} ${noun}${value === 1 ? "" : "s"}`;
+}
+/** Writes one trial's JSON views and candidate files; returns the file count. */
+async function snapshotTrial(reports, write, data, runId, trialId) {
+	const base = `runs/${runId}/trials/${trialId}`;
+	await write(`${base}/detail.json`, await reports.trialDetail(runId, trialId));
+	await write(`${base}/events.json`, { events: await reports.trajectory(runId, trialId) });
+	await write(`${base}/artifacts.json`, { artifacts: await reports.listArtifacts(runId, trialId) });
+	const workspace = await reports.listCandidateWorkspace(runId, trialId);
+	await write(`${base}/workspace.json`, workspace);
+	const root = resolve(data, base, "workspace");
+	let files = 0;
+	for (const entry of workspace) {
+		if (entry.kind !== "file") continue;
+		const target = resolve(root, entry.path);
+		if (!target.startsWith(`${root}${sep}`)) throw new Error(`Invalid workspace path: ${entry.path}`);
+		const response = await reports.candidateFile(runId, trialId, entry.path);
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, new Uint8Array(await response.arrayBuffer()));
+		files += 1;
+	}
+	return files;
+}
+/** Total size and file count of a directory, for the build summary. */
+async function directorySize(root) {
+	let bytes = 0;
+	let files = 0;
+	for (const entry of await readdir(root, {
+		withFileTypes: true,
+		recursive: true
+	})) {
+		if (!entry.isFile()) continue;
+		bytes += (await stat(resolve(entry.parentPath, entry.name))).size;
+		files += 1;
+	}
+	return {
+		bytes,
+		files
+	};
+}
+/**
+* Select the static API and make every URL relative to `<base href>`, which
+* points at the snapshot root. The app derives its router basename from it.
+*/
+function staticIndex(html, base = "./") {
+	const result = html.replace("<html lang=\"en\">", "<html lang=\"en\" data-evalkit-snapshot=\"static\">").replace("<head>", `<head>\n    <base href="${base}" />`).replaceAll("\"/assets/", "\"./assets/");
+	if (!result.includes("data-evalkit-snapshot=\"static\"") || !result.includes("<base href=")) throw new Error("Bundled dashboard index.html has an unexpected shape");
+	return result;
+}
+async function prepareOutDir(outDir) {
+	let entries;
+	try {
+		if (!(await stat(outDir)).isDirectory()) throw new Error(`Output path is not a directory: ${outDir}`);
+		entries = await readdir(outDir);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		await mkdir(outDir, { recursive: true });
+		return;
+	}
+	if (!entries.length) return;
+	if (!entries.includes(MARKER)) throw new Error(`Refusing to overwrite ${outDir}: it is not empty and was not created by evalkit build`);
+	await rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(outDir, { recursive: true });
+}
+//#endregion
+//#region ../cli/src/dashboard-cells.ts
+const MAX_SCAN = 1e5;
+function display(value) {
+	return typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+}
+/** Bounded report projection; both count and rows come from the core eligible-cell iterator. */
+function listMatrixCells(matrix, input) {
+	if (!Number.isSafeInteger(input.offset) || input.offset < 0 || !Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) throw new Error("Matrix page requires offset >= 0 and limit between 1 and 100");
+	if (![
+		"eval",
+		"agent",
+		"trials",
+		...[...Object.keys(matrix.cases?.[0] ?? {}), ...Object.keys(matrix.parameters)].map((key) => `axis:${key}`)
+	].includes(input.sort)) throw new Error(`Unknown matrix sort: ${input.sort}`);
+	const selection = input.evalIds.length ? { evals: input.evalIds } : {};
+	const planned = matrix.count(selection);
+	if (planned > MAX_SCAN) throw new Error(`Matrix has ${planned} eligible cells; narrow the selection in the CLI (dashboard limit ${MAX_SCAN})`);
+	const terms = input.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+	const cells = [...matrix.cells(selection)].filter((cell) => {
+		const haystack = [
+			cell.eval.id,
+			cell.eval.name,
+			cell.eval.agent?.identity?.name,
+			cell.eval.agent?.identity?.kind,
+			...Object.entries(cell.parameters).flatMap(([key, value]) => [key, display(value)])
+		].map(display).join(" ").toLowerCase();
+		return terms.every((term) => haystack.includes(term));
+	});
+	function value(cell) {
+		if (input.sort.startsWith("axis:")) {
+			const parameter = cell.parameters[input.sort.slice(5)];
+			return typeof parameter === "number" ? parameter : canonicalParameters(parameter);
+		}
+		if (input.sort === "eval") return cell.eval.name ?? cell.eval.id;
+		if (input.sort === "agent") return cell.eval.agent?.identity?.name ?? cell.eval.agent?.identity?.kind ?? "";
+		return cell.eval.policy?.trials ?? 1;
+	}
+	cells.sort((left, right) => {
+		const a = value(left);
+		const b = value(right);
+		const comparison = typeof a === "number" && typeof b === "number" ? a - b : String(a).localeCompare(String(b), void 0, {
+			numeric: true,
+			sensitivity: "base"
+		});
+		return (input.direction === "asc" ? comparison : -comparison) || left.key.localeCompare(right.key);
+	});
+	return {
+		total: cells.length,
+		planned,
+		cells: cells.slice(input.offset, input.offset + input.limit).map((cell) => ({
+			evalId: cell.eval.id,
+			key: cell.key,
+			parameters: cell.parameters
+		}))
+	};
+}
+//#endregion
 //#region ../cli/src/dashboard-matrix.ts
 /** Dashboard submissions are intentionally one explicit, configured cell at a time. */
 function selectDashboardCell(matrix, evalId, parameters) {
@@ -8376,6 +8573,111 @@ async function loadProject(cwd, configPath) {
 	};
 }
 //#endregion
+//#region ../cli/src/terminal.ts
+/** Human CLI output. Colors and live progress only appear on an interactive terminal. */
+const interactive = Boolean(process.stdout.isTTY);
+const colored = interactive && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+const paint = (code, reset) => (text) => colored ? `\x1b[${code}m${text}\x1b[${reset}m` : text;
+const bold = paint(1, 22);
+const dim = paint(2, 22);
+const red = paint(31, 39);
+const green = paint(32, 39);
+const yellow = paint(33, 39);
+const cyan = paint(36, 39);
+function banner(command, version) {
+	console.log(`\n  ${bold(cyan("EvalKit"))} ${bold(command)} ${dim(`v${version}`)}\n`);
+}
+function duration(ms) {
+	return ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(2)}s`;
+}
+function bytes(size) {
+	if (size < 1024) return `${size} B`;
+	if (size < 1024 ** 2) return `${(size / 1024).toFixed(1)} kB`;
+	return `${(size / 1024 ** 2).toFixed(1)} MB`;
+}
+function plural(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+/** Times one build step, showing a live line while it runs. */
+async function step(label, work, describe) {
+	const started = performance.now();
+	const progress = (detail) => {
+		if (interactive) process.stdout.write(`\r\x1b[2K  ${cyan("◇")} ${label.padEnd(20)} ${dim(detail)}`);
+	};
+	progress("…");
+	try {
+		const value = await work(progress);
+		const elapsed = duration(performance.now() - started);
+		if (interactive) process.stdout.write("\r\x1B[2K");
+		console.log(`  ${green("✓")} ${label.padEnd(20)} ${describe(value)} ${dim(elapsed)}`);
+		return value;
+	} catch (error) {
+		if (interactive) process.stdout.write("\r\x1B[2K");
+		console.log(`  ${red("✗")} ${label}`);
+		throw error;
+	}
+}
+function clock() {
+	return dim((/* @__PURE__ */ new Date()).toTimeString().slice(0, 8));
+}
+function cellLabel(name, parameters) {
+	const shown = Object.entries(parameters).map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`).join(" ");
+	return shown ? `${bold(name)} ${dim(shown)}` : bold(name);
+}
+function passed(result) {
+	return result.status === "completed" && (result.aggregateScoring?.passRate === 1 || Boolean(result.scoring?.passed));
+}
+/** Live log for runs launched from the `evalkit dev` dashboard. */
+const runLog = {
+	started(name, parameters = {}, suiteId) {
+		const suite = suiteId ? dim(` (suite ${suiteId})`) : "";
+		console.log(`${clock()}  ${cyan("▶ run ")} ${cellLabel(name, parameters)}${suite}`);
+	},
+	finished(name, parameters, result, ms) {
+		const ok = passed(result);
+		const trials = result.trials?.length ?? 1;
+		const passedTrials = result.aggregateScoring?.passed ?? (ok ? trials : 0);
+		const status = result.status === "completed" ? ok ? green("✓ pass") : red("✗ fail") : red(`✗ ${result.status}`);
+		console.log(`${clock()}  ${status} ${cellLabel(name, parameters)} ${dim(`${passedTrials}/${trials} trials · ${duration(ms)}`)}`);
+		console.log(`          ${dim(`report ${result.reportLocation}`)}`);
+	},
+	cell(cell, result, ms) {
+		runLog.finished(cell.eval.name ?? authoringId(cell.eval), cell.parameters, result, ms);
+	},
+	failed(name, error) {
+		console.log(`${clock()}  ${red("✗ error")} ${bold(name)} ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+/**
+* The runner logs structured Effect lines; the CLI prints its own summaries, so
+* only warnings show by default. `EVALKIT_LOG_LEVEL=info` (or `debug`) restores them.
+*/
+function runnerLogs(effect) {
+	const requested = process.env.EVALKIT_LOG_LEVEL?.toLowerCase();
+	const level = LogLevel.allLevels.find((item) => item.label.toLowerCase() === requested) ?? LogLevel.Warning;
+	return effect.pipe(Logger.withMinimumLogLevel(level));
+}
+/** True when a person can answer a prompt (not CI, pipes, or redirected input). */
+function canPrompt() {
+	return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function confirm(question) {
+	const { createInterface } = await import("node:readline/promises");
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await prompt.question(`  ${cyan("?")} ${question} ${dim("(y/N)")} `);
+		return /^y(es)?$/i.test(answer.trim());
+	} catch {
+		console.log("");
+		return false;
+	} finally {
+		prompt.close();
+	}
+}
+//#endregion
 //#region ../cli/src/run-command.ts
 function parseRunArgs(args) {
 	const { values, positionals } = parseArgs({
@@ -8388,6 +8690,8 @@ function parseRunArgs(args) {
 				type: "string",
 				multiple: true
 			},
+			suite: { type: "string" },
+			matrix: { type: "string" },
 			model: {
 				type: "string",
 				multiple: true
@@ -8454,6 +8758,8 @@ function normalizeRunOptions(values, positionals) {
 		if (index < 1) throw new Error("--param requires name=JSON");
 		parameters[value.slice(0, index)] = JSON.parse(value.slice(index + 1));
 	}
+	if (values.suite && values.matrix) throw new Error("--suite and --matrix cannot be used together");
+	if ((values.suite || values.matrix) && positionals.length) throw new Error("Use --eval to select evals with --suite or --matrix");
 	return {
 		values,
 		positionals,
@@ -8463,7 +8769,7 @@ function normalizeRunOptions(values, positionals) {
 		trials: integer("trials")
 	};
 }
-async function runProjectCommand(command, args, cwd = process.cwd(), parsed = parseRunArgs(args)) {
+async function runProjectCommand(args, cwd = process.cwd(), parsed = parseRunArgs(args)) {
 	const { values, positionals, parameters } = parsed;
 	const project = await loadProject(cwd, values.config);
 	process.chdir(project.root);
@@ -8471,14 +8777,9 @@ async function runProjectCommand(command, args, cwd = process.cwd(), parsed = pa
 	const requestedEvals = values.eval?.flatMap((value) => value.split(",")) ?? [];
 	let matrix;
 	let suiteId;
-	if (command === "run-matrix") {
-		if (positionals.length !== 1) throw new Error("run-matrix requires one matrix ID");
-		matrix = registry.matrices.find((m) => m.id === positionals[0]);
-		if (!matrix) throw new Error(`Unknown matrix: ${positionals[0]}`);
-	} else if (command === "run-suite") {
-		if (positionals.length !== 1) throw new Error("run-suite requires one suite ID");
-		const suite = registry.suites.find((s) => s.id === positionals[0]);
-		if (!suite) throw new Error(`Unknown suite: ${positionals[0]}`);
+	if (values.suite) {
+		const suite = registry.suites.find((item) => item.id === values.suite);
+		if (!suite) throw new Error(`Unknown suite: ${values.suite}`);
 		suiteId = authoringId(suite);
 		matrix = defineEvalMatrix({
 			id: "default",
@@ -8488,6 +8789,9 @@ async function runProjectCommand(command, args, cwd = process.cwd(), parsed = pa
 			cases: project.config.matrix?.cases,
 			exclude: project.config.matrix?.exclude
 		});
+	} else if (values.matrix) {
+		matrix = registry.matrices.find((item) => item.id === values.matrix);
+		if (!matrix) throw new Error(`Unknown matrix: ${values.matrix}`);
 	} else {
 		requestedEvals.push(...positionals.flatMap((value) => value.split(",")));
 		matrix = project.config.matrix ? registry.matrices.at(-1) : defineEvalMatrix({
@@ -8502,7 +8806,7 @@ async function runProjectCommand(command, args, cwd = process.cwd(), parsed = pa
 		...requestedEvals.length ? { evals: requestedEvals } : {}
 	};
 	for (const [axis, choices] of Object.entries(parsed.selection)) if (axis in matrix.parameters || matrix.cases?.some((assignment) => Object.hasOwn(assignment, axis))) selection.parameters[axis] = choices;
-	else if ((axis === "model" || axis === "mode") && choices.length === 1 && !project.config.matrix && command !== "run-matrix") selection.overrides[axis] = choices[0];
+	else if ((axis === "model" || axis === "mode") && choices.length === 1 && !project.config.matrix && !values.matrix) selection.overrides[axis] = choices[0];
 	else throw new Error(`Unknown matrix axis: ${axis}`);
 	const cells = matrix.count(selection);
 	if (!cells) throw new Error("Selection contains no eligible cells; check cases and exclusions");
@@ -8521,7 +8825,7 @@ async function runProjectCommand(command, args, cwd = process.cwd(), parsed = pa
 	}
 	if (cells > (project.config.execution?.maxCells ?? 100) && !values.all) throw new Error(`Selected ${cells} cells. Narrow the selection, inspect --dry-run, or pass --all.`);
 	if (!values.json) console.log(`Running ${cells} cell(s) from ${plan.matrix}`);
-	if ((await Effect.runPromise(runMatrix(matrix, {
+	if ((await Effect.runPromise(runnerLogs(runMatrix(matrix, {
 		selection,
 		concurrency: parsed.concurrency ?? project.config.execution?.concurrency ?? 4,
 		trials,
@@ -8547,7 +8851,56 @@ async function runProjectCommand(command, args, cwd = process.cwd(), parsed = pa
 				}
 			}
 		}
-	}))).failed) process.exitCode = 1;
+	})))).failed) process.exitCode = 1;
+}
+//#endregion
+//#region ../cli/src/tidy.ts
+/**
+* Every eval the project can run: standalone, in suites, or only in matrices.
+* A run is archived only when its eval is in none of these.
+*/
+function projectEvalIds(registry) {
+	return new Set([
+		...registry.evals,
+		...registry.suites.flatMap((suite) => suite.evals),
+		...registry.matrices.flatMap((matrix) => matrix.evals)
+	].map(authoringId));
+}
+/**
+* Mark runs of removed evals as archived, and restore runs whose eval returned.
+* Reports are never deleted: archiving writes a marker file beside the manifest.
+*/
+async function tidyReports(options) {
+	const known = projectEvalIds(options.registry);
+	const reports = createDashboardReportReader(options.reportRoot, options.registry);
+	const result = {
+		archived: [],
+		restored: [],
+		stillArchived: 0,
+		current: 0
+	};
+	for (const run of await reports.listRuns()) {
+		const marker = resolve(options.reportRoot, run.id, ARCHIVE_MARKER);
+		const entry = {
+			runId: run.id,
+			evalId: run.evalId
+		};
+		if (known.has(run.evalId)) {
+			result.current += 1;
+			if (run.archived) {
+				await rm(marker, { force: true });
+				result.restored.push(entry);
+			}
+		} else if (run.archived) result.stillArchived += 1;
+		else {
+			await writeFile(marker, `${JSON.stringify({
+				archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				reason: `Eval "${run.evalId}" is no longer in the project`
+			})}\n`);
+			result.archived.push(entry);
+		}
+	}
+	return result;
 }
 //#endregion
 //#region ../cli/src/new-project-template.ts
@@ -8653,21 +9006,23 @@ bun run check        # type-check your eval, agent, scorer, and config
 bun run evals        # run the example across both styles
 bun run matrix:plan  # inspect the matrix without running it
 bun run matrix       # run the configured matrix
-bun run dashboard    # inspect local reports
+bun run dashboard    # inspect local reports and launch runs
+bun run dashboard:build  # write a read-only, shareable snapshot
 \`\`\`
 
-EvalKit installs from the public GitHub repository; no registry token is needed.
-Reports and trial workspaces stay local and are ignored by Git.
-Commit \`bun.lock\` to pin the resolved EvalKit Git revision.
+EvalKit installs from npm. Reports, trial workspaces, and dashboard snapshots stay local
+and are ignored by Git. A snapshot in \`_evalkit-dashboard/\` contains report messages,
+scores, evidence, and candidate files (never evaluator workspaces): review it before sharing.
 `;
 }
 //#endregion
 //#region ../cli/src/new-project.ts
-const npmDependency = "^0.1.0";
+const npmDependency = "^0.3.0";
 const ignored = [
 	"node_modules/",
 	"_evalkit-results/",
-	"_evalkit-sandbox/"
+	"_evalkit-sandbox/",
+	"_evalkit-dashboard/"
 ];
 const readIfExists = async (path) => {
 	try {
@@ -8746,10 +9101,11 @@ async function preparePackage(packagePath, name) {
 	const devDependencies = pkg.devDependencies ?? {};
 	if (!scripts || typeof scripts !== "object" || Array.isArray(scripts) || !dependencies || typeof dependencies !== "object" || Array.isArray(dependencies) || !devDependencies || typeof devDependencies !== "object" || Array.isArray(devDependencies)) throw new Error(`Invalid package.json scripts/dependencies: ${packagePath}`);
 	scripts.check ??= "tsc --noEmit";
-	scripts.evals ??= "evalkit run-evals greeting --local";
-	scripts.matrix ??= "evalkit run-matrix styles --local";
-	scripts["matrix:plan"] ??= "evalkit run-matrix styles --dry-run";
-	scripts.dashboard ??= "evalkit serve-dashboard";
+	scripts.evals ??= "evalkit run greeting --local";
+	scripts.matrix ??= "evalkit run --matrix styles --local";
+	scripts["matrix:plan"] ??= "evalkit run --matrix styles --dry-run";
+	scripts.dashboard ??= "evalkit dev";
+	scripts["dashboard:build"] ??= "evalkit build";
 	if (!dependencies["@leostera/evalkit"] && !devDependencies["@leostera/evalkit"]) dependencies["@leostera/evalkit"] = npmDependency;
 	if (!dependencies.typescript && !devDependencies.typescript) devDependencies.typescript = "^6.0.0";
 	if (!dependencies["@types/bun"] && !devDependencies["@types/bun"]) devDependencies["@types/bun"] = "^1.4.0";
@@ -8778,6 +9134,7 @@ async function writeStarterReadme(root, name, inPlace) {
 }
 //#endregion
 //#region ../cli/src/index.ts
+const VERSION = "0.3.0";
 let projectRoot = process.cwd();
 let reportRoot = resolve(projectRoot, "_evalkit-results");
 const sandboxRoot = resolve(projectRoot, "_evalkit-sandbox");
@@ -8797,13 +9154,17 @@ async function runEvals(options) {
 	const registry = await loadRegistry();
 	const evaluations = options.evalIds.map((id) => registry.get(id));
 	if (evaluations.some((e) => !e)) throw new Error("Unknown eval");
-	await Effect.runPromise(Effect.all(evaluations.map((evaluation) => runEval(evaluation, {
-		report: localReportStore(reportRoot),
-		workspaceRoot: sandboxRoot,
-		suiteId: options.suiteId,
-		runtime: runtimeFor(evaluation),
-		concurrency: options.concurrency
-	})), { concurrency: options.concurrency }));
+	await Effect.runPromise(runnerLogs(Effect.all(evaluations.map((evaluation) => {
+		const name = evaluation.name ?? authoringId(evaluation);
+		const started = performance.now();
+		return Effect.sync(() => runLog.started(name, {}, options.suiteId)).pipe(Effect.andThen(runEval(evaluation, {
+			report: localReportStore(reportRoot),
+			workspaceRoot: sandboxRoot,
+			suiteId: options.suiteId,
+			runtime: runtimeFor(evaluation),
+			concurrency: options.concurrency
+		})), Effect.tap((result) => runLog.finished(name, {}, result, performance.now() - started)), Effect.tapError((error) => Effect.sync(() => runLog.failed(name, error))));
+	}), { concurrency: options.concurrency })));
 }
 function registerMatrixRoutes(app, registry, dashboardMatrix, trials) {
 	let matrixRunning = false;
@@ -8846,14 +9207,18 @@ function registerMatrixRoutes(app, registry, dashboardMatrix, trials) {
 			}
 			if (matrixRunning) return context.text("A dashboard matrix cell is already running", 409);
 			matrixRunning = true;
-			Effect.runPromise(runMatrix(dashboardMatrix, {
+			const name = evaluation.name ?? authoringId(evaluation);
+			const started = performance.now();
+			runLog.started(name, body.parameters ?? {}, suiteId);
+			Effect.runPromise(runnerLogs(runMatrix(dashboardMatrix, {
 				selection,
 				concurrency: 1,
 				trials,
 				...suiteId ? { suiteId } : {},
 				report: localReportStore(reportRoot),
-				workspaceRoot: sandboxRoot
-			})).catch((error) => console.error("Dashboard matrix run failed:", error)).finally(() => {
+				workspaceRoot: sandboxRoot,
+				onResult: (cell, result) => runLog.cell(cell, result, performance.now() - started)
+			}))).catch((error) => runLog.failed(name, error)).finally(() => {
 				matrixRunning = false;
 			});
 		} else {
@@ -8862,7 +9227,7 @@ function registerMatrixRoutes(app, registry, dashboardMatrix, trials) {
 				evalIds: [authoringId(evaluation)],
 				suiteId,
 				concurrency: 32
-			}).catch((error) => console.error("Dashboard run failed:", error));
+			}).catch(() => {});
 		}
 		return context.json({ accepted: true }, 202);
 	});
@@ -8874,7 +9239,7 @@ function registerMatrixRoutes(app, registry, dashboardMatrix, trials) {
 			evalIds: suite.evals.map(authoringId),
 			suiteId: authoringId(suite),
 			concurrency: 32
-		}).catch((error) => console.error("Dashboard suite run failed:", error));
+		}).catch(() => {});
 		return context.json({ accepted: true }, 202);
 	});
 }
@@ -8942,19 +9307,48 @@ function registerDashboardAssets(app, dashboardRoot) {
 		return new Response(content, { headers: { "content-type": fileContentType(servedFile) } });
 	});
 }
+/** The npm package bundles the UI beside cli.mjs; the monorepo uses its Vite build. */
+function dashboardAssets() {
+	const bundledDashboard = new URL("./dashboard/", import.meta.url);
+	const root = fileURLToPath(existsSync(bundledDashboard) ? bundledDashboard : new URL("../../dashboard/dist/", import.meta.url));
+	if (!existsSync(resolve(root, "index.html"))) throw new Error(`Dashboard assets not found at ${root}; run \`bun run build\` in the EvalKit repository`);
+	return root;
+}
+async function useProject(configPath) {
+	project = await loadProject(projectRoot, configPath);
+	projectRoot = project.root;
+	reportRoot = resolve(projectRoot, project.config.reportDir ?? "_evalkit-results");
+}
 async function serveDashboard() {
 	const registry = await loadRegistry();
-	const bundledDashboard = new URL("./dashboard/", import.meta.url);
-	const dashboardRoot = fileURLToPath(existsSync(bundledDashboard) ? bundledDashboard : new URL("../../dashboard/dist/", import.meta.url));
+	const dashboardRoot = dashboardAssets();
 	const app = new Hono();
-	registerMatrixRoutes(app, registry, project?.config.matrix ? registry.matrices.at(-1) : void 0, project?.config.execution?.trials);
+	const dashboardMatrix = project?.config.matrix ? registry.matrices.at(-1) : void 0;
+	registerMatrixRoutes(app, registry, dashboardMatrix, project?.config.execution?.trials);
 	registerReportRoutes(app, registry, createDashboardReportReader(reportRoot, registry));
 	registerDashboardAssets(app, dashboardRoot);
-	const url = `http://localhost:${Bun.serve({
-		port: Number(process.env.PORT ?? 4317),
-		fetch: app.fetch
-	}).port}`;
-	console.log(`EvalKit dashboard: ${url}`);
+	const port = Number(process.env.PORT ?? 4317);
+	let server;
+	try {
+		server = Bun.serve({
+			port,
+			fetch: app.fetch
+		});
+	} catch (error) {
+		if (error.code === "EADDRINUSE") throw new Error(`Port ${port} is already in use. Stop the other server or choose another port: PORT=4318 evalkit dev`);
+		throw error;
+	}
+	const url = `http://localhost:${server.port}`;
+	const reader = createDashboardReportReader(reportRoot, registry);
+	const runs = (await reader.listRuns()).length;
+	const legacy = reader.legacyRunIds().length;
+	const matrixCells = dashboardMatrix?.count({ parameters: {} });
+	const row = (label, value) => console.log(`  ${cyan("➜")}  ${bold(label.padEnd(9))}${value}`);
+	banner("dev", VERSION);
+	row("Local:", cyan(url));
+	row("Project:", `${plural(registry.evals.length, "eval")} · ${plural(registry.suites.length, "suite")}` + (dashboardMatrix ? ` · matrix ${authoringId(dashboardMatrix)} (${plural(matrixCells, "cell")})` : ""));
+	row("Reports:", `${relative(process.cwd(), reportRoot) || "."} ${dim(`(${plural(runs, "run")}${legacy ? `, ${legacy} from an older EvalKit hidden` : ""})`)}`);
+	console.log(`\n  ${dim("Runs started from the dashboard are logged below. Press Ctrl+C to stop.")}\n`);
 	if (process.env.EVALKIT_NO_OPEN !== "1") {
 		const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
 		try {
@@ -8969,6 +9363,8 @@ const config = text("config").pipe(optional);
 const runOptions = {
 	config,
 	eval: text("eval").pipe(repeated),
+	suite: text("suite").pipe(optional),
+	matrix: text("matrix").pipe(optional),
 	model: text("model").pipe(repeated),
 	mode: text("mode").pipe(repeated),
 	select: text("select").pipe(repeated),
@@ -8989,6 +9385,8 @@ function runInput(options, positionals) {
 	return normalizeRunOptions({
 		config: Option.getOrUndefined(options.config),
 		eval: options.eval,
+		suite: Option.getOrUndefined(options.suite),
+		matrix: Option.getOrUndefined(options.matrix),
 		model: options.model,
 		mode: options.mode,
 		select: options.select,
@@ -9004,22 +9402,14 @@ function runInput(options, positionals) {
 		local: options.local
 	}, positionals);
 }
-const execute = (command, input) => Effect.tryPromise({
-	try: () => runProjectCommand(command, [], process.cwd(), input),
+const execute = (input) => Effect.tryPromise({
+	try: () => runProjectCommand([], process.cwd(), input),
 	catch: (error) => error
 });
-const evalsCommand = make$1("run-evals", {
+const runCommand = make$1("run", {
 	...runOptions,
 	evalIds: text$2({ name: "eval-id" }).pipe(repeated$2)
-}, ({ evalIds, ...options }) => execute("run-evals", runInput(options, evalIds)));
-const matrixCommand = make$1("run-matrix", {
-	...runOptions,
-	matrixId: text$2({ name: "matrix-id" })
-}, ({ matrixId, ...options }) => execute("run-matrix", runInput(options, [matrixId])));
-const suiteCommand = make$1("run-suite", {
-	...runOptions,
-	suiteId: text$2({ name: "suite-id" })
-}, ({ suiteId, ...options }) => execute("run-suite", runInput(options, [suiteId])));
+}, ({ evalIds, ...options }) => execute(runInput(options, evalIds)));
 const newCommand = make$1("new", { directory: text$2({ name: "directory" }) }, ({ directory }) => Effect.tryPromise({
 	try: async () => {
 		const root = await newProject([directory]);
@@ -9027,24 +9417,103 @@ const newCommand = make$1("new", { directory: text$2({ name: "directory" }) }, (
 	},
 	catch: (error) => error
 }));
-const dashboardCommand = make$1("serve-dashboard", { config }, ({ config }) => Effect.tryPromise({
+const devCommand = make$1("dev", { config }, ({ config }) => Effect.tryPromise({
 	try: async () => {
-		project = await loadProject(projectRoot, Option.getOrUndefined(config));
-		projectRoot = project.root;
-		reportRoot = resolve(projectRoot, project.config.reportDir ?? "_evalkit-results");
+		await useProject(Option.getOrUndefined(config));
 		await serveDashboard();
 	},
 	catch: (error) => error
 }));
+const buildCommand = make$1("build", {
+	config,
+	out: text("out").pipe(optional),
+	run: boolean("run"),
+	noRun: boolean("no-run")
+}, ({ config, out, run, noRun }) => Effect.tryPromise({
+	try: async () => {
+		if (run && noRun) throw new Error("Choose either --run or --no-run");
+		const started = performance.now();
+		const configPath = Option.getOrUndefined(config);
+		banner("build", VERSION);
+		await loadProjectStep(configPath);
+		if (await shouldRunEvals({
+			run,
+			noRun
+		})) await runAllEvals(configPath);
+		const result = await buildDashboard({
+			registry: project.registry,
+			reportRoot,
+			dashboardRoot: dashboardAssets(),
+			outDir: resolve(projectRoot, Option.getOrElse(out, () => "_evalkit-dashboard"))
+		}, step);
+		const size = await directorySize(result.outDir);
+		const shown = relative(process.cwd(), result.outDir) || ".";
+		console.log(`\n  ${bold(`${shown}/`)}  ${dim(`${bytes(size.bytes)} · ${plural(size.files, "file")}`)}`);
+		console.log(`\n  ${bold("Built read-only dashboard")} in ${duration(performance.now() - started)}\n`);
+		console.log(`  ${cyan("➜")}  ${bold("Preview:")}  bunx serve ${shown}`);
+		console.log(`  ${yellow("⚠")}  Contains transcripts, scores, evidence, and candidate files\n     (never evaluator workspaces). Review before sharing.\n`);
+	},
+	catch: (error) => error
+}));
+async function loadProjectStep(configPath) {
+	await step("Eval project", () => useProject(configPath), () => {
+		const where = relative(process.cwd(), projectRoot);
+		return `${plural(project.registry.evals.length, "eval")} loaded${where ? ` from ${where}` : ""}`;
+	});
+}
+/**
+* A snapshot needs data: with no current results, run the evals. Otherwise ask,
+* or keep the existing results when no one can answer (CI, pipes).
+*/
+async function shouldRunEvals(flags) {
+	if (flags.run) return true;
+	if (flags.noRun) return false;
+	const runs = (await createDashboardReportReader(reportRoot, project.registry).listRuns()).filter((entry) => !entry.archived).length;
+	if (!runs) {
+		console.log(`  ${cyan("◇")} No results yet, so running the evals to have data to build.`);
+		return true;
+	}
+	if (!canPrompt()) {
+		console.log(`  ${dim(`Using ${plural(runs, "existing run")}; pass --run to run the evals first.`)}`);
+		return false;
+	}
+	return confirm(`Run the evals before building? ${dim(`(${plural(runs, "existing run")})`)}`);
+}
+async function runAllEvals(configPath) {
+	const started = performance.now();
+	console.log(`\n  ${cyan("▶")} ${bold("Running evals")}\n`);
+	await runProjectCommand([], process.cwd(), parseRunArgs(configPath ? ["--config", configPath] : []));
+	const failed = process.exitCode === 1;
+	console.log(`\n  ${failed ? yellow("⚠") : cyan("✓")} ${bold("Evals finished")} in ${duration(performance.now() - started)}` + (failed ? dim(" (some failed; building with their results)") : "") + "\n");
+}
+const tidyCommand = make$1("tidy", { config }, ({ config }) => Effect.tryPromise({
+	try: async () => {
+		banner("tidy", VERSION);
+		await loadProjectStep(Option.getOrUndefined(config));
+		const result = await step("Run reports", () => tidyReports({
+			registry: project.registry,
+			reportRoot
+		}), (value) => `${plural(value.current + value.archived.length + value.stillArchived, "run")} checked`);
+		const byEval = (entries) => [...entries.reduce((groups, entry) => groups.set(entry.evalId, (groups.get(entry.evalId) ?? 0) + 1), /* @__PURE__ */ new Map()).entries()].map(([id, total]) => `    ${bold(id)} ${dim(`(${plural(total, "run")})`)}`).join("\n");
+		console.log("");
+		if (result.archived.length) console.log(`  ${yellow("◆")} Archived ${plural(result.archived.length, "run")} of evals no longer in the project:\n${byEval(result.archived)}`);
+		if (result.restored.length) console.log(`  ${cyan("◆")} Restored ${plural(result.restored.length, "run")} whose eval is back:\n${byEval(result.restored)}`);
+		if (!result.archived.length && !result.restored.length) console.log(`  ${cyan("✓")} Nothing new to tidy.`);
+		const totalArchived = result.archived.length + result.stillArchived;
+		if (totalArchived) console.log(`\n  ${dim(`Archived runs (${totalArchived}) are hidden in \`evalkit dev\` (filter "Show archived")`)}\n  ${dim("and left out of `evalkit build`. Nothing was deleted.")}`);
+		console.log("");
+	},
+	catch: (error) => error
+}));
 const cli = run(make$1("evalkit").pipe(withSubcommands([
 	newCommand,
-	evalsCommand,
-	matrixCommand,
-	suiteCommand,
-	dashboardCommand
+	runCommand,
+	devCommand,
+	buildCommand,
+	tidyCommand
 ])), {
 	name: "EvalKit",
-	version: "0.1.0"
+	version: VERSION
 });
 const argv = process.argv.slice();
 if (argv[2] === "help") argv.splice(2, 1, "--help");