@vitest-agent/engine 0.1.0

package/testing.d.ts

@@ -0,0 +1,1101 @@
+import { Agent, Agent as Agent$1, AgentId, AgentNotFoundError, AgentNotFoundError as AgentNotFoundError$1, AgentReport, AgentReport as AgentReport$1, ArtifactKind, ArtifactKind as ArtifactKind$1, ArtifactKind as ArtifactKind$2, ArtifactSuite, ArtifactSuite as ArtifactSuite$1, ArtifactSuite as ArtifactSuite$2, BehaviorDetail, BehaviorDetail as BehaviorDetail$1, BehaviorNotFoundError, BehaviorNotFoundError as BehaviorNotFoundError$1, BehaviorRow, BehaviorRow as BehaviorRow$1, BehaviorStatus, BehaviorStatus as BehaviorStatus$1, CacheManifest, CacheManifest as CacheManifest$1, ChatId, CitedArtifact, CitedArtifact as CitedArtifact$1, CoverageBaselines, CoverageBaselines as CoverageBaselines$1, CoverageReport, CoverageReport as CoverageReport$1, DataStoreError, DataStoreError as DataStoreError$1, FileCoverageReport, FileCoverageReport as FileCoverageReport$1, GoalDetail, GoalDetail as GoalDetail$1, GoalNotFoundError, GoalNotFoundError as GoalNotFoundError$1, GoalRow, GoalRow as GoalRow$1, GoalStatus, GoalStatus as GoalStatus$1, HistoryRecord, HistoryRecord as HistoryRecord$1, IdempotencyHit, IdempotencyHit as IdempotencyHit$1, IllegalStatusTransitionEntity, IllegalStatusTransitionError, IllegalStatusTransitionError as IllegalStatusTransitionError$1, Phase, Phase as Phase$1, RegistrationConflictError, RegistrationConflictError as RegistrationConflictError$1, ResolvedThresholds, ResolvedThresholds as ResolvedThresholds$1, TddTaskAlreadyEndedError, TddTaskAlreadyEndedError as TddTaskAlreadyEndedError$1, TddTaskEndOutcome, TddTaskNotFoundError, TddTaskNotFoundError as TddTaskNotFoundError$1, TrendEntry, TrendEntry as TrendEntry$1, TrendRecord, TrendRecord as TrendRecord$1 } from "@vitest-agent/sdk";
+import { Context, Effect, Layer, Option } from "effect";
+//#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$1;
+}
+/** @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$1;
+  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 TestAttachmentInput {
+  readonly contentType?: string;
+  /** Post-resolution path under `.vitest/attachments/`, or an http(s) URL. */
+  readonly path?: string;
+  /** Inline body; persisted only when `byteSize` is under the 64 KiB cap. */
+  readonly body?: string;
+  /** How to read `body`. Vitest treats a string body as base64 unless `"utf-8"`. */
+  readonly bodyEncoding?: "base64" | "utf-8";
+  readonly byteSize: number;
+}
+/** @public */
+interface TestAnnotationInput {
+  readonly testCaseId: number;
+  /** Arbitrary Vitest annotation type -- not an enum. */
+  readonly type: string;
+  readonly message: string;
+  readonly locationFile?: string;
+  readonly locationLine?: number;
+  readonly locationColumn?: number;
+  readonly attachments?: ReadonlyArray<TestAttachmentInput>;
+}
+/** @public */
+interface TestArtifactInput {
+  readonly testCaseId: number;
+  /** `pkg:name`; `internal:` types are Vitest's own and are never written. */
+  readonly type: string;
+  readonly message?: string;
+  /** JSON of the artifact's custom fields, minus attachments and location. */
+  readonly data?: string;
+  readonly locationFile?: string;
+  readonly locationLine?: number;
+  readonly locationColumn?: number;
+  readonly attachments?: ReadonlyArray<TestAttachmentInput>;
+}
+/** @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;
+  /**
+   * Canonical conversation UUID this session belongs to (issue #144).
+   * Set once at INSERT time — `sessions.conversation_id` is immutable
+   * thereafter (see the `trg_sessions_conv_id_immutable` trigger), so
+   * omit it here rather than trying to backfill via an update.
+   */
+  readonly conversationId?: 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$1;
+  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$2;
+  readonly fileId?: number;
+  readonly testCaseId?: number;
+  readonly testRunId?: number;
+  readonly testFirstFailureRunId?: number;
+  readonly diffExcerpt?: string;
+  readonly recordedAt: string;
+  /** Issue #363: explicit suite marker. Defaults to `"vitest"` when omitted. */
+  readonly suite?: ArtifactSuite$2;
+}
+/** @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.ServiceClass<DataStore, "vitest-agent/DataStore", {
+  readonly writeSettings: (hash: string, settings: SettingsInput, envVars: Record<string, string>) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeRun: (input: TestRunInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly writeModules: (runId: number, modules: ReadonlyArray<ModuleInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError$1>;
+  readonly writeSuites: (moduleId: number, suites: ReadonlyArray<SuiteInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError$1>;
+  readonly writeTestCases: (moduleId: number, tests: ReadonlyArray<TestCaseInput>) => Effect.Effect<ReadonlyArray<number>, DataStoreError$1>;
+  readonly writeErrors: (runId: number, errors: ReadonlyArray<TestErrorInput>) => Effect.Effect<void, DataStoreError$1>;
+  /**
+   * Persist `context.annotate` notes and their attachment descriptors.
+   * `runId` is carried for log correlation only -- `test_annotations`
+   * rows are reachable through `test_cases`.
+   */
+  readonly writeAnnotations: (runId: number, annotations: ReadonlyArray<TestAnnotationInput>) => Effect.Effect<void, DataStoreError$1>;
+  /**
+   * Persist `recordArtifact` payloads and their attachment
+   * descriptors. `runId` is carried for log correlation only.
+   */
+  readonly writeArtifacts: (runId: number, artifacts: ReadonlyArray<TestArtifactInput>) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeCoverage: (runId: number, coverage: ReadonlyArray<FileCoverageInput>) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeHistory: (project: string, fullName: string, modulePath: string, runId: number, timestamp: string, state: string, duration: number | null, flaky: boolean, retryCount: number, errorMessage: string | null) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeBaselines: (baselines: CoverageBaselines$1) => Effect.Effect<void, DataStoreError$1>;
+  /**
+   * Persist the resolved (enforced) Vitest `coverage.thresholds` for the
+   * current run, distinct from the ratcheted `coverage_baselines` rows.
+   * Stored under `kind='threshold'`. See issue #237.
+   */
+  readonly writeThresholds: (thresholds: ResolvedThresholds$1) => Effect.Effect<void, DataStoreError$1>;
+  /**
+   * Persist the resolved aspirational `coverageTargets` for the current
+   * run, distinct from the ratcheted `coverage_baselines` rows. Stored
+   * under `kind='target'`. See issue #237.
+   */
+  readonly writeTargets: (targets: ResolvedThresholds$1) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeTrends: (project: string, runId: number, entry: TrendEntry$1) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeSourceMap: (sourceFilePath: string, testModuleId: number, mappingType: string) => Effect.Effect<void, DataStoreError$1>;
+  readonly ensureFile: (filePath: string) => Effect.Effect<number, DataStoreError$1>;
+  readonly writeNote: (note: NoteInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly updateNote: (id: number, fields: Partial<NoteInput>) => Effect.Effect<void, DataStoreError$1>;
+  readonly deleteNote: (id: number) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeSession: (input: SessionInput) => Effect.Effect<number, DataStoreError$1>;
+  /**
+   * 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$1>;
+  /**
+   * Backfill `sessions.conversation_id` for a row that was inserted
+   * before the canonical conversation id was known (issue #144) —
+   * `record session-start` always precedes `register-agent`, so the
+   * session row exists first. Race-safe and idempotent: the UPDATE's
+   * `WHERE conversation_id IS NULL` guard means a session that
+   * already carries a value is left untouched (zero rows affected),
+   * matching the trigger's null→value-only relaxation rather than
+   * risking an immutability-violation error on a redundant call.
+   */
+  readonly setSessionConversationIdIfNull: (input: {
+    readonly sessionId: number;
+    readonly conversationId: string;
+  }) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeTurn: (input: TurnInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly writeFailureSignature: (input: FailureSignatureWriteInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly endSession: (chatId: string, endedAt: string, endReason: string | null) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeHypothesis: (input: HypothesisInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly validateHypothesis: (input: ValidateHypothesisInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeTddTask: (input: TddTaskInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly endTddTask: (input: EndTddTaskInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly createGoal: (input: CreateGoalInput) => Effect.Effect<GoalRow$1, DataStoreError$1 | TddTaskNotFoundError$1 | TddTaskAlreadyEndedError$1>;
+  readonly getGoal: (id: number) => Effect.Effect<Option.Option<GoalRow$1>, DataStoreError$1>;
+  readonly updateGoal: (input: UpdateGoalInput) => Effect.Effect<GoalRow$1, DataStoreError$1 | GoalNotFoundError$1 | TddTaskAlreadyEndedError$1 | IllegalStatusTransitionError$1>;
+  readonly deleteGoal: (id: number) => Effect.Effect<void, DataStoreError$1 | GoalNotFoundError$1>;
+  readonly listGoalsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<GoalRow$1>, DataStoreError$1 | TddTaskNotFoundError$1>;
+  readonly createBehavior: (input: CreateBehaviorInput) => Effect.Effect<BehaviorRow$1, DataStoreError$1 | GoalNotFoundError$1 | BehaviorNotFoundError$1 | TddTaskAlreadyEndedError$1 | IllegalStatusTransitionError$1>;
+  readonly getBehavior: (id: number) => Effect.Effect<Option.Option<BehaviorRow$1>, DataStoreError$1>;
+  readonly updateBehavior: (input: UpdateBehaviorInput) => Effect.Effect<BehaviorRow$1, DataStoreError$1 | BehaviorNotFoundError$1 | TddTaskAlreadyEndedError$1 | IllegalStatusTransitionError$1>;
+  readonly deleteBehavior: (id: number) => Effect.Effect<void, DataStoreError$1 | BehaviorNotFoundError$1>;
+  readonly listBehaviorsByGoal: (goalId: number) => Effect.Effect<ReadonlyArray<BehaviorRow$1>, DataStoreError$1 | GoalNotFoundError$1>;
+  readonly listBehaviorsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<BehaviorRow$1>, DataStoreError$1 | TddTaskNotFoundError$1>;
+  readonly writeTddPhase: (input: WriteTddPhaseInput) => Effect.Effect<WriteTddPhaseOutput, DataStoreError$1>;
+  readonly writeTddArtifact: (input: WriteTddArtifactInput) => Effect.Effect<number, DataStoreError$1>;
+  readonly writeCommit: (input: WriteCommitInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly writeRunChangedFiles: (input: WriteRunChangedFilesInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly recordIdempotentResponse: (input: IdempotentResponseInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly pruneSessions: (keepRecent: number) => Effect.Effect<{
+    readonly affectedSessions: number;
+    readonly prunedTurns: number;
+  }, DataStoreError$1>;
+  readonly associateLatestRunWithSession: (input: AssociateRunSessionInput) => Effect.Effect<void, DataStoreError$1>;
+  readonly backfillTestCaseTurns: (chatId: string) => Effect.Effect<number, DataStoreError$1>;
+  /**
+   * 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$1 | IdempotencyHit$1, RegistrationConflictError$1 | DataStoreError$1>;
+  /**
+   * 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$1 | DataStoreError$1>;
+}>;
+/** @public */
+export declare class DataStore extends DataStore_base {}
+//#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 modulePath: string;
+  readonly project: string;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly lastState: "passed" | "failed";
+  readonly lastTimestamp: string;
+}
+/** @public */
+interface PersistentFailure {
+  readonly fullName: string;
+  readonly modulePath: 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;
+  /** Canonical conversation UUID this session belongs to (issue #144), null when unset. */
+  readonly conversationId: 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 HistoryQueryOptions {
+  /** Exact `full_name` match — narrows to a single test's history. */
+  readonly testName?: string;
+  /** Exact `module_path` match — narrows to tests in one file. */
+  readonly modulePath?: string;
+  /** Max runs kept per (module_path, full_name) pair, most-recent-first. Default 20. */
+  readonly limit?: number;
+}
+/**
+ * Narrowing options shared by the classification reads
+ * (`DataReader.getFlaky` / `getPersistentFailures`). Mirrors the
+ * `testName` / `modulePath` half of {@link HistoryQueryOptions} so a
+ * caller that scoped `getHistory` to one test can scope the derived
+ * classifications to the same test instead of receiving the whole
+ * project's rows.
+ *
+ * @public
+ */
+interface ClassificationQueryOptions {
+  /** Exact `full_name` match — narrows to a single test's classification. */
+  readonly testName?: string;
+  /** Exact `module_path` match — narrows to tests in one file. */
+  readonly modulePath?: string;
+}
+/**
+ * Narrowing options for `DataReader.getTestByFullName`. A
+ * `full_name` is not file-qualified (Decision D20), so the same name can
+ * exist in more than one module; `modulePath` disambiguates.
+ *
+ * @public
+ */
+interface TestLookupOptions {
+  /** Exact `module_path` match — picks one variant of an ambiguous `full_name`. */
+  readonly modulePath?: 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$1>;
+  readonly phases: ReadonlyArray<TddPhaseDetail>;
+  readonly artifacts: ReadonlyArray<TddArtifactDetail>;
+}
+/** @public */
+interface CurrentTddPhase {
+  readonly id: number;
+  readonly phase: Phase$1;
+  readonly startedAt: string;
+  readonly behaviorId: number | null;
+}
+/** @public */
+interface CitedArtifactRow extends CitedArtifact$1 {
+  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$1;
+  readonly artifactKind: ArtifactKind$1;
+  readonly behaviorId: number | null;
+  readonly testCaseId: number | null;
+  readonly testRunId: number | null;
+  readonly testFirstFailureRunId: number | null;
+  readonly recordedAt: string;
+  readonly suite: ArtifactSuite$1;
+}
+/** @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;
+}
+/** @public */
+interface TestArtifactQueryOptions {
+  /** Disambiguates a fullName that exists in more than one module. */
+  readonly modulePath?: string;
+}
+/** @public */
+interface PersistedAttachment {
+  readonly contentType?: string;
+  readonly path?: string;
+  readonly body?: string;
+  /** How to read `body`. Absent when nothing was stored inline. */
+  readonly bodyEncoding?: "base64" | "utf-8";
+  readonly byteSize: number | null;
+}
+/** @public */
+interface TestAnnotationRow {
+  readonly id: number;
+  readonly type: string;
+  readonly message: string;
+  readonly location?: {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+  };
+  readonly attachments: ReadonlyArray<PersistedAttachment>;
+}
+/** @public */
+interface TestArtifactRow {
+  readonly id: number;
+  readonly type: string;
+  readonly message: string | null;
+  readonly data: string | null;
+  readonly location?: {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+  };
+  readonly attachments: ReadonlyArray<PersistedAttachment>;
+}
+declare const DataReader_base: Context.ServiceClass<DataReader, "vitest-agent/DataReader", {
+  readonly getLatestRun: (project: string) => Effect.Effect<Option.Option<AgentReport$1>, DataStoreError$1>;
+  readonly getRunsByProject: () => Effect.Effect<ReadonlyArray<ProjectRunSummary>, DataStoreError$1>;
+  readonly getHistory: (project: string, options?: HistoryQueryOptions) => Effect.Effect<HistoryRecord$1, DataStoreError$1>;
+  readonly getBaselines: (project: string) => Effect.Effect<Option.Option<CoverageBaselines$1>, DataStoreError$1>;
+  readonly getTrends: (project: string, limit?: number) => Effect.Effect<Option.Option<TrendRecord$1>, DataStoreError$1>;
+  readonly getFlaky: (project: string, options?: ClassificationQueryOptions) => Effect.Effect<ReadonlyArray<FlakyTest>, DataStoreError$1>;
+  readonly getPersistentFailures: (project: string, options?: ClassificationQueryOptions) => Effect.Effect<ReadonlyArray<PersistentFailure>, DataStoreError$1>;
+  readonly getFileCoverage: (runId: number) => Effect.Effect<ReadonlyArray<FileCoverageReport$1>, DataStoreError$1>;
+  readonly getCoverage: (project: string) => Effect.Effect<Option.Option<CoverageReport$1>, DataStoreError$1>;
+  readonly getTestsForFile: (filePath: string) => Effect.Effect<ReadonlyArray<string>, DataStoreError$1>;
+  readonly getErrors: (project: string, errorName?: string) => Effect.Effect<ReadonlyArray<TestError>, DataStoreError$1>;
+  /** Annotations recorded for a test in the project's latest run. */
+  readonly getAnnotationsForTest: (project: string, fullName: string, options?: TestArtifactQueryOptions) => Effect.Effect<ReadonlyArray<TestAnnotationRow>, DataStoreError$1>;
+  /** Artifacts recorded for a test in the project's latest run. */
+  readonly getArtifactsForTest: (project: string, fullName: string, options?: TestArtifactQueryOptions) => Effect.Effect<ReadonlyArray<TestArtifactRow>, DataStoreError$1>;
+  readonly getNotes: (scope?: string, project?: string, testFullName?: string) => Effect.Effect<ReadonlyArray<NoteRow>, DataStoreError$1>;
+  readonly getNoteById: (id: number) => Effect.Effect<Option.Option<NoteRow>, DataStoreError$1>;
+  readonly searchNotes: (query: string) => Effect.Effect<ReadonlyArray<NoteRow>, DataStoreError$1>;
+  readonly getManifest: () => Effect.Effect<Option.Option<CacheManifest$1>, DataStoreError$1>;
+  readonly getSettings: (hash: string) => Effect.Effect<Option.Option<SettingsRow>, DataStoreError$1>;
+  readonly getLatestSettings: () => Effect.Effect<Option.Option<SettingsRow>, DataStoreError$1>;
+  readonly getTestByFullName: (project: string, fullName: string, options?: TestLookupOptions) => Effect.Effect<Option.Option<TestListEntry>, DataStoreError$1>;
+  /**
+   * Every module path in the project's latest run that carries a test
+   * case with this exact `full_name`, ordered ascending. Length > 1
+   * means the name is ambiguous and callers must disambiguate with
+   * {@link TestLookupOptions.modulePath} rather than guess.
+   */
+  readonly getTestModulesByFullName: (project: string, fullName: string) => Effect.Effect<ReadonlyArray<string>, DataStoreError$1>;
+  readonly listTests: (project: string, options?: {
+    state?: string;
+    module?: string;
+    limit?: number;
+  }) => Effect.Effect<ReadonlyArray<TestListEntry>, DataStoreError$1>;
+  readonly listModules: (project: string) => Effect.Effect<ReadonlyArray<ModuleListEntry>, DataStoreError$1>;
+  readonly listSuites: (project: string, options?: {
+    module?: string;
+  }) => Effect.Effect<ReadonlyArray<SuiteListEntry>, DataStoreError$1>;
+  readonly listSettings: () => Effect.Effect<ReadonlyArray<SettingsListEntry>, DataStoreError$1>;
+  readonly getSessionById: (id: number) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError$1>;
+  readonly getSessionByChatId: (chatId: string) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError$1>;
+  /**
+   * 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$1>;
+  /**
+   * 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$1>;
+  /**
+   * Resolve the session a TDD task was opened under: the `sessions`
+   * row whose `id` equals `tdd_tasks.session_id` for `tddTaskId`.
+   * Returns `Option.none` when the task — or its session — does not
+   * exist. Lets `hypothesis (action: record)` bind a hypothesis
+   * deterministically from the orchestrator's unambiguous
+   * `tddTaskId` (returned by `tdd_task (action: start)`) instead of
+   * the fragile recovered host context or a caller-guessed
+   * `sessionId`.
+   */
+  readonly getSessionByTddTaskId: (tddTaskId: number) => Effect.Effect<Option.Option<SessionDetail>, DataStoreError$1>;
+  readonly listSessions: (options: {
+    readonly project?: string;
+    readonly agentKind?: "main" | "subagent";
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<SessionDetail>, DataStoreError$1>;
+  readonly searchTurns: (options: TurnSearchOptions) => Effect.Effect<ReadonlyArray<TurnSummary>, DataStoreError$1>;
+  readonly computeAcceptanceMetrics: () => Effect.Effect<AcceptanceMetrics, DataStoreError$1>;
+  readonly getFailureSignatureByHash: (hash: string) => Effect.Effect<Option.Option<FailureSignatureDetail>, DataStoreError$1>;
+  readonly getTddTaskById: (id: number) => Effect.Effect<Option.Option<TddTaskDetail>, DataStoreError$1>;
+  readonly getGoalById: (id: number) => Effect.Effect<Option.Option<GoalDetail$1>, DataStoreError$1>;
+  readonly getGoalsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<GoalDetail$1>, DataStoreError$1>;
+  readonly getBehaviorById: (id: number) => Effect.Effect<Option.Option<BehaviorDetail$1>, DataStoreError$1>;
+  readonly getBehaviorsByGoal: (goalId: number) => Effect.Effect<ReadonlyArray<BehaviorRow$1>, DataStoreError$1>;
+  readonly getBehaviorsByTddTask: (tddTaskId: number) => Effect.Effect<ReadonlyArray<BehaviorRow$1>, DataStoreError$1>;
+  readonly getBehaviorDependencies: (behaviorId: number) => Effect.Effect<ReadonlyArray<BehaviorRow$1>, DataStoreError$1>;
+  readonly resolveGoalIdForBehavior: (behaviorId: number) => Effect.Effect<Option.Option<number>, DataStoreError$1>;
+  readonly getCurrentTddPhase: (tddTaskId: number) => Effect.Effect<Option.Option<CurrentTddPhase>, DataStoreError$1>;
+  readonly getTddArtifactWithContext: (artifactId: number) => Effect.Effect<Option.Option<CitedArtifactRow>, DataStoreError$1>;
+  readonly getCommitChanges: (sha?: string) => Effect.Effect<ReadonlyArray<CommitChangesEntry>, DataStoreError$1>;
+  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;
+    /**
+     * When true AND `sessionId`'s session has a non-null
+     * `conversation_id`, also return tdd_tasks belonging to
+     * any OTHER session sharing that `conversation_id` — the
+     * detached-session fallback (issue #144). A session with
+     * a null `conversation_id` never triggers this fallback.
+     * Rows are ordered so a task owned by an `agent_kind =
+     * 'main'` session sorts first, then by `started_at DESC`.
+     * Default `false` preserves the prior contract.
+     */
+    readonly walkConversation?: boolean;
+  }) => Effect.Effect<ReadonlyArray<TddTaskSummary>, DataStoreError$1>;
+  /**
+   * Diagnostic for the `missing_artifact_evidence` phase-transition
+   * denial (issue #144): counts `tdd_artifacts` rows recorded at or
+   * after `sinceIso` under sessions OTHER than the one that opened
+   * `tddTaskId`, but sharing that session's `conversation_id`. Used
+   * to tell an agent "your hooks may be attributing to a detached
+   * session" rather than a bare "no artifact found". Returns 0 when
+   * `tddTaskId` is unknown or its session's `conversation_id` is
+   * null — the diagnostic never fabricates a signal it cannot back.
+   */
+  readonly countRecentArtifactsInOtherSessionsOfConversation: (input: {
+    readonly tddTaskId: number;
+    readonly sinceIso: string;
+  }) => Effect.Effect<number, DataStoreError$1>;
+  /**
+   * 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$1;
+    readonly phaseId?: number;
+    readonly behaviorId?: number;
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<TddArtifactRow>, DataStoreError$1>;
+  readonly listHypotheses: (options: {
+    readonly sessionId?: number;
+    readonly outcome?: "confirmed" | "refuted" | "abandoned" | "open";
+    readonly limit?: number;
+  }) => Effect.Effect<ReadonlyArray<HypothesisDetail>, DataStoreError$1>;
+  readonly findIdempotentResponse: (procedurePath: string, key: string) => Effect.Effect<Option.Option<string>, DataStoreError$1>;
+  readonly getLatestTestCaseForSession: (chatId: string) => Effect.Effect<Option.Option<number>, DataStoreError$1>;
+  /**
+   * 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$1>;
+  /**
+   * 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$1>;
+}>;
+/** @public */
+export declare class DataReader extends DataReader_base {}
+//#endregion
+//#region src/migrations/index.d.ts
+/**
+ * Every migration that must run against a per-project `data.db`, keyed by
+ * migration id in application order.
+ *
+ * This is the single source of truth for the project database's migration
+ * set: `makeSqliteStack` (and through it `PlatformLive`, `ensureMigrated`,
+ * the testing layers, `ReporterLive` and `SidecarLive`) defaults to it when
+ * calling `SqliteMigrator.fromRecord`, so adding a migration file and
+ * registering it here is enough to reach every process that opens a project
+ * database.
+ *
+ * The session-map and discovery-registry databases are separate schemas with
+ * their own migrations and are deliberately not listed here.
+ *
+ * @public
+ */
+export declare const PROJECT_MIGRATIONS: {
+  readonly "0001_initial": import("effect/Effect").Effect<void, import("effect/unstable/sql/SqlError").SqlError, import("effect/unstable/sql/SqlClient").SqlClient>;
+  readonly "0002_test_artifacts": import("effect/Effect").Effect<void, import("effect/unstable/sql/SqlError").SqlError, import("effect/unstable/sql/SqlClient").SqlClient>;
+};
+//#endregion
+//#region src/testing/layers.d.ts
+/** @public */
+export declare function makeTestLayer(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+/** @public */
+export declare const DataStoreTestLayer: Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+//#endregion
+//#region src/testing/index.d.ts
+/** @public */
+export declare function empty(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+/** @public */
+export declare function singlePassingRun(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@vitest-agent/sdk").DataStoreError | import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+/** @public */
+export declare function withFailures(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@vitest-agent/sdk").DataStoreError | import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+/** @public */
+export declare function flaky(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@vitest-agent/sdk").DataStoreError | import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+/** @public */
+export declare function withTddTask(filename: string): Layer.Layer<DataReader | DataStore | import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, import("@vitest-agent/sdk").BehaviorNotFoundError | import("@vitest-agent/sdk").DataStoreError | import("@vitest-agent/sdk").GoalNotFoundError | import("@vitest-agent/sdk").IllegalStatusTransitionError | import("@effect/sql-sqlite-node/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError | import("@vitest-agent/sdk").TddTaskAlreadyEndedError | import("@vitest-agent/sdk").TddTaskNotFoundError, never>;
+//#endregion
+export { type AcceptanceMetrics, Agent, AgentId, AgentNotFoundError, AgentReport, type ArtifactKind, type ArtifactSuite, type AssociateRunSessionInput, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, type ChangeKind, ChatId, type CitedArtifact, type CitedArtifactRow, type ClassificationQueryOptions, type CommitChangesEntry, CoverageBaselines, CoverageReport, type CreateBehaviorInput, type CreateGoalInput, type CurrentTddPhase, DataStoreError, type EndTddTaskInput, type FailureSignatureDetail, type FailureSignatureWriteInput, type FileCoverageInput, FileCoverageReport, type FlakyTest, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, type HistoryQueryOptions, HistoryRecord, type HypothesisDetail, type HypothesisInput, IdempotencyHit, type IdempotentResponseInput, type IllegalStatusTransitionEntity, IllegalStatusTransitionError, type ModuleInput, type ModuleListEntry, type NoteInput, type NoteRow, type PersistedAttachment, type PersistentFailure, type Phase, type ProjectRunSummary, type RegisterAgentInput, RegistrationConflictError, type ResolvedThresholds, 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 TestAnnotationInput, type TestAnnotationRow, type TestArtifactInput, type TestArtifactQueryOptions, type TestArtifactRow, type TestAttachmentInput, type TestCaseInput, type TestError, type TestErrorInput, type TestListEntry, type TestLookupOptions, 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 };
+//# sourceMappingURL=testing.d.ts.map