@vitest-agent/sdk 1.0.0

package/layers/DetailResolverLive.js

@@ -0,0 +1,9 @@
+import { DetailResolver } from "../services/DetailResolver.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/DetailResolverLive.ts
+/** @public */
+const DetailResolverLive = Layer.succeed(DetailResolver, { resolve: (executor, health, explicit) => Effect.succeed(explicit ?? (executor === "agent" || executor === "ci" ? "verbose" : health.hasFailures ? "verbose" : health.belowTargets ? "standard" : health.hasTargets === false ? "neutral" : "minimal")) });
+
+//#endregion
+export { DetailResolverLive };

package/layers/DiscoveryRegistryLive.js

@@ -0,0 +1,70 @@
+import { DataStoreError, extractSqlReason } from "../errors/DataStoreError.js";
+import { DiscoveryRegistry } from "../services/DiscoveryRegistry.js";
+import { Effect, Layer } from "effect";
+import { SqlClient } from "@effect/sql/SqlClient";
+
+//#region src/layers/DiscoveryRegistryLive.ts
+const TABLE = "known_projects";
+const rowToDomain = (row) => ({
+	projectKey: row.project_key,
+	canonicalForm: row.canonical_form,
+	dataDbPath: row.data_db_path,
+	gitRemoteOrigin: row.git_remote_origin,
+	workspaceRoot: row.workspace_root,
+	firstSeenAt: row.first_seen_at,
+	lastSeenAt: row.last_seen_at
+});
+const dayInMs = 3600 * 24 * 1e3;
+/** @public */
+const DiscoveryRegistryLive = Layer.effect(DiscoveryRegistry, Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	return {
+		recordProject: (input) => Effect.gen(function* () {
+			const now = Date.now();
+			yield* sql`
+						INSERT INTO ${sql(TABLE)} (
+							project_key, canonical_form, data_db_path, git_remote_origin, workspace_root,
+							first_seen_at, last_seen_at
+						) VALUES (
+							${input.projectKey}, ${input.canonicalForm}, ${input.dataDbPath},
+							${input.gitRemoteOrigin}, ${input.workspaceRoot}, ${now}, ${now}
+						)
+						ON CONFLICT(project_key) DO UPDATE SET
+							canonical_form    = excluded.canonical_form,
+							data_db_path      = excluded.data_db_path,
+							git_remote_origin = excluded.git_remote_origin,
+							workspace_root    = excluded.workspace_root,
+							last_seen_at      = excluded.last_seen_at
+					`;
+		}).pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: TABLE,
+			reason: extractSqlReason(e)
+		}))),
+		listProjects: () => Effect.gen(function* () {
+			return (yield* sql`
+						SELECT project_key, canonical_form, data_db_path, git_remote_origin, workspace_root,
+							first_seen_at, last_seen_at
+						FROM ${sql(TABLE)}
+						ORDER BY last_seen_at DESC, rowid DESC
+					`).map(rowToDomain);
+		}).pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: TABLE,
+			reason: extractSqlReason(e)
+		}))),
+		prune: (maxAgeDays) => Effect.gen(function* () {
+			const cutoff = Date.now() - maxAgeDays * dayInMs;
+			const removable = (yield* sql`SELECT COUNT(*) AS c FROM ${sql(TABLE)} WHERE last_seen_at < ${cutoff}`)[0]?.c ?? 0;
+			if (removable > 0) yield* sql`DELETE FROM ${sql(TABLE)} WHERE last_seen_at < ${cutoff}`;
+			return removable;
+		}).pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: TABLE,
+			reason: extractSqlReason(e)
+		})))
+	};
+}));
+
+//#endregion
+export { DiscoveryRegistryLive };

package/layers/EnvironmentDetectorLive.js

@@ -0,0 +1,21 @@
+import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
+import { Effect, Layer } from "effect";
+import { agent, isAgent } from "std-env";
+
+//#region src/layers/EnvironmentDetectorLive.ts
+const isGitHub = () => process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_ACTIONS === "1";
+const isCI = () => isGitHub() || process.env.CI === "true";
+/** @public */
+const EnvironmentDetectorLive = Layer.succeed(EnvironmentDetector, {
+	detect: () => Effect.sync(() => {
+		if (isAgent) return "agent-shell";
+		if (isGitHub()) return "ci-github";
+		if (isCI()) return "ci-generic";
+		return "terminal";
+	}),
+	isAgent: Effect.sync(() => isAgent),
+	agentName: Effect.sync(() => agent ?? void 0)
+});
+
+//#endregion
+export { EnvironmentDetectorLive };

