@vitest-agent/ui 1.0.0

package/index.js

@@ -0,0 +1,40 @@
+import { classifyOutcome, classifyRunShape } from "./dispatcher/classify.js";
+import { buildFooter, dominantClassification } from "./dispatcher/footer.js";
+import { formatDisplayDuration } from "./format-duration.js";
+import { dispatch, dispatchInk, dispatcherTable } from "./dispatcher/dispatch.js";
+import { RunEventChannel, RunEventChannelLive } from "./pubsub/Channel.js";
+import { publish, publishAll } from "./pubsub/Publisher.js";
+import { reduceRenderState, reduceRenderStateAll } from "./reducer.js";
+import { accumulateUntilFinished, forEachRenderState, renderStateStream, subscribeRaw } from "./pubsub/Subscriber.js";
+import "./pubsub/index.js";
+import { renderAgent } from "./render-agent.js";
+import { CountColumns } from "./render-ink/CountColumns.js";
+import { CoverageBlock } from "./render-ink/CoverageBlock.js";
+import { FailureSection } from "./render-ink/FailureSection.js";
+import { FailuresSection } from "./render-ink/FailuresSection.js";
+import { StatusIcon } from "./render-ink/StatusIcon.js";
+import { ModuleHeader } from "./render-ink/ModuleHeader.js";
+import { ProjectRow } from "./render-ink/ProjectRow.js";
+import { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame, spinnerFrameForTime } from "./render-ink/spinner.js";
+import { TestRow } from "./render-ink/TestRow.js";
+import { TrendLine } from "./render-ink/TrendLine.js";
+import { StreamApp } from "./render-ink/StreamApp.js";
+import { SuggestedActions } from "./render-ink/SuggestedActions.js";
+import "./render-ink/index.js";
+import { synthesizeFromAgentReport, synthesizeRunEvents } from "./synthesize.js";
+import { ActionSeverity, CoverageFile, CoverageGap, CoverageMetric, CoverageRenderState, FailureRecord, ModuleRecord, RenderState, RenderTotals, RunEvent, SuggestedActionRecord, TestRecord, initialRenderState } from "@vitest-agent/sdk";
+
+//#region src/index.ts
+/**
+* The version of this package, inlined at build time from
+* `package.json#version` via rslib-builder's `__PACKAGE_VERSION__`
+* substitution. The UI package is consumed through the plugin so it does not
+* run its own init-time drift check, but the constant is exported so the
+* plugin can compare against it.
+*
+* @public
+*/
+const CURRENT_UI_VERSION = "1.0.0";
+
+//#endregion
+export { ActionSeverity, CURRENT_UI_VERSION, CountColumns, CoverageBlock, CoverageFile, CoverageGap, CoverageMetric, CoverageRenderState, FailureRecord, FailureSection, FailuresSection, ModuleHeader, ModuleRecord, ProjectRow, RenderState, RenderTotals, RunEvent, RunEventChannel, RunEventChannelLive, SPINNER_FRAMES, SPINNER_FRAME_MS, StatusIcon, StreamApp, SuggestedActionRecord, SuggestedActions, 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 };

