@vitest-agent/ui 2.2.12 → 2.3.0

package/dispatcher/classify.js

@@ -36,7 +36,11 @@ const classifyRunShape = (state, projects) => {
 * run whose only non-passing signal is one or more timed-out tests
 * (`totals.timeoutCount > 0`, `totals.failCount === 0`) also
 * classifies as `some-fail` — timeouts are not passes, and must not
-* route to a passing cell (issue #224).
+* route to a passing cell (issue #224). A run whose only non-passing
+* signal is a process-level unhandled error (a non-empty
+* `unhandledErrors`, all counts otherwise clean) also classifies as `some-fail` —
+* a green-looking count must never hide an unhandled error behind an
+* all-pass cell (issue #240).
 *
 * @param state - the fully-reduced render state
 * @returns the outcome classification
@@ -44,6 +48,7 @@ const classifyRunShape = (state, projects) => {
 */
 const classifyOutcome = (state) => {
 	if (state.totals.failCount > 0) return "some-fail";
+	if (state.unhandledErrors.length > 0) return "some-fail";
 	if (state.totals.timeoutCount > 0) return "some-fail";
 	if (state.coverage !== null && state.coverage.violations.length > 0) return "threshold-violation";
 	return "all-pass";

package/dispatcher/dispatch.js

@@ -10,6 +10,9 @@ import { renderSingleTestThreshold } from "./cells/single-test-threshold.js";
 import { renderWorkspaceFail } from "./cells/workspace-fail.js";
 import { renderWorkspacePass } from "./cells/workspace-pass.js";
 import { renderWorkspaceThreshold } from "./cells/workspace-threshold.js";
+import { formatScopedCoverageNote } from "@vitest-agent/sdk";
+import { Box, Text } from "ink";
+import { createElement } from "react";
 
 //#region src/dispatcher/dispatch.ts
 /**
@@ -51,7 +54,24 @@ const dispatcherTable = {
 * @public
 */
 const dispatch = (inputs, opts) => {
-	return dispatcherTable[inputs.shape][inputs.outcome].agent(inputs, opts);
+	const body = dispatcherTable[inputs.shape][inputs.outcome].agent(inputs, opts);
+	const note = scopedCoverageNoteFor(inputs);
+	return note !== null ? `${body}\n${note}` : body;
+};
+/**
+* Build the scoped-coverage note for this run, or `null` on a full
+* (non-scoped) run. Shared by {@link dispatch} and {@link dispatchInk} so
+* both render paths surface the same information (issue #160 gap 1) —
+* Vitest's coverage thresholds are meaningless against a subset of the
+* project's test files, so every cell's own threshold-flavored coverage
+* text is followed by an explanation of why to disregard it.
+*
+* @internal
+*/
+const scopedCoverageNoteFor = (inputs) => {
+	const cov = inputs.state.coverage;
+	if (cov === null || cov.scoped !== true) return null;
+	return formatScopedCoverageNote(cov.scopedFiles ?? 0, cov.totalFiles);
 };
 /**
 * Dispatch to the cell that matches `(inputs.shape, inputs.outcome)`
@@ -66,7 +86,11 @@ const dispatch = (inputs, opts) => {
 */
 const dispatchInk = (inputs, opts) => {
 	const cell = dispatcherTable[inputs.shape][inputs.outcome];
-	return cell.ink !== void 0 ? cell.ink(inputs, opts) : null;
+	if (cell.ink === void 0) return null;
+	const element = cell.ink(inputs, opts);
+	const note = scopedCoverageNoteFor(inputs);
+	if (note === null) return element;
+	return createElement(Box, { flexDirection: "column" }, element, createElement(Text, null, note));
 };
 
 //#endregion

package/dispatcher/helpers.js

@@ -102,9 +102,13 @@ const formatTrendLine = (trend) => {
 * project carrying failures or violations.
 */
 const formatProjectRow = (project, nameWidth) => {
-	const total = project.passCount + project.failCount + project.skipCount;
-	const glyph = project.failCount > 0 ? "✗" : "✓";
-	const counts = project.failCount > 0 ? `${project.passCount}/${total} passed, ${project.failCount} failed` : `${project.passCount} passed`;
+	const timeoutCount = project.timeoutCount ?? 0;
+	const total = project.passCount + project.failCount + project.skipCount + timeoutCount;
+	const glyph = project.failCount > 0 || timeoutCount > 0 ? "✗" : "✓";
+	const countParts = [`${project.passCount}/${total} passed`];
+	if (project.failCount > 0) countParts.push(`${project.failCount} failed`);
+	if (timeoutCount > 0) countParts.push(`${timeoutCount} timed out`);
+	const counts = project.failCount > 0 || timeoutCount > 0 ? countParts.join(", ") : `${project.passCount} passed`;
 	const tagSuffix = formatTagCountSuffix(project.tagCounts);
 	const base = `  ${glyph} ${project.name.padEnd(nameWidth)} ${counts} (${formatDisplayDuration(project.durationMs)})`;
 	return tagSuffix.length === 0 ? base : `${base}  ${tagSuffix}`;
@@ -132,36 +136,46 @@ const formatWorkspaceTotal = (projects) => {
 	let pass = 0;
 	let fail = 0;
 	let skip = 0;
+	let timeout = 0;
 	let durationMs = 0;
 	for (const p of projects) {
 		pass += p.passCount;
 		fail += p.failCount;
 		skip += p.skipCount;
+		timeout += p.timeoutCount ?? 0;
 		durationMs += p.durationMs;
 	}
-	const total = pass + fail + skip;
+	const total = pass + fail + skip + timeout;
 	const parts = [`${pass}/${total} passed`];
 	if (fail > 0) parts.push(`${fail} failed`);
+	if (timeout > 0) parts.push(`${timeout} timed out`);
 	if (skip > 0) parts.push(`${skip} skipped`);
 	return `Total: ${parts.join(", ")} (${formatDisplayDuration(durationMs)})`;
 };
-const TABLE_COL_FILE = 60;
+const TABLE_COL_FILE_MIN = 60;
 /**
 * Format the `Files below aspirational target:` block — a pipe-delimited
 * table truncated to the first `limit` files with a "+N more" suffix.
 * Returns an empty array when `belowTarget` is empty.
+*
+* The file column is sized to the longest path among the printed rows
+* (never narrower than {@link TABLE_COL_FILE_MIN}), so a printed path is
+* never truncated (issue #237 follow-up) — only the omitted rows (past
+* `limit`) are unaffected, since their width never entered the
+* calculation.
 */
 const formatBelowTargetTable = (belowTarget, limit) => {
 	if (belowTarget.length === 0) return [];
 	const top = belowTarget.slice(0, limit);
 	const omitted = belowTarget.length - top.length;
+	const fileColWidth = Math.max(TABLE_COL_FILE_MIN, ...top.map((f) => f.file.length + 2));
 	const header = [
 		"Files below aspirational target:",
-		buildTableSeparator(),
-		buildTableHeader(),
-		buildTableSeparator()
+		buildTableSeparator(fileColWidth),
+		buildTableHeader(fileColWidth),
+		buildTableSeparator(fileColWidth)
 	];
-	const rows = top.map((file) => buildTableRow(file));
+	const rows = top.map((file) => buildTableRow(file, fileColWidth));
 	const footer = [];
 	if (omitted > 0) footer.push(`… ${omitted} more (use the test_coverage MCP tool for the full list)`);
 	return [
@@ -170,14 +184,14 @@ const formatBelowTargetTable = (belowTarget, limit) => {
 		...footer
 	];
 };
-const buildTableSeparator = () => {
-	return `${"-".repeat(TABLE_COL_FILE)}|---------|---------|---------|---------|-------------------`;
+const buildTableSeparator = (fileColWidth) => {
+	return `${"-".repeat(fileColWidth)}|---------|---------|---------|---------|-------------------`;
 };
-const buildTableHeader = () => {
-	return ` ${"File".padEnd(59)}| % Stmts | % Branch| % Funcs | % Lines | Uncovered Line #s`;
+const buildTableHeader = (fileColWidth) => {
+	return ` ${"File".padEnd(fileColWidth - 1)}| % Stmts | % Branch| % Funcs | % Lines | Uncovered Line #s`;
 };
-const buildTableRow = (file) => {
-	return `${` ${truncate(file.file, 58).padEnd(59)}`}|${pctCell(file.summary.statements)}|${pctCell(file.summary.branches)}|${pctCell(file.summary.functions)}|${pctCell(file.summary.lines)}|${` ${file.uncoveredLines}`}`;
+const buildTableRow = (file, fileColWidth) => {
+	return `${` ${file.file.padEnd(fileColWidth - 1)}`}|${pctCell(file.summary.statements)}|${pctCell(file.summary.branches)}|${pctCell(file.summary.functions)}|${pctCell(file.summary.lines)}|${` ${file.uncoveredLines}`}`;
 };
 const pctCell = (n) => {
 	const text = `${Math.round(n)}`;

package/index.d.ts

@@ -154,6 +154,9 @@ declare const CoverageRenderState: Schema.Struct<{
     readonly expected: Schema.Number;
     readonly actual: Schema.Number;
   }>>;
+  readonly scoped: Schema.optional<Schema.Boolean>;
+  readonly scopedFiles: Schema.optional<Schema.Number>;
+  readonly totalFiles: Schema.optional<Schema.Number>;
 }>;
 /** @public */
 type CoverageRenderState = typeof CoverageRenderState.Type;
@@ -272,6 +275,9 @@ declare const RenderState: Schema.Struct<{
       readonly expected: Schema.Number;
       readonly actual: Schema.Number;
     }>>;
+    readonly scoped: Schema.optional<Schema.Boolean>;
+    readonly scopedFiles: Schema.optional<Schema.Number>;
+    readonly totalFiles: Schema.optional<Schema.Number>;
   }>>;
   readonly trend: Schema.NullOr<Schema.Struct<{
     readonly direction: Schema.Literals<readonly ["improving", "regressing", "stable"]>;
@@ -307,6 +313,19 @@ declare const RenderState: Schema.Struct<{
    * fixtures) falls back to `moduleOrder.length`.
    */
   readonly collectedModules: Schema.optional<Schema.Number>;
+  /**
+   * Process-level errors with no owning module, folded from
+   * `RunFinished.unhandledErrors`. A run that never carried the field
+   * (older replay data, hand-built fixtures) defaults to `[]`. See
+   * issue #240.
+   */
+  readonly unhandledErrors: Schema.$Array<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly received: Schema.optional<Schema.String>;
+  }>>;
 }>;
 /** @public */
 type RenderState = typeof RenderState.Type;
@@ -356,6 +375,7 @@ interface ProjectSummary {
   readonly failCount: number;
   readonly skipCount: number;
   readonly durationMs: number;
+  readonly timeoutCount?: number;
   readonly tagCounts?: Record<string, number>;
   readonly belowTarget?: number;
   readonly violations?: number;
@@ -549,6 +569,7 @@ declare const AgentReport: Schema.Struct<{
     }>>;
     readonly scoped: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
     readonly scopedFiles: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly totalFiles: Schema.optional<Schema.Number>;
     readonly lowCoverage: Schema.$Array<Schema.Struct<{
       readonly file: Schema.String;
       readonly summary: Schema.Struct<{
@@ -587,6 +608,10 @@ declare const AgentReport: Schema.Struct<{
       readonly sample: Schema.optional<Schema.String>;
     }>>;
     readonly truncated: Schema.optional<Schema.Boolean>;
+    readonly fromFailingTests: Schema.optional<Schema.Struct<{
+      readonly total: Schema.Number;
+      readonly files: Schema.Number;
+    }>>;
   }>>;
 }>;
 /** @public */
@@ -758,6 +783,9 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
     }>;
     readonly uncoveredLines: Schema.optional<Schema.String>;
   }>>;
+  readonly scoped: Schema.optional<Schema.Boolean>;
+  readonly scopedFiles: Schema.optional<Schema.Number>;
+  readonly totalFiles: Schema.optional<Schema.Number>;
 }>, Schema.TaggedStruct<"ThresholdViolation", {
   readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
   readonly expected: Schema.Number;
@@ -787,6 +815,19 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
    * tracks failing modules (report replay). See issue #204.
    */
   readonly collectedModules: Schema.optional<Schema.Number>;
+  /**
+   * Process-level errors with no owning module (an unhandled
+   * rejection, a worker crash) — Vitest's `unhandledErrors`
+   * argument to `onTestRunEnd`. Optional so hand-built fixtures
+   * and older replay data keep decoding. See issue #240.
+   */
+  readonly unhandledErrors: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly received: Schema.optional<Schema.String>;
+  }>>>;
 }>]>;
 /** @public */
 type RunEvent = typeof RunEvent.Type;
@@ -1014,7 +1055,11 @@ declare const classifyRunShape: (state: RenderState, projects: ReadonlyArray<Pro
  * run whose only non-passing signal is one or more timed-out tests
  * (`totals.timeoutCount > 0`, `totals.failCount === 0`) also
  * classifies as `some-fail` — timeouts are not passes, and must not
- * route to a passing cell (issue #224).
+ * route to a passing cell (issue #224). A run whose only non-passing
+ * signal is a process-level unhandled error (a non-empty
+ * `unhandledErrors`, all counts otherwise clean) also classifies as `some-fail` —
+ * a green-looking count must never hide an unhandled error behind an
+ * all-pass cell (issue #240).
  *
  * @param state - the fully-reduced render state
  * @returns the outcome classification
@@ -1247,6 +1292,9 @@ declare const RunEventChannel_base: Context.ServiceClass<RunEventChannel, "vites
     };
     readonly uncoveredLines?: string | undefined;
   }[];
+  readonly scoped?: boolean | undefined;
+  readonly scopedFiles?: number | undefined;
+  readonly totalFiles?: number | undefined;
 } | {
   readonly _tag: "ThresholdViolation";
   readonly metric: "branches" | "functions" | "lines" | "statements";
@@ -1273,6 +1321,13 @@ declare const RunEventChannel_base: Context.ServiceClass<RunEventChannel, "vites
   readonly durationMs: number;
   readonly timeoutCount?: number | undefined;
   readonly collectedModules?: number | undefined;
+  readonly unhandledErrors?: readonly {
+    readonly message: string;
+    readonly stack?: string | undefined;
+    readonly diff?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: string | undefined;
+  }[] | undefined;
 }>>;
 /**
  * Service tag for the run-event channel. Consumers depend on this tag;
@@ -1833,6 +1888,12 @@ interface SynthesizedCoverage {
     readonly expected: number;
     readonly actual: number;
   }>;
+  /** Set when this run's coverage was scoped to a subset of test files (issue #160). */
+  readonly scoped?: boolean;
+  /** Number of test files actually run, when `scoped` is true. */
+  readonly scopedFiles?: number;
+  /** Total test-file count for the project, when known. */
+  readonly totalFiles?: number;
 }
 /**
  * Project a fully-completed Vitest run into the canonical

package/index.js

@@ -33,7 +33,7 @@ import { ActionSeverity, CoverageFile, CoverageGap, CoverageMetric, CoverageRend
 *
 * @public
 */
-const CURRENT_UI_VERSION = "2.2.12";
+const CURRENT_UI_VERSION = "2.3.0";
 
 //#endregion
 export { ActionSeverity, CURRENT_UI_VERSION, CountColumns, CoverageBlock, CoverageFile, CoverageGap, CoverageMetric, CoverageRenderState, DURATION_CELL_WIDTH, FailureRecord, FailureSection, FailuresSection, ModuleHeader, ModuleRecord, ProjectRow, RenderState, RenderTotals, RunEvent, RunEventChannel, RunEventChannelLive, SPINNER_FRAMES, SPINNER_FRAME_MS, SUITE_LOAD_FAILURE_LABEL, StatusIcon, StreamApp, SuggestedActionRecord, SuggestedActions, TagColumns, TestRecord, TestRow, TrendLine, accumulateUntilFinished, buildFooter, classifyOutcome, classifyRunShape, dispatch, dispatchInk, dispatcherTable, dominantClassification, forEachRenderState, formatDisplayDuration, initialRenderState, publish, publishAll, reduceRenderState, reduceRenderStateAll, renderAgent, renderStateStream, spinnerFrame, spinnerFrameForTime, subscribeRaw, synthesizeFromAgentReport, synthesizeRunEvents, tagUnion };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/ui",
-	"version": "2.2.12",
+	"version": "2.3.0",
 	"private": false,
 	"description": "Shared event-sourced renderer for vitest-agent. React Ink view for humans, plain-string view for agents, both fed by the same reducer over a RunEvent stream.",
 	"keywords": [
@@ -39,7 +39,7 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@vitest-agent/sdk": "2.4.12",
+		"@vitest-agent/sdk": "2.5.0",
 		"effect": "4.0.0-rc.109"
 	},
 	"peerDependencies": {

package/reducer.js

@@ -175,7 +175,10 @@ const reduceRenderState = (state, event) => {
 				metrics: e.metrics,
 				thresholds: e.thresholds,
 				gaps: e.gaps,
-				violations: state.coverage?.violations ?? []
+				violations: state.coverage?.violations ?? [],
+				...e.scoped !== void 0 ? { scoped: e.scoped } : {},
+				...e.scopedFiles !== void 0 ? { scopedFiles: e.scopedFiles } : {},
+				...e.totalFiles !== void 0 ? { totalFiles: e.totalFiles } : {}
 			}
 		}),
 		ThresholdViolation: (e) => {
@@ -219,7 +222,8 @@ const reduceRenderState = (state, event) => {
 				timeoutCount: e.timeoutCount ?? state.totals.timeoutCount,
 				durationMs: e.durationMs
 			},
-			...e.collectedModules !== void 0 && { collectedModules: e.collectedModules }
+			...e.collectedModules !== void 0 && { collectedModules: e.collectedModules },
+			...e.unhandledErrors !== void 0 && { unhandledErrors: e.unhandledErrors }
 		}),
 		RunTimedOut: () => ({
 			...state,

package/render-agent.js

@@ -14,6 +14,10 @@ const formatHeader = (state) => {
 	if (failCount > 0) parts.push(`${failCount} failed`);
 	if (timeoutCount > 0) parts.push(`${timeoutCount} timed out`);
 	if (skipCount > 0) parts.push(`${skipCount} skipped`);
+	if (state.unhandledErrors.length > 0) {
+		const noun = state.unhandledErrors.length === 1 ? "unhandled error" : "unhandled errors";
+		parts.push(`${state.unhandledErrors.length} ${noun}`);
+	}
 	return `Tests: ${parts.join(", ")} (${formatDisplayDuration(durationMs)})`;
 };
 const formatModulesSection = (state) => {
@@ -61,6 +65,18 @@ const formatFailuresSection = (state, width, includeStack) => {
 	for (const f of state.failures) lines.push(formatFailure(f, width, includeStack));
 	return lines.join("\n");
 };
+const formatUnhandledError = (err, width, includeStack) => {
+	const firstLine = err.message.split("\n", 1)[0] ?? "";
+	const lines = [`- ${truncate(firstLine, Math.max(20, width - 2))}`];
+	if (includeStack && err.stack !== void 0) for (const stackLine of err.stack.split("\n")) lines.push(`  ${truncate(stackLine, Math.max(20, width - 2))}`);
+	return lines.join("\n");
+};
+const formatUnhandledErrorsSection = (state, width, includeStack) => {
+	if (state.unhandledErrors.length === 0) return null;
+	const lines = ["Unhandled errors:"];
+	for (const err of state.unhandledErrors) lines.push(formatUnhandledError(err, width, includeStack));
+	return lines.join("\n");
+};
 const formatPercent = (n) => {
 	const rounded = Math.round(n * 10) / 10;
 	return Number.isInteger(rounded) ? `${rounded}%` : `${rounded}%`;
@@ -128,6 +144,8 @@ const renderAgent = (state, options = {}) => {
 	const sections = [formatHeader(state)];
 	const failures = formatFailuresSection(state, width, includeStack);
 	if (failures !== null) sections.push(failures);
+	const unhandledErrors = formatUnhandledErrorsSection(state, width, includeStack);
+	if (unhandledErrors !== null) sections.push(unhandledErrors);
 	const modules = formatModulesSection(state);
 	if (modules !== null) sections.push(modules);
 	const coverage = formatCoverageSection(state, maxGaps);

package/render-ink/StreamApp.js

@@ -58,6 +58,21 @@ const sumCounts = (modules) => {
 		timeoutCount
 	};
 };
+/**
+* Build a `ProjectSummary` from a project's name and its rolled-up
+* counts. Includes `timeoutCount` only when nonzero, matching
+* `summarizeProject`'s convention in `@vitest-agent/reporter` (issue #242).
+*
+* @public
+*/
+const buildProjectSummary = (name, counts) => ({
+	name,
+	passCount: counts.passCount,
+	failCount: counts.failCount,
+	skipCount: counts.skipCount,
+	durationMs: 0,
+	...counts.timeoutCount > 0 ? { timeoutCount: counts.timeoutCount } : {}
+});
 const mergeTagCounts = (modules) => {
 	const out = {};
 	for (const m of modules) for (const [tag, count] of Object.entries(m.tagCounts ?? {})) out[tag] = (out[tag] ?? 0) + count;
@@ -166,6 +181,21 @@ const InlineError = ({ failure }) => {
 	});
 };
 const failureKey = (f) => `failure:${f.modulePath}::${f.suitePath.join("/")}::${f.testName}`;
+/** A process-level unhandled error, rendered in the aggregate Unhandled errors block. */
+const UnhandledErrorItem = ({ error }) => /* @__PURE__ */ jsxs(Box, {
+	flexDirection: "column",
+	children: [/* @__PURE__ */ jsxs(Text, { children: [
+		"  ",
+		/* @__PURE__ */ jsx(Text, {
+			color: "red",
+			children: "✗"
+		}),
+		" unhandled error"
+	] }), /* @__PURE__ */ jsxs(Text, {
+		dimColor: true,
+		children: ["      ", error.message.split("\n", 1)[0] ?? ""]
+	})]
+});
 const testKey = (modulePath, t) => `test:${modulePath}::${t.suitePath.join("/")}::${t.testName}`;
 const failurePath = (f) => [
 	f.modulePath,
@@ -248,6 +278,13 @@ const liveRegion = (state, shape, nowMs, frame) => {
 	const timedOut = state.phase === "timed-out";
 	const finished = state.phase === "finished" || state.phase === "timed-out";
 	const ordered = state.moduleOrder.map((p) => state.modules[p]).filter((m) => m !== void 0);
+	const unhandledErrorsSection = state.unhandledErrors.length > 0 ? /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Unhandled errors:"
+		}), state.unhandledErrors.map((err, i) => /* @__PURE__ */ jsx(UnhandledErrorItem, { error: err }, `unhandled:${i}:${err.message}`))]
+	}) : null;
 	if (shape === "single-test") {
 		const sole = ordered[0];
 		if (sole === void 0 || sole.tests.length === 0) return /* @__PURE__ */ jsx(Text, {
@@ -260,10 +297,14 @@ const liveRegion = (state, shape, nowMs, frame) => {
 			children: "discovering tests…"
 		});
 		const failure = only.status === "failed" || only.status === "timed-out" ? state.failures.find((f) => f.testName === only.testName && f.modulePath === sole.modulePath && samePath(f.suitePath, only.suitePath)) : void 0;
-		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(TestRow, {
-			test: only,
-			indent: 0
-		}), failure !== void 0 ? /* @__PURE__ */ jsx(InlineError, { failure }) : null] });
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsx(TestRow, {
+				test: only,
+				indent: 0
+			}),
+			failure !== void 0 ? /* @__PURE__ */ jsx(InlineError, { failure }) : null,
+			unhandledErrorsSection
+		] });
 	}
 	if (groups.length === 0) return /* @__PURE__ */ jsx(Text, {
 		dimColor: true,
@@ -297,13 +338,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 			if (runningVisible < MAX_LIVE_RUNNING_ROWS) {
 				runningVisible++;
 				const counts = sumCounts(g.modules);
-				const summary = {
-					name: g.name,
-					passCount: counts.passCount,
-					failCount: counts.failCount,
-					skipCount: counts.skipCount,
-					durationMs: 0
-				};
+				const summary = buildProjectSummary(g.name, counts);
 				rows.push(/* @__PURE__ */ jsx(ProjectRow, {
 					project: summary,
 					counts,
@@ -318,13 +353,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 			} else runningOverflow++;
 		} else {
 			const counts = sumCounts(g.modules);
-			const summary = {
-				name: g.name,
-				passCount: counts.passCount,
-				failCount: counts.failCount,
-				skipCount: counts.skipCount,
-				durationMs: 0
-			};
+			const summary = buildProjectSummary(g.name, counts);
 			rows.push(/* @__PURE__ */ jsx(ProjectRow, {
 				project: summary,
 				counts,
@@ -356,6 +385,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 				]
 			}) : null,
 			failuresSection,
+			unhandledErrorsSection,
 			coverageItem,
 			trendItem,
 			totalsItem(nameWidth + 4)
@@ -406,6 +436,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 				]
 			}) : null,
 			failuresSection,
+			unhandledErrorsSection,
 			coverageItem,
 			trendItem,
 			totalsItem()
@@ -438,6 +469,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 				}), failure !== void 0 ? /* @__PURE__ */ jsx(InlineError, { failure }) : null]
 			}, testKey(sole.modulePath, t));
 		}),