package/layers/EnvironmentDetectorTest.js

@@ -0,0 +1,13 @@
+import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/EnvironmentDetectorTest.ts
+/** @public */
+const EnvironmentDetectorTest = { layer: (env = "terminal") => Layer.succeed(EnvironmentDetector, {
+	detect: () => Effect.succeed(env),
+	isAgent: Effect.succeed(env === "agent-shell"),
+	agentName: Effect.succeed(env === "agent-shell" ? "test-agent" : void 0)
+}) };
+
+//#endregion
+export { EnvironmentDetectorTest };

package/layers/ExecutorResolverLive.js

@@ -0,0 +1,9 @@
+import { ExecutorResolver } from "../services/ExecutorResolver.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/ExecutorResolverLive.ts
+/** @public */
+const ExecutorResolverLive = Layer.succeed(ExecutorResolver, { resolve: (env) => Effect.succeed(env === "agent-shell" ? "agent" : env === "terminal" ? "human" : "ci") });
+
+//#endregion
+export { ExecutorResolverLive };

package/layers/FormatSelectorLive.js

@@ -0,0 +1,20 @@
+import { FormatSelector } from "../services/FormatSelector.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/FormatSelectorLive.ts
+/**
+* Default format dispatch:
+*
+* - GitHub Actions CI executor: `ci-annotations` (renders as `::error::`).
+* - Human executor: `silent` (Vitest's own reporters handle the user
+*   experience; we just write to the database).
+* - Anyone else (agent-shell, terminal-bound CI): `terminal` — plain
+*   text + ANSI color, no markdown syntax in the place that doesn't
+*   render it. Markdown stays available via explicit `format: "markdown"`
+*   for surfaces that *do* render it (MCP tools, GitHub step summary).
+* @public
+*/
+const FormatSelectorLive = Layer.succeed(FormatSelector, { select: (executor, explicitFormat, environment) => Effect.succeed(explicitFormat ?? (environment === "ci-github" && executor === "ci" ? "ci-annotations" : executor === "human" ? "silent" : "terminal")) });
+
+//#endregion
+export { FormatSelectorLive };

package/layers/HistoryTrackerLive.js

@@ -0,0 +1,47 @@
+import { DataReader } from "../services/DataReader.js";
+import { HistoryTracker } from "../services/HistoryTracker.js";
+import { classifyTest } from "../utils/classify-test.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/HistoryTrackerLive.ts
+const WINDOW_SIZE = 10;
+/** @public */
+const HistoryTrackerLive = Layer.effect(HistoryTracker, Effect.gen(function* () {
+	const reader = yield* DataReader;
+	return { classify: (project, testOutcomes, timestamp) => Effect.gen(function* () {
+		const existing = yield* reader.getHistory(project);
+		const testMap = /* @__PURE__ */ new Map();
+		for (const entry of existing.tests) testMap.set(entry.fullName, {
+			...entry,
+			runs: [...entry.runs]
+		});
+		const classifications = /* @__PURE__ */ new Map();
+		for (const outcome of testOutcomes) {
+			let entry = testMap.get(outcome.fullName);
+			if (!entry) {
+				entry = {
+					fullName: outcome.fullName,
+					runs: []
+				};
+				testMap.set(outcome.fullName, entry);
+			}
+			const priorRuns = entry.runs;
+			entry.runs = [{
+				timestamp,
+				state: outcome.state
+			}, ...priorRuns].slice(0, WINDOW_SIZE);
+			classifications.set(outcome.fullName, classifyTest(outcome.state, priorRuns));
+		}
+		return {
+			history: {
+				project,
+				updatedAt: timestamp,
+				tests: Array.from(testMap.values())
+			},
+			classifications
+		};
+	}) };
+}));
+
+//#endregion
+export { HistoryTrackerLive };

package/layers/HistoryTrackerTest.js

