@vitest-agent/plugin 2.5.7 → 3.0.0

package/index.d.ts

@@ -1,7 +1,6 @@
-import { TestTagDefinition } from "@vitest/runner";
 import { AgentPluginOptions, AgentReporterOptions, ConsoleMode, CoverageBaselines, CoverageInput, CoverageLevel, CoverageLevelName, CoverageLevelName as CoverageLevelName$1, CoverageReport, EnvironmentDetector, OutputFormat, ResolvedReporterConfig, ResolvedThresholds, RunEvent, SettingsInput, StackFrameInput, Transport, VitestAgentReporterFactory, resolveCoverageInput, validateCoverageConfig } from "@vitest-agent/sdk";
 import { Context, Effect, Layer, LogLevel, Option } from "effect";
-import { TestProjectInlineConfiguration } from "vitest/config";
+import { TestProjectInlineConfiguration, TestTagDefinition } from "vitest/config";
 import { ResolvedConfig, VitestPluginContext } from "vitest/node";
 import { SourceMap } from "magic-string";
 import { WorkspacesSyncOptions } from "@effected/workspaces/node-sync";
@@ -323,8 +322,10 @@ export declare function AgentPlugin(options?: AgentPluginConstructorOptions, _la
  * passed to Vitest's native `coverage.thresholds`; the `coverageTargets`
  * half is passed to `AgentPlugin({ coverageTargets })`.
  *
- * `thresholds` carries the optional `perFile` flag; `coverageTargets`
- * does not — it inherits `perFile` from `coverage.thresholds.perFile`.
+ * `thresholds` carries the optional top-level `perFile` flag. Under
+ * Vitest 5 a glob-pattern entry may carry its own `perFile`, and a file a
+ * pattern matches does NOT inherit the top-level one — the top-level
+ * setting applies only to files no pattern matches.
  * @public
  */
 interface CoverageLevelPreset {
@@ -384,9 +385,14 @@ export declare namespace AgentPlugin {
   /**
    * Tolerance functions for Vitest's `coverage.thresholds.autoUpdate` field.
    *
-   * Vitest's contract: `autoUpdate?: boolean | ((newThreshold: number) => number)`.
-   * Pass one of these functions directly. `standard` floors; `strict` ceils;
-   * `lenient` floors and subtracts 2 (clamped to 0) to leave a slack buffer.
+   * Vitest's contract is
+   * `autoUpdate?: boolean | ((newThreshold: number, previousThreshold: number) => number)`.
+   * Pass one of these functions directly. `standard` floors the new value;
+   * `strict` ceils it; `lenient` floors and subtracts 2 (clamped to 0) to
+   * leave a slack buffer, and never returns a value below
+   * `previousThreshold` — so a temporary coverage dip cannot ratchet the
+   * configured floor downward. `standard` and `strict` ignore
+   * `previousThreshold`.
    *
    * ```ts
    * defineConfig({
@@ -398,9 +404,9 @@ export declare namespace AgentPlugin {
    * ```
    */
   const COVERAGE_AUTOUPDATE: Readonly<{
-    standard: (n: number) => number;
-    strict: (n: number) => number;
-    lenient: (n: number) => number;
+    standard: (next: number, previous: number) => number;
+    strict: (next: number, previous: number) => number;
+    lenient: (next: number, previous: number) => number;
   }>;
   /**
    * Discover Vitest project configs and tag definitions from the workspace layout.
@@ -511,6 +517,13 @@ interface AgentReporterConstructorOptions extends AgentReporterOptions {
   format?: OutputFormat;
   mcp?: boolean;
   githubActions?: boolean;
+  /**
+   * The `.vitest/<scope>` directory name for `report`-targeted rendered
+   * output. Undefined disables report files.
+   *
+   * @internal
+   */
+  reportScope?: string;
   transport?: Transport;
   /**
    * Optional `test.passWithNoTests` value the plugin captured from the
@@ -549,6 +562,10 @@ interface AgentReporterConstructorOptions extends AgentReporterOptions {
  * results via Vitest's native `TestProject` API. In single-project mode,
  * results are written with project name "default".
  *
+ * Not to be confused with Vitest 5's own `AgentReporter` export from
+ * `vitest/node` (an alias of `MinimalReporter`) — this is
+ * `@vitest-agent/plugin`'s `AgentReporter`, an unrelated class.
+ *
  * @privateRemarks
  * The `onCoverage` hook fires **before** `onTestRunEnd` in Vitest's lifecycle.
  * Coverage data must be stashed as instance state and merged during
@@ -600,6 +617,11 @@ export declare class AgentReporter {
    * @internal
    */
   _vitest: unknown;
+  /**
+   * Lazily-created writer for `report`-targeted output. Null when
+   * `reportScope` is unset (report files disabled) or before `onInit`.
+   */
+  private reportWriter;
   private coverage;
   private logLevel;
   private logFile;
@@ -969,6 +991,18 @@ export declare class AgentReporter {
     };
   }, annotation: {
     message: string;
+    type?: string;
+    location?: {
+      file: string;
+      line: number;
+      column: number;
+    };
+    attachment?: {
+      contentType?: string;
+      path?: string;
+      body?: string | Uint8Array;
+      bodyEncoding?: "base64" | "utf-8";
+    };
   }): void;
   /**
    * Vitest streaming hook: a test case recorded an artifact.
@@ -985,6 +1019,17 @@ export declare class AgentReporter {
     };
   }, artifact: {
     type?: string;
+    location?: {
+      file: string;
+      line: number;
+      column: number;
+    };
+    attachments?: ReadonlyArray<{
+      contentType?: string;
+      path?: string;
+      body?: string | Uint8Array;
+      bodyEncoding?: "base64" | "utf-8";
+    }>;
   }): void;
   /**
    * Vitest streaming hook: watch mode has finished its initial run and
@@ -1036,6 +1081,23 @@ export declare class AgentReporter {
   onTestRunEnd(testModules: ReadonlyArray<unknown>, unhandledErrors: ReadonlyArray<unknown>, reason: "passed" | "failed" | "interrupted"): Promise<void>;
 }
 //#endregion
+//#region src/utils/configuration-error.d.ts
+/**
+ * A mistake in the user's own `AgentPlugin` configuration — a bad report
+ * scope, an unsafe report filename — as opposed to an internal failure of
+ * the plugin.
+ *
+ * `configureVitest` reports these as a single `vitest-agent: <message>`
+ * line on stderr, with no stack trace and no "please report an issue"
+ * banner: there is nothing to report, the user simply needs to fix the
+ * config. Every other throw keeps the `formatFatalError` treatment.
+ *
+ * @public
+ */
+export declare class ConfigurationError extends Error {
+  readonly name = "ConfigurationError";
+}
+//#endregion
 //#region src/utils/discover-projects.d.ts
 /**
  * The resolved output of `discoverProjects` — projects and tag definitions ready for `defineConfig`.
@@ -1353,9 +1415,12 @@ export declare function resolveThresholds(input: VitestThresholdsInput | undefin
  * These are the reporters suppressed when an agent takes over console output.
  *
  * @privateRemarks
- * `"agent"` is the built-in Vitest reporter added in v4.1 that reduces
- * console noise for AI agents. We strip it because our reporter replaces
- * its functionality with structured markdown output.
+ * `"agent"` and `"minimal"` both resolve to Vitest's `MinimalReporter`
+ * class. `"agent"` is the v4.1 spelling; `"minimal"` is the v5 spelling
+ * and is what `configDefaults.reporters` selects whenever `std-env`'s
+ * `isAgent` is true — which is the vitest-agent primary use case. Both
+ * are stripped because our reporter replaces their functionality with
+ * structured markdown output.
  *
  * @see {@link https://vitest.dev/api/advanced/reporters.html | Vitest Reporter docs}
  * @internal
@@ -1382,9 +1447,9 @@ export declare const COVERAGE_LEVELS: Readonly<Record<import("@vitest-agent/sdk"
 export declare const COVERAGE_LEVELS_PER_FILE: Readonly<Record<import("@vitest-agent/sdk").CoverageLevelName, CoverageLevelPreset>>;
 /** Auto-update tolerance functions for `coverage.thresholds.autoUpdate`. Mirrors `AgentPlugin.COVERAGE_AUTOUPDATE`. @public */
 export declare const COVERAGE_AUTOUPDATE: Readonly<{
-  standard: (n: number) => number;
-  strict: (n: number) => number;
-  lenient: (n: number) => number;
+  standard: (next: number, previous: number) => number;
+  strict: (next: number, previous: number) => number;
+  lenient: (next: number, previous: number) => number;
 }>;
 //#endregion
 export { type AddProjectInput, type AgentPluginConstructorOptions, type AgentReporterConstructorOptions, type ClassifyContext, type ClassifyFn, type CoverageInput, CoverageLevel, type CoverageLevelName, type CoverageLevelPreset, type CoverageOptions, type DiscoverBuilder, type DiscoverInput, type PackageJson as DiscoverPackageJson, type DiscoverProjectsOptions, type DiscoverProjectsResult, type DiscoverResult, type DiscoverStrategyCreateOptions, type DiscoverStrategyExtendOptions, type InjectTagsResult, type ModuleInfo, type TagOptions, type ValidationError, type ValidationInfo, type ValidationInput, type ValidationResult, type ValidationWarning, type VitestErrorLike, type VitestStackFrameLike, type VitestThresholdsInput, type WalkerEntry, type WalkerEntryStat, type WalkerFileSystem, resolveCoverageInput, validateCoverageConfig };

package/index.js

@@ -7,6 +7,7 @@ import { ReporterLive } from "./layers/ReporterLive.js";
 import { captureEnvVars } from "./utils/capture-env.js";
 import { captureSettings, hashSettings } from "./utils/capture-settings.js";
 import { processFailure } from "./utils/process-failure.js";
+import { ConfigurationError } from "./utils/configuration-error.js";
 import { AgentReporter } from "./reporter.js";
 import { nodeWalkerFs } from "./utils/walker-fs.js";
 import { findTestFiles } from "./utils/find-test-files.js";
@@ -29,4 +30,4 @@ const COVERAGE_LEVELS_PER_FILE = AgentPlugin.COVERAGE_LEVELS_PER_FILE;
 const COVERAGE_AUTOUPDATE = AgentPlugin.COVERAGE_AUTOUPDATE;
 
 //#endregion
-export { AgentPlugin, AgentReporter, CONSOLE_REPORTERS, COVERAGE_AUTOUPDATE, COVERAGE_LEVELS, COVERAGE_LEVELS_PER_FILE, CURRENT_PLUGIN_VERSION, ConfigValidation, ConfigValidationLive, ConfigValidationTest, CoverageAnalyzer, CoverageAnalyzerLive, CoverageAnalyzerTest, CoverageLevel, DefaultDiscoverStrategy, DiscoverStrategy, ReporterLive, Tag, captureEnvVars, captureSettings, classifyByDirectory, classifyByFilename, combineClassifiers, discoverProjects, findTestFiles, hashSettings, nodeWalkerFs, processFailure, resolveCoverageInput, resolveThresholds, stripConsoleReporters, validateCoverageConfig };
+export { AgentPlugin, AgentReporter, CONSOLE_REPORTERS, COVERAGE_AUTOUPDATE, COVERAGE_LEVELS, COVERAGE_LEVELS_PER_FILE, CURRENT_PLUGIN_VERSION, ConfigValidation, ConfigValidationLive, ConfigValidationTest, ConfigurationError, CoverageAnalyzer, CoverageAnalyzerLive, CoverageAnalyzerTest, CoverageLevel, DefaultDiscoverStrategy, DiscoverStrategy, ReporterLive, Tag, captureEnvVars, captureSettings, classifyByDirectory, classifyByFilename, combineClassifiers, discoverProjects, findTestFiles, hashSettings, nodeWalkerFs, processFailure, resolveCoverageInput, resolveThresholds, stripConsoleReporters, validateCoverageConfig };

package/layers/ConfigValidationLive.js

@@ -8,7 +8,7 @@ import { Effect, Layer } from "effect";
 /**
 * Live implementation of the ConfigValidation service.
 *
-* Implements all seven validation rules from the 2.0 starter rule set.
+* Implements the eight built-in validation rules.
 * Rules run inside `validate(...)` — no I/O at construction time.
 *
 * @packageDocumentation
@@ -90,7 +90,7 @@ function runInvalidTargetValueRule(input, errors, warnings) {
 	});
 	for (const warn of result.warnings) if (warn.code === "PERFILE_ON_TARGETS") warnings.push({
 		code: "PERFILE_ON_TARGETS",
-		message: `The "perFile" key should not be set inside coverageTargets. Set coverage.thresholds.perFile instead.`
+		message: `A top-level "perFile" key should not be set inside coverageTargets. Set coverage.thresholds.perFile instead, or move it inside a glob-pattern entry — under Vitest 5 a glob-pattern entry carries its own perFile and no longer inherits the top-level one.`
 	});
 }
 /**
@@ -119,6 +119,32 @@ function runMissingProviderPackageRule(input, errors) {
 	});
 }
 /**
+* Run the GITHUB_JOB_SUMMARY_COLLISION rule.
+*
+* Vitest 5's `github-actions` reporter writes a markdown job summary by
+* default, and Vitest seeds the reporter from `configDefaults` under
+* `GITHUB_ACTIONS=true`. The plugin normalizes every such entry to
+* `jobSummary.enabled = false` in `configureVitest`, so a bare string or a
+* tuple with no `jobSummary` key is NOT a collision. Only an explicit
+* `jobSummary: { enabled: true }` survives normalization, and that entry
+* collides with the plugin's own step summary under `ci-github`. Runs in
+* both operating modes — it is a reporter concern, not a coverage concern.
+*/
+function runGithubJobSummaryCollisionRule(input, warnings) {
+	const reporters = input.vitestConfig.reporters;
+	if (!Array.isArray(reporters)) return;
+	if (!reporters.some((entry) => {
+		if (!Array.isArray(entry) || entry[0] !== "github-actions") return false;
+		return entry[1]?.jobSummary?.enabled === true;
+	})) return;
+	warnings.push({
+		code: "GITHUB_JOB_SUMMARY_COLLISION",
+		path: "reporters",
+		message: "You enabled the Vitest job summary explicitly on the \"github-actions\" reporter, and vitest-agent also writes a GitHub Actions step summary. Both summaries will appear in the same job.",
+		remediation: "Drop the explicit jobSummary option so the plugin can set { jobSummary: { enabled: false } } for you, or set console.ci to \"silent\" to suppress the plugin's own summary instead."
+	});
+}
+/**
 * Core validation logic. Runs all rules and accumulates results.
 */
 function runAllRules(input) {
@@ -128,6 +154,7 @@ function runAllRules(input) {
 	const mode = resolveMode(input.vitestConfig);
 	runTargetThresholdRules(input, errors, warnings);
 	runInvalidTargetValueRule(input, errors, warnings);
+	runGithubJobSummaryCollisionRule(input, warnings);
 	if (mode === "full") {
 		runUnsupportedProviderRule(input, errors);
 		runMissingProviderPackageRule(input, errors);

package/layers/CoverageAnalyzerLive.js

@@ -39,6 +39,33 @@ function resolveEffectiveThresholds(filePath, resolved) {
 	return resolved.global;
 }
 /**
+* Resolve the per-file threshold override for a file path.
+*
+* Vitest 5 widened `perFile` to `boolean | MetricThresholds` and stopped
+* letting a glob-pattern entry inherit the top-level setting. A matched
+* pattern's own `perFile` is the ONLY per-file setting for that file — a
+* pattern that declares none does not fall back to the top-level one. The
+* top-level `perFile` applies only to files no pattern matches, mirroring
+* Vitest 5.
+*
+* Only an OBJECT-valued setting changes anything here — it replaces the
+* metric numbers used for the per-file check. `true` / `false` / absent
+* all return `null`, which leaves the existing per-file reporting behavior
+* (check against the effective metric thresholds) exactly as it was.
+*/
+function resolveEffectivePerFileThresholds(filePath, resolved) {
+	let setting;
+	let matched = false;
+	for (const [pattern, metrics] of resolved.patterns ?? []) if (matchGlob(filePath, pattern)) {
+		matched = true;
+		setting = metrics.perFile;
+		break;
+	}
+	if (!matched) setting = resolved.perFile;
+	if (setting === void 0 || typeof setting === "boolean") return null;
+	return setting;
+}
+/**
 * Internal coverage processing logic. Shared by both `process` and `processScoped`.
 *
 * @param coverageMap - The value received by `onCoverage`; duck-typed at runtime
@@ -73,7 +100,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		const isBareZero = fileStats.statements === 0 && fileStats.branches === 0 && fileStats.functions === 0 && fileStats.lines === 0;
 		if (isBareZero && !includeBareZero) continue;
 		if (scoped && !testedFileSet?.has(filePath)) continue;
-		const isBelowThreshold = isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(filePath, options.thresholds));
+		const isBelowThreshold = isBelowMetricThresholds(fileStats, resolveEffectivePerFileThresholds(filePath, options.thresholds) ?? resolveEffectiveThresholds(filePath, options.thresholds));
 		if (isBareZero || isBelowThreshold) {
 			const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
 			lowCoverage.push({

package/layers/ReporterLive.js

@@ -1,5 +1,5 @@
 import { CoverageAnalyzerLive } from "./CoverageAnalyzerLive.js";
-import { DataReaderLive, DataStoreLive, HistoryTrackerLive, LoggerLive, OutputPipelineLive, migration0001 } from "@vitest-agent/sdk";
+import { DataReaderLive, DataStoreLive, HistoryTrackerLive, LoggerLive, OutputPipelineLive, PROJECT_MIGRATIONS } from "@vitest-agent/sdk";
 import { Layer } from "effect";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { layer } from "@effect/sql-sqlite-node/SqliteClient";
@@ -13,7 +13,7 @@ import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
 const ReporterLive = (dbPath, logLevel, logFile) => {
 	const SqliteLayer = layer({ filename: dbPath });
 	const PlatformLayer = NodeServices.layer;
-	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration0001 }) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
+	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord(PROJECT_MIGRATIONS) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
 	return Layer.mergeAll(DataStoreLive, CoverageAnalyzerLive, HistoryTrackerLive, OutputPipelineLive).pipe(Layer.provideMerge(DataReaderLive), Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "2.5.7",
+	"version": "3.0.0",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -41,18 +41,18 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.112",
 		"@effect/sql-sqlite-node": "4.0.0-rc.112",
-		"@effected/workspaces": "^0.20.0",
-		"@vitest-agent/cli": "2.2.15",
-		"@vitest-agent/mcp": "2.4.15",
-		"@vitest-agent/reporter": "2.2.4",
-		"@vitest-agent/sdk": "2.5.1",
+		"@effected/workspaces": "^0.20.1",
+		"@vitest-agent/cli": "2.2.16",
+		"@vitest-agent/mcp": "3.0.0",
+		"@vitest-agent/reporter": "3.0.0",
+		"@vitest-agent/sdk": "3.0.0",
 		"effect": "4.0.0-rc.112",
 		"magic-string": "^1.2.3"
 	},
 	"peerDependencies": {
-		"@vitest/coverage-istanbul": "^4.1.0",
-		"@vitest/coverage-v8": "^4.1.0",
-		"vitest": "^4.1.0"
+		"@vitest/coverage-istanbul": "^5.0.0",
+		"@vitest/coverage-v8": "^5.0.0",
+		"vitest": "^5.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/plugin.js

@@ -1,6 +1,8 @@
 import { ConfigValidation } from "./services/ConfigValidation.js";
 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 { AgentReporter } from "./reporter.js";
 import { buildModuleInfo } from "./utils/build-module-info.js";
 import { DefaultDiscoverStrategy } from "./utils/discover-strategy.js";
@@ -11,6 +13,7 @@ import { isBenignViteSourceMapWarning } from "./utils/is-benign-vite-source-map-
 import { resolveCoverageDirIsolation } from "./utils/resolve-coverage-dir-isolation.js";
 import { DEFAULT_BUILT_RECENTLY_MS, DEFAULT_LOCK_STALE_MS, DEFAULT_LOCK_WAIT_TIMEOUT_MS, acquireRunScriptLock, markRunScriptDone, parseLockTimingOverride, releaseRunScriptLock } from "./utils/run-script-lock.js";
 import { stripConsoleReporters } from "./utils/strip-console-reporters.js";
+import { makeTagCacheKeyGenerator } from "./utils/tag-cache-key.js";
 import { execSync } from "node:child_process";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -98,6 +101,14 @@ function resolveFormat(mode) {
 */
 const aggregatedReporterByVitest = /* @__PURE__ */ new WeakSet();
 /**
+* Per-Vitest-instance guard for the `fsModuleCache` cache-key generator.
+* `configureVitest` fires once per project, but the generator is global to
+* the Vitest instance — register it exactly once per run.
+*
+* @internal
+*/
+const cacheKeyGeneratorByVitest = /* @__PURE__ */ new WeakSet();
+/**
 * Guards the coverage.reportsDirectory isolation decision (issue #194) to
 * run at most once per Vitest run — `configureVitest` fires once per
 * project, but `coverage.reportsDirectory` is root-level config shared by
@@ -114,7 +125,7 @@ const coverageDirDecidedByVitest = /* @__PURE__ */ new WeakSet();
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "2.5.7";
+const CURRENT_PLUGIN_VERSION = "3.0.0";
 const TEST_FILE_DIR_RE = new RegExp(`/(?:${SRC_DIR}|${TEST_DIR})/`);
 const isTestFile = (id) => isTestFileName(id) && TEST_FILE_DIR_RE.test(id);
 /**
@@ -169,6 +180,13 @@ function AgentPlugin(options = {}, _layer) {
 	const logLevel = resolveLogLevel();
 	const log = logLevel !== void 0 && logLevel !== "None" ? (...args) => process.stderr.write(`[vitest-agent:plugin] ${args.map(String).join(" ")}\n`) : (..._args) => {};
 	const discoverStrategyResolved = options.discoverStrategy === false ? null : options.discoverStrategy ?? new DefaultDiscoverStrategy();
+	const classifyForCache = (id) => {
+		if (!discoverStrategyResolved) return void 0;
+		const cleanId = id.split("?")[0] ?? id;
+		if (!isTestFile(cleanId)) return void 0;
+		const tags = discoverStrategyResolved.classify({ module: buildModuleInfo(cleanId) });
+		return tags.length === 0 ? void 0 : tags;
+	};
 	const pluginObj = {
 		name: "vitest-agent",
 		configResolved(resolvedConfig) {
@@ -178,8 +196,16 @@ function AgentPlugin(options = {}, _layer) {
 			try {
 				const { vitest, project } = ctx;
 				log("configureVitest called | project:", project?.name ?? "(root)");
+				if (discoverStrategyResolved && !cacheKeyGeneratorByVitest.has(vitest)) {
+					cacheKeyGeneratorByVitest.add(vitest);
+					ctx.defineCacheKeyGenerator(makeTagCacheKeyGenerator(classifyForCache));
+					log("registered fsModuleCache tag cache-key generator");
+				}
 				const env = await Effect.runPromise(Effect.provide(Effect.flatMap(EnvironmentDetector, (d) => d.detect()), layer));
 				const executor = envToExecutor(env);
+				const reportOption = options.report;
+				const reportScope = reportOption === false ? void 0 : executor === "human" && reportOption === void 0 ? void 0 : reportOption?.scope ?? "vitest-agent";
+				if (reportScope !== void 0) assertFlatScope(reportScope);
 				const consoleMode = resolveConsoleMode(options, executor, env);
 				const format = resolveFormat(consoleMode);
 				const mcp = executor === "agent";
@@ -195,7 +221,7 @@ function AgentPlugin(options = {}, _layer) {
 					}
 				}
 				if (env === "ci-github" && consoleMode !== "silent") {
-					log("ensuring github-actions reporter is present");
+					log("normalizing the github-actions reporter entry");
 					const withGithubActions = ensureGithubActionsReporter(vitest.config.reporters);
 					vitest.config.reporters = withGithubActions;
 				}
@@ -258,6 +284,7 @@ function AgentPlugin(options = {}, _layer) {
 					consoleMode,
 					mcp,
 					githubActions,
+					...reportScope !== void 0 && { reportScope },
 					transport,
 					...passWithNoTests !== void 0 ? { passWithNoTests } : {},
 					...options.reporter !== void 0 && { reporter: options.reporter },
@@ -267,20 +294,19 @@ function AgentPlugin(options = {}, _layer) {
 				aggregatedReporterByVitest.add(vitest);
 				log("reporters after push:", vitest.config.reporters.length);
 			} catch (err) {
+				if (err instanceof ConfigurationError) {
+					process.stderr.write(`${err.message}\n`);
+					throw err;
+				}
 				process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 				throw err;
 			}
 		}
 	};
 	if (discoverStrategyResolved) pluginObj.transform = (code, id) => {
-		const cleanId = id.split("?")[0] ?? id;
-		if (!isTestFile(cleanId)) return null;
-		const module = buildModuleInfo(cleanId);
-		const tags = discoverStrategyResolved.classify({ module });
-		if (tags.length === 0) return null;
-		const rewritten = injectTags(code, [...tags]);
-		if (rewritten === null) return null;
-		return rewritten;
+		const tags = classifyForCache(id);
+		if (tags === void 0) return null;
+		return injectTags(code, [...tags]);
 	};
 	return pluginObj;
 }
@@ -340,9 +366,12 @@ function makeDiscoverBuilder(options) {
 		full: buildPreset(CoverageLevel.full, CoverageLevel.full, true)
 	});
 	_AgentPlugin.COVERAGE_AUTOUPDATE = Object.freeze({
-		standard: (n) => Math.floor(n),
-		strict: (n) => Math.ceil(n),
-		lenient: (n) => Math.max(0, Math.floor(n - 2))
+		standard: (next, _previous) => Math.floor(next),
+		strict: (next, _previous) => Math.ceil(next),
+		lenient: (next, previous) => {
+			const slack = Math.max(0, Math.floor(next - 2));
+			return typeof previous === "number" ? Math.max(previous, slack) : slack;
+		}
 	});
 	function discover(strategy) {
 		if (strategy === void 0) return makeDiscoverBuilder({});

package/reporter.js

@@ -6,9 +6,10 @@ import { captureEnvVars } from "./utils/capture-env.js";
 import { captureSettings, hashSettings } from "./utils/capture-settings.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 { routeRenderedOutput } from "./utils/route-rendered-output.js";
 import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, statSync } from "node:fs";
 import { dirname } from "node:path";
 import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, buildAgentReport, coerceErrorField, computeTrend, ensureMigrated, formatFatalError, historyKey, isTimeoutError, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
@@ -89,6 +90,153 @@ function computeUpdatedBaselines(existing, actual, targets) {
 	};
 }
 /**
+* Size of a path-only attachment. Vitest has already rewritten `path`
+* to its `.vitest/attachments/` location (or left an external URL), so
+* a miss here is a dangling or remote descriptor, not an error.
+*/
+const attachmentPathByteSize = (path) => {
+	try {
+		return statSync(path).size;
+	} catch {
+		return 0;
+	}
+};
+/**
+* Read one property off a user-authored artifact or attachment object.
+* Both carry arbitrary user data and may expose live getters that throw,
+* so every read is guarded -- the same discipline `coerceErrorField`
+* applies to error objects.
+*/
+const readField = (raw, key) => {
+	try {
+		return raw[key];
+	} catch {
+		return;
+	}
+};
+/**
+* Normalize one Vitest attachment onto a `TestAttachmentInput`.
+*
+* A `Uint8Array` body is base64-encoded and declared as such, matching
+* what Vitest does for its own consumers. A string body is passed
+* through with whatever encoding the producer declared. `byteSize` is
+* always the size of the decoded payload: the raw array length, the
+* base64-decoded length, the UTF-8 length of a text body, or the
+* on-disk size of a path-only attachment.
+*/
+const toAttachmentInput = (att) => {
+	const raw = att;
+	const contentType = readField(raw, "contentType");
+	const path = readField(raw, "path");
+	const descriptor = {
+		...typeof contentType === "string" && { contentType },
+		...typeof path === "string" && { path }
+	};
+	const body = readField(raw, "body");
+	if (body instanceof Uint8Array) return {
+		...descriptor,
+		body: Buffer.from(body).toString("base64"),
+		bodyEncoding: "base64",
+		byteSize: body.byteLength
+	};
+	if (typeof body === "string") {
+		const bodyEncoding = readField(raw, "bodyEncoding") === "base64" ? "base64" : "utf-8";
+		return {
+			...descriptor,
+			body,
+			bodyEncoding,
+			byteSize: Buffer.byteLength(body, bodyEncoding === "base64" ? "base64" : "utf8")
+		};
+	}
+	return {
+		...descriptor,
+		byteSize: typeof path === "string" ? attachmentPathByteSize(path) : 0
+	};
+};
+const toAttachmentInputs = (attachments) => attachments.map(toAttachmentInput);
+/**
+* Strip the inline body off attachment inputs, leaving only the
+* descriptor (`contentType`, `path`, `byteSize`).
+*
+* The run-event stream is a live channel a subscriber may buffer, log or
+* forward; an inline body can be up to the 64 KiB cap per attachment, so
+* events carry the descriptor and leave the bytes to the database. The
+* persistence path keeps using `toAttachmentInputs`.
+*/
+const toAttachmentDescriptors = (attachments) => toAttachmentInputs(attachments).map(({ body: _body, bodyEncoding: _bodyEncoding, ...descriptor }) => descriptor);
+/**
+* Map Vitest annotations onto `DataStore.writeAnnotations` inputs.
+* @internal
+*/
+const toAnnotationInputs = (testCaseId, annotations) => annotations.map((anno) => ({
+	testCaseId,
+	type: anno.type ?? "notice",
+	message: anno.message,
+	...anno.location !== void 0 && {
+		locationFile: anno.location.file,
+		locationLine: anno.location.line,
+		locationColumn: anno.location.column
+	},
+	attachments: toAttachmentInputs(anno.attachment !== void 0 ? [anno.attachment] : [])
+}));
+/**
+* JSON-encode an artifact's custom fields, minus the ones modelled as
+* their own columns. Returns `undefined` when there is nothing to store
+* or when the object resists encoding -- a throwing getter surfaced by
+* `Object.entries`, or a circular structure `JSON.stringify` rejects.
+* Losing the `data` blob is acceptable; aborting the whole run's
+* persistence over one malformed user artifact is not.
+*/
+const collectArtifactData = (raw, skipMessage) => {
+	try {
+		const custom = {};
+		for (const [key, value] of Object.entries(raw)) {
+			if (key === "type" || key === "location" || key === "attachments") continue;
+			if (key === "message" && skipMessage) continue;
+			custom[key] = value;
+		}
+		if (Object.keys(custom).length === 0) return void 0;
+		return JSON.stringify(custom);
+	} catch {
+		return;
+	}
+};
+/**
+* Map Vitest test artifacts onto `DataStore.writeArtifacts` inputs.
+*
+* `internal:` is a Vitest-reserved type prefix; `internal:annotation`
+* never reaches `artifacts()` anyway, but the guard keeps any future
+* internal type out of `test_artifacts`.
+* @internal
+*/
+const toArtifactInputs = (testCaseId, artifacts) => {
+	const out = [];
+	for (const raw of artifacts) {
+		const rawType = readField(raw, "type");
+		const type = typeof rawType === "string" ? rawType : "";
+		if (type === "" || type.startsWith("internal:")) continue;
+		const location = readField(raw, "location");
+		const rawAttachments = readField(raw, "attachments");
+		const attachments = Array.isArray(rawAttachments) ? rawAttachments : [];
+		const message = readField(raw, "message");
+		const messageIsString = typeof message === "string";
+		const data = collectArtifactData(raw, messageIsString);
+		out.push({
+			testCaseId,
+			type,
+			...messageIsString && { message },
+			...data !== void 0 && { data },
+			...location !== void 0 && {
+				locationFile: location.file,
+				locationLine: location.line,
+				locationColumn: location.column
+			},
+			attachments: toAttachmentInputs(attachments)
+		});
+	}
+	return out;
+};
+/**
 * Vitest Reporter that produces structured output for LLM coding agents.
 *
 * @remarks
@@ -106,6 +254,10 @@ function computeUpdatedBaselines(existing, actual, targets) {
 * results via Vitest's native `TestProject` API. In single-project mode,
 * results are written with project name "default".
 *
+* Not to be confused with Vitest 5's own `AgentReporter` export from
+* `vitest/node` (an alias of `MinimalReporter`) — this is
+* `@vitest-agent/plugin`'s `AgentReporter`, an unrelated class.
+*
 * @privateRemarks
 * The `onCoverage` hook fires **before** `onTestRunEnd` in Vitest's lifecycle.
 * Coverage data must be stashed as instance state and merged during
@@ -157,6 +309,11 @@ var AgentReporter = class {
 	* @internal
 	*/
 	_vitest = null;
+	/**
+	* Lazily-created writer for `report`-targeted output. Null when
+	* `reportScope` is unset (report files disabled) or before `onInit`.
+	*/
+	reportWriter = null;
 	coverage = null;
 	logLevel;
 	logFile;
@@ -254,6 +411,7 @@ var AgentReporter = class {
 			githubActions,
 			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 } : {},
@@ -308,6 +466,10 @@ var AgentReporter = class {
 	*/
 	async onInit(vitest) {
 		this._vitest = vitest;
+		if (this.options.reportScope !== void 0) {
+			assertReportCapable(vitest);
+			this.reportWriter = createReportWriter(vitest, this.options.reportScope);
+		}
 		try {
 			await this.ensureDbPath();
 		} catch {}
@@ -741,7 +903,10 @@ var AgentReporter = class {
 			modulePath,
 			testName: testCase.name,
 			suitePath: this.collectSuitePath(testCase),
-			annotation: annotation.message
+			annotation: annotation.message,
+			annotationType: annotation.type ?? "notice",
+			...annotation.location !== void 0 && { location: annotation.location },
+			attachments: toAttachmentDescriptors(annotation.attachment !== void 0 ? [annotation.attachment] : [])
 		});
 	}
 	/**
@@ -751,12 +916,16 @@ var AgentReporter = class {
 		if (!this.wantsRunEvents()) return;
 		const modulePath = testCase.module?.relativeModuleId ?? "";
 		if (modulePath === "") return;
+		const type = artifact.type ?? "";
+		if (type === "" || type.startsWith("internal:")) return;
 		this.emit({
 			_tag: "TestArtifactRecorded",
 			modulePath,
 			testName: testCase.name,
 			suitePath: this.collectSuitePath(testCase),
-			artifact: artifact.type ?? "artifact"
+			artifact: type,
+			...artifact.location !== void 0 && { location: artifact.location },
+			attachments: toAttachmentDescriptors(artifact.attachments ?? [])
 		});
 	}
 	/**
@@ -869,6 +1038,7 @@ var AgentReporter = class {
 		const opts = this.options;
 		const stashedCoverage = this.coverage;
 		const stashedVitest = this._vitest;
+		const reportWriter = this.reportWriter;
 		const logLevel = this.logLevel;
 		const logFile = this.logFile;
 		const runEvents = this.runEvents;
@@ -964,11 +1134,15 @@ var AgentReporter = class {
 					classifications: /* @__PURE__ */ new Map()
 				};
 				const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
-				for (const output of allOutputs) routeRenderedOutput(output, { ...githubSummaryFile !== void 0 && { githubSummaryFile } });
+				for (const output of allOutputs) routeRenderedOutput(output, {
+					...githubSummaryFile !== void 0 && { githubSummaryFile },
+					...reportWriter !== null && { writeReport: reportWriter.write }
+				});
 			});
 			await Effect.runPromise(uiProgram.pipe(Effect.provide(OutputPipelineLive), Effect.provide(NodeServices.layer))).catch((err) => {
 				process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 			});
+			await reportWriter?.flush();
 			return;
 		}
 		if (dbPath !== void 0 && persistDisabled === void 0) try {
@@ -1167,8 +1341,8 @@ var AgentReporter = class {
 					let testIdx = 0;
 					for (const testCase of mod.children.allTests()) {
 						const result = testCase.result();
+						const testCaseId = testCaseIds[testIdx];
 						if (result?.errors && result.errors.length > 0) {
-							const testCaseId = testCaseIds[testIdx];
 							const inputs = [];
 							for (let ordinal = 0; ordinal < result.errors.length; ordinal++) {
 								const e = result.errors[ordinal];
@@ -1202,6 +1376,10 @@ var AgentReporter = class {
 							}
 							yield* store.writeErrors(runId, inputs);
 						}
+						const annotationInputs = toAnnotationInputs(testCaseId, testCase.annotations?.() ?? []);
+						if (annotationInputs.length > 0) yield* store.writeAnnotations(runId, annotationInputs);
+						const artifactInputs = toArtifactInputs(testCaseId, testCase.artifacts?.() ?? []);
+						if (artifactInputs.length > 0) yield* store.writeArtifacts(runId, artifactInputs);
 						testIdx++;
 					}
 					const modErrors = mod.errors();
@@ -1506,15 +1684,19 @@ var AgentReporter = class {
 				reporterCount: reporters.length,
 				outputs: allOutputs.length
 			}));
-			for (const output of allOutputs) routeRenderedOutput(output, { ...githubSummaryFile !== void 0 && { githubSummaryFile } });
+			for (const output of allOutputs) routeRenderedOutput(output, {
+				...githubSummaryFile !== void 0 && { githubSummaryFile },
+				...reportWriter !== null && { writeReport: reportWriter.write }
+			});
 		});
 		await Effect.runPromise(renderProgram.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(OutputPipelineLive), Effect.provide(NodeServices.layer))).catch((err) => {
 			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
 		});
