@vitest-agent/sdk 8.0.0 → 9.0.0

package/schemas/5.0/run.json

@@ -781,6 +781,98 @@
 			"required": ["timestamp", "reason", "summary", "failed", "unhandledErrors", "failedFiles"],
 			"additionalProperties": true
 		},
+		"PerformanceHintKind": {
+			"type": "string",
+			"enum": ["environment", "import", "transform", "isolate"]
+		},
+		"PerformanceHint": {
+			"type": "object",
+			"properties": {
+				"kind": {
+					"$ref": "#/$defs/PerformanceHintKind"
+				},
+				"project": {
+					"type": "string"
+				},
+				"message": {
+					"type": "string"
+				},
+				"remedy": {
+					"type": "string"
+				},
+				"detail": {
+					"type": "string"
+				},
+				"learnMoreUrl": {
+					"type": "string"
+				},
+				"estimatedSavingMs": {
+					"type": "number"
+				},
+				"share": {
+					"type": "number"
+				}
+			},
+			"required": ["kind", "message", "remedy", "detail", "learnMoreUrl"],
+			"additionalProperties": true
+		},
+		"PostRunTiming": {
+			"type": "object",
+			"properties": {
+				"persistMs": {
+					"type": "number"
+				},
+				"coverageScanMs": {
+					"type": "number"
+				},
+				"totalMs": {
+					"type": "number"
+				},
+				"renderMs": {
+					"type": "number"
+				},
+				"vitestDurationMs": {
+					"type": "number"
+				}
+			},
+			"required": ["persistMs", "coverageScanMs", "totalMs"],
+			"additionalProperties": true
+		},
+		"PersistenceStatus": {
+			"type": "object",
+			"properties": {
+				"ok": {
+					"type": "boolean"
+				},
+				"reason": {
+					"type": "string"
+				},
+				"migrationFailed": {
+					"type": "boolean"
+				}
+			},
+			"required": ["ok"],
+			"additionalProperties": true
+		},
+		"RunDiagnostics": {
+			"type": "object",
+			"properties": {
+				"performanceHints": {
+					"type": "array",
+					"items": {
+						"$ref": "#/$defs/PerformanceHint"
+					}
+				},
+				"postRun": {
+					"$ref": "#/$defs/PostRunTiming"
+				},
+				"persistence": {
+					"$ref": "#/$defs/PersistenceStatus"
+				}
+			},
+			"required": ["performanceHints"],
+			"additionalProperties": true
+		},
 		"RunReportFile": {
 			"type": "object",
 			"properties": {
@@ -799,6 +891,9 @@
 					"items": {
 						"$ref": "#/$defs/AgentReport"
 					}
+				},
+				"runDiagnostics": {
+					"$ref": "#/$defs/RunDiagnostics"
 				}
 			},
 			"required": ["schemaVersion", "generatedAt", "reports"],

package/schemas/RunDiagnostics.js

@@ -0,0 +1,61 @@
+import { FiniteNumber } from "./Common.js";
+import { Schema } from "effect";
+
+// src/schemas/RunDiagnostics.ts
+/**
+* Which Vitest performance diagnostic a hint came from.
+* @public
+*/
+const PerformanceHintKind = Schema.Literals([
+	"environment",
+	"import",
+	"transform",
+	"isolate"
+]).annotate({ identifier: "PerformanceHintKind" });
+/**
+* One performance hint derived from Vitest's run diagnostics. `project` is
+* omitted for a hint that applies to the whole run (for example `isolate`).
+* @public
+*/
+const PerformanceHint = Schema.Struct({
+	kind: PerformanceHintKind,
+	project: Schema.optionalKey(Schema.String),
+	message: Schema.String,
+	remedy: Schema.String,
+	detail: Schema.String,
+	learnMoreUrl: Schema.String,
+	estimatedSavingMs: Schema.optionalKey(FiniteNumber),
+	share: Schema.optionalKey(FiniteNumber)
+}).annotate({ identifier: "PerformanceHint" });
+/**
+* Wall-clock timing of the plugin's post-run work, in milliseconds.
+* @public
+*/
+const PostRunTiming = Schema.Struct({
+	persistMs: FiniteNumber,
+	coverageScanMs: FiniteNumber,
+	totalMs: FiniteNumber,
+	renderMs: Schema.optionalKey(FiniteNumber),
+	vitestDurationMs: Schema.optionalKey(FiniteNumber)
+}).annotate({ identifier: "PostRunTiming" });
+/**
+* Whether the run's results were persisted to the database.
+* @public
+*/
+const PersistenceStatus = Schema.Struct({
+	ok: Schema.Boolean,
+	reason: Schema.optionalKey(Schema.String),
+	migrationFailed: Schema.optionalKey(Schema.Boolean)
+}).annotate({ identifier: "PersistenceStatus" });
+/**
+* Run-level diagnostics: performance hints, post-run timing and persistence
+* status (issue #544).
+* @public
+*/
+const RunDiagnostics = Schema.Struct({
+	performanceHints: Schema.Array(PerformanceHint),
+	postRun: Schema.optionalKey(PostRunTiming),
+	persistence: Schema.optionalKey(PersistenceStatus)
+}).annotate({ identifier: "RunDiagnostics" });
+
+export { PerformanceHint, PerformanceHintKind, PersistenceStatus, PostRunTiming, RunDiagnostics };

