@vitest-agent/sdk 1.0.1 → 1.2.0

package/index.d.ts

@@ -1,4 +1,3 @@
-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";
@@ -6,6 +5,124 @@ import { SqlClient } from "@effect/sql/SqlClient";
 import { WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceRootNotFoundError } from "workspaces-effect";
 import { AppDirs } from "xdg-effect";
 
+//#region src/schemas/Coverage.d.ts
+/**
+ * Aggregate coverage percentages across four istanbul metrics.
+ * @public
+ */
+declare const CoverageTotals: Schema.Struct<{
+  statements: typeof Schema.Number;
+  branches: typeof Schema.Number;
+  functions: typeof Schema.Number;
+  lines: typeof Schema.Number;
+}>;
+/** @public */
+type CoverageTotals = typeof CoverageTotals.Type;
+/**
+ * Per-file coverage data including uncovered line ranges.
+ * @public
+ */
+declare const FileCoverageReport: Schema.Struct<{
+  file: typeof Schema.String;
+  summary: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  uncoveredLines: typeof Schema.String;
+}>;
+/** @public */
+type FileCoverageReport = typeof FileCoverageReport.Type;
+/**
+ * Complete coverage report attached to an AgentReport.
+ * @public
+ */
+declare const CoverageReport: Schema.Struct<{
+  totals: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: 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>;
+    }>;
+    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[];
+    }>;
+  }>;
+  targets: Schema.optional<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>;
+    }>;
+    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[];
+    }>;
+  }>>;
+  baselines: Schema.optional<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>;
+    }>;
+    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[];
+    }>;
+  }>>;
+  scoped: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+  }>;
+  scopedFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+  lowCoverage: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    summary: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: typeof Schema.String;
+  }>>;
+  lowCoverageFiles: Schema.Array$<typeof Schema.String>;
+  belowTarget: Schema.optional<Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    summary: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: typeof Schema.String;
+  }>>>;
+  belowTargetFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+/** @public */
+type CoverageReport = typeof CoverageReport.Type;
+//#endregion
 //#region src/schemas/RenderState.d.ts
 /**
  * Per-test record accumulated as `TestStarted` / `TestFinished` events arrive.
@@ -400,6 +517,240 @@ interface CellOptions {
   readonly osc8: (url: string, label: string) => string;
 }
 //#endregion
+//#region src/schemas/AgentReport.d.ts
+/**
+ * Aggregate test run statistics.
+ * @public
+ */
+declare const ReportSummary: Schema.Struct<{
+  total: typeof Schema.Number;
+  passed: typeof Schema.Number;
+  failed: typeof Schema.Number;
+  skipped: typeof Schema.Number;
+  duration: typeof Schema.Number;
+}>;
+/** @public */
+type ReportSummary = typeof ReportSummary.Type;
+/**
+ * An individual test case result.
+ * @public
+ */
+declare const TestReport: Schema.Struct<{
+  name: typeof Schema.String;
+  fullName: typeof Schema.String;
+  state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+  duration: Schema.optional<typeof Schema.Number>;
+  flaky: Schema.optional<typeof Schema.Boolean>;
+  slow: Schema.optional<typeof Schema.Boolean>;
+  errors: Schema.optional<Schema.Array$<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>;
+  }>>>;
+  classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+}>;
+/** @public */
+type TestReport = typeof TestReport.Type;
+/**
+ * A test module (file) and its contained test cases.
+ * @public
+ */
+declare const ModuleReport: Schema.Struct<{
+  file: typeof Schema.String;
+  state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+  duration: Schema.optional<typeof Schema.Number>;
+  errors: Schema.optional<Schema.Array$<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>;
+  }>>>;
+  tests: Schema.Array$<Schema.Struct<{
+    name: typeof Schema.String;
+    fullName: typeof Schema.String;
+    state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+    duration: Schema.optional<typeof Schema.Number>;
+    flaky: Schema.optional<typeof Schema.Boolean>;
+    slow: Schema.optional<typeof Schema.Boolean>;
+    errors: Schema.optional<Schema.Array$<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>;
+    }>>>;
+    classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+  }>>;
+}>;
+/** @public */
+type ModuleReport = typeof ModuleReport.Type;
+/**
+ * Per-tag pass/fail/skip aggregates for a single project run.
+ * @public
+ */
+declare const TagCountEntry: Schema.Struct<{
+  passed: Schema.optional<typeof Schema.Number>;
+  failed: Schema.optional<typeof Schema.Number>;
+  skipped: Schema.optional<typeof Schema.Number>;
+}>;
+/** @public */
+type TagCountEntry = typeof TagCountEntry.Type;
+/**
+ * Complete per-project test report written to disk as JSON.
+ * @public
+ */
+declare const AgentReport: Schema.Struct<{
+  timestamp: typeof Schema.String;
+  project: Schema.optional<typeof Schema.String>;
+  reason: Schema.Literal<["passed", "failed", "interrupted"]>;
+  summary: Schema.Struct<{
+    total: typeof Schema.Number;
+    passed: typeof Schema.Number;
+    failed: typeof Schema.Number;
+    skipped: typeof Schema.Number;
+    duration: typeof Schema.Number;
+  }>;
+  failed: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+    duration: Schema.optional<typeof Schema.Number>;
+    errors: Schema.optional<Schema.Array$<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>;
+    }>>>;
+    tests: Schema.Array$<Schema.Struct<{
+      name: typeof Schema.String;
+      fullName: typeof Schema.String;
+      state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+      duration: Schema.optional<typeof Schema.Number>;
+      flaky: Schema.optional<typeof Schema.Boolean>;
+      slow: Schema.optional<typeof Schema.Boolean>;
+      errors: Schema.optional<Schema.Array$<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>;
+      }>>>;
+      classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+    }>>;
+  }>>;
+  unhandledErrors: Schema.Array$<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>;
+  }>>;
+  failedFiles: Schema.Array$<typeof Schema.String>;
+  coverage: Schema.optional<Schema.Struct<{
+    totals: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: 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>;
+      }>;
+      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[];
+      }>;
+    }>;
+    targets: Schema.optional<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>;
+      }>;
+      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[];
+      }>;
+    }>>;
+    baselines: Schema.optional<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>;
+      }>;
+      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[];
+      }>;
+    }>>;
+    scoped: Schema.optionalWith<typeof Schema.Boolean, {
+      default: () => false;
+    }>;
+    scopedFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    lowCoverage: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>;
+    lowCoverageFiles: Schema.Array$<typeof Schema.String>;
+    belowTarget: Schema.optional<Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>>;
+    belowTargetFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+  }>>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    passed: Schema.optional<typeof Schema.Number>;
+    failed: Schema.optional<typeof Schema.Number>;
+    skipped: Schema.optional<typeof Schema.Number>;
+  }>>>;
+  consoleLeaks: Schema.optional<Schema.Struct<{
+    total: typeof Schema.Number;
+    byFile: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      stdout: typeof Schema.Number;
+      stderr: typeof Schema.Number;
+      tests: Schema.optional<Schema.Array$<typeof Schema.String>>;
+      sample: Schema.optional<typeof Schema.String>;
+    }>>;
+    truncated: Schema.optional<typeof Schema.Boolean>;
+  }>>;
+}>;
+/** @public */
+type AgentReport = typeof AgentReport.Type;
+//#endregion
 //#region src/schemas/Common.d.ts
 /**
  * Possible states for an individual test case.
@@ -1021,52 +1372,239 @@ interface VitestAgentReporter {
  */
 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";
+//#region src/schemas/Identity.d.ts
+/**
+ * Canonical UUID for an LLM agent invocation. Generated server-side at
+ * `register_agent` time. Stable across transport reconnects within an
+ * agent's lifetime.
+ * @public
+ */
+declare const AgentId: Schema.brand<typeof Schema.UUID, "AgentId">;
+/** @public */
+type AgentId = Schema.Schema.Type<typeof AgentId>;
+/**
+ * The unit "all work on this feature" rolls up to. Survives
+ * `claude --resume` and parallel windows; lives in the host's
+ * transcript filename for Claude Code.
+ * @public
+ */
+declare const ConversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
+/** @public */
+type ConversationId = Schema.Schema.Type<typeof ConversationId>;
+/**
+ * The agent host process's chat id (Claude Code's per-process chat
+ * UUID, etc.). Shorter-lived than a conversation; one conversation can
+ * have multiple chats across `--resume` invocations. Distinct from
+ * `sessions.id` (the SQLite agent-run PK).
+ * @public
+ */
+declare const ChatId: Schema.brand<typeof Schema.UUID, "ChatId">;
+/** @public */
+type ChatId = Schema.Schema.Type<typeof ChatId>;
+/**
+ * One TDD orchestration task. Replaces the legacy `tdd_session_id`
+ * vocabulary so "session" is unambiguous in the codebase.
+ * @public
+ */
+declare const TddTaskId: Schema.brand<typeof Schema.UUID, "TddTaskId">;
+/** @public */
+type TddTaskId = Schema.Schema.Type<typeof TddTaskId>;
+/**
+ * Filesystem-safe key for the per-project data store directory under
+ * `$XDG_DATA_HOME/vitest-agent/<projectKey>/`. Resolved by the
+ * `ProjectIdentity` service from the explicit option / TOML config /
+ * git remote / package.json fallback chain. Always non-empty (a missing
+ * value is `ProjectIdentityNotResolvableError`, not an empty string).
+ * @public
+ */
+declare const ProjectKey: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectKey">;
+/** @public */
+type ProjectKey = Schema.Schema.Type<typeof ProjectKey>;
+/**
+ * Who initiated the action (test run, hypothesis, note, TDD phase, …).
+ * Recorded on every action row alongside `agent_id`.
+ *
+ * - `agent` — an LLM agent (`agent_id` is set, `conversation_id` is set)
+ * - `user`  — a human at a terminal (`agent_id` and `conversation_id` are NULL)
+ * - `system` — a CI run, scheduler, or other non-human/non-agent actor
+ * @public
+ */
+declare const ActorType: Schema.Literal<["agent", "user", "system"]>;
+/** @public */
+type ActorType = typeof ActorType.Type;
+/**
+ * Recommended canonical host identifiers. Open enum at the SDK level so
+ * a new client doesn't require an SDK release; the MCP server defaults
+ * `agentType` validation against the `${hostKind}-` prefix using this
+ * value.
+ *
+ * `unknown` is the explicit fallback when `clientInfo.name` doesn't
+ * match a known pattern — preferred over guessing.
+ * @public
+ */
+declare const HostKind: Schema.Literal<["claude-code", "claude-desktop", "cursor", "goose", "chatgpt", "mcp-inspector", "unknown"]>;
+/** @public */
+type HostKind = typeof HostKind.Type;
+//#endregion
+//#region src/errors/AgentErrors.d.ts
+declare const AgentNotFoundError_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: "AgentNotFoundError";
 } & Readonly<A>;
 /**
- * Error raised when project discovery (glob, file read, or stat) fails.
+ * `agent_id` does not exist for the given chat. Surface to the
+ * caller; the typical resolution is to call `register_agent` for
+ * this agent first.
  * @public
  */