+		await reportWriter?.flush();
 		const persistError = persistDisabled ?? persistFailure;
 		if (persistError !== void 0) process.stderr.write(`vitest-agent: persistence failed — results above were rendered but NOT recorded: ${persistError}\n`);
 	}
 };
 
 //#endregion
-export { AgentReporter };
+export { AgentReporter, toAnnotationInputs, toArtifactInputs };

package/utils/configuration-error.js

@@ -0,0 +1,19 @@
+//#region src/utils/configuration-error.ts
+/**
+* A mistake in the user's own `AgentPlugin` configuration — a bad report
+* scope, an unsafe report filename — as opposed to an internal failure of
+* the plugin.
+*
+* `configureVitest` reports these as a single `vitest-agent: <message>`
+* line on stderr, with no stack trace and no "please report an issue"
+* banner: there is nothing to report, the user simply needs to fix the
+* config. Every other throw keeps the `formatFatalError` treatment.
+*
+* @public
+*/
+var ConfigurationError = class extends Error {
+	name = "ConfigurationError";
+};
+
+//#endregion
+export { ConfigurationError };

package/utils/ensure-github-reporter.js

@@ -1,23 +1,50 @@
 //#region src/utils/ensure-github-reporter.ts
 /**
-* Ensure a Vitest `reporters` array contains a `github-actions` entry.
+* Ensure a Vitest `reporters` array contains a `github-actions` entry with
+* its markdown job summary disabled.
 *
 * @privateRemarks
-* Vitest only auto-appends its built-in `"github-actions"` reporter when
-* the resolved `reporters` array is EMPTY. Once any other reporter is
-* configured (which the plugin always does), that implicit behavior no
-* longer applies, so `AgentPlugin` calls this explicitly under
-* `env === "ci-github"` to guarantee the entry is present.
+* Under Vitest 5 `github-actions` is seeded into `configDefaults.reporters`
+* whenever `GITHUB_ACTIONS=true`, and `resolveConfig` normalizes every bare
+* reporter name to a `[name, {}]` tuple. So by the time `configureVitest`
+* runs, the common CI case already holds `["github-actions", {}]` — an entry
+* that still writes a markdown job summary, because the reporter's own
+* default is `jobSummary.enabled = true`. The plugin writes its own step
+* summary to `$GITHUB_STEP_SUMMARY` under `env === "ci-github"`, so leaving
+* that entry alone produces two reports in the same job.
+*
+* This function therefore NORMALIZES an existing entry rather than only
+* appending a missing one: a bare string or a tuple whose options leave
+* `jobSummary.enabled` unset becomes
+* `["github-actions", { jobSummary: { enabled: false } }]`, with every other
+* option preserved. The plugin owns the summary, the reporter owns the
+* `::error::` annotations. An explicit `jobSummary.enabled === true` is a
+* deliberate opt-in and is left untouched; the `GITHUB_JOB_SUMMARY_COLLISION`
+* ConfigValidation rule warns about that case instead.
 *
 * @internal
 */
 function ensureGithubActionsReporter(reporters) {
-	if (reporters.some((entry) => {
-		if (typeof entry === "string") return entry === "github-actions";
-		if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0] === "github-actions";
-		return false;
-	})) return reporters;
-	return [...reporters, ["github-actions", {}]];
+	let found = false;
+	const normalized = reporters.map((entry) => {
+		if (entry === "github-actions") {
+			found = true;
+			return ["github-actions", { jobSummary: { enabled: false } }];
+		}
+		if (!Array.isArray(entry) || entry[0] !== "github-actions") return entry;
+		found = true;
+		const options = entry[1] ?? {};
+		if (options.jobSummary?.enabled === true) return entry;
+		return ["github-actions", {
+			...options,
+			jobSummary: {
+				...options.jobSummary,
+				enabled: false
+			}
+		}];
+	});
+	if (found) return normalized;
+	return [...reporters, ["github-actions", { jobSummary: { enabled: false } }]];
 }
 
 //#endregion

