@leostera/evalkit 0.2.0 → 0.4.0

package/dist/cli.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env bun
-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 { I as defineEvalMatrix, L as canonicalParameters, m as registerEvals, n as authoringId } from "./src-ButXPY8P.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-DoPs9Yug.mjs";
+import { c as dashboardIndex, d as encodeBundle, o as repoKey } from "./index-db-vbqEGFaU.mjs";
+import { t as createDirectoryShareApp } from "./src-DzZueFn3.mjs";
 import * as Schema from "effect/Schema";
-import { Effect, Option } from "effect";
-import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { Effect, LogLevel, Logger, Option } from "effect";
+import { cp, mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import * as Path from "node:path";
-import { basename, dirname, extname, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import * as OS from "node:os";
 import * as Crypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -43,11 +45,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";
@@ -65,8 +67,9 @@ import * as FiberSet from "effect/FiberSet";
 import "effect/Fiber";
 import "effect/Pool";
 import * as MutableRef from "effect/MutableRef";
-import { parseArgs } from "node:util";
+import { parseArgs, promisify } from "node:util";
 import * as ChildProcess from "node:child_process";
+import { execFile } from "node:child_process";
 import * as RcRef from "effect/RcRef";
 import * as readline from "node:readline";
 import { Hono } from "hono";
@@ -392,13 +395,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 +503,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 +515,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 +590,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 +615,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 +2221,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 +2231,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 +2251,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 +2310,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 +2376,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 +2595,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 +2615,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 +2645,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 +3109,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 +3162,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 +3176,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 +3319,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 +3331,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 +3340,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 +3371,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 }
 		}));
@@ -3463,7 +3466,7 @@ function handleProcessInteger(options) {
 	};
 }
 /** @internal */