@@ -0,0 +1,25 @@
+import { HistoryTracker } from "../services/HistoryTracker.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/HistoryTrackerTest.ts
+/** @public */
+const HistoryTrackerTest = {
+	empty: () => ({ classifyCalls: [] }),
+	layer: (state, cannedResult) => Layer.succeed(HistoryTracker, { classify: (project, _outcomes, timestamp) => Effect.sync(() => {
+		state.classifyCalls.push({
+			project,
+			timestamp
+		});
+		return cannedResult ?? {
+			history: {
+				project,
+				updatedAt: timestamp,
+				tests: []
+			},
+			classifications: /* @__PURE__ */ new Map()
+		};
+	}) })
+};
+
+//#endregion
+export { HistoryTrackerTest };

package/layers/LoggerLive.js

@@ -0,0 +1,64 @@
+import { Layer, LogLevel, Logger } from "effect";
+import { appendFileSync } from "node:fs";
+
+//#region src/layers/LoggerLive.ts
+/**
+* Create a structured JSON (NDJSON) logger layer for stderr.
+*
+* When level is undefined or LogLevel.None, replaces the default logger with Logger.none (silent).
+* When logFile is set, composes with a file logger via Logger.zip.
+* Uses Logger.structuredLogger serialized to JSON for machine-readable output.
+* @public
+*/
+const LoggerLive = (level, logFile) => {
+	if (!level || level._tag === "None") return Logger.replace(Logger.defaultLogger, Logger.none);
+	const stderrLogger = Logger.structuredLogger.pipe(Logger.map((entry) => JSON.stringify(entry)), Logger.withConsoleError);
+	const baseLogger = logFile ? (() => {
+		const fileLogger = Logger.make(({ message, date, logLevel, annotations }) => {
+			const entry = JSON.stringify({
+				timestamp: date.toISOString(),
+				level: logLevel._tag,
+				message,
+				...Object.fromEntries(annotations)
+			});
+			try {
+				appendFileSync(logFile, `${entry}\n`);
+			} catch {}
+		});
+		return Logger.zip(stderrLogger, fileLogger).pipe(Logger.map(() => void 0));
+	})() : stderrLogger;
+	return Layer.merge(Logger.replace(Logger.defaultLogger, baseLogger), Logger.minimumLogLevel(level));
+};
+/**
+* Resolve log level from option or environment variable.
+* Priority: explicit option \> VITEST_REPORTER_LOG_LEVEL env var \> undefined
+* @public
+*/
+const LEVEL_ALIASES = {
+	warn: "Warning",
+	error: "Error",
+	info: "Info",
+	debug: "Debug",
+	trace: "Trace",
+	fatal: "Fatal",
+	all: "All",
+	none: "None",
+	warning: "Warning"
+};
+/** @public */
+function resolveLogLevel(option) {
+	const raw = option ?? process.env.VITEST_REPORTER_LOG_LEVEL;
+	if (!raw) return void 0;
+	const normalized = LEVEL_ALIASES[raw.toLowerCase()] ?? `${raw.charAt(0).toUpperCase()}${raw.slice(1).toLowerCase()}`;
+	return LogLevel.fromLiteral(normalized);
+}
+/**
+* Resolve log file from option or environment variable.
+* @public
+*/
+function resolveLogFile(option) {
+	return option ?? process.env.VITEST_REPORTER_LOG_FILE ?? void 0;
+}
+
+//#endregion
+export { LoggerLive, resolveLogFile, resolveLogLevel };

package/layers/OutputPipelineLive.js

@@ -0,0 +1,13 @@
+import { DetailResolverLive } from "./DetailResolverLive.js";
+import { EnvironmentDetectorLive } from "./EnvironmentDetectorLive.js";
+import { ExecutorResolverLive } from "./ExecutorResolverLive.js";
+import { FormatSelectorLive } from "./FormatSelectorLive.js";
+import { OutputRendererLive } from "./OutputRendererLive.js";
+import { Layer } from "effect";
+
+//#region src/layers/OutputPipelineLive.ts
+/** @public */
+const OutputPipelineLive = Layer.mergeAll(EnvironmentDetectorLive, ExecutorResolverLive, FormatSelectorLive, DetailResolverLive, OutputRendererLive);
+
+//#endregion
+export { OutputPipelineLive };

