@vitest-agent/sdk 1.0.0

package/index.d.ts

@@ -0,0 +1,3334 @@
+import { $ as ValidateHypothesisInput, $t as TddTaskId, A as CreateGoalInput, At as CacheManifestEntry, B as RunChangedFile, Bt as extractSqlReason, C as TestError, Ct as GoalDetail, D as AssociateRunSessionInput, Dt as TestHistory, E as TurnSummary, Et as HistoryRecord, F as HypothesisInput, Ft as IllegalStatusTransitionError, G as SuiteInput, Gt as SessionNotFoundError, H as SessionInput, Ht as ConversationNotFoundError, I as IdempotentResponseInput, It as TddTaskAlreadyEndedError, J as TestErrorInput, Jt as AgentId, K as TddTaskInput, Kt as SidecarTimeoutError, L as ModuleInput, Lt as TddTaskEndOutcome, M as EndTddTaskInput, Mt as BehaviorNotFoundError, N as FailureSignatureWriteInput, Nt as GoalNotFoundError, O as ChangeKind, Ot as TestRun, P as FileCoverageInput, Pt as IllegalStatusTransitionEntity, Q as UpdateGoalInput, Qt as ProjectKey, R as NoteInput, Rt as TddTaskNotFoundError, S as TddTaskSummary, St as BehaviorStatus, T as TurnSearchOptions, Tt as GoalStatus, U as SettingsInput, Ut as HostMetadataParseError, V as RunInvocationMethod, Vt as AgentNotFoundError, W as StackFrameInput, Wt as RegistrationConflictError, X as TurnInput, Xt as ConversationId, Y as TestRunInput, Yt as ChatId, Z as UpdateBehaviorInput, Zt as HostKind, _ as TagInventoryRow, _t as validatePhaseTransition, a as DataReader, an as CoverageReport, at as Agent, b as TddPhaseDetail, bt as BehaviorDetail, c as HypothesisDetail, ct as RegisterAgentResult, d as PersistentFailure, dt as DenialReason, en as AgentReport, et as WriteCommitInput, f as ProjectRunSummary, ft as Phase, g as SuiteListEntry, gt as requiredArtifactForTransition, h as SettingsRow, ht as Remediation, i as CurrentTddPhase, in as TestReport, it as WriteTddPhaseOutput, j as DataStore, jt as CoverageBaselines, k as CreateBehaviorInput, kt as CacheManifest, l as ModuleListEntry, lt as ArtifactKind, m as SettingsListEntry, mt as PhaseTransitionResult, n as CitedArtifactRow, nn as ReportSummary, nt as WriteTddArtifactInput, o as FailureSignatureDetail, on as CoverageTotals, ot as AgentTreeNode, p as SessionDetail, pt as PhaseTransitionContext, q as TestCaseInput, qt as ActorType, r as CommitChangesEntry, rn as TagCountEntry, rt as WriteTddPhaseInput, s as FlakyTest, sn as FileCoverageReport, st as IdempotencyHit, t as AcceptanceMetrics, tn as ModuleReport, tt as WriteRunChangedFilesInput, u as NoteRow, ut as CitedArtifact, v as TddArtifactDetail, vt as TrendEntry, w as TestListEntry, wt as GoalRow, x as TddTaskDetail, xt as BehaviorRow, y as TddArtifactRow, yt as TrendRecord, z as RegisterAgentInput, zt as DataStoreError } from "./DataReader-2kJ9I9Hh.js";
+import { Context, Effect, Layer, LogLevel, Option, PubSub, Schema } from "effect";
+import { CommandExecutor, FileSystem } from "@effect/platform";
+import { ConfigFileService } from "config-file-effect";
+import { SqlClient } from "@effect/sql/SqlClient";
+import { WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceRootNotFoundError } from "workspaces-effect";
+import { AppDirs } from "xdg-effect";
+
+//#region src/schemas/RenderState.d.ts
+/**
+ * Per-test record accumulated as `TestStarted` / `TestFinished` events arrive.
+ * @public
+ */
+declare const TestRecord: Schema.Struct<{
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+  durationMs: Schema.NullOr<typeof Schema.Number>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type TestRecord = typeof TestRecord.Type;
+/**
+ * Per-module aggregation. The reducer keeps modules keyed on
+ * `modulePath` so out-of-order events can update the right slot.
+ * @public
+ */
+declare const ModuleRecord: Schema.Struct<{
+  modulePath: typeof Schema.String;
+  status: Schema.Literal<["queued", "running", "finished"]>;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  timeoutCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  tests: Schema.Array$<Schema.Struct<{
+    testName: typeof Schema.String;
+    suitePath: Schema.Array$<typeof Schema.String>;
+    status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+    durationMs: Schema.NullOr<typeof Schema.Number>;
+    error: Schema.optional<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>;
+  }>>;
+  /**
+   * Owning Vitest project name. Optional — events from project-less
+   * configs or older replays leave it `undefined`, which the renderer
+   * treats as a single anonymous project.
+   */
+  projectName: Schema.optional<typeof Schema.String>;
+  /**
+   * ISO wall-clock stamp captured at `onTestModuleStart`. The live
+   * renderer derives a ticking elapsed column from it while the module
+   * runs; once finished it shows `durationMs` instead. Optional — a
+   * module seeded by `ModuleQueued` (or replayed) has no start stamp.
+   */
+  startedAt: Schema.optional<typeof Schema.String>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>;
+/** @public */
+type ModuleRecord = typeof ModuleRecord.Type;
+/**
+ * One row in the failure list. A failure can exist before its
+ * classification arrives (`FailureClassified` is emitted from a
+ * separate pipeline), so `classification` is nullable.
+ * @public
+ */
+declare const FailureRecord: Schema.Struct<{
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  timedOut: Schema.optional<typeof Schema.Boolean>;
+  classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+}>;
+/** @public */
+type FailureRecord = typeof FailureRecord.Type;
+/**
+ * Coverage block, populated only after `CoverageReady`. Threshold
+ * violations are accumulated separately as they arrive.
+ * @public
+ */
+declare const CoverageRenderState: Schema.Struct<{
+  metrics: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  gaps: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    missing: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: Schema.optional<typeof Schema.String>;
+  }>>;
+  violations: Schema.Array$<Schema.Struct<{
+    metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+    expected: typeof Schema.Number;
+    actual: typeof Schema.Number;
+  }>>;
+}>;
+/** @public */
+type CoverageRenderState = typeof CoverageRenderState.Type;
+/**
+ * A `SuggestedAction` event, denormalized into the queue the renderer reads.
+ * @public
+ */
+declare const SuggestedActionRecord: Schema.Struct<{
+  severity: Schema.Literal<["info", "warn", "blocker"]>;
+  title: typeof Schema.String;
+  detail: typeof Schema.String;
+  targetTool: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type SuggestedActionRecord = typeof SuggestedActionRecord.Type;
+/**
+ * Per-run totals, recomputed on every `ModuleFinished` and reconciled
+ * against `RunFinished` (which carries the runner's own count).
+ * @public
+ */
+declare const RenderTotals: Schema.Struct<{
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  timeoutCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+}>;
+/** @public */
+type RenderTotals = typeof RenderTotals.Type;
+/**
+ * The renderer state. Both the human (Ink) and agent (string)
+ * renderers read this shape; the reducer is the only producer.
+ *
+ * `phase` is the layout discriminator — agent mode emits one final
+ * frame when `phase === "finished"`; human mode redraws at every
+ * state change. `"timed-out"` is a terminal phase like `"finished"`
+ * — the run is over, but it ended because `onProcessTimeout` fired
+ * rather than the suite completing.
+ * @public
+ */
+declare const RenderState: Schema.Struct<{
+  phase: Schema.Literal<["idle", "running", "finished", "timed-out"]>;
+  runId: Schema.NullOr<typeof Schema.String>;
+  configHash: Schema.NullOr<typeof Schema.String>;
+  startedAt: Schema.NullOr<typeof Schema.String>;
+  finishedAt: Schema.NullOr<typeof Schema.String>;
+  modules: Schema.Record$<typeof Schema.String, Schema.Struct<{
+    modulePath: typeof Schema.String;
+    status: Schema.Literal<["queued", "running", "finished"]>;
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+    tests: Schema.Array$<Schema.Struct<{
+      testName: typeof Schema.String;
+      suitePath: Schema.Array$<typeof Schema.String>;
+      status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+      durationMs: Schema.NullOr<typeof Schema.Number>;
+      error: Schema.optional<Schema.Struct<{
+        message: typeof Schema.String;
+        stack: Schema.optional<typeof Schema.String>;
+        diff: Schema.optional<typeof Schema.String>;
+        expected: Schema.optional<typeof Schema.String>;
+        received: Schema.optional<typeof Schema.String>;
+      }>>;
+    }>>;
+    /**
+     * Owning Vitest project name. Optional — events from project-less
+     * configs or older replays leave it `undefined`, which the renderer
+     * treats as a single anonymous project.
+     */
+    projectName: Schema.optional<typeof Schema.String>;
+    /**
+     * ISO wall-clock stamp captured at `onTestModuleStart`. The live
+     * renderer derives a ticking elapsed column from it while the module
+     * runs; once finished it shows `durationMs` instead. Optional — a
+     * module seeded by `ModuleQueued` (or replayed) has no start stamp.
+     */
+    startedAt: Schema.optional<typeof Schema.String>;
+    tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+  }>>;
+  moduleOrder: Schema.Array$<typeof Schema.String>;
+  totals: Schema.Struct<{
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+  }>;
+  coverage: Schema.NullOr<Schema.Struct<{
+    metrics: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: Schema.Struct<{
+      lines: Schema.optional<typeof Schema.Number>;
+      functions: Schema.optional<typeof Schema.Number>;
+      branches: Schema.optional<typeof Schema.Number>;
+      statements: Schema.optional<typeof Schema.Number>;
+    }>;
+    gaps: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      missing: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: Schema.optional<typeof Schema.String>;
+    }>>;
+    violations: Schema.Array$<Schema.Struct<{
+      metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+      expected: typeof Schema.Number;
+      actual: typeof Schema.Number;
+    }>>;
+  }>>;
+  trend: Schema.NullOr<Schema.Struct<{
+    direction: Schema.Literal<["improving", "regressing", "stable"]>;
+    runCount: typeof Schema.Number;
+  }>>;
+  failures: Schema.Array$<Schema.Struct<{
+    modulePath: typeof Schema.String;
+    testName: typeof Schema.String;
+    suitePath: Schema.Array$<typeof Schema.String>;
+    error: Schema.optional<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>;
+    timedOut: Schema.optional<typeof Schema.Boolean>;
+    classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+  }>>;
+  suggestedActions: Schema.Array$<Schema.Struct<{
+    severity: Schema.Literal<["info", "warn", "blocker"]>;
+    title: typeof Schema.String;
+    detail: typeof Schema.String;
+    targetTool: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type RenderState = typeof RenderState.Type;
+/**
+ * Initial state — what the reducer returns when no events have been
+ * applied yet. Exported so tests and the renderers' bootstrapping
+ * code share one definition.
+ * @public
+ */
+declare const initialRenderState: RenderState;
+//#endregion
+//#region src/contracts/dispatcher.d.ts
+/**
+ * The four run shapes the dispatcher distinguishes.
+ *
+ * Computed once per run from the reduced state's module count, the
+ * distinct-project count (carried via {@link DispatchInputs.projects}),
+ * and the test count inside each module.
+ *
+ * - `single-test`    — exactly one test by name across the run.
+ * - `single-file`    — exactly one module, more than one test.
+ * - `single-project` — one project, more than one module.
+ * - `workspace`      — more than one project.
+ * @public
+ */
+type RunShape = "single-test" | "single-file" | "single-project" | "workspace";
+/**
+ * The three outcome classes the dispatcher distinguishes.
+ *
+ * - `all-pass`             — `totals.failed === 0` and no coverage threshold violations.
+ * - `some-fail`            — `totals.failed > 0`.
+ * - `threshold-violation`  — `totals.failed === 0` and at least one coverage violation.
+ * @public
+ */
+type RunOutcome = "all-pass" | "some-fail" | "threshold-violation";
+/**
+ * Compact per-project aggregate carried into workspace cells.
+ *
+ * Populated by the plugin from `ReporterRenderInput.reports`. Empty for
+ * non-workspace shapes. `tagCounts`, `belowTarget`, and `violations` are
+ * optional — workspace cells render the columns only when present.
+ * @public
+ */
+interface ProjectSummary {
+  readonly name: string;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly durationMs: number;
+  readonly tagCounts?: Record<string, number>;
+  readonly belowTarget?: number;
+  readonly violations?: number;
+}
+/**
+ * Per-run trend direction handed to cells that surface a `Trend: …` line.
+ *
+ * Mirrors the inline `ReporterRenderInput.trendSummary` shape — promoted
+ * to a named type here so the dispatcher and its cells can pass it around
+ * without re-declaring it. The plugin populates this from
+ * `ReporterRenderInput.trendSummary` before invoking `dispatch`.
+ * @public
+ */
+interface TrendSummary {
+  readonly direction: "improving" | "regressing" | "stable";
+  readonly runCount: number;
+  readonly firstMetric?: {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    readonly target?: number;
+  };
+}
+/**
+ * Inputs each cell renderer reads to produce its output.
+ *
+ * `state` carries the post-reduce projection of the `RunEvent`
+ * stream. `shape` and `outcome` are the classified axes the dispatcher
+ * keyed on to reach this cell. The remaining fields are non-state
+ * helpers the plugin computes once before dispatch so cells stay pure.
+ * @public
+ */
+interface DispatchInputs {
+  readonly state: RenderState;
+  readonly shape: RunShape;
+  readonly outcome: RunOutcome;
+  /**
+   * Per-project aggregates carried into workspace cells. Populated by
+   * the plugin from `ReporterRenderInput.reports`; empty for non-workspace
+   * shapes.
+   */
+  readonly projects: ReadonlyArray<ProjectSummary>;
+  /**
+   * Trend direction for cells that surface a `Trend: …` line. `null`
+   * for scoped runs and any run where trend history is unavailable.
+   */
+  readonly trend: TrendSummary | null;
+  /**
+   * Files below the aspirational `coverageTargets` tier. Workspace and
+   * project cells surface a truncated listing of these; single-file and
+   * single-test cells ignore them.
+   */
+  readonly belowTarget: ReadonlyArray<FileCoverageReport>;
+  /**
+   * Configured run command (e.g. `pnpm test`). Cell footers reference
+   * this so copy-pasted commands stay accurate. `null` when no command
+   * was configured.
+   */
+  readonly runCommand: string | null;
+}
+/**
+ * Render-time options threaded into each cell from the resolved
+ * `ReporterKit`. These are concerns the cell needs to format its
+ * output but that do not belong on the state-derived
+ * {@link DispatchInputs} struct.
+ *
+ * The plugin builds this once per run from the kit and passes it into
+ * `dispatch(inputs, opts)`. Cells destructure only what they consume.
+ * @public
+ */
+interface CellOptions {
+  /**
+   * Resolved value of the `NO_COLOR` env var. Cells gate ANSI escape
+   * sequences and OSC-8 hyperlinks on this.
+   */
+  readonly noColor: boolean;
+  /**
+   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
+   * whether OSC-8 should be enabled (`target=stdout`, `!noColor`) so
+   * cells can call this directly without re-consulting the environment.
+   */
+  readonly osc8: (url: string, label: string) => string;
+}
+//#endregion
+//#region src/schemas/Common.d.ts
+/**
+ * Possible states for an individual test case.
+ * @public
+ */
+declare const TestState: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+/** @public */
+type TestState = typeof TestState.Type;
+/**
+ * Overall outcome of a test run.
+ * @public
+ */
+declare const TestRunReason: Schema.Literal<["passed", "failed", "interrupted"]>;
+/** @public */
+type TestRunReason = typeof TestRunReason.Type;
+/**
+ * Classification of a test's failure history across runs.
+ * @public
+ */
+declare const TestClassification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+/** @public */
+type TestClassification = typeof TestClassification.Type;
+/**
+ * Console output verbosity mode for AgentReporter.
+ * @public
+ */
+declare const ConsoleOutputMode: Schema.Literal<["failures", "full", "silent"]>;
+/** @public */
+type ConsoleOutputMode = typeof ConsoleOutputMode.Type;
+/**
+ * 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
+ */
+declare const HumanConsoleMode: Schema.Literal<["passthrough", "silent", "stream", "agent"]>;
+/** @public */
+type HumanConsoleMode = typeof HumanConsoleMode.Type;
+/** @public */
+declare const AgentConsoleMode: Schema.Literal<["passthrough", "silent", "agent"]>;
+/** @public */
+type AgentConsoleMode = typeof AgentConsoleMode.Type;
+/** @public */
+declare const CiConsoleMode: Schema.Literal<["passthrough", "silent", "ci-annotations"]>;
+/** @public */
+type CiConsoleMode = typeof CiConsoleMode.Type;
+/**
+ * Union of every legal console-output value across the three executor slots.
+ * Useful for type-narrowing in renderers that take the resolved value.
+ * @public
+ */
+declare const ConsoleMode: Schema.Union<[Schema.Literal<["passthrough", "silent", "stream", "agent"]>, Schema.Literal<["passthrough", "silent", "agent"]>, Schema.Literal<["passthrough", "silent", "ci-annotations"]>]>;
+/** @public */
+type ConsoleMode = typeof ConsoleMode.Type;
+/**
+ * Supported package managers for run command generation.
+ * @public
+ */
+declare const PackageManager: Schema.Literal<["pnpm", "npm", "yarn", "bun"]>;
+/** @public */
+type PackageManager = typeof PackageManager.Type;
+/**
+ * Runtime environment where tests are being executed.
+ * @public
+ */
+declare const Environment: Schema.Literal<["agent-shell", "terminal", "ci-github", "ci-generic"]>;
+/** @public */
+type Environment = typeof Environment.Type;
+/**
+ * Who or what is executing the test run.
+ * @public
+ */
+declare const Executor: Schema.Literal<["human", "agent", "ci"]>;
+/** @public */
+type Executor = typeof Executor.Type;
+/**
+ * Output format for the reporter pipeline.
+ * @public
+ */
+declare const OutputFormat: Schema.Literal<["terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations"]>;
+/** @public */
+type OutputFormat = typeof OutputFormat.Type;
+/**
+ * Level of detail in reporter output.
+ * @public
+ */
+declare const DetailLevel: Schema.Literal<["minimal", "neutral", "standard", "verbose"]>;
+/** @public */
+type DetailLevel = typeof DetailLevel.Type;
+/**
+ * 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
+ */
+declare const ReportError: Schema.Struct<{
+  message: typeof Schema.String;
+  stack: Schema.optional<typeof Schema.String>;
+  diff: Schema.optional<typeof Schema.String>;
+  expected: Schema.optional<typeof Schema.String>;
+  received: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type ReportError = typeof ReportError.Type;
+//#endregion
+//#region src/formatters/types.d.ts
+/** @public */
+interface RenderedOutput {
+  readonly target: "stdout" | "file" | "github-summary";
+  readonly content: string;
+  readonly contentType: string;
+}
+/** @public */
+interface FormatterContext {
+  readonly detail: DetailLevel;
+  readonly noColor: boolean;
+  readonly coverageConsoleLimit: number;
+  readonly trendSummary?: {
+    direction: "improving" | "regressing" | "stable";
+    runCount: number;
+    firstMetric?: {
+      name: string;
+      from: number;
+      to: number;
+      target?: number;
+    };
+  };
+  readonly runCommand?: string;
+  readonly githubSummaryFile?: string;
+  readonly mcp?: boolean;
+}
+/** @public */
+interface Formatter {
+  readonly format: string;
+  readonly render: (reports: ReadonlyArray<AgentReport>, context: FormatterContext) => ReadonlyArray<RenderedOutput>;
+}
+//#endregion
+//#region src/schemas/RunEvent.d.ts
+/**
+ * Coverage metric whose threshold can be violated independently.
+ * @public
+ */
+declare const CoverageMetric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+/** @public */
+type CoverageMetric = typeof CoverageMetric.Type;
+/**
+ * Severity tier for a suggested action emitted during a run.
+ * @public
+ */
+declare const ActionSeverity: Schema.Literal<["info", "warn", "blocker"]>;
+/** @public */
+type ActionSeverity = typeof ActionSeverity.Type;
+/**
+ * Lifecycle scope of a Vitest setup/teardown hook.
+ * @public
+ */
+declare const HookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+/** @public */
+type HookType = typeof HookType.Type;
+/**
+ * Terminal status of a Vitest hook run.
+ * @public
+ */
+declare const HookStatus: Schema.Literal<["passed", "failed"]>;
+/** @public */
+type HookStatus = typeof HookStatus.Type;
+/**
+ * Output stream a captured user `console.log` was written to.
+ * @public
+ */
+declare const ConsoleLogLevel: Schema.Literal<["stdout", "stderr"]>;
+/** @public */
+type ConsoleLogLevel = typeof ConsoleLogLevel.Type;
+/**
+ * A coverage gap surfaced to the renderer — a per-file shortfall that
+ * a renderer may want to call out individually.
+ * @public
+ */
+declare const CoverageGap: Schema.Struct<{
+  file: typeof Schema.String;
+  missing: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  uncoveredLines: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type CoverageGap = typeof CoverageGap.Type;
+/**
+ * The reducer projects this union into `RenderState`. Renderers
+ * never read the raw event stream — they read the projected state.
+ *
+ * @remarks
+ * Adding a variant here is one change in one place; the reducer's
+ * exhaustive `Match.exhaustive` will surface any renderer that hasn't
+ * been updated to consume the new state shape.
+ * @public
+ */
+declare const RunEvent: Schema.Union<[Schema.TaggedStruct<"RunStarted", {
+  runId: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  configHash: typeof Schema.String;
+}>, Schema.TaggedStruct<"ModuleQueued", {
+  modulePath: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"ModuleStarted", {
+  modulePath: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestStarted", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestFinished", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  status: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+  durationMs: typeof Schema.Number;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  timedOut: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.TaggedStruct<"ModuleFinished", {
+  modulePath: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  projectName: Schema.optional<typeof Schema.String>;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>, Schema.TaggedStruct<"ModuleCollected", {
+  modulePath: typeof Schema.String;
+  testCount: typeof Schema.Number;
+  suiteCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"SuiteStarted", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+}>, Schema.TaggedStruct<"SuiteFinished", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"HookStarted", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+}>, Schema.TaggedStruct<"HookFinished", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+  durationMs: typeof Schema.Number;
+  status: Schema.Literal<["passed", "failed"]>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ConsoleLog", {
+  modulePath: Schema.optional<typeof Schema.String>;
+  testName: Schema.optional<typeof Schema.String>;
+  level: Schema.Literal<["stdout", "stderr"]>;
+  content: typeof Schema.String;
+  time: typeof Schema.Number;
+}>, Schema.TaggedStruct<"RunTimedOut", {
+  message: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestAnnotated", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  annotation: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestArtifactRecorded", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  artifact: typeof Schema.String;
+}>, Schema.TaggedStruct<"WatcherReady", {}>, Schema.TaggedStruct<"WatcherRerun", {
+  triggerFiles: Schema.Array$<typeof Schema.String>;
+  reason: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TrendComputed", {
+  direction: Schema.Literal<["improving", "regressing", "stable"]>;
+  runCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"CoverageReady", {
+  metrics: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  gaps: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    missing: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ThresholdViolation", {
+  metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+  expected: typeof Schema.Number;
+  actual: typeof Schema.Number;
+}>, Schema.TaggedStruct<"FailureClassified", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  classification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+}>, Schema.TaggedStruct<"SuggestedAction", {
+  severity: Schema.Literal<["info", "warn", "blocker"]>;
+  title: typeof Schema.String;
+  detail: typeof Schema.String;
+  targetTool: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"RunFinished", {
+  runId: typeof Schema.String;
+  finishedAt: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+}>]>;
+/** @public */
+type RunEvent = typeof RunEvent.Type;
+/**
+ * Convenience: discriminator-keyed map of the individual variants.
+ *
+ * Useful for callers that want to construct an event by tag without
+ * pulling the whole union shape into scope.
+ * @public
+ */
+type RunEventByTag = { [E in RunEvent as E["_tag"]]: E };
+//#endregion
+//#region src/schemas/Thresholds.d.ts
+/**
+ * Per-metric threshold values. All optional -- only set metrics are enforced.
+ * @public
+ */
+declare const MetricThresholds: Schema.Struct<{
+  lines: Schema.optional<typeof Schema.Number>;
+  functions: Schema.optional<typeof Schema.Number>;
+  branches: Schema.optional<typeof Schema.Number>;
+  statements: Schema.optional<typeof Schema.Number>;
+}>;
+/** @public */
+type MetricThresholds = typeof MetricThresholds.Type;
+/**
+ * A glob pattern paired with its metric thresholds.
+ * @public
+ */
+declare const PatternThresholds: Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+  lines: Schema.optional<typeof Schema.Number>;
+  functions: Schema.optional<typeof Schema.Number>;
+  branches: Schema.optional<typeof Schema.Number>;
+  statements: Schema.optional<typeof Schema.Number>;
+}>>;
+/** @public */
+type PatternThresholds = typeof PatternThresholds.Type;
+/**
+ * Fully resolved thresholds ready for evaluation.
+ * @public
+ */
+declare const ResolvedThresholds: Schema.Struct<{
+  global: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  perFile: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+  }>;
+  patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>>>, {
+    default: () => never[];
+  }>;
+}>;
+/** @public */
+type ResolvedThresholds = typeof ResolvedThresholds.Type;
+//#endregion
+//#region src/schemas/Transport.d.ts
+/**
+ * Transport binding for the persistence layer.
+ *
+ * 2.x ships only `{ kind: "local" }`. Modeled as a single-member
+ * discriminated union so the 3.0 cloud-backend swap (D1, Turso, etc.)
+ * lands as a pure addition of new union members — no schema-shape
+ * diff and no breaking API change at the call site.
+ * @public
+ */
+declare const Transport: Schema.Struct<{
+  kind: Schema.Literal<["local"]>;
+}>;
+/** @public */
+type Transport = typeof Transport.Type;
+//#endregion
+//#region src/contracts/reporter.d.ts
+/**
+ * Config the plugin computes from its own options + Vitest's resolved config,
+ * then hands to the reporter factory inside {@link ReporterKit}.
+ *
+ * `dbPath` is optional at the type level so renderers that don't care about
+ * the persistence layer (e.g. a stdout-only renderer) can ignore it. The
+ * plugin always populates it in practice — the option exists for clarity
+ * and to leave room for future "no-persistence" experiments.
+ *
+ * `format` and `detail` are pre-resolved by the plugin (via
+ * `FormatSelector` / `DetailResolver`) but reporters that want to override
+ * can ignore them. `noColor` is the resolved value of the `NO_COLOR` env
+ * var; reporters use it to gate ANSI escapes and OSC-8 hyperlinks.
+ * @public
+ */
+interface ResolvedReporterConfig {
+  readonly dbPath?: string;
+  readonly projectFilter?: string;
+  /**
+   * The executor the plugin detected at run time (`human`, `agent`, `ci`).
+   * Renderers branch on this when their per-mode behavior depends on the
+   * observer (e.g. honoring `NO_COLOR` only when a human is watching).
+   */
+  readonly executor: Executor;
+  /**
+   * The `ConsoleMode` value the plugin selected for the active
+   * executor — the result of looking up `console.{executor}` and falling
+   * back to the per-slot default. Renderers that need to know "what am I
+   * supposed to produce right now?" read this single field.
+   */
+  readonly consoleMode: ConsoleMode;
+  readonly mcp: boolean;
+  readonly consoleOutput: "failures" | "full" | "silent";
+  readonly omitPassingTests: boolean;
+  readonly coverageConsoleLimit: number;
+  readonly includeBareZero: boolean;
+  readonly githubActions: boolean;
+  readonly githubSummary: boolean;
+  readonly githubSummaryFile?: string;
+  readonly coverageThresholds?: ResolvedThresholds;
+  readonly coverageTargets?: ResolvedThresholds;
+  /**
+   * Operating mode resolved from Vitest's native `coverage.enabled` config.
+   * - `"full"` — coverage is enabled; all analytics and persistence run.
+   * - `"ui-only"` — coverage is disabled (`coverage.enabled: false`); reporter
+   *   renders output but the persistence pipeline is skipped (Phase 5).
+   *
+   * The plugin always resolves this field in `configureVitest`.
+   * @internal
+   */
+  readonly coverageMode: "full" | "ui-only";
+  readonly format: OutputFormat;
+  readonly detail: DetailLevel;
+  readonly noColor: boolean;
+  readonly runCommand?: string;
+  /**
+   * Transport binding for the persistence layer. Custom reporters
+   * read this when they want to branch on backend kind (e.g. behave
+   * differently against a cloud DB). 2.x ships only `{ kind: "local" }`.
+   */
+  readonly transport?: Transport;
+  /**
+   * Snapshot of Vitest's `test.passWithNoTests` policy captured from
+   * the resolved config at `configureVitest` time.
+   *
+   * Informational for consumer reporters that want to render the
+   * resolved policy alongside other run context. The MCP `run_tests`
+   * tool does not read this field — when its per-call
+   * `passWithNoTests` override is unset the tool forwards nothing to
+   * `createVitest`, and Vitest re-resolves from the project config on
+   * disk. The `no-match` discriminator is filter-driven and is not
+   * affected by this policy.
+   *
+   * Optional because the field is only present when populated by the
+   * plugin; consumers constructing `ResolvedReporterConfig` directly
+   * may omit it.
+   */
+  readonly passWithNoTests?: boolean;
+}
+/**
+ * Plugin-provided primitives passed to the reporter factory at construction
+ * time. The `std*` prefix marks these as "the plugin gives you these — do
+ * not import equivalents yourself"; they are pre-resolved with full context
+ * (environment, executor, NO_COLOR, target=stdout) so the reporter doesn't
+ * have to re-derive that state.
+ *
+ * The shape is open to additions: future fields (e.g. `stdLogger`,
+ * `stdRuntime`) won't break existing reporters because the parameter is a
+ * named-field object. Reporters destructure only what they consume.
+ * @public
+ */
+interface ReporterKit {
+  readonly config: ResolvedReporterConfig;
+  readonly stdEnv: Environment;
+  /**
+   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
+   * whether OSC-8 should be enabled (target=stdout, !noColor) so the
+   * reporter can call this directly without consulting environment.
+   */
+  readonly stdOsc8: (url: string, label: string) => string;
+  /**
+   * Live run-event channel. The plugin publishes one `RunEvent`
+   * per Vitest streaming callback (`onTestRunStart`, `onTestModuleStart`,
+   * `onTestCaseResult`, `onTestRunEnd`, …) onto this `PubSub` as the run
+   * progresses. A reporter that paints live — the default reporter's Ink
+   * mount in `consoleMode: "stream"` — subscribes here at construction time
+   * (the factory is invoked at run start, before the first event) and
+   * drives its renderer off the stream.
+   *
+   * Optional at the type level so a reporter constructed directly
+   * without the plugin (tests, one-shot replay) can omit it; a reporter
+   * that wants live events must guard for `undefined`. The plugin always
+   * populates it.
+   */
+  readonly runEvents?: PubSub.PubSub<RunEvent>;
+}
+/**
+ * Per-run data handed to {@link VitestAgentReporter.render} after the plugin
+ * has finished persisting and classifying the run.
+ *
+ * `reports` is one entry per project (multi-project Vitest configs produce
+ * multiple). `classifications` is keyed by `TestReport.fullName` and is the
+ * stable / new-failure / persistent / flaky / recovered label assigned by
+ * `HistoryTracker`. `trendSummary` is present only on full (non-scoped) runs
+ * where coverage trends were computed.
+ * @public
+ */
+interface ReporterRenderInput {
+  readonly reports: ReadonlyArray<AgentReport>;
+  readonly classifications: ReadonlyMap<string, TestClassification>;
+  readonly trendSummary?: {
+    readonly direction: "improving" | "regressing" | "stable";
+    readonly runCount: number;
+    readonly firstMetric?: {
+      readonly name: string;
+      readonly from: number;
+      readonly to: number;
+      readonly target?: number;
+    };
+  };
+}
+/**
+ * The reporter contract. Implement this to plug a custom output strategy
+ * into `vitest-agent`.
+ *
+ * `render` is called once per test run after the plugin has persisted all
+ * data. It receives the assembled run plus a second, health-aware
+ * {@link ReporterKit}: the kit handed to the factory is resolved at run
+ * start (before failures are known), while the kit handed to `render` is
+ * resolved at run end and reflects post-run `detail`. A reporter that does
+ * construction-time work reads the factory kit; a reporter that renders
+ * reads the `render` kit. The reporter returns `RenderedOutput[]` — the
+ * plugin routes each entry to its declared `target` (`stdout`, `file`,
+ * `github-summary`), so the reporter does not need to know about file
+ * paths or write streams.
+ *
+ * A "no-op" reporter is one line: `() => ({ render: () => [] })`. Useful
+ * for users who only want persistence (the MCP/CLI tools see the data) and
+ * no console output at all.
+ * @public
+ */
+interface VitestAgentReporter {
+  readonly render: (input: ReporterRenderInput, kit: ReporterKit) => ReadonlyArray<RenderedOutput>;
+}
+/**
+ * Factory that the plugin's `reporter` option accepts. The plugin calls
+ * this once with the resolved kit; the factory returns either a single
+ * reporter or an array of reporters bound to that kit.
+ *
+ * Returning an array models Vitest's own multi-reporter pattern
+ * (`reporters: ['default', 'github-actions']`): each reporter handles
+ * its own concern (e.g. one for stdout markdown, one for SARIF, one
+ * for the GitHub Actions step summary) and the plugin concatenates
+ * their `RenderedOutput[]` before routing. Persistence still runs
+ * exactly once — the plugin owns the Vitest lifecycle and the
+ * reporters never see Vitest events directly.
+ *
+ * Defaulting to a factory (rather than passing a class or pre-made
+ * instance) gives implementations a place to do construction-time work
+ * (e.g. opening a file handle, capturing config) while still letting
+ * the plugin own the kit assembly.
+ * @public
+ */
+type VitestAgentReporterFactory = (kit: ReporterKit) => VitestAgentReporter | ReadonlyArray<VitestAgentReporter>;
+//#endregion
+//#region src/errors/DiscoveryError.d.ts
+declare const DiscoveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DiscoveryError";
+} & Readonly<A>;
+/**
+ * Error raised when project discovery (glob, file read, or stat) fails.
+ * @public
+ */
+declare class DiscoveryError extends DiscoveryError_base<{
+  readonly operation: "glob" | "read" | "stat";
+  readonly path: string;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly operation: "glob" | "read" | "stat";
+    readonly path: string;
+    readonly reason: string;
+  });
+}
+//#endregion
+//#region src/errors/PathResolutionError.d.ts
+declare const PathResolutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PathResolutionError";
+} & Readonly<A>;
+/**
+ * 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
+ */
+declare class PathResolutionError extends PathResolutionError_base<{
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly reason: string;
+  });
+}
+//#endregion
+//#region src/errors/ProjectIdentityError.d.ts
+/**
+ * One source the resolver tried while looking for project identity.
+ *
+ * `source` is a stable label (`"explicit"`, `"toml"`, `"git-remote"`,
+ * `"package-repository"`, `"package-name"`) the error message and
+ * downstream tooling can switch on. `reason` explains why the source
+ * didn't produce a value (e.g., "not configured", "git command failed",
+ * "URL canonicalization rejected the value").
+ * @public
+ */
+interface ProjectIdentityCandidate {
+  readonly source: string;
+  readonly reason: string;
+}
+declare const ProjectIdentityNotResolvableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ProjectIdentityNotResolvableError";
+} & Readonly<A>;
+/**
+ * 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
+ */
+declare class ProjectIdentityNotResolvableError extends ProjectIdentityNotResolvableError_base<{
+  readonly tried: ReadonlyArray<ProjectIdentityCandidate>;
+}> {
+  constructor(args: {
+    readonly tried: ReadonlyArray<ProjectIdentityCandidate>;
+  });
+}
+//#endregion
+//#region src/errors/RunContextError.d.ts
+declare const GitCommandError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "GitCommandError";
+} & Readonly<A>;
+/**
+ * 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
+ */
+declare class GitCommandError extends GitCommandError_base<{
+  readonly command: string;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly command: string;
+    readonly reason: string;
+  });
+}
+declare const ProbeMissError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ProbeMissError";
+} & Readonly<A>;
+/**
+ * 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
+ */
+declare class ProbeMissError extends ProbeMissError_base<{
+  readonly probe: string;
+}> {}
+//#endregion
+//#region src/formatters/ci-annotations.d.ts
+/** @public */
+declare const ciAnnotationsFormatter: Formatter;
+//#endregion
+//#region src/formatters/gfm.d.ts
+/** @public */
+declare const GfmFormatter: Formatter;
+//#endregion
+//#region src/formatters/json.d.ts
+/** @public */
+declare const JsonFormatter: Formatter;
+//#endregion
+//#region src/formatters/markdown.d.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
+ */
+declare const MarkdownFormatter: Formatter;
+//#endregion
+//#region src/formatters/silent.d.ts
+/** @public */
+declare const SilentFormatter: Formatter;
+//#endregion
+//#region src/formatters/terminal.d.ts
+/** @public */
+declare const TerminalFormatter: Formatter;
+//#endregion
+//#region src/schemas/Config.d.ts
+declare const VitestAgentConfig_base: Schema.Class<VitestAgentConfig, {
+  cacheDir: Schema.optional<typeof Schema.String>;
+  projectKey: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+  cacheDir: Schema.optional<typeof Schema.String>;
+  projectKey: Schema.optional<typeof Schema.String>;
+}>, never, {
+  readonly cacheDir?: string | undefined;
+} & {
+  readonly projectKey?: string | undefined;
+}, {}, {}>;
+/**
+ * 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
+ */
+declare class VitestAgentConfig extends VitestAgentConfig_base {}
+//#endregion
+//#region src/services/Config.d.ts
+/**
+ * Service shape that `ConfigLive(projectDir)` provides to downstream
+ * consumers. Re-exported so callers can spell out the concrete service
+ * type without referencing the `ConfigFileService<A>` generic directly.
+ * @public
+ */
+type VitestAgentConfigFileService = ConfigFileService<VitestAgentConfig>;
+/**
+ * Typed `Context.Tag` for the vitest-agent config file service.
+ *
+ * Both runtime packages (reporter, MCP) yield this tag to access the loaded
+ * `VitestAgentConfig`. The live layer is built per `projectDir` via
+ * `ConfigLive(projectDir)`.
+ * @public
+ */
+declare const VitestAgentConfigFile: import("effect/Context").Tag<ConfigFileService<VitestAgentConfig>, ConfigFileService<VitestAgentConfig>>;
+//#endregion
+//#region src/layers/ConfigLive.d.ts
+/**
+ * Build the live `ConfigFile` layer for a given project directory.
+ *
+ * Resolves the optional `vitest-agent.config.toml` from (in order):
+ *
+ * 1. The workspace root (when `projectDir` is inside a pnpm/npm/yarn workspace).
+ * 2. The git repository root (when `projectDir` is inside a git repo).
+ * 3. Walking upward from `projectDir`.
+ *
+ * The first found file wins (`FirstMatch` strategy). If no file is present,
+ * downstream callers use `loadOrDefault(new VitestAgentConfig({}))`
+ * to get an empty config.
+ *
+ * @param projectDir - Absolute path inside the user's workspace. Resolvers
+ *   anchor here rather than `process.cwd()` so the plugin-spawned MCP server
+ *   sees the right config even when invoked from elsewhere.
+ * @public
+ */
+declare const ConfigLive: (projectDir: string) => Layer.Layer<VitestAgentConfigFileService, never, FileSystem.FileSystem>;
+//#endregion
+//#region src/layers/DataReaderLive.d.ts
+/** @public */
+declare const DataReaderLive: Layer.Layer<DataReader, never, SqlClient>;
+//#endregion
+//#region src/layers/DataStoreLive.d.ts
+/** @public */
+declare const DataStoreLive: Layer.Layer<DataStore, never, SqlClient>;
+//#endregion
+//#region src/services/DetailResolver.d.ts
+/** @public */
+interface RunHealth {
+  readonly hasFailures: boolean;
+  readonly belowTargets: boolean;
+  readonly hasTargets?: boolean;
+}
+declare const DetailResolver_base: Context.TagClass<DetailResolver, "vitest-agent/DetailResolver", {
+  readonly resolve: (executor: Executor, health: RunHealth, explicit?: DetailLevel) => Effect.Effect<DetailLevel>;
+}>;
+/** @public */
+declare class DetailResolver extends DetailResolver_base {}
+//#endregion
+//#region src/layers/DetailResolverLive.d.ts
+/** @public */
+declare const DetailResolverLive: Layer.Layer<DetailResolver, never, never>;
+//#endregion
+//#region src/services/DiscoveryRegistry.d.ts
+/**
+ * Input for upserting a known project into the global discovery registry.
+ *
+ * @public
+ */
+interface KnownProjectInput {
+  readonly projectKey: string;
+  readonly canonicalForm: string;
+  readonly dataDbPath: string;
+  readonly gitRemoteOrigin: string | null;
+  readonly workspaceRoot: string;
+}
+/**
+ * A project record as stored in the global discovery registry.
+ *
+ * @public
+ */
+interface KnownProject {
+  readonly projectKey: string;
+  readonly canonicalForm: string;
+  readonly dataDbPath: string;
+  readonly gitRemoteOrigin: string | null;
+  readonly workspaceRoot: string;
+  readonly firstSeenAt: number;
+  readonly lastSeenAt: number;
+}
+declare const DiscoveryRegistry_base: Context.TagClass<DiscoveryRegistry, "vitest-agent/DiscoveryRegistry", {
+  /**
+   * Upsert this project into the registry. Sets `first_seen_at` on
+   * insert; updates `last_seen_at` plus all mutable fields on
+   * conflict. Returns nothing — the call is fire-and-observe.
+   */
+  readonly recordProject: (input: KnownProjectInput) => Effect.Effect<void, DataStoreError>;
+  /**
+   * List all projects ordered by most recent activity first. Used by
+   * cross-project discovery tooling.
+   */
+  readonly listProjects: () => Effect.Effect<ReadonlyArray<KnownProject>, DataStoreError>;
+  /**
+   * Drop registry rows whose `last_seen_at` is older than `maxAgeDays`
+   * days ago. The corresponding `data.db` files are NOT deleted; only
+   * the index entry is pruned. Returns the count of removed rows.
+   */
+  readonly prune: (maxAgeDays: number) => Effect.Effect<number, DataStoreError>;
+}>;
+/** @public */
+declare class DiscoveryRegistry extends DiscoveryRegistry_base {}
+//#endregion
+//#region src/layers/DiscoveryRegistryLive.d.ts
+/** @public */
+declare const DiscoveryRegistryLive: Layer.Layer<DiscoveryRegistry, never, SqlClient>;
+//#endregion
+//#region src/services/EnvironmentDetector.d.ts
+declare const EnvironmentDetector_base: Context.TagClass<EnvironmentDetector, "vitest-agent/EnvironmentDetector", {
+  readonly detect: () => Effect.Effect<Environment>;
+  readonly isAgent: Effect.Effect<boolean>;
+  readonly agentName: Effect.Effect<string | undefined>;
+}>;
+/** @public */
+declare class EnvironmentDetector extends EnvironmentDetector_base {}
+//#endregion
+//#region src/layers/EnvironmentDetectorLive.d.ts
+/** @public */
+declare const EnvironmentDetectorLive: Layer.Layer<EnvironmentDetector>;
+//#endregion
+//#region src/layers/EnvironmentDetectorTest.d.ts
+/** @public */
+declare const EnvironmentDetectorTest: {
+  layer: (env?: Environment) => Layer.Layer<EnvironmentDetector, never, never>;
+};
+//#endregion
+//#region src/services/ExecutorResolver.d.ts
+declare const ExecutorResolver_base: Context.TagClass<ExecutorResolver, "vitest-agent/ExecutorResolver", {
+  readonly resolve: (env: Environment) => Effect.Effect<Executor>;
+}>;
+/** @public */
+declare class ExecutorResolver extends ExecutorResolver_base {}
+//#endregion
+//#region src/layers/ExecutorResolverLive.d.ts
+/** @public */
+declare const ExecutorResolverLive: Layer.Layer<ExecutorResolver, never, never>;
+//#endregion
+//#region src/services/FormatSelector.d.ts
+declare const FormatSelector_base: Context.TagClass<FormatSelector, "vitest-agent/FormatSelector", {
+  readonly select: (executor: Executor, explicitFormat?: OutputFormat, environment?: Environment) => Effect.Effect<OutputFormat>;
+}>;
+/** @public */
+declare class FormatSelector extends FormatSelector_base {}
+//#endregion
+//#region src/layers/FormatSelectorLive.d.ts
+/**
+ * Default format dispatch:
+ *
+ * - GitHub Actions CI executor: `ci-annotations` (renders as `::error::`).
+ * - Human executor: `silent` (Vitest's own reporters handle the user
+ *   experience; we just write to the database).
+ * - Anyone else (agent-shell, terminal-bound CI): `terminal` — plain
+ *   text + ANSI color, no markdown syntax in the place that doesn't
+ *   render it. Markdown stays available via explicit `format: "markdown"`
+ *   for surfaces that *do* render it (MCP tools, GitHub step summary).
+ * @public
+ */
+declare const FormatSelectorLive: Layer.Layer<FormatSelector, never, never>;
+//#endregion
+//#region src/services/HistoryTracker.d.ts
+/**
+ * Lightweight test outcome for history classification.
+ * @public
+ */
+interface TestOutcome {
+  readonly fullName: string;
+  readonly state: "passed" | "failed";
+}
+declare const HistoryTracker_base: Context.TagClass<HistoryTracker, "vitest-agent/HistoryTracker", {
+  readonly classify: (project: string, testOutcomes: ReadonlyArray<TestOutcome>, timestamp: string) => Effect.Effect<{
+    history: HistoryRecord;
+    classifications: Map<string, TestClassification>;
+  }, DataStoreError>;
+}>;
+/** @public */
+declare class HistoryTracker extends HistoryTracker_base {}
+//#endregion
+//#region src/layers/HistoryTrackerLive.d.ts
+/** @public */
+declare const HistoryTrackerLive: Layer.Layer<HistoryTracker, never, DataReader>;
+//#endregion
+//#region src/layers/HistoryTrackerTest.d.ts
+/** @public */
+interface HistoryTrackerTestState {
+  readonly classifyCalls: Array<{
+    project: string;
+    timestamp: string;
+  }>;
+}
+/** @public */
+declare const HistoryTrackerTest: {
+  readonly empty: () => HistoryTrackerTestState;
+  readonly layer: (state: HistoryTrackerTestState, cannedResult?: {
+    history: HistoryRecord;
+    classifications: Map<string, TestClassification>;
+  }) => Layer.Layer<HistoryTracker>;
+};
+//#endregion
+//#region src/layers/LoggerLive.d.ts
+/**
+ * Create a structured JSON (NDJSON) logger layer for stderr.
+ *
+ * When level is undefined or LogLevel.None, replaces the default logger with Logger.none (silent).
+ * When logFile is set, composes with a file logger via Logger.zip.
+ * Uses Logger.structuredLogger serialized to JSON for machine-readable output.
+ * @public
+ */
+declare const LoggerLive: (level?: LogLevel.LogLevel, logFile?: string) => Layer.Layer<never>;
+/** @public */
+declare function resolveLogLevel(option?: string): LogLevel.LogLevel | undefined;
+/**
+ * Resolve log file from option or environment variable.
+ * @public
+ */
+declare function resolveLogFile(option?: string): string | undefined;
+//#endregion
+//#region src/layers/OutputPipelineLive.d.ts
+/** @public */
+declare const OutputPipelineLive: Layer.Layer<EnvironmentDetector | DetailResolver | ExecutorResolver | FormatSelector | OutputRenderer, never, never>;
+//#endregion
+//#region src/services/OutputRenderer.d.ts
+declare const OutputRenderer_base: Context.TagClass<OutputRenderer, "vitest-agent/OutputRenderer", {
+  readonly render: (reports: ReadonlyArray<AgentReport>, format: OutputFormat, context: FormatterContext) => Effect.Effect<ReadonlyArray<RenderedOutput>>;
+}>;
+/** @public */
+declare class OutputRenderer extends OutputRenderer_base {}
+//#endregion
+//#region src/layers/OutputRendererLive.d.ts
+/** @public */
+declare const OutputRendererLive: Layer.Layer<OutputRenderer, never, never>;
+//#endregion
+//#region src/layers/PathResolutionLive.d.ts
+/**
+ * Composite layer providing every service `resolveDataPath` requires:
+ * `AppDirs` (XDG path resolution), `VitestAgentConfigFile` (TOML
+ * config loader), `WorkspaceDiscovery` and `WorkspaceRoot` (workspace name
+ * lookup).
+ *
+ * Callers still need to provide `FileSystem` and `Path` from
+ * `@effect/platform-node`'s `NodeContext.layer` (or the equivalent on Bun).
+ *
+ * @param projectDir - Absolute path inside the user's workspace, used to
+ *   anchor the config file resolvers.
+ * @public
+ */
+declare const PathResolutionLive: (projectDir: string) => Layer.Layer<VitestAgentConfigFileService | import("workspaces-effect").WorkspaceDiscovery | import("xdg-effect").XdgResolver | import("xdg-effect").AppDirs, never, import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path>;
+//#endregion
+//#region src/services/PerClientSessionMap.d.ts
+/** @public */
+interface MapSessionInput {
+  readonly hostSessionId: string;
+  readonly conversationId: string;
+  readonly projectKey: string;
+  readonly projectDir: string;
+}
+/** @public */
+interface MapSessionOutput {
+  readonly mainAgentId: string;
+  readonly conversationId: string;
+}
+/** @public */
+interface SessionContextRow {
+  readonly hostSessionId: string;
+  readonly conversationId: string;
+  readonly projectKey: string;
+  readonly projectDir: string;
+  readonly mainAgentId: string;
+  readonly startedAt: number;
+  readonly endedAt: number | null;
+}
+declare const PerClientSessionMapReader_base: Context.TagClass<PerClientSessionMapReader, "vitest-agent/PerClientSessionMapReader", {
+  /**
+   * Look up an existing conversation_id for a given transcript
+   * path. Returns `Option.none()` when the transcript hasn't been
+   * seen before. Read-only — does not insert.
+   */
+  readonly lookupConversation: (transcriptPath: string) => Effect.Effect<Option.Option<string>, DataStoreError>;
+  /**
+   * Return the most recent open session for a project_dir
+   * (`ended_at IS NULL`). The MCP server uses this to recover
+   * `currentSessionContext` after `/reload-plugins`. The compound
+   * index `idx_session_map_active` covers the predicate.
+   */
+  readonly lookupByProjectDir: (projectDir: string) => Effect.Effect<Option.Option<SessionContextRow>, DataStoreError>;
+}>;
+/**
+ * Read-only side of the session map.
+ *
+ * Provided by `PerClientSessionMapReaderLive` (opens SQLite with
+ * `?mode=ro`). MCP server depends on this tag — calls to write
+ * methods would be a type error.
+ * @public
+ */
+declare class PerClientSessionMapReader extends PerClientSessionMapReader_base {}
+declare const PerClientSessionMapWriter_base: Context.TagClass<PerClientSessionMapWriter, "vitest-agent/PerClientSessionMapWriter", {
+  /**
+   * Upsert a conversation row. Returns the canonical conversation_id
+   * for the given transcript_path (existing if seen before, freshly
+   * generated otherwise).
+   */
+  readonly mapConversation: (transcriptPath: string) => Effect.Effect<string, DataStoreError>;
+  /**
+   * Upsert a session row. Returns the canonical main_agent_id and
+   * conversation_id (existing if `host_session_id` was seen before,
+   * freshly generated otherwise).
+   *
+   * The caller is responsible for having already mapped the
+   * conversation; this method only records the
+   * (host_session_id, conversation_id, project) tuple.
+   */
+  readonly mapSession: (input: MapSessionInput) => Effect.Effect<MapSessionOutput, DataStoreError>;
+  /**
+   * Mark a session as ended. Sets `ended_at` to the supplied
+   * timestamp. No-op if the session is unknown — endSession is
+   * best-effort cleanup.
+   */
+  readonly endSession: (hostSessionId: string, endedAt: number) => Effect.Effect<void, DataStoreError>;
+  /**
+   * Read methods so the Writer also satisfies the Reader tag's
+   * surface.
+   */
+  readonly lookupConversation: (transcriptPath: string) => Effect.Effect<Option.Option<string>, DataStoreError>;
+  readonly lookupByProjectDir: (projectDir: string) => Effect.Effect<Option.Option<SessionContextRow>, DataStoreError>;
+}>;
+/**
+ * Read-write side of the session map. Sidecar provides this; the
+ * Writer layer also satisfies the Reader tag so consumers of either
+ * one resolve.
+ * @public
+ */
+declare class PerClientSessionMapWriter extends PerClientSessionMapWriter_base {}
+//#endregion
+//#region src/layers/PerClientSessionMapLive.d.ts
+/**
+ * Read-only layer. The entry point provides an `SqlClient` configured
+ * with the `?mode=ro` URI parameter; this layer wraps the read
+ * methods and never declares write methods.
+ * @public
+ */
+declare const PerClientSessionMapReaderLive: Layer.Layer<PerClientSessionMapReader, never, SqlClient>;
+/**
+ * Read-write layer. Provides both write methods and the Reader's read
+ * methods so the same layer instance satisfies callers of either
+ * tag.
+ * @public
+ */
+declare const PerClientSessionMapWriterLive: Layer.Layer<PerClientSessionMapWriter | PerClientSessionMapReader, never, SqlClient>;
+//#endregion
+//#region src/services/ProjectDiscovery.d.ts
+/** @public */
+interface TestFileEntry {
+  readonly testFile: string;
+  readonly sourceFiles: ReadonlyArray<string>;
+}
+declare const ProjectDiscovery_base: Context.TagClass<ProjectDiscovery, "vitest-agent/ProjectDiscovery", {
+  readonly discoverTestFiles: (rootDir: string) => Effect.Effect<ReadonlyArray<TestFileEntry>, DiscoveryError>;
+  readonly mapTestToSource: (testFile: string) => Effect.Effect<ReadonlyArray<string>, DiscoveryError>;
+}>;
+/** @public */
+declare class ProjectDiscovery extends ProjectDiscovery_base {}
+//#endregion
+//#region src/layers/ProjectDiscoveryLive.d.ts
+/** @public */
+declare const ProjectDiscoveryLive: Layer.Layer<ProjectDiscovery, never, FileSystem.FileSystem>;
+//#endregion
+//#region src/layers/ProjectDiscoveryTest.d.ts
+/** @public */
+declare const ProjectDiscoveryTest: {
+  readonly layer: (entries: ReadonlyArray<TestFileEntry>) => Layer.Layer<ProjectDiscovery>;
+};
+//#endregion
+//#region src/services/ProjectIdentity.d.ts
+/**
+ * Result of a successful identity resolution.
+ *
+ * - `projectKey` — filesystem-safe single segment for the per-project
+ *   data store directory under `$XDG_DATA_HOME/vitest-agent/`.
+ * - `canonicalForm` — human-readable form for display in the discovery
+ *   registry. Equal to `projectKey` for non-git sources; for git
+ *   sources, the original `host/path` shape (with slashes preserved).
+ * - `source` — which source matched. Useful for diagnostics and the
+ *   `vitest-agent doctor`-style commands.
+ * @public
+ */
+interface ResolvedIdentity {
+  readonly projectKey: string;
+  readonly canonicalForm: string;
+  readonly source: ProjectIdentitySource;
+}
+/** @public */
+type ProjectIdentitySource = "explicit" | "toml" | "git-remote" | "package-repository" | "package-name";
+/**
+ * Per-source candidate values. Each is optional — an absent or empty
+ * value causes the resolver to fall through to the next source.
+ *
+ * The Live layer collects these from real I/O (config file, git
+ * subprocess, `package.json` read). Tests pass a literal object.
+ * @public
+ */
+interface ProjectIdentityCandidates {
+  readonly explicit?: string;
+  readonly toml?: string;
+  readonly gitRemote?: string;
+  readonly packageJsonRepoUrl?: string;
+  readonly packageJsonName?: string;
+}
+/**
+ * Options accepted by the `ProjectIdentity.resolve` service method.
+ *
+ * `projectId` is the priority-1 escape hatch — pass when the user has
+ * configured `AgentPlugin({ projectId: "..." })` in `vitest.config.ts`.
+ * @public
+ */
+interface ResolveProjectIdentityOptions {
+  readonly projectId?: string;
+}
+/**
+ * Pure priority resolver. Returns `null` when no candidate produces a
+ * usable value — the caller wraps `null` into a tagged error.
+ *
+ * For non-git sources the `canonicalForm` equals the original
+ * (un-normalized) input so the discovery registry can display
+ * `@spencerbeggs/vitest-agent` rather than the underscored form. For
+ * git sources, `canonicalForm` is the slash-preserving `host/path`
+ * shape from `canonicalizeGitUrl`.
+ * @public
+ */
+declare const resolveProjectIdentityFromCandidates: (candidates: ProjectIdentityCandidates) => ResolvedIdentity | null;
+declare const ProjectIdentity_base: Context.TagClass<ProjectIdentity, "vitest-agent/ProjectIdentity", {
+  readonly resolve: (workspaceRoot: string, options?: ResolveProjectIdentityOptions) => Effect.Effect<ResolvedIdentity, ProjectIdentityNotResolvableError>;
+}>;
+/**
+ * Service tag. The Live layer (in `layers/ProjectIdentityLive.ts`)
+ * wires up the I/O sources; tests provide a stub that returns a
+ * pre-built `ResolvedIdentity`.
+ * @public
+ */
+declare class ProjectIdentity extends ProjectIdentity_base {}
+//#endregion
+//#region src/layers/ProjectIdentityLive.d.ts
+/**
+ * Effect environment type required by `collectCandidates` and the
+ * `ProjectIdentityLive` layer. Exported only so the layer's
+ * `Layer.Layer<ProjectIdentity, never, CandidateContext>` signature
+ * has a named referent — consumers should provide the four named
+ * services (FileSystem, WorkspaceDiscovery, VitestAgentConfigFile,
+ * CommandExecutor) rather than reference this type directly.
+ *
+ * @public
+ */
+type CandidateContext = FileSystem.FileSystem | WorkspaceDiscovery | Context.Tag.Identifier<typeof VitestAgentConfigFile> | CommandExecutor.CommandExecutor;
+/**
+ * Live layer that wires the resolver into real I/O. Requires
+ * `FileSystem`, `CommandExecutor`, `WorkspaceDiscovery`, and
+ * `VitestAgentConfigFile`. The platform context comes from
+ * `NodeContext.layer` at the entry point.
+ * @public
+ */
+declare const ProjectIdentityLive: Layer.Layer<ProjectIdentity, never, CandidateContext>;
+/**
+ * Build a Test layer that returns a fixed `ResolvedIdentity` (or
+ * fails with `ProjectIdentityNotResolvableError`). Use in unit tests
+ * that depend on `ProjectIdentity` but don't want to wire upstream
+ * services.
+ * @public
+ */
+declare const ProjectIdentityTest: (result: ResolvedIdentity | ProjectIdentityNotResolvableError) => Layer.Layer<ProjectIdentity, never, never>;
+//#endregion
+//#region src/services/RunContext.d.ts
+declare const RunContext_base: Schema.Class<RunContext, {
+  gitBranch: Schema.NullOr<typeof Schema.String>;
+  gitCommitSha: Schema.NullOr<typeof Schema.String>;
+  gitDirty: Schema.NullOr<typeof Schema.Boolean>;
+  gitUpstream: Schema.NullOr<typeof Schema.String>;
+  gitWorktreeDir: Schema.NullOr<typeof Schema.String>;
+  hostSource: Schema.NullOr<typeof Schema.String>;
+  hostValue: Schema.NullOr<typeof Schema.String>;
+  hostMetadata: Schema.NullOr<typeof Schema.Unknown>;
+}, Schema.Struct.Encoded<{
+  gitBranch: Schema.NullOr<typeof Schema.String>;
+  gitCommitSha: Schema.NullOr<typeof Schema.String>;
+  gitDirty: Schema.NullOr<typeof Schema.Boolean>;
+  gitUpstream: Schema.NullOr<typeof Schema.String>;
+  gitWorktreeDir: Schema.NullOr<typeof Schema.String>;
+  hostSource: Schema.NullOr<typeof Schema.String>;
+  hostValue: Schema.NullOr<typeof Schema.String>;
+  hostMetadata: Schema.NullOr<typeof Schema.Unknown>;
+}>, never, {
+  readonly gitBranch: string | null;
+} & {
+  readonly gitCommitSha: string | null;
+} & {
+  readonly gitDirty: boolean | null;
+} & {
+  readonly gitUpstream: string | null;
+} & {
+  readonly gitWorktreeDir: string | null;
+} & {
+  readonly hostSource: string | null;
+} & {
+  readonly hostValue: string | null;
+} & {
+  readonly hostMetadata: unknown;
+}, {}, {}>;
+/**
+ * Per-run snapshot of the workspace's git state and host context.
+ * Every field is nullable: a non-git workspace has all-NULL git
+ * fields, a CI run with no terminal probe match has all-NULL host
+ * fields, and a worker that can't read upstream info has a NULL
+ * `gitUpstream` while everything else is set.
+ *
+ * Declared as a `Schema.Class` so callers can `new RunContext({...})`
+ * and `Schema.encode(...)` for the SQLite row mapping.
+ * @public
+ */
+declare class RunContext extends RunContext_base {}
+declare const AgentContext_base: Schema.Class<AgentContext, {
+  startGitBranch: Schema.NullOr<typeof Schema.String>;
+  startGitCommitSha: Schema.NullOr<typeof Schema.String>;
+  startWorktreeDir: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+  startGitBranch: Schema.NullOr<typeof Schema.String>;
+  startGitCommitSha: Schema.NullOr<typeof Schema.String>;
+  startWorktreeDir: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+  readonly startGitBranch: string | null;
+} & {
+  readonly startGitCommitSha: string | null;
+} & {
+  readonly startWorktreeDir: string | null;
+}, {}, {}>;
+/**
+ * Subset of {@link RunContext} captured at agent registration. Only
+ * the inheritable git context — branch, sha, worktree path. Mid-run
+ * dirty-tree state and upstream tracking are per-run concerns.
+ * @public
+ */
+declare class AgentContext extends AgentContext_base {}
+declare const RunContext$_base: Context.TagClass<RunContext$, "vitest-agent/RunContextService", {
+  readonly captureRunContext: (cwd: string) => Effect.Effect<RunContext>;
+  readonly captureAgentContext: (cwd: string) => Effect.Effect<AgentContext>;
+}>;
+/**
+ * Service tag. The Live layer captures real I/O; the Test layer
+ * returns whatever the test fixture passes.
+ * @public
+ */
+declare class RunContext$ extends RunContext$_base {}
+/**
+ * Re-export the service tag under a less-collision-prone name. The
+ * `RunContext` Schema.Class above shares its symbol-name with the
+ * service tag concept; the `$` suffix on the Context.Tag class name
+ * keeps both addressable from the same module.
+ *
+ * @public
+ */
+declare const RunContextService: typeof RunContext$;
+/** @public */
+type RunContextService = RunContext$;
+//#endregion
+//#region src/layers/RunContextLive.d.ts
+/**
+ * Live layer. Requires `CommandExecutor` (provided by
+ * `NodeContext.layer` at the entry point). Reads `process.env`
+ * directly for host-metadata probes — the env walk is pure but the
+ * env source is process-global, captured once when the layer
+ * constructs.
+ * @public
+ */
+declare const RunContextLive: Layer.Layer<RunContextService, never, CommandExecutor.CommandExecutor>;
+/**
+ * Build a Test layer that returns fixed `RunContext` and
+ * `AgentContext` values regardless of `cwd`.
+ * @public
+ */
+declare const RunContextTest: (fixture: {
+  readonly runContext: RunContext;
+  readonly agentContext: AgentContext;
+}) => Layer.Layer<RunContextService, never, never>;
+//#endregion
+//#region src/lib/format-triage.d.ts
+/** @public */
+interface FormatTriageOptions {
+  readonly project?: string;
+  readonly maxLines?: number;
+}
+/**
+ * Generates an orientation triage markdown string for LLM agents.
+ * Summarises recent test runs, active sessions, acceptance metrics,
+ * and (forward-compat) the most recent TDD session.
+ *
+ * Error channel is `never` — all DataReader errors are swallowed and
+ * replaced with empty defaults so the caller is guaranteed a string.
+ * @public
+ */
+declare const formatTriageEffect: (options?: FormatTriageOptions) => Effect.Effect<string, never, DataReader>;
+//#endregion
+//#region src/lib/format-wrapup.d.ts
+/** @public */
+type WrapupKind = "stop" | "session_end" | "pre_compact" | "tdd_handoff" | "user_prompt_nudge";
+/** @public */
+interface FormatWrapupOptions {
+  readonly sessionId?: number;
+  readonly chatId?: string;
+  readonly kind: WrapupKind;
+  readonly userPromptHint?: string;
+}
+/** @public */
+declare const formatWrapupEffect: (options: FormatWrapupOptions) => Effect.Effect<string, never, DataReader>;
+//#endregion
+//#region src/migrations/0001_initial.d.ts
+/** @internal */
+declare const migration: Effect.Effect<void, import("@effect/sql/SqlError").SqlError, SqlClient>;
+/** @public */
+//#endregion
+//#region src/migrations/registry_0001_initial.d.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
+ */
+declare const migration$1: Effect.Effect<void, import("@effect/sql/SqlError").SqlError, SqlClient>;
+//#endregion
+//#region src/migrations/session_map_0001_initial.d.ts
+/** @internal */
+declare const migration$2: Effect.Effect<void, import("@effect/sql/SqlError").SqlError, SqlClient>;
+/** @public */
+//#endregion
+//#region src/schemas/ChannelEvent.d.ts
+/** @public */
+declare const SessionOutcome: Schema.Literal<["succeeded", "blocked", "abandoned"]>;
+/** @public */
+type SessionOutcome = typeof SessionOutcome.Type;
+/** @public */
+declare const GoalsReadyEvent: Schema.Struct<{
+  type: Schema.Literal<["goals_ready"]>;
+  sessionId: typeof Schema.Number;
+  goals: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    goal: typeof Schema.String;
+  }>>;
+}>;
+/** @public */
+type GoalsReadyEvent = typeof GoalsReadyEvent.Type;
+/** @public */
+declare const GoalAddedEvent: Schema.Struct<{
+  type: Schema.Literal<["goal_added"]>;
+  sessionId: typeof Schema.Number;
+  goal: Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    goal: typeof Schema.String;
+  }>;
+}>;
+/** @public */
+type GoalAddedEvent = typeof GoalAddedEvent.Type;
+/** @public */
+declare const GoalStartedEvent: Schema.Struct<{
+  type: Schema.Literal<["goal_started"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+}>;
+/** @public */
+type GoalStartedEvent = typeof GoalStartedEvent.Type;
+/** @public */
+declare const GoalCompletedEvent: Schema.Struct<{
+  type: Schema.Literal<["goal_completed"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorIds: Schema.Array$<typeof Schema.Number>;
+}>;
+/** @public */
+type GoalCompletedEvent = typeof GoalCompletedEvent.Type;
+/** @public */
+declare const GoalAbandonedEvent: Schema.Struct<{
+  type: Schema.Literal<["goal_abandoned"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  reason: typeof Schema.String;
+}>;
+/** @public */
+type GoalAbandonedEvent = typeof GoalAbandonedEvent.Type;
+/** @public */
+declare const BehaviorsReadyEvent: Schema.Struct<{
+  type: Schema.Literal<["behaviors_ready"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviors: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+  }>>;
+}>;
+/** @public */
+type BehaviorsReadyEvent = typeof BehaviorsReadyEvent.Type;
+/** @public */
+declare const BehaviorAddedEvent: Schema.Struct<{
+  type: Schema.Literal<["behavior_added"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behavior: Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+  }>;
+}>;
+/** @public */
+type BehaviorAddedEvent = typeof BehaviorAddedEvent.Type;
+/** @public */
+declare const BehaviorStartedEvent: Schema.Struct<{
+  type: Schema.Literal<["behavior_started"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+}>;
+/** @public */
+type BehaviorStartedEvent = typeof BehaviorStartedEvent.Type;
+/** @public */
+declare const PhaseTransitionEvent: Schema.Struct<{
+  type: Schema.Literal<["phase_transition"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  from: Schema.Literal<["spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red"]>;
+  to: Schema.Literal<["spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red"]>;
+}>;
+/** @public */
+type PhaseTransitionEvent = typeof PhaseTransitionEvent.Type;
+/** @public */
+declare const BehaviorCompletedEvent: Schema.Struct<{
+  type: Schema.Literal<["behavior_completed"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+}>;
+/** @public */
+type BehaviorCompletedEvent = typeof BehaviorCompletedEvent.Type;
+/** @public */
+declare const BehaviorAbandonedEvent: Schema.Struct<{
+  type: Schema.Literal<["behavior_abandoned"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  reason: typeof Schema.String;
+}>;
+/** @public */
+type BehaviorAbandonedEvent = typeof BehaviorAbandonedEvent.Type;
+/** @public */
+declare const BlockedEvent: Schema.Struct<{
+  type: Schema.Literal<["blocked"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  reason: typeof Schema.String;
+  failureSignatureHash: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type BlockedEvent = typeof BlockedEvent.Type;
+/** @public */
+declare const SessionCompleteEvent: Schema.Struct<{
+  type: Schema.Literal<["session_complete"]>;
+  sessionId: typeof Schema.Number;
+  goalIds: Schema.Array$<typeof Schema.Number>;
+  outcome: Schema.Literal<["succeeded", "blocked", "abandoned"]>;
+}>;
+/** @public */
+type SessionCompleteEvent = typeof SessionCompleteEvent.Type;
+/** @public */
+declare const ChannelEvent: Schema.Union<[Schema.Struct<{
+  type: Schema.Literal<["goals_ready"]>;
+  sessionId: typeof Schema.Number;
+  goals: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    goal: typeof Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["goal_added"]>;
+  sessionId: typeof Schema.Number;
+  goal: Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    goal: typeof Schema.String;
+  }>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["goal_started"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+}>, Schema.Struct<{
+  type: Schema.Literal<["goal_completed"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorIds: Schema.Array$<typeof Schema.Number>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["goal_abandoned"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  reason: typeof Schema.String;
+}>, Schema.Struct<{
+  type: Schema.Literal<["behaviors_ready"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviors: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["behavior_added"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behavior: Schema.Struct<{
+    id: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+  }>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["behavior_started"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+}>, Schema.Struct<{
+  type: Schema.Literal<["phase_transition"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  from: Schema.Literal<["spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red"]>;
+  to: Schema.Literal<["spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red"]>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["behavior_completed"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+}>, Schema.Struct<{
+  type: Schema.Literal<["behavior_abandoned"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  reason: typeof Schema.String;
+}>, Schema.Struct<{
+  type: Schema.Literal<["blocked"]>;
+  sessionId: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  behaviorId: typeof Schema.Number;
+  reason: typeof Schema.String;
+  failureSignatureHash: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["session_complete"]>;
+  sessionId: typeof Schema.Number;
+  goalIds: Schema.Array$<typeof Schema.Number>;
+  outcome: Schema.Literal<["succeeded", "blocked", "abandoned"]>;
+}>]>;
+/** @public */
+type ChannelEvent = typeof ChannelEvent.Type;
+/**
+ * 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
+ */
+declare const BehaviorScopedEventTypes: readonly ["behavior_started", "phase_transition", "behavior_completed", "behavior_abandoned", "blocked"];
+/** @public */
+type BehaviorScopedEventType = (typeof BehaviorScopedEventTypes)[number];
+//#endregion
+//#region src/schemas/CoverageLevel.d.ts
+declare const CoverageLevel_base: Schema.Class<CoverageLevel, {
+  lines: typeof Schema.Number;
+  functions: typeof Schema.Number;
+  branches: typeof Schema.Number;
+  statements: typeof Schema.Number;
+  perFile: Schema.optional<typeof Schema.Boolean>;
+}, Schema.Struct.Encoded<{
+  lines: typeof Schema.Number;
+  functions: typeof Schema.Number;
+  branches: typeof Schema.Number;
+  statements: typeof Schema.Number;
+  perFile: Schema.optional<typeof Schema.Boolean>;
+}>, never, {
+  readonly lines: number;
+} & {
+  readonly functions: number;
+} & {
+  readonly branches: number;
+} & {
+  readonly statements: number;
+} & {
+  readonly perFile?: boolean | undefined;
+}, {}, {}>;
+/**
+ * A coverage level configuration with per-metric thresholds and an optional
+ * perFile flag. Extend this class to define custom named presets.
+ * @public
+ */
+declare class CoverageLevel extends CoverageLevel_base {
+  /** No enforcement — all metrics at 0%. */
+  static readonly none: CoverageLevel;
+  /** Minimal coverage bar — all metrics at 50%. */
+  static readonly basic: CoverageLevel;
+  /** Recommended default — lines/functions/statements at 70%, branches at 65%. */
+  static readonly standard: CoverageLevel;
+  /** High-quality bar — lines/functions/statements at 80%, branches at 75%. */
+  static readonly strict: CoverageLevel;
+  /** Near-complete coverage — lines/functions/statements at 90%, branches at 85%. */
+  static readonly full: CoverageLevel;
+  /**
+   * Returns a new CoverageLevel instance with perFile set to true.
+   * Does not mutate the original.
+   */
+  withPerFile(): CoverageLevel;
+  /**
+   * Returns a new CoverageLevel instance with the given fields overridden.
+   * Does not mutate the original. Existing perFile is preserved unless
+   * explicitly overridden.
+   */
+  extend(overrides: Partial<{
+    lines: number;
+    functions: number;
+    branches: number;
+    statements: number;
+    perFile: boolean;
+  }>): CoverageLevel;
+}
+/** The named preset identifiers.  * @public
+ */
+type CoverageLevelName = "none" | "basic" | "standard" | "strict" | "full";
+/** Accepted input forms: a preset name string or a CoverageLevel instance.  * @public
+ */
+type CoverageInput = CoverageLevelName | CoverageLevel;
+/**
+ * Resolves a CoverageInput (preset name or CoverageLevel instance) to a
+ * CoverageLevel. When input is undefined, returns the named fallback preset.
+ * Throws if a string is provided that does not match a known preset name.
+ * @public
+ */
+declare function resolveCoverageInput(input: CoverageInput | undefined, fallback: CoverageLevelName): CoverageLevel;
+/**
+ * Validates that coverageTargets are not below coverageThresholds for any
+ * metric, and that both agree on perFile. Throws a descriptive Error on
+ * any violation.
+ * @public
+ */
+declare function validateCoverageConfig(thresholds: CoverageLevel, targets: CoverageLevel): void;
+//#endregion
+//#region src/schemas/CoverageTargets.d.ts
+/**
+ * Per-metric leaf shape for coverageTargets entries. Allows optional
+ * numeric targets per metric and the `100: true` shortcut.
+ * @public
+ */
+declare const CoverageTargetsMetrics: Schema.Struct<{
+  lines: Schema.optional<typeof Schema.Positive>;
+  functions: Schema.optional<typeof Schema.Positive>;
+  branches: Schema.optional<typeof Schema.Positive>;
+  statements: Schema.optional<typeof Schema.Positive>;
+  100: Schema.optional<Schema.Literal<[true]>>;
+}>;
+/** @public */
+type CoverageTargetsMetrics = typeof CoverageTargetsMetrics.Type;
+/**
+ * Typed schema for the coverageTargets option.
+ *
+ * Mirrors Vitest's coverage.thresholds shape — per-metric positive numbers,
+ * the `100: true` shortcut (only valid at key `"100"`), and glob-pattern
+ * entries with metric objects. Positive numbers only; negatives and zeros
+ * are rejected. `perFile` is not allowed here — inherit it from
+ * `coverage.thresholds.perFile`.
+ *
+ * A decode-time refinement rejects `true` at any key other than `"100"`
+ * so `{ statements: true }` fails parse rather than silently flowing
+ * through to a runtime parser that only honors the canonical shorthand
+ * at key `"100"`.
+ * @public
+ */
+declare const CoverageTargets: Schema.refine<{
+  readonly [x: string]: number | true | {
+    readonly lines?: number | undefined;
+    readonly functions?: number | undefined;
+    readonly branches?: number | undefined;
+    readonly statements?: number | undefined;
+    readonly 100?: true | undefined;
+  };
+}, Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.Positive, Schema.Literal<[true]>, Schema.Struct<{
+  lines: Schema.optional<typeof Schema.Positive>;
+  functions: Schema.optional<typeof Schema.Positive>;
+  branches: Schema.optional<typeof Schema.Positive>;
+  statements: Schema.optional<typeof Schema.Positive>;
+  100: Schema.optional<Schema.Literal<[true]>>;
+}>]>>>;
+/** @public */
+type CoverageTargets = typeof CoverageTargets.Type;
+//#endregion
+//#region src/schemas/Options.d.ts
+/**
+ * Per-executor console-output matrix. Most users never set this — the
+ * built-in defaults cover the common cases. Override per slot when you
+ * want to force a specific layout for debugging or to suppress one
+ * channel without affecting the others.
+ *
+ * Defaults:
+ * - `human` → `"passthrough"` today; users opt into `"stream"` explicitly
+ *   for the progressively-drawn, animated agent-shaped live renderer.
+ * - `agent` → `"agent"` (markdown-flavored final frame).
+ * - `ci` → `"passthrough"` (Vitest's reporters produce log-friendly
+ *   output). `"ci-annotations"` is opt-in until the dedicated GHA
+ *   annotations writer ships.
+ * @public
+ */
+declare const ConsoleOutputs: Schema.Struct<{
+  human: Schema.optional<Schema.Literal<["passthrough", "silent", "stream", "agent"]>>;
+  agent: Schema.optional<Schema.Literal<["passthrough", "silent", "agent"]>>;
+  ci: Schema.optional<Schema.Literal<["passthrough", "silent", "ci-annotations"]>>;
+}>;
+/** @public */
+type ConsoleOutputs = typeof ConsoleOutputs.Type;
+/**
+ * The 2.0 user-facing options for `AgentPlugin`.
+ *
+ * Five fields total. Two are function-typed (`reporter`, `onRunEvent`)
+ * and live on the `AgentPluginConstructorOptions` companion interface in
+ * `@vitest-agent/plugin` — Effect Schema cannot encode functions cleanly,
+ * so the schema-decodable struct carries the three data-shaped fields.
+ * @public
+ */
+declare const AgentPluginOptions: Schema.Struct<{
+  console: Schema.optional<Schema.Struct<{
+    human: Schema.optional<Schema.Literal<["passthrough", "silent", "stream", "agent"]>>;
+    agent: Schema.optional<Schema.Literal<["passthrough", "silent", "agent"]>>;
+    ci: Schema.optional<Schema.Literal<["passthrough", "silent", "ci-annotations"]>>;
+  }>>;
+  coverageTargets: Schema.optional<Schema.refine<{
+    readonly [x: string]: number | true | {
+      readonly lines?: number | undefined;
+      readonly functions?: number | undefined;
+      readonly branches?: number | undefined;
+      readonly statements?: number | undefined;
+      readonly 100?: true | undefined;
+    };
+  }, Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.Positive, Schema.Literal<[true]>, Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Positive>;
+    functions: Schema.optional<typeof Schema.Positive>;
+    branches: Schema.optional<typeof Schema.Positive>;
+    statements: Schema.optional<typeof Schema.Positive>;
+    100: Schema.optional<Schema.Literal<[true]>>;
+  }>]>>>>;
+  transport: Schema.optional<Schema.Struct<{
+    kind: Schema.Literal<["local"]>;
+  }>>;
+}>;
+/** @public */
+type AgentPluginOptions = typeof AgentPluginOptions.Type;
+/**
+ * Reporter-implementation options.
+ *
+ * Public for users building custom reporters via `@vitest-agent/reporter`;
+ * most users never see this type — they wire `AgentPlugin({ reporter })`
+ * and the factory receives a fully-resolved `ReporterKit` instead.
+ *
+ * Carries internal flags the plugin sets when constructing the reporter
+ * (currently only `projectFilter` for per-project scoping).
+ * @public
+ */
+declare const AgentReporterOptions: Schema.Struct<{
+  /** Set by the plugin per-project. Filters reports to one project. */projectFilter: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type AgentReporterOptions = typeof AgentReporterOptions.Type;
+//#endregion
+//#region src/schemas/turns/FileEditPayload.d.ts
+/** @public */
+declare const FileEditPayload: Schema.Struct<{
+  type: Schema.Literal<["file_edit"]>;
+  file_path: typeof Schema.String;
+  edit_kind: Schema.Literal<["write", "edit", "multi_edit"]>;
+  lines_added: Schema.optional<typeof Schema.Number>;
+  lines_removed: Schema.optional<typeof Schema.Number>;
+  diff: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type FileEditPayload = typeof FileEditPayload.Type;
+//#endregion
+//#region src/schemas/turns/HookFirePayload.d.ts
+/** @public */
+declare const HookFirePayload: Schema.Struct<{
+  type: Schema.Literal<["hook_fire"]>;
+  hook_kind: Schema.Literal<["SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "FileChanged"]>;
+  chat_id: Schema.optional<typeof Schema.String>;
+  previous_record_failures: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+/** @public */
+type HookFirePayload = typeof HookFirePayload.Type;
+//#endregion
+//#region src/schemas/turns/HypothesisPayload.d.ts
+/** @public */
+declare const HypothesisPayload: Schema.Struct<{
+  type: Schema.Literal<["hypothesis"]>;
+  content: typeof Schema.String;
+  cited_test_error_id: Schema.optional<typeof Schema.Number>;
+  cited_stack_frame_id: Schema.optional<typeof Schema.Number>;
+}>;
+/** @public */
+type HypothesisPayload = typeof HypothesisPayload.Type;
+//#endregion
+//#region src/schemas/turns/NotePayload.d.ts
+/** @public */
+declare const NotePayload: Schema.Struct<{
+  type: Schema.Literal<["note"]>;
+  scope: typeof Schema.String;
+  title: Schema.optional<typeof Schema.String>;
+  content: typeof Schema.String;
+}>;
+/** @public */
+type NotePayload = typeof NotePayload.Type;
+//#endregion
+//#region src/schemas/turns/ToolCallPayload.d.ts
+/** @public */
+declare const ToolCallPayload: Schema.Struct<{
+  type: Schema.Literal<["tool_call"]>;
+  tool_name: typeof Schema.String;
+  tool_input: typeof Schema.Unknown;
+  tool_use_id: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type ToolCallPayload = typeof ToolCallPayload.Type;
+//#endregion
+//#region src/schemas/turns/ToolResultPayload.d.ts
+/** @public */
+declare const ToolResultPayload: Schema.Struct<{
+  type: Schema.Literal<["tool_result"]>;
+  tool_name: typeof Schema.String;
+  tool_use_id: Schema.optional<typeof Schema.String>;
+  result_summary: Schema.optional<typeof Schema.String>;
+  success: typeof Schema.Boolean;
+  duration_ms: Schema.optional<typeof Schema.Number>;
+}>;
+/** @public */
+type ToolResultPayload = typeof ToolResultPayload.Type;
+//#endregion
+//#region src/schemas/turns/UserPromptPayload.d.ts
+/** @public */
+declare const UserPromptPayload: Schema.Struct<{
+  type: Schema.Literal<["user_prompt"]>;
+  prompt: typeof Schema.String;
+  cc_message_id: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type UserPromptPayload = typeof UserPromptPayload.Type;
+//#endregion
+//#region src/schemas/turns/index.d.ts
+/** @public */
+declare const TurnPayload: Schema.Union<[Schema.Struct<{
+  type: Schema.Literal<["user_prompt"]>;
+  prompt: typeof Schema.String;
+  cc_message_id: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["tool_call"]>;
+  tool_name: typeof Schema.String;
+  tool_input: typeof Schema.Unknown;
+  tool_use_id: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["tool_result"]>;
+  tool_name: typeof Schema.String;
+  tool_use_id: Schema.optional<typeof Schema.String>;
+  result_summary: Schema.optional<typeof Schema.String>;
+  success: typeof Schema.Boolean;
+  duration_ms: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["file_edit"]>;
+  file_path: typeof Schema.String;
+  edit_kind: Schema.Literal<["write", "edit", "multi_edit"]>;
+  lines_added: Schema.optional<typeof Schema.Number>;
+  lines_removed: Schema.optional<typeof Schema.Number>;
+  diff: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["hook_fire"]>;
+  hook_kind: Schema.Literal<["SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "FileChanged"]>;
+  chat_id: Schema.optional<typeof Schema.String>;
+  previous_record_failures: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>, Schema.Struct<{
+  type: Schema.Literal<["note"]>;
+  scope: typeof Schema.String;
+  title: Schema.optional<typeof Schema.String>;
+  content: typeof Schema.String;
+}>, Schema.Struct<{
+  type: Schema.Literal<["hypothesis"]>;
+  content: typeof Schema.String;
+  cited_test_error_id: Schema.optional<typeof Schema.Number>;
+  cited_stack_frame_id: Schema.optional<typeof Schema.Number>;
+}>]>;
+/** @public */
+type TurnPayload = typeof TurnPayload.Type;
+//#endregion
+//#region src/services/idempotency.d.ts
+/**
+ * Sentinel substituted for `parentAgentId` when the value is `null`.
+ * Avoids ambiguity around hashing the literal string "null" or empty
+ * string, both of which could collide with caller-supplied values.
+ * @public
+ */
+declare const IDEMPOTENCY_ROOT_SENTINEL = "__ROOT__";
+/** @public */
+interface IdempotencyInput {
+  readonly agentType: string;
+  readonly parentAgentId: string | null;
+  readonly clientNonce: string;
+}
+/**
+ * Derive the canonical idempotency key for an `agents` row.
+ *
+ * Algorithm:
+ *   sha256(agentType + "|" + (parentAgentId ?? "__ROOT__") + "|" + clientNonce)
+ *   then base32 (RFC 4648 alphabet, lowercased) truncated to 26 chars.
+ *
+ * 26 base32 chars = 130 bits, far beyond the birthday-bound for the
+ * scoping (UNIQUE per session). The base32 alphabet is a-z2-7 — all
+ * lowercase to keep the column lexicographically friendly and
+ * case-insensitive on filesystems that we never hit but might in
+ * future debugging.
+ * @public
+ */
+declare const deriveIdempotencyKey: (input: IdempotencyInput) => string;
+//#endregion
+//#region src/sql/assemblers.d.ts
+/**
+ * Minimal shape of a test_runs aggregation row used to build the manifest.
+ * @public
+ */
+interface ManifestRow {
+  project: string;
+  sub_project: string | null;
+  timestamp: string;
+  reason: string;
+}
+/**
+ * Minimal shape of a test_history row used to build a history record.
+ * @public
+ */
+interface HistoryRow {
+  full_name: string;
+  timestamp: string;
+  state: string;
+}
+/**
+ * A `Record<fullName, { runs: TestRun[] }>` keyed by test full name.
+ *
+ * This is the internal representation returned by `assembleHistoryRecord`.
+ * Callers that need the Effect Schema `HistoryRecord` type should adapt this
+ * into the `tests` array format.
+ * @public
+ */
+interface AssembledHistoryRecord {
+  [fullName: string]: {
+    runs: TestRun[];
+  };
+}
+/**
+ * Builds a `CacheManifest` from an array of test_runs aggregation rows.
+ *
+ * Each row represents the latest run for a project/sub_project pair.
+ * The `dbPath` is stored as `cacheDir` so CLI tools can locate the source.
+ * @public
+ */
+declare function assembleManifest(rows: ManifestRow[], dbPath: string): CacheManifest;
+/**
+ * Groups test_history rows by `full_name` into a keyed record.
+ *
+ * Returns `Record<fullName, { runs: TestRun[] }>` where `runs` are the
+ * accumulated test runs for that test, in the order they appear in `rows`.
+ *
+ * Only rows with state `"passed"` or `"failed"` are included in runs
+ * (matching the `TestRun` schema constraint).
+ * @public
+ */
+declare function assembleHistoryRecord(rows: HistoryRow[]): AssembledHistoryRecord;
+//#endregion
+//#region src/utils/ansi.d.ts
+/**
+ * Options for ANSI color output control.
+ *
+ * @internal
+ */
+interface AnsiOptions {
+  noColor?: boolean;
+}
+/**
+ * Wrap text with an ANSI color/style escape code.
+ *
+ * No-ops when `options.noColor` is true, keeping output as valid plain
+ * markdown when captured by agents or piped to files.
+ *
+ * @privateRemarks
+ * Uses raw ANSI escape sequences (`\x1b[...m`) rather than a dependency
+ * like `chalk` or `picocolors` to keep the package zero-dependency. The
+ * `noColor` flag respects the `NO_COLOR` environment variable convention.
+ *
+ * @param text - Text to wrap
+ * @param color - ANSI code name: `reset`, `bold`, `dim`, `red`, `green`, `yellow`, `cyan`
+ * @param options - Control color output
+ * @returns Text with ANSI escape codes, or plain text if noColor
+ *
+ * @see {@link https://no-color.org/ | NO_COLOR convention}
+ * @internal
+ */
+declare function ansi(text: string, color: string, options?: AnsiOptions): string;
+/**
+ * Strip all ANSI escape codes from a string.
+ *
+ * @param text - String potentially containing ANSI escape sequences
+ * @returns Plain text with all escape sequences removed
+ *
+ * @internal
+ */
+declare function stripAnsi(text: string): string;
+//#endregion
+//#region src/utils/build-report.d.ts
+/**
+ * Duck-typed Vitest parsed stack frame.
+ *
+ * Vitest's TestError.stacks is `ParsedStack[]` from `@vitest/utils`, not a
+ * plain string array. Frames must be formatted before joining; otherwise
+ * `[obj].join("\n")` produces "[object Object]".
+ *
+ * @public
+ */
+interface VitestParsedStack {
+  method: string;
+  file: string;
+  line: number;
+  column: number;
+}
+/**
+ * Duck-typed Vitest test error with message, optional diff, and stack traces.
+ *
+ * `stacks` accepts both already-formatted strings (legacy / coercion path)
+ * and `ParsedStack[]` (real Vitest output).
+ *
+ * @public
+ */
+interface VitestTestError {
+  message: string;
+  diff?: string;
+  stacks?: Array<string | VitestParsedStack>;
+}
+/**
+ * Duck-typed Vitest test result returned by `TestCase.result()`.
+ *
+ * Vitest returns `undefined` for tests that have not finished running
+ * (pending/collected state).
+ *
+ * @public
+ */
+interface VitestTestResult {
+  state: string;
+  errors?: ReadonlyArray<VitestTestError>;
+}
+/**
+ * Duck-typed Vitest test diagnostic returned by `TestCase.diagnostic()`.
+ *
+ * @public
+ */
+interface VitestTestDiagnostic {
+  duration: number;
+  flaky: boolean;
+  slow: boolean;
+}
+/**
+ * Duck-typed Vitest TestCase from the Reporter v2 API.
+ *
+ * @remarks
+ * These interfaces mirror the Vitest TestCase shape without importing
+ * Vitest types directly, keeping the formatter a pure data transformer
+ * with no dependency on the Vitest runtime.
+ *
+ * @public
+ */
+interface VitestTestCase {
+  type: "test";
+  name: string;
+  fullName: string;
+  tags: readonly string[];
+  /** Parent suite or module. Optional in the duck-type so unit-test fixtures don't have to fabricate a stub; always present in real Vitest TestCase instances. */
+  parent?: VitestTestSuite | VitestTestModule;
+  result(): VitestTestResult | undefined;
+  diagnostic(): VitestTestDiagnostic | undefined;
+}
+/**
+ * Duck-typed Vitest module diagnostic.
+ *
+ * @public
+ */
+interface VitestModuleDiagnostic {
+  duration: number;
+}
+/**
+ * Duck-typed Vitest module error.
+ *
+ * @public
+ */
+interface VitestModuleError {
+  message: string;
+  stacks?: Array<string | VitestParsedStack>;
+}
+/**
+ * Duck-typed Vitest TestSuite from the Reporter v2 API.
+ *
+ * @public
+ */
+interface VitestTestSuite {
+  type: "suite";
+  name: string;
+  fullName: string;
+  state(): string;
+  parent: VitestTestSuite | VitestTestModule;
+  options: {
+    concurrent?: boolean;
+    shuffle?: boolean;
+    retry?: number;
+    repeats?: number;
+    mode?: string;
+    tags?: string[];
+  };
+  location?: {
+    line: number;
+    column: number;
+  };
+}
+/**
+ * Duck-typed Vitest TestModule from the Reporter v2 API.
+ *
+ * @remarks
+ * Each `TestModule` carries a `.project` reference with a `.name` property,
+ * which `AgentReporter` uses to group results by Vitest project in
+ * monorepo configurations.
+ *
+ * @public
+ */
+interface VitestTestModule {
+  type: "module";
+  moduleId: string;
+  relativeModuleId: string;
+  project: {
+    name: string;
+  };
+  state(): string;
+  children: {
+    allTests(filter?: string): Generator<VitestTestCase>;
+    allSuites(): Generator<VitestTestSuite>;
+  };
+  diagnostic(): VitestModuleDiagnostic | undefined;
+  errors(): Array<VitestModuleError>;
+}
+/**
+ * Convert Vitest TestModule/TestCase objects into an `AgentReport`.
+ *
+ * @remarks
+ * This is a pure data transformation function with no I/O. It tallies
+ * pass/fail/skip counts, extracts error details with diffs, and builds
+ * the complete report structure. Only modules with at least one failing
+ * test are included in the `failed` array to keep reports compact.
+ *
+ * @param testModules - All test modules from the Vitest run
+ * @param unhandledErrors - Unhandled errors from the run
+ * @param reason - Overall run outcome (`"passed"`, `"failed"`, or `"interrupted"`)
+ * @param options - Reporter options; only `omitPassingTests` is used
+ * @param projectName - Optional project name for monorepo grouping
+ * @returns Structured report ready for JSON serialization
+ *
+ * @public
+ */
+declare function buildAgentReport(testModules: ReadonlyArray<VitestTestModule>, unhandledErrors: ReadonlyArray<VitestModuleError>, reason: "passed" | "failed" | "interrupted", options: {
+  readonly omitPassingTests?: boolean;
+}, projectName?: string): AgentReport;
+//#endregion
+//#region src/utils/canonicalize-git-url.d.ts
+/**
+ * Canonicalize a git remote URL.
+ *
+ * Returns `null` when the input is empty, whitespace-only, or has
+ * neither a host nor a path after stripping known prefixes.
+ *
+ * Steps applied in order:
+ *
+ * 1. Trim whitespace.
+ * 2. If the value starts with `[git+]ssh|https|http://`, strip the
+ *    scheme. After stripping, drop any embedded `user@` segment.
+ * 3. Otherwise, try the SSH shorthand `user@host:path` pattern; on a
+ *    match, rebuild as `host/path` (drop the user).
+ * 4. Strip trailing `.git`.
+ * 5. Strip trailing `/`.
+ * 6. Lowercase the entire string.
+ * 7. Reject if the result is empty or has no `/` (no path) — a bare
+ *    host like `github.com` is not a project identity.
+ * @public
+ */
+declare const canonicalizeGitUrl: (raw: string) => string | null;
+/**
+ * Convert a (possibly raw) git URL to the filesystem-safe `project_key`
+ * form. The canonical `host/path` is mapped 1:1 to `host__path` so it
+ * can serve as a single path segment under
+ * `$XDG_DATA_HOME/vitest-agent/`.
+ * @public
+ */
+declare const gitUrlToProjectKey: (raw: string) => string | null;
+//#endregion
+//#region src/utils/classify-test.d.ts
+/**
+ * Classify a test based on its current state and prior run history.
+ *
+ * @param current - The test's state in the current run
+ * @param priorRuns - Previous runs (most recent first), before the current run was prepended
+ * @returns The test's classification
+ * @public
+ */
+declare function classifyTest(current: "passed" | "failed", priorRuns: ReadonlyArray<{
+  state: string;
+}>): TestClassification;
+//#endregion
+//#region src/utils/compress-lines.d.ts
+/**
+ * Compress an array of line numbers into a compact range string.
+ *
+ * Consecutive line numbers are collapsed into `start-end` ranges,
+ * separated by commas. Duplicate values are removed and the input
+ * is sorted ascending before processing.
+ *
+ * @param lines - Array of line numbers to compress
+ * @returns Compressed range string, or empty string for empty input
+ *
+ * @example
+ * ```typescript
+ * import { compressLines } from "@vitest-agent/sdk/utils";
+ *
+ * compressLines([1, 2, 3, 5, 10, 11, 12]);
+ * // Returns: "1-3,5,10-12"
+ *
+ * compressLines([42]);
+ * // Returns: "42"
+ *
+ * compressLines([]);
+ * // Returns: ""
+ * ```
+ *
+ * @public
+ */
+declare function compressLines(lines: number[]): string;
+//#endregion
+//#region src/utils/compute-trend.d.ts
+/**
+ * Hash resolved targets to detect configuration changes.
+ *
+ * Note: JSON.stringify is order-sensitive, but resolveThresholds()
+ * always produces keys in METRIC_KEYS iteration order, so the hash
+ * is stable for the same logical configuration.
+ * @public
+ */
+declare function hashTargets(targets: ResolvedThresholds | undefined): string | undefined;
+/**
+ * Compute a new trend entry and return the updated trend record.
+ *
+ * If targets have changed (different hash), the trend history is
+ * cleared and the new entry becomes the first data point.
+ * @public
+ */
+declare function computeTrend(current: CoverageTotals, existing: TrendRecord | undefined, targets: ResolvedThresholds | undefined): TrendRecord;
+/**
+ * Get the overall direction from recent entries.
+ * @public
+ */
+declare function getRecentDirection(record: TrendRecord, count?: number): {
+  direction: "improving" | "regressing" | "stable";
+  runCount: number;
+};
+//#endregion
+//#region src/utils/detect-pm.d.ts
+/**
+ * Filesystem abstraction for package manager detection.
+ *
+ * @remarks
+ * This interface allows dependency injection for testability. In production,
+ * pass an adapter backed by `node:fs/promises`. In tests, provide a mock
+ * implementation.
+ *
+ * @example
+ * ```typescript
+ * import type { FileSystemAdapter } from "@vitest-agent/sdk/detect-pm";
+ * import { readFile, access } from "node:fs/promises";
+ *
+ * const fsAdapter: FileSystemAdapter = {
+ *   readFile: (path: string) => readFile(path, "utf-8"),
+ *   exists: async (path: string) => {
+ *     try {
+ *       await access(path);
+ *       return true;
+ *     } catch {
+ *       return false;
+ *     }
+ *   },
+ * };
+ * ```
+ *
+ * @internal
+ */
+interface FileSystemAdapter {
+  readFile(path: string): Promise<string>;
+  exists(path: string): Promise<boolean>;
+}
+/**
+ * Detect the package manager used in a project by inspecting the root directory.
+ *
+ * @remarks
+ * Detection order:
+ * 1. The `packageManager` field in `package.json` (e.g., `"pnpm\@10.32.1"`)
+ * 2. Lockfile presence: `pnpm-lock.yaml`, `package-lock.json`, `yarn.lock`, `bun.lock`
+ *
+ * Returns `null` when no package manager can be determined.
+ *
+ * @param root - Absolute path to the project root directory
+ * @param fs - Filesystem adapter for reading files and checking existence
+ * @returns The detected package manager, or `null`
+ *
+ * @internal
+ */
+declare function detectPackageManager(root: string, fs: FileSystemAdapter): Promise<PackageManager | null>;
+/**
+ * Return the vitest run command for the given package manager.
+ *
+ * Falls back to `"npx vitest run"` when `pm` is `null`.
+ *
+ * @param pm - Detected package manager, or `null` for unknown
+ * @returns Shell command string for running vitest
+ *
+ * @internal
+ */
+declare function getRunCommand(pm: PackageManager | null): string;
+//#endregion
+//#region src/utils/detect-timeout.d.ts
+/**
+ * True when the error looks like a Vitest test or hook timeout. Either
+ * the message matches "timed out in Nms" or the error name contains
+ * "timeout".
+ * @public
+ */
+declare const isTimeoutError: (error: {
+  message?: string;
+  name?: string;
+}) => boolean;
+//#endregion
+//#region src/utils/ensure-migrated.d.ts
+/**
+ * Ensure the SQLite database at `dbPath` is migrated. Runs migrations at
+ * most once per dbPath in the current process; concurrent calls share the
+ * same in-flight promise. Subsequent calls (after the first resolves) are
+ * no-ops.
+ * @public
+ */
+declare function ensureMigrated(dbPath: string, logLevel?: LogLevel.LogLevel, logFile?: string): Promise<void>;
+/**
+ * Reset the migration cache. Test-only.
+ *
+ * @internal
+ */
+declare function _resetMigrationCacheForTesting(): void;
+//#endregion
+//#region src/utils/failure-signature.d.ts
+/** @public */
+interface FailureSignatureInput {
+  readonly error_name: string;
+  readonly assertion_message: string;
+  readonly top_frame_function_name: string;
+  readonly top_frame_function_boundary_line: number | null;
+  readonly top_frame_raw_line?: number;
+}
+/** @public */
+declare const normalizeAssertionShape: (message: string) => string | null;
+/** @public */
+declare const computeFailureSignature: (input: FailureSignatureInput) => string;
+//#endregion
+//#region src/utils/format-console.d.ts
+/**
+ * Options controlling console markdown output formatting.
+ *
+ * @internal
+ */
+interface ConsoleFormatOptions {
+  /** Output verbosity: `"failures"` (default), `"full"`, or `"silent"`. */
+  consoleOutput: "failures" | "full" | "silent";
+  /** Maximum number of low-coverage files to show in console output. */
+  coverageConsoleLimit: number;
+  /** When `true`, suppress ANSI color codes for valid plain markdown. */
+  noColor: boolean;
+  /** Optional trend summary for tiered coverage output. */
+  trendSummary?: {
+    direction: "improving" | "regressing" | "stable";
+    runCount: number;
+    firstMetric?: {
+      name: string;
+      from: number;
+      to: number;
+      target?: number;
+    };
+  };
+  /** CLI run command prefix for coverage/trends hints (e.g., `"pnpm vitest-agent"`). */
+  runCommand?: string;
+  /** When true, suggest MCP tools instead of CLI commands in Next Steps. */
+  mcp?: boolean;
+}
+/**
+ * Return the metric with the lowest percentage from a `FileCoverageReport`.
+ *
+ * @remarks
+ * Used to surface the single worst coverage metric per file in console output,
+ * keeping the display compact. Labels are abbreviated: `"Stmts"`, `"Branch"`,
+ * `"Funcs"`, `"Lines"`.
+ *
+ * @param f - File coverage report to analyze
+ * @returns Object with `label` and `pct` of the worst metric
+ *
+ * @internal
+ */
+declare function getWorstMetric(f: FileCoverageReport): {
+  label: string;
+  pct: number;
+};
+/**
+ * Strip the working directory prefix from a file path to produce a
+ * project-relative path for display.
+ *
+ * @param filePath - Absolute or relative file path
+ * @param cwd - Working directory to strip; defaults to `process.cwd()`
+ * @returns Project-relative path string
+ *
+ * @internal
+ */
+declare function relativePath(filePath: string, cwd?: string): string;
+/**
+ * Determine the output tier based on test results and coverage state.
+ *
+ * - `"red"` -- failures, unhandled errors, or files below threshold
+ * - `"yellow"` -- all tests pass but coverage targets exist (room to improve)
+ * - `"green"` -- all tests pass, all coverage targets met
+ *
+ * @internal
+ */
+declare function determineTier(report: AgentReport): "green" | "yellow" | "red";
+/**
+ * Format an {@link (AgentReport:variable)} as compact, actionable console markdown.
+ *
+ * @remarks
+ * The output is structured for LLM agent consumption with four sections:
+ *
+ * 1. **Compact header** with pass/fail counts and duration
+ * 2. **Failed test details** with error messages and diffs (the core value)
+ * 3. **Coverage gaps** showing only files below threshold, worst metric first
+ * 4. **Next steps** with re-run commands and cache file pointer
+ *
+ * When all tests pass, the output collapses to a single success line
+ * with an optional cache file reference.
+ *
+ * Returns an empty string when `consoleOutput` is `"silent"`.
+ *
+ * @param report - The report to format
+ * @param options - Formatting options controlling verbosity and color
+ * @returns Formatted markdown string, or empty string for silent mode
+ *
+ * @internal
+ */
+declare function formatConsoleMarkdown(report: AgentReport, options: ConsoleFormatOptions): string;
+//#endregion
+//#region src/utils/format-fatal-error.d.ts
+/**
+ * Format an unknown error into a human-readable string with issue URL.
+ *
+ * Extraction order:
+ * 1. Effect Cause — use `Cause.pretty()` for full formatting
+ * 2. Effect FiberFailure — extract Cause and use `Cause.pretty()`
+ * 3. Plain Error — extract `.message` and `.stack`
+ * 4. Unknown — `String(err)`
+ *
+ * @public
+ */
+declare function formatFatalError(err: unknown): string;
+//#endregion
+//#region src/utils/format-gfm.d.ts
+/**
+ * Format one or more {@link (AgentReport:variable) | AgentReports} as a GitHub-Flavored
+ * Markdown string for writing to `GITHUB_STEP_SUMMARY`.
+ *
+ * @remarks
+ * GFM-specific features used in the output:
+ *
+ * - **Summary table** with pass/fail counts across all projects
+ * - **Collapsible `<details>` blocks** for per-project results in monorepo setups
+ * - **Tables** for coverage metrics
+ * - **Diff-fenced code blocks** for expected/received comparison output
+ * - **GitHub Alert callouts** (`[!WARNING]`) for coverage threshold violations
+ *
+ * For a single report, the project body is rendered directly without
+ * a `<details>` wrapper. For multiple reports (monorepo), each project
+ * gets its own collapsible section with a status icon in the summary line.
+ *
+ * @param reports - One or more agent reports to format
+ * @returns GFM-formatted string ready for appending to `GITHUB_STEP_SUMMARY`
+ *
+ * @public
+ */
+declare function formatGfm(reports: AgentReport[]): string;
+//#endregion
+//#region src/utils/function-boundary.d.ts
+/** @public */
+interface FunctionBoundary {
+  readonly line: number;
+  readonly name: string;
+}
+/**
+ * Parse `source` (JavaScript or TypeScript, via `acorn` + `acorn-typescript`)
+ * and return the smallest enclosing function's start line and name for `line`.
+ *
+ * Returns `null` only when the parser rejects the source outright (rare —
+ * usually a syntax error). Type annotations, generics, decorators, and `as`
+ * casts are all accepted.
+ * @public
+ */
+declare const findFunctionBoundary: (source: string, line: number) => FunctionBoundary | null;
+//#endregion
+//#region src/utils/hyperlink.d.ts
+/** @public */
+interface Osc8Options {
+  readonly enabled: boolean;
+}
+/** @public */
+declare const osc8: (url: string, label: string, options: Osc8Options) => string;
+//#endregion
+//#region src/utils/match-vitest-command.d.ts
+/**
+ * Return `true` if the command invokes Vitest in any of the five
+ * supported shapes. The `vitestScripts` set carries the names of
+ * package.json scripts that were detected as containing `vitest`
+ * (computed once per project and cached by the sidecar).
+ * @public
+ */
+declare const isVitestInvocation: (command: string, vitestScripts: ReadonlySet<string>) => boolean;
+/**
+ * Build the env-var prefix string to prepend to a matched command.
+ *
+ * Returns the assignments in the documented order:
+ *   `VITEST_AGENT_CONVERSATION_ID=<uuid> VITEST_AGENT_AGENT_ID=<uuid> [VITEST_AGENT_PARENT_AGENT_ID=<uuid>]`
+ *
+ * POSIX env-prefix syntax scopes the assignments to the
+ * immediately-following process — no sticky-env across subsequent
+ * Bash calls, no risk of cross-contamination.
+ * @public
+ */
+declare const buildEnvPrefix: (input: {
+  readonly conversationId: string;
+  readonly agentId: string;
+  readonly parentAgentId?: string;
+}) => string;
+/**
+ * Compute the rewritten command for a Bash tool invocation. When the
+ * command does not match a Vitest shape, returns the original
+ * unchanged. When it matches, prepends the env prefix.
+ * @public
+ */
+declare const rewriteBashCommand: (input: {
+  readonly command: string;
+  readonly vitestScripts: ReadonlySet<string>;
+  readonly conversationId: string;
+  readonly agentId: string;
+  readonly parentAgentId?: string;
+}) => string;
+/**
+ * Detect which package.json scripts invoke Vitest by inspecting the
+ * `scripts` field. Resolves one hop of script reference (e.g.,
+ * `"test": "pnpm test:unit && pnpm test:int"` finds vitest if either
+ * `test:unit` or `test:int` mentions vitest). Multi-hop indirection
+ * is a documented limitation.
+ * @public
+ */
+declare const detectVitestScripts: (scripts: Record<string, string>) => Set<string>;
+//#endregion
+//#region src/utils/normalize-workspace-key.d.ts
+/**
+ * Normalize a workspace name into a filesystem-safe directory segment.
+ *
+ * The workspace key drives the per-project subdirectory under the XDG data
+ * directory (e.g. `$XDG_DATA_HOME/vitest-agent/<key>/data.db`). The
+ * key must be deterministic for a given input and safe to use as a single
+ * path segment on macOS, Linux, and Windows.
+ *
+ * Rules (applied in order):
+ *
+ * 1. Replace `/` with `__` so scoped names like `@org/pkg` collapse to
+ *    `@org__pkg` rather than introducing a subdirectory boundary. Scoped
+ *    npm names contain at most one `/` (between scope and name), and
+ *    leading-`@` requires the scope/name form, so `@org__pkg` is not a
+ *    valid unscoped npm name -- the `__` token is unambiguous in
+ *    practice.
+ * 2. Replace any character outside `[A-Za-z0-9._@-]` with `_`. This catches
+ *    Windows-reserved characters (`\`, `:`, `*`, `?`, `"`, `<`, `>`, `|`),
+ *    control characters, whitespace, and anything else that varies in
+ *    interpretation across filesystems.
+ * 3. Collapse runs of underscores produced by the substitution above into a
+ *    single `_` so the output stays compact.
+ *
+ * @param name - The raw `name` field from a workspace's `package.json`.
+ * @returns A filesystem-safe single path segment.
+ * @public
+ */
+declare function normalizeWorkspaceKey(name: string): string;
+//#endregion
+//#region src/utils/probe-host-metadata.d.ts
+/** @public */
+interface HostMetadataResult {
+  readonly source: string | null;
+  readonly value: string | null;
+  readonly metadata: Record<string, unknown> | null;
+}
+/**
+ * Walk the priority chain of env-var probes. Returns the first match
+ * along with any decorating metadata (`term_program`, `ci_provider`,
+ * etc.) for that source. When no probe matches, `source`/`value`/
+ * `metadata` are all `null`.
+ *
+ * The probe order matches the plan's table exactly:
+ *
+ * 1. `TMUX_PANE` (tmux reattach-stable)
+ * 2. `WT_SESSION` (Windows Terminal pane)
+ * 3. `WEZTERM_PANE` (WezTerm pane)
+ * 4. `KITTY_WINDOW_ID` (kitty window)
+ * 5. `TERM_SESSION_ID` (iTerm2, Terminal.app)
+ * 6. `VSCODE_INJECTION` + `process.ppid` (handled by the Live layer
+ *    since it needs `process.ppid`, not env)
+ * 7. `GITHUB_RUN_ID` + `GITHUB_RUN_ATTEMPT`
+ * 8. `BUILDKITE_JOB_ID` / `CIRCLE_BUILD_NUM` / `GITLAB_CI_JOB_ID`
+ * 9. `process.ppid` walk (handled by the Live layer)
+ * @public
+ */
+declare const probeHostMetadataFromEnv: (env: Record<string, string | undefined>) => HostMetadataResult;
+//#endregion
+//#region src/utils/resolve-data-path.d.ts
+/**
+ * Filename of the SQLite database that stores all reporter data.
+ * @public
+ */
+declare const DATABASE_FILENAME = "data.db";
+/**
+ * Caller-supplied overrides for `resolveDataPath`.
+ * @public
+ */
+interface ResolveDataPathOptions {
+  /**
+   * Programmatic override for the entire data directory. Highest precedence.
+   *
+   * Use this when the reporter or plugin user has explicitly set
+   * `reporter.cacheDir`. The returned path is `<cacheDir>/data.db`.
+   */
+  readonly cacheDir?: string;
+}
+/**
+ * Resolve the absolute path to the SQLite database for `projectDir`.
+ *
+ * The directory containing the database is ensured to exist before the
+ * function returns, so callers can open the database immediately without
+ * needing to create parent directories. better-sqlite3 creates the file but
+ * not its parent.
+ *
+ * Precedence (highest first):
+ *
+ * 1. `options.cacheDir` — programmatic override.
+ * 2. `cacheDir` from `vitest-agent.config.toml`.
+ * 3. `<XDG data>/<normalized projectKey from config>/data.db`.
+ * 4. `<XDG data>/<projectKey resolved from cwd's package.json>/data.db`.
+ *    Source 4 prefers `repository.url` (canonicalized to `host__path`),
+ *    falling back to the normalized `name`. This matches the sidecar
+ *    CLI's `_internal register-agent` resolver so the reporter and
+ *    sidecar always write to the same `data.db`.
+ *
+ * The XDG data directory is namespaced via `AppDirs` (typically
+ * `$XDG_DATA_HOME/vitest-agent`, defaulting to
+ * `~/.local/share/vitest-agent`).
+ *
+ * The path is a function of identity, not filesystem layout. When no
+ * `package.json` is reachable from `projectDir`, the cwd basename is used
+ * as the final fallback so the function never throws on identity lookup.
+ *
+ * @param projectDir - Absolute path inside the user's workspace.
+ * @param options - Optional programmatic overrides.
+ * @public
+ */
+declare const resolveDataPath: (projectDir: string, options?: ResolveDataPathOptions) => Effect.Effect<any, import("config-file-effect").ConfigError | import("xdg-effect").AppDirsError, import("config-file-effect").ConfigFileService<VitestAgentConfig> | AppDirs>;
+//#endregion
+//#region src/utils/resolve-project-key-from-cwd.d.ts
+/**
+ * Compute the project key for a workspace by reading `package.json`
+ * fields directly. Returns the canonical `host__path` form when a git
+ * remote URL is present, otherwise the normalized package name.
+ *
+ * Always returns a non-empty string — falls back to the cwd basename
+ * (or `"anonymous-project"`) so callers don't have to handle the
+ * empty case.
+ * @public
+ */
+declare const resolveProjectKeyFromCwd: (cwd: string) => string;
+//#endregion
+//#region src/utils/resolve-workspace-key.d.ts
+/**
+ * Resolve the normalized workspace key for the workspace containing
+ * `projectDir`.
+ *
+ * The key is the root `package.json`'s `name`, normalized via
+ * `normalizeWorkspaceKey`. This becomes the directory segment under
+ * `$XDG_DATA_HOME/vitest-agent/` where the SQLite database lives.
+ *
+ * Fails with `WorkspaceRootNotFoundError` when no root workspace is
+ * discoverable from `projectDir`. `WorkspacePackage.name` is enforced
+ * non-empty by `workspaces-effect`'s schema, so a successful root lookup
+ * always yields a usable name.
+ *
+ * @param projectDir - Absolute path inside the workspace. Typically the
+ *   reporter's resolved `projectDir` (CLAUDE_PROJECT_DIR or process.cwd()).
+ * @public
+ */
+declare const resolveWorkspaceKey: (projectDir: string) => Effect.Effect<string, WorkspaceRootNotFoundError | WorkspaceDiscoveryError, WorkspaceDiscovery>;
+//#endregion
+//#region src/utils/safe-filename.d.ts
+/**
+ * Convert a project name to a filesystem-safe filename.
+ *
+ * Replaces `/` and `:` characters with `__` (double underscore).
+ * Returns `"default"` for empty strings, which is used as the
+ * fallback project name for single-repo configurations.
+ *
+ * @param name - Project name to sanitize
+ * @returns Filesystem-safe filename string
+ *
+ * @example
+ * ```typescript
+ * import { safeFilename } from "@vitest-agent/sdk/utils";
+ *
+ * safeFilename("\@savvy-web/my-lib:unit");
+ * // Returns: "\@savvy-web__my-lib__unit"
+ *
+ * safeFilename("core");
+ * // Returns: "core"
+ *
+ * safeFilename("");
+ * // Returns: "default"
+ * ```
+ *
+ * @public
+ */
+declare function safeFilename(name: string): string;
+//#endregion
+//#region src/utils/validate-coverage-targets-shape.d.ts
+/** @public */
+interface CoverageTargetsShapeError {
+  readonly code: string;
+  readonly path: string;
+  readonly message: string;
+}
+/** @public */
+interface CoverageTargetsShapeWarning {
+  readonly code: string;
+  readonly path: string;
+  readonly message: string;
+}
+/** @public */
+interface CoverageTargetsShapeInfo {
+  readonly code: string;
+  readonly message: string;
+}
+/** @public */
+interface CoverageTargetsShapeResult {
+  readonly errors: ReadonlyArray<CoverageTargetsShapeError>;
+  readonly warnings: ReadonlyArray<CoverageTargetsShapeWarning>;
+  readonly info: ReadonlyArray<CoverageTargetsShapeInfo>;
+}
+/**
+ * Validates the shape of a raw coverageTargets value, producing structured
+ * diagnostic entries. This is a pure function with no Effect or I/O.
+ *
+ * Codes emitted:
+ * - `INVALID_TARGET_VALUE` — a numeric metric value is zero or negative,
+ *   OR a literal `true` appears at any key other than `"100"`. The
+ *   offending `path` is included (e.g. `"lines"`, `"src/**.ts.lines"`,
+ *   or `"statements"` when misused as a boolean shortcut).
+ * - `PERFILE_ON_TARGETS` — the `perFile` key appears inside coverageTargets;
+ *   it should be set on `coverage.thresholds.perFile` instead.
+ *
+ * @param input - The raw value passed as coverageTargets.
+ * @returns A result object with errors, warnings, and info arrays.
+ * @public
+ */
+declare function validateCoverageTargetsShape(input: unknown): CoverageTargetsShapeResult;
+//#endregion
+//#region src/index.d.ts
+/**
+ * The version of this package. Inlined at build time from
+ * package.json#version via rslib-builder's __PACKAGE_VERSION__ substitution.
+ * Source-level reads (workspace `exports: "./src/index.ts"` during dev)
+ * see the `"0.0.0"` fallback — a clear signal the build pipeline has not
+ * substituted yet. Read by the plugin / MCP / CLI init-time drift check.
+ * See the root CLAUDE.md "Cross-package version drift" section.
+ * @public
+ */
+declare const CURRENT_SDK_VERSION: string;
+//#endregion
+export { AcceptanceMetrics, ActionSeverity, ActorType, Agent, AgentConsoleMode, AgentContext, AgentId, AgentNotFoundError, AgentPluginOptions, AgentReport, AgentReporterOptions, AgentTreeNode, AnsiOptions, ArtifactKind, AssembledHistoryRecord, AssociateRunSessionInput, BehaviorAbandonedEvent, BehaviorAddedEvent, BehaviorCompletedEvent, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorScopedEventType, BehaviorScopedEventTypes, BehaviorStartedEvent, BehaviorStatus, BehaviorsReadyEvent, BlockedEvent, CURRENT_SDK_VERSION, CacheManifest, CacheManifestEntry, CandidateContext, CellOptions, ChangeKind, ChannelEvent, ChatId, CiConsoleMode, CitedArtifact, CitedArtifactRow, CommitChangesEntry, ConfigLive, ConsoleFormatOptions, ConsoleLogLevel, ConsoleMode, ConsoleOutputMode, ConsoleOutputs, ConversationId, ConversationNotFoundError, CoverageBaselines, FileCoverageReport as CoverageFile, FileCoverageReport, CoverageGap, CoverageInput, CoverageLevel, CoverageLevelName, CoverageMetric, CoverageRenderState, CoverageReport, CoverageTargets, CoverageTargetsMetrics, CoverageTargetsShapeError, CoverageTargetsShapeInfo, CoverageTargetsShapeResult, CoverageTargetsShapeWarning, CoverageTotals, CreateBehaviorInput, CreateGoalInput, CurrentTddPhase, DATABASE_FILENAME, DataReader, DataReaderLive, DataStore, DataStoreError, DataStoreLive, DenialReason, DetailLevel, DetailResolver, DetailResolverLive, DiscoveryError, DiscoveryRegistry, DiscoveryRegistryLive, DispatchInputs, EndTddTaskInput, Environment, EnvironmentDetector, EnvironmentDetectorLive, EnvironmentDetectorTest, Executor, ExecutorResolver, ExecutorResolverLive, FailureRecord, FailureSignatureDetail, FailureSignatureInput, FailureSignatureWriteInput, FileCoverageInput, FileEditPayload, FileSystemAdapter, FlakyTest, FormatSelector, FormatSelectorLive, type FormatTriageOptions, type FormatWrapupOptions, Formatter, FormatterContext, FunctionBoundary, GfmFormatter, GitCommandError, GoalAbandonedEvent, GoalAddedEvent, GoalCompletedEvent, GoalDetail, GoalNotFoundError, GoalRow, GoalStartedEvent, GoalStatus, GoalsReadyEvent, HistoryRecord, HistoryRow, HistoryTracker, HistoryTrackerLive, HistoryTrackerTest, HistoryTrackerTestState, HookFirePayload, HookStatus, HookType, HostKind, HostMetadataParseError, HostMetadataResult, HumanConsoleMode, HypothesisDetail, HypothesisInput, HypothesisPayload, IDEMPOTENCY_ROOT_SENTINEL, IdempotencyHit, IdempotencyInput, IdempotentResponseInput, IllegalStatusTransitionEntity, IllegalStatusTransitionError, JsonFormatter, KnownProject, KnownProjectInput, LoggerLive, ManifestRow, MapSessionInput, MapSessionOutput, MarkdownFormatter, MetricThresholds, ModuleInput, ModuleListEntry, ModuleRecord, ModuleReport, NoteInput, NotePayload, NoteRow, Osc8Options, OutputFormat, OutputPipelineLive, OutputRenderer, OutputRendererLive, PackageManager, PathResolutionError, PathResolutionLive, PatternThresholds, PerClientSessionMapReader, PerClientSessionMapReaderLive, PerClientSessionMapWriter, PerClientSessionMapWriterLive, PersistentFailure, Phase, PhaseTransitionContext, PhaseTransitionEvent, PhaseTransitionResult, ProbeMissError, ProjectDiscovery, ProjectDiscoveryLive, ProjectDiscoveryTest, ProjectIdentity, ProjectIdentityCandidate, ProjectIdentityCandidates, ProjectIdentityLive, ProjectIdentityNotResolvableError, ProjectIdentitySource, ProjectIdentityTest, ProjectKey, ProjectRunSummary, ProjectSummary, RegisterAgentInput, RegisterAgentResult, RegistrationConflictError, Remediation, RenderState, RenderTotals, RenderedOutput, ReportError, ReportSummary, ReporterKit, ReporterRenderInput, ResolveDataPathOptions, ResolveProjectIdentityOptions, ResolvedIdentity, ResolvedReporterConfig, ResolvedThresholds, RunChangedFile, RunContext, RunContext$, RunContextLive, RunContextService, RunContextTest, RunEvent, RunEventByTag, RunHealth, RunInvocationMethod, RunOutcome, RunShape, SessionCompleteEvent, SessionContextRow, SessionDetail, SessionInput, SessionNotFoundError, SessionOutcome, SettingsInput, SettingsListEntry, SettingsRow, SidecarTimeoutError, SilentFormatter, StackFrameInput, SuggestedActionRecord, SuiteInput, SuiteListEntry, TagCountEntry, TagInventoryRow, TddArtifactDetail, TddArtifactRow, TddPhaseDetail, TddTaskAlreadyEndedError, TddTaskDetail, TddTaskEndOutcome, TddTaskId, TddTaskInput, TddTaskNotFoundError, TddTaskSummary, TerminalFormatter, TestCaseInput, TestClassification, TestError, TestErrorInput, TestFileEntry, TestHistory, TestListEntry, TestOutcome, TestRecord, TestReport, TestRun, TestRunInput, TestRunReason, TestState, ToolCallPayload, ToolResultPayload, Transport, TrendEntry, TrendRecord, TrendSummary, TurnInput, TurnPayload, TurnSearchOptions, TurnSummary, UpdateBehaviorInput, UpdateGoalInput, UserPromptPayload, ValidateHypothesisInput, VitestAgentConfig, VitestAgentConfigFile, VitestAgentConfigFileService, VitestAgentReporter, VitestAgentReporterFactory, VitestModuleDiagnostic, VitestModuleError, VitestParsedStack, VitestTestCase, VitestTestDiagnostic, VitestTestError, VitestTestModule, VitestTestResult, VitestTestSuite, type WrapupKind, WriteCommitInput, WriteRunChangedFilesInput, WriteTddArtifactInput, WriteTddPhaseInput, WriteTddPhaseOutput, _resetMigrationCacheForTesting, ansi, assembleHistoryRecord, assembleManifest, buildAgentReport, buildEnvPrefix, canonicalizeGitUrl, ciAnnotationsFormatter, classifyTest, compressLines, computeFailureSignature, computeTrend, deriveIdempotencyKey, detectPackageManager, detectVitestScripts, determineTier, ensureMigrated, extractSqlReason, findFunctionBoundary, formatConsoleMarkdown, formatFatalError, formatGfm, formatTriageEffect, formatWrapupEffect, getRecentDirection, getRunCommand, getWorstMetric, gitUrlToProjectKey, hashTargets, initialRenderState, isTimeoutError, isVitestInvocation, migration as migration0001, normalizeAssertionShape, normalizeWorkspaceKey, osc8, probeHostMetadataFromEnv, migration$1 as registryMigration0001, relativePath, requiredArtifactForTransition, resolveCoverageInput, resolveDataPath, resolveLogFile, resolveLogLevel, resolveProjectIdentityFromCandidates, resolveProjectKeyFromCwd, resolveWorkspaceKey, rewriteBashCommand, safeFilename, migration$2 as sessionMapMigration0001, stripAnsi, validateCoverageConfig, validateCoverageTargetsShape, validatePhaseTransition };
+//# sourceMappingURL=index.d.ts.map