package/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "@vitest-agent/ui",
+	"version": "1.0.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": [
+		"vitest",
+		"ui",
+		"ink",
+		"react",
+		"llm",
+		"ai",
+		"agent",
+		"testing",
+		"coverage"
+	],
+	"homepage": "https://github.com/spencerbeggs/vitest-agent#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/vitest-agent/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/vitest-agent.git",
+		"directory": "packages/ui"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@vitest-agent/sdk": "1.0.0",
+		"effect": "^3.21.4"
+	},
+	"peerDependencies": {
+		"ink": "^7.1.0",
+		"react": "^19.2.0"
+	},
+	"peerDependenciesMeta": {
+		"ink": {
+			"optional": false
+		},
+		"react": {
+			"optional": false
+		}
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/pubsub/Channel.js

@@ -0,0 +1,30 @@
+import { Context, Layer, PubSub } from "effect";
+
+//#region src/pubsub/Channel.ts
+/**
+* Service tag for the run-event channel. Consumers depend on this tag;
+* the {@link RunEventChannelLive} layer is the single point at which
+* the underlying Effect `PubSub` is constructed.
+*
+* @public
+*/
+var RunEventChannel = class extends Context.Tag("vitest-agent-ui/RunEventChannel")() {};
+/**
+* Default live layer providing an unbounded Effect `PubSub` for
+* the run-event channel. The PubSub is scoped — when the surrounding
+* scope closes, the channel shuts down and any pending subscribers
+* receive their dequeue closure.
+*
+* Unbounded is the right default for the plugin and CLI: events arrive
+* faster than a slow renderer can drain (e.g., several `TestFinished`
+* per millisecond during a large suite), and dropping events would
+* leave the rendered state inconsistent with the runner's truth.
+* If memory pressure becomes a concern, swap in `PubSub.sliding`
+* with a tuned capacity at the call site.
+*
+* @public
+*/
+const RunEventChannelLive = Layer.scoped(RunEventChannel, PubSub.unbounded());
+
+//#endregion
+export { RunEventChannel, RunEventChannelLive };

package/pubsub/Publisher.js

@@ -0,0 +1,37 @@
+import { RunEventChannel } from "./Channel.js";
+import { Effect, PubSub } from "effect";
+
+//#region src/pubsub/Publisher.ts
+/**
+* Emit one event onto the channel.
+*
+* Resolves when the event is enqueued. Returns the success boolean
+* from `PubSub.publish` so callers can detect a shutdown
+* channel if needed; in normal operation the result is always `true`.
+*
+* @param event - the run event to publish
+* @returns an Effect that resolves to the publish success boolean
+* @public
+*/
+const publish = (event) => Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	return yield* PubSub.publish(channel, event);
+});
+/**
+* Emit a batch of events onto the channel in order.
+*
+* Useful for the CLI replay path where the entire event sequence is
+* materialized synchronously from a database query before any
+* subscriber needs to read it.
+*
+* @param events - iterable of run events to publish in order
+* @returns an Effect that resolves when all events are enqueued
+* @public
+*/
+const publishAll = (events) => Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	yield* PubSub.publishAll(channel, events);
+});
+
+//#endregion
+export { publish, publishAll };

package/pubsub/Subscriber.js

@@ -0,0 +1,77 @@
+import { RunEventChannel } from "./Channel.js";
+import { reduceRenderState } from "../reducer.js";
+import { initialRenderState } from "@vitest-agent/sdk";
+import { Effect, PubSub, Queue, Stream } from "effect";
+
+//#region src/pubsub/Subscriber.ts
+/**
+* Subscribe, fold the run-event stream into a terminal
+* `RenderState`, and return when `RunFinished` arrives.
+*
+* The subscription is scoped — when this effect completes (or is
+* interrupted), the underlying PubSub releases its slot.
+*
+* @param initial - the initial render state to fold from
+* @returns an Effect that resolves to the terminal render state
+* @public
+*/
+const accumulateUntilFinished = (initial = initialRenderState) => Effect.scoped(Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	const dequeue = yield* PubSub.subscribe(channel);
+	let state = initial;
+	while (state.phase !== "finished" && state.phase !== "timed-out") {
+		const event = yield* Queue.take(dequeue);
+		state = reduceRenderState(state, event);
+	}
+	return state;
+}));
+/**
+* Run a callback for every projected `RenderState` as events
+* arrive. The stream terminates when the PubSub shuts down (typically
+* when the surrounding scope closes).
+*
+* The host runs this in a forked fiber so the publisher and the
+* renderer can make progress concurrently. Returning an Effect from
+* the callback lets the host suspend further rendering on backpressure
+* (e.g. throttling redraws to the next animation frame).
+*
+* @param onState - callback invoked with each projected render state
+* @param initial - the initial render state to fold from
+* @returns an Effect that completes when the PubSub shuts down
+* @public
+*/
+const forEachRenderState = (onState, initial = initialRenderState) => Effect.scoped(Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	yield* (yield* Stream.fromPubSub(channel, { scoped: true })).pipe(Stream.scan(initial, reduceRenderState), Stream.runForEach(onState));
+}));
+/**
+* Build an Effect `Stream` of accumulated states over the channel.
+*
+* Lower-level than {@link forEachRenderState} — useful when the host
+* wants to compose with other stream operators (debouncing, throttling,
+* tee-to-file) before running the terminal sink.
+*
+* @param initial - the initial render state to fold from
+* @returns an Effect that resolves to a Stream of render states
+* @public
+*/
+const renderStateStream = (initial = initialRenderState) => Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	return (yield* Stream.fromPubSub(channel, { scoped: true })).pipe(Stream.scan(initial, reduceRenderState));
+});
+/**
+* Convenience: subscribe and produce a low-level dequeue of raw
+* `RunEvent` values. Mostly for tests and ad-hoc consumers; most
+* application code should prefer {@link forEachRenderState} or
+* {@link renderStateStream}.
+*
+* @returns an Effect that resolves to a dequeue of raw run events
+* @public
+*/
+const subscribeRaw = () => Effect.gen(function* () {
+	const channel = yield* RunEventChannel;
+	return yield* PubSub.subscribe(channel);
+});
+
+//#endregion
+export { accumulateUntilFinished, forEachRenderState, renderStateStream, subscribeRaw };

