@vitest-agent/sdk 1.0.0

package/migrations/registry_0001_initial.js

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import { SqlClient } from "@effect/sql/SqlClient";
+
+//#region src/migrations/registry_0001_initial.ts
+/**
+* Migration for the global discovery registry SQLite at
+* `$XDG_DATA_HOME/vitest-agent/registry.db`.
+*
+* Single table `known_projects` indexed by `project_key` (the
+* filesystem-safe form from {@link ProjectIdentity}). Tooling like
+* `mcp-app` queries this table to enumerate every vitest-agent
+* project the user has ever run on this machine.
+*
+* The registry never blocks anything — its writes are best-effort.
+* Concurrent writers from multiple Claude Code windows converge via
+* the `ON CONFLICT(project_key) DO UPDATE` upsert.
+* @public
+*/
+const migration = Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`PRAGMA journal_mode=WAL`;
+	yield* sql`PRAGMA foreign_keys=ON`;
+	yield* sql`PRAGMA busy_timeout=5000`;
+	yield* sql`
+		CREATE TABLE known_projects (
+			project_key       TEXT PRIMARY KEY,
+			canonical_form    TEXT NOT NULL,
+			data_db_path      TEXT NOT NULL,
+			git_remote_origin TEXT,
+			workspace_root    TEXT NOT NULL,
+			first_seen_at     INTEGER NOT NULL,
+			last_seen_at      INTEGER NOT NULL
+		) STRICT
+	`;
+	yield* sql`CREATE INDEX idx_known_projects_workspace_root ON known_projects(workspace_root)`;
+});
+
+//#endregion
+export { migration as default };

package/migrations/session_map_0001_initial.js

@@ -0,0 +1,61 @@
+import { Effect } from "effect";
+import { SqlClient } from "@effect/sql/SqlClient";
+
+//#region src/migrations/session_map_0001_initial.ts
+/**
+* Migration for the per-client session map SQLite at
+* `${CLAUDE_PLUGIN_DATA}/sessions.db` (Claude Code) or the
+* client-specific equivalent.
+*
+* The session map is a host-specific side-channel that translates
+* client-native identifiers (transcript path, hook-payload session id)
+* into the canonical UUIDs the per-project `data.db` expects. It lets
+* `claude --resume` reuse the same `conversation_id` UUID across
+* restarts.
+*
+* Two STRICT tables:
+*   - `conversation_map` keyed on the transcript filename UUID
+*     (already a UUID per Claude Code's convention)
+*   - `session_map` keyed on the host's native session id (the chat
+*     UUID — `session_id` from the Claude Code hook payload, exposed
+*     to agents as `chatId` post the 2026-05 rename)
+*
+* Concurrent writers from multiple Claude Code windows converge via
+* idempotent UPSERTs on the native-id keys; WAL mode plus 5s
+* busy_timeout absorb contention.
+* @public
+*/
+/** @internal */
+const migration = Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`PRAGMA journal_mode=WAL`;
+	yield* sql`PRAGMA foreign_keys=ON`;
+	yield* sql`PRAGMA busy_timeout=5000`;
+	yield* sql`
+		CREATE TABLE conversation_map (
+			transcript_uuid  TEXT PRIMARY KEY,
+			transcript_path  TEXT NOT NULL,
+			conversation_id  TEXT NOT NULL UNIQUE,
+			first_seen_at    INTEGER NOT NULL,
+			last_seen_at     INTEGER NOT NULL
+		) STRICT
+	`;
+	yield* sql`
+		CREATE TABLE session_map (
+			host_session_id  TEXT PRIMARY KEY,
+			conversation_id  TEXT NOT NULL REFERENCES conversation_map(conversation_id) ON DELETE RESTRICT,
+			project_key      TEXT NOT NULL,
+			project_dir      TEXT NOT NULL,
+			main_agent_id    TEXT NOT NULL,
+			started_at       INTEGER NOT NULL,
+			ended_at         INTEGER
+		) STRICT
+	`;
+	yield* sql`CREATE INDEX idx_session_map_project_key ON session_map(project_key)`;
+	yield* sql`CREATE INDEX idx_session_map_project_dir ON session_map(project_dir)`;
+	yield* sql`CREATE INDEX idx_session_map_active ON session_map(project_dir) WHERE ended_at IS NULL`;
+	yield* sql`CREATE INDEX idx_session_map_conversation_id ON session_map(conversation_id)`;
+});
+
+//#endregion
+export { migration as default };