package/layers/OutputRendererLive.js

@@ -0,0 +1,28 @@
+import { ciAnnotationsFormatter } from "../formatters/ci-annotations.js";
+import { GfmFormatter } from "../formatters/gfm.js";
+import { JsonFormatter } from "../formatters/json.js";
+import { MarkdownFormatter } from "../formatters/markdown.js";
+import { SilentFormatter } from "../formatters/silent.js";
+import { TerminalFormatter } from "../formatters/terminal.js";
+import { OutputRenderer } from "../services/OutputRenderer.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/OutputRendererLive.ts
+const formatters = /* @__PURE__ */ new Map([
+	["terminal", TerminalFormatter],
+	["markdown", MarkdownFormatter],
+	["gfm", GfmFormatter],
+	["json", JsonFormatter],
+	["silent", SilentFormatter],
+	["vitest-bypass", SilentFormatter],
+	["ci-annotations", ciAnnotationsFormatter]
+]);
+/** @public */
+const OutputRendererLive = Layer.succeed(OutputRenderer, { render: (reports, format, context) => Effect.sync(() => {
+	const formatter = formatters.get(format);
+	if (!formatter) return [];
+	return formatter.render(reports, context);
+}) });
+
+//#endregion
+export { OutputRendererLive };

package/layers/PathResolutionLive.js

@@ -0,0 +1,36 @@
+import { ConfigLive } from "./ConfigLive.js";
+import { Layer } from "effect";
+import { WorkspaceDiscoveryLive, WorkspaceRootLive } from "workspaces-effect";
+import { AppDirsConfig, XdgLive } from "xdg-effect";
+
+//#region src/layers/PathResolutionLive.ts
+const APP_NAMESPACE = "vitest-agent";
+/**
+* Minimal slice of `workspaces-effect` for `resolveWorkspaceKey`.
+*
+* `WorkspacesLive` from `workspaces-effect` composes seven services and
+* runs eager I/O at layer construction in `LockfileReaderLive` (reads and
+* parses the entire lockfile). We only call `WorkspaceDiscovery.listPackages`
+* to read the root `package.json`'s `name` — `WorkspaceRoot` is the only
+* upstream dependency `WorkspaceDiscoveryLive` actually needs. Skipping
+* the rest avoids the lockfile-read cost on every reporter init, which
+* otherwise fires once per Vitest project (5+ reads on monorepos).
+*/
+const WorkspaceMinimalLive = WorkspaceDiscoveryLive.pipe(Layer.provide(WorkspaceRootLive));
+/**
+* Composite layer providing every service `resolveDataPath` requires:
+* `AppDirs` (XDG path resolution), `VitestAgentConfigFile` (TOML
+* config loader), `WorkspaceDiscovery` and `WorkspaceRoot` (workspace name
+* lookup).
+*
+* Callers still need to provide `FileSystem` and `Path` from
+* `@effect/platform-node`'s `NodeContext.layer` (or the equivalent on Bun).
+*
+* @param projectDir - Absolute path inside the user's workspace, used to
+*   anchor the config file resolvers.
+* @public
+*/
+const PathResolutionLive = (projectDir) => Layer.mergeAll(XdgLive(new AppDirsConfig({ namespace: APP_NAMESPACE })), ConfigLive(projectDir), WorkspaceMinimalLive);
+
+//#endregion
+export { PathResolutionLive };

package/layers/PerClientSessionMapLive.js