-const integer = (options) => {
+const integer$3 = (options) => {
 	const opts = {
 		min: Number.NEGATIVE_INFINITY,
 		max: Number.POSITIVE_INFINITY,
@@ -3551,7 +3554,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 +3569,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 +3614,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 +3717,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 +3731,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 +3740,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 +3770,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 +3912,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 +3944,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",
@@ -4029,6 +4032,12 @@ const choice = (alternatives) => {
 	return op;
 };
 /** @internal */
+const integer$2 = /*#__PURE__*/ (() => {
+	const op = /*#__PURE__*/ Object.create(proto$5);
+	op._tag = "Integer";
+	return op;
+})();
+/** @internal */
 const text$4 = /*#__PURE__*/ (() => {
 	const op = /*#__PURE__*/ Object.create(proto$5);
 	op._tag = "Text";
@@ -4184,7 +4193,7 @@ const wizardInternal$3 = (self, help) => {
 		case "Integer": {
 			const primitiveHelp = p("Enter an integer");
 			const message = sequence(help, primitiveHelp);
-			return integer({ message: toAnsiText(message).trimEnd() }).pipe(map$3((value) => `${value}`));
+			return integer$3({ message: toAnsiText(message).trimEnd() }).pipe(map$3((value) => `${value}`));
 		}
 		case "Path": {
 			const primitiveHelp = p("Select a file system path");
@@ -4689,7 +4698,7 @@ const wizardInternal$2 = (self, config) => {
 		case "Variadic": {
 			const repeatHelp = p("How many times should this argument should be repeated?");
 			const message = pipe(getHelpInternal$2(self), sequence(repeatHelp));
-			return integer({
+			return integer$3({
 				message: toAnsiText(message).trimEnd(),
 				min: getMinSizeInternal$1(self),
 				max: getMaxSizeInternal$1(self)
@@ -4874,13 +4883,15 @@ const boolean$1 = (name, options) => {
 		const head = Arr.headNonEmpty(negationNames);
 		const tail = Arr.tailNonEmpty(negationNames);
 		const negationOption = makeSingle(head, tail, boolean$2(Option$1.some(!ifPresent)));
-		return withDefault(orElse(option, negationOption), !ifPresent);
+		return withDefault$1(orElse(option, negationOption), !ifPresent);
 	}
-	return withDefault(option, !ifPresent);
+	return withDefault$1(option, !ifPresent);
 };
 /** @internal */
 const choiceWithValue = (name, choices) => makeSingle(name, Arr.empty(), choice(choices));
 /** @internal */
+const integer$1 = (name) => makeSingle(name, Arr.empty(), integer$2);
+/** @internal */
 const none = /*#__PURE__*/ (() => {
 	const op = /*#__PURE__*/ Object.create(proto$2);
 	op._tag = "Empty";
@@ -4895,7 +4906,7 @@ const getUsage$1 = (self) => getUsageInternal$1(self);
 /** @internal */
 const map$1 = /*#__PURE__*/ dual(2, (self, f) => makeMap(self, (a) => Either$1.right(f(a))));
 /** @internal */
-const optional$1 = (self) => withDefault(map$1(self, Option$1.some), Option$1.none());
+const optional$1 = (self) => withDefault$1(map$1(self, Option$1.some), Option$1.none());
 /** @internal */
 const orElse = /*#__PURE__*/ dual(2, (self, that) => orElseEither(self, that).pipe(map$1(Either$1.merge)));
 /** @internal */
@@ -4917,7 +4928,7 @@ const withAlias = /*#__PURE__*/ dual(2, (self, alias) => modifySingle(self, (sin
 	return makeSingle(single.name, aliases, single.primitiveType, single.description, single.pseudoName);
 }));
 /** @internal */
-const withDefault = /*#__PURE__*/ dual(2, (self, fallback) => makeWithDefault(self, fallback));
+const withDefault$1 = /*#__PURE__*/ dual(2, (self, fallback) => makeWithDefault(self, fallback));
 /** @internal */
 const withDescription = /*#__PURE__*/ dual(2, (self, desc) => modifySingle(self, (single) => {
 	const description = sequence(single.description, p(desc));
@@ -5305,7 +5316,7 @@ const wizardInternal$1 = (self, config) => {
 		case "Variadic": {
 			const repeatHelp = p("How many times should this argument be repeated?");
 			const message = pipe(getHelpInternal$1(self), sequence(repeatHelp));
-			return integer({
+			return integer$3({
 				message: toAnsiText(message).trimEnd(),
 				min: getMinSizeInternal(self),
 				max: getMaxSizeInternal(self)
@@ -5919,7 +5930,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 */
@@ -5957,6 +5968,11 @@ const boolean = boolean$1;
 * @since 1.0.0
 * @category constructors
 */
+const integer = integer$1;
+/**
+* @since 1.0.0
+* @category constructors
+*/
 const text = text$1;
 /**
 * @since 1.0.0
@@ -5974,6 +5990,11 @@ const optional = optional$1;
 * @category combinators
 */
 const repeated = repeated$1;
+/**
+* @since 1.0.0
+* @category combinators
+*/
+const withDefault = withDefault$1;
 //#endregion
 //#region ../../node_modules/.bun/@effect+cli@0.77.2+74e017304edf4bf0/node_modules/@effect/cli/dist/esm/internal/commandDirective.js
 /** @internal */
@@ -6294,7 +6315,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 +6655,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 +6761,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) => {
@@ -8050,6 +8071,8 @@ const layer = /*#__PURE__*/ pipe(/*#__PURE__*/ Layer.mergeAll(layer$3, layer$5,
 //#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";
 }
@@ -8086,15 +8109,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));
@@ -8103,6 +8146,8 @@ 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 } : {},
+			...manifest.source ? { source: manifest.source } : {},
 			evalId: manifest.evalId,
 			...manifest.suiteId ? { suiteId: manifest.suiteId } : {},
 			...manifest.matrix ? {
@@ -8171,6 +8216,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,
@@ -8205,67 +8252,172 @@ async function walkArtifacts(root) {
 //#region ../cli/src/dashboard-build.ts
 /** Marks a directory as EvalKit-owned so a rebuild may safely replace it. */
 const MARKER = ".evalkit-dashboard";
-/**
-* Write a read-only static dashboard: the bundled UI plus JSON snapshots of
-* the catalog and local reports, and each trial's candidate artifact files.
-* Evaluator workspaces are never copied; reports may still contain sensitive
-* messages, scores, or evidence, so review the output before sharing it.
-*/
-async function buildDashboard(options) {
+const quietStep = (_label, work) => work(() => {});
+async function buildDashboard(options, step = quietStep) {
 	const { registry, reportRoot, dashboardRoot, outDir } = options;
-	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(await readFile(resolve(dashboardRoot, "index.html"), "utf8")));
+	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"), dashboardIndex(template, { base: "./" }));
+	}, () => "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 runs = await reports.listRuns();
-	await write("catalog.json", { evals: registry.catalog() });
-	await write("evals.json", { evals: registry.metadata() });
-	await write("suites.json", { suites: registry.suiteMetadata() });
-	await write("runs.json", { runs });
-	let trials = 0;
+	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 written = await snapshotRun(reports, run.id, directorySink(resolve(data, "runs", run.id)));
+			trials += written.trialIds.length;
+			files += written.files;
+			trialIds.push(...written.trialIds);
+		}
+		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, dashboardIndex(template, { base: baseFor(route) }));
+		}
+		await writeFile(resolve(outDir, "404.html"), dashboardIndex(template, { base: "/" }));
+		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 a run's snapshot below `root` (static builds). */
+function directorySink(root) {
+	const target = (path) => {
+		const file = resolve(root, path);
+		if (!file.startsWith(`${resolve(root)}${sep}`)) throw new Error(`Invalid snapshot path: ${path}`);
+		return file;
+	};
+	return {
+		async json(path, value) {
+			const file = target(path);
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, `${JSON.stringify(value)}\n`);
+		},
+		async bytes(path, data) {
+			const file = target(path);
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, data);
+		}
+	};
+}
+/**
+* One run's snapshot, shared by `evalkit build` (files on disk) and
+* `evalkit share` (an upload bundle): `trials.json`, then per trial
+* `detail.json`, `events.json`, `artifacts.json`, `workspace.json`, and the
+* candidate files under `workspace/`. Evaluator workspaces are never read.
+*/
+async function snapshotRun(reports, runId, sink, options = {}) {
+	const trials = await reports.listTrials(runId);
+	await sink.json("trials.json", { trials });
 	let files = 0;
-	for (const run of runs) {
-		const runTrials = await reports.listTrials(run.id);
-		await write(`runs/${run.id}/trials.json`, { trials: runTrials });
-		for (const trial of runTrials) {
-			trials += 1;
-			const base = `runs/${run.id}/trials/${trial.id}`;
-			await write(`${base}/detail.json`, await reports.trialDetail(run.id, trial.id));
-			await write(`${base}/events.json`, { events: await reports.trajectory(run.id, trial.id) });
-			await write(`${base}/artifacts.json`, { artifacts: await reports.listArtifacts(run.id, trial.id) });
-			const workspace = await reports.listCandidateWorkspace(run.id, trial.id);
-			await write(`${base}/workspace.json`, workspace);
-			for (const entry of workspace) {
-				if (entry.kind !== "file") continue;
-				const response = await reports.candidateFile(run.id, trial.id, entry.path);
-				const target = resolve(data, base, "workspace", entry.path);
-				const root = resolve(data, base, "workspace");
-				if (!target.startsWith(`${root}${sep}`)) throw new Error(`Invalid workspace path: ${entry.path}`);
-				await mkdir(dirname(target), { recursive: true });
-				await writeFile(target, new Uint8Array(await response.arrayBuffer()));
-				files += 1;
-			}
+	for (const trial of trials) {
+		const base = `trials/${trial.id}`;
+		await sink.json(`${base}/detail.json`, await reports.trialDetail(runId, trial.id));
+		await sink.json(`${base}/events.json`, { events: await reports.trajectory(runId, trial.id) });
+		await sink.json(`${base}/artifacts.json`, { artifacts: await reports.listArtifacts(runId, trial.id) });
+		const workspace = await reports.listCandidateWorkspace(runId, trial.id);
+		await sink.json(`${base}/workspace.json`, workspace);
+		if (options.workspaceFiles === false) continue;
+		for (const entry of workspace) {
+			if (entry.kind !== "file") continue;
+			const response = await reports.candidateFile(runId, trial.id, entry.path);
+			await sink.bytes(`${base}/workspace/${entry.path}`, new Uint8Array(await response.arrayBuffer()));
+			files += 1;
 		}
 	}
 	return {
-		outDir,
-		runs: runs.length,
-		trials,
+		trialIds: trials.map((trial) => trial.id),
 		files
 	};
 }
-/** Use relative asset URLs and select the static API in the browser bundle. */
-function staticIndex(html) {
-	const result = html.replace("<html lang=\"en\">", "<html lang=\"en\" data-evalkit-snapshot=\"static\">").replaceAll("\"/assets/", "\"./assets/");
-	if (!result.includes("data-evalkit-snapshot=\"static\"")) throw new Error("Bundled dashboard index.html has an unexpected shape");
-	return result;
+/** 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
+	};
 }
 async function prepareOutDir(outDir) {
 	let entries;
@@ -8460,6 +8612,231 @@ 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/source.ts
+const exec = promisify(execFile);
+/**
+* Normalize a git remote to a stable repository key: lowercase host, no
+* credentials, port, scheme, `.git`, or trailing slash.
+*
+*   git@GitLab.example.com:group/sub/repo.git → gitlab.example.com/group/sub/repo
+*   https://user:token@github.com/o/r/        → github.com/o/r
+*   /srv/repos/thing.git (no host)            → local/thing
+*/
+function normalizeRepoUrl(url) {
+	const trimmed = url.trim().replace(/\/+$/, "").replace(/\.git$/, "");
+	const scp = /^(?:[^@/]+@)?([^:/]+):(?!\/)(.+)$/.exec(trimmed);
+	if (scp && !/^[a-z]+:\/\//i.test(trimmed)) return `${scp[1].toLowerCase()}/${scp[2].replace(/^\/+/, "")}`;
+	try {
+		const parsed = new URL(trimmed);
+		if (parsed.protocol !== "file:" && parsed.hostname) return `${parsed.hostname.toLowerCase()}${parsed.pathname.replace(/\/+$/, "")}`;
+	} catch {}
+	return `local/${basename(trimmed)}`;
+}
+async function git(cwd, ...args) {
+	try {
+		const { stdout } = await exec("git", [
+			"-C",
+			cwd,
+			...args
+		], { timeout: 1e4 });
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+const posix = (path) => path.split(sep).join("/");
+const projectPath = (root, projectRoot) => root ? posix(relative(root, projectRoot)) : "";
+function ciSource(env, projectRoot) {
+	if (env.EVALKIT_SOURCE_REPO && env.EVALKIT_SOURCE_COMMIT) return {
+		repo: normalizeRepoUrl(env.EVALKIT_SOURCE_REPO),
+		project: env.EVALKIT_SOURCE_PROJECT ?? "",
+		commit: env.EVALKIT_SOURCE_COMMIT,
+		...env.EVALKIT_SOURCE_REF ? { ref: env.EVALKIT_SOURCE_REF } : {},
+		...env.EVALKIT_SOURCE_COMMITTED_AT ? { committedAt: env.EVALKIT_SOURCE_COMMITTED_AT } : {}
+	};
+	if (env.GITLAB_CI === "true" && env.CI_PROJECT_URL && env.CI_COMMIT_SHA) return {
+		repo: normalizeRepoUrl(env.CI_PROJECT_URL),
+		project: projectPath(env.CI_PROJECT_DIR, projectRoot),
+		commit: env.CI_COMMIT_SHA,
+		...env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME ?? env.CI_COMMIT_REF_NAME ? { ref: env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME ?? env.CI_COMMIT_REF_NAME } : {},
+		...env.CI_COMMIT_TIMESTAMP ? { committedAt: env.CI_COMMIT_TIMESTAMP } : {},
+		ci: {
+			provider: "gitlab",
+			...env.CI_PIPELINE_ID ? { pipeline: env.CI_PIPELINE_ID } : {},
+			...env.CI_JOB_ID ? { job: env.CI_JOB_ID } : {},
+			...env.CI_JOB_URL ? { url: env.CI_JOB_URL } : {}
+		}
+	};
+	if (env.GITHUB_ACTIONS === "true" && env.GITHUB_REPOSITORY && env.GITHUB_SHA) {
+		const server = env.GITHUB_SERVER_URL ?? "https://github.com";
+		return {
+			repo: normalizeRepoUrl(`${server}/${env.GITHUB_REPOSITORY}`),
+			project: projectPath(env.GITHUB_WORKSPACE, projectRoot),
+			commit: env.GITHUB_SHA,
+			...env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME ? { ref: env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME } : {},
+			ci: {
+				provider: "github",
+				...env.GITHUB_RUN_ID ? { pipeline: env.GITHUB_RUN_ID } : {},
+				...env.GITHUB_JOB ? { job: env.GITHUB_JOB } : {},
+				...env.GITHUB_RUN_ID ? { url: `${server}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` } : {}
+			}
+		};
+	}
+}
+/**
+* Determine which repository and commit this project's eval code comes from.
+* Order: EVALKIT_SOURCE_* variables, GitLab/GitHub CI variables, then git.
+* Returns undefined outside git with no CI variables ("untracked" results).
+*
+* `outputDirs` (results, sandbox, snapshot) never make the tree dirty, even
+* when a project forgot to ignore them.
+*/
+async function detectSource(givenRoot, options = {}) {
+	const env = options.env ?? process.env;
+	const projectRoot = await realpath(givenRoot).catch(() => givenRoot);
+	const top = await git(projectRoot, "rev-parse", "--show-toplevel");
+	const excludes = top ? (options.outputDirs ?? []).map((dir) => join(projectRoot, relative(givenRoot, dir))).map((dir) => posix(relative(top, dir))).filter((dir) => dir && !dir.startsWith("..")).map((dir) => `:(exclude)${dir}`) : [];
+	const dirty = top ? Boolean(await git(top, "status", "--porcelain", "--", ".", ...excludes)) : false;
+	const fromCi = ciSource(env, projectRoot);
+	if (fromCi) return {
+		...fromCi,
+		...top && !env.EVALKIT_SOURCE_PROJECT ? { project: projectPath(top, projectRoot) } : {},
+		dirty
+	};
+	if (!top) return void 0;
+	const commit = await git(top, "rev-parse", "HEAD");
+	if (!commit) return void 0;
+	const remote = await git(top, "config", "--get", "remote.origin.url") ?? (await git(top, "remote"))?.split("\n").map((name) => name.trim()).find(Boolean);
+	const remoteUrl = remote && !remote.includes("/") && !remote.includes(":") ? await git(top, "config", "--get", `remote.${remote}.url`) : remote;
+	const ref = await git(top, "symbolic-ref", "--short", "-q", "HEAD");
+	const committedAt = await git(top, "show", "-s", "--format=%cI", "HEAD");
+	return {
+		repo: normalizeRepoUrl(remoteUrl ?? top),
+		project: projectPath(top, projectRoot),
+		commit,
+		...ref ? { ref } : {},
+		...committedAt ? { committedAt } : {},
+		dirty
+	};
+}
+/** The project's evals and suites, saved with each run (`catalog.json`). */
+function runCatalog(registry) {
+	return {
+		catalog: registry.catalog(),
+		evals: registry.metadata(),
+		suites: registry.suiteMetadata()
+	};
+}
+/** `abc1234` or `abc1234+dirty`. */
+function shortSource(source) {
+	return `${source.commit.slice(0, 7)}${source.dirty ? "+dirty" : ""}`;
+}
+//#endregion
 //#region ../cli/src/run-command.ts
 function parseRunArgs(args) {
 	const { values, positionals } = parseArgs({
@@ -8606,15 +8983,24 @@ async function runProjectCommand(args, cwd = process.cwd(), parsed = parseRunArg
 		return;
 	}
 	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, {
+	const reportDir = resolve(project.root, project.config.reportDir ?? "_evalkit-results");
+	const sandboxDir = resolve(project.root, project.config.sandboxDir ?? "_evalkit-sandbox");
+	const source = await detectSource(project.root, { outputDirs: [
+		reportDir,
+		sandboxDir,
+		resolve(project.root, "_evalkit-dashboard")
+	] });
+	if (!values.json) console.log(`Running ${cells} cell(s) from ${plan.matrix}` + (source ? ` at ${shortSource(source)}${source.ref ? ` (${source.ref})` : ""}` : " (untracked: not in a git repository)"));
+	if ((await Effect.runPromise(runnerLogs(runMatrix(matrix, {
 		selection,
 		concurrency: parsed.concurrency ?? project.config.execution?.concurrency ?? 4,
 		trials,
 		...suiteId ? { suiteId } : {},
 		...values.local ? { runtime: "local" } : {},
-		report: localReportStore(resolve(project.root, project.config.reportDir ?? "_evalkit-results")),
-		workspaceRoot: resolve(project.root, project.config.sandboxDir ?? "_evalkit-sandbox"),
+		...source ? { source } : {},
+		catalog: runCatalog(registry),
+		report: localReportStore(reportDir),
+		workspaceRoot: sandboxDir,
 		onResult: (cell, result) => {
 			if (values.json) console.log(JSON.stringify({
 				cell: {
@@ -8633,7 +9019,211 @@ async function runProjectCommand(args, cwd = process.cwd(), parsed = parseRunArg
 				}
 			}
 		}
-	}))).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/share-command.ts
+/**
+* Which local runs `evalkit share` uploads: finished runs with a source, at
+* HEAD (or any commit with `all`), not dirty (unless `allowDirty`), not archived.
+*/
+function selectRuns(runs, head, options) {
+	const result = {
+		selected: [],
+		untracked: 0,
+		otherCommits: 0,
+		dirty: 0,
+		archived: 0,
+		running: 0
+	};
+	for (const run of runs) {
+		const { source } = run;
+		if (!source) result.untracked += 1;
+		else if (!options.all && (source.commit !== head.commit || repoKey(source) !== repoKey(head))) result.otherCommits += 1;
+		else if (source.dirty && !options.allowDirty) result.dirty += 1;
+		else if (run.archived) result.archived += 1;
+		else if (run.status === "running") result.running += 1;
+		else result.selected.push({
+			...run,
+			source
+		});
+	}
+	return result;
+}
+/** One line for the Runs step: what will be shared and what was skipped. */
+function selectionSummary(selection, options) {
+	return [
+		`${plural(selection.selected.length, "run")} to share`,
+		selection.otherCommits && !options.all ? `${selection.otherCommits} from other commits` : "",
+		selection.running ? `${selection.running} still running skipped` : "",
+		selection.dirty ? `${selection.dirty} dirty skipped` : "",
+		selection.untracked ? `${selection.untracked} untracked skipped` : "",
+		selection.archived ? `${selection.archived} archived skipped` : ""
+	].filter(Boolean).join(" · ");
+}
+/** Why nothing was selected, and what to do about it. */
+function noRunsMessage(selection, head, options) {
+	const at = shortSource(head);
+	if (selection.dirty) return `No committed runs for ${at}: ${plural(selection.dirty, "run")} came from uncommitted changes. Commit and rerun \`evalkit run\`, or pass --allow-dirty.`;
+	if (selection.running) return `No finished runs for ${at}: ${plural(selection.running, "run")} still running. Share again when they finish.`;
+	return `No runs for ${at}. Run \`evalkit run\` first${options.all ? "" : ", or pass --all to share runs from other commits"}.`;
+}
+/** Where to look after sharing: the commit, or the repository if several commits were shared. */
+function shareTarget(serverUrl, head, runs) {
+	const commits = new Set(runs.map((run) => run.source.commit));
+	const commit = commits.size === 1 ? `/-/${[...commits][0]}` : "";
+	return new URL(`/${repoKey(head)}${commit}`, serverUrl).href;
+}
+/** Build one run's upload bundle: run.json, catalog.json, and its snapshot. */
+async function runBundle(options) {
+	const files = [];
+	const encode = (value) => new TextEncoder().encode(`${JSON.stringify(value)}\n`);
+	files.push({
+		path: "run.json",
+		data: encode(options.run)
+	});
+	const saved = await readFile(resolve(options.reportRoot, options.run.id, "catalog.json")).catch(() => void 0);
+	files.push({
+		path: "catalog.json",
+		data: saved ? new Uint8Array(saved) : encode(runCatalog(options.registry))
+	});
+	await snapshotRun(options.reports, options.run.id, {
+		async json(path, value) {
+			files.push({
+				path,
+				data: encode(value)
+			});
+		},
+		async bytes(path, data) {
+			files.push({
+				path,
+				data
+			});
+		}
+	}, { workspaceFiles: options.workspaceFiles });
+	return encodeBundle(files);
+}
+/** The server refused the bundle (4xx): retrying the same bundle cannot help. */
+var UploadRejected = class extends Error {};
+/** POST one bundle, retrying network errors and 5xx responses. */
+async function uploadBundle(serverUrl, bundle, options = {}) {
+	const attempts = options.attempts ?? 3;
+	let lastError;
+	for (let attempt = 1; attempt <= attempts; attempt++) {
+		try {
+			return await postBundle(serverUrl, bundle);
+		} catch (error) {
+			if (error instanceof UploadRejected) throw error;
+			lastError = error;
+		}
+		if (attempt < attempts) await Bun.sleep((options.delayMs ?? 500) * 2 ** (attempt - 1));
+	}
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`Upload failed: ${String(lastError)}`);
+}
+async function postBundle(serverUrl, bundle) {
+	const response = await fetch(new URL("/api/v1/uploads", serverUrl), {
+		method: "POST",
+		headers: { "content-type": "application/octet-stream" },
+		body: bundle
+	});
+	if (response.ok) return parseUploadResult(await response.json());
+	const reason = await response.text();
+	if (response.status < 500) throw new UploadRejected(`Share server rejected the upload: ${reason}`);
+	throw new Error(`Share server error ${response.status}: ${reason}`);
+}
+function parseUploadResult(value) {
+	const result = value;
+	if ((result?.status === "created" || result?.status === "exists") && typeof result.url === "string") return {
+		status: result.status,
+		url: result.url
+	};
+	throw new UploadRejected(`Unexpected share server response: ${JSON.stringify(value)}`);
+}
+async function shareRuns(options) {
+	const reports = createDashboardReportReader(options.reportRoot, options.registry);
+	return options.step("Uploading", async (progress) => {
+		const result = {
+			created: 0,
+			exists: 0,
+			failed: [],
+			bytes: 0
+		};
+		for (const [index, run] of options.runs.entries()) {
+			progress(`run ${index + 1}/${options.runs.length} · ${formatBytes(result.bytes)}`);
+			try {
+				const bundle = await runBundle({
+					reports,
+					reportRoot: options.reportRoot,
+					registry: options.registry,
+					run,
+					workspaceFiles: options.workspaceFiles
+				});
+				const uploaded = await uploadBundle(options.serverUrl, bundle);
+				result.bytes += bundle.byteLength;
+				result[uploaded.status] += 1;
+			} catch (error) {
+				result.failed.push({
+					runId: run.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		return result;
+	}, (result) => `${result.created} new · ${result.exists} already shared` + (result.failed.length ? ` · ${result.failed.length} failed` : "") + ` · ${formatBytes(result.bytes)}`);
+}
+function formatBytes(size) {
+	if (size < 1024) return `${size} B`;
+	if (size < 1024 ** 2) return `${(size / 1024).toFixed(1)} kB`;
+	return `${(size / 1024 ** 2).toFixed(1)} MB`;
 }
 //#endregion
 //#region ../cli/src/new-project-template.ts
@@ -8735,12 +9325,11 @@ Replace these examples with your own agent, tasks, and checks.
 
 \`\`\`sh
 bun install
-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 and launch runs
-bun run dashboard:build  # write a read-only, shareable snapshot
+bun run check                                   # type-check your eval, agent, scorer, and config
+bun run evalkit run                             # run the example across both styles
+bun run evalkit run --matrix styles --dry-run   # inspect the matrix without running it
+bun run evalkit dev                             # inspect local reports and launch runs
+bun run evalkit build                           # write a read-only, shareable snapshot
 \`\`\`
 
 EvalKit installs from npm. Reports, trial workspaces, and dashboard snapshots stay local
@@ -8750,12 +9339,13 @@ scores, evidence, and candidate files (never evaluator workspaces): review it be
 }
 //#endregion
 //#region ../cli/src/new-project.ts
-const npmDependency = "^0.2.0";
+const npmDependency = "^0.4.0";
 const ignored = [
 	"node_modules/",
 	"_evalkit-results/",
 	"_evalkit-sandbox/",
-	"_evalkit-dashboard/"
+	"_evalkit-dashboard/",
+	"_evalkit-share/"
 ];
 const readIfExists = async (path) => {
 	try {
@@ -8834,11 +9424,6 @@ 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 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";
@@ -8867,6 +9452,7 @@ async function writeStarterReadme(root, name, inPlace) {
 }
 //#endregion
 //#region ../cli/src/index.ts
+const VERSION = "0.4.0";
 let projectRoot = process.cwd();
 let reportRoot = resolve(projectRoot, "_evalkit-results");
 const sandboxRoot = resolve(projectRoot, "_evalkit-sandbox");
@@ -8886,13 +9472,31 @@ 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 }));
+	const provenance = await runProvenance(registry);
+	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,
+			...provenance
+		})), Effect.tap((result) => runLog.finished(name, {}, result, performance.now() - started)), Effect.tapError((error) => Effect.sync(() => runLog.failed(name, error))));
+	}), { concurrency: options.concurrency })));
+}
+/** Detected per launch: `evalkit dev` keeps running while commits change. */
+async function runProvenance(registry) {
+	const source = await detectSource(projectRoot, { outputDirs: [
+		reportRoot,
+		sandboxRoot,
+		resolve(projectRoot, "_evalkit-dashboard")
+	] });
+	return {
+		...source ? { source } : {},
+		catalog: runCatalog(registry)
+	};
 }
 function registerMatrixRoutes(app, registry, dashboardMatrix, trials) {
 	let matrixRunning = false;
@@ -8935,14 +9539,19 @@ 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);
+			runProvenance(registry).then((provenance) => 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,
+				...provenance,
+				onResult: (cell, result) => runLog.cell(cell, result, performance.now() - started)
+			})))).catch((error) => runLog.failed(name, error)).finally(() => {
 				matrixRunning = false;
 			});
 		} else {
@@ -8951,7 +9560,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);
 	});
@@ -8963,7 +9572,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);
 	});
 }
@@ -9047,14 +9656,32 @@ async function serveDashboard() {
 	const registry = await loadRegistry();
 	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 {
@@ -9119,7 +9746,7 @@ const runCommand = make$1("run", {
 const newCommand = make$1("new", { directory: text$2({ name: "directory" }) }, ({ directory }) => Effect.tryPromise({
 	try: async () => {
 		const root = await newProject([directory]);
-		console.log(`Created EvalKit project at ${root}\nRun cd ${root} && bun install && bun run evals.`);
+		console.log(`Created EvalKit project at ${root}\nRun cd ${root} && bun install && bun run evalkit run.`);
 	},
 	catch: (error) => error
 }));
@@ -9132,29 +9759,162 @@ const devCommand = make$1("dev", { config }, ({ config }) => Effect.tryPromise({
 }));
 const buildCommand = make$1("build", {
 	config,
-	out: text("out").pipe(optional)
-}, ({ config, out }) => Effect.tryPromise({
+	out: text("out").pipe(optional),
+	run: boolean("run"),
+	noRun: boolean("no-run")
+}, ({ config, out, run, noRun }) => Effect.tryPromise({
 	try: async () => {
-		await useProject(Option.getOrUndefined(config));
+		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 shareServeCommand = make$1("serve", {
+	dir: text("dir").pipe(withDefault("_evalkit-share")),
+	port: integer("port").pipe(withDefault(4318))
+}, ({ dir, port }) => Effect.tryPromise({
+	try: async () => {
+		const root = resolve(process.cwd(), dir);
+		const app = await createDirectoryShareApp({
+			dir: root,
+			dashboardRoot: dashboardAssets()
 		});
-		console.log(`Built a read-only dashboard snapshot at ${result.outDir}\n  ${result.runs} run(s), ${result.trials} trial(s), ${result.files} candidate file(s)\nServe it with any static file server. It contains report messages, scores, evidence,
-and candidate files (never evaluator workspaces): review it before sharing.`);
+		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. Choose another: evalkit share serve --port 4319`);
+			throw error;
+		}
+		banner("share serve", VERSION);
+		console.log(`  ${cyan("➜")}  ${bold("Local:".padEnd(9))}${cyan(`http://localhost:${server.port}`)}`);
+		console.log(`  ${cyan("➜")}  ${bold("Storage:".padEnd(9))}${relative(process.cwd(), root) || "."}`);
+		console.log(`\n  ${dim(`Upload with share.url = "http://localhost:${server.port}". No authentication: keep it private.`)}\n`);
 	},
 	catch: (error) => error
 }));
+const shareCommand = make$1("share", {
+	config,
+	all: boolean("all"),
+	allowDirty: boolean("allow-dirty"),
+	noWorkspace: boolean("no-workspace")
+}, ({ config, all, allowDirty, noWorkspace }) => Effect.tryPromise({
+	try: async () => {
+		const started = performance.now();
+		banner("share", VERSION);
+		await loadProjectStep(Option.getOrUndefined(config));
+		const serverUrl = process.env.EVALKIT_SHARE_URL ?? project.config.share?.url;
+		if (!serverUrl) throw new Error("No share server configured. Set share: { url } in evalkit.config.ts or EVALKIT_SHARE_URL.");
+		const head = await step("Source", () => detectSource(projectRoot, { outputDirs: [
+			reportRoot,
+			sandboxRoot,
+			resolve(projectRoot, "_evalkit-dashboard")
+		] }), (source) => source ? `${repoKey(source)} @ ${shortSource(source)}${source.ref ? ` (${source.ref})` : ""}` : "not a git repository");
+		if (!head) throw new Error("evalkit share needs to know the commit: run it inside a git repository or set EVALKIT_SOURCE_REPO and EVALKIT_SOURCE_COMMIT. `evalkit build` works without one.");
+		const registry = project.registry;
+		const selection = await step("Runs", async () => selectRuns(await createDashboardReportReader(reportRoot, registry).listRuns(), head, {
+			all,
+			allowDirty
+		}), (value) => selectionSummary(value, { all }));
+		if (!selection.selected.length) throw new Error(noRunsMessage(selection, head, { all }));
+		const result = await shareRuns({
+			serverUrl,
+			reportRoot,
+			registry,
+			runs: selection.selected,
+			workspaceFiles: !noWorkspace,
+			step
+		});
+		for (const failure of result.failed) console.log(`  ${yellow("✗")} ${failure.runId.slice(0, 8)} ${dim(failure.error)}`);
+		const target = shareTarget(serverUrl, head, selection.selected);
+		console.log(`\n  ${bold(result.failed.length ? "Shared with errors" : "Shared")} in ${duration(performance.now() - started)}\n`);
+		console.log(`  ${cyan("➜")}  ${cyan(target)}\n`);
+		if (result.failed.length) process.exitCode = 1;
+	},
+	catch: (error) => error
+})).pipe(withSubcommands([shareServeCommand]));
 const cli = run(make$1("evalkit").pipe(withSubcommands([
 	newCommand,
 	runCommand,
 	devCommand,
-	buildCommand
+	buildCommand,
+	tidyCommand,
+	shareCommand
 ])), {
 	name: "EvalKit",
-	version: "0.2.0"
+	version: VERSION
 });
 const argv = process.argv.slice();
 if (argv[2] === "help") argv.splice(2, 1, "--help");