vieval 0.0.5 → 0.0.6

package/dist/bin/vieval.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as runTopLevelCli } from "../cli-DayPXzHX.mjs";
+import { n as runTopLevelCli } from "../cli-sanbKtQq.mjs";
 import process from "node:process";
 import { errorMessageFrom } from "@moeru/std";
 //#region src/bin/vieval.ts

package/dist/cli/index.mjs

@@ -1,2 +1,2 @@
-import { n as runTopLevelCli, t as parseTopLevelCliArguments } from "../cli-DayPXzHX.mjs";
+import { n as runTopLevelCli, t as parseTopLevelCliArguments } from "../cli-sanbKtQq.mjs";
 export { parseTopLevelCliArguments, runTopLevelCli };

package/dist/{cli-DayPXzHX.mjs → cli-sanbKtQq.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 { c as loadRawVievalConfig, l as loadVievalCliConfig, n as consumeModuleRegistrations, o as detectCliConfigMode, r as endModuleRegistration, t as beginModuleRegistration } from "./registry-CcKZqDJY.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
@@ -378,12 +380,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 +431,10 @@ var SummaryReporterStateMachine = class {
 			this.caseCounters.failed += 1;
 			return;
 		}
+		if (payload.state === "timeout") {
+			this.caseCounters.timeout += 1;
+			return;
+		}
 		this.caseCounters.skipped += 1;
 	}
 	/**
@@ -500,39 +515,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 +591,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 +654,7 @@ function createCounterState() {
 		failed: 0,
 		passed: 0,
 		skipped: 0,
+		timeout: 0,
 		total: 0
 	};
 }
@@ -601,6 +663,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 +682,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 +737,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 +1123,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,10 +1170,61 @@ 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 resolveCappedConcurrency(defaultConcurrency, cliConcurrency, fallback) {
+	const effectiveDefault = defaultConcurrency ?? fallback;
+	if (cliConcurrency == null) return effectiveDefault;
+	return Math.min(effectiveDefault, cliConcurrency);
+}
+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;
@@ -1094,7 +1268,7 @@ 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")}`);
@@ -1220,6 +1394,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 +1415,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 +1464,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 +1506,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,
@@ -1342,8 +1534,10 @@ function createTaskReporterHooks(task, reporter, projectName, recordEvent, proje
 			const caseId = createTaskCaseReporterId(payload);
 			syncCaseTotal(payload.total);
 			reporter.onCaseStart({
+				autoRetry: payload.autoRetry,
 				caseId,
 				caseName: payload.name,
+				retryIndex: payload.retryIndex,
 				taskId: task.id
 			});
 			vitestCompatReporter?.onCaseStart({
@@ -1360,7 +1554,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, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, runtimeConcurrency, vitestCompatReporter) {
 	return {
 		...createTaskExecutionContext({
 			cache: createFilesystemTaskCacheRuntime({
@@ -1371,7 +1565,8 @@ 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
 	};
 }
 function resolveTaskReporterHooks(task, context, reporter, projectName, recordEvent, projectCaseCounters, projectCaseFailures, vitestCompatReporter) {
@@ -1492,13 +1687,14 @@ async function prepareProject(project) {
 		};
 	}
 }
-async function executePreparedProject(prepared, identity, cacheProjectName, reporter, counters, recordEvent) {
+async function executePreparedProject(prepared, identity, cacheProjectName, 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 +1703,10 @@ 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 rawTaskExecutor(runtimeTask, context),
+			matrix: cloneScheduledTaskMatrix(runtimeTask)
 		};
 	};
 	for (const task of prepared.tasks) await vitestCompatReporter?.onTaskQueued({ taskId: task.id });
@@ -1517,7 +1714,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, reporter, prepared.name, recordEvent, projectCaseCounters, projectCaseFailures, resolveCliRuntimeConcurrency(options), vitestCompatReporter);
 			},
 			onTaskEnd(task, state) {
 				settledTaskIds.add(task.id);
@@ -1538,7 +1735,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 +1744,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 +1791,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,
@@ -1642,6 +1842,7 @@ async function runVievalCli(options = {}) {
 	const reporter = createReporterWithEventCapture(createRunReporter(options.reporter), eventRecorder.record);
 	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) => {
@@ -1659,14 +1860,21 @@ async function runVievalCli(options = {}) {
 		};
 		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));
-		}
+		const projectSummaries = (await Promise.all(preparedProjects.map(async (preparedProject, index) => {
+			if (preparedProject.kind === "summary") return {
+				index,
+				summary: preparedProject.summary
+			};
+			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))
+			};
+		}))).sort((left, right) => left.index - right.index).map((item) => item.summary);
 		reporter.onRunEnd({
 			failedTasks: reporterCounters.failedTasks,
 			passedTasks: reporterCounters.passedTasks,
@@ -1736,10 +1944,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 +1956,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}`);
@@ -1760,10 +1968,10 @@ function formatVievalCliRunOutput(output) {
 		const hybridAverageLabel = hybridAverage == null ? "n/a" : String(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}`);
@@ -1904,6 +2112,11 @@ 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
 `;
@@ -1945,17 +2158,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 +2214,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`);
@@ -2590,4 +2818,4 @@ async function runTopLevelCli(argv) {
 //#endregion
 export { runTopLevelCli as n, parseTopLevelCliArguments as t };
 
-//# sourceMappingURL=cli-DayPXzHX.mjs.map
+//# sourceMappingURL=cli-sanbKtQq.mjs.map