@vitest-agent/plugin 5.2.2 → 5.4.0

package/index.d.ts

@@ -1,6 +1,6 @@
 import "@effected/env";
 import { EnvironmentDetector, PlatformLiveError, PlatformOptions, PlatformServices, SettingsInput, StackFrameInput } from "@vitest-agent/engine";
-import { AgentPluginOptions, AgentReporterOptions, ConsoleMode, CoverageBaselines, CoverageInput, CoverageLevel, CoverageLevelName, CoverageLevelName as CoverageLevelName$1, CoverageReport, OutputFormat, ResolvedReporterConfig, ResolvedThresholds, RunEvent, Transport, VitestAgentReporterFactory, resolveCoverageInput, validateCoverageConfig } from "@vitest-agent/sdk";
+import { AgentPluginOptions, AgentReporterOptions, ConsoleMode, CoverageBaselines, CoverageInput, CoverageLevel, CoverageLevelName, CoverageLevelName as CoverageLevelName$1, CoverageReport, ResolvedReporterConfig, ResolvedThresholds, RunEvent, Transport, VitestAgentReporterFactory, resolveCoverageInput, validateCoverageConfig } from "@vitest-agent/sdk";
 import { Context, Effect, Layer, Option } from "effect";
 import { TestProjectInlineConfiguration, TestTagDefinition } from "vitest/config";
 import { ResolvedConfig, VitestPluginContext } from "vitest/node";
