@vitest-agent/plugin 5.6.2 → 6.0.1

package/reporter.js

@@ -5,17 +5,22 @@ import { ReporterLive } from "./layers/ReporterLive.js";
 import { buildReporterKit, normalizeReporters } from "./utils/build-reporter-kit.js";
 import { captureEnvVars } from "./utils/capture-env.js";
 import { captureSettings, hashSettings } from "./utils/capture-settings.js";
+import { collectPerformanceHints } from "./utils/collect-performance-hints.js";
+import { formatFailureSummary, shouldWriteFailureSummary } from "./utils/failure-summary.js";
 import { isPartialRun } from "./utils/is-partial-run.js";
 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 { publishRunDiagnostics } from "./utils/run-diagnostics.js";
+import { runsInCi } from "./utils/runs-in-ci.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 { ConfigLive, DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, HistoryTracker, OutputPipelineLive, PathResolutionLive, VitestAgentConfigFile, ensureMigrated, historyKey, resolveDataPath, resolveLogFile, resolveLogLevel, withPersistTransaction } from "@vitest-agent/engine";
-import { RunRetentionPolicy, VitestAgentConfig, buildAgentReport, coerceErrorField, computeTrend, formatFatalError, isTimeoutError, probeHostMetadataFromEnv } from "@vitest-agent/sdk";
+import { RuntimeEnv } from "@effected/env";
+import { ConfigLive, DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, HistoryTracker, OutputPipelineLive, PathResolutionLive, VitestAgentConfigFile, ensureMigrated, formatFatalError, historyKey, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel, withPersistTransaction } from "@vitest-agent/engine";
+import { RunRetentionPolicy, VitestAgentConfig, buildAgentReport, coerceErrorField, computeTrend, isTimeoutError, suggestedActionsFromRunDiagnostics } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
 import { randomUUID } from "node:crypto";
 import * as NodeServices from "@effect/platform-node/NodeServices";