package/pubsub/index.js

@@ -0,0 +1,5 @@
+import { RunEventChannel, RunEventChannelLive } from "./Channel.js";
+import { publish, publishAll } from "./Publisher.js";
+import { accumulateUntilFinished, forEachRenderState, renderStateStream, subscribeRaw } from "./Subscriber.js";
+
+export {  };

package/reducer.js

@@ -0,0 +1,260 @@
+import { initialRenderState } from "@vitest-agent/sdk";
+import { Match } from "effect";
+
+//#region src/reducer.ts
+const queuedModule = (modulePath, projectName) => ({
+	modulePath,
+	status: "queued",
+	passCount: 0,
+	failCount: 0,
+	skipCount: 0,
+	timeoutCount: 0,
+	durationMs: 0,
+	tests: [],
+	...projectName !== void 0 && { projectName }
+});
+const appendModuleIfNew = (state, modulePath, make) => {
+	if (state.modules[modulePath] !== void 0) return state;
+	return {
+		...state,
+		modules: {
+			...state.modules,
+			[modulePath]: make()
+		},
+		moduleOrder: [...state.moduleOrder, modulePath]
+	};
+};
+const updateModule = (state, modulePath, update) => {
+	const current = state.modules[modulePath];
+	if (current === void 0) {
+		const seeded = update(queuedModule(modulePath));
+		return {
+			...state,
+			modules: {
+				...state.modules,
+				[modulePath]: seeded
+			},
+			moduleOrder: [...state.moduleOrder, modulePath]
+		};
+	}
+	return {
+		...state,
+		modules: {
+			...state.modules,
+			[modulePath]: update(current)
+		}
+	};
+};
+const upsertTest = (module, testName, suitePath, patch) => {
+	const idx = module.tests.findIndex((t) => t.testName === testName && samePath(t.suitePath, suitePath));
+	const next = {
+		testName,
+		suitePath,
+		...patch
+	};
+	if (idx === -1) return {
+		...module,
+		tests: [...module.tests, next]
+	};
+	const tests = module.tests.slice();
+	tests[idx] = next;
+	return {
+		...module,
+		tests
+	};
+};
+const samePath = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+};
+const recomputeTotals = (modules) => {
+	let passCount = 0;
+	let failCount = 0;
+	let skipCount = 0;
+	let timeoutCount = 0;
+	let durationMs = 0;
+	for (const m of Object.values(modules)) {
+		passCount += m.passCount;
+		failCount += m.failCount;
+		skipCount += m.skipCount;
+		timeoutCount += m.timeoutCount;
+		durationMs += m.durationMs;
+	}
+	return {
+		passCount,
+		failCount,
+		skipCount,
+		timeoutCount,
+		durationMs
+	};
+};
+const upsertFailure = (failures, next) => {
+	const idx = failures.findIndex((f) => f.modulePath === next.modulePath && f.testName === next.testName && samePath(f.suitePath, next.suitePath));
+	if (idx === -1) return [...failures, next];
+	const out = failures.slice();
+	out[idx] = {
+		...failures[idx],
+		...next
+	};
+	return out;
+};
+/**
+* Apply a single event to the previous state and return the next.
+*
+* The function is pure: no I/O, no time, no randomness. Folding it
+* over an event sequence yields the same state regardless of when the
+* fold runs.
+*
+* @param state - the current render state
+* @param event - the run event to apply
+* @returns the next render state
+* @public
+*/
+const reduceRenderState = (state, event) => {
+	const noop = () => state;
+	return Match.value(event).pipe(Match.tagsExhaustive({
+		RunStarted: (e) => ({
+			...initialRenderState,
+			phase: "running",
+			runId: e.runId,
+			configHash: e.configHash,
+			startedAt: e.startedAt
+		}),
+		ModuleQueued: (e) => appendModuleIfNew(state, e.modulePath, () => queuedModule(e.modulePath, e.projectName)),
+		ModuleStarted: (e) => updateModule(state, e.modulePath, (m) => ({
+			...m,
+			status: "running",
+			startedAt: e.startedAt,
+			...e.projectName !== void 0 && { projectName: e.projectName }
+		})),
+		TestStarted: (e) => updateModule(state, e.modulePath, (m) => upsertTest(m, e.testName, e.suitePath, {
+			status: "running",
+			durationMs: null
+		})),
+		TestFinished: (e) => {
+			const status = e.timedOut === true ? "timed-out" : e.status;
+			const withTest = updateModule(state, e.modulePath, (m) => upsertTest(m, e.testName, e.suitePath, {
+				status,
+				durationMs: e.durationMs,
+				...e.error !== void 0 && { error: e.error }
+			}));
+			if (e.status !== "failed") return withTest;
+			return {
+				...withTest,
+				failures: upsertFailure(withTest.failures, {
+					modulePath: e.modulePath,
+					testName: e.testName,
+					suitePath: e.suitePath,
+					...e.error !== void 0 && { error: e.error },
+					...e.timedOut === true && { timedOut: true },
+					classification: null
+				})
+			};
+		},
+		ModuleFinished: (e) => {
+			const next = updateModule(state, e.modulePath, (m) => ({
+				...m,
+				status: "finished",
+				passCount: e.passCount,
+				failCount: e.failCount,
+				skipCount: e.skipCount,
+				timeoutCount: e.timeoutCount ?? 0,
+				durationMs: e.durationMs,
+				...e.projectName !== void 0 && { projectName: e.projectName },
+				...e.tagCounts !== void 0 && { tagCounts: e.tagCounts }
+			}));
+			return {
+				...next,
+				totals: recomputeTotals(next.modules)
+			};
+		},
+		CoverageReady: (e) => ({
+			...state,
+			coverage: {
+				metrics: e.metrics,
+				thresholds: e.thresholds,
+				gaps: e.gaps,
+				violations: state.coverage?.violations ?? []
+			}
+		}),
+		ThresholdViolation: (e) => {
+			if (state.coverage === null) return state;
+			return {
+				...state,
+				coverage: {
+					...state.coverage,
+					violations: [...state.coverage.violations, {
+						metric: e.metric,
+						expected: e.expected,
+						actual: e.actual
+					}]
+				}
+			};
+		},
+		FailureClassified: (e) => ({
+			...state,
+			failures: state.failures.map((f) => f.modulePath === e.modulePath && f.testName === e.testName ? {
+				...f,
+				classification: e.classification
+			} : f)
+		}),
+		SuggestedAction: (e) => ({
+			...state,
+			suggestedActions: [...state.suggestedActions, {
+				severity: e.severity,
+				title: e.title,
+				detail: e.detail,
+				...e.targetTool !== void 0 && { targetTool: e.targetTool }
+			}]
+		}),
+		RunFinished: (e) => ({
+			...state,
+			phase: "finished",
+			finishedAt: e.finishedAt,
+			totals: {
+				passCount: e.passCount,
+				failCount: e.failCount,
+				skipCount: e.skipCount,
+				timeoutCount: e.timeoutCount ?? state.totals.timeoutCount,
+				durationMs: e.durationMs
+			}
+		}),
+		RunTimedOut: () => ({
+			...state,
+			phase: "timed-out"
+		}),
+		ModuleCollected: noop,
+		SuiteStarted: noop,
+		SuiteFinished: noop,
+		HookStarted: noop,
+		HookFinished: noop,
+		ConsoleLog: noop,
+		TestAnnotated: noop,
+		TestArtifactRecorded: noop,
+		WatcherReady: noop,
+		WatcherRerun: noop,
+		TrendComputed: (e) => ({
+			...state,
+			trend: {
+				direction: e.direction,
+				runCount: e.runCount
+			}
+		})
+	}));
+};
+/**
+* Fold a sequence of events into a final `RenderState`.
+*
+* Convenience for tests, replays, and the agent renderer's
+* accumulate-then-render-once path.
+*
+* @param events - the ordered event sequence to fold
+* @param seed - the initial render state (defaults to `initialRenderState`)
+* @returns the terminal render state after all events are applied
+* @public
+*/
+const reduceRenderStateAll = (events, seed = initialRenderState) => events.reduce(reduceRenderState, seed);
+
+//#endregion
+export { reduceRenderState, reduceRenderStateAll };