package/utils/report-writer.js

@@ -0,0 +1,83 @@
+import { ConfigurationError } from "./configuration-error.js";
+
+//#region src/utils/report-writer.ts
+/**
+* Lazily-created writer over Vitest 5's `createReport` scope directory.
+*
+* `vitest.createReport(scope)` mkdirs `<config.root>/.vitest/<scope>`
+* eagerly and synchronously at call time, so the handle is created on
+* the first write rather than at reporter construction — a run that
+* emits no report-targeted output leaves no directory behind.
+*
+* `clean()` is never called: it would wipe a prior shard's output, and
+* it is a no-op under `--merge-reports` anyway.
+*
+* @internal
+*/
+const VITEST_5_REQUIRED = "vitest-agent: writing report files requires Vitest 5's `createReport` API. Upgrade vitest to ^5.0.0, or set `AgentPlugin({ report: false })`.";
+/**
+* Narrow a Vitest instance to one carrying `createReport`, throwing the
+* upgrade message when it does not.
+*
+* Called eagerly from `onInit` so an unsupported Vitest fails before any
+* rendering happens, rather than mid-way through a routing loop. It only
+* reads the property — `createReport` itself stays uncalled, preserving
+* the lazy directory creation.
+*
+* @internal
+*/
+const assertReportCapable = (vitest) => {
+	if (typeof vitest?.createReport !== "function") throw new Error(VITEST_5_REQUIRED);
+};
+/**
+* Vitest's `Report.writeFile` resolves `filename` against the scope
+* directory with no `mkdir` and no containment check, so a nested path
+* rejects at write time and a `..` segment escapes the directory
+* entirely. Reject both here, where the message can name the culprit.
+*/
+const assertFlatFilename = (filename) => {
+	if (filename.includes("/") || filename.includes("\\") || filename === ".." || filename === ".") throw new ConfigurationError(`vitest-agent: report filename ${filename} must be a flat name — Vitest writes it directly into the report scope directory and creates no intermediate directories.`);
+};
+/**
+* The report scope names a single directory under `<config.root>/.vitest`.
+* Vitest joins it without a containment check, so a `..` segment or a
+* path separator escapes `.vitest` entirely, and an empty scope resolves
+* to `.vitest` itself. Reject all of those here, where the message can
+* name the offending scope.
+*
+* A dot inside the name (`vitest.agent`) is fine — only the bare `.` and
+* `..` traversal names are rejected.
+*
+* @internal
+*/
+const assertFlatScope = (scope) => {
+	if (scope === "" || scope.includes("/") || scope.includes("\\") || scope === "." || scope === "..") throw new ConfigurationError(`vitest-agent: report scope ${JSON.stringify(scope)} must be a single flat directory name — it is created directly under <root>/.vitest and must not traverse or nest.`);
+};
+/** @internal */
+const createReportWriter = (vitest, scope) => {
+	let handle = null;
+	const pending = [];
+	const resolveHandle = () => {
+		if (handle !== null) return handle;
+		const create = vitest?.createReport;
+		if (typeof create !== "function") throw new Error(VITEST_5_REQUIRED);
+		handle = create.call(vitest, scope);
+		return handle;
+	};
+	return {
+		write: (filename, content) => {
+			assertFlatFilename(filename);
+			const report = resolveHandle();
+			pending.push(report.writeFile(filename, content).catch((err) => {
+				process.stderr.write(`vitest-agent: report file ${filename} not written: ${String(err)}\n`);
+			}));
+		},
+		flush: async () => {
+			await Promise.all(pending);
+			pending.length = 0;
+		}
+	};
+};
+
+//#endregion
+export { assertFlatScope, assertReportCapable, createReportWriter };