+		unhandledErrorsSection,
 		coverageItem,
 		trendItem,
 		totalsItem()
@@ -452,16 +484,7 @@ const liveRegion = (state, shape, nowMs, frame) => {
 const StreamApp = ({ state, frameIndex, nowMs }) => {
 	const now = nowMs ?? Date.now();
 	const frame = spinnerFrame(frameIndex);
-	const projects = groupByProject(state).map((g) => {
-		const c = sumCounts(g.modules);
-		return {
-			name: g.name,
-			passCount: c.passCount,
-			failCount: c.failCount,
-			skipCount: c.skipCount,
-			durationMs: 0
-		};
-	});
+	const projects = groupByProject(state).map((g) => buildProjectSummary(g.name, sumCounts(g.modules)));
 	const shape = classifyRunShape(state, projects);
 	const liveContent = liveRegion(state, shape, now, frame);
 	return /* @__PURE__ */ jsx(Box, {
@@ -471,4 +494,4 @@ const StreamApp = ({ state, frameIndex, nowMs }) => {
 };
 
 //#endregion
-export { StreamApp };
+export { StreamApp, buildProjectSummary };

package/synthesize.js

@@ -147,7 +147,10 @@ const synthesizeRunEvents = (modules, options = {}) => {
 			_tag: "CoverageReady",
 			metrics: cov.metrics,
 			thresholds: cov.thresholds,
-			gaps: cov.gaps
+			gaps: cov.gaps,
+			...cov.scoped !== void 0 ? { scoped: cov.scoped } : {},
+			...cov.scopedFiles !== void 0 ? { scopedFiles: cov.scopedFiles } : {},
+			...cov.totalFiles !== void 0 ? { totalFiles: cov.totalFiles } : {}
 		});
 		if (cov.violations !== void 0) for (const v of cov.violations) events.push({
 			_tag: "ThresholdViolation",
@@ -189,7 +192,7 @@ const coverageReportToBlock = (report) => {
 	const cov = report.coverage;
 	if (cov === void 0) return void 0;
 	const violations = [];
-	for (const metric of [
+	if (!cov.scoped) for (const metric of [
 		"lines",
 		"branches",
 		"functions",
@@ -212,7 +215,10 @@ const coverageReportToBlock = (report) => {
 		metrics: cov.totals,
 		thresholds: cov.thresholds.global,
 		gaps,
-		violations
+		violations,
+		...cov.scoped ? { scoped: cov.scoped } : {},
+		...cov.scopedFiles !== void 0 ? { scopedFiles: cov.scopedFiles.length } : {},
+		...cov.totalFiles !== void 0 ? { totalFiles: cov.totalFiles } : {}
 	};
 };
 /**
@@ -331,7 +337,10 @@ const synthesizeFromAgentReport = (report, options = {}) => {
 			_tag: "CoverageReady",
 			metrics: coverage.metrics,
 			thresholds: coverage.thresholds,
-			gaps: coverage.gaps
+			gaps: coverage.gaps,
+			...coverage.scoped !== void 0 ? { scoped: coverage.scoped } : {},
+			...coverage.scopedFiles !== void 0 ? { scopedFiles: coverage.scopedFiles } : {},
+			...coverage.totalFiles !== void 0 ? { totalFiles: coverage.totalFiles } : {}
 		});
 		if (coverage.violations !== void 0) for (const v of coverage.violations) events.push({
 			_tag: "ThresholdViolation",
@@ -362,7 +371,8 @@ const synthesizeFromAgentReport = (report, options = {}) => {
 		skipCount: report.summary.skipped,
 		durationMs: report.summary.duration,
 		...totalTimeoutCount > 0 && { timeoutCount: totalTimeoutCount },
-		...report.summary.modules !== void 0 && { collectedModules: report.summary.modules }
+		...report.summary.modules !== void 0 && { collectedModules: report.summary.modules },
+		...report.unhandledErrors.length > 0 && { unhandledErrors: report.unhandledErrors }
 	});
 	return events;
 };