@@ -345,6 +350,12 @@ var AgentReporter = class {
 	*/
 	rendered = false;
 	/**
+	* `performance.now()` at this run's `onTestRunStart`, for the run's
+	* execution time (issue #544). `undefined` when `onTestRunStart` never
+	* fired (tests invoking `onTestRunEnd` directly).
+	*/
+	runStartedAt = void 0;
+	/**
 	* Stored Vitest instance from {@link AgentReporter.onInit | onInit}.
 	*
 	* @remarks
@@ -719,6 +730,7 @@ var AgentReporter = class {
 	onTestRunStart(_specifications) {
 		this.rendered = false;
 		this.coverage = null;
+		this.runStartedAt = performance.now();
 		this.startedSpecCount = _specifications.length;
 		this.strayCapture?.reset();
 		if (this.neutralizedThresholdSnapshot.size > 0) {
@@ -1131,6 +1143,7 @@ var AgentReporter = class {
 	async onTestRunEnd(testModules, unhandledErrors, reason) {
 		if (this.rendered) return;
 		this.rendered = true;
+		const executionTimeMs = this.runStartedAt !== void 0 ? performance.now() - this.runStartedAt : void 0;
 		const errors = unhandledErrors;
 		this.strayCapture?.flush();
 		const strayOutput = this.strayCapture?.snapshot();
@@ -1169,6 +1182,26 @@ var AgentReporter = class {
 			});
 		}
 		const modules = testModules;
+		const writeFailureSummary = (summaryReports) => {
+			const consoleMode = this.options.consoleMode ?? "passthrough";
+			if (!shouldWriteFailureSummary(consoleMode)) return;
+			try {
+				const summary = formatFailureSummary(summaryReports, reason);
+				if (summary === void 0) return;
+				const printers = consoleMode === "stream" ? (this.reporters ?? []).flatMap((reporter) => reporter.printStrayLine !== void 0 ? [reporter.printStrayLine] : []) : [];
+				if (printers.length === 0) {
+					process.stderr.write(`${summary}\n`);
+					return;
+				}
+				for (const line of summary.split("\n")) if (!printers.some((print) => {
+					try {
+						return print("stderr", line);
+					} catch {
+						return false;
+					}
+				})) process.stderr.write(`${line}\n`);
+			} catch {}
+		};
 		const opts = this.options;
 		const stashedCoverage = this.coverage;
 		const stashedVitest = this._vitest;
@@ -1214,6 +1247,7 @@ var AgentReporter = class {
 		const wantsRunEvents = this.wantsRunEvents();
 		let dbPath;
 		let persistDisabled;
+		let migrationFailed = false;
 		if (opts.persist) try {
 			dbPath = await this.ensureDbPath();
 		} catch (err) {
@@ -1222,6 +1256,42 @@ var AgentReporter = class {
 		const retention = dbPath === void 0 || persistDisabled !== void 0 ? Option.none() : opts.retention === false ? Option.none() : opts.retention !== void 0 ? Option.some(opts.retention) : await resolveRetentionPolicyCached(process.cwd());
 		const filteredModules = opts.projectFilter ? modules.filter((m) => (m.project.name || "default") === opts.projectFilter) : modules;
 		if (filteredModules.length === 0 && opts.projectFilter) return;
+		const projectModuleCounts = /* @__PURE__ */ new Map();
+		for (const m of modules) {
+			const key = m.project.name || "default";
+			projectModuleCounts.set(key, (projectModuleCounts.get(key) ?? 0) + 1);
+		}
+		const primaryProject = Array.from(projectModuleCounts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+		const isFirstProject = !opts.projectFilter || opts.projectFilter === primaryProject;
+		const vitestInstance = typeof stashedVitest === "object" && stashedVitest !== null ? stashedVitest : void 0;
+		const performanceHints = isFirstProject && vitestInstance !== void 0 ? collectPerformanceHints(vitestInstance, executionTimeMs ?? 0, { isCI: runsInCi() }) : [];
+		let coverageScanMs = 0;
+		const buildRunDiagnostics = (persistMs, persistence) => isFirstProject ? {
+			performanceHints,
+			postRun: {
+				persistMs,
+				coverageScanMs,
+				totalMs: persistMs + coverageScanMs,
+				...executionTimeMs !== void 0 && { vitestDurationMs: executionTimeMs }
+			},
+			...persistence !== void 0 && { persistence }
+		} : void 0;
+		const suggestedActionsFor = (diagnostics) => {
+			const actions = [...opts.suggestedActions ?? [], ...diagnostics !== void 0 ? suggestedActionsFromRunDiagnostics(diagnostics) : []];
+			return actions.length > 0 ? actions : void 0;
+		};
+		const publishDiagnostics = (diagnostics, renderMs) => {
+			if (!isFirstProject || vitestInstance === void 0) return;
+			publishRunDiagnostics(vitestInstance, diagnostics !== void 0 && renderMs !== void 0 ? {
+				...diagnostics,
+				postRun: {
+					...diagnostics.postRun,
+					renderMs
+				}
+			} : diagnostics);
+		};
+		let runDiagnostics;
+		let renderMs;
 		const coverageRoot = (() => {
 			const root = stashedVitest?.config?.root;
 			return typeof root === "string" ? root : void 0;
@@ -1237,15 +1307,8 @@ var AgentReporter = class {
 				...exclude !== void 0 ? { exclude } : {}
 			};
 		})();
-		const analyzeCoverage = (baselines) => Effect.gen(function* () {
+		const analyzeCoverageUntimed = (baselines) => Effect.gen(function* () {
 			const analyzer = yield* CoverageAnalyzer;
-			const projectModuleCounts = /* @__PURE__ */ new Map();
-			for (const m of modules) {
-				const key = m.project.name || "default";
-				projectModuleCounts.set(key, (projectModuleCounts.get(key) ?? 0) + 1);
-			}
-			const primaryProject = Array.from(projectModuleCounts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
-			const isFirstProject = !opts.projectFilter || opts.projectFilter === primaryProject;
 			const coverageOpts = {
 				thresholds: opts.coverageThresholds,
 				includeBareZero: opts.includeBareZero,
@@ -1291,6 +1354,12 @@ var AgentReporter = class {
 			}
 			return coverageReport;
 		});
+		const analyzeCoverage = (baselines) => Effect.suspend(() => {
+			const startedAt = performance.now();
+			return analyzeCoverageUntimed(baselines).pipe(Effect.ensuring(Effect.sync(() => {
+				coverageScanMs += performance.now() - startedAt;
+			})));
+		});
 		if (opts.coverageMode === "ui-only" || !opts.persist) {
 			const uiProjectGroups = /* @__PURE__ */ new Map();
 			for (const mod of filteredModules) {
@@ -1301,6 +1370,7 @@ var AgentReporter = class {
 			}
 			const isMultiProject = uiProjectGroups.size > 1 || !!opts.projectFilter;
 			const uiReports = [];
+			const summaryReports = uiReports;
 			for (const [projectName, projectModules] of uiProjectGroups) {
 				const report = buildAgentReport(projectModules, errors, reason, { omitPassingTests: opts.omitPassingTests }, isMultiProject ? projectName : void 0);
 				uiReports.push(report);
@@ -1342,21 +1412,28 @@ var AgentReporter = class {
 					persist: opts.persist
 				});
 				const reporters = preBuiltReporters ?? normalizeReporters(opts.reporter(kit));
+				runDiagnostics = buildRunDiagnostics(0, void 0);
+				const suggestedActions = suggestedActionsFor(runDiagnostics);
 				const renderInput = {
 					reports: withStrayOutput(reports, strayOutput),
 					classifications: /* @__PURE__ */ new Map(),
-					...opts.suggestedActions !== void 0 && { suggestedActions: opts.suggestedActions }
+					...suggestedActions !== void 0 && { suggestedActions },
+					...runDiagnostics !== void 0 && { runDiagnostics }
 				};
+				const renderStartedAt = performance.now();
 				const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
 				for (const output of allOutputs) routeRenderedOutput(output, {
 					...githubSummaryFile !== void 0 && { githubSummaryFile },
 					...reportWriter !== null && { writeReport: reportWriter.write }
 				});
+				renderMs = performance.now() - renderStartedAt;
 			});
 			await Effect.runPromise(uiProgram.pipe(Effect.provide(CoverageAnalyzerLive), Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer))).catch((err) => {
 				process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 			});
 			await reportWriter?.flush();
+			publishDiagnostics(runDiagnostics, renderMs);
+			writeFailureSummary(summaryReports);
 			return;
 		}
 		if (dbPath !== void 0 && persistDisabled === void 0) try {
@@ -1384,6 +1461,7 @@ var AgentReporter = class {
 			await ensureMigrated(dbPath, logLevel, logFile, process.env);
 		} catch (err) {
 			persistDisabled = formatFatalError(err);
+			migrationFailed = true;
 		}
 		const persistProgram = Effect.gen(function* () {
 			const store = yield* DataStore;
@@ -1396,6 +1474,10 @@ var AgentReporter = class {
 			const settings = captureSettings(vitestConfig, vitestVersion);
 			const settingsHash = hashSettings(settings);
 			const envVars = captureEnvVars(process.env);
+			const runtimeEnv = RuntimeEnv.fromRecord(process.env);
+			const ciRun = Option.isSome(runtimeEnv.ci) && runtimeEnv.ci.value === "github-actions" ? Option.getOrUndefined(runtimeEnv.ciRun) : void 0;
+			const ciCommitSha = ciRun === void 0 ? null : Option.getOrNull(ciRun.sha);
+			const ciRefName = ciRun === void 0 ? null : Option.getOrNull(ciRun.refName);
 			const projectGroups = /* @__PURE__ */ new Map();
 			for (const mod of filteredModules) {
 				const key = mod.project.name || "default";
@@ -1434,8 +1516,8 @@ var AgentReporter = class {
 						project,
 						settingsHash,
 						timestamp: baseReport.timestamp,
-						commitSha: process.env.GITHUB_SHA ?? null,
-						branch: process.env.GITHUB_REF_NAME ?? null,
+						commitSha: ciCommitSha,
+						branch: ciRefName,
 						reason: projectReason,
 						duration: totalDuration,
 						total: baseReport.summary.total,
@@ -1446,8 +1528,8 @@ var AgentReporter = class {
 						actorType: attribution.actorType,
 						agentId: attribution.agentId,
 						conversationId: attribution.conversationId,
-						gitBranch: process.env.GITHUB_REF_NAME ?? null,
-						gitCommitSha: process.env.GITHUB_SHA ?? null,
+						gitBranch: ciRefName,
+						gitCommitSha: ciCommitSha,
 						hostSource: hostProbe.source,
 						hostValue: hostProbe.value,
 						hostMetadata: hostProbe.metadata,
@@ -1800,14 +1882,26 @@ var AgentReporter = class {
 		});
 		let persistFailure;
 		let persistResult;
-		if (persistDisabled === void 0 && dbPath !== void 0) persistResult = await Effect.runPromise(persistProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(ReporterLive({
-			dbPath,
-			env: process.env,
-			logLevel,
-			logFile
-		})))).catch((err) => {
-			persistFailure = formatFatalError(err);
+		let persistMs = 0;
+		if (persistDisabled === void 0 && dbPath !== void 0) {
+			const persistStartedAt = performance.now();
+			persistResult = await Effect.runPromise(persistProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(ReporterLive({
+				dbPath,
+				env: process.env,
+				logLevel,
+				logFile
+			})))).catch((err) => {
+				persistFailure = formatFatalError(err);
+			});
+			persistMs = Math.max(0, performance.now() - persistStartedAt - coverageScanMs);
+		}
+		const persistError = persistDisabled ?? persistFailure;
+		runDiagnostics = buildRunDiagnostics(persistMs, persistError === void 0 ? { ok: true } : {
+			ok: false,
+			reason: persistError,
+			...persistDisabled !== void 0 && migrationFailed && { migrationFailed: true }
 		});
+		const suggestedActions = suggestedActionsFor(runDiagnostics);
 		const renderInputData = persistResult ?? {
 			reports: fallbackReports,
 			classifications: /* @__PURE__ */ new Map()
@@ -1855,9 +1949,11 @@ var AgentReporter = class {
 			const renderInput = {
 				reports: withStrayOutput(reports, strayOutput),
 				classifications,
-				...opts.suggestedActions !== void 0 && { suggestedActions: opts.suggestedActions },
-				...trendSummary !== void 0 && { trendSummary }
+				...suggestedActions !== void 0 && { suggestedActions },
+				...trendSummary !== void 0 && { trendSummary },
+				...runDiagnostics !== void 0 && { runDiagnostics }
 			};
+			const renderStartedAt = performance.now();
 			const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
 			yield* Effect.logDebug("reporters rendered").pipe(Effect.annotateLogs({
 				reporterCount: reporters.length,
@@ -1867,13 +1963,15 @@ var AgentReporter = class {
 				...githubSummaryFile !== void 0 && { githubSummaryFile },
 				...reportWriter !== null && { writeReport: reportWriter.write }
 			});
+			renderMs = performance.now() - renderStartedAt;
 		});
 		await Effect.runPromise(renderProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer))).catch((err) => {
 			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 		});
 		await reportWriter?.flush();
-		const persistError = persistDisabled ?? persistFailure;
+		publishDiagnostics(runDiagnostics, renderMs);
 		if (persistError !== void 0) process.stderr.write(`vitest-agent: persistence failed — results above were rendered but NOT recorded: ${persistError}\n`);
+		writeFailureSummary(renderInputData.reports);
 	}
 };
 

package/utils/collect-performance-hints.js

@@ -0,0 +1,205 @@
+import { formatTime, getEnvironmentDiagnostics, getImportDiagnostics, getIsolateDiagnostic, getTransformDiagnostics } from "./vitest-diagnostics.js";
+
+// src/utils/collect-performance-hints.ts
+const LEARN_MORE = {
+	environment: "https://vitest.dev/guide/improving-performance#test-environments",
+	import: "https://vitest.dev/guide/improving-performance#test-isolation",
+	transform: "https://vitest.dev/guide/improving-performance#caching-between-reruns",
+	isolate: "https://vitest.dev/guide/improving-performance#test-isolation"
+};
+/**
+* Summed time of all tracked phases of a file (base.ts `trackedFileTime`).
+* The transform wait is part of `setupDuration`/`collectDuration`, so it is
+* not added separately.
+*/
+const trackedFileTime = (file) => (file.environmentLoad || 0) + (file.setupDuration || 0) + (file.collectDuration || 0) + (file.prepareDuration || 0) + (file.result?.duration || 0);
+const pct = (share) => Math.round(share * 100);
+const projectFilesOf = (files, name) => files.filter((file) => (file.projectName || "") === name);
+const nameOf = (project) => project.name ?? "";
+const withProject = (name) => name ? { project: name } : {};
+function environmentHints(vitest, projects, files, executionTime) {
+	const maxWorkers = vitest.config?.maxWorkers ?? 1;
+	const inputs = projects.map((project) => {
+		const name = nameOf(project);
+		const config = project.config ?? {};
+		let environmentTime = 0;
+		let environmentCount = 0;
+		let trackedTime = 0;
+		for (const file of projectFilesOf(files, name)) {
+			if (file.environmentLoad) {
+				environmentTime += file.environmentLoad;
+				environmentCount++;
+			}
+			trackedTime += trackedFileTime(file);
+		}
+		return {
+			name,
+			environment: config.environment ?? "",
+			pool: config.pool ?? "",
+			isolate: config.isolate === true,
+			browser: config.browser?.enabled === true,
+			poolProvided: Boolean(config.providedOptions?.pool),
+			isolateProvided: Boolean(config.providedOptions?.isolate),
+			environmentTime,
+			environmentCount,
+			trackedTime,
+			parallelism: Math.max(1, Math.min(environmentCount, maxWorkers)),
+			executionTime
+		};
+	});
+	return getEnvironmentDiagnostics(inputs).map((d) => ({
+		kind: "environment",
+		...withProject(d.name),
+		message: `${d.environment} was created ${d.environmentCount} times · ${formatTime(d.environmentTime)} total, ${pct(d.share)}% of tracked time`,
+		remedy: "pool: 'vmThreads'",
+		detail: d.suggestIsolate ? "create it once per worker (keeps per-file isolation) or isolate: false (shares it across files)" : "create it once per worker (keeps per-file isolation)",
+		learnMoreUrl: LEARN_MORE.environment,
+		share: d.share
+	}));
+}
+function importHints(vitest, projects, files, executionTime) {
+	const maxWorkers = vitest.config?.maxWorkers ?? 1;
+	const metadata = vitest.state?.metadata ?? {};
+	const inputs = projects.map((project) => {
+		const name = nameOf(project);
+		const config = project.config ?? {};
+		const projectFiles = projectFilesOf(files, name);
+		let importTime = 0;
+		let trackedTime = 0;
+		for (const file of projectFiles) {
+			importTime += Math.max((file.collectDuration || 0) - (file.collectFetchDuration || 0), 0);
+			trackedTime += trackedFileTime(file);
+		}
+		const durations = metadata[name]?.duration;
+		return {
+			name,
+			pool: config.pool ?? "",
+			isolate: config.isolate === true,
+			browser: config.browser?.enabled === true,
+			isolateProvided: Boolean(config.providedOptions?.isolate),
+			importTime,
+			trackedTime,
+			fetchCounts: durations ? Object.values(durations).map((times) => times.length) : [],
+			fileCount: projectFiles.length,
+			parallelism: Math.max(1, Math.min(projectFiles.length, maxWorkers)),
+			executionTime
+		};
+	});
+	return getImportDiagnostics(inputs).map((d) => ({
+		kind: "import",
+		...withProject(d.name),
+		message: `${d.uniqueModules} modules were evaluated ${d.totalFetches} times · ${formatTime(d.importTime)} total, ${pct(d.share)}% of tracked time`,
+		remedy: "isolate: false",
+		detail: `~${formatTime(d.estimatedSaving)} faster — shared modules are evaluated once per worker instead of once per file`,
+		learnMoreUrl: LEARN_MORE.import,
+		estimatedSavingMs: d.estimatedSaving,
+		share: d.share
+	}));
+}
+function transformHints(projects, files, executionTime, isCI) {
+	const inputs = projects.map((project) => {
+		const name = nameOf(project);
+		const config = project.config ?? {};
+		let transformTime = 0;
+		let trackedTime = 0;
+		for (const file of projectFilesOf(files, name)) {
+			transformTime += (file.setupFetchDuration || 0) + (file.collectFetchDuration || 0);
+			trackedTime += trackedFileTime(file);
+		}
+		return {
+			name,
+			transformTime,
+			trackedTime,
+			fsModuleCache: config.fsModuleCache === true,
+			fsModuleCacheProvided: Boolean(config.providedOptions?.fsModuleCache),
+			executionTime
+		};
+	});
+	return getTransformDiagnostics(inputs).map((d) => ({
+		kind: "transform",
+		...withProject(d.name),
+		message: `transforming modules took ${formatTime(d.transformTime)} · ${pct(d.share)}% of tracked time, re-done on every run`,
+		remedy: "fsModuleCache: true",
+		detail: isCI ? "persist transforms across runs; on CI this only helps when the cache directory is persisted between runs" : "persist transforms across runs",
+		learnMoreUrl: LEARN_MORE.transform,
+		share: d.share
+	}));
+}
+function isolateHint(vitest, projects, files, executionTime) {
+	const config = vitest.config ?? {};
+	const isEligible = (project) => project.config?.isolate === true && project.config.browser?.enabled !== true && !project.config.providedOptions?.isolate;
+	const measuresModules = (config.experimental?.importDurations?.limit ?? 0) > 0;
+	const moduleSelfTimes = /* @__PURE__ */ new Map();
+	if (measuresModules) {
+		const eligibleProjects = new Set(projects.filter((project) => (project.config?.pool === "forks" || project.config?.pool === "threads") && isEligible(project)).map(nameOf));
+		for (const file of files) {
+			if (!eligibleProjects.has(file.projectName || "") || !file.importDurations) continue;
+			for (const moduleId in file.importDurations) {
+				let times = moduleSelfTimes.get(moduleId);
+				if (!times) {
+					times = [];
+					moduleSelfTimes.set(moduleId, times);
+				}
+				times.push(file.importDurations[moduleId]?.selfTime ?? 0);
+			}
+		}
+	}
+	const d = getIsolateDiagnostic({
+		numWorkers: vitest.state?.workersSpawned ?? 0,
+		isolates: projects.some(isEligible),
+		numFiles: files.length,
+		startupTime: vitest.state?.startupTime ?? 0,
+		maxWorkers: config.maxWorkers ?? 1,
+		measuresModules,
+		moduleSelfTimes: moduleSelfTimes.values(),
+		executionTime
+	});
+	if (d === void 0) return void 0;
+	return {
+		kind: "isolate",
+		message: `${d.numWorkers} workers spawned · ~${formatTime(d.avgStartup)} startup each (spawn + environment, per file)`,
+		remedy: "isolate: false",
+		detail: `${d.measuresModules ? "" : "at least "}~${formatTime(d.estimatedSaving)} faster — ${d.measuresModules ? "reuses workers across files and evaluates shared modules once per worker" : "reuses workers across files instead of one per file"}`,
+		learnMoreUrl: LEARN_MORE.isolate,
+		estimatedSavingMs: d.estimatedSaving
+	};
+}
+/**
+* Compute the performance hints Vitest's `BaseReporter` would print at the
+* end of a run, for runs where `AgentPlugin` stripped that reporter. Applies
+* Vitest's gating (watch mode, merged blob reports, and each kind's
+* `experimental.diagnostics` flag) and its one-hint-per-family order:
+* environment, else import, else transform; isolate only when none of those
+* produced a hint. Never throws; an unrecognized `vitest` shape yields `[]`.
+*
+* @param vitest - The Vitest instance (read structurally)
+* @param executionTimeMs - Wall time of the run, in milliseconds
+* @param options - See {@link CollectPerformanceHintsOptions}
+* @internal
+*/
+function collectPerformanceHints(vitest, executionTimeMs, options = {}) {
+	try {
+		const v = vitest;
+		const config = v.config;
+		if (config === void 0 || config === null || typeof config !== "object" || config.watch) return [];
+		const projects = Array.isArray(v.projects) ? v.projects : [];
+		const getFiles = v.state?.getFiles;
+		const files = typeof getFiles === "function" ? getFiles.call(v.state) ?? [] : [];
+		const diagnostics = config.experimental?.diagnostics ?? {};
+		if (!v.state?.blobs) {
+			const familyHints = diagnostics.environment ? environmentHints(v, projects, files, executionTimeMs) : [];
+			if (familyHints.length > 0) return familyHints;
+			const imports = diagnostics.import ? importHints(v, projects, files, executionTimeMs) : [];
+			if (imports.length > 0) return imports;
+			const transforms = diagnostics.transform ? transformHints(projects, files, executionTimeMs, options.isCI === true) : [];
+			if (transforms.length > 0) return transforms;
+		}
+		if (!diagnostics.isolate) return [];
+		const isolate = isolateHint(v, projects, files, executionTimeMs);
+		return isolate === void 0 ? [] : [isolate];
+	} catch {
+		return [];
+	}
+}
+
+export { collectPerformanceHints };

package/utils/discover-projects.js

@@ -1,9 +1,10 @@
 import { toPosixPath } from "./to-posix-path.js";
-import { nodeWalkerFs } from "./walker-fs.js";
+import { directorySignature } from "./find-test-files.js";
 import { DefaultDiscoverStrategy } from "./discover-strategy.js";
 import { isTestShapedPackage } from "./is-test-shaped-package.js";
 import { isAbsolute, join, normalize, relative } from "node:path";
-import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR } from "@vitest-agent/sdk";
+import { SRC_DIR, TEST_DIR } from "@vitest-agent/sdk";
+import { nodeWalkerSyncOps } from "@effected/walker/node-sync";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 import { nodeSyncOps } from "@effected/workspaces/node-sync";
 
@@ -68,61 +69,26 @@ function recordDiscoveryScanTimestamp() {
 }
 const _cache = /* @__PURE__ */ new Map();
 /**
-* Computes a cheap signature (relative path + mtimeMs pairs, sorted) for every
-* file nested under `dirPath`. Used to detect added/removed/moved/renamed test
-* files between `discoverProjects` calls without re-walking test-file globs.
-* Returns an empty string when `dirPath` does not exist — this still produces
-* a stable, comparable signature contribution.
-*
-* Manual per-directory walk (not a single `readdir({ recursive: true })`
-* call) pruning `NON_DISCOVERABLE_DIRS` *before* recursing: a `src/` or
-* `__test__/` dir can itself contain a fixture `node_modules` (e.g. a
-* subprocess-e2e fixture that installs deps), and Node's recursive `readdir`
-* follows symlinked directories, so an unguarded call would walk into it.
-*/
-async function computeDirSignature(dirPath, fs) {
-	const parts = [];
-	await walkDirSignature(dirPath, dirPath, parts, fs);
-	parts.sort();
-	return parts.join("|");
-}
-async function walkDirSignature(root, dir, parts, fs) {
-	let entries;
-	try {
-		entries = await fs.readDirectory(dir);
-	} catch {
-		return;
-	}
-	for (const ent of entries) {
-		const fullPath = join(dir, ent.name);
-		if (ent.isDirectory()) {
-			if (NON_DISCOVERABLE_DIRS.has(ent.name)) continue;
-			await walkDirSignature(root, fullPath, parts, fs);
-		} else if (ent.isFile()) {
-			const info = await fs.statEntry(fullPath);
-			if (info === null) continue;
-			const mtimeMs = info.mtimeMs;
-			const relPath = toPosixPath(relative(root, fullPath));
-			parts.push(`${relPath}:${mtimeMs}`);
-		}
-	}
-}
-/**
 * Computes a cheap whole-workspace directory signature from each package's
 * `src/` and `__test__/` directories (issue #100). Only entries + mtimes are
 * read — no file content — so this stays fast for large monorepos. A changed
 * signature means a test file was added, removed, moved, or renamed since
 * the cached result was computed.
 *
+* Each directory's signature is composed from the stats
+* `@effected/walker`'s `descendEntriesSync` already read (relative path plus
+* mtimeMs per file), with the same prune and symlink rules as the test-file
+* walk.
+*
 * Only the two anchored directories are fingerprinted. Discovery cannot see a
 * test file anywhere else, so nothing else can change the emitted project list
 * (issue #227).
 */
-async function computeWorkspaceSignature(packages, fs) {
+function computeWorkspaceSignature(packages, fs) {
 	const parts = [];
 	for (const pkg of packages) {
-		const srcSig = await computeDirSignature(join(pkg.path, SRC_DIR), fs);
-		const testSig = await computeDirSignature(join(pkg.path, TEST_DIR), fs);
+		const srcSig = directorySignature(join(pkg.path, SRC_DIR), fs);
+		const testSig = directorySignature(join(pkg.path, TEST_DIR), fs);
 		parts.push(`${pkg.path}::src=${srcSig}::__test__=${testSig}`);
 	}
 	return parts.join("\n");
@@ -138,7 +104,7 @@ async function discoverProjects(options) {
 	const cwd = options?.cwd;
 	const additionalEntries = options?.additionalEntries ?? [];
 	const configure = options?.configure;
-	const fs = options?.fs ?? nodeWalkerFs;
+	const fs = options?.fs ?? nodeWalkerSyncOps;
 	const syncOps = options?.syncOps ?? nodeSyncOps;
 	const packageEnumerationOptions = {
 		...syncOps,
@@ -151,7 +117,7 @@ async function discoverProjects(options) {
 	const packages = getWorkspacePackagesSync(root, packageEnumerationOptions);
 	let signature;
 	if (useCache) {
-		signature = await computeWorkspaceSignature(packages, fs);
+		signature = computeWorkspaceSignature(packages, fs);
 		const cached = _cache.get(root);
 		if (cached && cached.signature === signature) return cached.result;
 	}

package/utils/discover-strategy.js

@@ -1,10 +1,10 @@
-import { nodeWalkerFs } from "./walker-fs.js";
+import { runsInCi } from "./runs-in-ci.js";
 import { findTestFiles } from "./find-test-files.js";
 import { Tag } from "./tag.js";
+import { statOrNull } from "./walker-fs.js";
 import { join, sep } from "node:path";
-import { RuntimeEnv } from "@effected/env";
 import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX, TEST_HELPER_DIRS } from "@vitest-agent/sdk";
-import { Option } from "effect";
+import { nodeWalkerSyncOps } from "@effected/walker/node-sync";
 import { configDefaults } from "vitest/config";
 
 // src/utils/discover-strategy.ts
@@ -14,10 +14,10 @@ const SETUP_EXTS = [
 	"js",
 	"jsx"
 ];
-async function detectSetupFile(pkgPath, fs) {
+function detectSetupFile(pkgPath, fs) {
 	for (const ext of SETUP_EXTS) {
 		const candidate = join(pkgPath, `vitest.setup.${ext}`);
-		if ((await fs.statEntry(candidate))?.isFile === true) return `vitest.setup.${ext}`;
+		if (statOrNull(fs, candidate)?.isFile() === true) return `vitest.setup.${ext}`;
 	}
 	return null;
 }
@@ -82,14 +82,6 @@ var ConcreteDiscoverStrategy = class ConcreteDiscoverStrategy extends DiscoverSt
 		return new ConcreteDiscoverStrategy(newTags, newClassifyLayers, newBuildProjectLayers);
 	}
 };
-/**
-* Whether the process runs in CI, by `@effected/env`'s `RuntimeEnv` rule: a
-* truthy `GITHUB_ACTIONS`, or a `CI` / `CONTINUOUS_INTEGRATION` that is set,
-* non-empty, and not `false` / `0` (is-in-ci semantics). Read when a strategy is
-* constructed rather than at module load, so the environment in force when
-* `AgentPlugin.discover()` runs is the one that decides.
-*/
-const runsInCi = () => Option.isSome(RuntimeEnv.fromRecord(process.env).ci);
 const defaultTags = (inCi) => [
 	Tag.make("unit"),
 	Tag.make("int", { timeout: 6e4 }),
@@ -118,7 +110,7 @@ var DefaultDiscoverStrategy = class extends DiscoverStrategy {
 		return ["unit"];
 	}
 	async buildProject(input) {
-		const fs = input.fs ?? nodeWalkerFs;
+		const fs = input.fs ?? nodeWalkerSyncOps;
 		const srcPrefix = join(input.path, SRC_DIR);
 		const allFiles = await findTestFiles(input.path, [`${SRC_DIR}/**/${TEST_FILE_GLOB_SUFFIX}`, `${TEST_DIR}/**/${TEST_FILE_GLOB_SUFFIX}`], fs);
 		if (allFiles.length === 0) return null;
@@ -132,7 +124,7 @@ var DefaultDiscoverStrategy = class extends DiscoverStrategy {
 			...[SRC_DIR, TEST_DIR].flatMap((root) => [...NON_DISCOVERABLE_DIRS].map((d) => join(input.path, root, "**", d, "**"))),
 			...hasTestDirTests ? TEST_HELPER_DIRS.map((d) => join(input.path, TEST_DIR, d, "**")) : []
 		];
-		const setupFile = await detectSetupFile(input.path, fs);
+		const setupFile = detectSetupFile(input.path, fs);
 		return {
 			extends: true,
 			test: {