package/schemas/RunReportFile.js

@@ -1,4 +1,5 @@
 import { AgentReport } from "./AgentReport.js";
+import { RunDiagnostics } from "./RunDiagnostics.js";
 import { Schema } from "effect";
 
 // src/schemas/RunReportFile.ts
@@ -47,7 +48,8 @@ const RunReportFile = Schema.Struct({
 	$schema: Schema.optionalKey(Schema.String),
 	schemaVersion: Schema.Literal(1),
 	generatedAt: IsoInstant,
-	reports: Schema.Array(AgentReport)
+	reports: Schema.Array(AgentReport),
+	runDiagnostics: Schema.optionalKey(RunDiagnostics)
 }).annotate({
 	identifier: "RunReportFile",
 	description: "The vitest-agent run report file (.vitest/vitest-agent/run.json): one AgentReport per Vitest project from the most recent run. Read reports[].summary for pass/fail counts and reports[].failed for the failing modules and their tests. schemaVersion is the envelope contract version; generatedAt is when the run finished."

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }

package/utils/ansi.js

@@ -1,38 +1,4 @@
 // src/utils/ansi.ts
-const ANSI_CODES = {
-	reset: [0, 0],
-	bold: [1, 22],
-	dim: [2, 22],
-	red: [31, 39],
-	green: [32, 39],
-	yellow: [33, 39],
-	cyan: [36, 39]
-};
-/**
-* Wrap text with an ANSI color/style escape code.
-*
-* No-ops when `options.noColor` is true, keeping output as valid plain
-* markdown when captured by agents or piped to files.
-*
-* @privateRemarks
-* Uses raw ANSI escape sequences (`\x1b[...m`) rather than a dependency
-* like `chalk` or `picocolors` to keep the package zero-dependency. The
-* `noColor` flag respects the `NO_COLOR` environment variable convention.
-*
-* @param text - Text to wrap
-* @param color - ANSI code name: `reset`, `bold`, `dim`, `red`, `green`, `yellow`, `cyan`
-* @param options - Control color output
-* @returns Text with ANSI escape codes, or plain text if noColor
-*
-* @see {@link https://no-color.org/ | NO_COLOR convention}
-* @internal
-*/
-function ansi(text, color, options) {
-	if (options?.noColor) return text;
-	const codes = ANSI_CODES[color];
-	if (!codes) return text;
-	return `\x1b[${codes[0]}m${text}\x1b[${codes[1]}m`;
-}
 /**
 * Strip all ANSI escape codes from a string.
 *
@@ -45,4 +11,4 @@ function stripAnsi(text) {
 	return text.replace(/\x1b\[[0-9;]*m/g, "");
 }
 
-export { ansi, stripAnsi };
+export { stripAnsi };

package/utils/run-diagnostics-actions.js

@@ -0,0 +1,58 @@
+// src/utils/run-diagnostics-actions.ts
+/**
+* Post-run work at or above this many milliseconds is always "slow".
+* @public
+*/
+const POST_RUN_SLOW_MS = 5e3;
+/**
+* Post-run work at or above this share of Vitest's own duration is "slow"
+* (once it also clears {@link POST_RUN_SLOW_MIN_MS}).
+* @public
+*/
+const POST_RUN_SLOW_SHARE = .1;
+/**
+* Minimum post-run milliseconds before the share rule applies.
+* @public
+*/
+const POST_RUN_SLOW_MIN_MS = 1e3;
+/**
+* Whether the plugin's post-run work was slow enough to surface.
+* @public
+*/
+function isPostRunSlow(timing) {
+	if (timing.totalMs >= 5e3) return true;
+	return timing.totalMs >= 1e3 && timing.vitestDurationMs !== void 0 && timing.totalMs >= .1 * timing.vitestDurationMs;
+}
+const fmt = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+/**
+* Map run diagnostics onto suggested actions: persistence failure first, then
+* slow post-run work, then performance hints in input order.
+* @public
+*/
+function suggestedActionsFromRunDiagnostics(d) {
+	const out = [];
+	if (d.persistence !== void 0 && !d.persistence.ok) {
+		const { reason, migrationFailed } = d.persistence;
+		out.push({
+			severity: "warn",
+			title: "Results were not saved",
+			detail: migrationFailed ? `${reason ?? "unknown error"}. Run \`vitest-agent db reset\` to recreate the database.` : reason ?? "unknown error"
+		});
+	}
+	if (d.postRun !== void 0 && isPostRunSlow(d.postRun)) {
+		const { totalMs, persistMs, coverageScanMs } = d.postRun;
+		out.push({
+			severity: "warn",
+			title: `Post-run work took ${fmt(totalMs)} (persist ${fmt(persistMs)}, coverage scan ${fmt(coverageScanMs)})`,
+			detail: "Time vitest-agent spent after Vitest finished. Set persist: false where history is not needed (e.g. CI), or narrow coverage.include."
+		});
+	}
+	for (const hint of d.performanceHints) out.push({
+		severity: "info",
+		title: hint.project !== void 0 ? `${hint.project}: ${hint.message}` : hint.message,
+		detail: `${hint.remedy} — ${hint.detail} (${hint.learnMoreUrl})`
+	});
+	return out;
+}
+
+export { POST_RUN_SLOW_MIN_MS, POST_RUN_SLOW_MS, POST_RUN_SLOW_SHARE, isPostRunSlow, suggestedActionsFromRunDiagnostics };

package/utils/vitest-config-files.js

@@ -0,0 +1,24 @@
+// src/utils/vitest-config-files.ts
+/**
+* The config filenames Vitest 5 itself loads, in the order it prefers them:
+* `vitest.config.*` before `vite.config.*`, each across
+* `ts` / `mts` / `cts` / `js` / `mjs` / `cjs`. Mirrors `configFiles` in
+* Vitest's own `constants.ts`. `vitest.workspace.*` is absent on purpose:
+* Vitest no longer reads a workspace file (projects live in the config's
+* `test.projects`).
+*
+* The single source both front ends derive their config lookups from, so the
+* CLI's `check-test-path` and the MCP `run_tests` root walk cannot drift.
+*
+* @public
+*/
+const VITEST_CONFIG_FILES = ["vitest.config", "vite.config"].flatMap((name) => [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+].map((ext) => `${name}.${ext}`));
+
+export { VITEST_CONFIG_FILES };

package/version.js

@@ -11,6 +11,6 @@
 * survives into the published artifact.
 * @public
 */
-const CURRENT_SDK_VERSION = "8.0.0";
+const CURRENT_SDK_VERSION = "9.0.0";
 
 export { CURRENT_SDK_VERSION };

package/utils/compress-lines.js

@@ -1,44 +0,0 @@
-// src/utils/compress-lines.ts
-/**
-* Compress an array of line numbers into a compact range string.
-*
-* Consecutive line numbers are collapsed into `start-end` ranges,
-* separated by commas. Duplicate values are removed and the input
-* is sorted ascending before processing.
-*
-* @param lines - Array of line numbers to compress
-* @returns Compressed range string, or empty string for empty input
-*
-* @example
-* ```typescript
-* import { compressLines } from "@vitest-agent/sdk/utils";
-*
-* compressLines([1, 2, 3, 5, 10, 11, 12]);
-* // Returns: "1-3,5,10-12"
-*
-* compressLines([42]);
-* // Returns: "42"
-*
-* compressLines([]);
-* // Returns: ""
-* ```
-*
-* @public
-*/
-function compressLines(lines) {
-	if (lines.length === 0) return "";
-	const sorted = [...new Set(lines)].sort((a, b) => a - b);
-	const ranges = [];
-	let start = sorted[0];
-	let end = sorted[0];
-	for (let i = 1; i < sorted.length; i++) if (sorted[i] === end + 1) end = sorted[i];
-	else {
-		ranges.push(start === end ? `${start}` : `${start}-${end}`);
-		start = sorted[i];
-		end = sorted[i];
-	}
-	ranges.push(start === end ? `${start}` : `${start}-${end}`);
-	return ranges.join(",");
-}
-
-export { compressLines };

package/utils/detect-pm.js

@@ -1,57 +0,0 @@
-// src/utils/detect-pm.ts
-const LOCKFILE_MAP = [
-	["pnpm-lock.yaml", "pnpm"],
-	["package-lock.json", "npm"],
-	["yarn.lock", "yarn"],
-	["bun.lock", "bun"]
-];
-const RUN_COMMANDS = {
-	pnpm: "pnpm vitest run",
-	npm: "npx vitest run",
-	yarn: "yarn vitest run",
-	bun: "bun vitest run"
-};
-/**
-* Detect the package manager used in a project by inspecting the root directory.
-*
-* @remarks
-* Detection order:
-* 1. The `packageManager` field in `package.json` (e.g., `"pnpm\@10.32.1"`)
-* 2. Lockfile presence: `pnpm-lock.yaml`, `package-lock.json`, `yarn.lock`, `bun.lock`
-*
-* Returns `null` when no package manager can be determined.
-*
-* @param root - Absolute path to the project root directory
-* @param fs - Filesystem adapter for reading files and checking existence
-* @returns The detected package manager, or `null`
-*
-* @internal
-*/
-async function detectPackageManager(root, fs) {
-	try {
-		const raw = await fs.readFile(`${root}/package.json`);
-		const pkg = JSON.parse(raw);
-		if (pkg.packageManager) {
-			const name = pkg.packageManager.split("@")[0];
-			if (name in RUN_COMMANDS) return name;
-		}
-	} catch {}
-	for (const [lockfile, pm] of LOCKFILE_MAP) if (await fs.exists(`${root}/${lockfile}`)) return pm;
-	return null;
-}
-/**
-* Return the vitest run command for the given package manager.
-*
-* Falls back to `"npx vitest run"` when `pm` is `null`.
-*
-* @param pm - Detected package manager, or `null` for unknown
-* @returns Shell command string for running vitest
-*
-* @internal
-*/
-function getRunCommand(pm) {
-	if (!pm) return "npx vitest run";
-	return RUN_COMMANDS[pm];
-}
-
-export { detectPackageManager, getRunCommand };

package/utils/format-console.js

@@ -1,222 +0,0 @@
-import { ansi } from "./ansi.js";
-import { formatScopedCoverageNote } from "./format-scoped-coverage-note.js";
-
-// src/utils/format-console.ts
-/**
-* Return the metric with the lowest percentage from a `FileCoverageReport`.
-*
-* @remarks
-* Used to surface the single worst coverage metric per file in console output,
-* keeping the display compact. Labels are abbreviated: `"Stmts"`, `"Branch"`,
-* `"Funcs"`, `"Lines"`.
-*
-* @param f - File coverage report to analyze
-* @returns Object with `label` and `pct` of the worst metric
-*
-* @internal
-*/
-function getWorstMetric(f) {
-	return [
-		{
-			label: "Stmts",
-			pct: f.summary.statements
-		},
-		{
-			label: "Branch",
-			pct: f.summary.branches
-		},
-		{
-			label: "Funcs",
-			pct: f.summary.functions
-		},
-		{
-			label: "Lines",
-			pct: f.summary.lines
-		}
-	].reduce((worst, m) => m.pct < worst.pct ? m : worst);
-}
-/**
-* Strip the working directory prefix from a file path to produce a
-* project-relative path for display.
-*
-* @param filePath - Absolute or relative file path
-* @param cwd - Working directory to strip
-* @returns Project-relative path string
-*
-* @internal
-*/
-function relativePath(filePath, cwd) {
-	if (filePath.startsWith(cwd)) {
-		const rel = filePath.slice(cwd.length);
-		return rel.startsWith("/") ? rel.slice(1) : rel;
-	}
-	return filePath;
-}
-/**
-* Determine the output tier based on test results and coverage state.
-*
-* - `"red"` -- failures, unhandled errors, or files below threshold
-* - `"yellow"` -- all tests pass but coverage targets exist (room to improve)
-* - `"green"` -- all tests pass, all coverage targets met
-*
-* @internal
-*/
-function determineTier(report) {
-	if (report.summary.failed > 0 || report.unhandledErrors.length > 0) return "red";
-	if (report.coverage) {
-		if (report.coverage.lowCoverage.length > 0) return "red";
-		if (report.coverage.targets && report.coverage.belowTarget && report.coverage.belowTarget.length > 0) return "yellow";
-	}
-	return "green";
-}
-/**
-* Format an {@link (AgentReport:variable)} as compact, actionable console markdown.
-*
-* @remarks
-* The output is structured for LLM agent consumption with four sections:
-*
-* 1. **Compact header** with pass/fail counts and duration
-* 2. **Failed test details** with error messages and diffs (the core value)
-* 3. **Coverage gaps** showing only files below threshold, worst metric first
-* 4. **Next steps** with re-run commands and cache file pointer
-*
-* When all tests pass, the output collapses to a single success line
-* with an optional cache file reference.
-*
-* Returns an empty string when `consoleOutput` is `"silent"`.
-*
-* @param report - The report to format
-* @param options - Formatting options controlling verbosity and color
-* @returns Formatted markdown string, or empty string for silent mode
-*
-* @internal
-*/
-function formatConsoleMarkdown(report, options) {
-	const { consoleOutput, coverageConsoleLimit, noColor, cwd } = options;
-	if (consoleOutput === "silent") return "";
-	const ao = { noColor };
-	const lines = [];
-	const hasFailures = report.summary.failed > 0;
-	const duration = Math.round(report.summary.duration);
-	const projectLabel = report.project ? ` (${report.project})` : "";
-	if (hasFailures) lines.push(`## ${ansi("✗", "red", ao)} Vitest${projectLabel} \u2014 ${report.summary.failed} failed, ${report.summary.passed} passed (${duration}ms)`);
-	else lines.push(`## ${ansi("✓", "green", ao)} Vitest${projectLabel} \u2014 ${report.summary.passed} passed (${duration}ms)`);
-	lines.push("");
-	if (options.trendSummary && report.coverage) {
-		const { direction, runCount, firstMetric } = options.trendSummary;
-		const tier = determineTier(report);
-		if (tier === "green") {
-			const trendNote = `Coverage: all targets met | trending ${direction} over ${runCount} runs`;
-			lines[0] = `${lines[0]} — ${trendNote}`;
-		} else if (tier === "yellow") {
-			const belowTargetCount = report.coverage.belowTarget?.length ?? 0;
-			let summary = `Coverage: ${belowTargetCount} file${belowTargetCount !== 1 ? "s" : ""} below target`;
-			summary += ` | trending ${direction} over ${runCount} runs`;
-			if (firstMetric) {
-				summary += ` (${firstMetric.name}: ${firstMetric.from}% -> ${firstMetric.to}%`;
-				if (firstMetric.target) summary += `, target: ${firstMetric.target}%`;
-				summary += ")";
-			}
-			lines.push(summary);
-			lines.push("");
-		} else {
-			let summary = "Coverage:";
-			if (report.coverage.lowCoverage.length > 0) summary += ` ${report.coverage.lowCoverage.length} file${report.coverage.lowCoverage.length !== 1 ? "s" : ""} below threshold`;
-			summary += ` | trending ${direction} over ${runCount} runs`;
-			if (firstMetric) summary += ` (${firstMetric.name}: ${firstMetric.from}% -> ${firstMetric.to}%)`;
-			lines.push(summary);
-			lines.push("");
-		}
-	}
-	if (hasFailures) for (const mod of report.failed) {
-		const file = relativePath(mod.file, cwd);
-		lines.push(`### ${ansi("✗", "red", ao)} \`${file}\``);
-		lines.push("");
-		if (mod.errors && mod.errors.length > 0) for (const err of mod.errors) {
-			lines.push(ansi(err.message, "red", ao));
-			if (err.diff) {
-				lines.push("");
-				lines.push("```diff");
-				lines.push(err.diff);
-				lines.push("```");
-			}
-			lines.push("");
-		}
-		const failedTests = mod.tests.filter((t) => t.state === "failed");
-		for (const test of failedTests) {
-			const label = test.classification ? ` [${test.classification}]` : "";
-			lines.push(`- ${ansi("✗", "red", ao)} **${test.fullName}**${label}`);
-			if (test.errors && test.errors.length > 0) for (const err of test.errors) {
-				lines.push(`  ${ansi(err.message, "dim", ao)}`);
-				if (err.diff) {
-					lines.push("");
-					lines.push("  ```diff");
-					for (const diffLine of err.diff.split("\n")) lines.push(`  ${diffLine}`);
-					lines.push("  ```");
-				}
-			}
-			lines.push("");
-		}
-	}
-	if (report.coverage) {
-		const cov = report.coverage;
-		const globalThresholds = cov.thresholds.global;
-		if (cov.scoped) {
-			lines.push(formatScopedCoverageNote(cov.scopedFiles?.length ?? 0, cov.totalFiles));
-			lines.push("");
-		}
-		const filesToShow = cov.lowCoverage.slice(0, coverageConsoleLimit);
-		if (filesToShow.length > 0) {
-			lines.push(`### Coverage gaps`);
-			lines.push("");
-			for (const f of filesToShow) {
-				const file = relativePath(f.file, cwd);
-				const worst = getWorstMetric(f);
-				const thresholdValue = globalThresholds[worst.label === "Stmts" ? "statements" : worst.label === "Branch" ? "branches" : worst.label === "Funcs" ? "functions" : "lines"];
-				const thresholdSuffix = thresholdValue != null ? ` (threshold: ${thresholdValue}%)` : "";
-				lines.push(`- \`${file}\` \u2014 ${worst.label}: ${worst.pct}%${thresholdSuffix} \u2014 uncovered: ${f.uncoveredLines}`);
-			}
-			lines.push("");
-		}
-		if (cov.targets && cov.belowTarget && cov.belowTarget.length > 0) {
-			lines.push(`### Coverage improvements needed`);
-			lines.push("");
-			for (const f of cov.belowTarget.slice(0, coverageConsoleLimit)) {
-				const file = relativePath(f.file, cwd);
-				const worst = getWorstMetric(f);
-				const metricKey = worst.label === "Stmts" ? "statements" : worst.label === "Branch" ? "branches" : worst.label === "Funcs" ? "functions" : "lines";
-				const targetValue = cov.targets.global[metricKey];
-				const targetSuffix = targetValue != null ? ` (target: ${targetValue}%)` : "";
-				lines.push(`- \`${file}\` \u2014 ${worst.label}: ${worst.pct}%${targetSuffix} \u2014 uncovered: ${f.uncoveredLines}`);
-			}
-			lines.push("");
-		}
-	}
-	if (hasFailures || report.coverage && report.coverage.lowCoverage.length > 0) {
-		lines.push("### Next steps");
-		lines.push("");
-		if (hasFailures) {
-			const allFailedTests = report.failed.flatMap((m) => m.tests.filter((t) => t.state === "failed"));
-			const newFailures = allFailedTests.filter((t) => t.classification === "new-failure");
-			const persistent = allFailedTests.filter((t) => t.classification === "persistent");
-			const flaky = allFailedTests.filter((t) => t.classification === "flaky");
-			if (newFailures.length > 0) {
-				const files = [...new Set(report.failed.filter((m) => m.tests.some((t) => t.classification === "new-failure")).map((m) => relativePath(m.file, cwd)))];
-				lines.push(`- Fix ${newFailures.length} new failure${newFailures.length > 1 ? "s" : ""} in ${files.map((f) => `\`${f}\``).join(", ")} (likely caused by recent changes)`);
-			}
-			if (persistent.length > 0) lines.push(`- ${persistent.length} persistent failure${persistent.length > 1 ? "s" : ""} (pre-existing, may not be yours)`);
-			if (flaky.length > 0) lines.push(`- ${flaky.length} flaky test${flaky.length > 1 ? "s" : ""} (may pass on retry)`);
-			for (const file of report.failedFiles) lines.push(`- Re-run: \`vitest run ${relativePath(file, cwd)}\``);
-			if (options.mcp) {
-				lines.push("- Use `test_history` for failure trends");
-				lines.push("- Use `test_errors` to search errors by type");
-				lines.push("- Use `test_coverage` for coverage gap analysis");
-				lines.push("- Use `note({ action: \"create\" })` to record debugging findings");
-			}
-		}
-		lines.push("");
-	}
-	return lines.join("\n");
-}
-
-export { determineTier, formatConsoleMarkdown, getWorstMetric, relativePath };