@vitest-agent/engine 1.1.2 → 2.0.0

package/index.d.ts

@@ -1,8 +1,8 @@
 import { Context, Effect, FileSystem, Layer, LogLevel, Option, Path, Schema } from "effect";
 import { ConfigFileShape } from "@effected/config-file";
-import { Agent, AgentNotFoundError, AgentReport, ArtifactKind, ArtifactKind as ArtifactKind$1, ArtifactSuite, ArtifactSuite as ArtifactSuite$1, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, CitedArtifact, CoverageBaselines, CoverageReport, DataStoreError, DetailLevel, DiscoveryError, Environment, Executor, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, Phase, ProjectIdentityNotResolvableError, RegistrationConflictError, ResolvedThresholds, TddTaskAlreadyEndedError, TddTaskNotFoundError, TestClassification, TestRun, TrendEntry, TrendRecord, TurnPayload, VitestAgentConfig } from "@vitest-agent/sdk";
+import { Agent, AgentNotFoundError, AgentReport, ArtifactKind, ArtifactKind as ArtifactKind$1, ArtifactSuite, ArtifactSuite as ArtifactSuite$1, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, CitedArtifact, CoverageBaselines, CoverageReport, DataStoreError, DetailLevel, DiscoveryError, Environment, Executor, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, Phase, ProjectIdentityError, ProjectIdentityNotResolvableError, RegistrationConflictError, ResolvedThresholds, RunRetentionPolicy, StrayOutput, TddTaskAlreadyEndedError, TddTaskNotFoundError, TestClassification, TestRun, TrendEntry, TrendRecord, TurnPayload, VitestAgentConfig } from "@vitest-agent/sdk";
 import { SqlClient } from "effect/sql/SqlClient";
-import { RuntimeEnv } from "@effected/env";
+import { CiName, RuntimeEnv } from "@effected/env";
 import { WorkspaceDiscovery, WorkspaceDiscoveryFailure, WorkspaceRootNotFoundError } from "@effected/workspaces";
 import { AppDirs, AppDirsError, XdgEnvError } from "@effected/xdg";
 import { ChildProcessSpawner } from "effect/process";