@@ -0,0 +1,145 @@
+import { DataStoreError, extractSqlReason } from "../errors/DataStoreError.js";
+import { PerClientSessionMapReader, PerClientSessionMapWriter } from "../services/PerClientSessionMap.js";
+import { Effect, Layer, Option } from "effect";
+import { basename } from "node:path";
+import { SqlClient } from "@effect/sql/SqlClient";
+import { randomUUID } from "node:crypto";
+
+//#region src/layers/PerClientSessionMapLive.ts
+const sessionRowToContext = (row) => ({
+	hostSessionId: row.host_session_id,
+	conversationId: row.conversation_id,
+	projectKey: row.project_key,
+	projectDir: row.project_dir,
+	mainAgentId: row.main_agent_id,
+	startedAt: row.started_at,
+	endedAt: row.ended_at
+});
+/**
+* Extract the transcript UUID from a transcript file path. Claude
+* Code's transcript filenames are the conversation UUID directly
+* (with optional `.jsonl` suffix), so the basename is the right
+* stable key — path normalization differences (symlinks, user
+* renames) don't fragment the table.
+*/
+const extractTranscriptUuid = (transcriptPath) => {
+	const base = basename(transcriptPath);
+	const dotIndex = base.lastIndexOf(".");
+	return dotIndex === -1 ? base : base.slice(0, dotIndex);
+};
+const lookupConversationImpl = (sql, transcriptPath) => Effect.gen(function* () {
+	const rows = yield* sql`
+			SELECT transcript_uuid, transcript_path, conversation_id, first_seen_at, last_seen_at
+			FROM conversation_map WHERE transcript_uuid = ${extractTranscriptUuid(transcriptPath)}
+		`;
+	return rows.length === 0 ? Option.none() : Option.some(rows[0].conversation_id);
+}).pipe(Effect.mapError((e) => new DataStoreError({
+	operation: "read",
+	table: "conversation_map",
+	reason: extractSqlReason(e)
+})));
+const lookupByProjectDirImpl = (sql, projectDir) => Effect.gen(function* () {
+	const rows = yield* sql`
+			SELECT host_session_id, conversation_id, project_key, project_dir, main_agent_id, started_at, ended_at
+			FROM session_map
+			WHERE project_dir = ${projectDir} AND ended_at IS NULL
+			ORDER BY started_at DESC
+			LIMIT 1
+		`;
+	return rows.length === 0 ? Option.none() : Option.some(sessionRowToContext(rows[0]));
+}).pipe(Effect.mapError((e) => new DataStoreError({
+	operation: "read",
+	table: "session_map",
+	reason: extractSqlReason(e)
+})));
+/**
+* Read-only layer. The entry point provides an `SqlClient` configured
+* with the `?mode=ro` URI parameter; this layer wraps the read
+* methods and never declares write methods.
+* @public
+*/
+const PerClientSessionMapReaderLive = Layer.effect(PerClientSessionMapReader, Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	return {
+		lookupConversation: (path) => lookupConversationImpl(sql, path),
+		lookupByProjectDir: (dir) => lookupByProjectDirImpl(sql, dir)
+	};
+}));
+/**
+* Read-write layer. Provides both write methods and the Reader's read
+* methods so the same layer instance satisfies callers of either
+* tag.
+* @public
+*/
+const PerClientSessionMapWriterLive = Layer.effect(PerClientSessionMapWriter, Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	const mapConversation = (transcriptPath) => Effect.gen(function* () {
+		const uuid = extractTranscriptUuid(transcriptPath);
+		const existing = yield* sql`
+					SELECT conversation_id FROM conversation_map WHERE transcript_uuid = ${uuid}
+				`;
+		const now = Date.now();
+		if (existing.length > 0) {
+			yield* sql`UPDATE conversation_map SET last_seen_at = ${now} WHERE transcript_uuid = ${uuid}`;
+			return existing[0].conversation_id;
+		}
+		const conversationId = randomUUID();
+		yield* sql`
+					INSERT INTO conversation_map (transcript_uuid, transcript_path, conversation_id, first_seen_at, last_seen_at)
+					VALUES (${uuid}, ${transcriptPath}, ${conversationId}, ${now}, ${now})
+				`;
+		return conversationId;
+	}).pipe(Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "conversation_map",
+		reason: extractSqlReason(e)
+	})));
+	const mapSession = (input) => Effect.gen(function* () {
+		const existing = yield* sql`
+					SELECT main_agent_id, conversation_id FROM session_map WHERE host_session_id = ${input.hostSessionId}
+				`;
+		if (existing.length > 0) return {
+			mainAgentId: existing[0].main_agent_id,
+			conversationId: existing[0].conversation_id
+		};
+		const mainAgentId = randomUUID();
+		const now = Date.now();
+		yield* sql`
+					INSERT INTO session_map (
+						host_session_id, conversation_id, project_key, project_dir, main_agent_id, started_at, ended_at
+					) VALUES (
+						${input.hostSessionId}, ${input.conversationId}, ${input.projectKey}, ${input.projectDir},
+						${mainAgentId}, ${now}, ${null}
+					)
+				`;
+		return {
+			mainAgentId,
+			conversationId: input.conversationId
+		};
+	}).pipe(Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "session_map",
+		reason: extractSqlReason(e)
+	})));
+	const endSession = (hostSessionId, endedAt) => sql`UPDATE session_map SET ended_at = ${endedAt} WHERE host_session_id = ${hostSessionId}`.pipe(Effect.asVoid, Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "session_map",
+		reason: extractSqlReason(e)
+	})));
+	return {
+		mapConversation,
+		mapSession,
+		endSession,
+		lookupConversation: (path) => lookupConversationImpl(sql, path),
+		lookupByProjectDir: (dir) => lookupByProjectDirImpl(sql, dir)
+	};
+})).pipe(Layer.provideMerge(Layer.effect(PerClientSessionMapReader, Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	return {
+		lookupConversation: (path) => lookupConversationImpl(sql, path),
+		lookupByProjectDir: (dir) => lookupByProjectDirImpl(sql, dir)
+	};
+}))));
+
+//#endregion
+export { PerClientSessionMapReaderLive, PerClientSessionMapWriterLive };