package/render-agent.js

@@ -0,0 +1,137 @@
+import { formatDisplayDuration } from "./format-duration.js";
+
+//#region src/render-agent.ts
+const DEFAULT_WIDTH = 80;
+const DEFAULT_MAX_GAPS = 3;
+const severityLabel = {
+	info: "info",
+	warn: "warn",
+	blocker: "blocker"
+};
+const formatHeader = (state) => {
+	const { passCount, failCount, skipCount, durationMs } = state.totals;
+	const parts = [`${passCount}/${passCount + failCount + skipCount} passed`];
+	if (failCount > 0) parts.push(`${failCount} failed`);
+	if (skipCount > 0) parts.push(`${skipCount} skipped`);
+	return `Tests: ${parts.join(", ")} (${formatDisplayDuration(durationMs)})`;
+};
+const formatModulesSection = (state) => {
+	const modules = state.moduleOrder.map((path) => state.modules[path]).filter((m) => m !== void 0);
+	if (modules.length === 0) return null;
+	if (modules.filter((m) => m.failCount > 0 || m.skipCount > 0).length === 0) {
+		const noun = modules.length === 1 ? "module" : "modules";
+		return `${modules.length} ${noun} all-passed.`;
+	}
+	const lines = ["Modules:"];
+	for (const m of modules) {
+		const parts = [];
+		if (m.passCount > 0) parts.push(`${m.passCount} passed`);
+		if (m.failCount > 0) parts.push(`${m.failCount} failed`);
+		if (m.skipCount > 0) parts.push(`${m.skipCount} skipped`);
+		const summary = parts.length > 0 ? parts.join(", ") : `status=${m.status}`;
+		lines.push(`- ${m.modulePath}: ${summary}`);
+	}
+	return lines.join("\n");
+};
+const truncate = (line, max) => {
+	if (line.length <= max) return line;
+	const slice = max - 1;
+	if (slice <= 0) return "…";
+	return `${line.slice(0, slice)}…`;
+};
+const formatFailure = (f, width, includeStack) => {
+	const suite = f.suitePath.length > 0 ? `${f.suitePath.join(" > ")} > ` : "";
+	const classification = f.classification !== null ? ` [${f.classification}]` : "";
+	const lines = [`- ${f.modulePath} > ${suite}${f.testName}${classification}`];
+	if (f.error?.message !== void 0) {
+		const firstLine = f.error.message.split("\n", 1)[0] ?? "";
+		lines.push(`  ${truncate(firstLine, Math.max(20, width - 2))}`);
+	}
+	if (f.error?.diff !== void 0) for (const diffLine of f.error.diff.split("\n")) lines.push(`  ${truncate(diffLine, Math.max(20, width - 2))}`);
+	if (includeStack && f.error?.stack !== void 0) for (const stackLine of f.error.stack.split("\n")) lines.push(`  ${truncate(stackLine, Math.max(20, width - 2))}`);
+	return lines.join("\n");
+};
+const formatFailuresSection = (state, width, includeStack) => {
+	if (state.failures.length === 0) return null;
+	const lines = ["Failures:"];
+	for (const f of state.failures) lines.push(formatFailure(f, width, includeStack));
+	return lines.join("\n");
+};
+const formatPercent = (n) => {
+	const rounded = Math.round(n * 10) / 10;
+	return Number.isInteger(rounded) ? `${rounded}%` : `${rounded}%`;
+};
+const formatCoverageSection = (state, maxGaps) => {
+	const cov = state.coverage;
+	if (cov === null) return null;
+	const lines = ["Coverage:"];
+	for (const m of [
+		"lines",
+		"branches",
+		"functions",
+		"statements"
+	]) {
+		const actual = cov.metrics[m];
+		const threshold = cov.thresholds[m];
+		const thresholdNote = threshold !== void 0 ? ` (threshold ${formatPercent(threshold)})` : "";
+		lines.push(`- ${m}: ${formatPercent(actual)}${thresholdNote}`);
+	}
+	if (cov.violations.length > 0) {
+		lines.push("Violations:");
+		for (const v of cov.violations) lines.push(`- ${v.metric}: ${formatPercent(v.actual)} < ${formatPercent(v.expected)}`);
+	}
+	if (maxGaps > 0 && cov.gaps.length > 0) {
+		const topN = [...cov.gaps].sort((a, b) => b.missing.lines - a.missing.lines).slice(0, maxGaps);
+		lines.push("Gaps:");
+		for (const g of topN) {
+			const detail = g.uncoveredLines !== void 0 ? `: ${g.uncoveredLines}` : "";
+			lines.push(`- ${g.file}${detail}`);
+		}
+		const omitted = cov.gaps.length - topN.length;
+		if (omitted > 0) {
+			const noun = omitted === 1 ? "gap" : "gaps";
+			lines.push(`- (+${omitted} more ${noun})`);
+		}
+	}
+	return lines.join("\n");
+};
+const formatActionsSection = (state) => {
+	if (state.suggestedActions.length === 0) return null;
+	const lines = ["Actions:"];
+	for (const a of state.suggestedActions) lines.push(formatAction(a));
+	return lines.join("\n");
+};
+const formatAction = (a) => {
+	const tool = a.targetTool !== void 0 ? ` (tool: ${a.targetTool})` : "";
+	return `- ${severityLabel[a.severity]}: ${a.title}${tool}\n  ${a.detail}`;
+};
+/**
+* Project the reduced `RenderState` into a single string suitable
+* for emission once at the end of a run.
+*
+* The output is deterministic given a stable input — folding the same
+* event sequence twice and rendering produces byte-identical strings.
+*
+* @param state - the fully-reduced render state
+* @param options - optional output-shaping options
+* @returns the agent-format string
+* @public
+*/
+const renderAgent = (state, options = {}) => {
+	const width = options.width ?? DEFAULT_WIDTH;
+	const maxGaps = options.maxCoverageGaps ?? DEFAULT_MAX_GAPS;
+	const includeStack = options.includeStack ?? false;
+	const sections = [formatHeader(state)];
+	const failures = formatFailuresSection(state, width, includeStack);
+	if (failures !== null) sections.push(failures);
+	const modules = formatModulesSection(state);
+	if (modules !== null) sections.push(modules);
+	const coverage = formatCoverageSection(state, maxGaps);
+	if (coverage !== null) sections.push(coverage);
+	const actions = formatActionsSection(state);
+	if (actions !== null) sections.push(actions);
+	return `${sections.join("\n\n")}\n`;
+};
+
+//#endregion
+export { renderAgent };

