vieval 0.0.5 → 0.0.7

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

@@ -1,4 +1,5 @@
-import { c as loadRawVievalConfig, l as loadVievalCliConfig, n as consumeModuleRegistrations, o as detectCliConfigMode, r as endModuleRegistration, t as beginModuleRegistration } from "./registry-CwcMMjnZ.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";
 import { errorMessageFrom } from "@moeru/std";
@@ -12,6 +13,7 @@ import c from "tinyrainbow";
 import { existsSync, readFileSync } from "node:fs";
 import { uniq } from "es-toolkit";
 import { createVitest } from "vitest/node";
+import { formatDuration, intervalToDuration } from "date-fns";
 import { stripVTControlCharacters } from "node:util";
 import stringWidth from "fast-string-width";
 //#region src/cli/comparison-config.ts
@@ -262,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.
@@ -378,12 +986,21 @@ var SummaryReporterStateMachine = class {
 		if (task.state === "finished") return;
 		task.state = "running";
 		task.startedAt ??= this.options.getNow();
-		if (task.settledCaseIds.has(payload.caseId) || task.runningCases.has(payload.caseId)) return;
+		if (task.settledCaseIds.has(payload.caseId)) return;
+		const existingCase = task.runningCases.get(payload.caseId);
+		if (existingCase != null) {
+			existingCase.autoRetry = payload.autoRetry;
+			existingCase.caseName = payload.caseName ?? payload.caseId;
+			existingCase.retryIndex = payload.retryIndex;
+			return;
+		}
 		task.caseOrderCounter += 1;
 		task.runningCases.set(payload.caseId, {
+			autoRetry: payload.autoRetry,
 			caseId: payload.caseId,
 			caseName: payload.caseName ?? payload.caseId,
 			order: task.caseOrderCounter,
+			retryIndex: payload.retryIndex,
 			startedAt: this.options.getNow()
 		});
 		this.syncTaskTotalCases(task);
@@ -420,6 +1037,10 @@ var SummaryReporterStateMachine = class {
 			this.caseCounters.failed += 1;
 			return;
 		}
+		if (payload.state === "timeout") {
+			this.caseCounters.timeout += 1;
+			return;
+		}
 		this.caseCounters.skipped += 1;
 	}
 	/**
@@ -500,39 +1121,52 @@ var SummaryReporterStateMachine = class {
 		const activeRows = this.createActiveRows();
 		const footerRows = this.createFooterRows();
 		const maxRows = options?.maxRows;
-		const activeBlock = [
+		const footerBlock = [...footerRows, ""];
+		if (maxRows == null || maxRows <= 0) return [...[
 			"",
 			...activeRows,
 			...activeRows.length > 0 ? [""] : []
-		];
-		const footerBlock = [...footerRows, ""];
-		if (maxRows == null || maxRows <= 0) return [...activeBlock, ...footerBlock];
+		], ...footerBlock];
 		if (maxRows <= footerBlock.length) return footerBlock.slice(-maxRows);
-		const availableActiveRows = Math.max(0, maxRows - footerBlock.length);
-		return [...activeBlock.slice(0, availableActiveRows), ...footerBlock];
+		return [...createBoundedActiveBlock(activeRows, Math.max(0, maxRows - footerBlock.length)), ...footerBlock];
 	}
 	createActiveRows() {
 		const activeTasks = Array.from(this.tasks.values()).filter((task) => task.state !== "finished").sort(compareActiveTasks);
 		const rows = [];
 		for (const task of activeTasks) {
-			const suffix = task.state === "queued" ? c.dim(" [queued]") : ` ${task.completedCases}/${task.totalCases}`;
+			const now = this.options.getNow();
+			const suffix = task.state === "queued" ? c.dim(" [queued]") : formatTaskProgressSuffix(task, now);
 			const badge = formatProjectBadge(task.projectName, this.options.isTTY);
 			rows.push(c.bold(c.yellow(` ${POINTER} `)) + badge + task.displayName + c.dim(suffix));
-			const slowCases = Array.from(task.runningCases.values()).filter((activeCase) => this.options.getNow() - activeCase.startedAt >= this.options.slowThresholdMs).sort((left, right) => left.order - right.order);
+			const slowCases = Array.from(task.runningCases.values()).filter((activeCase) => now - activeCase.startedAt >= this.options.slowThresholdMs).sort((left, right) => left.order - right.order);
 			for (const [index, activeCase] of slowCases.entries()) {
 				const icon = index === slowCases.length - 1 ? TREE_NODE_END : TREE_NODE_MIDDLE;
-				const elapsed = Math.max(0, this.options.getNow() - activeCase.startedAt);
-				rows.push(c.bold(c.yellow(`   ${icon} `)) + activeCase.caseName + c.bold(c.yellow(` ${formatDuration$1(elapsed)}`)));
+				const elapsed = Math.max(0, now - activeCase.startedAt);
+				rows.push(c.bold(c.yellow(`   ${icon} `)) + activeCase.caseName + formatRetrySuffix(activeCase) + c.bold(c.yellow(` ${formatDuration$2(elapsed)}`)));
 			}
 		}
 		return rows;
 	}
 	createFooterRows() {
+		const now = this.options.getNow();
+		const runElapsedDurationMs = Math.max(0, now - this.startedAtMs);
+		const taskRunningCount = countRunningTasks(this.tasks.values());
+		const caseRunningCount = countRunningCases(this.tasks.values());
 		return [
-			padSummaryTitle("Tasks") + formatCounterState(this.taskCounters),
-			padSummaryTitle("Cases") + formatCounterState(this.caseCounters),
+			padSummaryTitle("Tasks") + formatCounterState(this.taskCounters, taskRunningCount, {
+				elapsedDurationMs: runElapsedDurationMs,
+				estimatedDurationMs: estimateTotalDurationMs(this.taskCounters.completed, this.taskCounters.total, runElapsedDurationMs)
+			}),
+			padSummaryTitle("Cases") + formatCounterState(this.caseCounters, caseRunningCount, {
+				elapsedDurationMs: runElapsedDurationMs,
+				estimatedDurationMs: estimateTotalDurationMs(this.caseCounters.completed, this.caseCounters.total, runElapsedDurationMs)
+			}),
+			padSummaryTitle("Concurrency") + formatActiveConcurrencyState({
+				caseRunningCount,
+				taskRunningCount
+			}),
 			padSummaryTitle("Start at") + this.startTime,
-			padSummaryTitle("Duration") + formatDuration$1(Math.max(0, this.options.getNow() - this.startedAtMs))
+			padSummaryTitle("Duration") + formatHumanDuration(runElapsedDurationMs)
 		];
 	}
 	getOrCreateTaskState(taskId) {
@@ -563,6 +1197,39 @@ var SummaryReporterStateMachine = class {
 	}
 };
 /**
+* Creates the active task block while keeping room for summary footer rows.
+*
+* Use when:
+* - the live TTY window is smaller than the number of running task/case rows
+* - active rows need a visible truncation marker instead of silently disappearing
+*
+* Expects:
+* - `activeRows` contains already-formatted task and slow-case rows
+* - `maxRows` counts the leading spacer and truncation marker
+*
+* Returns:
+* - rows that fit inside `maxRows`
+* - a final hidden-row marker when active rows were omitted
+*/
+function createBoundedActiveBlock(activeRows, maxRows) {
+	if (maxRows <= 0) return [];
+	if (activeRows.length === 0) return [""];
+	const fullBlock = [
+		"",
+		...activeRows,
+		""
+	];
+	if (fullBlock.length <= maxRows) return fullBlock;
+	if (maxRows === 1) return [""];
+	const visibleActiveRows = Math.max(0, maxRows - 2);
+	const hiddenRows = Math.max(0, activeRows.length - visibleActiveRows);
+	return [
+		"",
+		...activeRows.slice(0, visibleActiveRows),
+		c.dim(`   ${TREE_NODE_END} ... ${hiddenRows} more running rows hidden`)
+	];
+}
+/**
 * Creates the live summary reporter state machine for `vieval` CLI runs.
 *
 * Use when:
@@ -593,6 +1260,7 @@ function createCounterState() {
 		failed: 0,
 		passed: 0,
 		skipped: 0,
+		timeout: 0,
 		total: 0
 	};
 }
@@ -601,6 +1269,7 @@ function resetCounterState(counter, total) {
 	counter.failed = 0;
 	counter.passed = 0;
 	counter.skipped = 0;
+	counter.timeout = 0;
 	counter.total = total;
 }
 function sumTaskCaseTotals(tasks) {
@@ -619,19 +1288,48 @@ function compareActiveTasks(left, right) {
 function padSummaryTitle(label) {
 	return `${c.dim(label.padEnd(8))} `;
 }
-function formatCounterState(counter) {
+function formatCounterState(counter, runningCount, timing) {
+	const plannedCount = Math.max(0, counter.total - counter.completed - runningCount);
 	return [
+		plannedCount > 0 ? c.bold(c.blue(`${plannedCount} planned`)) : c.dim(`${plannedCount} planned`),
+		runningCount > 0 ? c.bold(c.yellow(`${runningCount} running`)) : c.dim(`${runningCount} running`),
 		c.bold(c.green(`${counter.passed} passed`)),
 		counter.failed > 0 ? c.bold(c.red(`${counter.failed} failed`)) : c.dim(`${counter.failed} failed`),
+		counter.timeout > 0 ? c.bold(c.yellow(`${counter.timeout} timeout`)) : c.dim(`${counter.timeout} timeout`),
 		counter.skipped > 0 ? c.yellow(`${counter.skipped} skipped`) : c.dim(`${counter.skipped} skipped`)
-	].join(c.dim(" | ")) + c.gray(` (${counter.total})`);
+	].join(c.dim(" | ")) + c.gray(` (${counter.total})`) + formatTimingSuffix(timing);
+}
+function formatActiveConcurrencyState(options) {
+	return [options.taskRunningCount > 0 ? c.bold(c.yellow(`${options.taskRunningCount} ${pluralize("task", options.taskRunningCount)} running`)) : c.dim("0 tasks running"), options.caseRunningCount > 0 ? c.bold(c.yellow(`${options.caseRunningCount} ${pluralize("case", options.caseRunningCount)} running`)) : c.dim("0 cases running")].join(c.dim(" | "));
+}
+function pluralize(noun, count) {
+	return count === 1 ? noun : `${noun}s`;
+}
+function formatRetrySuffix(activeCase) {
+	if (activeCase.retryIndex == null || activeCase.retryIndex <= 0 || activeCase.autoRetry == null || activeCase.autoRetry <= 0) return "";
+	return c.dim(` retry ${activeCase.retryIndex}/${activeCase.autoRetry}`);
 }
 function formatTimeString(date) {
 	return date.toTimeString().split(" ")[0] ?? "";
 }
-function formatDuration$1(durationMs) {
-	if (durationMs >= 1e3) return `${(durationMs / 1e3).toFixed(2)}s`;
-	return `${Math.round(durationMs)}ms`;
+function formatDuration$2(durationMs) {
+	return formatHumanDuration(durationMs);
+}
+function formatHumanDuration(durationMs) {
+	if (durationMs < 1e3) return `${Math.round(durationMs)}ms`;
+	const formatted = formatDuration(intervalToDuration({
+		end: durationMs,
+		start: 0
+	}), {
+		delimiter: " ",
+		format: [
+			"hours",
+			"minutes",
+			"seconds"
+		],
+		zero: false
+	});
+	return formatted.length > 0 ? formatted : "0 seconds";
 }
 function formatProjectBadge(projectName, isTTY) {
 	if (projectName == null || projectName.length === 0) return "";
@@ -645,6 +1343,37 @@ function formatProjectBadge(projectName, isTTY) {
 	const background = backgroundPool[projectName.split("").reduce((accumulator, character, index) => accumulator + character.charCodeAt(0) + index, 0) % backgroundPool.length];
 	return `${c.black(background(` ${projectName} `))} `;
 }
+function countRunningCases(tasks) {
+	let runningCount = 0;
+	for (const task of tasks) runningCount += task.runningCases.size;
+	return runningCount;
+}
+function countRunningTasks(tasks) {
+	let runningCount = 0;
+	for (const task of tasks) if (task.state === "running") runningCount += 1;
+	return runningCount;
+}
+function estimateTaskDurationMs(task, now) {
+	if (task.startedAt == null) return;
+	return estimateTotalDurationMs(task.completedCases, task.totalCases, Math.max(0, now - task.startedAt));
+}
+function estimateTotalDurationMs(completedCount, totalCount, elapsedDurationMs) {
+	if (completedCount === 0 || totalCount === 0) return;
+	const averageDurationMs = elapsedDurationMs / completedCount;
+	return Math.round(averageDurationMs * totalCount);
+}
+function formatTaskProgressSuffix(task, now) {
+	const elapsedDurationMs = task.startedAt == null ? 0 : Math.max(0, now - task.startedAt);
+	return ` ${task.completedCases}/${task.totalCases}, ${task.runningCases.size} ${pluralize("case", task.runningCases.size)} running${formatTimingSuffix({
+		elapsedDurationMs,
+		estimatedDurationMs: estimateTaskDurationMs(task, now)
+	})}`;
+}
+function formatTimingSuffix(timing) {
+	const parts = [`elapsed ${formatHumanDuration(timing.elapsedDurationMs)}`];
+	if (timing.estimatedDurationMs != null) parts.push(`estimated ${formatHumanDuration(timing.estimatedDurationMs)}`);
+	return ` (${parts.join(", ")})`;
+}
 //#endregion
 //#region src/cli/reporters/index.ts
 /**
@@ -1000,7 +1729,7 @@ async function createVievalVitestCompatReporterBridge(options) {
 	return {
 		async onCaseEnd(payload) {
 			const taskCase = getOrCreateCase(payload.taskId, payload.caseId);
-			taskCase.state = payload.state;
+			taskCase.state = payload.state === "timeout" ? "failed" : payload.state;
 			await emitToReporters(loadedReporters, (reporter) => reporter.onTestCaseResult?.(taskCase));
 		},
 		async onCaseStart(payload) {
@@ -1047,17 +1776,68 @@ async function createVievalVitestCompatReporterBridge(options) {
 function hasRunFailures(output) {
 	return output.projects.some((project) => {
 		if (project.errorMessage != null) return true;
-		if (project.caseSummary != null && project.caseSummary.failed > 0) return true;
+		if (project.caseSummary != null && (project.caseSummary.failed > 0 || project.caseSummary.timeout > 0)) return true;
 		return (project.caseFailures?.length ?? 0) > 0;
 	});
 }
-function shouldUseColor() {
-	if (process.env.NO_COLOR != null) return false;
-	const forceColor = process.env.FORCE_COLOR;
-	if (forceColor != null) return forceColor !== "0";
-	return process.stdout.isTTY === true;
+function resolveCappedConcurrency(defaultConcurrency, cliConcurrency, fallback) {
+	const effectiveDefault = defaultConcurrency ?? fallback;
+	if (cliConcurrency == null) return effectiveDefault;
+	return Math.min(effectiveDefault, cliConcurrency);
 }
-function createColorPalette(enabled) {
+function resolveOptionalRuntimeTaskConcurrency(defaultConcurrency, cliConcurrency) {
+	return cliConcurrency ?? defaultConcurrency;
+}
+function resolveWorkspaceConcurrency(loadedConfig, options) {
+	return resolveCappedConcurrency(loadedConfig.concurrency?.workspace, options.workspaceConcurrency, 1);
+}
+function resolveProjectConcurrency(project, options) {
+	return resolveCappedConcurrency(project.concurrency?.project, options.projectConcurrency, Number.POSITIVE_INFINITY);
+}
+function resolveTaskConcurrency(project, options) {
+	return resolveCappedConcurrency(project.concurrency?.task, options.taskConcurrency, 1);
+}
+function resolveScheduledTaskConcurrency(project, options) {
+	return Math.min(resolveProjectConcurrency(project, options), resolveTaskConcurrency(project, options));
+}
+function resolveRuntimeTaskConcurrency(taskConcurrency, project, options) {
+	const attempt = resolveOptionalRuntimeTaskConcurrency(taskConcurrency?.attempt ?? project.concurrency?.attempt, options.attemptConcurrency);
+	const caseConcurrency = resolveOptionalRuntimeTaskConcurrency(taskConcurrency?.case ?? project.concurrency?.case, options.caseConcurrency);
+	if (attempt == null && caseConcurrency == null) return;
+	return {
+		attempt,
+		case: caseConcurrency
+	};
+}
+function createScheduledTaskWithRuntimeConcurrency(task, project, options) {
+	const taskDefinition = task.entry.task;
+	if (taskDefinition == null) return task;
+	const concurrency = resolveRuntimeTaskConcurrency(taskDefinition.concurrency, project, options);
+	return {
+		...task,
+		entry: {
+			...task.entry,
+			task: {
+				...taskDefinition,
+				concurrency
+			}
+		}
+	};
+}
+function resolveCliRuntimeConcurrency(options) {
+	if (options.attemptConcurrency == null && options.caseConcurrency == null) return;
+	return {
+		attempt: options.attemptConcurrency,
+		case: options.caseConcurrency
+	};
+}
+function shouldUseColor() {
+	if (process.env.NO_COLOR != null) return false;
+	const forceColor = process.env.FORCE_COLOR;
+	if (forceColor != null) return forceColor !== "0";
+	return process.stdout.isTTY === true;
+}
+function createColorPalette(enabled) {
 	if (!enabled) return {
 		black: (value) => value,
 		bgCyan: (value) => value,
@@ -1094,11 +1874,15 @@ function createProjectBadge(name, colors, colorEnabled) {
 	const background = labelColorPool[name.split("").reduce((accumulator, char, index) => accumulator + char.charCodeAt(0) + index, 0) % labelColorPool.length];
 	return `${colors.black(background(` ${name} `))} `;
 }
-function formatDuration(durationMs, colors) {
+function formatDuration$1(durationMs, colors) {
 	if (durationMs == null) return "";
 	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);
@@ -1119,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();
@@ -1220,6 +1999,7 @@ function isSummaryReporter(reporter) {
 	return "getWindowRows" in reporter;
 }
 function createRunReporter(options) {
+	const getRows = options?.getRows ?? (() => process.stdout.rows);
 	const reporter = createCliReporter({
 		getColumns: options?.getColumns ?? (() => process.stdout.columns ?? 80),
 		getNow: options?.getNow ?? (() => Date.now()),
@@ -1240,7 +2020,7 @@ function createRunReporter(options) {
 	};
 	const rendererBaseOptions = {
 		getColumns: options?.getColumns ?? (() => process.stdout.columns ?? 80),
-		getWindow: () => reporter.getWindowRows(),
+		getWindow: () => reporter.getWindowRows({ maxRows: normalizeLiveReporterMaxRows(getRows()) }),
 		queueRenderReset: options?.queueRenderReset,
 		supportsAnsiWindowing: options?.supportsAnsiWindowing,
 		writeOutput: options?.writeOutput ?? ((value) => process.stdout.write(value))
@@ -1289,6 +2069,22 @@ function createRunReporter(options) {
 		}
 	};
 }
+/**
+* Normalizes terminal row count into the live reporter window height.
+*
+* Before:
+* - undefined
+* - 4
+* - 40
+*
+* After:
+* - 23
+* - 6
+* - 39
+*/
+function normalizeLiveReporterMaxRows(rows) {
+	return Math.max(6, (rows == null || !Number.isFinite(rows) || rows <= 0 ? 24 : Math.floor(rows)) - 1);
+}
 function createTaskQueuePayload(task, projectName) {
 	return {
 		displayName: task.entry.name,
@@ -1315,11 +2111,12 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 					projectCaseCounters.seenCaseIds.add(projectCaseId);
 					if (payload.state === "passed") projectCaseCounters.passed += 1;
 					else if (payload.state === "failed") projectCaseCounters.failed += 1;
+					else if (payload.state === "timeout") projectCaseCounters.timeout += 1;
 					else projectCaseCounters.skipped += 1;
 				}
 			}
 			syncCaseTotal(payload.total);
