@vitest-agent/sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @vitest-agent/sdk
+
+[![npm](https://img.shields.io/npm/v/@vitest-agent/sdk?label=npm&color=cb3837)](https://www.npmjs.com/package/@vitest-agent/sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+
+> **Part of the [vitest-agent](https://vitest-agent.dev) ecosystem.** Most users want **[@vitest-agent/plugin](https://www.npmjs.com/package/@vitest-agent/plugin)**, which pulls this package in automatically. Install `@vitest-agent/sdk` directly only if you build tooling on the shared schemas or data layer.
+
+The no-internal-deps base for the vitest-agent ecosystem. Carries the Effect Schemas, SQLite migrations and data layer, services and live layers, formatters, XDG path resolution, the public reporter and dispatcher contract types, and testing utilities.
+
+## Features
+
+- **Effect Schemas** — all domain types (`RunEvent`, `RenderState`, `CoverageTargets`, `TurnPayload`, identity types) defined with Effect Schema; runtime validation and TypeScript types from one source
+- **SQLite data layer** — `DataStore` and `DataReader` Effect services with live and `:memory:` test layers; `ensureMigrated` for safe multi-project setups
+- **XDG path resolution** — deterministic `dbPath` derivation from workspace identity with a five-source fallback chain
+- **Reporter and dispatcher contracts** — `VitestAgentReporterFactory`, `ReporterKit`, `ResolvedReporterConfig`, `DispatchInputs` and the types consumed by every other package
+- **Sidecar dispatch core** — `dispatch`, `injectEnv` and `exitCodeForTag` on the `@vitest-agent/sdk/dispatch` sub-path for a minimal SEA bundle
+- **Test utilities** — `makeTestLayer`, `DataStoreTestLayer` and five preset factory functions on the `@vitest-agent/sdk/testing` sub-path
+
+## Install
+
+```bash
+npm install @vitest-agent/sdk
+# or
+pnpm add @vitest-agent/sdk
+```
+
+## Quick start
+
+```ts
+import { Effect } from "effect";
+import { DataReader } from "@vitest-agent/sdk";
+import { singlePassingRun } from "@vitest-agent/sdk/testing";
+
+const layer = singlePassingRun(":memory:");
+
+await Effect.runPromise(
+  Effect.provide(
+    Effect.flatMap(DataReader, (r) => r.getLatestRun("default", null)),
+    layer,
+  ),
+);
+// returns the seeded run row
+```
+
+## Documentation
+
+Package reference at [vitest-agent.dev/sdk](https://vitest-agent.dev/sdk).
+
+## License
+
+[MIT](LICENSE)

package/dispatch.d.ts

@@ -0,0 +1,48 @@
+//#region src/exit-code-for-tag.d.ts
+/**
+ * Map a tagged-error `_tag` to the agent-agnostic sidecar exit-code
+ * taxonomy. Unknown tags collapse to `5` (other unexpected defect).
+ * @public
+ */
+declare const exitCodeForTag: (tag: string) => number;
+//#endregion
+//#region src/internal-inject-env.d.ts
+/** Input to {@link injectEnv}. @public */
+interface InjectEnvInput {
+  readonly command: string;
+  readonly cwd: string;
+  readonly env: Record<string, string | undefined>;
+}
+/**
+ * Compute the (possibly rewritten) Bash command. Returns the original
+ * unchanged when:
+ *
+ *   - The command does not match any Vitest pattern
+ *   - `VITEST_AGENT_CONVERSATION_ID` or `VITEST_AGENT_AGENT_ID` is
+ *     missing from env (no agent context to attribute to)
+ *
+ * Always synchronous — the package.json read is the only I/O and is
+ * fast enough not to need Effect wrapping.
+ * @public
+ */
+declare const injectEnv: (input: InjectEnvInput) => string;
+//#endregion
+//#region src/sidecar-dispatch.d.ts
+/** Result of a {@link dispatch} call: captured stdout/stderr + exit code.
+ * @public
+ */
+interface DispatchResult {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly code: number;
+}
+/**
+ * Dispatch one argv invocation. `argv` is the post-`node post-bin`
+ * slice — i.e. `process.argv.slice(2)`. Never throws: every failure is
+ * folded into the returned {@link DispatchResult}.
+ * @public
+ */
+declare const dispatch: (argv: readonly string[]) => Promise<DispatchResult>;
+//#endregion
+export { type DispatchResult, type InjectEnvInput, dispatch, exitCodeForTag, injectEnv };
+//# sourceMappingURL=dispatch.d.ts.map

package/dispatch.js

@@ -0,0 +1,5 @@
+import { exitCodeForTag } from "./exit-code-for-tag.js";
+import { injectEnv } from "./internal-inject-env.js";
+import { dispatch } from "./sidecar-dispatch.js";
+
+export { dispatch, exitCodeForTag, injectEnv };

package/errors/AgentErrors.js

@@ -0,0 +1,65 @@
+import { Data } from "effect";
+
+//#region src/errors/AgentErrors.ts
+/**
+* `agent_id` does not exist for the given chat. Surface to the
+* caller; the typical resolution is to call `register_agent` for
+* this agent first.
+* @public
+*/
+var AgentNotFoundError = class extends Data.TaggedError("AgentNotFoundError") {};
+/**
+* Session row for the given `chat_id` does not exist. The host
+* probably hasn't fired the SessionStart equivalent for this chat yet.
+* @public
+*/
+var SessionNotFoundError = class extends Data.TaggedError("SessionNotFoundError") {};
+/**
+* `conversation_id` does not exist. Used by rollup queries that
+* require a conversation row.
+* @public
+*/
+var ConversationNotFoundError = class extends Data.TaggedError("ConversationNotFoundError") {};
+/**
+* True conflict — e.g., the `parentAgentId` supplied to
+* `register_agent` refers to a different session than the one the
+* caller named. Distinct from `IdempotencyHit`, which is a success.
+* @public
+*/
+var RegistrationConflictError = class extends Data.TaggedError("RegistrationConflictError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[register_agent] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/**
+* `host_metadata` JSON column failed to parse on read. Usually mapped
+* to `DataStoreError` at the row-read boundary; surfaces alone in
+* paths that explicitly carry through `Schema.parseJson` errors.
+* @public
+*/
+var HostMetadataParseError = class extends Data.TaggedError("HostMetadataParseError") {};
+/**
+* Sidecar exceeded its timeout. Surfaces from the sidecar CLI's
+* `Effect.timeout`; the top-level wrapper maps it to exit code 2.
+* @public
+*/
+var SidecarTimeoutError = class extends Data.TaggedError("SidecarTimeoutError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[sidecar ${args.operation}] timed out after ${args.timeoutMs}ms`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+
+//#endregion
+export { AgentNotFoundError, ConversationNotFoundError, HostMetadataParseError, RegistrationConflictError, SessionNotFoundError, SidecarTimeoutError };

package/errors/DataStoreError.js

@@ -0,0 +1,44 @@
+import { Data } from "effect";
+
+//#region src/errors/DataStoreError.ts
+/**
+* Error raised when a SQLite operation fails at read, write, or migration time.
+* @public
+*/
+var DataStoreError = class extends Data.TaggedError("DataStoreError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[${args.operation} ${args.table}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/**
+* Extract a human-readable reason string from an Effect SqlError or unknown error.
+*
+* SqlError wraps the underlying better-sqlite3 error in `cause`. The actual SQLite
+* message (e.g. "SQLITE_BUSY: database is locked", "UNIQUE constraint failed: ...")
+* lives on `cause.message`, while the SqlError's own `message` is generic
+* ("Failed to execute statement"). Prefer the cause's message when available.
+* @public
+*/
+const extractSqlReason = (e) => {
+	const err = e;
+	if (err && typeof err === "object") {
+		if (err.cause) {
+			if (typeof err.cause === "string") return err.cause;
+			if (typeof err.cause === "object" && typeof err.cause.message === "string") return err.cause.message;
+		}
+		if (typeof err.message === "string" && err.message.length > 0) return err.message;
+		try {
+			return JSON.stringify(e);
+		} catch {}
+	}
+	return String(e);
+};
+
+//#endregion
+export { DataStoreError, extractSqlReason };

package/errors/DiscoveryError.js

@@ -0,0 +1,21 @@
+import { Data } from "effect";
+
+//#region src/errors/DiscoveryError.ts
+/**
+* Error raised when project discovery (glob, file read, or stat) fails.
+* @public
+*/
+var DiscoveryError = class extends Data.TaggedError("DiscoveryError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[${args.operation} ${args.path}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+
+//#endregion
+export { DiscoveryError };

package/errors/PathResolutionError.js

@@ -0,0 +1,27 @@
+import { Data } from "effect";
+
+//#region src/errors/PathResolutionError.ts
+/**
+* Error raised when the data directory path cannot be resolved.
+*
+* The most common case is missing workspace identity: no `projectKey`
+* override in `vitest-agent.config.toml` and no `name` field in
+* the root workspace's `package.json`. The path is a function of the
+* workspace's identity, so without one we have no canonical location to
+* write to.
+* @public
+*/
+var PathResolutionError = class extends Data.TaggedError("PathResolutionError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: args.reason,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+
+//#endregion
+export { PathResolutionError };

package/errors/ProjectIdentityError.js

@@ -0,0 +1,29 @@
+import { Data } from "effect";
+
+//#region src/errors/ProjectIdentityError.ts
+/**
+* Raised at plugin / sidecar / MCP boot when the project's identity
+* cannot be resolved through the documented fallback chain. The error
+* carries the full list of attempted sources so the user knows which
+* lever to pull (set `projectId` explicitly, configure the TOML file,
+* add a git remote, or set `name` in `package.json`).
+*
+* Replaces the legacy `WorkspaceRootNotFoundError` for callers that
+* went through the new resolver.
+* @public
+*/
+var ProjectIdentityNotResolvableError = class extends Data.TaggedError("ProjectIdentityNotResolvableError") {
+	constructor(args) {
+		super(args);
+		const summary = args.tried.length === 0 ? "no sources attempted" : args.tried.map((c) => `${c.source}: ${c.reason}`).join("; ");
+		Object.defineProperty(this, "message", {
+			value: `Project identity could not be resolved (${summary}). Set projectId explicitly in vitest.config.ts, projectKey in vitest-agent.config.toml, configure a git remote, or add "name" to package.json.`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+
+//#endregion
+export { ProjectIdentityNotResolvableError };

package/errors/RunContextError.js

@@ -0,0 +1,35 @@
+import { Data } from "effect";
+
+//#region src/errors/RunContextError.ts
+/**
+* Surfaces unexpected git-command failures from `RunContext`. Expected
+* non-zero exits (e.g., "not a git repository") are absorbed via
+* `Effect.option` and surface as `null` columns — they are not errors.
+* This error is reserved for "the executable is missing" /
+* "permission denied" / other system-level failures the caller cannot
+* meaningfully recover from.
+* @public
+*/
+var GitCommandError = class extends Data.TaggedError("GitCommandError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[git ${args.command}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/**
+* Internal probe miss — consumed by `Effect.firstSuccessOf` /
+* `Effect.orElse` inside the host-metadata probe chain. Never surfaces
+* to the caller of `RunContext.captureRunContext`; the public API
+* always returns a complete `RunContext` (with NULLs for missed
+* probes).
+* @internal
+*/
+var ProbeMissError = class extends Data.TaggedError("ProbeMissError") {};
+
+//#endregion
+export { GitCommandError, ProbeMissError };

package/errors/TddErrors.js

@@ -0,0 +1,66 @@
+import { Data } from "effect";
+
+//#region src/errors/TddErrors.ts
+/** @public */
+var GoalNotFoundError = class extends Data.TaggedError("GoalNotFoundError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[goal not_found id=${args.id}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/** @public */
+var BehaviorNotFoundError = class extends Data.TaggedError("BehaviorNotFoundError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[behavior not_found id=${args.id}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/** @public */
+var TddTaskNotFoundError = class extends Data.TaggedError("TddTaskNotFoundError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[tdd_task not_found id=${args.id}] ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/** @public */
+var TddTaskAlreadyEndedError = class extends Data.TaggedError("TddTaskAlreadyEndedError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[tdd_task ended id=${args.id}] outcome=${args.outcome} endedAt=${args.endedAt}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+/** @public */
+var IllegalStatusTransitionError = class extends Data.TaggedError("IllegalStatusTransitionError") {
+	constructor(args) {
+		super(args);
+		Object.defineProperty(this, "message", {
+			value: `[${args.entity} illegal_transition id=${args.id}] ${args.from} → ${args.to}: ${args.reason}`,
+			enumerable: true,
+			writable: false,
+			configurable: true
+		});
+	}
+};
+
+//#endregion
+export { BehaviorNotFoundError, GoalNotFoundError, IllegalStatusTransitionError, TddTaskAlreadyEndedError, TddTaskNotFoundError };

package/exit-code-for-tag.js

@@ -0,0 +1,18 @@
+//#region src/exit-code-for-tag.ts
+/**
+* Map a tagged-error `_tag` to the agent-agnostic sidecar exit-code
+* taxonomy. Unknown tags collapse to `5` (other unexpected defect).
+* @public
+*/
+const exitCodeForTag = (tag) => {
+	switch (tag) {
+		case "RegistrationConflictError": return 1;
+		case "SidecarTimeoutError": return 2;
+		case "DataStoreError": return 3;
+		case "ProjectIdentityNotResolvableError": return 4;
+		default: return 5;
+	}
+};
+
+//#endregion
+export { exitCodeForTag };

package/formatters/ci-annotations.js

@@ -0,0 +1,61 @@
+//#region src/formatters/ci-annotations.ts
+const escapeData = (s) => s.replace(/%/g, "%25").replace(/\n/g, "%0A").replace(/\r/g, "%0D");
+const escapeProperty = (s) => s.replace(/%/g, "%25").replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/:/g, "%3A").replace(/,/g, "%2C");
+const STACK_FILE_LINE = /\(([^():\s]+):(\d+):\d+\)/;
+function extractFileAndLine(error, fallbackFile) {
+	if (error.stack !== void 0) {
+		const m = STACK_FILE_LINE.exec(error.stack);
+		if (m) return {
+			file: m[1],
+			line: Number.parseInt(m[2], 10)
+		};
+	}
+	return {
+		file: fallbackFile,
+		line: 1
+	};
+}
+function annotateFailure(report) {
+	const lines = [];
+	for (const mod of report.failed) for (const test of mod.tests) {
+		if (test.state !== "failed") continue;
+		const errors = test.errors ?? [];
+		if (errors.length === 0) {
+			lines.push(`::error file=${escapeProperty(mod.file)},line=1,title=${escapeProperty(test.fullName)}::${escapeData(`${test.fullName} failed`)}`);
+			continue;
+		}
+		for (const err of errors) {
+			const { file, line } = extractFileAndLine(err, mod.file);
+			lines.push(`::error file=${escapeProperty(file)},line=${line},title=${escapeProperty(test.fullName)}::${escapeData(err.message)}`);
+		}
+	}
+	for (const err of report.unhandledErrors) lines.push(`::error title=Unhandled%20error::${escapeData(err.message)}`);
+	return lines;
+}
+/** @public */
+const ciAnnotationsFormatter = {
+	format: "ci-annotations",
+	render: (reports, _context) => {
+		const allLines = [];
+		let totalPassed = 0;
+		let totalFailed = 0;
+		let totalSkipped = 0;
+		let totalDuration = 0;
+		for (const r of reports) {
+			allLines.push(...annotateFailure(r));
+			totalPassed += r.summary.passed;
+			totalFailed += r.summary.failed;
+			totalSkipped += r.summary.skipped;
+			totalDuration += r.summary.duration;
+		}
+		if (allLines.length === 0) allLines.push(`::notice::${escapeData(`Vitest: ${totalPassed} passed, ${totalSkipped} skipped (${totalDuration}ms)`)}`);
+		return [{
+			target: "stdout",
+			content: `${allLines.join("\n")}\n`,
+			contentType: "text/plain"
+		}];
+	}
+};
+
+//#endregion
+export { ciAnnotationsFormatter };

package/formatters/gfm.js

@@ -0,0 +1,20 @@
+import { formatGfm } from "../utils/format-gfm.js";
+
+//#region src/formatters/gfm.ts
+/** @public */
+const GfmFormatter = {
+	format: "gfm",
+	render: (reports, _context) => {
+		const outputs = [];
+		const gfm = formatGfm([...reports]);
+		if (gfm) outputs.push({
+			target: "github-summary",
+			content: gfm,
+			contentType: "text/markdown"
+		});
+		return outputs;
+	}
+};
+
+//#endregion
+export { GfmFormatter };

package/formatters/json.js

@@ -0,0 +1,18 @@
+//#region src/formatters/json.ts
+/** @public */
+const JsonFormatter = {
+	format: "json",
+	render: (reports, _context) => {
+		const outputs = [];
+		const json = JSON.stringify(reports, null, 2);
+		outputs.push({
+			target: "stdout",
+			content: json,
+			contentType: "application/json"
+		});
+		return outputs;
+	}
+};
+
+//#endregion
+export { JsonFormatter };

package/formatters/markdown.js

@@ -0,0 +1,39 @@
+import { formatConsoleMarkdown } from "../utils/format-console.js";
+
+//#region src/formatters/markdown.ts
+/**
+* Markdown formatter for surfaces that *render* markdown.
+*
+* Stdout output goes through {@link TerminalFormatter} (plain text +
+* ANSI), not this formatter — markdown syntax (e.g. heading prefixes,
+* backticks, list dashes) is visual noise in a terminal that doesn't
+* render it. This formatter remains for callers that explicitly request
+* `format: "markdown"`, e.g. when piping the rendered output into a
+* Markdown-aware sink.
+* @public
+*/
+const MarkdownFormatter = {
+	format: "markdown",
+	render: (reports, context) => {
+		const outputs = [];
+		for (const report of reports) {
+			const md = formatConsoleMarkdown(report, {
+				consoleOutput: context.detail === "minimal" ? "failures" : "full",
+				coverageConsoleLimit: context.coverageConsoleLimit,
+				noColor: context.noColor,
+				...context.trendSummary !== void 0 ? { trendSummary: context.trendSummary } : {},
+				...context.runCommand !== void 0 ? { runCommand: context.runCommand } : {},
+				...context.mcp !== void 0 ? { mcp: context.mcp } : {}
+			});
+			if (md) outputs.push({
+				target: "stdout",
+				content: md,
+				contentType: "text/markdown"
+			});
+		}
+		return outputs;
+	}
+};
+
+//#endregion
+export { MarkdownFormatter };

package/formatters/silent.js

@@ -0,0 +1,9 @@
+//#region src/formatters/silent.ts
+/** @public */
+const SilentFormatter = {
+	format: "silent",
+	render: () => []
+};
+
+//#endregion
+export { SilentFormatter };

package/formatters/terminal.js

@@ -0,0 +1,56 @@
+import { formatTerminal } from "../utils/format-terminal.js";
+import { osc8 } from "../utils/hyperlink.js";
+import * as path from "node:path";
+
+//#region src/formatters/terminal.ts
+/**
+* Wrap test-file paths in failing-test rows with `file://` OSC-8
+* hyperlinks. Only fires when the target is stdout and noColor is
+* unset; MCP responses never reach this formatter so they cannot
+* accidentally pick up escape sequences.
+*
+* Failing-test rows are emitted by `renderFailedTest` in
+* `format-terminal.ts` as
+*
+*   `    ` + ANSI(red, ✗) + ` ` + path + ` > ` + fullName
+*
+* The ✗ is wrapped in ANSI color escapes whenever color is on (which
+* is always when this function runs — `wrapHyperlinks` is gated on
+* `!noColor`). The optional `(?:\x1b\[\d+m)?` groups around `✗` make
+* the pattern tolerant of those escapes; without them the regex
+* silently never matched and the hyperlink feature was a no-op.
+*
+* The captured path is project-relative (the failing-test row goes
+* through `relativePath()` in `format-terminal.ts`). RFC 8089
+* requires an absolute filesystem path inside a `file://` URL —
+* iTerm2 / WezTerm / Kitty / VSCode all silently fail to open
+* relative targets. Resolve the captured value back to absolute
+* against the cwd before handing it to `osc8`. The display label
+* stays relative so the rendered output is unchanged.
+* @public
+*/
+const FAILED_TEST_ROW = /^( {4}(?:\x1b\[\d+m)?✗(?:\x1b\[\d+m)? )([^ ]+)( > )/gm;
+const wrapHyperlinks = (text, ctx) => text.replace(FAILED_TEST_ROW, (_match, prefix, captured, suffix) => {
+	return `${prefix}${osc8(`file://${path.resolve(process.cwd(), captured)}`, captured, { enabled: !ctx.noColor })}${suffix}`;
+});
+/** @public */
+const TerminalFormatter = {
+	format: "terminal",
+	render: (reports, context) => {
+		const text = formatTerminal(reports, {
+			noColor: context.noColor,
+			coverageConsoleLimit: context.coverageConsoleLimit,
+			...context.trendSummary !== void 0 ? { trendSummary: context.trendSummary } : {},
+			...context.mcp !== void 0 ? { mcp: context.mcp } : {}
+		});
+		if (text === "") return [];
+		return [{
+			target: "stdout",
+			content: context.noColor ? text : wrapHyperlinks(text, context),
+			contentType: "text/plain"
+		}];
+	}
+};
+
+//#endregion
+export { TerminalFormatter };