package/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@vitest-agent/sdk",
+	"version": "1.0.0",
+	"private": false,
+	"description": "Shared Effect Schema, SQLite migrations, data layer, services, formatters, and utilities for vitest-agent packages.",
+	"keywords": [
+		"vitest",
+		"agent",
+		"shared",
+		"effect",
+		"sqlite"
+	],
+	"homepage": "https://github.com/spencerbeggs/vitest-agent#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/vitest-agent/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/vitest-agent.git",
+		"directory": "packages/sdk"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./dispatch": {
+			"types": "./dispatch.d.ts",
+			"import": "./dispatch.js"
+		},
+		"./testing": {
+			"types": "./testing.d.ts",
+			"import": "./testing.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@effect/cluster": "^0.59.0",
+		"@effect/platform": "^0.96.2",
+		"@effect/platform-node": "^0.107.0",
+		"@effect/rpc": "^0.75.1",
+		"@effect/sql": "^0.51.1",
+		"@effect/sql-sqlite-node": "^0.52.0",
+		"@types/acorn": "^6.0.4",
+		"acorn": "^8.17.0",
+		"acorn-typescript": "^1.4.13",
+		"ajv": "^8.20.0",
+		"config-file-effect": "^0.2.3",
+		"effect": "^3.21.4",
+		"std-env": "^4.1.0",
+		"workspaces-effect": "^1.2.0",
+		"xdg-effect": "^2.0.1"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/schemas/Agent.js

@@ -0,0 +1,42 @@
+import { AgentId, ConversationId } from "./Identity.js";
+import { Data, Schema } from "effect";
+
+//#region src/schemas/Agent.ts
+/**
+* Successful registration row. The fields mirror the `agents` SQLite
+* table 1:1 in camelCase.
+*
+* `startGitBranch`, `startGitCommitSha`, `startWorktreeDir` capture
+* *what the agent inherited at registration time* — distinct from the
+* per-run git context recorded on `runs`. A divergence between the
+* two reveals a mid-session branch switch, which is itself signal.
+* @public
+*/
+var Agent = class extends Schema.TaggedClass()("Agent", {
+	agentId: AgentId,
+	sessionId: Schema.Number,
+	parentAgentId: Schema.NullOr(AgentId),
+	conversationId: Schema.NullOr(ConversationId),
+	agentType: Schema.String,
+	startedAt: Schema.Number,
+	endedAt: Schema.NullOr(Schema.Number),
+	startGitBranch: Schema.NullOr(Schema.String),
+	startGitCommitSha: Schema.NullOr(Schema.String),
+	startWorktreeDir: Schema.NullOr(Schema.String),
+	idempotencyKey: Schema.String
+}) {};
+/**
+* Returned by `DataStore.registerAgent` when the
+* `(session_id, idempotency_key)` UNIQUE constraint already has a
+* row. Not an error — the caller treats it as a successful recovery
+* of the existing `agentId`.
+*
+* Modeled as a `Data.TaggedClass` so the success channel of
+* `registerAgent` is `Effect<Agent | IdempotencyHit, ...>` and
+* downstream code uses `Match.tag` to branch.
+* @public
+*/
+var IdempotencyHit = class extends Data.TaggedClass("IdempotencyHit") {};
+
+//#endregion
+export { Agent, IdempotencyHit };

package/schemas/AgentReport.js

@@ -0,0 +1,71 @@
+import { ReportError, TestClassification, TestRunReason, TestState } from "./Common.js";
+import { CoverageReport } from "./Coverage.js";
+import { Schema } from "effect";
+
+//#region src/schemas/AgentReport.ts
+/**
+* Aggregate test run statistics.
+* @public
+*/
+const ReportSummary = Schema.Struct({
+	total: Schema.Number,
+	passed: Schema.Number,
+	failed: Schema.Number,
+	skipped: Schema.Number,
+	duration: Schema.Number
+}).annotations({ identifier: "ReportSummary" });
+/**
+* An individual test case result.
+* @public
+*/
+const TestReport = Schema.Struct({
+	name: Schema.String,
+	fullName: Schema.String,
+	state: TestState,
+	duration: Schema.optional(Schema.Number),
+	flaky: Schema.optional(Schema.Boolean),
+	slow: Schema.optional(Schema.Boolean),
+	errors: Schema.optional(Schema.Array(ReportError)),
+	classification: Schema.optional(TestClassification)
+}).annotations({ identifier: "TestReport" });
+/**
+* A test module (file) and its contained test cases.
+* @public
+*/
+const ModuleReport = Schema.Struct({
+	file: Schema.String,
+	state: TestState,
+	duration: Schema.optional(Schema.Number),
+	errors: Schema.optional(Schema.Array(ReportError)),
+	tests: Schema.Array(TestReport)
+}).annotations({ identifier: "ModuleReport" });
+/**
+* Per-tag pass/fail/skip aggregates for a single project run.
+* @public
+*/
+const TagCountEntry = Schema.Struct({
+	passed: Schema.optional(Schema.Number),
+	failed: Schema.optional(Schema.Number),
+	skipped: Schema.optional(Schema.Number)
+}).annotations({ identifier: "TagCountEntry" });
+/**
+* Complete per-project test report written to disk as JSON.
+* @public
+*/
+const AgentReport = Schema.Struct({
+	timestamp: Schema.String,
+	project: Schema.optional(Schema.String),
+	reason: TestRunReason,
+	summary: ReportSummary,
+	failed: Schema.Array(ModuleReport),
+	unhandledErrors: Schema.Array(ReportError),
+	failedFiles: Schema.Array(Schema.String),
+	coverage: Schema.optional(CoverageReport),
+	tagCounts: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: TagCountEntry
+	}))
+}).annotations({ identifier: "AgentReport" });
+
+//#endregion
+export { AgentReport, ModuleReport, ReportSummary, TagCountEntry, TestReport };