-			if (payload.state === "failed" && payload.errorMessage != null && projectCaseFailures != null) projectCaseFailures.push({
+			if ((payload.state === "failed" || payload.state === "timeout") && payload.errorMessage != null && projectCaseFailures != null) projectCaseFailures.push({
 				caseId,
 				caseName: payload.name,
 				errorMessage: payload.errorMessage,
@@ -1328,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
 			});
@@ -1342,8 +2140,11 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 			const caseId = createTaskCaseReporterId(payload);
 			syncCaseTotal(payload.total);
 			reporter.onCaseStart({
+				autoRetry: payload.autoRetry,
 				caseId,
+				input: payload.input,
 				caseName: payload.name,
+				retryIndex: payload.retryIndex,
 				taskId: task.id
 			});
 			vitestCompatReporter?.onCaseStart({
@@ -1360,7 +2161,7 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 		}
 	};
 }
-function createCliTaskExecutionContext(task, models, cacheRootDirectory, cacheProjectName, workspaceId, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter) {
+function createCliTaskExecutionContext(task, models, cacheRootDirectory, cacheProjectName, workspaceId, telemetry, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, runtimeConcurrency, vitestCompatReporter) {
 	return {
 		...createTaskExecutionContext({
 			cache: createFilesystemTaskCacheRuntime({
@@ -1371,7 +2172,9 @@ function createCliTaskExecutionContext(task, models, cacheRootDirectory, cachePr
 			models,
 			task
 		}),
-		reporterHooks: createTaskReporterHooks(task, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter)
+		reporterHooks: createTaskReporterHooks(task, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter),
+		runtimeConcurrency,
+		telemetry
 	};
 }
 function resolveTaskReporterHooks(task, context, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter) {
@@ -1389,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,
@@ -1492,13 +2296,14 @@ async function prepareProject(project) {
 		};
 	}
 }
-async function executePreparedProject(prepared, identity, cacheProjectName, reporter, counters, recordEvent) {
+async function executePreparedProject(prepared, identity, cacheProjectName, telemetry, reporter, counters, recordEvent, options) {
 	const settledTaskIds = /* @__PURE__ */ new Set();
 	const projectCaseCounters = {
 		failed: 0,
 		passed: 0,
 		seenCaseIds: /* @__PURE__ */ new Set(),
-		skipped: 0
+		skipped: 0,
+		timeout: 0
 	};
 	const projectCaseFailures = [];
 	const vitestCompatReporter = await createVievalVitestCompatReporterBridge({
@@ -1507,9 +2312,16 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 	});
 	const rawTaskExecutor = prepared.project.executor ?? createAutoTaskExecutor(reporter, prepared.name, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter);
 	const taskExecutor = async (task, context) => {
+		const runtimeTask = createScheduledTaskWithRuntimeConcurrency(task, prepared.project, options);
 		return {
-			...await rawTaskExecutor(task, context),
-			matrix: cloneScheduledTaskMatrix(task)
+			...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)
 		};
 	};
 	for (const task of prepared.tasks) await vitestCompatReporter?.onTaskQueued({ taskId: task.id });
@@ -1517,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, 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);
@@ -1538,7 +2350,8 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 			onTaskStart(task) {
 				reporter.onTaskStart({ taskId: task.id });
 				vitestCompatReporter?.onTaskStart({ taskId: task.id });
-			}
+			},
+			maxConcurrency: resolveScheduledTaskConcurrency(prepared.project, options)
 		});
 		await vitestCompatReporter?.onRunEnd({ failed: false });
 		return {
@@ -1546,6 +2359,7 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 				failed: projectCaseCounters.failed,
 				passed: projectCaseCounters.passed,
 				skipped: projectCaseCounters.skipped,
+				timeout: projectCaseCounters.timeout,
 				total: projectCaseCounters.seenCaseIds.size
 			},
 			caseFailures: projectCaseFailures,
@@ -1592,6 +2406,7 @@ async function executePreparedProject(prepared, identity, cacheProjectName, repo
 				failed: projectCaseCounters.failed,
 				passed: projectCaseCounters.passed,
 				skipped: projectCaseCounters.skipped,
+				timeout: projectCaseCounters.timeout,
 				total: projectCaseCounters.seenCaseIds.size
 			},
 			caseFailures: projectCaseFailures,
@@ -1607,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.
 *
@@ -1637,57 +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 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 = [];
-		for (const preparedProject of preparedProjects) {
-			if (preparedProject.kind === "summary") {
-				projectSummaries.push(preparedProject.summary);
-				continue;
-			}
-			projectSummaries.push(await executePreparedProject(preparedProject.prepared, identity, options.cacheProjectName, reporter, reporterCounters, eventRecorder.record));
-		}
-		reporter.onRunEnd({
-			failedTasks: reporterCounters.failedTasks,
-			passedTasks: reporterCounters.passedTasks,
-			skippedTasks: reporterCounters.skippedTasks + skippedSummaryTasks,
-			totalTasks
+		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
+			};
+			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
+			};
+			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.
@@ -1736,10 +2577,10 @@ function formatVievalCliRunOutput(output) {
 		executedTasks += project.result?.overall.runCount ?? 0;
 		const badge = createProjectBadge(project.name, colors, colorEnabled);
 		const isFailed = project.errorMessage != null;
-		const hasFailedCases = (project.caseSummary?.failed ?? 0) > 0 || (project.caseFailures?.length ?? 0) > 0;
+		const hasFailedCases = (project.caseSummary?.failed ?? 0) > 0 || (project.caseSummary?.timeout ?? 0) > 0 || (project.caseFailures?.length ?? 0) > 0;
 		if (isFailed) {
 			failedProjects += 1;
-			lines.push(` ${colors.red("❯")} ${badge}${formatDuration(project.durationMs, colors)}`);
+			lines.push(` ${colors.red("❯")} ${badge}${formatDuration$1(project.durationMs, colors)}`);
 			lines.push(`   ${project.errorMessage}`);
 			continue;
 		}
@@ -1748,7 +2589,7 @@ function formatVievalCliRunOutput(output) {
 			const countLabel = colors.dim(`(${project.taskCount} tasks)`);
 			const detailsLabel = colors.dim(` ${project.discoveredEvalFileCount} files, ${project.entryCount} entries, 0 runs, hybrid n/a`);
 			const matrixSummary = formatMatrixSummary(project.matrixSummary);
-			lines.push(` ${colors.dim("○")} ${badge}${countLabel}${detailsLabel}${formatDuration(project.durationMs, colors)}`);
+			lines.push(` ${colors.dim("○")} ${badge}${countLabel}${detailsLabel}${formatDuration$1(project.durationMs, colors)}`);
 			if (matrixSummary != null) lines.push(`   ${colors.dim(matrixSummary)}`);
 			const scheduleBreakdown = formatScheduleBreakdown(project);
 			if (scheduleBreakdown != null) lines.push(`   ${scheduleBreakdown}`);
@@ -1756,14 +2597,13 @@ 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`;
+		const caseSummaryLabel = project.caseSummary == null ? "" : `, cases ${project.caseSummary.passed} passed | ${project.caseSummary.failed} failed | ${project.caseSummary.timeout} timeout`;
 		const detailsLabel = colors.dim(` ${project.discoveredEvalFileCount} files, ${project.entryCount} entries, ${runCount} runs${caseSummaryLabel}, hybrid ${hybridAverageLabel}`);
 		const matrixSummary = formatMatrixSummary(project.matrixSummary);
-		lines.push(` ${hasFailedCases ? colors.red("❯") : colors.green("✓")} ${badge}${countLabel}${detailsLabel}${formatDuration(project.durationMs, colors)}`);
+		lines.push(` ${hasFailedCases ? colors.red("❯") : colors.green("✓")} ${badge}${countLabel}${detailsLabel}${formatDuration$1(project.durationMs, colors)}`);
 		if (matrixSummary != null) lines.push(`   ${colors.dim(matrixSummary)}`);
 		const scheduleBreakdown = formatScheduleBreakdown(project);
 		if (scheduleBreakdown != null) lines.push(`   ${scheduleBreakdown}`);
@@ -1800,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" },
@@ -1904,10 +2744,15 @@ const evalRunHelpText = `
     --workspace  Workspace id used in report artifacts
     --experiment Experiment id used in report artifacts
     --attempt    Attempt id used in report artifacts
+    --workspace-concurrency Workspace scheduling cap
+    --project-concurrency   Project scheduling cap
+    --task-concurrency      Task scheduling cap
+    --attempt-concurrency   Attempt scheduling cap
+    --case-concurrency      Case scheduling cap
     --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;
 }
@@ -1930,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" },
@@ -1945,17 +2790,27 @@ function parseCliArguments(argv) {
 			workspace: { type: "string" },
 			experiment: { type: "string" },
 			attempt: { type: "string" },
+			workspaceConcurrency: { type: "number" },
+			projectConcurrency: { type: "number" },
+			taskConcurrency: { type: "number" },
+			attemptConcurrency: { type: "number" },
+			caseConcurrency: { type: "number" },
 			reportOut: { type: "string" }
 		}
 	});
 	return {
 		attempt: cli.flags.attempt,
+		attemptConcurrency: cli.flags.attemptConcurrency,
+		caseConcurrency: cli.flags.caseConcurrency,
 		configFilePath: cli.flags.config,
 		experiment: cli.flags.experiment,
 		json: cli.flags.json === true,
 		project: normalizeProjectNames(cli.flags.project),
+		projectConcurrency: cli.flags.projectConcurrency,
 		reportOut: cli.flags.reportOut,
-		workspace: cli.flags.workspace
+		taskConcurrency: cli.flags.taskConcurrency,
+		workspace: cli.flags.workspace,
+		workspaceConcurrency: cli.flags.workspaceConcurrency
 	};
 }
 /**
@@ -1991,11 +2846,16 @@ async function runEvalRunCli(argv) {
 	try {
 		const output = await runVievalCli({
 			attempt: parsed.attempt,
+			attemptConcurrency: parsed.attemptConcurrency,
+			caseConcurrency: parsed.caseConcurrency,
 			configFilePath: parsed.configFilePath,
 			experiment: parsed.experiment,
 			project: parsed.project,
+			projectConcurrency: parsed.projectConcurrency,
 			reportOut: parsed.reportOut,
-			workspace: parsed.workspace
+			taskConcurrency: parsed.taskConcurrency,
+			workspace: parsed.workspace,
+			workspaceConcurrency: parsed.workspaceConcurrency
 		});
 		if (parsed.json) {
 			process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
@@ -2011,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.
@@ -2115,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);
@@ -2123,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" },
@@ -2412,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.
@@ -2579,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);
@@ -2590,4 +3842,4 @@ async function runTopLevelCli(argv) {
 //#endregion
 export { runTopLevelCli as n, parseTopLevelCliArguments as t };
 
-//# sourceMappingURL=cli-DayPXzHX.mjs.map
+//# sourceMappingURL=cli-ImxGpoYQ.mjs.map