@vitest-agent/engine 0.1.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 { DiscoveryRegistry } from "../services/DiscoveryRegistry.js";
+import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
+import { Effect, Layer } from "effect";
+import { SqlClient } from "effect/unstable/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 = 864e5;
+/** @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,36 @@
+import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
+import { Effect, Layer } from "effect";
+import { agent, isAgent } from "std-env";
+
+//#region src/layers/EnvironmentDetectorLive.ts
+const isGitHub = (env) => env.GITHUB_ACTIONS === "true" || env.GITHUB_ACTIONS === "1";
+const isCI = (env) => isGitHub(env) || env.CI === "true";
+/**
+* Pure classification behind {@link EnvironmentDetectorLive}: an agent shell
+* wins, then GitHub Actions, then generic CI, else a terminal.
+*
+* @param env - the environment map to consult
+* @param agentShell - whether the process runs under an AI agent (`std-env`'s `isAgent`)
+* @public
+*/
+const classifyEnvironment = (env, agentShell) => {
+	if (agentShell) return "agent-shell";
+	if (isGitHub(env)) return "ci-github";
+	if (isCI(env)) return "ci-generic";
+	return "terminal";
+};
+/**
+* Live environment detector. CI detection reads `GITHUB_ACTIONS` / `CI`
+* from the injected `env` map; agent detection comes from `std-env`.
+*
+* @param env - the environment map to consult (the front end passes `process.env`)
+* @public
+*/
+const EnvironmentDetectorLive = (env) => Layer.succeed(EnvironmentDetector, {
+	detect: () => Effect.sync(() => classifyEnvironment(env, isAgent)),
+	isAgent: Effect.sync(() => isAgent),
+	agentName: Effect.sync(() => agent ?? void 0)
+});
+
+//#endregion
+export { EnvironmentDetectorLive, classifyEnvironment };

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,49 @@
+import { DataReader } from "../services/DataReader.js";
+import { HistoryTracker, historyKey } from "../services/HistoryTracker.js";
+import { classifyTest } from "@vitest-agent/sdk";
+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(historyKey(entry.modulePath, entry.fullName), {
+			...entry,
+			runs: [...entry.runs]
+		});
+		const classifications = /* @__PURE__ */ new Map();
+		for (const outcome of testOutcomes) {
+			const key = historyKey(outcome.modulePath, outcome.fullName);
+			let entry = testMap.get(key);
+			if (!entry) {
+				entry = {
+					modulePath: outcome.modulePath,
+					fullName: outcome.fullName,
+					runs: []
+				};
+				testMap.set(key, entry);
+			}
+			const priorRuns = entry.runs;
+			entry.runs = [{
+				timestamp,
+				state: outcome.state
+			}, ...priorRuns].slice(0, WINDOW_SIZE);
+			classifications.set(key, 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,70 @@
+import { Layer, LogLevel, Logger, References } 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 `"None"`, installs an empty logger set (silent).
+* When logFile is set, composes the stderr logger with a file logger.
+* Uses `Logger.formatJson` / `Logger.formatStructured` for machine-readable
+* output.
+* @public
+*/
+const LoggerLive = (level, logFile) => {
+	if (!level || level === "None") return Logger.layer([]);
+	const stderrLogger = Logger.formatJson.pipe(Logger.withConsoleError);
+	const fileLogger = logFile ? Logger.formatStructured.pipe(Logger.map((entry) => {
+		const line = JSON.stringify({
+			timestamp: entry.timestamp,
+			level: entry.level,
+			message: entry.message,
+			...entry.annotations
+		});
+		try {
+			appendFileSync(logFile, `${line}\n`);
+		} catch {}
+		return line;
+	})) : void 0;
+	const loggers = fileLogger ? [stderrLogger, fileLogger] : [stderrLogger];
+	return Layer.merge(Logger.layer(loggers), Layer.succeed(References.MinimumLogLevel, level));
+};
+const LEVEL_ALIASES = {
+	warn: "Warn",
+	warning: "Warn",
+	error: "Error",
+	info: "Info",
+	debug: "Debug",
+	trace: "Trace",
+	fatal: "Fatal",
+	all: "All",
+	none: "None"
+};
+/**
+* Resolve log level from option or environment variable.
+* Priority: explicit option \> `VITEST_REPORTER_LOG_LEVEL` in `env` \> undefined.
+*
+* @param env - the environment map to consult (the front end passes `process.env`)
+* @param option - explicit override
+* @public
+*/
+function resolveLogLevel(env, option) {
+	const raw = option ?? 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.values.includes(normalized) ? normalized : void 0;
+}
+/**
+* Resolve log file from option or environment variable
+* (`VITEST_REPORTER_LOG_FILE` in `env`).
+*
+* @param env - the environment map to consult (the front end passes `process.env`)
+* @param option - explicit override
+* @public
+*/
+function resolveLogFile(env, option) {
+	return option ?? env.VITEST_REPORTER_LOG_FILE ?? void 0;
+}
+
+//#endregion
+export { LoggerLive, resolveLogFile, resolveLogLevel };

package/layers/OutputPipelineLive.js

@@ -0,0 +1,20 @@
+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
+/**
+* The output pipeline: environment detection, executor resolution, format
+* selection, detail resolution and rendering.
+*
+* @param env - the environment map `EnvironmentDetectorLive` consults
+*   (the front end passes `process.env`)
+* @public
+*/
+const OutputPipelineLive = (env) => Layer.mergeAll(EnvironmentDetectorLive(env), ExecutorResolverLive, FormatSelectorLive, DetailResolverLive, OutputRendererLive);
+
+//#endregion
+export { OutputPipelineLive };

package/layers/OutputRendererLive.js

@@ -0,0 +1,23 @@
+import { OutputRenderer } from "../services/OutputRenderer.js";
+import { GfmFormatter, JsonFormatter, MarkdownFormatter, SilentFormatter, TerminalFormatter, ciAnnotationsFormatter } from "@vitest-agent/sdk";
+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,46 @@
+import { ConfigLive } from "./ConfigLive.js";
+import { Layer } from "effect";
+import { WorkspaceDiscovery, WorkspaceRoot } from "@effected/workspaces";
+import { AppDirs, Xdg } from "@effected/xdg";
+
+//#region src/layers/PathResolutionLive.ts
+/**
+* The XDG namespace every vitest-agent data directory lives under —
+* `<XDG data>/vitest-agent`. The one place the name exists.
+* @public
+*/
+const APP_NAMESPACE = "vitest-agent";
+/**
+* `AppDirs` over the ambient `Xdg` environment, bound to a `const` so the
+* layer memoizes by reference (calling `AppDirs.layer(...)` inline at two
+* provide sites would resolve two independent services). Requires
+* `FileSystem` + `Path` at the edge.
+*/
+const AppDirsLive = AppDirs.layer({ namespace: APP_NAMESPACE }).pipe(Layer.provide(Xdg.layer));
+/**
+* Composite layer providing every service `resolveDataPath` requires:
+* `AppDirs` (XDG path resolution), `VitestAgentConfigFile` (TOML
+* config loader), and `WorkspaceDiscovery` / `WorkspaceRoot` (workspace name
+* lookup).
+*
+* Callers still need to provide `FileSystem` and `Path` from
+* `@effect/platform-node`'s `NodeServices.layer` (or the equivalent on Bun).
+*
+* `WorkspaceDiscovery` is pinned to `projectDir` as its `cwd`, which sets the
+* root for the layer-bound methods (`listPackages`, `info`, `refresh`). The
+* per-root methods (`listPackagesIn`, `infoIn`, `refreshIn`) take a directory
+* per call and ignore that pin — `resolveWorkspaceKey` and
+* `ProjectIdentityLive` use them, so a long-lived host built against one root
+* still answers correctly for a git worktree or an unrelated project.
+*
+* @param projectDir - Absolute path inside the user's workspace, used to
+*   anchor the config file resolvers and workspace discovery.
+* @public
+*/
+const PathResolutionLive = (projectDir) => {
+	const WorkspaceMinimalLive = WorkspaceDiscovery.layer({ cwd: projectDir }).pipe(Layer.provide(WorkspaceRoot.layer));
+	return Layer.mergeAll(AppDirsLive, ConfigLive(projectDir), WorkspaceMinimalLive);
+};
+
+//#endregion
+export { APP_NAMESPACE, PathResolutionLive };

package/layers/PerClientSessionMapLive.js

@@ -0,0 +1,145 @@
+import { PerClientSessionMapReader, PerClientSessionMapWriter } from "../services/PerClientSessionMap.js";
+import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
+import { Effect, Layer, Option } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+
+//#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,67 @@
+import { ProjectDiscovery } from "../services/ProjectDiscovery.js";
+import { DiscoveryError, NON_DISCOVERABLE_DIRS } from "@vitest-agent/sdk";
+import { Effect, FileSystem, Layer } from "effect";
+
+//#region src/layers/ProjectDiscoveryLive.ts
+const TEST_FILE_PATTERN = /\.(test|spec)\.(ts|tsx)$/;
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	...NON_DISCOVERABLE_DIRS,
+	"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 };