package/schemas/Baselines.js

@@ -0,0 +1,16 @@
+import { MetricThresholds, PatternThresholds } from "./Thresholds.js";
+import { Schema } from "effect";
+
+//#region src/schemas/Baselines.ts
+/**
+* Coverage baselines -- the auto-ratcheting high-water mark.
+* @public
+*/
+const CoverageBaselines = Schema.Struct({
+	updatedAt: Schema.String,
+	global: MetricThresholds,
+	patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+}).annotations({ identifier: "CoverageBaselines" });
+
+//#endregion
+export { CoverageBaselines };

package/schemas/CacheManifest.js

@@ -0,0 +1,27 @@
+import { TestRunReason } from "./Common.js";
+import { Schema } from "effect";
+
+//#region src/schemas/CacheManifest.ts
+/**
+* A single project entry in the cache manifest.
+* @public
+*/
+const CacheManifestEntry = Schema.Struct({
+	project: Schema.String,
+	reportFile: Schema.String,
+	historyFile: Schema.optional(Schema.String),
+	lastRun: Schema.NullOr(Schema.String),
+	lastResult: Schema.NullOr(TestRunReason)
+}).annotations({ identifier: "CacheManifestEntry" });
+/**
+* Root manifest file that indexes all project reports.
+* @public
+*/
+const CacheManifest = Schema.Struct({
+	updatedAt: Schema.String,
+	cacheDir: Schema.String,
+	projects: Schema.Array(CacheManifestEntry)
+}).annotations({ identifier: "CacheManifest" });
+
+//#endregion
+export { CacheManifest, CacheManifestEntry };

package/schemas/ChannelEvent.js