package/utils/resolve-thresholds.js

@@ -12,6 +12,25 @@ const RESERVED_KEYS = /* @__PURE__ */ new Set([
 	"autoUpdate"
 ]);
 /**
+* Extract the four metric numbers (plus the `100: true` shorthand) from a
+* raw threshold-shaped record. Shared by the global, glob-pattern, and
+* object-valued `perFile` paths.
+*/
+function extractMetrics(obj) {
+	const metrics = {};
+	if (obj["100"] === true) {
+		metrics.lines = 100;
+		metrics.functions = 100;
+		metrics.branches = 100;
+		metrics.statements = 100;
+	}
+	for (const mk of METRIC_KEYS) {
+		const mv = obj[mk];
+		if (typeof mv === "number") metrics[mk] = mv;
+	}
+	return metrics;
+}
+/**
 * Parse Vitest `coverage.thresholds` format into a normalized `ResolvedThresholds`.
 * @param input - The raw `coverage.thresholds` object from Vitest config
 * @returns Normalized thresholds with global, perFile, and pattern entries
@@ -37,21 +56,14 @@ function resolveThresholds(input) {
 		if (typeof value === "number") global[key] = value;
 	}
 	if (input.perFile === true) perFile = true;
+	else if (typeof input.perFile === "object" && input.perFile !== null && !Array.isArray(input.perFile)) perFile = extractMetrics(input.perFile);
 	for (const [key, value] of Object.entries(input)) {
 		if (RESERVED_KEYS.has(key)) continue;
 		if (typeof value !== "object" || value === null) continue;
-		const patternMetrics = {};
 		const obj = value;
-		if (obj["100"] === true) {
-			patternMetrics.lines = 100;
-			patternMetrics.functions = 100;
-			patternMetrics.branches = 100;
-			patternMetrics.statements = 100;
-		}
-		for (const mk of METRIC_KEYS) {
-			const mv = obj[mk];
-			if (typeof mv === "number") patternMetrics[mk] = mv;
-		}
+		const patternMetrics = extractMetrics(obj);
+		if (obj.perFile === true || obj.perFile === false) patternMetrics.perFile = obj.perFile;
+		else if (typeof obj.perFile === "object" && obj.perFile !== null && !Array.isArray(obj.perFile)) patternMetrics.perFile = extractMetrics(obj.perFile);
 		if (Object.keys(patternMetrics).length > 0) patterns.push([key, patternMetrics]);
 	}
 	return {

package/utils/route-rendered-output.js

@@ -16,6 +16,11 @@ import { dirname } from "node:path";
 * GitHub Actions and the user-supplied reporter shouldn't have produced
 * one anyway."
 *
+* `report` outputs carry their own `filename` and go to the plugin's
+* `writeReport` sink — Vitest 5's `createReport` scope directory. When
+* report files are disabled the sink is absent and the output is
+* dropped, mirroring the `github-summary` contract.
+*
 * `file` outputs require an explicit path embedded in the output (a
 * convention reporters should adopt; this helper currently treats `file`
 * as a no-op until we settle on a path field). The default reporter
@@ -37,6 +42,13 @@ const routeRenderedOutput = (output, options) => {
 			} catch {}
 			return;
 		}
+		case "report":
+			try {
+				options.writeReport?.(output.filename, output.content);
+			} catch (err) {
+				process.stderr.write(`vitest-agent: report file ${output.filename} not written: ${String(err)}\n`);
+			}
+			return;
 		case "file": return;
 	}
 };

package/utils/strip-console-reporters.js

@@ -4,9 +4,12 @@
 * These are the reporters suppressed when an agent takes over console output.
 *
 * @privateRemarks
-* `"agent"` is the built-in Vitest reporter added in v4.1 that reduces
-* console noise for AI agents. We strip it because our reporter replaces
-* its functionality with structured markdown output.
+* `"agent"` and `"minimal"` both resolve to Vitest's `MinimalReporter`
+* class. `"agent"` is the v4.1 spelling; `"minimal"` is the v5 spelling
+* and is what `configDefaults.reporters` selects whenever `std-env`'s
+* `isAgent` is true — which is the vitest-agent primary use case. Both
+* are stripped because our reporter replaces their functionality with
+* structured markdown output.
 *
 * @see {@link https://vitest.dev/api/advanced/reporters.html | Vitest Reporter docs}
 * @internal
@@ -19,7 +22,8 @@ const CONSOLE_REPORTERS = /* @__PURE__ */ new Set([
 	"tap",
 	"tap-flat",
 	"hanging-process",
-	"agent"
+	"agent",
+	"minimal"
 ]);
 /**
 * Filter out built-in console reporters from a Vitest reporters array.

package/utils/tag-cache-key.js

@@ -0,0 +1,30 @@
+//#region src/utils/tag-cache-key.ts
+/**
+* Cache-key material for Vitest 5's `fsModuleCache`.
+*
+* The tag-injection transform's output depends on the classification tag
+* set, which Vitest cannot see. Returning this string from a
+* `defineCacheKeyGenerator` callback folds the tag set into the module
+* cache key, so a changed tag set invalidates the cached prelude.
+*
+* @internal
+*/
+function tagCacheKey(tags) {
+	return `vitest-agent:tags:${[...tags].sort().join(",")}`;
+}
+/**
+* Builds the `defineCacheKeyGenerator` callback from the same per-id
+* classification the `transform` hook uses. Ids the transform would not
+* rewrite contribute nothing to the cache key.
+*
+* @internal
+*/
+function makeTagCacheKeyGenerator(classify) {
+	return (context) => {
+		const tags = classify(context.id);
+		return tags === void 0 ? void 0 : tagCacheKey(tags);
+	};
+}
+
+//#endregion
+export { makeTagCacheKeyGenerator, tagCacheKey };