package/layers/ProjectDiscoveryLive.js

@@ -0,0 +1,70 @@
+import { DiscoveryError } from "../errors/DiscoveryError.js";
+import { ProjectDiscovery } from "../services/ProjectDiscovery.js";
+import { Effect, Layer } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/layers/ProjectDiscoveryLive.ts
+const TEST_FILE_PATTERN = /\.(test|spec)\.(ts|tsx)$/;
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"coverage",
+	".turbo",
+	".vite"
+]);
+function isTestFile(filePath) {
+	return TEST_FILE_PATTERN.test(filePath);
+}
+function testFileToSource(testFile) {
+	return testFile.replace(/\.(test|spec)\.(ts|tsx)$/, ".$2");
+}
+function walkDir(fs, dir) {
+	return Effect.gen(function* () {
+		const entries = yield* fs.readDirectory(dir);
+		const results = [];
+		for (const entry of entries) {
+			if (SKIP_DIRS.has(entry)) continue;
+			const fullPath = `${dir}/${entry}`;
+			if ((yield* fs.stat(fullPath)).type === "Directory") {
+				const subFiles = yield* walkDir(fs, fullPath);
+				results.push(...subFiles);
+			} else results.push(fullPath);
+		}
+		return results;
+	});
+}
+/** @public */
+const ProjectDiscoveryLive = Layer.effect(ProjectDiscovery, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const mapTestToSource = (testFile) => Effect.gen(function* () {
+		const sourceFile = testFileToSource(testFile);
+		return (yield* fs.exists(sourceFile)) ? [sourceFile] : [];
+	}).pipe(Effect.mapError((error) => new DiscoveryError({
+		operation: "stat",
+		path: testFile,
+		reason: String(error)
+	})));
+	return {
+		discoverTestFiles: (rootDir) => Effect.gen(function* () {
+			const testFiles = (yield* walkDir(fs, rootDir).pipe(Effect.mapError((error) => new DiscoveryError({
+				operation: "glob",
+				path: rootDir,
+				reason: String(error)
+			})))).filter(isTestFile);
+			const entries = [];
+			for (const testFile of testFiles) {
+				const sourceFiles = yield* mapTestToSource(testFile);
+				entries.push({
+					testFile,
+					sourceFiles
+				});
+			}
+			return entries;
+		}),
+		mapTestToSource
+	};
+}));
+
+//#endregion
+export { ProjectDiscoveryLive };

package/layers/ProjectDiscoveryTest.js

@@ -0,0 +1,12 @@
+import { ProjectDiscovery } from "../services/ProjectDiscovery.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/ProjectDiscoveryTest.ts
+/** @public */
+const ProjectDiscoveryTest = { layer: (entries) => Layer.succeed(ProjectDiscovery, {
+	discoverTestFiles: () => Effect.succeed(entries),
+	mapTestToSource: (testFile) => Effect.succeed(entries.find((e) => e.testFile === testFile)?.sourceFiles ?? [])
+}) };
+
+//#endregion
+export { ProjectDiscoveryTest };