@@ -141,6 +141,13 @@ export interface TestRunInput {
   readonly hostSource?: string | null;
   readonly hostValue?: string | null;
   readonly hostMetadata?: Record<string, unknown> | null;
+  /**
+   * Output the run wrote straight to the terminal past Vitest's console
+   * capture (issue 578). A run-level signal: every project row of one
+   * invocation carries the same value. Omitted or `null` when the run
+   * recorded nothing, which the row stores as NULL in every `stray_*` column.
+   */
+  readonly strayOutput?: StrayOutput | null;
 }
 /** @public */
 export interface ModuleInput {
@@ -457,6 +464,15 @@ export interface RegisterAgentInput {
    */
   readonly agentId?: string;
 }
+/**
+ * What `DataStore.pruneRuns` removed: `test_runs` rows deleted (their
+ * cascaded rows are not counted) and orphaned `files` rows garbage-collected.
+ * @public
+ */
+export interface PruneRunsResult {
+  readonly prunedRuns: number;
+  readonly prunedFiles: number;
+}
 /** @public */
 export interface AssociateRunSessionInput {
   readonly chatId: string;
@@ -554,6 +570,25 @@ declare const DataStore_base: Context.ServiceClass<DataStore, "vitest-agent/Data
     readonly affectedSessions: number;
     readonly prunedTurns: number;
   }, DataStoreError>;
+  /**
+   * Apply a run-retention policy: delete every `test_runs` row beyond the
+   * newest `policy.keepRuns` of its project, and any run older than
+   * `policy.maxAgeDays` days when set, letting the schema's cascades drop
+   * the dependent rows (modules, suites, cases, tags, errors, frames,
+   * coverage, trends, triggers), then garbage-collect `files` rows no
+   * table references any more. `test_history` rows survive with a NULL
+   * `run_id`; they keep their own newest-10-per-series window. Before
+   * the delete, `file_coverage` rows held by a doomed run are moved onto
+   * the lowest surviving run of the same invocation (coverage is written
+   * once per invocation, issue 622) unless a survivor already carries
+   * coverage rows, so every sibling project's coverage read stays whole.
+   *
+   * A handful of synchronous statements on the open connection, no
+   * yielding, so it may run inside `withPersistTransaction` after the
+   * run's own rows are written: the run just written is the newest of
+   * its project and is never pruned.
+   */
+  readonly pruneRuns: (policy: RunRetentionPolicy) => Effect.Effect<PruneRunsResult, DataStoreError>;
   readonly associateLatestRunWithSession: (input: AssociateRunSessionInput) => Effect.Effect<void, DataStoreError>;
   readonly backfillTestCaseTurns: (chatId: string) => Effect.Effect<number, DataStoreError>;
   /**
@@ -587,6 +622,32 @@ export interface ProjectRunSummary {
   readonly passed: number;
   readonly failed: number;
   readonly skipped: number;
+  /** The latest run's stray output (issue 578); `null` when it recorded none. */
+  readonly strayOutput: StrayOutput | null;
+}
+/**
+ * Options for `DataReader.getStrayOutputHistory`.
+ * @public
+ */
+export interface StrayOutputHistoryOptions {
+  /** Only runs of this project; every project otherwise. */
+  readonly project?: string;
+  /** How many of the most recent runs to consider. Default 10. */
+  readonly limit?: number;
+}
+/**
+ * How often recent runs wrote stray output (issue 578). A "run" is one
+ * reporter invocation: stray output is a run-level signal that every project
+ * row of an invocation repeats, so rows are counted once per `invocation_id`.
+ * @public
+ */
+export interface StrayOutputHistory {
+  /** Runs considered: the most recent ones, up to the requested limit. */
+  readonly runs: number;
+  /** How many of them recorded any stray output. */
+  readonly runsWithStrayOutput: number;
+  /** The most recent run's stray output, when that run recorded any. */
+  readonly latest: StrayOutput | null;
 }
 /** @public */
 export interface FlakyTest {
@@ -945,6 +1006,8 @@ export interface TestArtifactRow {
 declare const DataReader_base: Context.ServiceClass<DataReader, "vitest-agent/DataReader", {
   readonly getLatestRun: (project: string) => Effect.Effect<Option.Option<AgentReport>, DataStoreError>;
   readonly getRunsByProject: () => Effect.Effect<ReadonlyArray<ProjectRunSummary>, DataStoreError>;
+  /** How often the most recent runs wrote stray output; see {@link StrayOutputHistory}. */
+  readonly getStrayOutputHistory: (options?: StrayOutputHistoryOptions) => Effect.Effect<StrayOutputHistory, DataStoreError>;
   readonly getHistory: (project: string, options?: HistoryQueryOptions) => 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>;
@@ -1177,8 +1240,21 @@ declare const EnvironmentDetector_base: Context.ServiceClass<EnvironmentDetector
   readonly detect: () => Effect.Effect<Environment>;
   readonly isAgent: Effect.Effect<boolean>;
   readonly agentName: Effect.Effect<string | undefined>;
+  readonly ci: Effect.Effect<Option.Option<CiName>>;
 }>;
-/** @public */
+/**
+ * Who is running the program and where.
+ *
+ * @remarks
+ * `detect` is the console audience: an agent marker wins over CI, so an
+ * agent inside GitHub Actions reads `agent-shell`. `ci` is the CI vendor
+ * independently of that precedence, so a caller can keep GitHub-only
+ * extras (the step summary, annotations, the `github-actions` reporter)
+ * on for the humans reviewing the job even when the console audience is
+ * the agent (issue #624).
+ *
+ * @public
+ */
 export declare class EnvironmentDetector extends EnvironmentDetector_base {}
 /**
  * Pure classification behind {@link EnvironmentDetectorLive}: an agent shell
@@ -1207,9 +1283,21 @@ export declare const classifyEnvironment: (runtime: RuntimeEnv) => Environment;
  * @public
  */
 export declare const EnvironmentDetectorLive: (env: Record<string, string | undefined>) => Layer.Layer<EnvironmentDetector>;
-/** @public */
+/**
+ * A fixed `EnvironmentDetector` for tests.
+ *
+ * @remarks
+ * `ci` defaults to the vendor the environment implies (`ci-github` is
+ * GitHub Actions, `ci-generic` another CI, the rest none). Pass
+ * `options.ci` to decouple the two, as the live detector does for an agent
+ * running inside GitHub Actions: `layer("agent-shell", { ci: "github-actions" })`.
+ *
+ * @public
+ */
 export declare const EnvironmentDetectorTest: {
-  layer: (env?: Environment) => Layer.Layer<EnvironmentDetector, never, never>;
+  layer: (env?: Environment, options?: {
+    readonly ci?: CiName;
+  }) => Layer.Layer<EnvironmentDetector, never, never>;
 };
 declare const ExecutorResolver_base: Context.ServiceClass<ExecutorResolver, "vitest-agent/ExecutorResolver", {
   readonly resolve: (env: Environment) => Effect.Effect<Executor>;
@@ -1528,12 +1616,18 @@ export interface ResolveProjectIdentityOptions {
  */
 export declare const resolveProjectIdentityFromCandidates: (candidates: ProjectIdentityCandidates) => ResolvedIdentity | null;
 declare const ProjectIdentity_base: Context.ServiceClass<ProjectIdentity, "vitest-agent/ProjectIdentity", {
-  readonly resolve: (workspaceRoot: string, options?: ResolveProjectIdentityOptions) => Effect.Effect<ResolvedIdentity, ProjectIdentityNotResolvableError>;
+  readonly resolve: (workspaceRoot: string, options?: ResolveProjectIdentityOptions) => Effect.Effect<ResolvedIdentity, ProjectIdentityError>;
 }>;
 /**
  * Service tag. The Live layer (in `layers/ProjectIdentityLive.ts`)
  * wires up the I/O sources; tests provide a stub that returns a
  * pre-built `ResolvedIdentity`.
+ *
+ * `resolve` fails with `ProjectIdentityNotResolvableError` when every
+ * source is absent or empty, and with `ProjectIdentitySourceError` when a
+ * source is present but unusable (a malformed `vitest-agent.config.toml`,
+ * an unreadable root `package.json`): a broken config is reported, never
+ * silently replaced by the default identity (issue 321).
  * @public
  */
 export declare class ProjectIdentity extends ProjectIdentity_base {}
@@ -1553,17 +1647,21 @@ export type CandidateContext = FileSystem.FileSystem | WorkspaceDiscovery | Vite
  * `FileSystem`, `CommandExecutor`, `WorkspaceDiscovery`, and
  * `VitestAgentConfigFile`. The platform context comes from
  * `NodeServices.layer` at the entry point.
+ *
+ * Absent sources fall through (no config file, no workspace root, no
+ * `repository` field, no git remote); a present source that cannot be read
+ * or decoded fails with `ProjectIdentitySourceError`.
  * @public
  */
 export declare const ProjectIdentityLive: Layer.Layer<ProjectIdentity, never, CandidateContext>;
 /**
  * Build a Test layer that returns a fixed `ResolvedIdentity` (or
- * fails with `ProjectIdentityNotResolvableError`). Use in unit tests
+ * fails with the given `ProjectIdentityError`). Use in unit tests
  * that depend on `ProjectIdentity` but don't want to wire upstream
  * services.
  * @public
  */
-export declare const ProjectIdentityTest: (result: ResolvedIdentity | ProjectIdentityNotResolvableError) => Layer.Layer<ProjectIdentity, never, never>;
+export declare const ProjectIdentityTest: (result: ResolvedIdentity | ProjectIdentityError) => Layer.Layer<ProjectIdentity, never, never>;
 declare const RunContext_base: Schema.Class<RunContext, Schema.Struct<{
   readonly gitBranch: Schema.NullOr<Schema.String>;
   readonly gitCommitSha: Schema.NullOr<Schema.String>;
@@ -1643,6 +1741,13 @@ interface FormatTriageOptions {
   readonly project?: string;
   readonly maxLines?: number;
 }
+/**
+ * The "stray output" line of the Recent Test Runs section, or `undefined`
+ * when none of the recent runs wrote past Vitest's console capture (issue
+ * 578). Pure, so the wording is testable without a database.
+ * @public
+ */
+export declare const formatStrayOutputLine: (history: StrayOutputHistory) => string | undefined;
 /**
  * Generates an orientation triage markdown string for LLM agents.
  * Summarises recent test runs, active sessions, acceptance metrics,
@@ -1688,6 +1793,8 @@ declare const migration$1: Effect.Effect<void, import("effect/sql/SqlError").Sql
 export declare const PROJECT_MIGRATIONS: {
   readonly "0001_initial": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
   readonly "0002_test_artifacts": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
+  readonly "0003_run_retention": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
+  readonly "0004_stray_output": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
 };
 /**
  * Migration for the global discovery registry SQLite at
@@ -2540,6 +2647,30 @@ export interface FailureSignatureInput {
 export declare const normalizeAssertionShape: (message: string) => string | null;
 /** @public */
 export declare const computeFailureSignature: (input: FailureSignatureInput) => string;
+/**
+ * Run `effect` as a nested transaction that keeps the
+ * {@link withPersistTransaction} caches honest.
+ *
+ * Outside a persist batch this is exactly `sql.withTransaction(effect)`.
+ * Inside one, the nested `withTransaction` becomes a SAVEPOINT, and when it
+ * rolls back (a failure, a defect, an interrupt) every `files` / `tags` row
+ * the savepoint inserted is gone while the ids `DataStoreLive` cached for
+ * them would survive in `PersistBatchState`. This helper snapshots the
+ * cache sizes before the savepoint opens and discards the entries added
+ * since whenever it does not commit, so a later write in the same batch
+ * re-inserts the row instead of referencing one that no longer exists
+ * (issue #628: a FK failure or a dangling id). A savepoint that commits
+ * keeps its entries.
+ *
+ * Use this, never a bare `sql.withTransaction`, for any nested transaction
+ * whose failure a caller may catch and continue from inside the batch; a
+ * bare one that rolls back leaves the caches stale. The bookkeeping is
+ * synchronous, so the batch's no-yield guarantee is unchanged.
+ *
+ * @param effect - the writes to run as one savepoint (or transaction)
+ * @public
+ */
+export declare const withPersistSavepoint: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R | SqlClient>;
 /**
  * Run `effect` as one SQLite write transaction on the `data.db` connection:
  * every `DataStore` write inside it commits together or not at all, and a
@@ -2560,8 +2691,13 @@ export declare const computeFailureSignature: (input: FailureSignatureInput) =>
  * genuinely asynchronous work for that reason; CPU-heavy work that needs no
  * database belongs before the block.
  *
- * Nested `withTransaction` calls inside `effect` become savepoints. A
- * `DataReader` query inside it runs on the transaction's connection.
+ * Nested `withTransaction` calls inside `effect` become savepoints. Open
+ * them through {@link withPersistSavepoint}: a savepoint that rolls back
+ * also discards the tag / file ids cached while it was open, so a write the
+ * caller recovers from cannot leave a later write pointing at a row the
+ * rollback removed. A bare nested `sql.withTransaction` whose failure is
+ * caught inside the block leaves those caches stale. A `DataReader` query
+ * inside the block runs on the transaction's connection.
  *
  * @param effect - the writes (and the reads they depend on) to run atomically
  * @public

package/index.js

@@ -4,7 +4,7 @@ import { DataReader } from "./services/DataReader.js";
 import { HistoryTracker, historyKey } from "./services/HistoryTracker.js";
 import { DataReaderLive } from "./layers/DataReaderLive.js";
 import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "./services/DataStore.js";
-import { withPersistTransaction } from "./utils/persist-transaction.js";
+import { withPersistSavepoint, withPersistTransaction } from "./utils/persist-transaction.js";
 import { DataStoreLive } from "./layers/DataStoreLive.js";
 import { DetailResolver } from "./services/DetailResolver.js";
 import { DetailResolverLive } from "./layers/DetailResolverLive.js";
@@ -29,7 +29,7 @@ import { ProjectIdentity, resolveProjectIdentityFromCandidates } from "./service
 import { ProjectIdentityLive, ProjectIdentityTest } from "./layers/ProjectIdentityLive.js";
 import { AgentContext, RunContext, RunContext$, RunContextService } from "./services/RunContext.js";
 import { RunContextLive, RunContextTest } from "./layers/RunContextLive.js";
-import { formatTriageEffect } from "./lib/format-triage.js";
+import { formatStrayOutputLine, formatTriageEffect } from "./lib/format-triage.js";
 import { formatWrapupEffect } from "./lib/format-wrapup.js";
 import migration from "./migrations/0001_initial.js";
 import migration$1 from "./migrations/0002_test_artifacts.js";
@@ -57,4 +57,4 @@ import { DATABASE_FILENAME, resolveDataPath } from "./utils/resolve-data-path.js
 import { resolveWorkspaceKey } from "./utils/resolve-workspace-key.js";
 import { CURRENT_ENGINE_VERSION } from "./version.js";
 
-export { APP_NAMESPACE, AgentContext, CURRENT_ENGINE_VERSION, ConfigLive, DATABASE_FILENAME, DATA_DB_FILENAME, DATA_FALLBACK_DIR, DataReader, DataReaderLive, DataStore, DataStoreLive, DetailResolver, DetailResolverLive, DiscoveryRegistry, DiscoveryRegistryLive, EnvironmentDetector, EnvironmentDetectorLive, EnvironmentDetectorTest, ExecutorResolver, ExecutorResolverLive, HistoryTracker, HistoryTrackerLive, HistoryTrackerTest, IDEMPOTENCY_ROOT_SENTINEL, INLINE_ATTACHMENT_BODY_CAP_BYTES, LoggerLive, NodePlatformLayer, OutputPipelineLive, PROJECT_MIGRATIONS, PathResolutionLive, PerClientSessionMapReader, PerClientSessionMapReaderLive, PerClientSessionMapWriter, PerClientSessionMapWriterLive, PlatformLive, ProjectDiscovery, ProjectDiscoveryLive, ProjectDiscoveryTest, ProjectIdentity, ProjectIdentityLive, ProjectIdentityTest, REGISTRY_DB_FILENAME, REGISTRY_STORE_OPTIONS, RunContext, RunContext$, RunContextLive, RunContextService, RunContextTest, SESSIONS_DB_FILENAME, SidecarPlatformLive, VitestAgentConfigFile, _resetMigrationCacheForTesting, assembleHistoryRecord, assembleManifest, classifyEnvironment, computeFailureSignature, deriveIdempotencyKey, dispatchRecordTddArtifactEffect, endAgentEffect, ensureMigrated, formatTriageEffect, formatWrapupEffect, historyKey, makeSqliteStack, migration as migration0001, migration$1 as migration0002, normalizeAssertionShape, parseAndValidateTurnPayload, parseSessionEnvExports, recordRunWorkspaceChangesEffect, recordSessionEnd, recordSessionStart, recordTddArtifactByTaskIdEffect, recordTddArtifactEffect, recordTurnEffect, recoverSessionContextFromSessionEnv, registerAgentEffect, migration$2 as registryMigration0001, resolveDataPath, resolveHookPaths, resolveLogFile, resolveLogLevel, resolveProjectDir, resolveProjectIdentityFromCandidates, resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect, resolveSessionForRecording, resolveSessionMapPath, resolveWorkspaceKey, migration$3 as sessionMapMigration0001, withPersistTransaction };
+export { APP_NAMESPACE, AgentContext, CURRENT_ENGINE_VERSION, ConfigLive, DATABASE_FILENAME, DATA_DB_FILENAME, DATA_FALLBACK_DIR, DataReader, DataReaderLive, DataStore, DataStoreLive, DetailResolver, DetailResolverLive, DiscoveryRegistry, DiscoveryRegistryLive, EnvironmentDetector, EnvironmentDetectorLive, EnvironmentDetectorTest, ExecutorResolver, ExecutorResolverLive, HistoryTracker, HistoryTrackerLive, HistoryTrackerTest, IDEMPOTENCY_ROOT_SENTINEL, INLINE_ATTACHMENT_BODY_CAP_BYTES, LoggerLive, NodePlatformLayer, OutputPipelineLive, PROJECT_MIGRATIONS, PathResolutionLive, PerClientSessionMapReader, PerClientSessionMapReaderLive, PerClientSessionMapWriter, PerClientSessionMapWriterLive, PlatformLive, ProjectDiscovery, ProjectDiscoveryLive, ProjectDiscoveryTest, ProjectIdentity, ProjectIdentityLive, ProjectIdentityTest, REGISTRY_DB_FILENAME, REGISTRY_STORE_OPTIONS, RunContext, RunContext$, RunContextLive, RunContextService, RunContextTest, SESSIONS_DB_FILENAME, SidecarPlatformLive, VitestAgentConfigFile, _resetMigrationCacheForTesting, assembleHistoryRecord, assembleManifest, classifyEnvironment, computeFailureSignature, deriveIdempotencyKey, dispatchRecordTddArtifactEffect, endAgentEffect, ensureMigrated, formatStrayOutputLine, formatTriageEffect, formatWrapupEffect, historyKey, makeSqliteStack, migration as migration0001, migration$1 as migration0002, normalizeAssertionShape, parseAndValidateTurnPayload, parseSessionEnvExports, recordRunWorkspaceChangesEffect, recordSessionEnd, recordSessionStart, recordTddArtifactByTaskIdEffect, recordTddArtifactEffect, recordTurnEffect, recoverSessionContextFromSessionEnv, registerAgentEffect, migration$2 as registryMigration0001, resolveDataPath, resolveHookPaths, resolveLogFile, resolveLogLevel, resolveProjectDir, resolveProjectIdentityFromCandidates, resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect, resolveSessionForRecording, resolveSessionMapPath, resolveWorkspaceKey, migration$3 as sessionMapMigration0001, withPersistSavepoint, withPersistTransaction };

package/layers/DataReaderLive.js

@@ -1,16 +1,53 @@
 import { DataReader } from "../services/DataReader.js";
 import { historyKey } from "../services/HistoryTracker.js";
-import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
-import { Effect, Layer, Option } from "effect";
+import { DataStoreError, StrayOutputSample, extractSqlReason } from "@vitest-agent/sdk";
+import { Effect, Layer, Option, Schema } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
 
 // src/layers/DataReaderLive.ts
+const decodeStraySamples = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Array(StrayOutputSample)));
+/**
+* The run's stray output from its `test_runs` row, or `null` when the row
+* recorded none (every `stray_*` column NULL: a run that wrote nothing, a
+* passthrough-mode run, or a row older than migration 0004). Pure; the
+* inverse is `DataStoreLive`'s `strayOutputColumns`. A samples column that
+* does not decode reads as no samples rather than failing the row.
+*/
+const strayOutputFromRow = (row) => row.stray_total === null ? null : {
+	total: row.stray_total,
+	stdout: row.stray_stdout ?? 0,
+	stderr: row.stray_stderr ?? 0,
+	bytes: row.stray_bytes ?? 0,
+	samples: Option.getOrElse(decodeStraySamples(row.stray_samples ?? "[]"), () => [])
+};
 /** @public */
 const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	const sql = yield* SqlClient;
+	/**
+	* The run whose `file_coverage` rows describe `runId`'s coverage.
+	*
+	* The reporter writes per-file coverage ONCE per invocation, under
+	* one run of that invocation (issue #622), while every project gets
+	* its own `test_runs` row. A project run's rows therefore live under
+	* the sibling run sharing its `invocation_id`. Preference order: the
+	* run itself when it carries rows (a database an older reporter wrote
+	* holds an identical copy under every run of the invocation — reading
+	* exactly one run keeps that layout deduplicated), else the lowest
+	* sibling run id that carries rows. A run whose invocation wrote no
+	* rows resolves to itself, so the caller's `WHERE run_id = ?` is
+	* simply empty. Never crosses an invocation boundary.
+	*/
+	const resolveCoverageRunId = (runId) => Effect.gen(function* () {
+		return (yield* sql`SELECT fc.run_id
+					FROM file_coverage fc
+					JOIN test_runs tr ON tr.id = fc.run_id
+					WHERE tr.invocation_id = (SELECT invocation_id FROM test_runs WHERE id = ${runId})
+					ORDER BY CASE WHEN fc.run_id = ${runId} THEN 0 ELSE 1 END, fc.run_id ASC
+					LIMIT 1`)[0]?.run_id ?? runId;
+	});
 	const getLatestRun = (project) => Effect.gen(function* () {
 		yield* Effect.logDebug("getLatestRun").pipe(Effect.annotateLogs({ project }));
-		const runs = yield* sql`SELECT id, timestamp, reason, duration, total, passed, failed, skipped, project
+		const runs = yield* sql`SELECT id, timestamp, reason, duration, total, passed, failed, skipped, project, stray_total, stray_stdout, stray_stderr, stray_bytes, stray_samples
 					FROM test_runs
 					WHERE project = ${project}
 					ORDER BY timestamp DESC LIMIT 1`;
@@ -80,11 +117,13 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 					WHERE run_id = ${run.id} AND scope = 'unhandled'`;
 		const failedFiles = failedModules.map((m) => m.file_path);
 		const projectName = run.project;
+		const strayOutput = strayOutputFromRow(run);
+		const coverageRunId = yield* resolveCoverageRunId(run.id);
 		const fileCovRows = yield* sql`SELECT f.path AS file_path, fc.statements, fc.branches, fc.functions, fc.lines,
 					   fc.uncovered_lines, fc.tier
 					FROM file_coverage fc
 					JOIN files f ON f.id = fc.file_id
-					WHERE fc.run_id = ${run.id}`;
+					WHERE fc.run_id = ${coverageRunId}`;
 		const lowCoverage = fileCovRows.filter((r) => r.tier === "below_threshold").map((r) => ({
 			file: r.file_path,
 			summary: {
@@ -156,7 +195,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 				...e.diff != null ? { diff: e.diff } : {}
 			})),
 			failedFiles,
-			...coverage ? { coverage } : {}
+			...coverage ? { coverage } : {},
+			...strayOutput !== null ? { strayOutput } : {}
 		};
 		return Option.some(report);
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -173,7 +213,12 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 						t1.total,
 						t1.passed,
 						t1.failed,
-						t1.skipped
+						t1.skipped,
+						t1.stray_total,
+						t1.stray_stdout,
+						t1.stray_stderr,
+						t1.stray_bytes,
+						t1.stray_samples
 					FROM test_runs t1
 					INNER JOIN (
 						SELECT project, MAX(timestamp) as max_ts
@@ -187,8 +232,38 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 			total: r.total,
 			passed: r.passed,
 			failed: r.failed,
-			skipped: r.skipped
+			skipped: r.skipped,
+			strayOutput: strayOutputFromRow(r)
+		}));
+	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
+		operation: "read",
+		table: "test_runs",
+		reason: extractSqlReason(e)
+	})));
+	const getStrayOutputHistory = (options = {}) => Effect.gen(function* () {
+		const limit = options.limit ?? 10;
+		yield* Effect.logDebug("getStrayOutputHistory").pipe(Effect.annotateLogs({
+			project: options.project ?? "*",
+			limit
 		}));
+		const rows = yield* sql`SELECT
+						MAX(timestamp) AS timestamp,
+						MAX(stray_total) AS stray_total,
+						MAX(stray_stdout) AS stray_stdout,
+						MAX(stray_stderr) AS stray_stderr,
+						MAX(stray_bytes) AS stray_bytes,
+						MAX(stray_samples) AS stray_samples
+					FROM test_runs
+					${options.project !== void 0 ? sql`WHERE project = ${options.project}` : sql``}
+					GROUP BY invocation_id
+					ORDER BY timestamp DESC
+					LIMIT ${limit}`;
+		const recorded = rows.map(strayOutputFromRow);
+		return {
+			runs: rows.length,
+			runsWithStrayOutput: recorded.filter((s) => s !== null).length,
+			latest: recorded[0] ?? null
+		};
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
 		operation: "read",
 		table: "test_runs",
@@ -440,10 +515,11 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	})));
 	const getFileCoverage = (runId) => Effect.gen(function* () {
 		yield* Effect.logDebug("getFileCoverage").pipe(Effect.annotateLogs({ runId }));
+		const coverageRunId = yield* resolveCoverageRunId(runId);
 		return (yield* sql`SELECT f.path as file_path, fc.statements, fc.branches, fc.functions, fc.lines, fc.uncovered_lines
 					FROM file_coverage fc
 					JOIN files f ON f.id = fc.file_id
-					WHERE fc.run_id = ${runId}`).map((r) => ({
+					WHERE fc.run_id = ${coverageRunId}`).map((r) => ({
 			file: r.file_path,
 			summary: {
 				statements: r.statements,
@@ -464,7 +540,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 					WHERE project = ${project}
 					ORDER BY timestamp DESC LIMIT 1`;
 		if (runs.length === 0) return Option.none();
-		const runId = runs[0].id;
+		const runId = yield* resolveCoverageRunId(runs[0].id);
 		const fileCoverageRows = yield* sql`SELECT f.path as file_path, fc.statements, fc.branches, fc.functions, fc.lines, fc.uncovered_lines, fc.tier
 					FROM file_coverage fc JOIN files f ON f.id = fc.file_id
 					WHERE fc.run_id = ${runId}`;
@@ -1854,6 +1930,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	return {
 		getLatestRun,
 		getRunsByProject,
+		getStrayOutputHistory,
 		getHistory,
 		getBaselines,
 		getTrends,

package/layers/DataStoreLive.js

@@ -1,12 +1,30 @@
 import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "../services/DataStore.js";
-import { PersistBatch } from "../utils/persist-transaction.js";
+import { PersistBatch, withPersistSavepoint } from "../utils/persist-transaction.js";
 import { Agent, AgentNotFoundError, BehaviorNotFoundError, DataStoreError, GoalNotFoundError, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, coerceErrorText, extractSqlReason } from "@vitest-agent/sdk";
-import { Effect, Layer, Option } from "effect";
+import { Clock, Effect, Layer, Option } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
 import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
 
 // src/layers/DataStoreLive.ts
+/**
+* The five `test_runs.stray_*` column values for a run's stray output: all
+* NULL when the run recorded nothing, so a reader cannot mistake "nothing
+* recorded" for "zero lines" (pure; the inverse lives in `DataReaderLive`).
+*/
+const strayOutputColumns = (stray) => stray == null ? {
+	total: null,
+	stdout: null,
+	stderr: null,
+	bytes: null,
+	samples: null
+} : {
+	total: stray.total,
+	stdout: stray.stdout,
+	stderr: stray.stderr,
+	bytes: stray.bytes,
+	samples: JSON.stringify(stray.samples)
+};
 const isLegalLifecycleTransition = (from, to) => {
 	if (from === to) return true;
 	if (from === "done" || from === "abandoned") return false;
@@ -36,6 +54,7 @@ const boolToInt = (v) => v === void 0 ? null : v ? 1 : 0;
 const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	const sql = yield* SqlClient;
 	yield* sql`PRAGMA foreign_keys=ON`.pipe(Effect.catch(() => Effect.void));
+	const savepoint = (effect) => withPersistSavepoint(effect).pipe(Effect.provideService(SqlClient, sql));
 	const ensureFile = (filePath) => Effect.gen(function* () {
 		yield* Effect.logDebug("ensureFile").pipe(Effect.annotateLogs({ filePath }));
 		const batch = yield* PersistBatch;
@@ -69,7 +88,8 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		const conversationId = input.conversationId ?? null;
 		const gitDirtyInt = input.gitDirty === void 0 || input.gitDirty === null ? null : input.gitDirty ? 1 : 0;
 		const hostMetadataJson = input.hostMetadata == null ? null : JSON.stringify(input.hostMetadata);
-		yield* sql`INSERT INTO test_runs (invocation_id, project, settings_hash, timestamp, commit_sha, branch, reason, duration, total, passed, failed, skipped, scoped, snapshot_added, snapshot_matched, snapshot_unmatched, snapshot_updated, snapshot_unchecked, snapshot_total, snapshot_failure, snapshot_did_update, snapshot_files_added, snapshot_files_removed, snapshot_files_unmatched, snapshot_files_updated, actor_type, agent_id, conversation_id, git_branch, git_commit_sha, git_dirty, git_upstream, git_worktree_dir, host_source, host_value, host_metadata) VALUES (${input.invocationId}, ${input.project}, ${input.settingsHash}, ${input.timestamp}, ${input.commitSha ?? null}, ${input.branch ?? null}, ${input.reason}, ${input.duration}, ${input.total}, ${input.passed}, ${input.failed}, ${input.skipped}, ${input.scoped ? 1 : 0}, ${input.snapshotAdded ?? 0}, ${input.snapshotMatched ?? 0}, ${input.snapshotUnmatched ?? 0}, ${input.snapshotUpdated ?? 0}, ${input.snapshotUnchecked ?? 0}, ${input.snapshotTotal ?? 0}, ${boolToInt(input.snapshotFailure) ?? 0}, ${boolToInt(input.snapshotDidUpdate) ?? 0}, ${input.snapshotFilesAdded ?? 0}, ${input.snapshotFilesRemoved ?? 0}, ${input.snapshotFilesUnmatched ?? 0}, ${input.snapshotFilesUpdated ?? 0}, ${actorType}, ${agentId}, ${conversationId}, ${input.gitBranch ?? null}, ${input.gitCommitSha ?? null}, ${gitDirtyInt}, ${input.gitUpstream ?? null}, ${input.gitWorktreeDir ?? null}, ${input.hostSource ?? null}, ${input.hostValue ?? null}, ${hostMetadataJson})`;
+		const stray = strayOutputColumns(input.strayOutput);
+		yield* sql`INSERT INTO test_runs (invocation_id, project, settings_hash, timestamp, commit_sha, branch, reason, duration, total, passed, failed, skipped, scoped, snapshot_added, snapshot_matched, snapshot_unmatched, snapshot_updated, snapshot_unchecked, snapshot_total, snapshot_failure, snapshot_did_update, snapshot_files_added, snapshot_files_removed, snapshot_files_unmatched, snapshot_files_updated, actor_type, agent_id, conversation_id, git_branch, git_commit_sha, git_dirty, git_upstream, git_worktree_dir, host_source, host_value, host_metadata, stray_total, stray_stdout, stray_stderr, stray_bytes, stray_samples) VALUES (${input.invocationId}, ${input.project}, ${input.settingsHash}, ${input.timestamp}, ${input.commitSha ?? null}, ${input.branch ?? null}, ${input.reason}, ${input.duration}, ${input.total}, ${input.passed}, ${input.failed}, ${input.skipped}, ${input.scoped ? 1 : 0}, ${input.snapshotAdded ?? 0}, ${input.snapshotMatched ?? 0}, ${input.snapshotUnmatched ?? 0}, ${input.snapshotUpdated ?? 0}, ${input.snapshotUnchecked ?? 0}, ${input.snapshotTotal ?? 0}, ${boolToInt(input.snapshotFailure) ?? 0}, ${boolToInt(input.snapshotDidUpdate) ?? 0}, ${input.snapshotFilesAdded ?? 0}, ${input.snapshotFilesRemoved ?? 0}, ${input.snapshotFilesUnmatched ?? 0}, ${input.snapshotFilesUpdated ?? 0}, ${actorType}, ${agentId}, ${conversationId}, ${input.gitBranch ?? null}, ${input.gitCommitSha ?? null}, ${gitDirtyInt}, ${input.gitUpstream ?? null}, ${input.gitWorktreeDir ?? null}, ${input.hostSource ?? null}, ${input.hostValue ?? null}, ${hostMetadataJson}, ${stray.total}, ${stray.stdout}, ${stray.stderr}, ${stray.bytes}, ${stray.samples})`;
 		return (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
 	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
 		operation: "write",
@@ -275,7 +295,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	* enforced Vitest thresholds or the aspirational coverageTargets
 	* (issue #237).
 	*/
-	const writeCoveragePolicy = (kind, policy) => sql.withTransaction(Effect.gen(function* () {
+	const writeCoveragePolicy = (kind, policy) => savepoint(Effect.gen(function* () {
 		yield* Effect.logDebug("writeCoveragePolicy").pipe(Effect.annotateLogs({ kind }));
 		const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const { global: g, patterns = [] } = policy;
@@ -427,7 +447,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		table: "sessions",
 		reason: extractSqlReason(e)
 	})));
-	const writeTurn = (input) => sql.withTransaction(Effect.gen(function* () {
+	const writeTurn = (input) => savepoint(Effect.gen(function* () {
 		yield* Effect.logDebug("writeTurn").pipe(Effect.annotateLogs({
 			sessionId: input.sessionId,
 			type: input.type
@@ -533,7 +553,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		table: "hypotheses",
 		reason: extractSqlReason(e)
 	})));
-	const writeTddTask = (input) => sql.withTransaction(Effect.gen(function* () {
+	const writeTddTask = (input) => savepoint(Effect.gen(function* () {
 		yield* Effect.logDebug("writeTddTask").pipe(Effect.annotateLogs({
 			sessionId: input.sessionId,
 			goal: input.goal
@@ -797,7 +817,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 			reason: extractSqlReason(e)
 		})));
 	});
-	const createBehavior = (input) => sql.withTransaction(Effect.gen(function* () {
+	const createBehavior = (input) => savepoint(Effect.gen(function* () {
 		yield* Effect.logDebug("createBehavior").pipe(Effect.annotateLogs({
 			goalId: input.goalId,
 			behavior: input.behavior
@@ -836,7 +856,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		table: "tdd_session_behaviors",
 		reason: extractSqlReason(e)
 	})));
-	const updateBehavior = (input) => sql.withTransaction(Effect.gen(function* () {
+	const updateBehavior = (input) => savepoint(Effect.gen(function* () {
 		yield* Effect.logDebug("updateBehavior").pipe(Effect.annotateLogs({ id: input.id }));
 		const existing = yield* sql`
 							SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
@@ -1113,6 +1133,82 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		table: "turns",
 		reason: extractSqlReason(e)
 	})));
+	const pruneRuns = (policy) => Effect.gen(function* () {
+		yield* Effect.logDebug("pruneRuns").pipe(Effect.annotateLogs({
+			keepRuns: policy.keepRuns,
+			maxAgeDays: policy.maxAgeDays ?? null
+		}));
+		const now = yield* Clock.currentTimeMillis;
+		const cutoff = policy.maxAgeDays === void 0 ? null : (/* @__PURE__ */ new Date(now - policy.maxAgeDays * 24 * 60 * 60 * 1e3)).toISOString();
+		yield* sql`CREATE TEMP TABLE IF NOT EXISTS prune_doomed_runs (id INTEGER PRIMARY KEY)`;
+		yield* sql`DELETE FROM prune_doomed_runs`;
+		yield* sql`
+					INSERT INTO prune_doomed_runs (id)
+					SELECT id FROM (
+						SELECT id, timestamp,
+							ROW_NUMBER() OVER (PARTITION BY project ORDER BY timestamp DESC, id DESC) AS rn
+						FROM test_runs
+					)
+					WHERE rn > ${policy.keepRuns} OR (${cutoff} IS NOT NULL AND timestamp < ${cutoff})`;
+		yield* sql`
+					WITH sources AS (
+						SELECT tr.invocation_id, MIN(tr.id) AS from_run_id
+						FROM test_runs tr
+						JOIN prune_doomed_runs d ON d.id = tr.id
+						WHERE EXISTS (SELECT 1 FROM file_coverage fc WHERE fc.run_id = tr.id)
+						GROUP BY tr.invocation_id
+					),
+					moves AS (
+						SELECT s.from_run_id,
+							(SELECT MIN(tr2.id) FROM test_runs tr2
+								WHERE tr2.invocation_id = s.invocation_id
+									AND tr2.id NOT IN (SELECT id FROM prune_doomed_runs)) AS to_run_id
+						FROM sources s
+						WHERE NOT EXISTS (
+							SELECT 1 FROM file_coverage fc2
+							JOIN test_runs tr3 ON tr3.id = fc2.run_id
+							WHERE tr3.invocation_id = s.invocation_id
+								AND tr3.id NOT IN (SELECT id FROM prune_doomed_runs)
+						)
+					)
+					UPDATE file_coverage
+					SET run_id = (SELECT to_run_id FROM moves WHERE moves.from_run_id = file_coverage.run_id)
+					WHERE run_id IN (SELECT from_run_id FROM moves WHERE to_run_id IS NOT NULL)`;
+		const deletedRuns = yield* sql`
+					DELETE FROM test_runs WHERE id IN (SELECT id FROM prune_doomed_runs) RETURNING id`;
+		yield* sql`DELETE FROM prune_doomed_runs`;
+		if (deletedRuns.length === 0) return {
+			prunedRuns: 0,
+			prunedFiles: 0
+		};
+		const deletedFiles = yield* sql`
+					DELETE FROM files WHERE
+						NOT EXISTS (SELECT 1 FROM test_modules WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM scoped_files WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM file_coverage WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM stack_frames WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM test_annotations WHERE location_file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM test_artifacts WHERE location_file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM import_durations WHERE file_id = files.id OR importer_file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM source_test_map WHERE source_file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM file_edits WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM run_changed_files WHERE file_id = files.id)
+						AND NOT EXISTS (SELECT 1 FROM tdd_artifacts WHERE file_id = files.id)
+					RETURNING id`;
+		const batch = yield* PersistBatch;
+		if (batch !== void 0 && deletedFiles.length > 0) {
+			const gone = new Set(deletedFiles.map((row) => row.id));
+			for (const [path, id] of batch.fileIds) if (gone.has(id)) batch.fileIds.delete(path);
+		}
+		return {
+			prunedRuns: deletedRuns.length,
+			prunedFiles: deletedFiles.length
+		};
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_runs",
+		reason: extractSqlReason(e)
+	})));
 	const associateLatestRunWithSession = (input) => Effect.gen(function* () {
 		yield* Effect.logDebug("associateLatestRunWithSession").pipe(Effect.annotateLogs({
 			chatId: input.chatId,
@@ -1288,6 +1384,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		writeRunChangedFiles,
 		recordIdempotentResponse,
 		pruneSessions,
+		pruneRuns,
 		associateLatestRunWithSession,
 		backfillTestCaseTurns,
 		registerAgent,

package/layers/EnvironmentDetectorLive.js

@@ -48,7 +48,8 @@ const EnvironmentDetectorLive = (env) => Layer.effect(EnvironmentDetector, Effec
 	return {
 		detect: () => Effect.succeed(environment),
 		isAgent: Effect.succeed(Option.isSome(runtime.agent)),
-		agentName: Effect.succeed(Option.getOrUndefined(runtime.agent))
+		agentName: Effect.succeed(Option.getOrUndefined(runtime.agent)),
+		ci: Effect.succeed(runtime.ci)
 	};
 })).pipe(Layer.provide(CurrentRuntimeEnv.layerFrom(env)));
 

package/layers/EnvironmentDetectorTest.js

@@ -1,12 +1,30 @@
 import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
-import { Effect, Layer } from "effect";
+import { Effect, Layer, Option } from "effect";
 
 // src/layers/EnvironmentDetectorTest.ts
-/** @public */
-const EnvironmentDetectorTest = { layer: (env = "terminal") => Layer.succeed(EnvironmentDetector, {
+/** The CI vendor each environment implies when a test does not say otherwise. */
+const CI_FOR_ENVIRONMENT = {
+	"ci-github": Option.some("github-actions"),
+	"ci-generic": Option.some("generic"),
+	"agent-shell": Option.none(),
+	terminal: Option.none()
+};
+/**
+* A fixed `EnvironmentDetector` for tests.
+*
+* @remarks
+* `ci` defaults to the vendor the environment implies (`ci-github` is
+* GitHub Actions, `ci-generic` another CI, the rest none). Pass
+* `options.ci` to decouple the two, as the live detector does for an agent
+* running inside GitHub Actions: `layer("agent-shell", { ci: "github-actions" })`.
+*
+* @public
+*/
+const EnvironmentDetectorTest = { layer: (env = "terminal", options = {}) => Layer.succeed(EnvironmentDetector, {
 	detect: () => Effect.succeed(env),
 	isAgent: Effect.succeed(env === "agent-shell"),
-	agentName: Effect.succeed(env === "agent-shell" ? "test-agent" : void 0)
+	agentName: Effect.succeed(env === "agent-shell" ? "test-agent" : void 0),
+	ci: Effect.succeed(options.ci !== void 0 ? Option.some(options.ci) : CI_FOR_ENVIRONMENT[env])
 }) };
 
 export { EnvironmentDetectorTest };

package/layers/ProjectIdentityLive.js

@@ -1,11 +1,21 @@
 import { VitestAgentConfigFile } from "../services/Config.js";
 import { ProjectIdentity, resolveProjectIdentityFromCandidates } from "../services/ProjectIdentity.js";
-import { ProjectIdentityNotResolvableError, VitestAgentConfig } from "@vitest-agent/sdk";
+import { ProjectIdentityNotResolvableError, ProjectIdentitySourceError, VitestAgentConfig } from "@vitest-agent/sdk";
 import { Effect, FileSystem, Layer, Option } from "effect";
 import { WorkspaceDiscovery } from "@effected/workspaces";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 
 // src/layers/ProjectIdentityLive.ts
+/** The one-line text of a kit failure, for `ProjectIdentitySourceError.detail`. */
+const detailOf = (cause) => cause instanceof Error && cause.message.length > 0 ? cause.message : String(cause);
+/**
+* The git remote is an OPTIONAL source: a repository with no
+* `remote.origin.url`, a directory that is not a git checkout, or a machine
+* with no `git` on `PATH` are all "no remote" rather than failures. `git
+* config --get` exits non-zero for an unset key, so every spawner failure
+* folds to `Option.none()` on purpose — this is the one catch in this module
+* that stays broad, and it is a policy, not an accident.
+*/
 const readGitRemote = (cwd) => Effect.gen(function* () {
 	const trimmed = (yield* (yield* ChildProcessSpawner.ChildProcessSpawner).string(ChildProcess.make("git", [
 		"config",
@@ -14,23 +24,55 @@ const readGitRemote = (cwd) => Effect.gen(function* () {
 	]).pipe(ChildProcess.setCwd(cwd)))).trim();
 	return trimmed.length > 0 ? Option.some(trimmed) : Option.none();
 }).pipe(Effect.catch(() => Effect.succeed(Option.none())));
+/**
+* The `repository` URL of the root `package.json` discovery named.
+*
+* A file that is not there (`NotFound`) is an absent source. Any other
+* filesystem failure (permission denied, an I/O error) and a body that is not
+* JSON are `ProjectIdentitySourceError`s: the file exists and says
+* something, and silently reading it as "no repository" would hand the
+* operator the wrong identity.
+*/
 const readPackageRepoUrl = (packageJsonPath) => Effect.gen(function* () {
-	const raw = yield* (yield* FileSystem.FileSystem).readFileString(packageJsonPath).pipe(Effect.catch(() => Effect.succeed("")));
-	if (raw.length === 0) return Option.none();
-	try {
-		const repo = JSON.parse(raw).repository;
-		if (typeof repo === "string" && repo.trim().length > 0) return Option.some(repo.trim());
-		if (repo !== null && typeof repo === "object" && "url" in repo && typeof repo.url === "string") {
-			const url = repo.url.trim();
-			return url.length > 0 ? Option.some(url) : Option.none();
-		}
-	} catch {}
+	const raw = yield* (yield* FileSystem.FileSystem).readFileString(packageJsonPath).pipe(Effect.map(Option.some), Effect.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(new ProjectIdentitySourceError({
+		source: "package-json",
+		path: packageJsonPath,
+		detail: detailOf(error),
+		cause: error
+	}))));
+	if (Option.isNone(raw)) return Option.none();
+	const parsed = yield* Effect.try({
+		try: () => JSON.parse(raw.value),
+		catch: (cause) => new ProjectIdentitySourceError({
+			source: "package-json",
+			path: packageJsonPath,
+			detail: detailOf(cause),
+			cause
+		})
+	});
+	if (parsed === null || typeof parsed !== "object") return Option.none();
+	const repo = parsed.repository;
+	if (typeof repo === "string" && repo.trim().length > 0) return Option.some(repo.trim());
+	if (repo !== null && typeof repo === "object" && "url" in repo && typeof repo.url === "string") {
+		const url = repo.url.trim();
+		return url.length > 0 ? Option.some(url) : Option.none();
+	}
 	return Option.none();
 });
 const collectCandidates = (workspaceRoot, options) => Effect.gen(function* () {
-	const tomlConfig = yield* (yield* VitestAgentConfigFile).loadOrDefault(new VitestAgentConfig({})).pipe(Effect.catch(() => Effect.succeed(new VitestAgentConfig({}))));
+	const tomlConfig = yield* (yield* VitestAgentConfigFile).loadOrDefault(new VitestAgentConfig({})).pipe(Effect.mapError((cause) => new ProjectIdentitySourceError({
+		source: "toml",
+		path: cause._tag === "ConfigValidationError" ? Option.getOrElse(cause.path, () => workspaceRoot) : cause.path ?? workspaceRoot,
+		detail: detailOf(cause),
+		cause
+	})));
 	const gitRemote = yield* readGitRemote(workspaceRoot);
-	const root = (yield* (yield* WorkspaceDiscovery).listPackagesIn(workspaceRoot).pipe(Effect.catch(() => Effect.succeed([])))).find((pkg) => pkg.isRootWorkspace);
+	const root = (yield* (yield* WorkspaceDiscovery).listPackagesIn(workspaceRoot).pipe(Effect.catchTag("WorkspaceRootNotFoundError", () => Effect.succeed([])), Effect.mapError((cause) => new ProjectIdentitySourceError({
+		source: "workspace",
+		path: cause._tag === "WorkspacePatternError" ? cause.root : cause.path,
+		detail: detailOf(cause),
+		cause
+	})))).find((pkg) => pkg.isRootWorkspace);
 	const packageJsonRepoUrl = root ? yield* readPackageRepoUrl(root.packageJsonPath) : Option.none();
 	const candidates = {};
 	if (options.projectId !== void 0) candidates.explicit = options.projectId;
@@ -69,6 +111,10 @@ const candidatesToTriedList = (candidates) => [
 * `FileSystem`, `CommandExecutor`, `WorkspaceDiscovery`, and
 * `VitestAgentConfigFile`. The platform context comes from
 * `NodeServices.layer` at the entry point.
+*
+* Absent sources fall through (no config file, no workspace root, no
+* `repository` field, no git remote); a present source that cannot be read
+* or decoded fails with `ProjectIdentitySourceError`.
 * @public
 */
 const ProjectIdentityLive = Layer.effect(ProjectIdentity, Effect.gen(function* () {
@@ -84,11 +130,11 @@ const ProjectIdentityLive = Layer.effect(ProjectIdentity, Effect.gen(function* (
 }));
 /**
 * Build a Test layer that returns a fixed `ResolvedIdentity` (or
-* fails with `ProjectIdentityNotResolvableError`). Use in unit tests
+* fails with the given `ProjectIdentityError`). Use in unit tests
 * that depend on `ProjectIdentity` but don't want to wire upstream
 * services.
 * @public
 */
-const ProjectIdentityTest = (result) => Layer.succeed(ProjectIdentity, { resolve: () => result instanceof ProjectIdentityNotResolvableError ? Effect.fail(result) : Effect.succeed(result) });
+const ProjectIdentityTest = (result) => Layer.succeed(ProjectIdentity, { resolve: () => result instanceof ProjectIdentityNotResolvableError || result instanceof ProjectIdentitySourceError ? Effect.fail(result) : Effect.succeed(result) });
 
 export { ProjectIdentityLive, ProjectIdentityTest };

package/lib/format-triage.js

@@ -2,6 +2,19 @@ import { DataReader } from "../services/DataReader.js";
 import { Effect, Option } from "effect";
 
 // src/lib/format-triage.ts
+const STRAY_OUTPUT_WINDOW = 10;
+const describeStrayOutput = (stray) => {
+	const lines = `${stray.total} line${stray.total === 1 ? "" : "s"}`;
+	const sample = stray.samples[0];
+	return sample === void 0 ? `${lines}, ${stray.bytes} bytes` : `${lines}, ${stray.bytes} bytes; first: \`${sample.text}\``;
+};
+/**
+* The "stray output" line of the Recent Test Runs section, or `undefined`
+* when none of the recent runs wrote past Vitest's console capture (issue
+* 578). Pure, so the wording is testable without a database.
+* @public
+*/
+const formatStrayOutputLine = (history) => history.runsWithStrayOutput === 0 ? void 0 : `- Stray output in ${history.runsWithStrayOutput} of the last ${history.runs} run${history.runs === 1 ? "" : "s"}${history.latest === null ? "" : ` (latest: ${describeStrayOutput(history.latest)})`} — tests or child processes writing straight to the terminal`;
 /**
 * Generates an orientation triage markdown string for LLM agents.
 * Summarises recent test runs, active sessions, acceptance metrics,
@@ -16,6 +29,14 @@ const formatTriageEffect = (options = {}) => Effect.gen(function* () {
 	const allProjects = yield* reader.getRunsByProject().pipe(Effect.orElseSucceed(() => []));
 	const projects = options.project ? allProjects.filter((p) => p.project === options.project) : allProjects;
 	const sessions = yield* reader.listSessions({}).pipe(Effect.orElseSucceed(() => []));
+	const strayHistory = yield* reader.getStrayOutputHistory({
+		...options.project !== void 0 && { project: options.project },
+		limit: STRAY_OUTPUT_WINDOW
+	}).pipe(Effect.orElseSucceed(() => ({
+		runs: 0,
+		runsWithStrayOutput: 0,
+		latest: null
+	})));
 	const fallbackMetrics = {
 		phaseEvidenceIntegrity: {
 			total: 0,
@@ -59,6 +80,8 @@ const formatTriageEffect = (options = {}) => Effect.gen(function* () {
 			const counts = `${p.passed} passed, ${p.failed} failed`;
 			lines.push(`- **${p.project}** — ${status} (${counts})`);
 		}
+		const strayLine = formatStrayOutputLine(strayHistory);
+		if (strayLine !== void 0) lines.push(strayLine);
 		lines.push("");
 	} else {
 		lines.push("### Recent Test Runs");
@@ -99,4 +122,4 @@ const formatTriageEffect = (options = {}) => Effect.gen(function* () {
 	return out;
 });
 
-export { formatTriageEffect };
+export { formatStrayOutputLine, formatTriageEffect };

package/migrations/0003_run_retention.js

@@ -0,0 +1,66 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+
+// src/migrations/0003_run_retention.ts
+/** @internal */
+const migration = Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`
+		CREATE TABLE test_history_new (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			run_id INTEGER REFERENCES test_runs(id) ON DELETE SET NULL,
+			project TEXT NOT NULL,
+			module_path TEXT NOT NULL,
+			full_name TEXT NOT NULL,
+			timestamp TEXT NOT NULL,
+			state TEXT NOT NULL CHECK (state IN ('passed', 'failed', 'skipped', 'pending')),
+			duration INTEGER,
+			flaky INTEGER CHECK (flaky IN (0, 1)),
+			retry_count INTEGER DEFAULT 0,
+			error_message TEXT,
+			UNIQUE(project, module_path, full_name, timestamp)
+		)
+	`;
+	yield* sql`
+		INSERT INTO test_history_new (id, run_id, project, module_path, full_name, timestamp, state, duration, flaky, retry_count, error_message)
+		SELECT id, run_id, project, module_path, full_name, timestamp, state, duration, flaky, retry_count, error_message
+		FROM test_history
+	`;
+	yield* sql`DROP INDEX IF EXISTS idx_test_history_lookup`;
+	yield* sql`DROP INDEX IF EXISTS idx_test_history_full_name`;
+	yield* sql`DROP INDEX IF EXISTS idx_test_history_run`;
+	yield* sql`DROP TABLE test_history`;
+	yield* sql`ALTER TABLE test_history_new RENAME TO test_history`;
+	yield* sql`CREATE INDEX idx_test_history_lookup ON test_history(project, module_path, full_name)`;
+	yield* sql`CREATE INDEX idx_test_history_full_name ON test_history(full_name, timestamp)`;
+	yield* sql`CREATE INDEX idx_test_history_run ON test_history(run_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_runs_project_timestamp ON test_runs(project, timestamp)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_modules_file ON test_modules(file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_scoped_files_file ON scoped_files(file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_stack_frames_file ON stack_frames(file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_annotations_file ON test_annotations(location_file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_artifacts_file ON test_artifacts(location_file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_import_durations_file ON import_durations(file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_tdd_artifacts_file ON tdd_artifacts(file_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_tdd_artifacts_test_run ON tdd_artifacts(test_run_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_tdd_artifacts_first_failure_run ON tdd_artifacts(test_first_failure_run_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_failure_signatures_first_seen_run ON failure_signatures(first_seen_run_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_suites_parent ON test_suites(parent_suite_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_errors_suite ON test_errors(test_suite_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_errors_module ON test_errors(module_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_test_errors_cause ON test_errors(cause_error_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_tdd_artifacts_test_case ON tdd_artifacts(test_case_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_task_metadata_case ON task_metadata(test_case_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_task_metadata_suite ON task_metadata(test_suite_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_task_metadata_module ON task_metadata(module_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hook_executions_module ON hook_executions(test_module_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hook_executions_suite ON hook_executions(test_suite_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hook_executions_case ON hook_executions(test_case_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hook_executions_error ON hook_executions(error_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_attachments_artifact ON attachments(artifact_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_attachments_annotation ON attachments(annotation_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hypotheses_cited_error ON hypotheses(cited_test_error_id)`;
+	yield* sql`CREATE INDEX IF NOT EXISTS idx_hypotheses_cited_frame ON hypotheses(cited_stack_frame_id)`;
+});
+
+export { migration as default };

package/migrations/0004_stray_output.js

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+
+// src/migrations/0004_stray_output.ts
+/** @internal */
+const migration = Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`ALTER TABLE test_runs ADD COLUMN stray_total INTEGER`;
+	yield* sql`ALTER TABLE test_runs ADD COLUMN stray_stdout INTEGER`;
+	yield* sql`ALTER TABLE test_runs ADD COLUMN stray_stderr INTEGER`;
+	yield* sql`ALTER TABLE test_runs ADD COLUMN stray_bytes INTEGER`;
+	yield* sql`ALTER TABLE test_runs ADD COLUMN stray_samples TEXT`;
+});
+
+export { migration as default };

package/migrations/index.js

@@ -1,5 +1,7 @@
 import migration from "./0001_initial.js";
 import migration$1 from "./0002_test_artifacts.js";
+import migration$2 from "./0003_run_retention.js";
+import migration$3 from "./0004_stray_output.js";
 
 // src/migrations/index.ts
 /**
@@ -21,7 +23,9 @@ import migration$1 from "./0002_test_artifacts.js";
 */
 const PROJECT_MIGRATIONS = {
 	"0001_initial": migration,
-	"0002_test_artifacts": migration$1
+	"0002_test_artifacts": migration$1,
+	"0003_run_retention": migration$2,
+	"0004_stray_output": migration$3
 };
 
 export { PROJECT_MIGRATIONS };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/engine",
-	"version": "1.1.2",
+	"version": "2.0.0",
 	"private": false,
 	"description": "Shared services, layers, SQLite data layer, migrations and platform resolution for the vitest-agent CLI and MCP server.",
 	"keywords": [
@@ -55,7 +55,7 @@
 		"@effected/workspaces": "^0.38.0",
 		"@effected/xdg": "^0.14.1",
 		"@effected/yaml": "^0.25.0",
-		"@vitest-agent/sdk": "7.0.5",
+		"@vitest-agent/sdk": "8.0.0",
 		"effect": "^4.0.6"
 	},
 	"engines": {

package/services/EnvironmentDetector.js

@@ -1,7 +1,19 @@
 import { Context } from "effect";
 
 // src/services/EnvironmentDetector.ts
-/** @public */
+/**
+* Who is running the program and where.
+*
+* @remarks
+* `detect` is the console audience: an agent marker wins over CI, so an
+* agent inside GitHub Actions reads `agent-shell`. `ci` is the CI vendor
+* independently of that precedence, so a caller can keep GitHub-only
+* extras (the step summary, annotations, the `github-actions` reporter)
+* on for the humans reviewing the job even when the console audience is
+* the agent (issue #624).
+*
+* @public
+*/
 var EnvironmentDetector = class extends Context.Service()("vitest-agent/EnvironmentDetector") {};
 
 export { EnvironmentDetector };

package/services/ProjectIdentity.js

@@ -54,6 +54,12 @@ const resolveProjectIdentityFromCandidates = (candidates) => {
 * Service tag. The Live layer (in `layers/ProjectIdentityLive.ts`)
 * wires up the I/O sources; tests provide a stub that returns a
 * pre-built `ResolvedIdentity`.
+*
+* `resolve` fails with `ProjectIdentityNotResolvableError` when every
+* source is absent or empty, and with `ProjectIdentitySourceError` when a
+* source is present but unusable (a malformed `vitest-agent.config.toml`,
+* an unreadable root `package.json`): a broken config is reported, never
+* silently replaced by the default identity (issue 321).
 * @public
 */
 var ProjectIdentity = class extends Context.Service()("vitest-agent/ProjectIdentity") {};

package/testing.d.ts

@@ -1,10 +1,11 @@
-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 { 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, RunRetentionPolicy, RunRetentionPolicy as RunRetentionPolicy$1, StrayOutput, 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";
 import "@effect/platform-node/NodeServices";
 import "@effect/sql-sqlite-node/SqliteClient";
 import { StoreError, StoreMigrationError } from "@effected/store";
 import "effect/sql/SqlClient";
 import { SqlError } from "effect/sql/SqlError";
+import "@effected/env";
 /** @public */
 interface CreateGoalInput {
   readonly tddTaskId: number;
@@ -99,6 +100,13 @@ interface TestRunInput {
   readonly hostSource?: string | null;
   readonly hostValue?: string | null;
   readonly hostMetadata?: Record<string, unknown> | null;
+  /**
+   * Output the run wrote straight to the terminal past Vitest's console
+   * capture (issue 578). A run-level signal: every project row of one
+   * invocation carries the same value. Omitted or `null` when the run
+   * recorded nothing, which the row stores as NULL in every `stray_*` column.
+   */
+  readonly strayOutput?: StrayOutput | null;
 }
 /** @public */
 interface ModuleInput {
@@ -408,6 +416,15 @@ interface RegisterAgentInput {
    */
   readonly agentId?: string;
 }
+/**
+ * What `DataStore.pruneRuns` removed: `test_runs` rows deleted (their
+ * cascaded rows are not counted) and orphaned `files` rows garbage-collected.
+ * @public
+ */
+interface PruneRunsResult {
+  readonly prunedRuns: number;
+  readonly prunedFiles: number;
+}
 /** @public */
 interface AssociateRunSessionInput {
   readonly chatId: string;
@@ -505,6 +522,25 @@ declare const DataStore_base: Context.ServiceClass<DataStore, "vitest-agent/Data
     readonly affectedSessions: number;
     readonly prunedTurns: number;
   }, DataStoreError$1>;
+  /**
+   * Apply a run-retention policy: delete every `test_runs` row beyond the
+   * newest `policy.keepRuns` of its project, and any run older than
+   * `policy.maxAgeDays` days when set, letting the schema's cascades drop
+   * the dependent rows (modules, suites, cases, tags, errors, frames,
+   * coverage, trends, triggers), then garbage-collect `files` rows no
+   * table references any more. `test_history` rows survive with a NULL
+   * `run_id`; they keep their own newest-10-per-series window. Before
+   * the delete, `file_coverage` rows held by a doomed run are moved onto
+   * the lowest surviving run of the same invocation (coverage is written
+   * once per invocation, issue 622) unless a survivor already carries
+   * coverage rows, so every sibling project's coverage read stays whole.
+   *
+   * A handful of synchronous statements on the open connection, no
+   * yielding, so it may run inside `withPersistTransaction` after the
+   * run's own rows are written: the run just written is the newest of
+   * its project and is never pruned.
+   */
+  readonly pruneRuns: (policy: RunRetentionPolicy$1) => Effect.Effect<PruneRunsResult, DataStoreError$1>;
   readonly associateLatestRunWithSession: (input: AssociateRunSessionInput) => Effect.Effect<void, DataStoreError$1>;
   readonly backfillTestCaseTurns: (chatId: string) => Effect.Effect<number, DataStoreError$1>;
   /**
@@ -538,6 +574,32 @@ interface ProjectRunSummary {
   readonly passed: number;
   readonly failed: number;
   readonly skipped: number;
+  /** The latest run's stray output (issue 578); `null` when it recorded none. */
+  readonly strayOutput: StrayOutput | null;
+}
+/**
+ * Options for `DataReader.getStrayOutputHistory`.
+ * @public
+ */
+interface StrayOutputHistoryOptions {
+  /** Only runs of this project; every project otherwise. */
+  readonly project?: string;
+  /** How many of the most recent runs to consider. Default 10. */
+  readonly limit?: number;
+}
+/**
+ * How often recent runs wrote stray output (issue 578). A "run" is one
+ * reporter invocation: stray output is a run-level signal that every project
+ * row of an invocation repeats, so rows are counted once per `invocation_id`.
+ * @public
+ */
+interface StrayOutputHistory {
+  /** Runs considered: the most recent ones, up to the requested limit. */
+  readonly runs: number;
+  /** How many of them recorded any stray output. */
+  readonly runsWithStrayOutput: number;
+  /** The most recent run's stray output, when that run recorded any. */
+  readonly latest: StrayOutput | null;
 }
 /** @public */
 interface FlakyTest {
@@ -896,6 +958,8 @@ interface TestArtifactRow {
 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>;
+  /** How often the most recent runs wrote stray output; see {@link StrayOutputHistory}. */
+  readonly getStrayOutputHistory: (options?: StrayOutputHistoryOptions) => Effect.Effect<StrayOutputHistory, 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>;
@@ -1085,6 +1149,8 @@ type PlatformLiveError = SqlError | StoreError | StoreMigrationError;
 export declare const PROJECT_MIGRATIONS: {
   readonly "0001_initial": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
   readonly "0002_test_artifacts": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
+  readonly "0003_run_retention": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
+  readonly "0004_stray_output": import("effect/Effect").Effect<void, import("effect/sql/SqlError").SqlError, import("effect/sql/SqlClient").SqlClient>;
 };
 /** @public */
 export declare function makeTestLayer(filename: string): Layer.Layer<DataReader | DataStore | import("effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | import("@effect/platform-node/NodeServices").NodeServices, PlatformLiveError, never>;
@@ -1100,5 +1166,5 @@ export declare function withFailures(filename: string): Layer.Layer<DataReader |
 export 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/NodeServices").NodeServices, import("@vitest-agent/sdk").DataStoreError | PlatformLiveError, never>;
 /** @public */
 export 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/NodeServices").NodeServices, import("@vitest-agent/sdk").BehaviorNotFoundError | import("@vitest-agent/sdk").DataStoreError | import("@vitest-agent/sdk").GoalNotFoundError | import("@vitest-agent/sdk").IllegalStatusTransitionError | import("@vitest-agent/sdk").TddTaskAlreadyEndedError | import("@vitest-agent/sdk").TddTaskNotFoundError | PlatformLiveError, never>;
-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 PlatformLiveError, 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 };
+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 PlatformLiveError, type ProjectRunSummary, type PruneRunsResult, type RegisterAgentInput, RegistrationConflictError, type ResolvedThresholds, type RunChangedFile, type RunInvocationMethod, RunRetentionPolicy, type SessionDetail, type SessionInput, type SettingsInput, type SettingsListEntry, type SettingsRow, type StackFrameInput, type StrayOutputHistory, type StrayOutputHistoryOptions, 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

package/testing.js

@@ -2,7 +2,7 @@ import { DataReader } from "./services/DataReader.js";
 import { DataStore } from "./services/DataStore.js";
 import { PROJECT_MIGRATIONS } from "./migrations/index.js";
 import { DataStoreTestLayer, makeTestLayer } from "./testing/layers.js";
-import { Agent, AgentId, AgentNotFoundError, AgentReport, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, ChatId, CoverageBaselines, CoverageReport, DataStoreError, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, TrendEntry, TrendRecord } from "@vitest-agent/sdk";
+import { Agent, AgentId, AgentNotFoundError, AgentReport, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, ChatId, CoverageBaselines, CoverageReport, DataStoreError, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, RunRetentionPolicy, TddTaskAlreadyEndedError, TddTaskNotFoundError, TrendEntry, TrendRecord } from "@vitest-agent/sdk";
 import { Effect, Layer } from "effect";
 
 // src/testing/index.ts
@@ -239,4 +239,4 @@ function withTddTask(filename) {
 	return Layer.effectDiscard(seed).pipe(Layer.provideMerge(base));
 }
 
-export { Agent, AgentId, AgentNotFoundError, AgentReport, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, ChatId, CoverageBaselines, CoverageReport, DataReader, DataStore, DataStoreError, DataStoreTestLayer, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, PROJECT_MIGRATIONS, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, TrendEntry, TrendRecord, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };
+export { Agent, AgentId, AgentNotFoundError, AgentReport, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, ChatId, CoverageBaselines, CoverageReport, DataReader, DataStore, DataStoreError, DataStoreTestLayer, FileCoverageReport, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, PROJECT_MIGRATIONS, RegistrationConflictError, RunRetentionPolicy, TddTaskAlreadyEndedError, TddTaskNotFoundError, TrendEntry, TrendRecord, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };

package/utils/persist-transaction.js

@@ -1,5 +1,5 @@
 import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
-import { Context, Effect, References } from "effect";
+import { Context, Effect, Exit, References } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
 import { isSqlError } from "effect/sql/SqlError";
 
@@ -11,6 +11,55 @@ import { isSqlError } from "effect/sql/SqlError";
 * @internal
 */
 const PersistBatch = Context.Reference("@vitest-agent/engine/PersistBatch", { defaultValue: () => void 0 });
+/**
+* Drop every entry added after `size`. The caches only ever grow (an id for
+* a name never changes while the write lock is held), and a `Map` / `Set`
+* iterates in insertion order, so the entries past the snapshot size are
+* exactly the ones a rolled-back savepoint added.
+*/
+const truncate = (collection, size) => {
+	if (collection.size <= size) return;
+	let index = 0;
+	for (const key of collection.keys()) if (index++ >= size) collection.delete(key);
+};
+/**
+* Run `effect` as a nested transaction that keeps the
+* {@link withPersistTransaction} caches honest.
+*
+* Outside a persist batch this is exactly `sql.withTransaction(effect)`.
+* Inside one, the nested `withTransaction` becomes a SAVEPOINT, and when it
+* rolls back (a failure, a defect, an interrupt) every `files` / `tags` row
+* the savepoint inserted is gone while the ids `DataStoreLive` cached for
+* them would survive in `PersistBatchState`. This helper snapshots the
+* cache sizes before the savepoint opens and discards the entries added
+* since whenever it does not commit, so a later write in the same batch
+* re-inserts the row instead of referencing one that no longer exists
+* (issue #628: a FK failure or a dangling id). A savepoint that commits
+* keeps its entries.
+*
+* Use this, never a bare `sql.withTransaction`, for any nested transaction
+* whose failure a caller may catch and continue from inside the batch; a
+* bare one that rolls back leaves the caches stale. The bookkeeping is
+* synchronous, so the batch's no-yield guarantee is unchanged.
+*
+* @param effect - the writes to run as one savepoint (or transaction)
+* @public
+*/
+const withPersistSavepoint = (effect) => Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	const batch = yield* PersistBatch;
+	if (batch === void 0) return yield* sql.withTransaction(effect);
+	const snapshot = {
+		historyRunIds: batch.historyRunIds.size,
+		tagIds: batch.tagIds.size,
+		fileIds: batch.fileIds.size
+	};
+	return yield* sql.withTransaction(effect).pipe(Effect.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => {
+		truncate(batch.historyRunIds, snapshot.historyRunIds);
+		truncate(batch.tagIds, snapshot.tagIds);
+		truncate(batch.fileIds, snapshot.fileIds);
+	})));
+});
 /** Matches the per-write window `DataStoreLive.writeHistory` keeps outside a batch. */
 const HISTORY_WINDOW = 10;
 /**
@@ -53,8 +102,13 @@ const pruneHistoryForRun = (sql, runId) => sql`DELETE FROM test_history WHERE id
 * genuinely asynchronous work for that reason; CPU-heavy work that needs no
 * database belongs before the block.
 *
-* Nested `withTransaction` calls inside `effect` become savepoints. A
-* `DataReader` query inside it runs on the transaction's connection.
+* Nested `withTransaction` calls inside `effect` become savepoints. Open
+* them through {@link withPersistSavepoint}: a savepoint that rolls back
+* also discards the tag / file ids cached while it was open, so a write the
+* caller recovers from cannot leave a later write pointing at a row the
+* rollback removed. A bare nested `sql.withTransaction` whose failure is
+* caught inside the block leaves those caches stale. A `DataReader` query
+* inside the block runs on the transaction's connection.
 *
 * @param effect - the writes (and the reads they depend on) to run atomically
 * @public
@@ -81,4 +135,4 @@ const withPersistTransaction = (effect) => Effect.gen(function* () {
 	reason: extractSqlReason(e)
 }))));
 
-export { PersistBatch, withPersistTransaction };
+export { PersistBatch, withPersistSavepoint, withPersistTransaction };

package/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
 /** Build-time injected package version (see architecture.md D36). @public */
-const CURRENT_ENGINE_VERSION = "1.1.2";
+const CURRENT_ENGINE_VERSION = "2.0.0";
 
 export { CURRENT_ENGINE_VERSION };