@@ -0,0 +1,138 @@
+import { Schema } from "effect";
+
+//#region src/schemas/ChannelEvent.ts
+/**
+* Channel event schemas for the orchestrator → main-agent progress push.
+*
+* All payloads share a `type` discriminator and pass through
+* `tdd_progress_push`. Behavior-level events declare goalId/sessionId
+* fields, but the MCP server resolves those server-side from
+* behaviorId via `DataReader.resolveGoalIdForBehavior` before emitting
+* the notification — caller-supplied values for goalId/sessionId on
+* behavior events are advisory and may be overwritten.
+*/
+/** @public */
+const SessionOutcome = Schema.Literal("succeeded", "blocked", "abandoned");
+const PhaseLiteral = Schema.Literal("spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red");
+const GoalSummary = Schema.Struct({
+	id: Schema.Number,
+	ordinal: Schema.Number,
+	goal: Schema.String
+});
+const BehaviorSummary = Schema.Struct({
+	id: Schema.Number,
+	ordinal: Schema.Number,
+	behavior: Schema.String
+});
+/** @public */
+const GoalsReadyEvent = Schema.Struct({
+	type: Schema.Literal("goals_ready"),
+	sessionId: Schema.Number,
+	goals: Schema.Array(GoalSummary)
+});
+/** @public */
+const GoalAddedEvent = Schema.Struct({
+	type: Schema.Literal("goal_added"),
+	sessionId: Schema.Number,
+	goal: GoalSummary
+});
+/** @public */
+const GoalStartedEvent = Schema.Struct({
+	type: Schema.Literal("goal_started"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number
+});
+/** @public */
+const GoalCompletedEvent = Schema.Struct({
+	type: Schema.Literal("goal_completed"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorIds: Schema.Array(Schema.Number)
+});
+/** @public */
+const GoalAbandonedEvent = Schema.Struct({
+	type: Schema.Literal("goal_abandoned"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	reason: Schema.String
+});
+/** @public */
+const BehaviorsReadyEvent = Schema.Struct({
+	type: Schema.Literal("behaviors_ready"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviors: Schema.Array(BehaviorSummary)
+});
+/** @public */
+const BehaviorAddedEvent = Schema.Struct({
+	type: Schema.Literal("behavior_added"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behavior: BehaviorSummary
+});
+/** @public */
+const BehaviorStartedEvent = Schema.Struct({
+	type: Schema.Literal("behavior_started"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorId: Schema.Number
+});
+/** @public */
+const PhaseTransitionEvent = Schema.Struct({
+	type: Schema.Literal("phase_transition"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorId: Schema.Number,
+	from: PhaseLiteral,
+	to: PhaseLiteral
+});
+/** @public */
+const BehaviorCompletedEvent = Schema.Struct({
+	type: Schema.Literal("behavior_completed"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorId: Schema.Number
+});
+/** @public */
+const BehaviorAbandonedEvent = Schema.Struct({
+	type: Schema.Literal("behavior_abandoned"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorId: Schema.Number,
+	reason: Schema.String
+});
+/** @public */
+const BlockedEvent = Schema.Struct({
+	type: Schema.Literal("blocked"),
+	sessionId: Schema.Number,
+	goalId: Schema.Number,
+	behaviorId: Schema.Number,
+	reason: Schema.String,
+	failureSignatureHash: Schema.optional(Schema.String)
+});
+/** @public */
+const SessionCompleteEvent = Schema.Struct({
+	type: Schema.Literal("session_complete"),
+	sessionId: Schema.Number,
+	goalIds: Schema.Array(Schema.Number),
+	outcome: SessionOutcome
+});
+/** @public */
+const ChannelEvent = Schema.Union(GoalsReadyEvent, GoalAddedEvent, GoalStartedEvent, GoalCompletedEvent, GoalAbandonedEvent, BehaviorsReadyEvent, BehaviorAddedEvent, BehaviorStartedEvent, PhaseTransitionEvent, BehaviorCompletedEvent, BehaviorAbandonedEvent, BlockedEvent, SessionCompleteEvent);
+/**
+* Event types whose `goalId` and `sessionId` should be resolved
+* server-side from `behaviorId` (per spec: "not trusting the
+* orchestrator's request"). Listed explicitly so the resolver knows
+* which subset to enrich vs pass through.
+* @public
+*/
+const BehaviorScopedEventTypes = [
+	"behavior_started",
+	"phase_transition",
+	"behavior_completed",
+	"behavior_abandoned",
+	"blocked"
+];
+
+//#endregion
+export { BehaviorAbandonedEvent, BehaviorAddedEvent, BehaviorCompletedEvent, BehaviorScopedEventTypes, BehaviorStartedEvent, BehaviorsReadyEvent, BlockedEvent, ChannelEvent, GoalAbandonedEvent, GoalAddedEvent, GoalCompletedEvent, GoalStartedEvent, GoalsReadyEvent, PhaseTransitionEvent, SessionCompleteEvent, SessionOutcome };

package/schemas/Common.js

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Common.ts
+/**
+* Common schemas shared across multiple modules.
+*
+* Defines enums/literals and the ReportError struct used by
+* both AgentReport and CacheManifest schemas.
+*/
+/**
+* Possible states for an individual test case.
+* @public
+*/
+const TestState = Schema.Literal("passed", "failed", "skipped", "pending").annotations({ identifier: "TestState" });
+/**
+* Overall outcome of a test run.
+* @public
+*/
+const TestRunReason = Schema.Literal("passed", "failed", "interrupted").annotations({ identifier: "TestRunReason" });
+/**
+* Classification of a test's failure history across runs.
+* @public
+*/
+const TestClassification = Schema.Literal("stable", "new-failure", "persistent", "flaky", "recovered").annotations({ identifier: "TestClassification" });
+/**
+* Console output verbosity mode for AgentReporter.
+* @public
+*/
+const ConsoleOutputMode = Schema.Literal("failures", "full", "silent").annotations({ identifier: "ConsoleOutputMode" });
+/**
+* Console output choices per executor type.
+*
+* - `passthrough` — plugin emits nothing observable; Vitest's own reporters
+*   do the visible work. Persistence still runs. Default for `human` and `ci`.
+* - `silent` — strip Vitest's reporters AND emit nothing from the plugin.
+*   True silence. Persistence still runs.
+* - `agent` — markdown-flavored final-frame string tuned for token economy.
+*   Default for `agent` executor. Set on `human` as the debugging mode for
+*   inspecting the exact plain-text output an agent consumes.
+* - `stream` — progressively-drawn, colored, animated rendering of the
+*   agent's run-shape view. Strips Vitest's reporters and owns stdout for
+*   the duration of the run. Human executor only.
+* - `ci-annotations` — GitHub Actions `::error::` annotations. Opt-in for
+*   the `ci` executor; the matching dedicated emitter is not yet shipped,
+*   so the default for `ci` is `passthrough` until it lands.
+* @public
+*/
+const HumanConsoleMode = Schema.Literal("passthrough", "silent", "stream", "agent").annotations({ identifier: "HumanConsoleMode" });
+/** @public */
+const AgentConsoleMode = Schema.Literal("passthrough", "silent", "agent").annotations({ identifier: "AgentConsoleMode" });
+/** @public */
+const CiConsoleMode = Schema.Literal("passthrough", "silent", "ci-annotations").annotations({ identifier: "CiConsoleMode" });
+/**
+* Union of every legal console-output value across the three executor slots.
+* Useful for type-narrowing in renderers that take the resolved value.
+* @public
+*/
+const ConsoleMode = Schema.Union(HumanConsoleMode, AgentConsoleMode, CiConsoleMode).annotations({ identifier: "ConsoleMode" });
+/**
+* Supported package managers for run command generation.
+* @public
+*/
+const PackageManager = Schema.Literal("pnpm", "npm", "yarn", "bun").annotations({ identifier: "PackageManager" });
+/**
+* Runtime environment where tests are being executed.
+* @public
+*/
+const Environment = Schema.Literal("agent-shell", "terminal", "ci-github", "ci-generic").annotations({ identifier: "Environment" });
+/**
+* Who or what is executing the test run.
+* @public
+*/
+const Executor = Schema.Literal("human", "agent", "ci").annotations({ identifier: "Executor" });
+/**
+* Output format for the reporter pipeline.
+* @public
+*/
+const OutputFormat = Schema.Literal("terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations").annotations({ identifier: "OutputFormat" });
+/**
+* Level of detail in reporter output.
+* @public
+*/
+const DetailLevel = Schema.Literal("minimal", "neutral", "standard", "verbose").annotations({ identifier: "DetailLevel" });
+/**
+* A single test or module error with optional stack trace, diff, and
+* structured assertion values.
+*
+* `expected` / `received` are pre-stringified, one-line representations
+* of the assertion's expected and received JS values. They are populated
+* only when the underlying test runner error carries structured `.expected`
+* / `.actual` properties (assertion errors). The raw JS values stay in
+* Vitest's internal error object; only the string representation crosses
+* the schema boundary.
+* @public
+*/
+const ReportError = Schema.Struct({
+	message: Schema.String,
+	stack: Schema.optional(Schema.String),
+	diff: Schema.optional(Schema.String),
+	expected: Schema.optional(Schema.String),
+	received: Schema.optional(Schema.String)
+}).annotations({ identifier: "ReportError" });
+
+//#endregion
+export { AgentConsoleMode, CiConsoleMode, ConsoleMode, ConsoleOutputMode, DetailLevel, Environment, Executor, HumanConsoleMode, OutputFormat, PackageManager, ReportError, TestClassification, TestRunReason, TestState };

package/schemas/Config.js

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Config.ts
+/**
+* Schema for the optional `vitest-agent.config.toml` file.
+*
+* Both fields are optional. When the file is absent or these fields are
+* unset, `resolveDataPath` falls back to deriving the path from the
+* workspace's `package.json` `name` under the XDG data directory.
+*
+* Fields:
+* - `cacheDir` — absolute path overriding the entire data directory. Highest
+*   precedence after the programmatic option. Use this to relocate the SQLite
+*   database (e.g. project-local `.vitest-agent/`) instead of the
+*   default XDG location.
+* - `projectKey` — overrides the workspace key segment under the XDG data
+*   directory. Use this when two unrelated projects on the same machine
+*   share a `package.json` `name` (the collision case for workspace-name
+*   keying), or when you want a stable key independent of `name` changes.
+* @public
+*/
+var VitestAgentConfig = class extends Schema.Class("VitestAgentConfig")({
+	cacheDir: Schema.optional(Schema.String),
+	projectKey: Schema.optional(Schema.String)
+}) {};
+
+//#endregion
+export { VitestAgentConfig };

package/schemas/Coverage.js

@@ -0,0 +1,51 @@
+import { MetricThresholds, PatternThresholds } from "./Thresholds.js";
+import { Schema } from "effect";
+
+//#region src/schemas/Coverage.ts
+/**
+* Aggregate coverage percentages across four istanbul metrics.
+* @public
+*/
+const CoverageTotals = Schema.Struct({
+	statements: Schema.Number,
+	branches: Schema.Number,
+	functions: Schema.Number,
+	lines: Schema.Number
+}).annotations({ identifier: "CoverageTotals" });
+/**
+* Per-file coverage data including uncovered line ranges.
+* @public
+*/
+const FileCoverageReport = Schema.Struct({
+	file: Schema.String,
+	summary: CoverageTotals,
+	uncoveredLines: Schema.String
+}).annotations({ identifier: "FileCoverageReport" });
+/**
+* Complete coverage report attached to an AgentReport.
+* @public
+*/
+const CoverageReport = Schema.Struct({
+	totals: CoverageTotals,
+	thresholds: Schema.Struct({
+		global: MetricThresholds,
+		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+	}),
+	targets: Schema.optional(Schema.Struct({
+		global: MetricThresholds,
+		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+	})),
+	baselines: Schema.optional(Schema.Struct({
+		global: MetricThresholds,
+		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+	})),
+	scoped: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+	scopedFiles: Schema.optional(Schema.Array(Schema.String)),
+	lowCoverage: Schema.Array(FileCoverageReport),
+	lowCoverageFiles: Schema.Array(Schema.String),
+	belowTarget: Schema.optional(Schema.Array(FileCoverageReport)),
+	belowTargetFiles: Schema.optional(Schema.Array(Schema.String))
+}).annotations({ identifier: "CoverageReport" });
+
+//#endregion
+export { CoverageReport, CoverageTotals, FileCoverageReport };