package/render-ink/CountColumns.js

@@ -0,0 +1,34 @@
+import { Text } from "ink";
+import { jsxs } from "react/jsx-runtime";
+
+//#region src/render-ink/CountColumns.tsx
+/**
+* The four-outcome count columns for an aggregate row (a project or a
+* module): pass, fail, skip, timeout. All four always render — a zero
+* is dimmed, never omitted — so the columns line up across rows.
+*/
+const cell = (count, glyph, color) => count > 0 ? /* @__PURE__ */ jsxs(Text, {
+	color,
+	children: [count, glyph]
+}) : /* @__PURE__ */ jsxs(Text, {
+	color: "gray",
+	children: [count, glyph]
+});
+/**
+* Renders four colored count columns (pass ✓, fail ✗, skip ↷, timeout ⧖)
+* for an aggregate row. Zeros are dimmed; all four columns always appear.
+*
+* @public
+*/
+const CountColumns = ({ passCount, failCount, skipCount, timeoutCount }) => /* @__PURE__ */ jsxs(Text, { children: [
+	cell(passCount, "✓", "green"),
+	"  ",
+	cell(failCount, "✗", "red"),
+	"  ",
+	cell(skipCount, "↷", "yellow"),
+	"  ",
+	cell(timeoutCount, "⧖", "#e09a4e")
+] });
+
+//#endregion
+export { CountColumns };