@vitest-agent/sdk 1.0.0 → 1.1.0

package/testing.d.ts

@@ -1,25 +1,1538 @@
-import { Ft as IllegalStatusTransitionError, It as TddTaskAlreadyEndedError, Lt as TddTaskEndOutcome, Mt as BehaviorNotFoundError, Nt as GoalNotFoundError, Pt as IllegalStatusTransitionEntity, Rt as TddTaskNotFoundError, a as DataReader, j as DataStore, zt as DataStoreError } from "./DataReader-2kJ9I9Hh.js";
-import { Layer } from "effect";
+import { Context, Effect, Layer, Option, Schema } from "effect";
 import * as NodeContext from "@effect/platform-node/NodeContext";
 import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
 
+//#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 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>;
+//#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>;
+/**
+ * `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 AgentNotFoundError extends AgentNotFoundError_base<{
+  readonly agentId: AgentId;
+  readonly chatId?: ChatId;
+}> {}
+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 reason: string;
+  });
+}
+//#endregion
+//#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>;
+/**
+ * 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;
+  });
+}
+//#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/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;
+}> {}
+//#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/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;
+}
+//#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 */
+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 */
+interface WriteCommitInput {
+  readonly sha: string;
+  readonly parentSha?: string;
+  readonly message?: string;
+  readonly author?: string;
+  readonly committedAt?: string;
+  readonly branch?: string;
+}
+/** @public */
+type ChangeKind = "added" | "modified" | "deleted" | "renamed" | "untracked-modified";
+/** @public */
+interface RunChangedFile {
+  readonly filePath: string;
+  readonly changeKind: ChangeKind;
+  readonly commitSha?: string;
+}
+/** @public */
+interface WriteRunChangedFilesInput {
+  readonly runId: number;
+  readonly files: ReadonlyArray<RunChangedFile>;
+}
+/** @public */
+type RunInvocationMethod = "bash" | "mcp" | "cli";
+/**
+ * Input to `DataStore.registerAgent`.
+ *
+ * `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.
+ *
+ * `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
+ */
+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/schemas/AgentReport.d.ts
+/**
+ * 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/CacheManifest.d.ts
+/**
+ * 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/Coverage.d.ts
+/**
+ * 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/History.d.ts
+/**
+ * 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/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;
+}
+/**
+ * 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.
+ *
+ * @public
+ */
+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/testing/layers.d.ts
 /** @public */
-declare function makeTestLayer(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | NodeContext.NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | SqliteMigrator.MigrationError, never>;
+declare function makeTestLayer(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | NodeContext.NodeContext, SqliteMigrator.MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 /** @public */
-declare const DataStoreTestLayer: Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | NodeContext.NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | SqliteMigrator.MigrationError, never>;
+declare const DataStoreTestLayer: Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | NodeContext.NodeContext, SqliteMigrator.MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 //#endregion
 //#region src/testing/index.d.ts
 /** @public */
-declare function empty(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError, never>;
+declare function empty(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeContext").NodeContext, import("@effect/sql/Migrator").MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 /** @public */
-declare function singlePassingRun(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+declare function singlePassingRun(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeContext").NodeContext, DataStoreError | import("@effect/sql/Migrator").MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 /** @public */
-declare function withFailures(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+declare function withFailures(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeContext").NodeContext, DataStoreError | import("@effect/sql/Migrator").MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 /** @public */
-declare function flaky(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+declare function flaky(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeContext").NodeContext, DataStoreError | import("@effect/sql/Migrator").MigrationError | import("@effect/sql/SqlError").SqlError | import("effect/ConfigError").ConfigError, never>;
 /** @public */
-declare function withTddTask(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError | TddTaskNotFoundError | TddTaskAlreadyEndedError | GoalNotFoundError | IllegalStatusTransitionError | BehaviorNotFoundError, never>;
+declare function withTddTask(filename: string): Layer.Layer<DataReader | DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeContext").NodeContext, BehaviorNotFoundError | DataStoreError | GoalNotFoundError | IllegalStatusTransitionError | import("@effect/sql/Migrator").MigrationError | import("@effect/sql/SqlError").SqlError | TddTaskAlreadyEndedError | TddTaskNotFoundError | import("effect/ConfigError").ConfigError, never>;
 //#endregion
-export { BehaviorNotFoundError, DataReader, DataStore, DataStoreError, DataStoreTestLayer, GoalNotFoundError, type IllegalStatusTransitionEntity, IllegalStatusTransitionError, TddTaskAlreadyEndedError, type TddTaskEndOutcome, TddTaskNotFoundError, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };
+export { type AcceptanceMetrics, Agent, AgentId, AgentNotFoundError, AgentReport, type ArtifactKind, type AssociateRunSessionInput, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, type ChangeKind, ChatId, type CitedArtifact, type CitedArtifactRow, type CommitChangesEntry, CoverageBaselines, CoverageReport, type CreateBehaviorInput, type CreateGoalInput, type CurrentTddPhase, DataReader, DataStore, DataStoreError, DataStoreTestLayer, type EndTddTaskInput, type FailureSignatureDetail, type FailureSignatureWriteInput, type FileCoverageInput, FileCoverageReport, type FlakyTest, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, type HypothesisDetail, type HypothesisInput, IdempotencyHit, type IdempotentResponseInput, type IllegalStatusTransitionEntity, IllegalStatusTransitionError, type ModuleInput, type ModuleListEntry, type NoteInput, type NoteRow, type PersistentFailure, type Phase, type ProjectRunSummary, type RegisterAgentInput, RegistrationConflictError, type RunChangedFile, type RunInvocationMethod, type SessionDetail, type SessionInput, type SettingsInput, type SettingsListEntry, type SettingsRow, type StackFrameInput, type SuiteInput, type SuiteListEntry, type TagInventoryRow, type TddArtifactDetail, type TddArtifactRow, type TddPhaseDetail, TddTaskAlreadyEndedError, type TddTaskDetail, type TddTaskEndOutcome, type TddTaskInput, TddTaskNotFoundError, type TddTaskSummary, type TestCaseInput, type TestError, type TestErrorInput, type TestListEntry, type TestRunInput, TrendEntry, TrendRecord, type TurnInput, type TurnSearchOptions, type TurnSummary, type UpdateBehaviorInput, type UpdateGoalInput, type ValidateHypothesisInput, type WriteCommitInput, type WriteRunChangedFilesInput, type WriteTddArtifactInput, type WriteTddPhaseInput, type WriteTddPhaseOutput, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };
 //# sourceMappingURL=testing.d.ts.map