@vitest-agent/plugin 1.0.0

package/reporter.js

@@ -0,0 +1,1349 @@
+import { resolveThresholds } from "./utils/resolve-thresholds.js";
+import { CoverageAnalyzer } from "./services/CoverageAnalyzer.js";
+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 { processFailure } from "./utils/process-failure.js";
+import { routeRenderedOutput } from "./utils/route-rendered-output.js";
+import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
+import { DefaultVitestAgentReporter } from "@vitest-agent/reporter";
+import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, buildAgentReport, computeTrend, ensureMigrated, formatFatalError, isTimeoutError, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/sdk";
+import { Effect, Option, PubSub } from "effect";
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { NodeContext } from "@effect/platform-node";
+
+//#region src/reporter.ts
+/**
+* Cache of in-flight `resolveDataPath` promises, keyed by `projectDir`.
+*
+* Multi-project Vitest configs construct one `AgentReporter` instance per
+* project (typical: 4-5 reporters per repo). Each instance's `ensureDbPath`
+* runs `resolveDataPath(projectDir)` under `PathResolutionLive`, which
+* pulls in `WorkspacesLive` — a layer that eagerly scans lockfiles and
+* walks the workspace package graph. Without this cache, that scan
+* happens N times in serial during reporter init, adding seconds of
+* overhead to every `vitest run`.
+*
+* The cache is module-local: one entry per `projectDir` (in practice,
+* always `process.cwd()` for a single Vitest invocation), shared across
+* all reporter instances within the same Node process. Sufficient
+* because reporter instances are created in the main Vitest process,
+* not in worker forks.
+*
+* @internal
+*/
+const dbPathCache = /* @__PURE__ */ new Map();
+function resolveDataPathCached(projectDir) {
+	const cached = dbPathCache.get(projectDir);
+	if (cached !== void 0) return cached;
+	const promise = Effect.runPromise(resolveDataPath(projectDir).pipe(Effect.provide(PathResolutionLive(projectDir)), Effect.provide(NodeContext.layer)));
+	dbPathCache.set(projectDir, promise);
+	promise.catch(() => void 0);
+	return promise;
+}
+/**
+* Compute updated baselines using ratchet logic: take the max of actual vs previous,
+* capped by targets if set.
+*
+* @internal
+*/
+function computeUpdatedBaselines(existing, actual, targets) {
+	const prev = existing?.global ?? {};
+	const cap = targets?.global ?? {};
+	const ratchet = (metric) => {
+		const actualVal = actual[metric];
+		const prevVal = prev[metric] ?? 0;
+		const targetVal = cap[metric];
+		const newVal = Math.max(actualVal, prevVal);
+		if (targetVal !== void 0 && newVal > targetVal) return targetVal;
+		return newVal;
+	};
+	return {
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		global: {
+			lines: ratchet("lines"),
+			functions: ratchet("functions"),
+			branches: ratchet("branches"),
+			statements: ratchet("statements")
+		},
+		patterns: existing?.patterns ?? []
+	};
+}
+/**
+* Vitest Reporter that produces structured output for LLM coding agents.
+*
+* @remarks
+* `AgentReporter` implements three Vitest Reporter lifecycle hooks:
+*
+* - {@link AgentReporter.onInit | onInit} -- stores the Vitest instance
+*   for project enumeration (used in Phase 2 overview generation)
+* - {@link AgentReporter.onCoverage | onCoverage} -- stashes the istanbul
+*   CoverageMap for merging into reports
+* - {@link AgentReporter.onTestRunEnd | onTestRunEnd} -- groups test
+*   modules by project, builds reports, writes data to SQLite,
+*   updates the manifest, and emits console/GFM output
+*
+* The reporter handles both single-package repos and monorepos by grouping
+* results via Vitest's native `TestProject` API. In single-project mode,
+* results are written with project name "default".
+*
+* @privateRemarks
+* The `onCoverage` hook fires **before** `onTestRunEnd` in Vitest's lifecycle.
+* Coverage data must be stashed as instance state and merged during
+* `onTestRunEnd`. This ordering is a Vitest design constraint, not a bug.
+*
+* @example
+* ```typescript
+* import { AgentReporter } from "@vitest-agent/plugin";
+* import { defineConfig } from "vitest/config";
+*
+* export default defineConfig({
+*   test: {
+*     reporters: [
+*       new AgentReporter({
+*         cacheDir: ".vitest-agent",
+*         consoleOutput: "failures",
+*         coverageThresholds: { global: { lines: 80 } },
+*       }),
+*     ],
+*   },
+* });
+* ```
+*
+* @see `AgentPlugin` for the convenience plugin wrapper
+* @see {@link https://vitest.dev/api/advanced/reporters.html | Vitest Reporter API}
+* @public
+*/
+var AgentReporter = class {
+	options;
+	dbPath = null;
+	/**
+	* Set to `true` after the first `onTestRunEnd` invocation completes.
+	*
+	* Vitest can fire `onTestRunEnd` more than once per `vitest run` in
+	* some multi-project configurations (e.g., once per project group, with
+	* the same `testModules` array each time). The plugin pushes only ONE
+	* AgentReporter per run, so a fresh instance always starts with this
+	* flag `false`; the first call does the work and the flag prevents
+	* subsequent invocations from re-rendering and re-writing to the DB.
+	*/
+	rendered = false;
+	/**
+	* Stored Vitest instance from {@link AgentReporter.onInit | onInit}.
+	*
+	* @remarks
+	* Available for Phase 2 overview generation. Exposed as a public
+	* property (prefixed with `_`) for testing and extension purposes.
+	*
+	* @internal
+	*/
+	_vitest = null;
+	coverage = null;
+	logLevel;
+	logFile;
+	onRunEvent;
+	/**
+	* Run-event channel. The plugin publishes one `RunEvent` per
+	* Vitest streaming callback onto this `PubSub`; the reporter factory
+	* receives it on the `ReporterKit` and a live-painting reporter
+	* (the default reporter in `stream` mode) subscribes to drive its mount.
+	* The plugin no longer owns any render mount itself.
+	*
+	* @internal
+	*/
+	runEvents;
+	/**
+	* Reporters resolved from the factory at run start (`onInit`). Reused
+	* by `onTestRunEnd` for the `render` call. Undefined when `onInit` did
+	* not run (tests invoking `onTestRunEnd` directly) — `onTestRunEnd`
+	* then resolves the factory itself.
+	*
+	* @internal
+	*/
+	reporters;
+	/**
+	* Whether the user supplied a custom `reporter` factory. A custom
+	* reporter may subscribe to the run-event channel in any console mode,
+	* so the streaming hooks publish events whenever this is true.
+	*
+	* @internal
+	*/
+	hasCustomReporter;
+	currentRunId = null;
+	moduleStartedAt = /* @__PURE__ */ new Map();
+	/**
+	* Wall-clock start stamp (`Date.now()`) for an in-flight Vitest
+	* setup/teardown hook, keyed `modulePath::hookType::scopeName`.
+	* `onHookStart` writes it, `onHookEnd` reads and clears it to derive
+	* `HookFinished.durationMs` — `ReportedHookContext` carries no
+	* duration of its own.
+	*
+	* @internal
+	*/
+	hookStartedAt = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.logLevel = resolveLogLevel();
+		this.logFile = resolveLogFile();
+		this.onRunEvent = options.onRunEvent;
+		this.hasCustomReporter = options.reporter !== void 0;
+		this.runEvents = Effect.runSync(PubSub.unbounded());
+		const rawThresholds = options.coverageThresholds;
+		const resolvedThresholds = rawThresholds && "global" in rawThresholds ? rawThresholds : resolveThresholds(rawThresholds);
+		const rawTargets = options.coverageTargets;
+		const resolvedTargets = rawTargets ? "global" in rawTargets ? rawTargets : resolveThresholds(rawTargets) : void 0;
+		const consoleMode = options.consoleMode ?? "passthrough";
+		const consoleOutput = consoleMode === "silent" ? "silent" : "failures";
+		const derivedFormat = options.format ?? (consoleMode === "silent" ? "silent" : consoleMode === "stream" || consoleMode === "agent" ? "terminal" : consoleMode === "ci-annotations" ? "ci-annotations" : void 0);
+		const githubActions = options.githubActions ?? false;
+		const base = {
+			...options.cacheDir !== void 0 ? { cacheDir: options.cacheDir } : {},
+			consoleOutput,
+			omitPassingTests: true,
+			coverageThresholds: resolvedThresholds,
+			autoUpdate: true,
+			coverageConsoleLimit: 10,
+			includeBareZero: false,
+			githubActions,
+			githubSummary: githubActions,
+			githubSummaryFile: void 0,
+			...derivedFormat !== void 0 ? { format: derivedFormat } : {},
+			consoleMode,
+			...options.mcp !== void 0 ? { mcp: options.mcp } : {},
+			...options.projectFilter !== void 0 ? { projectFilter: options.projectFilter } : {},
+			reporter: options.reporter ?? DefaultVitestAgentReporter,
+			coverageMode: options.coverageMode ?? "full",
+			transport: options.transport ?? { kind: "local" },
+			...options.passWithNoTests !== void 0 ? { passWithNoTests: options.passWithNoTests } : {}
+		};
+		this.options = resolvedTargets ? {
+			...base,
+			coverageTargets: resolvedTargets
+		} : base;
+	}
+	/**
+	* The resolved reporter config built at construction time. Exposed for
+	* test inspection and Phase 5 short-circuit logic.
+	*
+	* This getter is @internal — do not reference in user-facing docs.
+	* @internal
+	*/
+	get resolvedConfig() {
+		const opts = this.options;
+		return {
+			executor: "ci",
+			consoleMode: opts.consoleMode,
+			mcp: opts.mcp ?? false,
+			consoleOutput: opts.consoleOutput,
+			omitPassingTests: opts.omitPassingTests,
+			coverageConsoleLimit: opts.coverageConsoleLimit,
+			includeBareZero: opts.includeBareZero,
+			githubActions: opts.githubActions,
+			githubSummary: opts.githubSummary,
+			format: opts.format ?? "vitest-bypass",
+			detail: opts.detail ?? "standard",
+			noColor: false,
+			coverageMode: opts.coverageMode,
+			transport: opts.transport,
+			...opts.coverageThresholds !== void 0 && { coverageThresholds: opts.coverageThresholds },
+			...opts.coverageTargets !== void 0 && { coverageTargets: opts.coverageTargets },
+			...opts.passWithNoTests !== void 0 && { passWithNoTests: opts.passWithNoTests }
+		};
+	}
+	/**
+	* Store the Vitest instance for project enumeration.
+	*
+	* @remarks
+	* Called once at the start of the test run. The instance is stored
+	* for Phase 2 overview generation via `vitest.projects`.
+	*
+	* @param vitest - The Vitest instance
+	*/
+	async onInit(vitest) {
+		this._vitest = vitest;
+		await this.ensureDbPath();
+		await this.initReporters();
+	}
+	/**
+	* Resolve the reporter factory at run start.
+	*
+	* The factory is invoked here — before any streaming hook fires — so a
+	* reporter that paints live (the default reporter's Ink mount in `stream`
+	* mode) can subscribe to {@link AgentReporter.runEvents | the run-event
+	* channel} before the first `RunStarted` event. The kit built here
+	* carries neutral run health; `detail` is resolved health-aware again
+	* for the render kit at `onTestRunEnd`, and that kit is the one handed
+	* to `render`.
+	*
+	* A resolution failure degrades silently: `this.reporters` stays unset
+	* and `onTestRunEnd` resolves the factory itself from the render kit.
+	*
+	* @internal
+	*/
+	async initReporters() {
+		const opts = this.options;
+		try {
+			const initProgram = Effect.gen(function* () {
+				const detector = yield* EnvironmentDetector;
+				const executorResolver = yield* ExecutorResolver;
+				const formatSelector = yield* FormatSelector;
+				const detailResolver = yield* DetailResolver;
+				const env = yield* detector.detect();
+				const executor = yield* executorResolver.resolve(env);
+				return {
+					env,
+					executor,
+					format: yield* formatSelector.select(executor, opts.format, env),
+					detail: yield* detailResolver.resolve(executor, {
+						hasFailures: false,
+						belowTargets: false,
+						hasTargets: !!opts.coverageTargets
+					}, opts.detail)
+				};
+			});
+			const { env, executor, format, detail } = await Effect.runPromise(initProgram.pipe(Effect.provide(OutputPipelineLive), Effect.provide(NodeContext.layer)));
+			const kit = buildReporterKit({
+				env,
+				executor,
+				format,
+				detail,
+				noColor: !!process.env.NO_COLOR,
+				consoleMode: opts.consoleMode ?? "passthrough",
+				mcp: opts.mcp ?? false,
+				githubActions: opts.githubActions,
+				transport: opts.transport,
+				runEvents: this.runEvents,
+				...this.dbPath !== null && { dbPath: this.dbPath },
+				...opts.projectFilter !== void 0 && { projectFilter: opts.projectFilter },
+				...opts.coverageThresholds !== void 0 && { coverageThresholds: opts.coverageThresholds },
+				...opts.coverageTargets !== void 0 && { coverageTargets: opts.coverageTargets },
+				...opts.passWithNoTests !== void 0 && { passWithNoTests: opts.passWithNoTests },
+				coverageMode: opts.coverageMode
+			});
+			this.reporters = normalizeReporters(opts.reporter(kit));
+		} catch (err) {
+			process.stderr.write(`vitest-agent: reporter init failed; retrying at run end (${formatFatalError(err)})\n`);
+		}
+	}
+	/**
+	* Should the streaming Vitest hooks publish `RunEvent`s? The
+	* hooks short-circuit when this is false to skip constructing event
+	* objects nothing will read: the default reporter consumes the channel
+	* only in `stream` mode, a custom reporter may consume it in any mode,
+	* and the user `onRunEvent` tap is fed off the same stream.
+	*
+	* @internal
+	*/
+	wantsRunEvents() {
+		return this.onRunEvent !== void 0 || this.options.consoleMode === "stream" || this.hasCustomReporter;
+	}
+	/**
+	* Publish a `RunEvent` onto the run-event channel and the
+	* user-supplied tap. A throwing publish or tap is caught and logged to
+	* stderr — a live-render bug must not break persistence.
+	*
+	* @internal
+	*/
+	emit(event) {
+		try {
+			Effect.runSync(PubSub.publish(this.runEvents, event));
+		} catch (err) {
+			process.stderr.write(`vitest-agent: run-event publish threw: ${formatFatalError(err)}\n`);
+		}
+		const tap = this.onRunEvent;
+		if (tap !== void 0) try {
+			tap(event);
+		} catch (err) {
+			process.stderr.write(`vitest-agent: onRunEvent tap threw: ${formatFatalError(err)}\n`);
+		}
+	}
+	/**
+	* Walk the suite parent chain to produce the suite-path array used
+	* in `RunEvent.TestStarted` / `RunEvent.TestFinished`.
+	*
+	* @internal
+	*/
+	collectSuitePath(testCase) {
+		const path = [];
+		let cursor = testCase.parent;
+		while (cursor !== void 0 && cursor.type === "suite") {
+			path.unshift(cursor.name);
+			cursor = cursor.parent;
+		}
+		return path;
+	}
+	/**
+	* Vitest streaming hook: a test run is about to start. Mints a
+	* synthetic `runId` for the duration of this run and emits a
+	* `RunStarted` event for live subscribers.
+	*/
+	onTestRunStart(_specifications) {
+		if (!this.wantsRunEvents()) return;
+		this.currentRunId = randomUUID();
+		this.moduleStartedAt.clear();
+		this.emit({
+			_tag: "RunStarted",
+			runId: this.currentRunId,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			configHash: "live"
+		});
+	}
+	/**
+	* Read the owning Vitest project name off a `TestModule`. Vitest 4.x
+	* attaches `project` to every module; an empty name (the unnamed
+	* default project) collapses to `undefined` so the renderer treats it
+	* as a single anonymous project.
+	*
+	* @internal
+	*/
+	moduleProjectName(testModule) {
+		const name = testModule.project?.name;
+		return name !== void 0 && name.length > 0 ? name : void 0;
+	}
+	/**
+	* Vitest streaming hook: a test module has been queued.
+	*/
+	onTestModuleQueued(testModule) {
+		if (!this.wantsRunEvents()) return;
+		const projectName = this.moduleProjectName(testModule);
+		this.emit({
+			_tag: "ModuleQueued",
+			modulePath: testModule.relativeModuleId,
+			...projectName !== void 0 && { projectName }
+		});
+	}
+	/**
+	* Vitest streaming hook: a test module is starting execution.
+	*/
+	onTestModuleStart(testModule) {
+		if (!this.wantsRunEvents()) return;
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.moduleStartedAt.set(testModule.relativeModuleId, startedAt);
+		const projectName = this.moduleProjectName(testModule);
+		this.emit({
+			_tag: "ModuleStarted",
+			modulePath: testModule.relativeModuleId,
+			startedAt,
+			...projectName !== void 0 && { projectName }
+		});
+	}
+	/**
+	* Vitest streaming hook: a test module has finished collecting its
+	* tests and suites, before execution begins.
+	*/
+	onTestModuleCollected(testModule) {
+		if (!this.wantsRunEvents()) return;
+		let testCount = 0;
+		for (const _ of testModule.children.allTests()) testCount++;
+		let suiteCount = 0;
+		for (const _ of testModule.children.allSuites()) suiteCount++;
+		this.emit({
+			_tag: "ModuleCollected",
+			modulePath: testModule.relativeModuleId,
+			testCount,
+			suiteCount
+		});
+	}
+	/**
+	* Vitest streaming hook: a test case is about to run.
+	*
+	* Emits a standalone `TestStarted` so the renderer gets a render
+	* frame for the transient "running" state. `onTestCaseReady` fires
+	* before `onTestCaseResult`; emitting here — rather than synthesizing
+	* `TestStarted` back-to-back with `TestFinished` inside
+	* `onTestCaseResult` — gives the running state a real lifetime in the
+	* event stream and is the prerequisite for any future per-test
+	* animation.
+	*/
+	onTestCaseReady(testCase) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = testCase.module?.relativeModuleId ?? "";
+		if (modulePath === "") return;
+		this.emit({
+			_tag: "TestStarted",
+			modulePath,
+			testName: testCase.name,
+			suitePath: this.collectSuitePath(testCase)
+		});
+	}
+	/**
+	* Vitest streaming hook: a test case has produced a result.
+	*
+	* Emits only `TestFinished` — the matching `TestStarted` is emitted
+	* by `onTestCaseReady`, which fires earlier in the lifecycle.
+	*/
+	onTestCaseResult(testCase) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = testCase.module?.relativeModuleId ?? "";
+		if (modulePath === "") return;
+		const suitePath = this.collectSuitePath(testCase);
+		const result = testCase.result();
+		const diag = testCase.diagnostic();
+		const status = result?.state === "passed" || result?.state === "failed" || result?.state === "skipped" ? result.state : "pending";
+		const firstError = result?.errors?.[0];
+		const expectedStr = stringifyFailureValue(firstError?.expected);
+		const receivedStr = stringifyFailureValue(firstError?.actual);
+		const error = firstError !== void 0 ? {
+			message: firstError.message,
+			...firstError.diff !== void 0 && { diff: firstError.diff },
+			...expectedStr !== void 0 && { expected: expectedStr },
+			...receivedStr !== void 0 && { received: receivedStr }
+		} : void 0;
+		const timedOut = result?.state === "failed" && firstError !== void 0 && isTimeoutError(firstError);
+		this.emit({
+			_tag: "TestFinished",
+			modulePath,
+			testName: testCase.name,
+			suitePath,
+			status,
+			durationMs: diag?.duration ?? 0,
+			...error !== void 0 && { error },
+			...timedOut && { timedOut: true }
+		});
+	}
+	/**
+	* Vitest streaming hook: a test module has finished. Emits a
+	* `ModuleFinished` carrying the tallied counts plus a duration
+	* derived from the module's diagnostic.
+	*/
+	onTestModuleEnd(testModule) {
+		if (!this.wantsRunEvents()) return;
+		let pass = 0;
+		let fail = 0;
+		let skip = 0;
+		let timeout = 0;
+		for (const test of testModule.children.allTests()) {
+			const result = test.result();
+			const state = result?.state;
+			if (state === "passed") pass++;
+			else if (state === "failed") {
+				const firstError = result?.errors?.[0];
+				if (firstError !== void 0 && isTimeoutError(firstError)) timeout++;
+				else fail++;
+			} else skip++;
+		}
+		const tagCounts = {};
+		for (const test of testModule.children.allTests()) for (const tag of test.tags ?? []) tagCounts[tag] = (tagCounts[tag] ?? 0) + 1;
+		const projectName = this.moduleProjectName(testModule);
+		this.emit({
+			_tag: "ModuleFinished",
+			modulePath: testModule.relativeModuleId,
+			passCount: pass,
+			failCount: fail,
+			skipCount: skip,
+			timeoutCount: timeout,
+			durationMs: testModule.diagnostic()?.duration ?? 0,
+			...projectName !== void 0 && { projectName },
+			...Object.keys(tagCounts).length > 0 && { tagCounts }
+		});
+	}
+	/**
+	* Walk a suite/test entity's parent chain to its owning module path.
+	*
+	* @internal
+	*/
+	entityModulePath(entity) {
+		return entity.relativeModuleId ?? entity.module?.relativeModuleId ?? "";
+	}
+	/**
+	* Vitest streaming hook: a test suite is about to run.
+	*/
+	onTestSuiteReady(testSuite) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = this.entityModulePath(testSuite);
+		if (modulePath === "") return;
+		this.emit({
+			_tag: "SuiteStarted",
+			modulePath,
+			suitePath: this.collectSuitePath(testSuite),
+			suiteName: testSuite.name
+		});
+	}
+	/**
+	* Vitest streaming hook: a test suite has finished running.
+	*/
+	onTestSuiteResult(testSuite) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = this.entityModulePath(testSuite);
+		if (modulePath === "") return;
+		let pass = 0;
+		let fail = 0;
+		let skip = 0;
+		for (const test of testSuite.children.allTests()) {
+			const state = test.result()?.state;
+			if (state === "passed") pass++;
+			else if (state === "failed") fail++;
+			else skip++;
+		}
+		this.emit({
+			_tag: "SuiteFinished",
+			modulePath,
+			suitePath: this.collectSuitePath(testSuite),
+			suiteName: testSuite.name,
+			passCount: pass,
+			failCount: fail,
+			skipCount: skip
+		});
+	}
+	/**
+	* Derive `modulePath` / `scopeName` / a stable key for a Vitest
+	* setup/teardown hook from its `ReportedHookContext` entity.
+	*
+	* @internal
+	*/
+	hookScope(hook) {
+		const entity = hook.entity ?? {};
+		return {
+			modulePath: entity.relativeModuleId ?? entity.module?.relativeModuleId ?? "",
+			scopeName: entity.name ?? entity.relativeModuleId ?? ""
+		};
+	}
+	/**
+	* Vitest streaming hook: a `beforeAll` / `afterAll` / `beforeEach` /
+	* `afterEach` hook is starting.
+	*/
+	onHookStart(hook) {
+		if (!this.wantsRunEvents()) return;
+		if (hook.name !== "beforeAll" && hook.name !== "afterAll" && hook.name !== "beforeEach" && hook.name !== "afterEach") return;
+		const { modulePath, scopeName } = this.hookScope(hook);
+		this.hookStartedAt.set(`${modulePath}::${hook.name}::${scopeName}`, Date.now());
+		this.emit({
+			_tag: "HookStarted",
+			modulePath,
+			hookType: hook.name,
+			scopeName
+		});
+	}
+	/**
+	* Vitest streaming hook: a setup/teardown hook has finished. Duration
+	* is derived from the stamp `onHookStart` recorded — `ReportedHookContext`
+	* carries none of its own. Status is a best-effort read of the
+	* entity's collected errors.
+	*/
+	onHookEnd(hook) {
+		if (!this.wantsRunEvents()) return;
+		if (hook.name !== "beforeAll" && hook.name !== "afterAll" && hook.name !== "beforeEach" && hook.name !== "afterEach") return;
+		const { modulePath, scopeName } = this.hookScope(hook);
+		const key = `${modulePath}::${hook.name}::${scopeName}`;
+		const startedAt = this.hookStartedAt.get(key);
+		this.hookStartedAt.delete(key);
+		const durationMs = startedAt !== void 0 ? Date.now() - startedAt : 0;
+		const entityErrors = typeof hook.entity?.errors === "function" ? hook.entity.errors() : [];
+		const firstError = entityErrors[0];
+		this.emit({
+			_tag: "HookFinished",
+			modulePath,
+			hookType: hook.name,
+			scopeName,
+			durationMs,
+			status: entityErrors.length > 0 ? "failed" : "passed",
+			...firstError !== void 0 && { error: {
+				message: firstError.message,
+				...firstError.stack !== void 0 && { stack: firstError.stack },
+				...firstError.diff !== void 0 && { diff: firstError.diff }
+			} }
+		});
+	}
+	/**
+	* Vitest streaming hook: a captured `console.log` / `console.error`
+	* from user test code. The Vitest log carries a `taskId` rather than
+	* a module/test path; resolving it back to one would need the task
+	* registry, so `modulePath` / `testName` are left unset.
+	*/
+	onUserConsoleLog(log) {
+		if (!this.wantsRunEvents()) return;
+		this.emit({
+			_tag: "ConsoleLog",
+			level: log.type,
+			content: log.content,
+			time: log.time
+		});
+	}
+	/**
+	* Vitest streaming hook: the run exceeded its configured process
+	* timeout. Terminal — moves the renderer to a final frame.
+	*/
+	onProcessTimeout() {
+		if (!this.wantsRunEvents()) return;
+		this.emit({
+			_tag: "RunTimedOut",
+			message: "Test run exceeded the configured process timeout."
+		});
+	}
+	/**
+	* Vitest streaming hook: a test case recorded an annotation.
+	*/
+	onTestCaseAnnotate(testCase, annotation) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = testCase.module?.relativeModuleId ?? "";
+		if (modulePath === "") return;
+		this.emit({
+			_tag: "TestAnnotated",
+			modulePath,
+			testName: testCase.name,
+			suitePath: this.collectSuitePath(testCase),
+			annotation: annotation.message
+		});
+	}
+	/**
+	* Vitest streaming hook: a test case recorded an artifact.
+	*/
+	onTestCaseArtifactRecord(testCase, artifact) {
+		if (!this.wantsRunEvents()) return;
+		const modulePath = testCase.module?.relativeModuleId ?? "";
+		if (modulePath === "") return;
+		this.emit({
+			_tag: "TestArtifactRecorded",
+			modulePath,
+			testName: testCase.name,
+			suitePath: this.collectSuitePath(testCase),
+			artifact: artifact.type ?? "artifact"
+		});
+	}
+	/**
+	* Vitest streaming hook: watch mode has finished its initial run and
+	* is waiting for file changes.
+	*/
+	onWatcherStart() {
+		if (!this.wantsRunEvents()) return;
+		this.emit({ _tag: "WatcherReady" });
+	}
+	/**
+	* Vitest streaming hook: watch mode is re-running because tracked
+	* files changed.
+	*/
+	onWatcherRerun(files, trigger) {
+		if (!this.wantsRunEvents()) return;
+		this.emit({
+			_tag: "WatcherRerun",
+			triggerFiles: [...files],
+			...trigger !== void 0 && { reason: trigger }
+		});
+	}
+	async ensureDbPath() {
+		if (this.dbPath) return this.dbPath;
+		if (this.options.cacheDir) {
+			mkdirSync(this.options.cacheDir, { recursive: true });
+			this.dbPath = `${this.options.cacheDir}/data.db`;
+			return this.dbPath;
+		}
+		const projectDir = process.cwd();
+		this.dbPath = await resolveDataPathCached(projectDir);
+		return this.dbPath;
+	}
+	/**
+	* Stash coverage data for merging into reports.
+	*
+	* @privateRemarks
+	* This hook fires **before** `onTestRunEnd` in Vitest's lifecycle.
+	* The coverage value is an istanbul CoverageMap that will be duck-typed
+	* and processed during `onTestRunEnd`.
+	*
+	* @param coverage - Istanbul CoverageMap (duck-typed at processing time)
+	*
+	* @see `processCoverage` for the duck-typing logic
+	*/
+	onCoverage(coverage) {
+		this.coverage = coverage;
+	}
+	/**
+	* Process test results, write reports, and emit formatted output.
+	*
+	* @remarks
+	* This is the main lifecycle hook where all output is generated.
+	* Processing steps:
+	*
+	* 1. Group test modules by `testModule.project.name`
+	* 2. Process stashed coverage data (if available)
+	* 3. Build per-project `AgentReport` objects
+	* 4. Classify tests via HistoryTracker and attach classifications
+	* 5. Write settings, run, modules, test cases, and errors to SQLite
+	* 6. Write per-test history entries
+	* 7. Write baselines and trends
+	* 8. Emit console markdown (unless `"silent"`)
+	* 9. Write GFM summary to `GITHUB_STEP_SUMMARY` (if GitHub Actions)
+	*
+	* File write failures are logged to stderr but do not crash the test run.
+	*
+	* @param testModules - All test modules from the completed run
+	* @param unhandledErrors - Any unhandled errors during the run
+	* @param reason - Overall outcome: `"passed"`, `"failed"`, or `"interrupted"`
+	*/
+	async onTestRunEnd(testModules, unhandledErrors, reason) {
+		if (this.rendered) return;
+		this.rendered = true;
+		if (this.wantsRunEvents() && this.currentRunId !== null) {
+			let pass = 0;
+			let fail = 0;
+			let skip = 0;
+			let timeout = 0;
+			let totalDuration = 0;
+			for (const mod of testModules) {
+				totalDuration += mod.diagnostic()?.duration ?? 0;
+				for (const test of mod.children.allTests()) {
+					const result = test.result();
+					const state = result?.state;
+					if (state === "passed") pass++;
+					else if (state === "failed") {
+						const firstError = result?.errors?.[0];
+						if (firstError !== void 0 && isTimeoutError(firstError)) timeout++;
+						else fail++;
+					} else skip++;
+				}
+			}
+			this.emit({
+				_tag: "RunFinished",
+				runId: this.currentRunId,
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				passCount: pass,
+				failCount: fail,
+				skipCount: skip,
+				timeoutCount: timeout,
+				durationMs: totalDuration
+			});
+		}
+		const modules = testModules;
+		const errors = unhandledErrors;
+		const opts = this.options;
+		const stashedCoverage = this.coverage;
+		const stashedVitest = this._vitest;
+		const logLevel = this.logLevel;
+		const logFile = this.logFile;
+		const runEvents = this.runEvents;
+		const preBuiltReporters = this.reporters;
+		const emitEvent = (event) => {
+			this.emit(event);
+		};
+		const wantsRunEvents = this.wantsRunEvents();
+		let dbPath;
+		try {
+			dbPath = await this.ensureDbPath();
+		} catch (err) {
+			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
+			return;
+		}
+		const filteredModules = opts.projectFilter ? modules.filter((m) => (m.project.name || "default") === opts.projectFilter) : modules;
+		if (filteredModules.length === 0 && opts.projectFilter) return;
+		if (opts.coverageMode === "ui-only") {
+			const uiProjectGroups = /* @__PURE__ */ new Map();
+			for (const mod of filteredModules) {
+				const key = mod.project.name || "default";
+				const existing = uiProjectGroups.get(key);
+				if (existing) existing.push(mod);
+				else uiProjectGroups.set(key, [mod]);
+			}
+			const isMultiProject = uiProjectGroups.size > 1 || !!opts.projectFilter;
+			const uiReports = [];
+			for (const [projectName, projectModules] of uiProjectGroups) {
+				const report = buildAgentReport(projectModules, errors, reason, { omitPassingTests: opts.omitPassingTests }, isMultiProject ? projectName : void 0);
+				uiReports.push(report);
+			}
+			const uiProgram = Effect.gen(function* () {
+				const detector = yield* EnvironmentDetector;
+				const executorResolver = yield* ExecutorResolver;
+				const formatSelector = yield* FormatSelector;
+				const detailResolver = yield* DetailResolver;
+				const env = yield* detector.detect();
+				const executor = yield* executorResolver.resolve(env);
+				const format = yield* formatSelector.select(executor, opts.format, env);
+				const health = {
+					hasFailures: uiReports.some((r) => r.summary.failed > 0 || r.unhandledErrors.length > 0),
+					belowTargets: false,
+					hasTargets: !!opts.coverageTargets
+				};
+				const detail = yield* detailResolver.resolve(executor, health, opts.detail);
+				const githubSummaryFile = process.env.GITHUB_STEP_SUMMARY;
+				const kit = buildReporterKit({
+					env,
+					executor,
+					format,
+					detail,
+					noColor: !!process.env.NO_COLOR,
+					consoleMode: opts.consoleMode ?? "passthrough",
+					mcp: opts.mcp ?? false,
+					githubActions: opts.githubActions,
+					transport: opts.transport,
+					runEvents,
+					...dbPath !== void 0 && { dbPath },
+					...opts.projectFilter !== void 0 && { projectFilter: opts.projectFilter },
+					...opts.coverageThresholds !== void 0 && { coverageThresholds: opts.coverageThresholds },
+					...opts.coverageTargets !== void 0 && { coverageTargets: opts.coverageTargets },
+					...opts.passWithNoTests !== void 0 && { passWithNoTests: opts.passWithNoTests },
+					coverageMode: opts.coverageMode
+				});
+				const reporters = preBuiltReporters ?? normalizeReporters(opts.reporter(kit));
+				const renderInput = {
+					reports: uiReports,
+					classifications: /* @__PURE__ */ new Map()
+				};
+				const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
+				for (const output of allOutputs) routeRenderedOutput(output, { ...githubSummaryFile !== void 0 && { githubSummaryFile } });
+			});
+			await Effect.runPromise(uiProgram.pipe(Effect.provide(OutputPipelineLive), Effect.provide(NodeContext.layer))).catch((err) => {
+				process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
+			});
+			return;
+		}
+		mkdirSync(dirname(dbPath), { recursive: true });
+		try {
+			await ensureMigrated(dbPath, logLevel, logFile);
+		} catch (err) {
+			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
+			return;
+		}
+		const program = Effect.gen(function* () {
+			const store = yield* DataStore;
+			const reader = yield* DataReader;
+			const analyzer = yield* CoverageAnalyzer;
+			const tracker = yield* HistoryTracker;
+			const invocationId = randomUUID();
+			const vitest = stashedVitest;
+			const settings = captureSettings(vitest?.config ?? {}, vitest?.version ?? "unknown");
+			const settingsHash = hashSettings(settings);
+			const envVars = captureEnvVars(process.env);
+			yield* store.writeSettings(settingsHash, settings, envVars);
+			const projectGroups = /* @__PURE__ */ new Map();
+			for (const mod of filteredModules) {
+				const key = mod.project.name || "default";
+				const existing = projectGroups.get(key);
+				if (existing) existing.push(mod);
+				else projectGroups.set(key, [mod]);
+			}
+			const baselinesOpt = yield* reader.getBaselines("__global__").pipe(Effect.catchAll(() => Effect.succeed(Option.none())));
+			const baselines = Option.getOrUndefined(baselinesOpt);
+			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,
+				...opts.coverageTargets ? { targets: opts.coverageTargets } : {},
+				...baselines ? { baselines } : {}
+			};
+			const coverageResult = stashedCoverage && isFirstProject ? yield* analyzer.process(stashedCoverage, coverageOpts) : Option.none();
+			const coverageReport = Option.getOrUndefined(coverageResult);
+			if (wantsRunEvents && coverageReport !== void 0) {
+				const globalThresholds = coverageReport.thresholds.global;
+				emitEvent({
+					_tag: "CoverageReady",
+					metrics: coverageReport.totals,
+					thresholds: globalThresholds,
+					gaps: coverageReport.lowCoverage.map((fc) => ({
+						file: fc.file,
+						missing: fc.summary,
+						uncoveredLines: fc.uncoveredLines
+					}))
+				});
+				for (const metric of [
+					"lines",
+					"branches",
+					"functions",
+					"statements"
+				]) {
+					const expected = globalThresholds[metric];
+					const actual = coverageReport.totals[metric];
+					if (expected !== void 0 && actual < expected) emitEvent({
+						_tag: "ThresholdViolation",
+						metric,
+						expected,
+						actual
+					});
+				}
+			}
+			const reports = [];
+			const isMultiProject = projectGroups.size > 1 || !!opts.projectFilter;
+			for (const [projectName, projectModules] of projectGroups) {
+				const project = projectName === "default" ? "default" : projectName;
+				const baseReport = buildAgentReport(projectModules, errors, reason, { omitPassingTests: opts.omitPassingTests }, isMultiProject ? projectName : void 0);
+				let totalDuration = 0;
+				for (const mod of projectModules) totalDuration += mod.diagnostic()?.duration ?? 0;
+				const envAgentId = process.env.VITEST_AGENT_AGENT_ID;
+				const envConversationId = process.env.VITEST_AGENT_CONVERSATION_ID;
+				const attribution = envAgentId !== void 0 && envAgentId.length > 0 ? {
+					actorType: "agent",
+					agentId: envAgentId,
+					conversationId: envConversationId ?? null
+				} : {
+					actorType: "system",
+					agentId: null,
+					conversationId: null
+				};
+				const hostProbe = probeHostMetadataFromEnv(process.env);
+				const runId = yield* store.writeRun({
+					invocationId,
+					project,
+					settingsHash,
+					timestamp: baseReport.timestamp,
+					commitSha: process.env.GITHUB_SHA ?? null,
+					branch: process.env.GITHUB_REF_NAME ?? null,
+					reason,
+					duration: totalDuration,
+					total: baseReport.summary.total,
+					passed: baseReport.summary.passed,
+					failed: baseReport.summary.failed,
+					skipped: baseReport.summary.skipped,
+					scoped: false,
+					actorType: attribution.actorType,
+					agentId: attribution.agentId,
+					conversationId: attribution.conversationId,
+					gitBranch: process.env.GITHUB_REF_NAME ?? null,
+					gitCommitSha: process.env.GITHUB_SHA ?? null,
+					hostSource: hostProbe.source,
+					hostValue: hostProbe.value,
+					hostMetadata: hostProbe.metadata
+				});
+				for (const mod of projectModules) {
+					const fileId = yield* store.ensureFile(mod.relativeModuleId);
+					const moduleId = (yield* store.writeModules(runId, [{
+						fileId,
+						relativeModuleId: mod.relativeModuleId,
+						state: mod.state(),
+						duration: mod.diagnostic()?.duration ?? 0
+					}]))[0];
+					const sourceFile = mod.relativeModuleId.replace(/\.test\.([^.]+)$/, ".$1").replace(/\.spec\.([^.]+)$/, ".$1");
+					if (sourceFile !== mod.relativeModuleId) yield* store.writeSourceMap(sourceFile, moduleId, "convention");
+					const suiteIdMap = /* @__PURE__ */ new Map();
+					for (const suite of mod.children.allSuites()) {
+						const parentSuiteId = suite.parent && suite.parent.type === "suite" ? suiteIdMap.get(suite.parent.fullName) : void 0;
+						const suiteIds = yield* store.writeSuites(moduleId, [{
+							name: suite.name,
+							fullName: suite.fullName,
+							state: suite.state(),
+							...parentSuiteId !== void 0 && { parentSuiteId },
+							...suite.options?.mode !== void 0 && { mode: suite.options.mode },
+							...suite.options?.concurrent !== void 0 && { concurrent: suite.options.concurrent },
+							...suite.options?.shuffle !== void 0 && { shuffle: suite.options.shuffle },
+							...suite.options?.retry !== void 0 && { retry: suite.options.retry },
+							...suite.options?.repeats !== void 0 && { repeats: suite.options.repeats },
+							...suite.location?.line !== void 0 && { locationLine: suite.location.line },
+							...suite.location?.column !== void 0 && { locationColumn: suite.location.column }
+						}]);
+						suiteIdMap.set(suite.fullName, suiteIds[0]);
+					}
+					const testCases = [];
+					for (const testCase of mod.children.allTests()) {
+						const result = testCase.result();
+						const diag = testCase.diagnostic();
+						const parent = testCase.parent;
+						const parentSuiteId = parent && parent.type === "suite" ? suiteIdMap.get(parent.fullName) : void 0;
+						testCases.push({
+							name: testCase.name,
+							fullName: testCase.fullName,
+							state: result?.state ?? "pending",
+							...diag?.duration !== void 0 && { duration: diag.duration },
+							...diag?.flaky !== void 0 && { flaky: diag.flaky },
+							...diag?.slow !== void 0 && { slow: diag.slow },
+							...testCase.tags.length > 0 && { tags: testCase.tags },
+							...parentSuiteId !== void 0 && { suiteId: parentSuiteId }
+						});
+					}
+					const testCaseIds = yield* store.writeTestCases(moduleId, testCases.map((tc) => ({
+						name: tc.name,
+						fullName: tc.fullName,
+						state: tc.state,
+						...tc.duration !== void 0 && { duration: tc.duration },
+						...tc.flaky !== void 0 && { flaky: tc.flaky },
+						...tc.slow !== void 0 && { slow: tc.slow },
+						...tc.tags !== void 0 && { tags: tc.tags },
+						...tc.suiteId !== void 0 && { suiteId: tc.suiteId }
+					})));
+					let testIdx = 0;
+					for (const testCase of mod.children.allTests()) {
+						const result = testCase.result();
+						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];
+								const { frames, signatureHash } = processFailure(e);
+								if (signatureHash !== null) yield* store.writeFailureSignature({
+									signatureHash,
+									runId,
+									seenAt: baseReport.timestamp
+								});
+								inputs.push({
+									testCaseId,
+									scope: "test",
+									message: e.message,
+									...e.name !== void 0 && { name: e.name },
+									...e.diff !== void 0 && { diff: e.diff },
+									...e.stack !== void 0 && { stack: e.stack },
+									...signatureHash !== null && { signatureHash },
+									...frames.length > 0 && { frames },
+									ordinal
+								});
+							}
+							yield* store.writeErrors(runId, inputs);
+						}
+						testIdx++;
+					}
+					const modErrors = mod.errors();
+					if (modErrors.length > 0) {
+						const inputs = [];
+						for (let ordinal = 0; ordinal < modErrors.length; ordinal++) {
+							const e = modErrors[ordinal];
+							const { frames, signatureHash } = processFailure(e);
+							if (signatureHash !== null) yield* store.writeFailureSignature({
+								signatureHash,
+								runId,
+								seenAt: baseReport.timestamp
+							});
+							inputs.push({
+								moduleId,
+								scope: "module",
+								message: e.message,
+								...e.name !== void 0 && { name: e.name },
+								...e.stack !== void 0 && { stack: e.stack },
+								...signatureHash !== null && { signatureHash },
+								...frames.length > 0 && { frames },
+								ordinal
+							});
+						}
+						yield* store.writeErrors(runId, inputs);
+					}
+				}
+				if (errors.length > 0) {
+					const inputs = [];
+					for (let ordinal = 0; ordinal < errors.length; ordinal++) {
+						const e = errors[ordinal];
+						const { frames, signatureHash } = processFailure(e);
+						if (signatureHash !== null) yield* store.writeFailureSignature({
+							signatureHash,
+							runId,
+							seenAt: baseReport.timestamp
+						});
+						inputs.push({
+							scope: "unhandled",
+							message: e.message,
+							...e.name !== void 0 && { name: e.name },
+							...e.stack !== void 0 && { stack: e.stack },
+							...signatureHash !== null && { signatureHash },
+							...frames.length > 0 && { frames },
+							ordinal
+						});
+					}
+					yield* store.writeErrors(runId, inputs);
+				}
+				const testOutcomes = [];
+				for (const mod of projectModules) for (const testCase of mod.children.allTests()) {
+					const state = testCase.result()?.state;
+					if (state === "passed" || state === "failed") testOutcomes.push({
+						fullName: testCase.fullName,
+						state
+					});
+				}
+				const { classifications } = yield* tracker.classify(project, testOutcomes, baseReport.timestamp);
+				const diagMap = /* @__PURE__ */ new Map();
+				const errorMap = /* @__PURE__ */ new Map();
+				for (const mod of projectModules) for (const tc of mod.children.allTests()) {
+					diagMap.set(tc.fullName, tc.diagnostic() ?? {});
+					const tcResult = tc.result();
+					if (tcResult?.state === "failed") {
+						const errors = tcResult.errors;
+						errorMap.set(tc.fullName, errors?.[0]?.message ?? null);
+					}
+				}
+				for (const outcome of testOutcomes) {
+					const diag = diagMap.get(outcome.fullName);
+					const errorMessage = outcome.state === "failed" ? errorMap.get(outcome.fullName) ?? null : null;
+					yield* store.writeHistory(project, outcome.fullName, runId, baseReport.timestamp, outcome.state, diag?.duration ?? null, diag?.flaky ?? false, 0, errorMessage);
+				}
+				const failedWithClassifications = baseReport.failed.map((mod) => ({
+					...mod,
+					tests: mod.tests.map((test) => {
+						const cls = classifications.get(test.fullName);
+						return cls ? {
+							...test,
+							classification: cls
+						} : test;
+					})
+				}));
+				const classifiedReport = {
+					...baseReport,
+					failed: failedWithClassifications
+				};
+				const tagCounts = {};
+				for (const mod of projectModules) for (const tc of mod.children.allTests()) {
+					const state = tc.result()?.state ?? "pending";
+					const tags = tc.tags ?? [];
+					for (const tag of tags) {
+						tagCounts[tag] ??= {
+							passed: 0,
+							failed: 0,
+							skipped: 0
+						};
+						if (state === "passed") tagCounts[tag].passed++;
+						else if (state === "failed") tagCounts[tag].failed++;
+						else if (state === "skipped") tagCounts[tag].skipped++;
+					}
+				}
+				const reportWithTags = Object.keys(tagCounts).length > 0 ? {
+					...classifiedReport,
+					tagCounts
+				} : classifiedReport;
+				const report = coverageReport ? {
+					...reportWithTags,
+					coverage: coverageReport
+				} : reportWithTags;
+				reports.push(report);
+				if (coverageReport) {
+					const tierByFile = /* @__PURE__ */ new Map();
+					const sourceByFile = /* @__PURE__ */ new Map();
+					for (const fc of coverageReport.belowTarget ?? []) {
+						tierByFile.set(fc.file, "below_target");
+						sourceByFile.set(fc.file, fc);
+					}
+					for (const fc of coverageReport.lowCoverage) {
+						tierByFile.set(fc.file, "below_threshold");
+						sourceByFile.set(fc.file, fc);
+					}
+					if (tierByFile.size > 0) {
+						const coverageInputs = [];
+						for (const [file, tier] of tierByFile) {
+							const fc = sourceByFile.get(file);
+							if (!fc) continue;
+							const fileId = yield* store.ensureFile(fc.file);
+							coverageInputs.push({
+								fileId,
+								statements: fc.summary.statements,
+								branches: fc.summary.branches,
+								functions: fc.summary.functions,
+								lines: fc.summary.lines,
+								uncoveredLines: fc.uncoveredLines,
+								tier
+							});
+						}
+						yield* store.writeCoverage(runId, coverageInputs);
+					}
+				}
+				if (coverageReport && !coverageReport.scoped) {
+					const existingTrends = yield* reader.getTrends(project).pipe(Effect.map((opt) => Option.getOrUndefined(opt)), Effect.catchAll(() => Effect.succeed(void 0)));
+					const updatedTrends = computeTrend(coverageReport.totals, existingTrends, opts.coverageTargets);
+					const latestEntry = updatedTrends.entries[updatedTrends.entries.length - 1];
+					if (latestEntry) yield* store.writeTrends(project, runId, latestEntry);
+				}
+			}
+			if (opts.autoUpdate && coverageReport) {
+				const newBaselines = computeUpdatedBaselines(baselines, coverageReport.totals, opts.coverageTargets);
+				yield* store.writeBaselines(newBaselines);
+			}
+			let trendSummary;
+			if (coverageReport && !coverageReport.scoped) {
+				const firstProjectKey = Array.from(projectGroups.keys())[0];
+				if (firstProjectKey) {
+					const tp = firstProjectKey === "default" ? "default" : firstProjectKey;
+					const trendsOpt = yield* reader.getTrends(tp).pipe(Effect.catchAll(() => Effect.succeed(Option.none())));
+					if (Option.isSome(trendsOpt)) {
+						const entries = trendsOpt.value.entries;
+						if (entries.length >= 2) {
+							const latest = entries[entries.length - 1];
+							const prev = entries[entries.length - 2];
+							const direction = latest.direction;
+							const metrics = [
+								"lines",
+								"functions",
+								"branches",
+								"statements"
+							];
+							let firstMetric;
+							for (const m of metrics) {
+								const from = prev.coverage[m];
+								const to = latest.coverage[m];
+								if (from !== to) {
+									const target = opts.coverageTargets?.global?.[m];
+									firstMetric = {
+										name: m,
+										from,
+										to,
+										...target !== void 0 ? { target } : {}
+									};
+									break;
+								}
+							}
+							trendSummary = {
+								direction,
+								runCount: entries.length,
+								...firstMetric ? { firstMetric } : {}
+							};
+						}
+					}
+				}
+			}
+			if (wantsRunEvents && trendSummary !== void 0) emitEvent({
+				_tag: "TrendComputed",
+				direction: trendSummary.direction,
+				runCount: trendSummary.runCount
+			});
+			yield* Effect.logInfo("reports built").pipe(Effect.annotateLogs({
+				count: reports.length,
+				projects: Array.from(projectGroups.keys()).join(", ")
+			}));
+			const detector = yield* EnvironmentDetector;
+			const executorResolver = yield* ExecutorResolver;
+			const formatSelector = yield* FormatSelector;
+			const detailResolver = yield* DetailResolver;
+			const env = yield* detector.detect();
+			const executor = yield* executorResolver.resolve(env);
+			const format = yield* formatSelector.select(executor, opts.format, env);
+			const health = {
+				hasFailures: reports.some((r) => r.summary.failed > 0 || r.unhandledErrors.length > 0),
+				belowTargets: reports.some((r) => {
+					return (r.coverage?.belowTarget?.length ?? 0) > 0;
+				}),
+				hasTargets: !!opts.coverageTargets
+			};
+			const detail = yield* detailResolver.resolve(executor, health, opts.detail);
+			yield* Effect.logDebug("pipeline resolved").pipe(Effect.annotateLogs({
+				env,
+				executor,
+				format,
+				detail
+			}));
+			const classifications = /* @__PURE__ */ new Map();
+			for (const report of reports) for (const mod of report.failed) for (const test of mod.tests) if (test.classification) classifications.set(test.fullName, test.classification);
+			const githubSummaryFile = process.env.GITHUB_STEP_SUMMARY;
+			const kit = buildReporterKit({
+				env,
+				executor,
+				format,
+				detail,
+				noColor: !!process.env.NO_COLOR,
+				consoleMode: opts.consoleMode ?? "passthrough",
+				mcp: opts.mcp ?? false,
+				githubActions: opts.githubActions,
+				transport: opts.transport,
+				runEvents,
+				...dbPath !== void 0 && { dbPath },
+				...opts.projectFilter !== void 0 && { projectFilter: opts.projectFilter },
+				...opts.coverageThresholds !== void 0 && { coverageThresholds: opts.coverageThresholds },
+				...opts.coverageTargets !== void 0 && { coverageTargets: opts.coverageTargets },
+				...opts.passWithNoTests !== void 0 && { passWithNoTests: opts.passWithNoTests },
+				coverageMode: opts.coverageMode
+			});
+			const reporters = preBuiltReporters ?? normalizeReporters(opts.reporter(kit));
+			const renderInput = {
+				reports,
+				classifications,
+				...trendSummary !== void 0 && { trendSummary }
+			};
+			const allOutputs = reporters.flatMap((r) => r.render(renderInput, kit));
+			yield* Effect.logDebug("reporters rendered").pipe(Effect.annotateLogs({
+				reporterCount: reporters.length,
+				outputs: allOutputs.length
+			}));
+			for (const output of allOutputs) routeRenderedOutput(output, { ...githubSummaryFile !== void 0 && { githubSummaryFile } });
+		});
+		await Effect.runPromise(program.pipe(Effect.annotateLogs("service", "reporter"), Effect.provide(ReporterLive(dbPath, logLevel, logFile)))).catch((err) => {
+			process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
+		});
+	}
+};
+
+//#endregion
+export { AgentReporter };