vieval 0.0.6 → 0.0.7

package/dist/{cli-sanbKtQq.mjs → cli-ImxGpoYQ.mjs}

@@ -1,4 +1,4 @@
-import { c as loadRawVievalConfig, l as loadVievalCliConfig, n as consumeModuleRegistrations, o as detectCliConfigMode, r as endModuleRegistration, t as beginModuleRegistration } from "./registry-CcKZqDJY.mjs";
+import { a as createOpenTelemetryRuntime, c as detectCliConfigMode, d as loadVievalCliConfig, n as consumeModuleRegistrations, o as createNoopTelemetryRuntime, r as endModuleRegistration, t as beginModuleRegistration, u as loadRawVievalConfig } from "./registry-BHGMxjpA.mjs";
 import { createSchedulerRuntime } from "./core/scheduler/index.mjs";
 import { RunnerExecutionError, collectEvalEntries, createFilesystemTaskCacheRuntime, createRunnerRuntimeContext, createRunnerSchedule, createTaskExecutionContext, runScheduledTasks } from "./core/runner/index.mjs";
 import process from "node:process";
@@ -264,6 +264,612 @@ async function loadEvalModulesWithVitestRuntime(evalFilePaths, projectRoot) {
 	return loadedModules;
 }
 //#endregion
+//#region src/cli/report-selectors.ts
+/**
+* Resolves a generic case selector from metrics, scores, then direct fields.
+*
+* Use when:
+* - report commands accept benchmark-neutral selectors such as `benchmark.case.id`
+* - comparisons need the same lookup semantics as filtering and grouping
+*
+* Expects:
+* - `key` is a direct `CaseRecord` field, score key, `scores.<key>`, or metric key
+*
+* Returns:
+* - existence flag plus matched value when present
+*/
+function getCaseSelectorValue(record, key) {
+	if (Object.hasOwn(record.metrics, key)) return {
+		exists: true,
+		value: record.metrics[key]
+	};
+	if (key.startsWith("scores.") && Object.hasOwn(record.scores, key.slice(7))) return {
+		exists: true,
+		value: record.scores[key.slice(7)]
+	};
+	if (Object.hasOwn(record.scores, key)) return {
+		exists: true,
+		value: record.scores[key]
+	};
+	if (Object.hasOwn(record, key)) return {
+		exists: true,
+		value: record[key]
+	};
+	return { exists: false };
+}
+/**
+* Stable-stringifies JSON-like values for report comparisons.
+*
+* Before:
+* - `{ b: 1, a: true }`
+*
+* After:
+* - `{"a":true,"b":1}`
+*/
+function stableStringify(value) {
+	if (value == null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).sort((left, right) => left.localeCompare(right)).map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+//#endregion
+//#region src/cli/report-otlp.ts
+/**
+* Builds local OTLP-shaped JSON projections from normalized case records.
+*
+* Use when:
+* - writing deterministic report artifacts without requiring an OpenTelemetry Collector
+* - future tools need trace/log/metric-shaped JSON files
+*
+* Expects:
+* - records belong to one Vieval run
+*
+* Returns:
+* - trace, log, and metric containers shaped after OTLP JSON concepts
+*/
+function buildLocalOtlpProjection(args) {
+	const projectSpans = collectProjectNames(args.records).map((projectName) => ({
+		attributes: toAttributes({
+			"vieval.project.name": projectName,
+			"vieval.run.id": args.runId
+		}),
+		name: "vieval.project"
+	}));
+	const taskSpans = collectTasks(args.records).map((task) => ({
+		attributes: toAttributes({
+			"vieval.project.name": task.projectName,
+			"vieval.run.id": args.runId,
+			"vieval.task.id": task.taskId
+		}),
+		name: "vieval.task"
+	}));
+	const caseSpans = args.records.map((record) => ({
+		attributes: toAttributes({
+			...record.metrics,
+			"vieval.case.duration_ms": record.durationMs,
+			"vieval.case.id": record.caseId,
+			"vieval.case.name": record.caseName,
+			"vieval.case.retry_count": record.retryCount,
+			"vieval.case.state": record.state,
+			"vieval.project.name": record.projectName,
+			"vieval.task.id": record.taskId
+		}),
+		endTimeUnixNano: isoToUnixNano(record.endedAt),
+		name: "vieval.case",
+		startTimeUnixNano: isoToUnixNano(record.startedAt)
+	}));
+	return {
+		logs: { resourceLogs: [{ scopeLogs: [{
+			logRecords: args.records.map((record) => ({
+				attributes: toAttributes(record.metrics),
+				body: { stringValue: JSON.stringify({
+					caseId: record.caseId,
+					scores: record.scores,
+					state: record.state
+				}) },
+				eventName: "vieval.case",
+				timeUnixNano: isoToUnixNano(record.endedAt)
+			})),
+			scope: { name: "vieval" }
+		}] }] },
+		metrics: { resourceMetrics: [{ scopeMetrics: [{
+			metrics: collectScoreKinds(args.records).map((kind) => ({
+				gauge: { dataPoints: args.records.filter((record) => typeof record.scores[kind] === "number").map((record) => ({
+					asDouble: record.scores[kind],
+					attributes: toAttributes({
+						...record.metrics,
+						"vieval.case.id": record.caseId,
+						"vieval.task.id": record.taskId
+					}),
+					timeUnixNano: isoToUnixNano(record.endedAt)
+				})) },
+				name: `vieval.score.${kind}`
+			})),
+			scope: { name: "vieval" }
+		}] }] },
+		traces: { resourceSpans: [{ scopeSpans: [{
+			scope: { name: "vieval" },
+			spans: [
+				{
+					attributes: toAttributes({ "vieval.run.id": args.runId }),
+					name: "vieval.run"
+				},
+				...projectSpans,
+				...taskSpans,
+				...caseSpans
+			]
+		}] }] }
+	};
+}
+function toAttributes(attributes) {
+	return Object.entries(attributes).filter(([, value]) => value !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, value]) => ({
+		key,
+		value: toAnyValue(value)
+	}));
+}
+function toAnyValue(value) {
+	if (Array.isArray(value)) return { arrayValue: { values: value.map((item) => toAnyValue(item)) } };
+	if (isAttributeScalar(value)) {
+		if (typeof value === "boolean") return { boolValue: value };
+		if (typeof value === "number") return Number.isFinite(value) ? { doubleValue: value } : { stringValue: String(value) };
+		if (value == null) return { stringValue: "null" };
+		return { stringValue: value };
+	}
+	return { stringValue: stableStringify(value) };
+}
+function isAttributeScalar(value) {
+	return value == null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+}
+function isoToUnixNano(value) {
+	const preciseMatch = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+	if (preciseMatch != null) {
+		const [, secondsPart, fraction = "", zone] = preciseMatch;
+		const unixMilliseconds = Date.parse(`${secondsPart}.000${zone}`);
+		if (!Number.isFinite(unixMilliseconds)) return "0";
+		return String(BigInt(unixMilliseconds) * 1000000n + BigInt(fraction.padEnd(9, "0").slice(0, 9)));
+	}
+	const unixMilliseconds = Date.parse(value);
+	if (!Number.isFinite(unixMilliseconds)) return "0";
+	return String(BigInt(unixMilliseconds) * 1000000n);
+}
+function collectScoreKinds(records) {
+	return [...new Set(records.flatMap((record) => Object.keys(record.scores)))].sort((left, right) => left.localeCompare(right));
+}
+function collectProjectNames(records) {
+	return [...new Set(records.map((record) => record.projectName))].sort((left, right) => left.localeCompare(right));
+}
+function collectTasks(records) {
+	const tasks = /* @__PURE__ */ new Map();
+	for (const record of records) tasks.set(`${record.projectName}\0${record.taskId}`, {
+		projectName: record.projectName,
+		taskId: record.taskId
+	});
+	return [...tasks.values()].sort((left, right) => {
+		const projectOrder = left.projectName.localeCompare(right.projectName);
+		return projectOrder === 0 ? left.taskId.localeCompare(right.taskId) : projectOrder;
+	});
+}
+//#endregion
+//#region src/cli/report-records.ts
+/**
+* Builds normalized case records from lifecycle, metric, and score events.
+*
+* Use when:
+* - `events.jsonl` should be projected into `cases.jsonl`
+* - report commands need one final record per observed case outcome
+*
+* Expects:
+* - events are ordered by occurrence where possible
+* - lifecycle events use either `task.case.start`/`task.case.end` or current CLI `CaseStarted`/`CaseEnded` names
+*
+* Returns:
+* - records for cases that emitted an end lifecycle event
+*/
+function buildCaseRecords(args) {
+	const drafts = /* @__PURE__ */ new Map();
+	const completedKeys = [];
+	for (const event of args.events) {
+		const normalizedEvent = normalizeCaseEventName(event.event);
+		if (normalizedEvent == null) continue;
+		const ids = extractEventIds(event, args);
+		if (ids.caseId.length === 0 || ids.taskId.length === 0) continue;
+		const draft = getOrCreateDraft(drafts, ids, event, args);
+		applyIdentity(draft, ids, event, args);
+		if (normalizedEvent === "start") applyCaseStart(draft, event);
+		else if (normalizedEvent === "metric") applyCaseMetric(draft, event);
+		else if (normalizedEvent === "score") applyCaseScore(draft, event);
+		else {
+			applyCaseEnd(draft, event);
+			const key = createCaseKey(ids.taskId, ids.caseId);
+			if (!completedKeys.includes(key)) completedKeys.push(key);
+		}
+	}
+	return completedKeys.map((key) => drafts.get(key)).filter((draft) => draft != null && draft.endedAt != null).map(toCaseRecord);
+}
+/**
+* Builds generic score summaries overall and grouped by arbitrary keys.
+*
+* Use when:
+* - report artifacts need benchmark-neutral aggregate score views
+* - callers want to group by metrics such as `benchmark.category` or direct record fields such as `taskId`
+*
+* Expects:
+* - `groupByKeys` are stable metric names or direct `CaseRecord` field names
+* - record score values are normalized numeric scores
+*
+* Returns:
+* - overall score buckets and group buckets keyed by `<key>=<value>`
+*/
+function buildMetricsSummary(records, groupByKeys) {
+	const overall = {};
+	const groups = {};
+	for (const record of records) {
+		addRecordScores(overall, record);
+		for (const groupByKey of groupByKeys) {
+			const groupValue = getGroupValue(record, groupByKey);
+			if (!groupValue.exists) continue;
+			const groupKey = `${groupByKey}=${String(groupValue.value)}`;
+			groups[groupKey] ??= {};
+			addRecordScores(groups[groupKey], record);
+		}
+	}
+	return {
+		groups: finalizeSummaryGroups(groups),
+		overall: finalizeScoreSummary(overall)
+	};
+}
+/**
+* Encodes records as newline-delimited JSON.
+*
+* Use when:
+* - writing `cases.jsonl` for command-line tools, dataframes, or streaming parsers
+* - each record should occupy exactly one JSON line
+*
+* Expects:
+* - records are JSON-serializable case records
+*
+* Returns:
+* - one JSON object per line with a trailing newline for non-empty input
+*/
+function encodeJsonl(records) {
+	if (records.length === 0) return "";
+	return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`;
+}
+function normalizeCaseEventName(eventName) {
+	if (eventName === "task.case.start" || eventName === "CaseStarted") return "start";
+	if (eventName === "task.case.metric") return "metric";
+	if (eventName === "task.case.score") return "score";
+	if (eventName === "task.case.end" || eventName === "CaseEnded") return "end";
+}
+function extractEventIds(event, args) {
+	const data = asRecord(event.data);
+	return {
+		attemptId: stringFrom(data?.attemptId) ?? event.attemptId ?? args.attemptId,
+		caseId: stringFrom(data?.caseId) ?? event.caseId ?? "",
+		experimentId: stringFrom(data?.experimentId) ?? event.experimentId ?? args.experimentId,
+		projectName: stringFrom(data?.projectName) ?? event.projectName ?? event.projectId ?? args.projectName,
+		runId: stringFrom(data?.runId) ?? event.runId ?? args.runId,
+		taskId: stringFrom(data?.taskId) ?? event.taskId ?? "",
+		workspaceId: stringFrom(data?.workspaceId) ?? event.workspaceId ?? args.workspaceId
+	};
+}
+function getOrCreateDraft(drafts, ids, event, args) {
+	const key = createCaseKey(ids.taskId, ids.caseId);
+	const existing = drafts.get(key);
+	if (existing != null) return existing;
+	const draft = {
+		attemptId: ids.attemptId,
+		caseId: ids.caseId,
+		caseName: extractCaseName(event) ?? ids.caseId,
+		experimentId: ids.experimentId,
+		metrics: {},
+		projectName: ids.projectName || args.projectName,
+		retryCount: 0,
+		runId: ids.runId,
+		scores: {},
+		startCount: 0,
+		taskId: ids.taskId,
+		workspaceId: ids.workspaceId
+	};
+	drafts.set(key, draft);
+	return draft;
+}
+function applyIdentity(draft, ids, event, args) {
+	draft.attemptId = ids.attemptId || args.attemptId;
+	draft.experimentId = ids.experimentId || args.experimentId;
+	draft.projectName = extractExplicitProjectName(event) ?? draft.projectName;
+	draft.runId = ids.runId || args.runId;
+	draft.workspaceId = ids.workspaceId || args.workspaceId;
+}
+function applyCaseStart(draft, event) {
+	const data = asRecord(event.data);
+	draft.startCount += 1;
+	draft.caseName = extractCaseName(event) ?? draft.caseName;
+	draft.startedAt ??= stringFrom(data?.startedAt) ?? event.timestamp;
+	draft.endedAt = void 0;
+	draft.input = void 0;
+	draft.metrics = {};
+	draft.output = void 0;
+	draft.scores = {};
+	draft.state = void 0;
+	draft.input = data != null && "input" in data ? data.input : draft.input;
+	const retryIndex = numberFrom(data?.retryIndex);
+	if (retryIndex != null) {
+		draft.retryCount = Math.max(draft.retryCount, retryIndex);
+		return;
+	}
+	draft.retryCount = Math.max(draft.retryCount, draft.startCount - 1);
+}
+function applyCaseMetric(draft, event) {
+	const data = asRecord(event.data);
+	const name = stringFrom(data?.name);
+	if (name == null) return;
+	const value = data?.value;
+	if (isCaseMetricValue(value)) draft.metrics[name] = value;
+}
+function applyCaseScore(draft, event) {
+	const data = asRecord(event.data);
+	const kind = stringFrom(data?.kind) ?? stringFrom(data?.name) ?? stringFrom(data?.["vieval.score.kind"]);
+	const score = numberFrom(data?.score) ?? numberFrom(data?.value) ?? numberFrom(data?.["vieval.score.value"]);
+	if (kind == null || score == null) return;
+	draft.scores[kind] = score;
+}
+function applyCaseEnd(draft, event) {
+	const data = asRecord(event.data);
+	draft.caseName = extractCaseName(event) ?? draft.caseName;
+	draft.endedAt = stringFrom(data?.endedAt) ?? event.timestamp ?? draft.endedAt;
+	draft.output = data != null && "output" in data ? data.output : draft.output;
+	draft.state = normalizeState(stringFrom(data?.state)) ?? "failed";
+	draft.scores.exact ??= draft.state === "passed" ? 1 : 0;
+}
+function toCaseRecord(draft) {
+	const startedAt = draft.startedAt ?? draft.endedAt ?? "";
+	const endedAt = draft.endedAt ?? startedAt;
+	return {
+		attemptId: draft.attemptId,
+		caseId: draft.caseId,
+		caseName: draft.caseName,
+		durationMs: calculateDurationMs(startedAt, endedAt),
+		endedAt,
+		experimentId: draft.experimentId,
+		...draft.input === void 0 ? {} : { input: draft.input },
+		metrics: draft.metrics,
+		...draft.output === void 0 ? {} : { output: draft.output },
+		projectName: draft.projectName,
+		retryCount: draft.retryCount,
+		runId: draft.runId,
+		schemaVersion: 1,
+		scores: draft.scores,
+		startedAt,
+		state: draft.state ?? "failed",
+		taskId: draft.taskId,
+		workspaceId: draft.workspaceId
+	};
+}
+function addRecordScores(summary, record) {
+	for (const [kind, score] of Object.entries(record.scores)) {
+		if (!Number.isFinite(score)) continue;
+		summary[kind] ??= {
+			average: 0,
+			count: 0,
+			sum: 0
+		};
+		summary[kind].count += 1;
+		summary[kind].sum += score;
+	}
+}
+function finalizeSummaryGroups(groups) {
+	return Object.fromEntries(Object.entries(groups).map(([key, summary]) => [key, finalizeScoreSummary(summary)]));
+}
+function finalizeScoreSummary(summary) {
+	return Object.fromEntries(Object.entries(summary).map(([kind, bucket]) => [kind, {
+		average: bucket.count === 0 ? 0 : bucket.sum / bucket.count,
+		count: bucket.count,
+		sum: bucket.sum
+	}]));
+}
+function getGroupValue(record, key) {
+	if (Object.hasOwn(record.metrics, key)) return {
+		exists: true,
+		value: record.metrics[key]
+	};
+	const directValue = record[key];
+	return isCaseMetricValue(directValue) ? {
+		exists: true,
+		value: directValue
+	} : { exists: false };
+}
+function extractCaseName(event) {
+	const data = asRecord(event.data);
+	return stringFrom(data?.caseName) ?? stringFrom(data?.name);
+}
+function extractExplicitProjectName(event) {
+	return stringFrom(asRecord(event.data)?.projectName) ?? event.projectName ?? event.projectId;
+}
+function createCaseKey(taskId, caseId) {
+	return `${taskId}\u0000${caseId}`;
+}
+/**
+* Normalizes duration timestamps.
+*
+* Before:
+* - `startedAt="2026-05-08T00:00:00.000Z"`, `endedAt="2026-05-08T00:00:01.250Z"`
+* - `startedAt="bad"`, `endedAt="2026-05-08T00:00:01.250Z"`
+*
+* After:
+* - `1250`
+* - `0`
+*/
+function calculateDurationMs(startedAt, endedAt) {
+	const started = Date.parse(startedAt);
+	const ended = Date.parse(endedAt);
+	if (!Number.isFinite(started) || !Number.isFinite(ended)) return 0;
+	return Math.max(0, ended - started);
+}
+function normalizeState(value) {
+	if (value === "failed" || value === "passed" || value === "skipped" || value === "timeout") return value;
+}
+function isCaseMetricValue(value) {
+	if (value == null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") return true;
+	return Array.isArray(value);
+}
+function asRecord(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function stringFrom(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function numberFrom(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+//#endregion
+//#region src/cli/report-artifacts.ts
+/**
+* Resolves one or more `run-summary.json` paths from a report location.
+*
+* Use when:
+* - callers may pass a run directory, summary file path, or a report root
+*
+* Returns:
+* - sorted absolute summary file paths
+*/
+async function resolveRunSummaryPaths(reportPath) {
+	const absoluteReportPath = resolve(reportPath);
+	const directSummaryPath = resolve(absoluteReportPath, "run-summary.json");
+	if (existsSync(absoluteReportPath) && absoluteReportPath.endsWith(".json")) return [absoluteReportPath];
+	if (existsSync(directSummaryPath)) return [directSummaryPath];
+	return (await glob("**/run-summary.json", {
+		absolute: true,
+		cwd: absoluteReportPath
+	})).sort((left, right) => left.localeCompare(right));
+}
+/**
+* Reads one run report artifact set from `run-summary.json` and sibling `events.jsonl`.
+*
+* Use when:
+* - report analysis needs both run aggregate output and event count metadata
+*/
+function readReportRunArtifact(summaryFilePath) {
+	const reportDirectory = resolve(summaryFilePath, "..");
+	const summary = JSON.parse(readFileSync(summaryFilePath, "utf-8"));
+	const eventsFilePath = resolve(reportDirectory, "events.jsonl");
+	const events = existsSync(eventsFilePath) ? readFileSync(eventsFilePath, "utf-8").split("\n").filter((line) => line.trim().length > 0).map((line) => {
+		const event = JSON.parse(line);
+		return {
+			attemptId: event.attemptId,
+			caseId: event.caseId,
+			data: event.data,
+			event: event.event,
+			experimentId: event.experimentId,
+			projectId: event.projectId,
+			projectName: event.projectName,
+			runId: event.runId,
+			taskId: event.taskId,
+			timestamp: event.timestamp,
+			workspaceId: event.workspaceId
+		};
+	}) : [];
+	return {
+		events,
+		eventsCount: events.length,
+		reportDirectory,
+		summary,
+		summaryFilePath
+	};
+}
+/**
+* Reads all run artifacts found under `reportPath`.
+*
+* Use when:
+* - callers need multi-run analysis from a directory root
+*/
+async function readReportArtifacts(reportPath) {
+	return (await resolveRunSummaryPaths(reportPath)).map((summaryFilePath) => readReportRunArtifact(summaryFilePath));
+}
+/**
+* Creates a compact summary row for one run artifact.
+*
+* Use when:
+* - table/csv/jsonl exports should stay stable and cheap to parse
+*/
+function summarizeReportRunArtifact(artifact) {
+	const totalProjects = artifact.summary.projects.length;
+	const failedProjects = artifact.summary.projects.filter((project) => project.errorMessage != null).length;
+	const executedProjects = artifact.summary.projects.filter((project) => project.executed).length;
+	const totalTasks = artifact.summary.projects.reduce((sum, project) => sum + project.taskCount, 0);
+	const projectNames = artifact.summary.projects.map((project) => project.name);
+	return {
+		attemptId: artifact.summary.attemptId ?? null,
+		eventsCount: artifact.eventsCount,
+		executedProjects,
+		experimentId: artifact.summary.experimentId ?? null,
+		failedProjects,
+		projectNames,
+		reportDirectory: artifact.reportDirectory,
+		runId: artifact.summary.runId ?? null,
+		totalProjects,
+		totalTasks,
+		workspaceId: artifact.summary.workspaceId ?? null
+	};
+}
+/**
+* Writes one complete local run report artifact set.
+*
+* Use when:
+* - CLI runs need deterministic local artifacts under workspace/project/experiment/attempt/run
+* - report commands need normalized case, metrics, and OTLP-shaped files
+*
+* Expects:
+* - `events` are the same envelopes written to `events.jsonl`
+* - `output` already contains run identity fields
+*
+* Returns:
+* - absolute report directory path containing the written artifacts
+*/
+async function writeRunReportArtifacts(output, events, identity, reportOut) {
+	const projectId = deriveReportProjectId(output);
+	const reportDirectory = resolve(reportOut, identity.workspaceId, projectId, identity.experimentId, identity.attemptId, identity.runId);
+	const persistedOutput = {
+		...output,
+		reportDirectory
+	};
+	await mkdir(reportDirectory, { recursive: true });
+	await writeFile(resolve(reportDirectory, "run-summary.json"), `${JSON.stringify(persistedOutput, null, 2)}\n`, "utf-8");
+	await writeFile(resolve(reportDirectory, "events.jsonl"), events.map((event) => JSON.stringify(event)).join("\n").concat(events.length > 0 ? "\n" : ""), "utf-8");
+	const caseRecords = buildCaseRecords({
+		attemptId: identity.attemptId,
+		events,
+		experimentId: identity.experimentId,
+		projectName: projectId,
+		runId: identity.runId,
+		workspaceId: identity.workspaceId
+	});
+	const metricsSummary = buildMetricsSummary(caseRecords, []);
+	const otlp = buildLocalOtlpProjection({
+		records: caseRecords,
+		runId: identity.runId
+	});
+	await writeFile(resolve(reportDirectory, "cases.jsonl"), encodeJsonl(caseRecords), "utf-8");
+	await writeFile(resolve(reportDirectory, "metrics-summary.json"), `${JSON.stringify(metricsSummary, null, 2)}\n`, "utf-8");
+	await mkdir(resolve(reportDirectory, "otlp"), { recursive: true });
+	await mkdir(resolve(reportDirectory, "benchmark"), { recursive: true });
+	await writeFile(resolve(reportDirectory, "otlp", "traces.json"), `${JSON.stringify(otlp.traces, null, 2)}\n`, "utf-8");
+	await writeFile(resolve(reportDirectory, "otlp", "logs.json"), `${JSON.stringify(otlp.logs, null, 2)}\n`, "utf-8");
+	await writeFile(resolve(reportDirectory, "otlp", "metrics.json"), `${JSON.stringify(otlp.metrics, null, 2)}\n`, "utf-8");
+	return reportDirectory;
+}
+function deriveReportProjectId(output) {
+	const uniqueProjectNames = [...new Set(output.projects.map((project) => project.name))];
+	if (uniqueProjectNames.length === 1) return sanitizeIdentitySegment$1(uniqueProjectNames[0] ?? "default-project");
+	return "multi-project";
+}
+function sanitizeIdentitySegment$1(value) {
+	const normalized = value.trim();
+	if (normalized.length === 0) return "default";
+	return normalized.replace(/[^\w.-]+/g, "-");
+}
+//#endregion
 //#region src/cli/reporters/noop-reporter.ts
 /**
 * Creates a reporter that intentionally does nothing.
@@ -1273,6 +1879,10 @@ function formatDuration$1(durationMs, colors) {
 	const rounded = Math.round(durationMs);
 	return (rounded > 1e3 ? colors.yellow : colors.green)(` ${rounded}${colors.dim("ms")}`);
 }
+function formatHybridAverage(hybridAverage) {
+	if (hybridAverage == null) return "n/a";
+	return hybridAverage.toFixed(3).replace(/\.?0+$/, "");
+}
 function filterProjectsByName(projects, names) {
 	if (names.length === 0) return [...projects];
 	const nameSet = new Set(names);
@@ -1293,11 +1903,6 @@ function createRunIdentity(options) {
 		workspaceId
 	};
 }
-function deriveReportProjectId(output) {
-	const uniqueProjectNames = [...new Set(output.projects.map((project) => project.name))];
-	if (uniqueProjectNames.length === 1) return sanitizeIdentitySegment(uniqueProjectNames[0] ?? "default-project");
-	return "multi-project";
-}
 function createEventRecorder(identity) {
 	const events = [];
 	const taskProjectMap = /* @__PURE__ */ new Map();
@@ -1520,6 +2125,7 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 			reporter.onCaseEnd({
 				caseId,
 				errorMessage: payload.errorMessage,
+				output: payload.output,
 				state: payload.state,
 				taskId: task.id
 			});
@@ -1536,6 +2142,7 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 			reporter.onCaseStart({
 				autoRetry: payload.autoRetry,
 				caseId,
+				input: payload.input,
 				caseName: payload.name,
 				retryIndex: payload.retryIndex,
 				taskId: task.id
@@ -1554,7 +2161,7 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 		}
 	};
 }
-function createCliTaskExecutionContext(task, models, cacheRootDirectory, cacheProjectName, workspaceId, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, runtimeConcurrency, vitestCompatReporter) {
+function createCliTaskExecutionContext(task, models, cacheRootDirectory, cacheProjectName, workspaceId, telemetry, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, runtimeConcurrency, vitestCompatReporter) {
 	return {
 		...createTaskExecutionContext({
 			cache: createFilesystemTaskCacheRuntime({
@@ -1566,7 +2173,8 @@ function createCliTaskExecutionContext(task, models, cacheRootDirectory, cachePr
 			task
 		}),
 		reporterHooks: createTaskReporterHooks(task, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter),
-		runtimeConcurrency
+		runtimeConcurrency,
+		telemetry
 	};
 }
 function resolveTaskReporterHooks(task, context, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter) {
@@ -1584,7 +2192,8 @@ function createAutoTaskExecutor(reporter, projectName, recordEvent, projectCaseC
 			cache: context.cache,
 			model: context.model,
 			reporterHooks: resolveTaskReporterHooks(task, context, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter),
-			task
+			task,
+			telemetry: context.telemetry
 		});
 		return {
 			entryId: task.entry.id,
@@ -1687,7 +2296,7 @@ async function prepareProject(project) {
 		};
 	}
 }
-async function executePreparedProject(prepared, identity, cacheProjectName, reporter, counters, recordEvent, options) {
+async function executePreparedProject(prepared, identity, cacheProjectName, telemetry, reporter, counters, recordEvent, options) {
 	const settledTaskIds = /* @__PURE__ */ new Set();
 	const projectCaseCounters = {
 		failed: 0,
@@ -1705,7 +2314,13 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 	const taskExecutor = async (task, context) => {
 		const runtimeTask = createScheduledTaskWithRuntimeConcurrency(task, prepared.project, options);
 		return {
-			...await rawTaskExecutor(runtimeTask, context),
+			...await telemetry.withSpan("vieval.task", {
+				"vieval.project.name": prepared.name,
+				"vieval.run.id": identity.runId,
+				"vieval.task.entry.id": runtimeTask.entry.id,
+				"vieval.task.id": runtimeTask.id,
+				"vieval.task.name": runtimeTask.entry.name
+			}, async () => await rawTaskExecutor(runtimeTask, context)),
 			matrix: cloneScheduledTaskMatrix(runtimeTask)
 		};
 	};
@@ -1714,7 +2329,7 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 	try {
 		const aggregated = await runScheduledTasks(prepared.tasks, taskExecutor, {
 			createExecutionContext(task) {
-				return createCliTaskExecutionContext(task, prepared.project.models, resolve(prepared.project.root, ".vieval", "cache"), cacheProjectName ?? prepared.name, identity.workspaceId, reporter, prepared.name, recordEvent, projectCaseCounters, projectCaseFailures, resolveCliRuntimeConcurrency(options), vitestCompatReporter);
+				return createCliTaskExecutionContext(task, prepared.project.models, resolve(prepared.project.root, ".vieval", "cache"), cacheProjectName ?? prepared.name, identity.workspaceId, telemetry, reporter, prepared.name, recordEvent, projectCaseCounters, projectCaseFailures, resolveCliRuntimeConcurrency(options), vitestCompatReporter);
 			},
 			onTaskEnd(task, state) {
 				settledTaskIds.add(task.id);
@@ -1807,14 +2422,6 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 		};
 	}
 }
-async function writeRunReportArtifacts(output, events, identity, reportOut) {
-	const projectId = deriveReportProjectId(output);
-	const reportDirectory = resolve(reportOut, identity.workspaceId, projectId, identity.experimentId, identity.attemptId, identity.runId);
-	await mkdir(reportDirectory, { recursive: true });
-	await writeFile(resolve(reportDirectory, "run-summary.json"), `${JSON.stringify(output, null, 2)}\n`, "utf-8");
-	await writeFile(resolve(reportDirectory, "events.jsonl"), events.map((event) => JSON.stringify(event)).join("\n").concat(events.length > 0 ? "\n" : ""), "utf-8");
-	return reportDirectory;
-}
 /**
 * Runs vieval orchestration from config and returns project-level summaries.
 *
@@ -1837,65 +2444,91 @@ async function runVievalCli(options = {}) {
 		configFilePath: options.configFilePath,
 		cwd: options.cwd
 	});
+	const telemetry = loadedConfig.reporting?.openTelemetry?.enabled === true ? createOpenTelemetryRuntime() : createNoopTelemetryRuntime();
+	const onOpenTelemetryRunEnd = loadedConfig.reporting?.openTelemetry?.enabled === true ? loadedConfig.reporting.openTelemetry.onRunEnd : void 0;
 	const restoreEnvironment = applyRunEnvironment(loadedConfig.env);
 	const eventRecorder = createEventRecorder(identity);
 	const reporter = createReporterWithEventCapture(createRunReporter(options.reporter), eventRecorder.record);
+	let runError;
+	let runEndError;
+	let output;
 	try {
-		const selectedProjects = filterProjectsByName(loadedConfig.projects, options.project ?? []);
-		const workspaceScheduler = createSchedulerRuntime({ concurrency: { workspace: resolveWorkspaceConcurrency(loadedConfig, options) } });
-		const preparedProjects = await Promise.all(selectedProjects.map(async (project) => prepareProject(project)));
-		const executableProjects = preparedProjects.filter((project) => project.kind === "prepared").map((project) => project.prepared);
-		const totalTasks = preparedProjects.reduce((sum, project) => {
-			if (project.kind === "prepared") return sum + project.prepared.tasks.length;
-			return sum + project.summary.taskCount;
-		}, 0);
-		const skippedSummaryTasks = preparedProjects.reduce((sum, project) => {
-			if (project.kind === "summary") return sum + project.summary.taskCount;
-			return sum;
-		}, 0);
-		const reporterCounters = {
-			failedTasks: 0,
-			passedTasks: 0,
-			skippedTasks: 0
-		};
-		reporter.onRunStart({ totalTasks });
-		for (const project of executableProjects) for (const task of project.tasks) reporter.onTaskQueued(createTaskQueuePayload(task, project.name));
-		const projectSummaries = (await Promise.all(preparedProjects.map(async (preparedProject, index) => {
-			if (preparedProject.kind === "summary") return {
-				index,
-				summary: preparedProject.summary
+		output = await telemetry.withSpan("vieval.run", {
+			"vieval.attempt.id": identity.attemptId,
+			"vieval.experiment.id": identity.experimentId,
+			"vieval.run.id": identity.runId,
+			"vieval.workspace.id": identity.workspaceId
+		}, async () => {
+			const selectedProjects = filterProjectsByName(loadedConfig.projects, options.project ?? []);
+			const workspaceScheduler = createSchedulerRuntime({ concurrency: { workspace: resolveWorkspaceConcurrency(loadedConfig, options) } });
+			const preparedProjects = await Promise.all(selectedProjects.map(async (project) => prepareProject(project)));
+			const executableProjects = preparedProjects.filter((project) => project.kind === "prepared").map((project) => project.prepared);
+			const totalTasks = preparedProjects.reduce((sum, project) => {
+				if (project.kind === "prepared") return sum + project.prepared.tasks.length;
+				return sum + project.summary.taskCount;
+			}, 0);
+			const skippedSummaryTasks = preparedProjects.reduce((sum, project) => {
+				if (project.kind === "summary") return sum + project.summary.taskCount;
+				return sum;
+			}, 0);
+			const reporterCounters = {
+				failedTasks: 0,
+				passedTasks: 0,
+				skippedTasks: 0
 			};
-			return {
-				index,
-				summary: await workspaceScheduler.runCase({
-					experimentId: identity.experimentId,
-					projectName: preparedProject.prepared.name,
-					scope: "workspace",
-					workspaceId: identity.workspaceId
-				}, async () => executePreparedProject(preparedProject.prepared, identity, options.cacheProjectName, reporter, reporterCounters, eventRecorder.record, options))
+			reporter.onRunStart({ totalTasks });
+			for (const project of executableProjects) for (const task of project.tasks) reporter.onTaskQueued(createTaskQueuePayload(task, project.name));
+			const projectSummaries = (await Promise.all(preparedProjects.map(async (preparedProject, index) => {
+				if (preparedProject.kind === "summary") return {
+					index,
+					summary: preparedProject.summary
+				};
+				return {
+					index,
+					summary: await telemetry.withSpan("vieval.project", {
+						"vieval.project.name": preparedProject.prepared.name,
+						"vieval.run.id": identity.runId
+					}, async () => await workspaceScheduler.runCase({
+						experimentId: identity.experimentId,
+						projectName: preparedProject.prepared.name,
+						scope: "workspace",
+						workspaceId: identity.workspaceId
+					}, async () => executePreparedProject(preparedProject.prepared, identity, options.cacheProjectName, telemetry, reporter, reporterCounters, eventRecorder.record, options)))
+				};
+			}))).sort((left, right) => left.index - right.index).map((item) => item.summary);
+			reporter.onRunEnd({
+				failedTasks: reporterCounters.failedTasks,
+				passedTasks: reporterCounters.passedTasks,
+				skippedTasks: reporterCounters.skippedTasks + skippedSummaryTasks,
+				totalTasks
+			});
+			const output = {
+				attemptId: identity.attemptId,
+				configFilePath: loadedConfig.configFilePath,
+				experimentId: identity.experimentId,
+				projects: projectSummaries,
+				reportDirectory: null,
+				runId: identity.runId,
+				workspaceId: identity.workspaceId
 			};
-		}))).sort((left, right) => left.index - right.index).map((item) => item.summary);
-		reporter.onRunEnd({
-			failedTasks: reporterCounters.failedTasks,
-			passedTasks: reporterCounters.passedTasks,
-			skippedTasks: reporterCounters.skippedTasks + skippedSummaryTasks,
-			totalTasks
+			if (options.reportOut != null) output.reportDirectory = await writeRunReportArtifacts(output, eventRecorder.events, identity, options.reportOut);
+			return output;
 		});
-		const output = {
-			attemptId: identity.attemptId,
-			configFilePath: loadedConfig.configFilePath,
-			experimentId: identity.experimentId,
-			projects: projectSummaries,
-			reportDirectory: null,
-			runId: identity.runId,
-			workspaceId: identity.workspaceId
-		};
-		if (options.reportOut != null) output.reportDirectory = await writeRunReportArtifacts(output, eventRecorder.events, identity, options.reportOut);
-		return output;
+	} catch (error) {
+		runError = error;
 	} finally {
+		if (onOpenTelemetryRunEnd != null) try {
+			await onOpenTelemetryRunEnd();
+		} catch (error) {
+			if (runError == null) runEndError = error;
+		}
 		reporter.dispose();
 		restoreEnvironment();
 	}
+	if (runError != null) throw runError;
+	if (runEndError != null) throw runEndError;
+	if (output == null) throw new Error("Vieval run finished without output.");
+	return output;
 }
 /**
 * Formats CLI run output as human-readable lines.
@@ -1964,8 +2597,7 @@ function formatVievalCliRunOutput(output) {
 		}
 		if (hasFailedCases) failedProjects += 1;
 		else passedProjects += 1;
-		const hybridAverage = project.result?.overall.hybridAverage;
-		const hybridAverageLabel = hybridAverage == null ? "n/a" : String(hybridAverage);
+		const hybridAverageLabel = formatHybridAverage(project.result?.overall.hybridAverage);
 		const runCount = project.result?.overall.runCount ?? 0;
 		const countLabel = colors.dim(`(${project.taskCount} tasks)`);
 		const caseSummaryLabel = project.caseSummary == null ? "" : `, cases ${project.caseSummary.passed} passed | ${project.caseSummary.failed} failed | ${project.caseSummary.timeout} timeout`;
@@ -2008,14 +2640,14 @@ const compareHelpText = `
     --output      Optional output artifact path
     --format      Console output format: table | json (default: table)
 `;
-function normalizeCliArgv$4(argv) {
+function normalizeCliArgv$6(argv) {
 	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
 	if (normalizedArgv[0] === "compare") return normalizedArgv.slice(1);
 	return normalizedArgv;
 }
 function parseCompareCliArguments(argv) {
 	const cli = meow(compareHelpText, {
-		argv: normalizeCliArgv$4(argv),
+		argv: normalizeCliArgv$6(argv),
 		flags: {
 			config: { type: "string" },
 			comparison: { type: "string" },
@@ -2120,7 +2752,7 @@ const evalRunHelpText = `
     --report-out Report output root directory
     --json       Print machine-readable JSON output
 `;
-function normalizeCliArgv$3(argv) {
+function normalizeCliArgv$5(argv) {
 	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
 	return normalizedArgv[0] === "run" ? normalizedArgv.slice(1) : normalizedArgv;
 }
@@ -2143,7 +2775,7 @@ function normalizeProjectNames(projectNames) {
 */
 function parseCliArguments(argv) {
 	const cli = meow(evalRunHelpText, {
-		argv: normalizeCliArgv$3(argv),
+		argv: normalizeCliArgv$5(argv),
 		importMeta: import.meta,
 		flags: {
 			config: { type: "string" },
@@ -2239,89 +2871,6 @@ async function runEvalRunCli(argv) {
 	}
 }
 //#endregion
-//#region src/cli/report-artifacts.ts
-/**
-* Resolves one or more `run-summary.json` paths from a report location.
-*
-* Use when:
-* - callers may pass a run directory, summary file path, or a report root
-*
-* Returns:
-* - sorted absolute summary file paths
-*/
-async function resolveRunSummaryPaths(reportPath) {
-	const absoluteReportPath = resolve(reportPath);
-	const directSummaryPath = resolve(absoluteReportPath, "run-summary.json");
-	if (existsSync(absoluteReportPath) && absoluteReportPath.endsWith(".json")) return [absoluteReportPath];
-	if (existsSync(directSummaryPath)) return [directSummaryPath];
-	return (await glob("**/run-summary.json", {
-		absolute: true,
-		cwd: absoluteReportPath
-	})).sort((left, right) => left.localeCompare(right));
-}
-/**
-* Reads one run report artifact set from `run-summary.json` and sibling `events.jsonl`.
-*
-* Use when:
-* - report analysis needs both run aggregate output and event count metadata
-*/
-function readReportRunArtifact(summaryFilePath) {
-	const reportDirectory = resolve(summaryFilePath, "..");
-	const summary = JSON.parse(readFileSync(summaryFilePath, "utf-8"));
-	const eventsFilePath = resolve(reportDirectory, "events.jsonl");
-	const events = existsSync(eventsFilePath) ? readFileSync(eventsFilePath, "utf-8").split("\n").filter((line) => line.trim().length > 0).map((line) => {
-		const event = JSON.parse(line);
-		return {
-			caseId: event.caseId,
-			data: event.data,
-			event: event.event,
-			taskId: event.taskId
-		};
-	}) : [];
-	return {
-		events,
-		eventsCount: events.length,
-		reportDirectory,
-		summary,
-		summaryFilePath
-	};
-}
-/**
-* Reads all run artifacts found under `reportPath`.
-*
-* Use when:
-* - callers need multi-run analysis from a directory root
-*/
-async function readReportArtifacts(reportPath) {
-	return (await resolveRunSummaryPaths(reportPath)).map((summaryFilePath) => readReportRunArtifact(summaryFilePath));
-}
-/**
-* Creates a compact summary row for one run artifact.
-*
-* Use when:
-* - table/csv/jsonl exports should stay stable and cheap to parse
-*/
-function summarizeReportRunArtifact(artifact) {
-	const totalProjects = artifact.summary.projects.length;
-	const failedProjects = artifact.summary.projects.filter((project) => project.errorMessage != null).length;
-	const executedProjects = artifact.summary.projects.filter((project) => project.executed).length;
-	const totalTasks = artifact.summary.projects.reduce((sum, project) => sum + project.taskCount, 0);
-	const projectNames = artifact.summary.projects.map((project) => project.name);
-	return {
-		attemptId: artifact.summary.attemptId ?? null,
-		eventsCount: artifact.eventsCount,
-		executedProjects,
-		experimentId: artifact.summary.experimentId ?? null,
-		failedProjects,
-		projectNames,
-		reportDirectory: artifact.reportDirectory,
-		runId: artifact.summary.runId ?? null,
-		totalProjects,
-		totalTasks,
-		workspaceId: artifact.summary.workspaceId ?? null
-	};
-}
-//#endregion
 //#region src/cli/report-analyze.ts
 const reportAnalyzeHelpText = `
   Analyze generated vieval report artifacts.
@@ -2343,7 +2892,7 @@ const reportAnalyzeHelpText = `
     --run-matrix   Keep runs matching run-matrix selector "key=value[,key=value]"
     --eval-matrix  Keep runs matching eval-matrix selector "key=value[,key=value]"
 `;
-function normalizeCliArgv$2(argv) {
+function normalizeCliArgv$4(argv) {
 	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
 	if (normalizedArgv[0] === "report" && normalizedArgv[1] === "analyze") return normalizedArgv.slice(2);
 	if (normalizedArgv[0] === "analyze") return normalizedArgv.slice(1);
@@ -2351,7 +2900,7 @@ function normalizeCliArgv$2(argv) {
 }
 function parseReportAnalyzeCliArguments(argv) {
 	const cli = meow(reportAnalyzeHelpText, {
-		argv: normalizeCliArgv$2(argv),
+		argv: normalizeCliArgv$4(argv),
 		flags: {
 			attempt: { type: "string" },
 			caseState: { type: "string" },
@@ -2640,6 +3189,473 @@ async function runReportAnalyzeCli(argv) {
 	}
 }
 //#endregion
+//#region src/cli/report-cases.ts
+const reportCasesHelpText = `
+  Inspect normalized case records from generated vieval report artifacts.
+
+  Usage
+    $ vieval report cases <reportPath> [options]
+
+  Options
+    --format       Output format: table | json | jsonl (default: table)
+    --where        Equality filter "key=value"; repeatable
+    --group-by     Case field, score name, or metric name used for grouped score summaries
+`;
+/**
+* Reads normalized case records from one report run directory or report root.
+*
+* Use when:
+* - CLI tools need case-level inspection from local report artifacts
+* - callers may pass a run directory, a `cases.jsonl` file, or a report root
+*
+* Expects:
+* - discovered `cases.jsonl` files contain one `CaseRecord` JSON object per line
+*
+* Returns:
+* - all parsed case records sorted by discovered file path order
+*/
+async function readCaseRecordsFromReport(reportPath) {
+	const caseFilePaths = await resolveCaseRecordPaths(reportPath);
+	if (caseFilePaths.length === 0) throw new Error(`No cases.jsonl files found under "${resolve(reportPath)}".`);
+	const records = [];
+	for (const caseFilePath of caseFilePaths) {
+		const lines = readFileSync(caseFilePath, "utf-8").split("\n");
+		for (const [index, line] of lines.entries()) {
+			const trimmed = line.trim();
+			if (trimmed.length === 0) continue;
+			try {
+				records.push(JSON.parse(trimmed));
+			} catch (error) {
+				throw new Error(`Invalid cases.jsonl line ${index + 1} in "${caseFilePath}": ${errorMessageFrom(error) ?? "Unknown JSON parse failure."}`);
+			}
+		}
+	}
+	return records;
+}
+/**
+* Builds filtered case inspection output.
+*
+* Use when:
+* - `vieval report cases` needs deterministic JSON/table output
+* - tests need pure filtering and grouping behavior without process I/O
+*
+* Expects:
+* - `where` filters use `key=value`
+* - lookup keys may target direct case fields, score names, or metric names
+*
+* Returns:
+* - filtered records plus grouped score summaries when `groupBy` is present
+*/
+function buildReportCasesOutput(records, options) {
+	const whereFilters = (options.where ?? []).map(parseSelector);
+	const filteredRecords = records.filter((record) => matchesWhereFilters(record, whereFilters));
+	return {
+		groups: options.groupBy == null ? void 0 : buildCaseGroups(filteredRecords, options.groupBy),
+		records: [...filteredRecords]
+	};
+}
+/**
+* Runs the `vieval report cases` command.
+*
+* Call stack:
+*
+* published executable (`../bin/vieval`)
+*   -> {@link import('./index').runTopLevelCli}
+*     -> {@link runReportCasesCli}
+*       -> {@link readCaseRecordsFromReport}
+*
+* Use when:
+* - the top-level CLI dispatches local case artifact inspection
+*
+* Expects:
+* - argv is either `cases <reportPath> ...` or `<reportPath> ...`
+*
+* Returns:
+* - resolves after writing the requested output to stdout
+*/
+async function runReportCasesCli(argv) {
+	try {
+		const parsed = parseReportCasesCliArguments(argv);
+		const output = buildReportCasesOutput(await readCaseRecordsFromReport(parsed.reportPath), parsed);
+		if (parsed.format === "json") {
+			process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+			return;
+		}
+		if (parsed.format === "jsonl") {
+			process.stdout.write(encodeJsonl(output.records));
+			return;
+		}
+		process.stdout.write(`${formatCasesTable(output)}\n`);
+	} catch (error) {
+		const errorMessage = errorMessageFrom(error) ?? "Unknown report cases failure.";
+		process.stderr.write(`[vieval report cases] ${errorMessage}\n`);
+		process.exitCode = 1;
+	}
+}
+function normalizeCliArgv$3(argv) {
+	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
+	if (normalizedArgv[0] === "report" && normalizedArgv[1] === "cases") return normalizedArgv.slice(2);
+	if (normalizedArgv[0] === "cases") return normalizedArgv.slice(1);
+	return normalizedArgv;
+}
+function parseReportCasesCliArguments(argv) {
+	const cli = meow(reportCasesHelpText, {
+		argv: normalizeCliArgv$3(argv),
+		flags: {
+			format: {
+				default: "table",
+				type: "string"
+			},
+			groupBy: { type: "string" },
+			where: {
+				isMultiple: true,
+				type: "string"
+			}
+		},
+		importMeta: import.meta
+	});
+	const reportPath = cli.input[0];
+	if (reportPath == null || reportPath.length === 0) throw new Error("Missing required <reportPath> argument.");
+	return {
+		format: normalizeReportCasesFormat(cli.flags.format),
+		groupBy: cli.flags.groupBy,
+		reportPath,
+		where: cli.flags.where
+	};
+}
+function normalizeReportCasesFormat(value) {
+	const normalized = value.toLowerCase();
+	if (normalized === "json") return "json";
+	if (normalized === "jsonl") return "jsonl";
+	return "table";
+}
+async function resolveCaseRecordPaths(reportPath) {
+	const absoluteReportPath = resolve(reportPath);
+	const directCaseFilePath = resolve(absoluteReportPath, "cases.jsonl");
+	if (existsSync(absoluteReportPath) && absoluteReportPath.endsWith(".jsonl")) return [absoluteReportPath];
+	if (existsSync(directCaseFilePath)) return [directCaseFilePath];
+	return (await glob("**/cases.jsonl", {
+		absolute: true,
+		cwd: absoluteReportPath
+	})).sort((left, right) => left.localeCompare(right));
+}
+function matchesWhereFilters(record, whereFilters) {
+	return whereFilters.every((parsed) => {
+		const resolved = getCaseSelectorValue(record, parsed.key);
+		return resolved.exists && String(resolved.value) === parsed.value;
+	});
+}
+function parseSelector(selector) {
+	const separatorIndex = selector.indexOf("=");
+	if (separatorIndex <= 0 || separatorIndex === selector.length - 1) throw new Error(`Invalid selector "${selector}". Expected "key=value".`);
+	return {
+		key: selector.slice(0, separatorIndex).trim(),
+		value: selector.slice(separatorIndex + 1).trim()
+	};
+}
+function buildCaseGroups(records, groupBy) {
+	const groups = {};
+	for (const record of records) {
+		const resolved = getCaseSelectorValue(record, groupBy);
+		if (!resolved.exists) continue;
+		const groupKey = `${groupBy}=${String(resolved.value)}`;
+		groups[groupKey] ??= {
+			count: 0,
+			scores: {}
+		};
+		groups[groupKey].count += 1;
+		addScores(groups[groupKey].scores, record.scores);
+	}
+	return Object.fromEntries(Object.entries(groups).sort(([left], [right]) => left.localeCompare(right)).map(([groupKey, group]) => [groupKey, {
+		count: group.count,
+		scores: finalizeScores(group.scores)
+	}]));
+}
+function addScores(summary, scores) {
+	for (const [scoreName, value] of Object.entries(scores)) {
+		summary[scoreName] ??= {
+			average: 0,
+			count: 0,
+			sum: 0
+		};
+		summary[scoreName].count += 1;
+		summary[scoreName].sum += value;
+	}
+}
+function finalizeScores(summary) {
+	return Object.fromEntries(Object.entries(summary).sort(([left], [right]) => left.localeCompare(right)).map(([scoreName, bucket]) => [scoreName, {
+		average: bucket.count === 0 ? 0 : bucket.sum / bucket.count,
+		count: bucket.count,
+		sum: bucket.sum
+	}]));
+}
+function formatCasesTable(output) {
+	const lines = ["CASES  vieval report", `Case count ${output.records.length}`];
+	if (output.groups != null) {
+		lines.push("Groups");
+		for (const [groupKey, group] of Object.entries(output.groups)) {
+			const scoreText = Object.entries(group.scores).map(([scoreName, bucket]) => `${scoreName}=${bucket.average.toFixed(3)}`).join(" ");
+			lines.push(`${groupKey}  count=${group.count}${scoreText.length > 0 ? ` ${scoreText}` : ""}`);
+		}
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/report-case-compare.ts
+const reportCompareHelpText = `
+  Compare normalized case records from two generated vieval reports.
+
+  Usage
+    $ vieval report compare <leftReportPath> <rightReportPath> [options]
+
+  Options
+    --format       Output format: table | json (default: table)
+    --case-key     Case field, score name, or metric name used to match records
+    --score-kind   Score kind used for deltas (default: exact)
+    --group-by     Case field, score name, or metric name used for grouped deltas
+`;
+/**
+* Builds a generic case-level comparison between two report runs.
+*
+* Use when:
+* - local report analysis needs per-case improvements/regressions
+* - benchmark-specific facets should stay as generic metric keys
+*
+* Expects:
+* - left and right records are normalized `cases.jsonl` rows
+* - score values are numeric and comparable by `scoreKind`
+*
+* Returns:
+* - matched case deltas, added/removed cases, top changes, and optional group summaries
+*/
+function buildCaseComparison(args) {
+	const scoreKind = args.scoreKind ?? "exact";
+	const leftByKey = indexRecordsByCaseKey(args.left, args.caseKey, "left");
+	const rightByKey = indexRecordsByCaseKey(args.right, args.caseKey, "right");
+	const cases = [];
+	const added = [];
+	const removed = [];
+	for (const [caseKey, leftRecord] of leftByKey) {
+		const rightRecord = rightByKey.get(caseKey);
+		if (rightRecord == null) {
+			removed.push(leftRecord);
+			continue;
+		}
+		const leftScore = getScore(leftRecord, scoreKind);
+		const rightScore = getScore(rightRecord, scoreKind);
+		cases.push({
+			caseKey,
+			delta: {
+				left: leftScore,
+				right: rightScore,
+				score: rightScore - leftScore
+			},
+			left: leftRecord,
+			metricsChanged: diffMetrics(leftRecord.metrics, rightRecord.metrics),
+			right: rightRecord
+		});
+	}
+	for (const [caseKey, rightRecord] of rightByKey) if (!leftByKey.has(caseKey)) added.push(rightRecord);
+	const sortedCases = [...cases].sort((left, right) => {
+		const deltaOrder = right.delta.score - left.delta.score;
+		return deltaOrder === 0 ? left.caseKey.localeCompare(right.caseKey) : deltaOrder;
+	});
+	return {
+		added: added.sort(compareCaseRecords),
+		cases: cases.sort((left, right) => left.caseKey.localeCompare(right.caseKey)),
+		groups: args.groupBy == null ? void 0 : buildComparisonGroups(cases, args.groupBy),
+		overall: {
+			delta: averageScore(args.right, scoreKind) - averageScore(args.left, scoreKind),
+			leftAverage: averageScore(args.left, scoreKind),
+			rightAverage: averageScore(args.right, scoreKind)
+		},
+		removed: removed.sort(compareCaseRecords),
+		topImprovements: sortedCases.filter((row) => row.delta.score > 0).slice(0, 10),
+		topRegressions: [...sortedCases].reverse().filter((row) => row.delta.score < 0).slice(0, 10)
+	};
+}
+/**
+* Runs the `vieval report compare` command.
+*
+* Call stack:
+*
+* published executable (`../bin/vieval`)
+*   -> {@link import('./index').runTopLevelCli}
+*     -> {@link runReportCompareCli}
+*       -> {@link readCaseRecordsFromReport}
+*       -> {@link buildCaseComparison}
+*
+* Use when:
+* - two local report artifact directories should be compared case-by-case
+*
+* Expects:
+* - argv is either `compare <left> <right> ...` or `<left> <right> ...`
+*
+* Returns:
+* - resolves after writing the requested output to stdout
+*/
+async function runReportCompareCli(argv) {
+	try {
+		const parsed = parseReportCompareCliArguments(argv);
+		const [left, right] = await Promise.all([readCaseRecordsFromReport(parsed.leftReportPath), readCaseRecordsFromReport(parsed.rightReportPath)]);
+		const output = buildCaseComparison({
+			caseKey: parsed.caseKey,
+			groupBy: parsed.groupBy,
+			left,
+			right,
+			scoreKind: parsed.scoreKind
+		});
+		if (parsed.format === "json") {
+			process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(`${formatCaseComparisonTable(output)}\n`);
+	} catch (error) {
+		const errorMessage = errorMessageFrom(error) ?? "Unknown report compare failure.";
+		process.stderr.write(`[vieval report compare] ${errorMessage}\n`);
+		process.exitCode = 1;
+	}
+}
+function normalizeCliArgv$2(argv) {
+	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
+	if (normalizedArgv[0] === "report" && normalizedArgv[1] === "compare") return normalizedArgv.slice(2);
+	if (normalizedArgv[0] === "compare") return normalizedArgv.slice(1);
+	return normalizedArgv;
+}
+function parseReportCompareCliArguments(argv) {
+	const cli = meow(reportCompareHelpText, {
+		argv: normalizeCliArgv$2(argv),
+		flags: {
+			caseKey: { type: "string" },
+			format: {
+				default: "table",
+				type: "string"
+			},
+			groupBy: { type: "string" },
+			scoreKind: {
+				default: "exact",
+				type: "string"
+			}
+		},
+		importMeta: import.meta
+	});
+	const leftReportPath = cli.input[0];
+	const rightReportPath = cli.input[1];
+	if (leftReportPath == null || leftReportPath.length === 0 || rightReportPath == null || rightReportPath.length === 0) throw new Error("Missing required <leftReportPath> and <rightReportPath> arguments.");
+	return {
+		caseKey: cli.flags.caseKey,
+		format: cli.flags.format === "json" ? "json" : "table",
+		groupBy: cli.flags.groupBy,
+		leftReportPath,
+		rightReportPath,
+		scoreKind: cli.flags.scoreKind
+	};
+}
+function indexRecordsByCaseKey(records, caseKey, side) {
+	const indexed = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const resolved = resolveCaseKey(record, caseKey);
+		if (indexed.has(resolved)) throw new Error(`Duplicate case key "${resolved}" in ${side} report.`);
+		indexed.set(resolved, record);
+	}
+	return indexed;
+}
+function resolveCaseKey(record, caseKey) {
+	if (caseKey != null) {
+		const resolved = getCaseSelectorValue(record, caseKey);
+		if (resolved.exists) return String(resolved.value);
+		throw new Error(`Missing explicit case key "${caseKey}" for case "${record.caseId}".`);
+	}
+	const benchmarkCaseId = getCaseSelectorValue(record, "benchmark.case.id");
+	if (benchmarkCaseId.exists) return String(benchmarkCaseId.value);
+	const vievalCaseId = getCaseSelectorValue(record, "vieval.case.id");
+	return vievalCaseId.exists ? String(vievalCaseId.value) : record.caseId;
+}
+function getScore(record, scoreKind) {
+	return record.scores[scoreKind] ?? 0;
+}
+function averageScore(records, scoreKind) {
+	const values = records.map((record) => record.scores[scoreKind]).filter((value) => typeof value === "number");
+	if (values.length === 0) return 0;
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function diffMetrics(left, right) {
+	const changed = {};
+	const metricKeys = [...new Set([...Object.keys(left), ...Object.keys(right)])].sort((leftKey, rightKey) => leftKey.localeCompare(rightKey));
+	for (const metricKey of metricKeys) if (stableStringify(left[metricKey]) !== stableStringify(right[metricKey])) changed[metricKey] = {
+		left: left[metricKey],
+		right: right[metricKey]
+	};
+	return changed;
+}
+function buildComparisonGroups(cases, groupBy) {
+	const groupedRows = {};
+	for (const row of cases) {
+		const resolved = getCaseSelectorValue(row.right, groupBy);
+		if (!resolved.exists) continue;
+		const groupKey = `${groupBy}=${String(resolved.value)}`;
+		groupedRows[groupKey] ??= [];
+		groupedRows[groupKey].push(row);
+	}
+	return Object.fromEntries(Object.entries(groupedRows).sort(([left], [right]) => left.localeCompare(right)).map(([groupKey, rows]) => {
+		const leftAverage = rows.reduce((sum, row) => sum + row.delta.left, 0) / rows.length;
+		const rightAverage = rows.reduce((sum, row) => sum + row.delta.right, 0) / rows.length;
+		return [groupKey, {
+			count: rows.length,
+			delta: rightAverage - leftAverage,
+			leftAverage,
+			rightAverage
+		}];
+	}));
+}
+function compareCaseRecords(left, right) {
+	return left.caseId.localeCompare(right.caseId);
+}
+/**
+* Formats a case comparison as a compact human-readable table.
+*
+* Use when:
+* - `vieval report compare` should expose the same information as JSON output
+* - users need a terminal-first overview of group and per-case deltas
+*
+* Expects:
+* - comparison output was produced by {@link buildCaseComparison}
+*
+* Returns:
+* - multi-line text containing aggregate, group, top-change, case, and unmatched summaries
+*/
+function formatCaseComparisonTable(output) {
+	const lines = [
+		"COMPARE  vieval report cases",
+		`Matched   ${output.cases.length}`,
+		`Added     ${output.added.length}`,
+		`Removed   ${output.removed.length}`,
+		`Scores    left=${output.overall.leftAverage.toFixed(3)} right=${output.overall.rightAverage.toFixed(3)} delta=${output.overall.delta.toFixed(3)}`
+	];
+	if (output.groups != null && Object.keys(output.groups).length > 0) {
+		lines.push("Groups");
+		for (const [groupKey, group] of Object.entries(output.groups)) lines.push(`${groupKey}  count=${group.count} left=${group.leftAverage.toFixed(3)} right=${group.rightAverage.toFixed(3)} delta=${group.delta.toFixed(3)}`);
+	}
+	if (output.topImprovements.length > 0) {
+		lines.push("Top improvements");
+		for (const row of output.topImprovements) lines.push(`${row.caseKey}  delta=${row.delta.score.toFixed(3)} left=${row.delta.left.toFixed(3)} right=${row.delta.right.toFixed(3)}`);
+	}
+	if (output.topRegressions.length > 0) {
+		lines.push("Top regressions");
+		for (const row of output.topRegressions) lines.push(`${row.caseKey}  delta=${row.delta.score.toFixed(3)} left=${row.delta.left.toFixed(3)} right=${row.delta.right.toFixed(3)}`);
+	}
+	if (output.cases.length > 0) {
+		lines.push("Cases");
+		for (const row of output.cases) {
+			const changedMetricNames = Object.keys(row.metricsChanged);
+			lines.push(`${row.caseKey}  delta=${row.delta.score.toFixed(3)} changedMetrics=${changedMetricNames.length === 0 ? "none" : changedMetricNames.join(",")}`);
+		}
+	}
+	if (output.added.length > 0) lines.push(`Added cases ${output.added.map((record) => record.caseId).join(",")}`);
+	if (output.removed.length > 0) lines.push(`Removed cases ${output.removed.map((record) => record.caseId).join(",")}`);
+	return lines.join("\n");
+}
+//#endregion
 //#region src/cli/report-index.ts
 const reportIndexHelpText = `
   Build report indexes from generated vieval artifacts.
@@ -2807,7 +3823,15 @@ async function runTopLevelCli(argv) {
 			await runReportIndexCli(parsed.commandArgv);
 			return;
 		}
-		throw new Error(`Unsupported vieval report command "${reportSubcommand ?? "(none)"}". Expected "analyze" or "index".`);
+		if (reportSubcommand === "cases") {
+			await runReportCasesCli(parsed.commandArgv);
+			return;
+		}
+		if (reportSubcommand === "compare") {
+			await runReportCompareCli(parsed.commandArgv);
+			return;
+		}
+		throw new Error(`Unsupported vieval report command "${reportSubcommand ?? "(none)"}". Expected "analyze", "index", "cases", or "compare".`);
 	}
 	if (parsed.command === "compare") {
 		await runCompareCliOrExit(parsed.commandArgv);
@@ -2818,4 +3842,4 @@ async function runTopLevelCli(argv) {
 //#endregion
 export { runTopLevelCli as n, parseTopLevelCliArguments as t };
 
-//# sourceMappingURL=cli-sanbKtQq.mjs.map
+//# sourceMappingURL=cli-ImxGpoYQ.mjs.map