@leostera/evalkit 0.1.0 → 0.2.0

package/README.md

@@ -21,6 +21,7 @@ bun run check        # type-check the project
 bun run evals         # both configured styles
 bun run matrix:plan  # inspect the matrix without executing it
 bun run dashboard     # in a second terminal
+bun run dashboard:build  # optional read-only snapshot to share
 ```
 
 Already have a Bun project? From its root you can instead run:

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import { F as defineEvalMatrix, I as canonicalParameters, m as registerEvals, n
 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 { 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";
@@ -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,63 +8048,6 @@ 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;
 function isMissing(error) {
@@ -8259,6 +8202,147 @@ 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";
+/**
+* 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 { 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 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`);
+	};
+	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;
+	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;
+			}
+		}
+	}
+	return {
+		outDir,
+		runs: runs.length,
+		trials,
+		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;
+}
+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) {
@@ -8388,6 +8472,8 @@ function parseRunArgs(args) {
 				type: "string",
 				multiple: true
 			},
+			suite: { type: "string" },
+			matrix: { type: "string" },
 			model: {
 				type: "string",
 				multiple: true
@@ -8454,6 +8540,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 +8551,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 +8559,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 +8571,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 +8588,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");
@@ -8653,21 +8739,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.2.0";
 const ignored = [
 	"node_modules/",
 	"_evalkit-results/",
-	"_evalkit-sandbox/"
+	"_evalkit-sandbox/",
+	"_evalkit-dashboard/"
 ];
 const readIfExists = async (path) => {
 	try {
@@ -8746,10 +8834,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";
@@ -8942,10 +9031,21 @@ 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);
 	registerReportRoutes(app, registry, createDashboardReportReader(reportRoot, registry));
@@ -8969,6 +9069,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 +9091,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 +9108,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 +9123,38 @@ 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)
+}, ({ config, out }) => Effect.tryPromise({
+	try: async () => {
+		await useProject(Option.getOrUndefined(config));
+		const result = await buildDashboard({
+			registry: project.registry,
+			reportRoot,
+			dashboardRoot: dashboardAssets(),
+			outDir: resolve(projectRoot, Option.getOrElse(out, () => "_evalkit-dashboard"))
+		});
+		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.`);
+	},
+	catch: (error) => error
+}));
 const cli = run(make$1("evalkit").pipe(withSubcommands([
 	newCommand,
-	evalsCommand,
-	matrixCommand,
-	suiteCommand,
-	dashboardCommand
+	runCommand,
+	devCommand,
+	buildCommand
 ])), {
 	name: "EvalKit",
-	version: "0.1.0"
+	version: "0.2.0"
 });
 const argv = process.argv.slice();
 if (argv[2] === "help") argv.splice(2, 1, "--help");