-declare class DiscoveryError extends DiscoveryError_base<{
-  readonly operation: "glob" | "read" | "stat";
-  readonly path: string;
+declare class AgentNotFoundError extends AgentNotFoundError_base<{
+  readonly agentId: AgentId;
+  readonly chatId?: ChatId;
+}> {}
+declare const SessionNotFoundError_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: "SessionNotFoundError";
+} & Readonly<A>;
+/**
+ * Session row for the given `chat_id` does not exist. The host
+ * probably hasn't fired the SessionStart equivalent for this chat yet.
+ * @public
+ */
+declare class SessionNotFoundError extends SessionNotFoundError_base<{
+  readonly chatId: ChatId;
+}> {}
+declare const ConversationNotFoundError_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: "ConversationNotFoundError";
+} & Readonly<A>;
+/**
+ * `conversation_id` does not exist. Used by rollup queries that
+ * require a conversation row.
+ * @public
+ */
+declare class ConversationNotFoundError extends ConversationNotFoundError_base<{
+  readonly conversationId: ConversationId;
+}> {}
+declare const RegistrationConflictError_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: "RegistrationConflictError";
+} & Readonly<A>;
+/**
+ * True conflict — e.g., the `parentAgentId` supplied to
+ * `register_agent` refers to a different session than the one the
+ * caller named. Distinct from `IdempotencyHit`, which is a success.
+ * @public
+ */
+declare class RegistrationConflictError extends RegistrationConflictError_base<{
   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";
+declare const HostMetadataParseError_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: "HostMetadataParseError";
 } & 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.
+ * `host_metadata` JSON column failed to parse on read. Usually mapped
+ * to `DataStoreError` at the row-read boundary; surfaces alone in
+ * paths that explicitly carry through `Schema.parseJson` errors.
  * @public
  */
-declare class PathResolutionError extends PathResolutionError_base<{
+declare class HostMetadataParseError extends HostMetadataParseError_base<{
+  readonly raw: string;
   readonly reason: string;
+}> {}
+declare const SidecarTimeoutError_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: "SidecarTimeoutError";
+} & Readonly<A>;
+/**
+ * Sidecar exceeded its timeout. Surfaces from the sidecar CLI's
+ * `Effect.timeout`; the top-level wrapper maps it to exit code 2.
+ * @public
+ */
+declare class SidecarTimeoutError extends SidecarTimeoutError_base<{
+  readonly operation: string;
+  readonly timeoutMs: number;
 }> {
   constructor(args: {
-    readonly reason: string;
+    readonly operation: string;
+    readonly timeoutMs: number;
   });
 }
 //#endregion