@@ -561,7 +561,6 @@ interface AgentReporterConstructorOptions extends AgentReporterOptions {
    */
   coverageMode?: "full" | "ui-only";
   consoleMode?: ConsoleMode;
-  format?: OutputFormat;
   mcp?: boolean;
   githubActions?: boolean;
   /**
@@ -699,6 +698,14 @@ export declare class AgentReporter {
    * @internal
    */
   private closing;
+  /**
+   * The stray-output capture the plugin installed on this Vitest
+   * instance's Logger (`configureVitest`, only when the plugin owns the
+   * console), found at `onInit`. Undefined otherwise.
+   *
+   * @internal
+   */
+  private strayCapture;
   /**
    * Whether the user supplied a custom `reporter` factory. A custom
    * reporter may subscribe to the run-event channel in any console mode,
@@ -795,6 +802,15 @@ export declare class AgentReporter {
    * @internal
    */
   private closeReporters;
+  /**
+   * Find the stray-output capture on `vitest.logger` and, when a reporter
+   * resolved at `onInit` prints stray lines (a live view), route whole
+   * lines to it so they print above its drawing. The first reporter that
+   * takes a line wins.
+   *
+   * @internal
+   */
+  private routeStrayOutput;
   /**
    * Resolve the reporter factory at run start.
    *

package/layers/CoverageAnalyzerLive.js

@@ -17,6 +17,59 @@ function isBelowMetricThresholds(stats, thresholds) {
 	if (thresholds.statements !== void 0 && stats.statements < thresholds.statements) return true;
 	return false;
 }
+const METRICS = [
+	"statements",
+	"branches",
+	"functions",
+	"lines"
+];
+/**
+* Istanbul's own percentage: `covered / total` floored to two decimals, and
+* 100 for an empty (`total === 0`) metric. Mirrors `istanbul-lib-coverage`'s
+* `percent()` so an aggregate computed here equals what Vitest compares.
+*/
+function istanbulPercent(covered, total) {
+	return total > 0 ? Math.floor(1e4 * covered / total) / 100 : 100;
+}
+/**
+* Aggregate a glob's matched files the way Vitest builds a glob coverage map:
+* sum `covered` and `total` per metric across the files' summaries, then take
+* the percentage of the sums (NOT a mean of per-file percentages). Returns
+* `undefined` when any file's summary lacks counts, since no honest aggregate
+* exists then.
+*/
+function aggregateSummaries(summaries) {
+	const sums = {
+		statements: {
+			covered: 0,
+			total: 0
+		},
+		branches: {
+			covered: 0,
+			total: 0
+		},
+		functions: {
+			covered: 0,
+			total: 0
+		},
+		lines: {
+			covered: 0,
+			total: 0
+		}
+	};
+	for (const s of summaries) for (const m of METRICS) {
+		const { covered, total } = s[m];
+		if (typeof covered !== "number" || typeof total !== "number") return void 0;
+		sums[m].covered += covered;
+		sums[m].total += total;
+	}
+	return {
+		statements: istanbulPercent(sums.statements.covered, sums.statements.total),
+		branches: istanbulPercent(sums.branches.covered, sums.branches.total),
+		functions: istanbulPercent(sums.functions.covered, sums.functions.total),
+		lines: istanbulPercent(sums.lines.covered, sums.lines.total)
+	};
+}
 /**
 * Runtime duck-type check for istanbul CoverageMap.
 */
@@ -86,6 +139,53 @@ function resolveEffectivePerFileThresholds(filePath, resolved) {
 	return setting;
 }
 /**
+* Find the threshold globs whose aggregate coverage is below their own metric
+* numbers (issue #391), matching Vitest 5: a glob's coverage map holds every
+* file in the run that matches it (a file may belong to several globs), the
+* aggregate is `sum(covered) / sum(total)` per metric, and it is enforced in
+* addition to any object `perFile`. A glob with `perFile: true` is checked per
+* file only, so it has no aggregate to fail.
+*
+* Choices (document before changing):
+* - Bare-zero files COUNT toward the aggregate, regardless of
+*   `includeBareZero`. That option only decides whether such files are listed
+*   per file; Vitest's aggregate includes them, and dropping them would hide
+*   exactly the shortfall they cause.
+* - Scoped runs never produce shortfalls (the caller skips this): a partial
+*   coverage map says nothing about a glob's full aggregate, mirroring how
+*   scoped runs never flag threshold violations.
+* - Only non-negative numbers are compared (minimum percentages). Vitest's
+*   negative "max uncovered count" form is not evaluated here.
+* - A glob that matches no file, or whose matched summaries lack
+*   covered/total counts, yields nothing.
+*/
+function computeGlobShortfalls(files, resolved) {
+	const shortfalls = [];
+	for (const [pattern, metrics] of resolved.patterns ?? []) {
+		if (metrics.perFile === true) continue;
+		const thresholds = {
+			...metrics.lines !== void 0 ? { lines: metrics.lines } : {},
+			...metrics.functions !== void 0 ? { functions: metrics.functions } : {},
+			...metrics.branches !== void 0 ? { branches: metrics.branches } : {},
+			...metrics.statements !== void 0 ? { statements: metrics.statements } : {}
+		};
+		if (METRICS.every((m) => thresholds[m] === void 0)) continue;
+		const matched = files.filter((f) => matchGlob(f.matchPath, pattern));
+		if (matched.length === 0) continue;
+		const aggregate = aggregateSummaries(matched.map((f) => f.summary));
+		if (aggregate === void 0) continue;
+		if (METRICS.some((m) => {
+			const min = thresholds[m];
+			return min !== void 0 && min >= 0 && aggregate[m] < min;
+		})) shortfalls.push({
+			pattern,
+			summary: aggregate,
+			thresholds
+		});
+	}
+	return shortfalls;
+}
+/**
 * Internal coverage processing logic. Shared by both `process` and `processScoped`.
 *
 * @param coverageMap - The value received by `onCoverage`; duck-typed at runtime
@@ -110,10 +210,15 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 	const belowTarget = [];
 	const { root } = options;
 	const matchKey = (filePath) => toPosixPath(root === void 0 ? filePath : relative(root, filePath));
+	const mapSummaries = [];
 	for (const filePath of coverageMap.files()) {
 		const matchPath = matchKey(filePath);
 		const fileCoverage = coverageMap.fileCoverageFor(filePath);
 		const fileSummary = fileCoverage.toSummary();
+		mapSummaries.push({
+			matchPath,
+			summary: fileSummary
+		});
 		const fileStats = {
 			statements: fileSummary.statements.pct,
 			branches: fileSummary.branches.pct,
@@ -134,7 +239,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 			continue;
 		}
 		if (options.targets) {
-			if (isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(matchPath, options.targets))) {
+			if (isBelowMetricThresholds(fileStats, resolveEffectivePerFileThresholds(matchPath, options.targets) ?? resolveEffectiveThresholds(matchPath, options.targets))) {
 				const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
 				belowTarget.push({
 					file: filePath,
@@ -144,6 +249,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 			}
 		}
 	}
+	const globShortfalls = scoped ? [] : computeGlobShortfalls(mapSummaries, options.thresholds);
 	lowCoverage.sort((a, b) => a.summary.lines - b.summary.lines);
 	belowTarget.sort((a, b) => a.summary.lines - b.summary.lines);
 	return {
@@ -165,6 +271,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		...scoped && options.totalFiles !== void 0 ? { totalFiles: options.totalFiles } : {},
 		lowCoverage,
 		lowCoverageFiles: lowCoverage.map((f) => f.file),
+		...globShortfalls.length > 0 ? { globShortfalls } : {},
 		...options.targets ? {
 			belowTarget,
 			belowTargetFiles: belowTarget.map((f) => f.file)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "5.2.2",
+	"version": "5.4.0",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -43,19 +43,19 @@
 		"vitest-agent-mcp": "bin/vitest-agent-mcp.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "^4.0.0",
-		"@effected/cli": "^0.12.0",
+		"@effect/platform-node": "^4.0.2",
+		"@effected/cli": "^0.15.0",
 		"@effected/env": "^0.1.0",
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",
-		"@effected/workspaces": "^0.31.0",
-		"@vitest-agent/cli": "4.0.2",
-		"@vitest-agent/engine": "0.6.0",
-		"@vitest-agent/mcp": "5.1.8",
-		"@vitest-agent/reporter": "4.1.0",
-		"@vitest-agent/sdk": "6.0.0",
-		"effect": "^4.0.0",
-		"magic-string": "^1.4.2"
+		"@effected/workspaces": "^0.32.0",
+		"@vitest-agent/cli": "4.0.4",
+		"@vitest-agent/engine": "1.0.0",
+		"@vitest-agent/mcp": "5.2.0",
+		"@vitest-agent/reporter": "5.0.0",
+		"@vitest-agent/sdk": "7.0.0",
+		"effect": "^4.0.2",
+		"magic-string": "^1.4.3"
 	},
 	"peerDependencies": {
 		"@vitest/coverage-istanbul": "^5.0.0",

package/plugin.js

@@ -3,6 +3,7 @@ import { resolveThresholds } from "./utils/resolve-thresholds.js";
 import { ConfigValidationLive } from "./layers/ConfigValidationLive.js";
 import { ConfigurationError } from "./utils/configuration-error.js";
 import { assertFlatScope } from "./utils/report-writer.js";
+import { installStrayOutputCapture } from "./utils/stray-output-capture.js";
 import { AgentReporter } from "./reporter.js";
 import { buildModuleInfo } from "./utils/build-module-info.js";
 import { DefaultDiscoverStrategy } from "./utils/discover-strategy.js";
@@ -101,24 +102,6 @@ function ownsStdout(mode) {
 	return mode !== "passthrough";
 }
 /**
-* Map the resolved {@link ConsoleMode} to the legacy {@link OutputFormat}
-* the existing reporter factories switch on. The new event-sourced renderer
-* does not consult this — it dispatches directly on `kit.config.consoleMode`
-* — but the bundled markdown/terminal/silent/ci-annotations reporters still
-* need a format value to pick which formatter to invoke.
-*
-* @internal
-*/
-function resolveFormat(mode) {
-	switch (mode) {
-		case "stream":
-		case "agent": return "terminal";
-		case "ci-annotations": return "ci-annotations";
-		case "silent": return "silent";
-		case "passthrough": return "vitest-bypass";
-	}
-}
-/**
 * Set to the Vitest object reference once we've pushed an aggregating
 * reporter for that Vitest instance. The flag is module-scoped (rather
 * than closure-scoped on the plugin) because Vitest can construct the
@@ -253,9 +236,8 @@ function AgentPlugin(options = {}, _layer) {
 					process.stderr.write(line);
 				};
 				const consoleMode = resolveConsoleMode(options, executor, env, reportOnce);
-				const format = resolveFormat(consoleMode);
 				const mcp = executor === "agent";
-				log("env:", env, "| executor:", executor, "| consoleMode:", consoleMode, "| format:", format, "| mcp (auto):", mcp);
+				log("env:", env, "| executor:", executor, "| consoleMode:", consoleMode, "| mcp (auto):", mcp);
 				if (ownsStdout(consoleMode)) {
 					log("stripping console reporters (consoleMode owns stdout)");
 					const stripped = stripConsoleReporters(vitest.config.reporters);
@@ -265,6 +247,11 @@ function AgentPlugin(options = {}, _layer) {
 						log("suppressing native coverage text reporter");
 						coverageCfg.reporter = [];
 					}
+					const logger = vitest.logger;
+					if (logger?.outputStream !== void 0 && logger.errorStream !== void 0) installStrayOutputCapture(logger, {
+						stdout: process.stdout,
+						stderr: process.stderr
+					});
 				}
 				if (env === "ci-github" && consoleMode !== "silent") {
 					log("normalizing the github-actions reporter entry");
@@ -326,7 +313,6 @@ function AgentPlugin(options = {}, _layer) {
 					...coverageThresholds !== void 0 ? { coverageThresholds } : {},
 					...coverageTargets !== void 0 ? { coverageTargets } : {},
 					coverageMode,
-					format,
 					consoleMode,
 					mcp,
 					githubActions,

package/reporter.js

@@ -9,10 +9,11 @@ import { processFailure } from "./utils/process-failure.js";
 import { assertReportCapable, createReportWriter } from "./utils/report-writer.js";
 import { resolveNoColor } from "./utils/resolve-no-color.js";
 import { routeRenderedOutput } from "./utils/route-rendered-output.js";
+import { strayOutputCaptureOf } from "./utils/stray-output-capture.js";
 import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
 import { mkdirSync, statSync } from "node:fs";
 import { dirname } from "node:path";
-import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, ensureMigrated, historyKey, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/engine";
+import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, HistoryTracker, OutputPipelineLive, PathResolutionLive, ensureMigrated, historyKey, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/engine";
 import { buildAgentReport, coerceErrorField, computeTrend, formatFatalError, isTimeoutError, probeHostMetadataFromEnv } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
 import { randomUUID } from "node:crypto";
@@ -41,6 +42,14 @@ import { DefaultVitestAgentReporter } from "@vitest-agent/reporter";
 */
 const dbPathCache = /* @__PURE__ */ new Map();
 /**
+* The run's stray output on every project report: it arrives on one stream
+* shared by every project, so no report owns it more than another.
+*/
+const withStrayOutput = (reports, strayOutput) => strayOutput === void 0 ? reports : reports.map((report) => ({
+	...report,
+	strayOutput
+}));
+/**
 * Safely read a raw Vitest error object's `stacks` array. The property
 * access itself can throw on hostile shapes (live getters — the same
 * ConfigError class of failure `coerceErrorField` guards); frames are
@@ -347,6 +356,14 @@ var AgentReporter = class {
 	*/
 	closing;
 	/**
+	* The stray-output capture the plugin installed on this Vitest
+	* instance's Logger (`configureVitest`, only when the plugin owns the
+	* console), found at `onInit`. Undefined otherwise.
+	*
+	* @internal
+	*/
+	strayCapture;
+	/**
 	* Whether the user supplied a custom `reporter` factory. A custom
 	* reporter may subscribe to the run-event channel in any console mode,
 	* so the streaming hooks publish events whenever this is true.
@@ -423,7 +440,6 @@ var AgentReporter = class {
 		const resolvedTargets = rawTargets ? "global" in rawTargets ? rawTargets : resolveThresholds(rawTargets) : void 0;
 		const consoleMode = options.consoleMode ?? "passthrough";
 		const consoleOutput = consoleMode === "silent" ? "silent" : "failures";
-		const derivedFormat = options.format ?? (consoleMode === "silent" ? "silent" : consoleMode === "stream" || consoleMode === "agent" ? "terminal" : consoleMode === "ci-annotations" ? "ci-annotations" : void 0);
 		const githubActions = options.githubActions ?? false;
 		const base = {
 			...options.cacheDir !== void 0 ? { cacheDir: options.cacheDir } : {},
@@ -437,7 +453,6 @@ var AgentReporter = class {
 			githubSummary: githubActions,
 			githubSummaryFile: void 0,
 			...options.reportScope !== void 0 ? { reportScope: options.reportScope } : {},
-			...derivedFormat !== void 0 ? { format: derivedFormat } : {},
 			consoleMode,
 			...options.mcp !== void 0 ? { mcp: options.mcp } : {},
 			...options.projectFilter !== void 0 ? { projectFilter: options.projectFilter } : {},
@@ -470,7 +485,6 @@ var AgentReporter = class {
 			includeBareZero: opts.includeBareZero,
 			githubActions: opts.githubActions,
 			githubSummary: opts.githubSummary,
-			format: opts.format ?? "vitest-bypass",
 			detail: opts.detail ?? "standard",
 			noColor: false,
 			coverageMode: opts.coverageMode,
@@ -500,6 +514,7 @@ var AgentReporter = class {
 			await this.ensureDbPath();
 		} catch {}
 		await this.initReporters();
+		this.routeStrayOutput(vitest);
 		const onClose = vitest?.onClose;
 		if (typeof onClose === "function") onClose.call(vitest, () => this.closeReporters());
 	}
@@ -516,6 +531,7 @@ var AgentReporter = class {
 	*/
 	closeReporters() {
 		this.closing ??= (async () => {
+			this.strayCapture?.route(void 0);
 			await Promise.all((this.reporters ?? []).map(async (reporter) => {
 				try {
 					await reporter.close?.();
@@ -532,6 +548,25 @@ var AgentReporter = class {
 		return this.closing;
 	}
 	/**
+	* Find the stray-output capture on `vitest.logger` and, when a reporter
+	* resolved at `onInit` prints stray lines (a live view), route whole
+	* lines to it so they print above its drawing. The first reporter that
+	* takes a line wins.
+	*
+	* @internal
+	*/
+	routeStrayOutput(vitest) {
+		this.strayCapture = strayOutputCaptureOf(vitest?.logger);
+		const printers = (this.reporters ?? []).flatMap((reporter) => reporter.printStrayLine !== void 0 ? [reporter.printStrayLine] : []);
+		if (this.strayCapture === void 0 || printers.length === 0) return;
+		this.strayCapture.route((stream, line) => {
+			for (const print of printers) try {
+				if (print(stream, line)) return true;
+			} catch {}
+			return false;
+		});
+	}
+	/**
 	* Resolve the reporter factory at run start.
 	*
 	* The factory is invoked here — before any streaming hook fires — so a
@@ -553,14 +588,12 @@ var AgentReporter = class {
 			const initProgram = Effect.gen(function* () {
 				const detector = yield* EnvironmentDetector;
 				const executorResolver = yield* ExecutorResolver;
-				const formatSelector = yield* FormatSelector;
 				const detailResolver = yield* DetailResolver;
 				const env = yield* detector.detect();
 				const executor = yield* executorResolver.resolve(env);
 				return {
 					env,
 					executor,
-					format: yield* formatSelector.select(executor, opts.format, env),
 					detail: yield* detailResolver.resolve(executor, {
 						hasFailures: false,
 						belowTargets: false,
@@ -569,11 +602,10 @@ var AgentReporter = class {
 					noColor: yield* resolveNoColor
 				};
 			});
-			const { env, executor, format, detail, noColor } = await Effect.runPromise(initProgram.pipe(Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer)));
+			const { env, executor, detail, noColor } = await Effect.runPromise(initProgram.pipe(Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer)));
 			const kit = buildReporterKit({
 				env,
 				executor,
-				format,
 				detail,
 				noColor,
 				consoleMode: opts.consoleMode ?? "passthrough",
@@ -647,6 +679,7 @@ var AgentReporter = class {
 	*/
 	onTestRunStart(_specifications) {
 		this.startedSpecCount = _specifications.length;
+		this.strayCapture?.reset();
 		if (this.neutralizedThresholdSnapshot.size > 0) {
 			try {
 				const thresholds = (this._vitest?.coverageProvider)?.options?.thresholds;
@@ -1058,6 +1091,8 @@ var AgentReporter = class {
 		if (this.rendered) return;
 		this.rendered = true;
 		const errors = unhandledErrors;
+		this.strayCapture?.flush();
+		const strayOutput = this.strayCapture?.snapshot();
 		if (this.wantsRunEvents() && this.currentRunId !== null) {
 			let pass = 0;
 			let fail = 0;
@@ -1088,7 +1123,8 @@ var AgentReporter = class {
 				durationMs: totalDuration,
 				// @vitest-agent/ui, which both populate `collectedModules` on their
 				collectedModules: testModules.length,
-				...errors.length > 0 && { unhandledErrors: errors }
+				...errors.length > 0 && { unhandledErrors: errors },
+				...strayOutput !== void 0 && { strayOutput }
 			});
 		}
 		const modules = testModules;
@@ -1161,11 +1197,9 @@ var AgentReporter = class {
 			const uiProgram = Effect.gen(function* () {
 				const detector = yield* EnvironmentDetector;
 				const executorResolver = yield* ExecutorResolver;
-				const formatSelector = yield* FormatSelector;
 				const detailResolver = yield* DetailResolver;
 				const env = yield* detector.detect();
 				const executor = yield* executorResolver.resolve(env);
-				const format = yield* formatSelector.select(executor, opts.format, env);
 				const health = {
 					hasFailures: uiReports.some((r) => r.failedFiles.length > 0 || r.unhandledErrors.length > 0),
 					belowTargets: false,
@@ -1176,7 +1210,6 @@ var AgentReporter = class {
 				const kit = buildReporterKit({
 					env,
 					executor,
-					format,
 					detail,
 					noColor: yield* resolveNoColor,
 					consoleMode: opts.consoleMode ?? "passthrough",
@@ -1193,7 +1226,7 @@ var AgentReporter = class {
 				});
 				const reporters = preBuiltReporters ?? normalizeReporters(opts.reporter(kit));
 				const renderInput = {
-					reports: uiReports,
+					reports: withStrayOutput(uiReports, strayOutput),
 					classifications: /* @__PURE__ */ new Map()
 				};
 				const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
@@ -1287,7 +1320,8 @@ var AgentReporter = class {
 					})),
 					...coverageReport.scoped ? { scoped: coverageReport.scoped } : {},
 					...coverageReport.scopedFiles !== void 0 ? { scopedFiles: coverageReport.scopedFiles.length } : {},
-					...coverageReport.totalFiles !== void 0 ? { totalFiles: coverageReport.totalFiles } : {}
+					...coverageReport.totalFiles !== void 0 ? { totalFiles: coverageReport.totalFiles } : {},
+					...coverageReport.globShortfalls !== void 0 ? { globShortfalls: coverageReport.globShortfalls } : {}
 				});
 				if (!coverageReport.scoped) for (const metric of [
 					"lines",
@@ -1705,11 +1739,9 @@ var AgentReporter = class {
 			const { reports, classifications, trendSummary } = renderInputData;
 			const detector = yield* EnvironmentDetector;
 			const executorResolver = yield* ExecutorResolver;
-			const formatSelector = yield* FormatSelector;
 			const detailResolver = yield* DetailResolver;
 			const env = yield* detector.detect();
 			const executor = yield* executorResolver.resolve(env);
-			const format = yield* formatSelector.select(executor, opts.format, env);
 			const health = {
 				hasFailures: reports.some((r) => r.failedFiles.length > 0 || r.unhandledErrors.length > 0),
 				belowTargets: reports.some((r) => {
@@ -1721,14 +1753,12 @@ var AgentReporter = class {
 			yield* Effect.logDebug("pipeline resolved").pipe(Effect.annotateLogs({
 				env,
 				executor,
-				format,
 				detail
 			}));
 			const githubSummaryFile = process.env.GITHUB_STEP_SUMMARY;
 			const kit = buildReporterKit({
 				env,
 				executor,
-				format,
 				detail,
 				noColor: yield* resolveNoColor,
 				consoleMode: opts.consoleMode ?? "passthrough",
@@ -1745,7 +1775,7 @@ var AgentReporter = class {
 			});
 			const reporters = preBuiltReporters ?? normalizeReporters(opts.reporter(kit));
 			const renderInput = {
-				reports,
+				reports: withStrayOutput(reports, strayOutput),
 				classifications,
 				...trendSummary !== void 0 && { trendSummary }
 			};

package/utils/build-reporter-kit.js

@@ -15,7 +15,6 @@ const buildReporterKit = (input) => {
 		includeBareZero: false,
 		githubActions: input.githubActions,
 		githubSummary,
-		format: input.format,
 		detail: input.detail,
 		noColor: input.noColor,
 		coverageMode: input.coverageMode,

package/utils/stray-output-capture.js

@@ -0,0 +1,177 @@
+import { STRAY_OUTPUT_SOURCE, isEscapeOnly, makeStrayOutputRecorder } from "@vitest-agent/sdk";
+import { Writable } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+
+//#region src/utils/stray-output-capture.ts
+/**
+* Stray-output capture: a pass-through over Vitest's `Logger.outputStream` /
+* `errorStream`.
+*
+* Why those two streams (vitest\@5.0.0, `src/node/pools/workers/`): the forks
+* and vmForks pools fork each worker with `stdio: "pipe"` and pipe its stdout
+* and stderr into `project.vitest.logger.outputStream` / `errorStream`,
+* captured when the worker is constructed, so every raw byte a worker writes
+* (a grandchild process that inherits the worker's fds included, such as an
+* `execFileSync("git", …)` with default stdio) arrives on them. The threads
+* and vmThreads pools pipe a worker thread's JS-level `process.stdout` /
+* `stderr` the same way, but a child process spawned from a thread inherits
+* the main process's real fds 1/2, so its bytes reach the terminal directly
+* and nothing here can see them. Workers are constructed lazily by the pool,
+* at run time, long after `configureVitest`, so installing there is early
+* enough. The `Logger`'s own `console` was built from the ORIGINAL streams in
+* its constructor, so Vitest's logging bypasses the wrapper; its few direct
+* `outputStream.write` calls are escape-only (cursor show, clear screen),
+* which pass straight through unrecorded.
+*
+* Every byte is recorded (bounded: counts, a few sample lines). While a
+* printer is routed (the reporter's live view is up) and the stream's
+* original destination is the process terminal, bytes are line-buffered and
+* each whole line goes to the printer, which prints it above the live frame;
+* otherwise bytes pass through to the original stream unchanged. The
+* original is whatever stream object the Logger held: under MCP's
+* `run_tests` that is the server's null sink, so worker output still never
+* reaches the JSON-RPC stdout, and it is never routed.
+*/
+/**
+* The most text a stream holds back waiting for a newline. Past it, the held
+* text is routed as a line of its own, so a child that never writes a newline
+* cannot grow the buffer without bound.
+*
+* @internal
+*/
+const MAX_HELD_CHARS = 8192;
+const isCapture = (value) => typeof value === "object" && value !== null && "route" in value && "snapshot" in value;
+/**
+* The capture installed on `logger`, if any.
+*
+* @internal
+*/
+const strayOutputCaptureOf = (logger) => {
+	if (typeof logger !== "object" || logger === null) return void 0;
+	const value = logger[STRAY_OUTPUT_SOURCE];
+	return isCapture(value) ? value : void 0;
+};
+const DELEGATED = [
+	"isTTY",
+	"columns",
+	"rows",
+	"getColorDepth",
+	"hasColors",
+	"getWindowSize"
+];
+var StrayStream = class extends Writable {
+	original;
+	take;
+	constructor(original, take) {
+		super({ decodeStrings: false });
+		this.original = original;
+		this.take = take;
+		for (const key of DELEGATED) {
+			if (!(key in original)) continue;
+			Object.defineProperty(this, key, {
+				configurable: true,
+				enumerable: true,
+				get: () => {
+					const value = original[key];
+					return typeof value === "function" ? value.bind(original) : value;
+				}
+			});
+		}
+	}
+	_write(chunk, encoding, callback) {
+		try {
+			this.take(chunk, encoding);
+			callback();
+		} catch (err) {
+			callback(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+};
+/**
+* Wrap `logger`'s output and error streams with the stray-output capture, once
+* per Logger (a second call returns the first capture). The capture is
+* published on the Logger under `STRAY_OUTPUT_SOURCE`, so MCP's `run_tests`
+* (which cannot import the plugin) reads the run's stray output with the
+* sdk's `readStrayOutput`.
+*
+* @param logger - the Vitest instance's `logger`
+* @param terminal - the process's own stdout and stderr
+*
+* @internal
+*/
+const installStrayOutputCapture = (logger, terminal) => {
+	const existing = strayOutputCaptureOf(logger);
+	if (existing !== void 0) return existing;
+	const recorder = makeStrayOutputRecorder();
+	const originals = {
+		stdout: logger.outputStream,
+		stderr: logger.errorStream
+	};
+	const decoders = {
+		stdout: new StringDecoder("utf8"),
+		stderr: new StringDecoder("utf8")
+	};
+	const held = {
+		stdout: "",
+		stderr: ""
+	};
+	let printer;
+	const flushHeld = (stream) => {
+		const text = held[stream];
+		if (text === "") return;
+		held[stream] = "";
+		originals[stream].write(text);
+	};
+	const take = (stream) => (chunk, encoding) => {
+		const original = originals[stream];
+		if (typeof chunk === "string" && isEscapeOnly(chunk)) {
+			original.write(chunk, encoding);
+			return;
+		}
+		const text = typeof chunk === "string" ? chunk : decoders[stream].write(chunk);
+		recorder.write(stream, text);
+		const route = printer !== void 0 && original === terminal[stream] ? printer : void 0;
+		if (route === void 0) {
+			original.write(chunk, encoding);
+			return;
+		}
+		const lines = (held[stream] + text).split("\n");
+		const rest = lines.pop() ?? "";
+		if (rest.length > 8192) {
+			lines.push(rest);
+			held[stream] = "";
+		} else held[stream] = rest;
+		for (const line of lines) if (!route(stream, line)) original.write(`${line}\n`);
+	};
+	const flushHeldThrough = (stream) => {
+		const text = held[stream];
+		if (text === "") return;
+		held[stream] = "";
+		if (printer === void 0 || !printer(stream, text)) originals[stream].write(text);
+	};
+	logger.outputStream = new StrayStream(originals.stdout, take("stdout"));
+	logger.errorStream = new StrayStream(originals.stderr, take("stderr"));
+	const capture = {
+		snapshot: recorder.snapshot,
+		reset: recorder.reset,
+		route: (next) => {
+			if (next === void 0) {
+				flushHeld("stdout");
+				flushHeld("stderr");
+			}
+			printer = next;
+		},
+		flush: () => {
+			flushHeldThrough("stdout");
+			flushHeldThrough("stderr");
+		}
+	};
+	Object.defineProperty(logger, STRAY_OUTPUT_SOURCE, {
+		value: capture,
+		configurable: true
+	});
+	return capture;
+};
+
+//#endregion
+export { MAX_HELD_CHARS, installStrayOutputCapture, strayOutputCaptureOf };

package/version.js

@@ -8,7 +8,7 @@
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "5.2.2";
+const CURRENT_PLUGIN_VERSION = "5.4.0";
 
 //#endregion
 export { CURRENT_PLUGIN_VERSION };