-//#region src/errors/ProjectIdentityError.d.ts
+//#region src/errors/DataStoreError.d.ts
+declare const DataStoreError_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: "DataStoreError";
+} & Readonly<A>;
 /**
- * One source the resolver tried while looking for project identity.
- *
+ * Error raised when a SQLite operation fails at read, write, or migration time.
+ * @public
+ */
+declare class DataStoreError extends DataStoreError_base<{
+  readonly operation: "read" | "write" | "migrate";
+  readonly table: string;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly operation: "read" | "write" | "migrate";
+    readonly table: string;
+    readonly reason: string;
+  });
+}
+/**
+ * Extract a human-readable reason string from an Effect SqlError or unknown error.
+ *
+ * SqlError wraps the underlying better-sqlite3 error in `cause`. The actual SQLite
+ * message (e.g. "SQLITE_BUSY: database is locked", "UNIQUE constraint failed: ...")
+ * lives on `cause.message`, while the SqlError's own `message` is generic
+ * ("Failed to execute statement"). Prefer the cause's message when available.
+ * @public
+ */
+declare const extractSqlReason: (e: unknown) => string;
+//#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
@@ -1122,125 +1660,1417 @@ declare class GitCommandError extends GitCommandError_base<{
     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
+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/errors/TddErrors.d.ts
+declare const GoalNotFoundError_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: "GoalNotFoundError";
+} & Readonly<A>;
+/** @public */
+declare class GoalNotFoundError extends GoalNotFoundError_base<{
+  readonly id: number;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly id: number;
+    readonly reason: string;
+  });
+}
+declare const BehaviorNotFoundError_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: "BehaviorNotFoundError";
+} & Readonly<A>;
+/** @public */
+declare class BehaviorNotFoundError extends BehaviorNotFoundError_base<{
+  readonly id: number;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly id: number;
+    readonly reason: string;
+  });
+}
+declare const TddTaskNotFoundError_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: "TddTaskNotFoundError";
+} & Readonly<A>;
+/** @public */
+declare class TddTaskNotFoundError extends TddTaskNotFoundError_base<{
+  readonly id: number;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly id: number;
+    readonly reason: string;
+  });
+}
+/** @public */
+type TddTaskEndOutcome = "succeeded" | "blocked" | "abandoned";
+declare const TddTaskAlreadyEndedError_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: "TddTaskAlreadyEndedError";
+} & Readonly<A>;
+/** @public */
+declare class TddTaskAlreadyEndedError extends TddTaskAlreadyEndedError_base<{
+  readonly id: number;
+  readonly endedAt: string;
+  readonly outcome: TddTaskEndOutcome;
+}> {
+  constructor(args: {
+    readonly id: number;
+    readonly endedAt: string;
+    readonly outcome: TddTaskEndOutcome;
+  });
+}
+/** @public */
+type IllegalStatusTransitionEntity = "goal" | "behavior" | "task";
+declare const IllegalStatusTransitionError_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: "IllegalStatusTransitionError";
+} & Readonly<A>;
+/** @public */
+declare class IllegalStatusTransitionError extends IllegalStatusTransitionError_base<{
+  readonly entity: IllegalStatusTransitionEntity;
+  readonly id: number;
+  readonly from: string;
+  readonly to: string;
+  readonly reason: string;
+}> {
+  constructor(args: {
+    readonly entity: IllegalStatusTransitionEntity;
+    readonly id: number;
+    readonly from: string;
+    readonly to: string;
+    readonly reason: 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/schemas/Baselines.d.ts
+/**
+ * Coverage baselines -- the auto-ratcheting high-water mark.
+ * @public
+ */
+declare const CoverageBaselines: Schema.Struct<{
+  updatedAt: typeof Schema.String;
+  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>;
+  }>;
+  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 CoverageBaselines = typeof CoverageBaselines.Type;
+//#endregion
+//#region src/schemas/CacheManifest.d.ts
+/**
+ * A single project entry in the cache manifest.
+ * @public
+ */
+declare const CacheManifestEntry: Schema.Struct<{
+  project: typeof Schema.String;
+  reportFile: typeof Schema.String;
+  historyFile: Schema.optional<typeof Schema.String>;
+  lastRun: Schema.NullOr<typeof Schema.String>;
+  lastResult: Schema.NullOr<Schema.Literal<["passed", "failed", "interrupted"]>>;
+}>;
+/** @public */
+type CacheManifestEntry = typeof CacheManifestEntry.Type;
+/**
+ * Root manifest file that indexes all project reports.
+ * @public
+ */
+declare const CacheManifest: Schema.Struct<{
+  updatedAt: typeof Schema.String;
+  cacheDir: typeof Schema.String;
+  projects: Schema.Array$<Schema.Struct<{
+    project: typeof Schema.String;
+    reportFile: typeof Schema.String;
+    historyFile: Schema.optional<typeof Schema.String>;
+    lastRun: Schema.NullOr<typeof Schema.String>;
+    lastResult: Schema.NullOr<Schema.Literal<["passed", "failed", "interrupted"]>>;
+  }>>;
+}>;
+/** @public */
+type CacheManifest = typeof CacheManifest.Type;
+//#endregion
+//#region src/schemas/History.d.ts
+/**
+ * A single test run outcome (pass or fail only).
+ * @public
+ */
+declare const TestRun: Schema.Struct<{
+  timestamp: typeof Schema.String;
+  state: Schema.Literal<["passed", "failed"]>;
+}>;
+/** @public */
+type TestRun = typeof TestRun.Type;
+/**
+ * History for a single test across multiple runs.
+ * @public
+ */
+declare const TestHistory: Schema.Struct<{
+  fullName: typeof Schema.String;
+  runs: Schema.Array$<Schema.Struct<{
+    timestamp: typeof Schema.String;
+    state: Schema.Literal<["passed", "failed"]>;
+  }>>;
+}>;
+/** @public */
+type TestHistory = typeof TestHistory.Type;
+/**
+ * Per-project history record containing all tracked tests.
+ * @public
+ */
+declare const HistoryRecord: Schema.Struct<{
+  project: typeof Schema.String;
+  updatedAt: typeof Schema.String;
+  tests: Schema.Array$<Schema.Struct<{
+    fullName: typeof Schema.String;
+    runs: Schema.Array$<Schema.Struct<{
+      timestamp: typeof Schema.String;
+      state: Schema.Literal<["passed", "failed"]>;
+    }>>;
+  }>>;
+}>;
+/** @public */
+type HistoryRecord = typeof HistoryRecord.Type;
+//#endregion
+//#region src/schemas/Tdd.d.ts
+/** @public */
+declare const GoalStatus: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+/** @public */
+type GoalStatus = typeof GoalStatus.Type;
+/** @public */
+declare const BehaviorStatus: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+/** @public */
+type BehaviorStatus = typeof BehaviorStatus.Type;
+/** @public */
+declare const GoalRow: Schema.Struct<{
+  id: typeof Schema.Number;
+  sessionId: typeof Schema.Number;
+  ordinal: typeof Schema.Number;
+  goal: typeof Schema.String;
+  status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+  createdAt: typeof Schema.String;
+}>;
+/** @public */
+type GoalRow = typeof GoalRow.Type;
+/** @public */
+declare const BehaviorRow: Schema.Struct<{
+  id: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  ordinal: typeof Schema.Number;
+  behavior: typeof Schema.String;
+  suggestedTestName: Schema.NullOr<typeof Schema.String>;
+  status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+  createdAt: typeof Schema.String;
+}>;
+/** @public */
+type BehaviorRow = typeof BehaviorRow.Type;
+/** @public */
+declare const GoalDetail: Schema.Struct<{
+  id: typeof Schema.Number;
+  sessionId: typeof Schema.Number;
+  ordinal: typeof Schema.Number;
+  goal: typeof Schema.String;
+  status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+  createdAt: typeof Schema.String;
+  behaviors: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    goalId: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+    suggestedTestName: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+    createdAt: typeof Schema.String;
+  }>>;
+}>;
+/** @public */
+type GoalDetail = typeof GoalDetail.Type;
+/** @public */
+declare const BehaviorDetail: Schema.Struct<{
+  id: typeof Schema.Number;
+  goalId: typeof Schema.Number;
+  ordinal: typeof Schema.Number;
+  behavior: typeof Schema.String;
+  suggestedTestName: Schema.NullOr<typeof Schema.String>;
+  status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+  createdAt: typeof Schema.String;
+  parentGoal: Schema.Struct<{
+    id: typeof Schema.Number;
+    goal: typeof Schema.String;
+    status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+  }>;
+  dependencies: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.Number;
+    goalId: typeof Schema.Number;
+    ordinal: typeof Schema.Number;
+    behavior: typeof Schema.String;
+    suggestedTestName: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["pending", "in_progress", "done", "abandoned"]>;
+    createdAt: typeof Schema.String;
+  }>>;
+}>;
+/** @public */
+type BehaviorDetail = typeof BehaviorDetail.Type;
+//#endregion
+//#region src/schemas/Trends.d.ts
+/**
+ * A single coverage trend data point recorded on a full test run.
+ * @public
+ */
+declare const TrendEntry: Schema.Struct<{
+  timestamp: typeof Schema.String;
+  coverage: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  delta: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  direction: Schema.Literal<["improving", "regressing", "stable"]>;
+  targetsHash: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type TrendEntry = typeof TrendEntry.Type;
+/**
+ * Per-project trend record with sliding window of entries.
+ * @public
+ */
+declare const TrendRecord: Schema.Struct<{
+  entries: Schema.Array$<Schema.Struct<{
+    timestamp: typeof Schema.String;
+    coverage: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    delta: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    direction: Schema.Literal<["improving", "regressing", "stable"]>;
+    targetsHash: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type TrendRecord = typeof TrendRecord.Type;
+//#endregion
+//#region src/utils/validate-phase-transition.d.ts
+/** @public */
+type Phase = "spike" | "red" | "red.triangulate" | "green" | "green.fake-it" | "refactor" | "extended-red" | "green-without-red";
+/** @public */
+type ArtifactKind = "test_written" | "test_failed_run" | "code_written" | "test_passed_run" | "refactor" | "test_weakened";
+/** @public */
+interface CitedArtifact {
+  readonly id: number;
+  readonly artifact_kind: ArtifactKind;
+  readonly test_case_id: number | null;
+  readonly test_case_created_turn_at: string | null;
+  readonly test_case_authored_in_session: boolean;
+  readonly test_run_id: number | null;
+  readonly test_first_failure_run_id: number | null;
+  readonly behavior_id: number | null;
+}
+/** @public */
+interface PhaseTransitionContext {
+  readonly tdd_task_id: number;
+  readonly current_phase: Phase;
+  readonly phase_started_at: string;
+  readonly now: string;
+  readonly requested_phase: Phase;
+  readonly cited_artifact: CitedArtifact;
+  readonly requested_behavior_id: number | null;
+}
+/** @public */
+type DenialReason = "missing_artifact_evidence" | "wrong_artifact_kind" | "wrong_source_phase" | "unknown_tdd_task" | "tdd_task_already_ended" | "goal_not_started" | "goal_not_found" | "goal_not_in_progress" | "goal_not_in_tdd_task" | "behavior_not_found" | "behavior_not_in_goal" | "refactor_without_passing_run" | "evidence_not_in_phase_window" | "evidence_not_for_behavior" | "evidence_test_was_already_failing";
+/** @public */
+interface Remediation {
+  readonly suggestedTool: string;
+  readonly suggestedArgs: Record<string, unknown>;
+  readonly humanHint: string;
+}
+/** @public */
+type PhaseTransitionResult = {
+  readonly accepted: true;
+  readonly phase: Phase;
+} | {
+  readonly accepted: false;
+  readonly phase: Phase;
+  readonly denialReason: DenialReason;
+  readonly remediation: Remediation;
+};
+/**
+ * Return the artifact kind a phase transition requires, plus a
+ * human-readable hint for surfacing in remediations.
+ *
+ * Exported so the MCP `tdd_phase_transition_request` tool can pre-compute
+ * the expected kind when the agent omits `citedArtifactId` (auto-resolve
+ * to the most recent matching artifact). The transitions without a
+ * required artifact (`spike→red`, `*→red`, etc.) return `null`.
+ * @public
+ */
+declare const requiredArtifactForTransition: (from: Phase, to: Phase) => {
+  kind: ArtifactKind;
+  humanHint: string;
+} | null;
+/**
+ * Whether D2 binding rule 2 (behavior-match) applies to a given transition.
+ *
+ * Only the transitions whose cited evidence must belong to the behavior being
+ * transitioned enforce behavior-match: `red→green` (the failing test for this
+ * behavior) and `green→refactor` (its passing test). It deliberately excludes
+ * `red.triangulate→green` (the cited failing run belongs to an earlier batch
+ * behavior) and `refactor→red` (the required `test_passed_run` is the
+ * just-finished behavior's, never the new target). Exported so the MCP
+ * `tdd_phase_transition_request` tool scopes artifact auto-resolution by
+ * behavior on exactly the same transitions the validator will accept —
+ * keeping the two in lockstep (issue #115).
+ * @public
+ */
+declare const transitionEnforcesBehaviorMatch: (from: Phase, to: Phase) => boolean;
+/** @public */
+declare const validatePhaseTransition: (ctx: PhaseTransitionContext) => PhaseTransitionResult;
+//#endregion
+//#region src/schemas/Agent.d.ts
+declare const Agent_base: Schema.TaggedClass<Agent, "Agent", {
+  readonly _tag: Schema.tag<"Agent">;
+} & {
+  agentId: Schema.brand<typeof Schema.UUID, "AgentId">;
+  sessionId: typeof Schema.Number;
+  parentAgentId: Schema.NullOr<Schema.brand<typeof Schema.UUID, "AgentId">>;
+  conversationId: Schema.NullOr<Schema.brand<typeof Schema.UUID, "ConversationId">>;
+  agentType: typeof Schema.String;
+  startedAt: typeof Schema.Number;
+  endedAt: Schema.NullOr<typeof Schema.Number>;
+  startGitBranch: Schema.NullOr<typeof Schema.String>;
+  startGitCommitSha: Schema.NullOr<typeof Schema.String>;
+  startWorktreeDir: Schema.NullOr<typeof Schema.String>;
+  idempotencyKey: typeof Schema.String;
+}>;
+/**
+ * Successful registration row. The fields mirror the `agents` SQLite
+ * table 1:1 in camelCase.
+ *
+ * `startGitBranch`, `startGitCommitSha`, `startWorktreeDir` capture
+ * *what the agent inherited at registration time* — distinct from the
+ * per-run git context recorded on `runs`. A divergence between the
+ * two reveals a mid-session branch switch, which is itself signal.
+ * @public
+ */
+declare class Agent extends Agent_base {}
+declare const IdempotencyHit_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] }>) => Readonly<A> & {
+  readonly _tag: "IdempotencyHit";
+};
+/**
+ * Returned by `DataStore.registerAgent` when the
+ * `(session_id, idempotency_key)` UNIQUE constraint already has a
+ * row. Not an error — the caller treats it as a successful recovery
+ * of the existing `agentId`.
+ *
+ * Modeled as a `Data.TaggedClass` so the success channel of
+ * `registerAgent` is `Effect<Agent | IdempotencyHit, ...>` and
+ * downstream code uses `Match.tag` to branch.
+ * @public
+ */
+declare class IdempotencyHit extends IdempotencyHit_base<{
+  readonly existingAgentId: typeof AgentId.Type;
+}> {}
+/**
+ * Sum type of the two possible outcomes of `registerAgent`.
+ * @public
+ */
+type RegisterAgentResult = Agent | IdempotencyHit;
+/**
+ * Agent tree — root agent with all descendants nested under
+ * `children`. Returned by `DataStore.getAgentTree` for forensics and
+ * the `vitest-agent agent list` CLI subcommand.
+ * @public
+ */
+interface AgentTreeNode {
+  readonly agent: Agent;
+  readonly children: ReadonlyArray<AgentTreeNode>;
+}
+//#endregion
+//#region src/services/DataStore.d.ts
+/** @public */
+interface CreateGoalInput {
+  readonly tddTaskId: number;
+  readonly goal: string;
+}
+/** @public */
+interface UpdateGoalInput {
+  readonly id: number;
+  readonly goal?: string;
+  readonly status?: GoalStatus;
+}
+/** @public */
+interface CreateBehaviorInput {
+  readonly goalId: number;
+  readonly behavior: string;
+  readonly suggestedTestName?: string;
+  readonly dependsOnBehaviorIds?: ReadonlyArray<number>;
+}
+/** @public */
+interface UpdateBehaviorInput {
+  readonly id: number;
+  readonly behavior?: string;
+  readonly suggestedTestName?: string | null;
+  readonly status?: BehaviorStatus;
+  readonly dependsOnBehaviorIds?: ReadonlyArray<number>;
+}
+/** @public */
+interface SettingsInput {
+  readonly vitestVersion: string;
+  readonly pool?: string;
+  readonly environment?: string;
+  readonly testTimeout?: number;
+  readonly hookTimeout?: number;
+  readonly slowTestThreshold?: number;
+  readonly maxConcurrency?: number;
+  readonly maxWorkers?: number;
+  readonly isolate?: boolean;
+  readonly bail?: number;
+  readonly globals?: boolean;
+  readonly fileParallelism?: boolean;
+  readonly sequenceSeed?: number;
+  readonly coverageProvider?: string;
+}
+/** @public */
+interface TestRunInput {
+  readonly invocationId: string;
+  readonly project: string;
+  readonly settingsHash: string;
+  readonly timestamp: string;
+  readonly commitSha: string | null;
+  readonly branch: string | null;
+  readonly reason: "passed" | "failed" | "interrupted";
+  readonly duration: number;
+  readonly total: number;
+  readonly passed: number;
+  readonly failed: number;
+  readonly skipped: number;
+  readonly scoped: boolean;
+  readonly snapshotAdded?: number;
+  readonly snapshotMatched?: number;
+  readonly snapshotUnmatched?: number;
+  readonly snapshotUpdated?: number;
+  readonly snapshotUnchecked?: number;
+  readonly snapshotTotal?: number;
+  readonly snapshotFailure?: boolean;
+  readonly snapshotDidUpdate?: boolean;
+  readonly snapshotFilesAdded?: number;
+  readonly snapshotFilesRemoved?: number;
+  readonly snapshotFilesUnmatched?: number;
+  readonly snapshotFilesUpdated?: number;
+  /**
+   * Attribution columns added by the agent-agnostic taxonomy work. The
+   * reporter walks env vars / session map to populate these; un-attributed
+   * runs default to actor_type='system' and NULL agent/conversation ids.
+   */
+  readonly actorType?: "agent" | "user" | "system";
+  readonly agentId?: string | null;
+  readonly conversationId?: string | null;
+  /**
+   * Git context the run executed against. NULL for non-git workspaces.
+   */
+  readonly gitBranch?: string | null;
+  readonly gitCommitSha?: string | null;
+  readonly gitDirty?: boolean | null;
+  readonly gitUpstream?: string | null;
+  readonly gitWorktreeDir?: string | null;
+  /**
+   * Host metadata probe result (terminal pane, CI runner). NULL when no
+   * probe in the priority chain matched.
+   * @public
+   */
+  readonly hostSource?: string | null;
+  readonly hostValue?: string | null;
+  readonly hostMetadata?: Record<string, unknown> | null;
+}
+/** @public */
+interface ModuleInput {
+  readonly fileId: number;
+  readonly relativeModuleId: string;
+  readonly state: string;
+  readonly duration?: number;
+  readonly environmentSetupDuration?: number;
+  readonly prepareDuration?: number;
+  readonly collectDuration?: number;
+  readonly setupDuration?: number;
+  readonly heap?: number;
+}
+/** @public */
+interface TestCaseInput {
+  readonly suiteId?: number;
+  readonly vitestId?: string;
+  readonly name: string;
+  readonly fullName: string;
+  readonly state: string;
+  readonly classification?: string;
+  readonly duration?: number;
+  readonly startTime?: number;
+  readonly flaky?: boolean;
+  readonly slow?: boolean;
+  readonly retryCount?: number;
+  readonly repeatCount?: number;
+  readonly heap?: number;
+  readonly mode?: string;
+  readonly each?: boolean;
+  readonly fails?: boolean;
+  readonly concurrent?: boolean;
+  readonly shuffle?: boolean;
+  readonly timeout?: number;
+  readonly skipNote?: string;
+  readonly locationLine?: number;
+  readonly locationColumn?: number;
+  readonly tags?: readonly string[];
+  /**
+   * FK to `turns(id)`. Set by the reporter when the test case row was
+   * authored within a recorded turn (D2 binding rule 1).
+   * @public
+   */
+  readonly createdTurnId?: number;
+}
+/** @public */
+interface StackFrameInput {
+  readonly ordinal: number;
+  readonly method: string | null;
+  readonly filePath: string;
+  readonly line: number;
+  readonly col: number;
+  readonly sourceMappedLine?: number;
+  readonly functionBoundaryLine?: number;
+}
+/** @public */
+interface TestErrorInput {
+  readonly testCaseId?: number;
+  readonly testSuiteId?: number;
+  readonly moduleId?: number;
+  readonly scope: "test" | "suite" | "module" | "unhandled";
+  readonly name?: string;
+  readonly message: string;
+  readonly diff?: string;
+  readonly actual?: string;
+  readonly expected?: string;
+  readonly stack?: string;
+  readonly causeErrorId?: number;
+  readonly signatureHash?: string;
+  readonly frames?: ReadonlyArray<StackFrameInput>;
+  readonly ordinal?: number;
+}
+/** @public */
+interface FileCoverageInput {
+  readonly fileId: number;
+  readonly statements: number;
+  readonly branches: number;
+  readonly functions: number;
+  readonly lines: number;
+  readonly uncoveredLines?: string;
+  /**
+   * Coverage tier this row represents. `'below_threshold'` is the
+   * build-failing tier (file falls below the configured minimum
+   * coverage thresholds). `'below_target'` is the warning tier (file
+   * is above thresholds but below the aspirational target).
+   *
+   * Defaults to `'below_threshold'` when omitted, matching the only
+   * tier that existed before migration 0005.
+   * @public
+   */
+  readonly tier?: "below_threshold" | "below_target";
+}
+/** @public */
+interface SuiteInput {
+  readonly parentSuiteId?: number;
+  readonly name: string;
+  readonly fullName: string;
+  readonly state: "pending" | "passed" | "failed" | "skipped";
+  readonly mode?: "run" | "only" | "skip" | "todo";
+  readonly concurrent?: boolean;
+  readonly shuffle?: boolean;
+  readonly retry?: number;
+  readonly repeats?: number;
+  readonly locationLine?: number;
+  readonly locationColumn?: number;
+}
+/** @public */
+interface NoteInput {
+  readonly title: string;
+  readonly content: string;
+  readonly scope: "global" | "project" | "module" | "suite" | "test" | "note";
+  readonly project?: string;
+  readonly testFullName?: string;
+  readonly modulePath?: string;
+  readonly parentNoteId?: number;
+  readonly createdBy?: string;
+  readonly expiresAt?: string;
+  readonly pinned?: boolean;
+}
+/** @public */
+interface SessionInput {
+  readonly chatId: string;
+  readonly project: string;
+  readonly cwd: string;
+  readonly agentKind: "main" | "subagent";
+  readonly agentType?: string;
+  readonly parentSessionId?: number;
+  readonly triageWasNonEmpty?: boolean;
+  readonly startedAt: string;
+}
+/** @public */
+interface TurnInput {
+  readonly sessionId: number;
+  /** When omitted, writeTurn computes MAX(turnNo) + 1 for the session. */
+  readonly turnNo?: number;
+  readonly type: "user_prompt" | "tool_call" | "tool_result" | "file_edit" | "hook_fire" | "note" | "hypothesis";
+  readonly payload: string;
+  readonly occurredAt: string;
+}
+/** @public */
+interface FailureSignatureWriteInput {
+  readonly signatureHash: string;
+  readonly runId: number;
+  readonly seenAt: string;
+}
+/** @public */
+interface HypothesisInput {
+  readonly sessionId: number;
+  readonly content: string;
+  readonly createdTurnId?: number;
+  readonly citedTestErrorId?: number;
+  readonly citedStackFrameId?: number;
+}
+/** @public */
+interface ValidateHypothesisInput {
+  readonly id: number;
+  readonly outcome: "confirmed" | "refuted" | "abandoned";
+  readonly validatedTurnId?: number;
+  readonly validatedAt: string;
+}
+/** @public */
+interface IdempotentResponseInput {
+  readonly procedurePath: string;
+  readonly key: string;
+  readonly resultJson: string;
+  readonly createdAt: string;
+}
+/** @public */
+interface TddTaskInput {
+  readonly sessionId: number;
+  readonly goal: string;
+  readonly startedAt: string;
+  readonly parentTddTaskId?: number;
+  readonly runId?: string;
+}
+/** @public */
+interface EndTddTaskInput {
+  readonly id: number;
+  readonly endedAt: string;
+  readonly outcome: "succeeded" | "blocked" | "abandoned";
+  readonly summaryNoteId?: number;
+}
+/** @public */
+interface WriteTddPhaseInput {
+  readonly tddTaskId: number;
+  readonly behaviorId?: number;
+  readonly phase: Phase;
+  readonly startedAt: string;
+  readonly transitionReason?: string;
+  readonly parentPhaseId?: number;
+}
+/** @public */
+interface WriteTddPhaseOutput {
+  readonly id: number;
+  readonly previousPhaseId: number | null;
+}
 /** @public */
-declare const ciAnnotationsFormatter: Formatter;
-//#endregion
-//#region src/formatters/gfm.d.ts
+interface WriteTddArtifactInput {
+  readonly phaseId: number;
+  readonly artifactKind: ArtifactKind;
+  readonly fileId?: number;
+  readonly testCaseId?: number;
+  readonly testRunId?: number;
+  readonly testFirstFailureRunId?: number;
+  readonly diffExcerpt?: string;
+  readonly recordedAt: string;
+}
 /** @public */
-declare const GfmFormatter: Formatter;
-//#endregion
-//#region src/formatters/json.d.ts
+interface WriteCommitInput {
+  readonly sha: string;
+  readonly parentSha?: string;
+  readonly message?: string;
+  readonly author?: string;
+  readonly committedAt?: string;
+  readonly branch?: string;
+}
 /** @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
+type ChangeKind = "added" | "modified" | "deleted" | "renamed" | "untracked-modified";
 /** @public */
-declare const SilentFormatter: Formatter;
-//#endregion
-//#region src/formatters/terminal.d.ts
+interface RunChangedFile {
+  readonly filePath: string;
+  readonly changeKind: ChangeKind;
+  readonly commitSha?: string;
+}
 /** @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;
-}, {}, {}>;
+interface WriteRunChangedFilesInput {
+  readonly runId: number;
+  readonly files: ReadonlyArray<RunChangedFile>;
+}
+/** @public */
+type RunInvocationMethod = "bash" | "mcp" | "cli";
 /**
- * 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.
+ * Input to `DataStore.registerAgent`.
  *
- * 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.
+ * `sessionId` is the FK to `sessions.id` (integer PK), NOT the host's
+ * chat UUID string. Callers that hold only the chat UUID must resolve
+ * it through `getSessionByChatId` first.
  *
- * Both runtime packages (reporter, MCP) yield this tag to access the loaded
- * `VitestAgentConfig`. The live layer is built per `projectDir` via
- * `ConfigLive(projectDir)`.
+ * `idempotencyKey` is pre-derived by the caller via
+ * `deriveIdempotencyKey(...)` — both the sidecar CLI and the MCP
+ * server compute it the same way so a hook retry collapses to the
+ * same row.
  * @public
  */
-declare const VitestAgentConfigFile: import("effect/Context").Tag<ConfigFileService<VitestAgentConfig>, ConfigFileService<VitestAgentConfig>>;
+interface RegisterAgentInput {
+  readonly sessionId: number;
+  readonly agentType: string;
+  readonly parentAgentId: string | null;
+  readonly conversationId: string | null;
+  readonly startedAt: number;
+  readonly startGitBranch?: string;
+  readonly startGitCommitSha?: string;
+  readonly startWorktreeDir?: string;
+  readonly idempotencyKey: string;
+  /**
+   * Pre-allocated `agents.agent_id` UUID. The sidecar passes
+   * `PerClientSessionMapWriter.mapSession()`'s `main_agent_id` here so
+   * the per-project `agents` row and the per-client session_map row
+   * agree on a single canonical id — the same value the SessionStart
+   * hook exports as `VITEST_AGENT_MAIN_AGENT_ID` / `_AGENT_ID`. When
+   * omitted, the implementation generates a fresh UUID (used by tests
+   * and any caller without a session map).
+   */
+  readonly agentId?: string;
+}
+/** @public */
+interface AssociateRunSessionInput {
+  readonly chatId: string;
+  readonly invocationMethod: RunInvocationMethod;
+}
+declare const DataStore_base: Context.TagClass<DataStore, "vitest-agent/DataStore", {
+  readonly writeSettings: (hash: string, settings: SettingsInput, envVars: Record<string, string>) => Effect.Effect<void, DataStoreError>;
+  readonly writeRun: (input: TestRunInput) => Effect.Effect<number, DataStoreError>;
+  readonly writeModules: (runId: number, modules: ReadonlyArray<ModuleInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError>;
+  readonly writeSuites: (moduleId: number, suites: ReadonlyArray<SuiteInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError>;
+  readonly writeTestCases: (moduleId: number, tests: ReadonlyArray<TestCaseInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError>;
+  readonly writeErrors: (runId: number, errors: ReadonlyArray<TestErrorInput>) => Effect.Effect<void, DataStoreError>;
+  readonly writeCoverage: (runId: number, coverage: ReadonlyArray<FileCoverageInput>) => Effect.Effect<void, DataStoreError>;
+  readonly writeHistory: (project: string, fullName: string, runId: number, timestamp: string, state: string, duration: number | null, flaky: boolean, retryCount: number, errorMessage: string | null) => Effect.Effect<void, DataStoreError>;
+  readonly writeBaselines: (baselines: CoverageBaselines) => Effect.Effect<void, DataStoreError>;
+  readonly writeTrends: (project: string, runId: number, entry: TrendEntry) => Effect.Effect<void, DataStoreError>;
+  readonly writeSourceMap: (sourceFilePath: string, testModuleId: number, mappingType: string) => Effect.Effect<void, DataStoreError>;
+  readonly ensureFile: (filePath: string) => Effect.Effect<number, DataStoreError>;
+  readonly writeNote: (note: NoteInput) => Effect.Effect<number, DataStoreError>;
+  readonly updateNote: (id: number, fields: Partial<NoteInput>) => Effect.Effect<void, DataStoreError>;
+  readonly deleteNote: (id: number) => Effect.Effect<void, DataStoreError>;
+  readonly writeSession: (input: SessionInput) => Effect.Effect<number, DataStoreError>;
+  /**
+   * Idempotent variant of `writeSession`: if a row with this
+   * `chat_id` already exists, return its id and leave the stored
+   * fields untouched; otherwise insert a new row. Used by
+   * hook-triggered recording paths (artifacts, turns) that fire
+   * for sessions whose original `SessionStart` may have missed —
+   * e.g. when Claude Code rotates `chat_id` mid-window after a
+   * continuation or compaction. Race-safe via
+   * `INSERT ... ON CONFLICT DO NOTHING`.
+   */
+  readonly upsertSession: (input: SessionInput) => Effect.Effect<number, DataStoreError>;
+  readonly writeTurn: (input: TurnInput) => Effect.Effect<number, DataStoreError>;
+  readonly writeFailureSignature: (input: FailureSignatureWriteInput) => Effect.Effect<void, DataStoreError>;
+  readonly endSession: (chatId: string, endedAt: string, endReason: string | null) => Effect.Effect<void, DataStoreError>;
+  readonly writeHypothesis: (input: HypothesisInput) => Effect.Effect<number, DataStoreError>;
+  readonly validateHypothesis: (input: ValidateHypothesisInput) => Effect.Effect<void, DataStoreError>;
+  readonly writeTddTask: (input: TddTaskInput) => Effect.Effect<number, DataStoreError>;
+  readonly endTddTask: (input: EndTddTaskInput) => Effect.Effect<void, DataStoreError>;
+  readonly createGoal: (input: CreateGoalInput) => Effect.Effect<GoalRow, DataStoreError | TddTaskNotFoundError | TddTaskAlreadyEndedError>;
+  readonly getGoal: (id: number) => Effect.Effect<Option.Option<GoalRow>, DataStoreError>;
+  readonly updateGoal: (input: UpdateGoalInput) => Effect.Effect<GoalRow, DataStoreError | GoalNotFoundError | TddTaskAlreadyEndedError | IllegalStatusTransitionError>;
+  readonly deleteGoal: (id: number) => Effect.Effect<void, DataStoreError | GoalNotFoundError>;
+  readonly listGoalsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<GoalRow>, DataStoreError | TddTaskNotFoundError>;
+  readonly createBehavior: (input: CreateBehaviorInput) => Effect.Effect<BehaviorRow, DataStoreError | GoalNotFoundError | BehaviorNotFoundError | TddTaskAlreadyEndedError | IllegalStatusTransitionError>;
+  readonly getBehavior: (id: number) => Effect.Effect<Option.Option<BehaviorRow>, DataStoreError>;
+  readonly updateBehavior: (input: UpdateBehaviorInput) => Effect.Effect<BehaviorRow, DataStoreError | BehaviorNotFoundError | TddTaskAlreadyEndedError | IllegalStatusTransitionError>;
+  readonly deleteBehavior: (id: number) => Effect.Effect<void, DataStoreError | BehaviorNotFoundError>;
+  readonly listBehaviorsByGoal: (goalId: number) => Effect.Effect<ReadonlyArray<BehaviorRow>, DataStoreError | GoalNotFoundError>;
+  readonly listBehaviorsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<BehaviorRow>, DataStoreError | TddTaskNotFoundError>;
+  readonly writeTddPhase: (input: WriteTddPhaseInput) => Effect.Effect<WriteTddPhaseOutput, DataStoreError>;
+  readonly writeTddArtifact: (input: WriteTddArtifactInput) => Effect.Effect<number, DataStoreError>;
+  readonly writeCommit: (input: WriteCommitInput) => Effect.Effect<void, DataStoreError>;
+  readonly writeRunChangedFiles: (input: WriteRunChangedFilesInput) => Effect.Effect<void, DataStoreError>;
+  readonly recordIdempotentResponse: (input: IdempotentResponseInput) => Effect.Effect<void, DataStoreError>;
+  readonly pruneSessions: (keepRecent: number) => Effect.Effect<{
+    readonly affectedSessions: number;
+    readonly prunedTurns: number;
+  }, DataStoreError>;
+  readonly associateLatestRunWithSession: (input: AssociateRunSessionInput) => Effect.Effect<void, DataStoreError>;
+  readonly backfillTestCaseTurns: (chatId: string) => Effect.Effect<number, DataStoreError>;
+  /**
+   * Idempotently insert an `agents` row.
+   *
+   * Returns `Agent` on a fresh insert, or `IdempotencyHit` carrying
+   * the existing `agentId` when the `(session_id, idempotency_key)`
+   * UNIQUE constraint already has a row. The caller treats the latter
+   * as a successful recovery (same logical agent), not an error.
+   *
+   * Fails with `RegistrationConflictError` when the supplied
+   * `parentAgentId` references an agent in a different session, or
+   * when no such agent exists. Surface to the caller for true
+   * mis-configuration cases; idempotency hits never produce this.
+   */
+  readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent | IdempotencyHit, RegistrationConflictError | DataStoreError>;
+  /**
+   * Mark an agent as ended. Sets `agents.ended_at` to the supplied
+   * timestamp. Fails with `AgentNotFoundError` when no row exists.
+   */
+  readonly endAgent: (agentId: string, endedAt: number) => Effect.Effect<void, AgentNotFoundError | DataStoreError>;
+}>;
+/** @public */
+declare class DataStore extends DataStore_base {}
 //#endregion
-//#region src/layers/ConfigLive.d.ts
+//#region src/services/DataReader.d.ts
+/** @public */
+interface ProjectRunSummary {
+  readonly project: string;
+  readonly lastRun: string | null;
+  readonly lastResult: "passed" | "failed" | "interrupted" | null;
+  readonly total: number;
+  readonly passed: number;
+  readonly failed: number;
+  readonly skipped: number;
+}
+/** @public */
+interface FlakyTest {
+  readonly fullName: string;
+  readonly project: string;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly lastState: "passed" | "failed";
+  readonly lastTimestamp: string;
+}
+/** @public */
+interface PersistentFailure {
+  readonly fullName: string;
+  readonly project: string;
+  readonly consecutiveFailures: number;
+  readonly firstFailedAt: string;
+  readonly lastFailedAt: string;
+  readonly lastErrorMessage: string | null;
+}
+/** @public */
+interface TestError {
+  /** `test_errors.id` — required by `hypothesis (action: record).citedTestErrorId`. */
+  readonly id: number;
+  /**
+   * `stack_frames.id` for the top frame of this error (ordinal 0), or
+   * `null` if no frames were captured. Required by
+   * `hypothesis (action: record).citedStackFrameId`.
+   */
+  readonly topStackFrameId: number | null;
+  readonly name: string | null;
+  readonly message: string;
+  readonly diff: string | null;
+  readonly actual: string | null;
+  readonly expected: string | null;
+  readonly stack: string | null;
+  readonly scope: "test" | "suite" | "module" | "unhandled";
+  readonly testFullName: string | null;
+  readonly moduleFile: string | null;
+}
+/** @public */
+interface NoteRow {
+  readonly id: number;
+  readonly title: string;
+  readonly content: string;
+  readonly scope: "global" | "project" | "module" | "suite" | "test" | "note";
+  readonly project: string | null;
+  readonly testFullName: string | null;
+  readonly modulePath: string | null;
+  readonly parentNoteId: number | null;
+  readonly createdBy: string | null;
+  readonly expiresAt: string | null;
+  readonly pinned: boolean;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+}
+/** @public */
+interface SettingsRow {
+  readonly hash: string;
+  readonly reporters: string | null;
+  readonly coverageEnabled: boolean;
+  readonly coverageProvider: string | null;
+  readonly coverageThresholds: string | null;
+  readonly coverageTargets: string | null;
+  readonly pool: string | null;
+  readonly shard: string | null;
+  readonly project: string | null;
+  readonly environment: string | null;
+  readonly envVars: Record<string, string>;
+  readonly capturedAt: string;
+}
+/** @public */
+interface TestListEntry {
+  readonly id: number;
+  readonly fullName: string;
+  readonly state: string;
+  readonly duration: number | null;
+  readonly module: string;
+  readonly classification: string | null;
+}
+/** @public */
+interface ModuleListEntry {
+  readonly id: number;
+  readonly file: string;
+  readonly state: string;
+  readonly testCount: number;
+  readonly duration: number | null;
+}
+/** @public */
+interface SuiteListEntry {
+  readonly id: number;
+  readonly name: string;
+  readonly module: string;
+  readonly state: string;
+  readonly testCount: number;
+}
+/** @public */
+interface SettingsListEntry {
+  readonly hash: string;
+  readonly capturedAt: string;
+}
+/** @public */
+interface SessionDetail {
+  readonly id: number;
+  readonly chatId: string;
+  readonly project: string;
+  readonly cwd: string;
+  readonly agentKind: "main" | "subagent";
+  readonly agentType: string | null;
+  readonly parentSessionId: number | null;
+  readonly triageWasNonEmpty: boolean;
+  readonly startedAt: string;
+  readonly endedAt: string | null;
+  readonly endReason: string | null;
+}
+/** @public */
+interface TurnSummary {
+  readonly id: number;
+  readonly sessionId: number;
+  readonly turnNo: number;
+  readonly type: string;
+  readonly payload: string;
+  readonly occurredAt: string;
+}
+/** @public */
+interface TurnSearchOptions {
+  readonly sessionId?: number;
+  readonly type?: string;
+  readonly since?: string;
+  readonly limit?: number;
+}
+/** @public */
+interface AcceptanceMetrics {
+  readonly phaseEvidenceIntegrity: {
+    total: number;
+    compliant: number;
+    ratio: number;
+  };
+  readonly complianceHookResponsiveness: {
+    total: number;
+    withFollowup: number;
+    ratio: number;
+  };
+  readonly orientationUsefulness: {
+    total: number;
+    referencedCount: number;
+    ratio: number;
+  };
+  readonly antiPatternDetectionRate: {
+    total: number;
+    cleanSessions: number;
+    ratio: number;
+  };
+}
+/** @public */
+interface FailureSignatureDetail {
+  readonly signatureHash: string;
+  readonly firstSeenRunId: number | null;
+  readonly firstSeenAt: string;
+  readonly lastSeenAt: string | null;
+  readonly occurrenceCount: number;
+  readonly recentErrors: ReadonlyArray<{
+    readonly runId: number;
+    readonly message: string;
+    readonly errorName: string | null;
+  }>;
+}
+/** @public */
+interface TddPhaseDetail {
+  readonly id: number;
+  readonly behaviorId: number | null;
+  readonly phase: string;
+  readonly startedAt: string;
+  readonly endedAt: string | null;
+  readonly transitionReason: string | null;
+}
+/** @public */
+interface TddArtifactDetail {
+  readonly id: number;
+  readonly phaseId: number;
+  readonly artifactKind: string;
+  readonly testCaseId: number | null;
+  readonly testRunId: number | null;
+  readonly recordedAt: string;
+}
+/** @public */
+interface TddTaskDetail {
+  readonly id: number;
+  readonly sessionId: number;
+  readonly goal: string;
+  readonly startedAt: string;
+  readonly endedAt: string | null;
+  readonly outcome: string | null;
+  readonly runId: string | null;
+  readonly goals: ReadonlyArray<GoalDetail>;
+  readonly phases: ReadonlyArray<TddPhaseDetail>;
+  readonly artifacts: ReadonlyArray<TddArtifactDetail>;
+}
+/** @public */
+interface CurrentTddPhase {
+  readonly id: number;
+  readonly phase: Phase;
+  readonly startedAt: string;
+  readonly behaviorId: number | null;
+}
+/** @public */
+interface CitedArtifactRow extends CitedArtifact {
+  readonly phase_id: number;
+}
+/** @public */
+interface CommitChangesEntry {
+  readonly sha: string;
+  readonly parentSha: string | null;
+  readonly message: string | null;
+  readonly author: string | null;
+  readonly committedAt: string | null;
+  readonly branch: string | null;
+  readonly files: ReadonlyArray<{
+    readonly filePath: string;
+    readonly changeKind: ChangeKind;
+  }>;
+}
+/** @public */
+interface HypothesisDetail {
+  readonly id: number;
+  readonly sessionId: number;
+  readonly content: string;
+  readonly citedTestErrorId: number | null;
+  readonly citedStackFrameId: number | null;
+  readonly validationOutcome: "confirmed" | "refuted" | "abandoned" | null;
+  readonly validatedAt: string | null;
+}
+/** @public */
+interface TddTaskSummary {
+  readonly id: number;
+  readonly sessionId: number;
+  readonly goal: string;
+  readonly startedAt: string;
+  readonly endedAt: string | null;
+  readonly outcome: "succeeded" | "blocked" | "abandoned" | null;
+}
 /**
- * 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`.
+ * Row shape returned by `listTddArtifactsForTask`. Carries every
+ * field an agent typically needs to cite an artifact in a subsequent
+ * `tdd_phase_transition_request` call without further lookups.
  *
- * 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>;
+interface TddArtifactRow {
+  readonly id: number;
+  readonly tddTaskId: number;
+  readonly phaseId: number;
+  readonly phaseName: Phase;
+  readonly artifactKind: ArtifactKind;
+  readonly behaviorId: number | null;
+  readonly testCaseId: number | null;
+  readonly testRunId: number | null;
+  readonly testFirstFailureRunId: number | null;
+  readonly recordedAt: string;
+}
+/** @public */
+interface TagInventoryRow {
+  /** The tag name (e.g. `"int"`, `"e2e"`, `"unit"`). */
+  readonly tag: string;
+  /** The Vitest project this tag was observed in. */
+  readonly project: string;
+  /**
+   * Number of distinct test modules in the project's latest run that contain
+   * at least one test case carrying this tag.
+   */
+  readonly moduleCount: number;
+  /**
+   * Number of test cases in the project's latest run that carry this tag.
+   */
+  readonly testCount: number;
+}
+declare const DataReader_base: Context.TagClass<DataReader, "vitest-agent/DataReader", {
+  readonly getLatestRun: (project: string) => Effect.Effect<Option.Option<AgentReport>, DataStoreError>;
+  readonly getRunsByProject: () => Effect.Effect<ReadonlyArray<ProjectRunSummary>, DataStoreError>;
+  readonly getHistory: (project: string) => Effect.Effect<HistoryRecord, DataStoreError>;
+  readonly getBaselines: (project: string) => Effect.Effect<Option.Option<CoverageBaselines>, DataStoreError>;
+  readonly getTrends: (project: string, limit?: number) => Effect.Effect<Option.Option<TrendRecord>, DataStoreError>;
+  readonly getFlaky: (project: string) => Effect.Effect<ReadonlyArray<FlakyTest>, DataStoreError>;
+  readonly getPersistentFailures: (project: string) => Effect.Effect<ReadonlyArray<PersistentFailure>, DataStoreError>;
+  readonly getFileCoverage: (runId: number) => Effect.Effect<ReadonlyArray<FileCoverageReport>, DataStoreError>;
+  readonly getCoverage: (project: string) => Effect.Effect<Option.Option<CoverageReport>, DataStoreError>;
+  readonly getTestsForFile: (filePath: string) => Effect.Effect<ReadonlyArray<string>, DataStoreError>;
+  readonly getErrors: (project: string, errorName?: string) => Effect.Effect<ReadonlyArray<TestError>, DataStoreError>;
+  readonly getNotes: (scope?: string, project?: string, testFullName?: string) => Effect.Effect<ReadonlyArray<NoteRow>, DataStoreError>;
+  readonly getNoteById: (id: number) => Effect.Effect<Option.Option<NoteRow>, DataStoreError>;
+  readonly searchNotes: (query: string) => Effect.Effect<ReadonlyArray<NoteRow>, DataStoreError>;
+  readonly getManifest: () => Effect.Effect<Option.Option<CacheManifest>, DataStoreError>;
+  readonly getSettings: (hash: string) => Effect.Effect<Option.Option<SettingsRow>, DataStoreError>;
+  readonly getLatestSettings: () => Effect.Effect<Option.Option<SettingsRow>, DataStoreError>;
+  readonly getTestByFullName: (project: string, fullName: string) => Effect.Effect<Option.Option<TestListEntry>, DataStoreError>;
+  readonly listTests: (project: string, options?: {
+    state?: string;
+    module?: string;
+    limit?: number;
+  }) => Effect.Effect<ReadonlyArray<TestListEntry>, DataStoreError>;
+  readonly listModules: (project: string) => Effect.Effect<ReadonlyArray<ModuleListEntry>, DataStoreError>;
+  readonly listSuites: (project: string, options?: {
+    module?: string;
+  }) => Effect.Effect<ReadonlyArray<SuiteListEntry>, DataStoreError>;
+  readonly listSettings: () => Effect.Effect<ReadonlyArray<SettingsListEntry>, DataStoreError>;
+  readonly getSessionById: (id: number) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError>;
+  readonly getSessionByChatId: (chatId: string) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError>;
+  /**
+   * Find every session row whose `chat_id` begins with `prefix`.
+   * Used to recover the synthetic subagent row created by the
+   * SubagentStart hook (`<parentChatId>-subagent-<ts>-<pid>`)
+   * when subsequent PostToolUse hooks fire under the bare
+   * parent chat_id. Returns most recent first.
+   */
+  readonly findSessionsByChatPrefix: (prefix: string) => Effect.Effect<ReadonlyArray<SessionDetail>, DataStoreError>;
+  /**
+   * Find the most-recently-started subagent session whose
+   * `parent_session_id` is `parentSessionId` and that has not ended
+   * (`ended_at IS NULL`). Used to attribute orchestrator (subagent)
+   * MCP writes — e.g. `hypothesis record` — to the running subagent's
+   * own session row instead of the parent main session, since the MCP
+   * server's recovered context only ever names the main agent.
+   */
+  readonly findActiveSubagentSession: (parentSessionId: number) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError>;
+  readonly listSessions: (options: {
+    readonly project?: string;
+    readonly agentKind?: "main" | "subagent";
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<SessionDetail>, DataStoreError>;
+  readonly searchTurns: (options: TurnSearchOptions) => Effect.Effect<ReadonlyArray<TurnSummary>, DataStoreError>;
+  readonly computeAcceptanceMetrics: () => Effect.Effect<AcceptanceMetrics, DataStoreError>;
+  readonly getFailureSignatureByHash: (hash: string) => Effect.Effect<Option.Option<FailureSignatureDetail>, DataStoreError>;
+  readonly getTddTaskById: (id: number) => Effect.Effect<Option.Option<TddTaskDetail>, DataStoreError>;
+  readonly getGoalById: (id: number) => Effect.Effect<Option.Option<GoalDetail>, DataStoreError>;
+  readonly getGoalsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<GoalDetail>, DataStoreError>;
+  readonly getBehaviorById: (id: number) => Effect.Effect<Option.Option<BehaviorDetail>, DataStoreError>;
+  readonly getBehaviorsByGoal: (goalId: number) => Effect.Effect<ReadonlyArray<BehaviorRow>, DataStoreError>;
+  readonly getBehaviorsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<BehaviorRow>, DataStoreError>;
+  readonly getBehaviorDependencies: (behaviorId: number) => Effect.Effect<ReadonlyArray<BehaviorRow>, DataStoreError>;
+  readonly resolveGoalIdForBehavior: (behaviorId: number) => Effect.Effect<Option.Option<number>, DataStoreError>;
+  readonly getCurrentTddPhase: (tddTaskId: number) => Effect.Effect<Option.Option<CurrentTddPhase>, DataStoreError>;
+  readonly getTddArtifactWithContext: (artifactId: number) => Effect.Effect<Option.Option<CitedArtifactRow>, DataStoreError>;
+  readonly getCommitChanges: (sha?: string) => Effect.Effect<ReadonlyArray<CommitChangesEntry>, DataStoreError>;
+  readonly listTddTasksForSession: (sessionId: number, options?: {
+    /**
+     * When true, also return tdd_tasks belonging to any
+     * ancestor of `sessionId` via `parent_session_id`. Used
+     * by hook-driven artifact recording where the
+     * orchestrator opened the tdd task under the parent
+     * main row but the subagent's own session row is the
+     * one carrying the calling chat_id. Default `false`
+     * preserves the prior single-session contract.
+     */
+    readonly walkParents?: boolean;
+  }) => Effect.Effect<ReadonlyArray<TddTaskSummary>, DataStoreError>;
+  /**
+   * List artifacts recorded for a TDD task, optionally filtered
+   * by `artifactKind`, `phaseId`, or `behaviorId`. Returns rows in
+   * recorded_at DESC order so the most recently captured artifact
+   * (the typical citation target for a phase transition) appears
+   * first. `limit` defaults to 50.
+   */
+  readonly listTddArtifactsForTask: (input: {
+    readonly tddTaskId: number;
+    readonly artifactKind?: ArtifactKind;
+    readonly phaseId?: number;
+    readonly behaviorId?: number;
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<TddArtifactRow>, DataStoreError>;
+  readonly listHypotheses: (options: {
+    readonly sessionId?: number;
+    readonly outcome?: "confirmed" | "refuted" | "abandoned" | "open";
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<HypothesisDetail>, DataStoreError>;
+  readonly findIdempotentResponse: (procedurePath: string, key: string) => Effect.Effect<Option.Option<string>, DataStoreError>;
+  readonly getLatestTestCaseForSession: (chatId: string) => Effect.Effect<Option.Option<number>, DataStoreError>;
+  /**
+   * Returns one `TagInventoryRow` per `(tag, project)` pair observed in
+   * each project's latest test run. When `project` is supplied, results
+   * are restricted to that project's latest run.
+   */
+  readonly listTagInventory: (options?: {
+    readonly project?: string;
+  }) => Effect.Effect<ReadonlyArray<TagInventoryRow>, DataStoreError>;
+  /**
+   * Returns every `TestListEntry` from the latest run of each project
+   * (or the specified project) whose test case carries `tag`.
+   */
+  readonly listTestsForTag: (tag: string, options?: {
+    readonly project?: string;
+  }) => Effect.Effect<ReadonlyArray<TestListEntry>, DataStoreError>;
+}>;
+/** @public */
+declare class DataReader extends DataReader_base {}
 //#endregion
 //#region src/layers/DataReaderLive.d.ts
 /** @public */
@@ -1458,7 +3288,7 @@ declare const OutputRendererLive: Layer.Layer<OutputRenderer, never, never>;
  *   anchor the config file resolvers.
  * @public
  */
-declare const PathResolutionLive: (projectDir: string) => Layer.Layer<VitestAgentConfigFileService | import("xdg-effect").XdgResolver | import("xdg-effect").AppDirs | import("workspaces-effect").WorkspaceDiscovery, never, import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path>;
+declare const PathResolutionLive: (projectDir: string) => Layer.Layer<import("xdg-effect").AppDirs | VitestAgentConfigFileService | import("workspaces-effect").WorkspaceDiscovery | import("xdg-effect").XdgResolver, never, import("@effect/platform/FileSystem").FileSystem | import("@effect/platform/Path").Path>;
 //#endregion
 //#region src/services/PerClientSessionMap.d.ts
 /** @public */
@@ -1710,12 +3540,12 @@ declare const RunContext_base: Schema.Class<RunContext, {
   readonly gitUpstream: string | null;
 } & {
   readonly gitWorktreeDir: string | null;
+} & {
+  readonly hostMetadata: unknown;
 } & {
   readonly hostSource: string | null;
 } & {
   readonly hostValue: string | null;
-} & {
-  readonly hostMetadata: unknown;
 }, {}, {}>;
 /**
  * Per-run snapshot of the workspace's git state and host context.
@@ -2088,6 +3918,40 @@ declare const BehaviorScopedEventTypes: readonly ["behavior_started", "phase_tra
 /** @public */
 type BehaviorScopedEventType = (typeof BehaviorScopedEventTypes)[number];
 //#endregion
+//#region src/schemas/ConsoleLeaks.d.ts
+/**
+ * Per-file stray-console-output detail. Counts are of console writes
+ * (one `console.*` call), not lines.
+ * @public
+ */
+declare const ConsoleLeakFile: Schema.Struct<{
+  file: typeof Schema.String;
+  stdout: typeof Schema.Number;
+  stderr: typeof Schema.Number;
+  tests: Schema.optional<Schema.Array$<typeof Schema.String>>;
+  sample: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type ConsoleLeakFile = typeof ConsoleLeakFile.Type;
+/**
+ * Aggregate stray-console-output signal for a single test run. Omitted from
+ * a report entirely when the run produced no user console output.
+ * @public
+ */
+declare const ConsoleLeaks: Schema.Struct<{
+  total: typeof Schema.Number;
+  byFile: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    stdout: typeof Schema.Number;
+    stderr: typeof Schema.Number;
+    tests: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    sample: Schema.optional<typeof Schema.String>;
+  }>>;
+  truncated: Schema.optional<typeof Schema.Boolean>;
+}>;
+/** @public */
+type ConsoleLeaks = typeof ConsoleLeaks.Type;
+//#endregion
 //#region src/schemas/CoverageLevel.d.ts
 declare const CoverageLevel_base: Schema.Class<CoverageLevel, {
   lines: typeof Schema.Number;
@@ -2102,15 +3966,15 @@ declare const CoverageLevel_base: Schema.Class<CoverageLevel, {
   statements: typeof Schema.Number;
   perFile: Schema.optional<typeof Schema.Boolean>;
 }>, never, {
-  readonly lines: number;
+  readonly perFile?: boolean | undefined;
+} & {
+  readonly branches: number;
 } & {
   readonly functions: number;
 } & {
-  readonly branches: number;
+  readonly lines: number;
 } & {
   readonly statements: number;
-} & {
-  readonly perFile?: boolean | undefined;
 }, {}, {}>;
 /**
  * A coverage level configuration with per-metric thresholds and an optional
@@ -2796,6 +4660,53 @@ declare function getRecentDirection(record: TrendRecord, count?: number): {
   runCount: number;
 };
 //#endregion
+//#region src/utils/console-leaks.d.ts
+/**
+ * A single captured stray console write, attributed to a file (and a test
+ * when the write happened inside one). Fed to buildConsoleLeaks.
+ * @public
+ */
+interface ConsoleLeakEntry {
+  readonly file: string;
+  readonly test?: string;
+  readonly type: "stdout" | "stderr";
+  readonly content: string;
+}
+/**
+ * Aggregate raw console-leak entries into a ConsoleLeaks signal:
+ * bucket by file, split stdout/stderr, collect attributable test names,
+ * capture one truncated sample per file, sort by total writes descending,
+ * and cap the file list. Returns `undefined` when there are no entries so a
+ * clean run attaches nothing.
+ * @public
+ */
+declare function buildConsoleLeaks(entries: ReadonlyArray<ConsoleLeakEntry>): ConsoleLeaks | undefined;
+/**
+ * Structural subset of a Vitest runner task (File / Suite / Test) carrying
+ * captured console output. Modeled locally so this util needs no `vitest`
+ * dependency. `logs` is attached to tasks by Vitest's console interception
+ * regardless of which reporter is active, which is why the walk survives
+ * reporter stripping in agent mode.
+ * @public
+ */
+interface ConsoleLeakTask {
+  readonly type?: string;
+  readonly name?: string;
+  readonly fullTestName?: string;
+  readonly logs?: ReadonlyArray<{
+    readonly type: "stdout" | "stderr";
+    readonly content: string;
+  }>;
+  readonly tasks?: ReadonlyArray<ConsoleLeakTask>;
+}
+/**
+ * Walk a Vitest `File[]` task tree (from `vitest.state.getFiles()`) into flat
+ * {@link ConsoleLeakEntry} values. Each task `log` becomes one entry attributed
+ * to its enclosing file and, when the log sits on a test task, that test's name.
+ * @public
+ */
+declare function collectConsoleLeakEntries(files: ReadonlyArray<ConsoleLeakTask>): ConsoleLeakEntry[];
+//#endregion
 //#region src/utils/detect-pm.d.ts
 /**
  * Filesystem abstraction for package manager detection.
@@ -3212,7 +5123,7 @@ interface ResolveDataPathOptions {
  * @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, AppDirs | import("config-file-effect").ConfigFileService<VitestAgentConfig>>;
+declare const resolveDataPath: (projectDir: string, options?: ResolveDataPathOptions) => Effect.Effect<any, import("xdg-effect").AppDirsError | import("config-file-effect").ConfigError, AppDirs | import("config-file-effect").ConfigFileService<VitestAgentConfig>>;
 //#endregion
 //#region src/utils/resolve-project-key-from-cwd.d.ts
 /**
@@ -3324,11 +5235,10 @@ declare function validateCoverageTargetsShape(input: unknown): CoverageTargetsSh
  * 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.
+ * substituted yet. Exported for version introspection by downstream tooling.
  * @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 };
+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, ConsoleLeakEntry, ConsoleLeakFile, ConsoleLeakTask, ConsoleLeaks, 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, buildConsoleLeaks, buildEnvPrefix, canonicalizeGitUrl, ciAnnotationsFormatter, classifyTest, collectConsoleLeakEntries, 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, transitionEnforcesBehaviorMatch, validateCoverageConfig, validateCoverageTargetsShape, validatePhaseTransition };
 //# sourceMappingURL=index.d.ts.map