@vitest-agent/sdk 3.1.2 → 4.0.0

package/layers/DataReaderLive.js

@@ -1,1923 +0,0 @@
-import { DataStoreError, extractSqlReason } from "../errors/DataStoreError.js";
-import { DataReader } from "../services/DataReader.js";
-import { historyKey } from "../services/HistoryTracker.js";
-import { Effect, Layer, Option } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-
-//#region src/layers/DataReaderLive.ts
-/** @public */
-const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
-	const sql = yield* SqlClient;
-	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
-					FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return Option.none();
-		const run = runs[0];
-		const failedModules = yield* sql`SELECT f.path as file_path, tm.state as module_state, tm.duration as module_duration, tm.id as module_id
-					FROM test_modules tm
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${run.id} AND tm.state = 'failed'`;
-		const moduleIds = failedModules.map((m) => m.module_id);
-		const allTestCases = moduleIds.length > 0 ? yield* sql`SELECT tc.module_id, tc.id as test_case_id, tc.name, tc.full_name, tc.state, tc.duration, tc.flaky, tc.slow, tc.classification
-							FROM test_cases tc WHERE tc.module_id IN ${sql.in(moduleIds)}` : [];
-		const allErrors = moduleIds.length > 0 ? yield* sql`SELECT te.test_case_id, te.module_id, te.scope, te.message, te.stack, te.diff
-							FROM test_errors te
-							WHERE te.run_id = ${run.id}
-							  AND te.module_id IN ${sql.in(moduleIds)}` : [];
-		const testsByModule = /* @__PURE__ */ new Map();
-		for (const tc of allTestCases) {
-			const arr = testsByModule.get(tc.module_id);
-			if (arr) arr.push(tc);
-			else testsByModule.set(tc.module_id, [tc]);
-		}
-		const errorsByTestCase = /* @__PURE__ */ new Map();
-		const errorsByModule = /* @__PURE__ */ new Map();
-		for (const e of allErrors) if (e.scope === "test" && e.test_case_id != null) {
-			const arr = errorsByTestCase.get(e.test_case_id);
-			if (arr) arr.push(e);
-			else errorsByTestCase.set(e.test_case_id, [e]);
-		} else if (e.scope === "module" && e.module_id != null) {
-			const arr = errorsByModule.get(e.module_id);
-			if (arr) arr.push(e);
-			else errorsByModule.set(e.module_id, [e]);
-		}
-		const failedModuleReports = failedModules.map((mod) => {
-			const tests = testsByModule.get(mod.module_id) ?? [];
-			const modErrors = errorsByModule.get(mod.module_id) ?? [];
-			const testReports = tests.map((tc) => {
-				const tcErrors = errorsByTestCase.get(tc.test_case_id) ?? [];
-				return {
-					name: tc.name,
-					fullName: tc.full_name,
-					state: tc.state,
-					...tc.duration != null ? { duration: tc.duration } : {},
-					...tc.flaky === 1 ? { flaky: true } : {},
-					...tc.slow === 1 ? { slow: true } : {},
-					...tcErrors.length > 0 ? { errors: tcErrors.map((e) => ({
-						message: e.message,
-						...e.stack != null ? { stack: e.stack } : {},
-						...e.diff != null ? { diff: e.diff } : {}
-					})) } : {},
-					...tc.classification != null ? { classification: tc.classification } : {}
-				};
-			});
-			return {
-				file: mod.file_path,
-				state: mod.module_state,
-				...mod.module_duration != null ? { duration: mod.module_duration } : {},
-				...modErrors.length > 0 ? { errors: modErrors.map((e) => ({
-					message: e.message,
-					...e.stack != null ? { stack: e.stack } : {},
-					...e.diff != null ? { diff: e.diff } : {}
-				})) } : {},
-				tests: testReports
-			};
-		});
-		const unhandledErrors = yield* sql`SELECT message, stack, diff FROM test_errors
-					WHERE run_id = ${run.id} AND scope = 'unhandled'`;
-		const failedFiles = failedModules.map((m) => m.file_path);
-		const projectName = run.project;
-		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}`;
-		const lowCoverage = fileCovRows.filter((r) => r.tier === "below_threshold").map((r) => ({
-			file: r.file_path,
-			summary: {
-				statements: r.statements,
-				branches: r.branches,
-				functions: r.functions,
-				lines: r.lines
-			},
-			uncoveredLines: r.uncovered_lines ?? ""
-		}));
-		const belowTarget = fileCovRows.filter((r) => r.tier === "below_target").map((r) => ({
-			file: r.file_path,
-			summary: {
-				statements: r.statements,
-				branches: r.branches,
-				functions: r.functions,
-				lines: r.lines
-			},
-			uncoveredLines: r.uncovered_lines ?? ""
-		}));
-		const trendRows = yield* sql`SELECT statements, branches, functions, lines FROM coverage_trends WHERE run_id = ${run.id} LIMIT 1`;
-		const totals = trendRows[0] ? {
-			statements: trendRows[0].statements,
-			branches: trendRows[0].branches,
-			functions: trendRows[0].functions,
-			lines: trendRows[0].lines
-		} : {
-			statements: 0,
-			branches: 0,
-			functions: 0,
-			lines: 0
-		};
-		const baselineRows = yield* sql`SELECT metric, value FROM coverage_baselines
-					WHERE project = '__global__' AND kind = 'baseline' AND pattern = ''`;
-		const thresholds = {};
-		for (const b of baselineRows) if (b.metric === "lines") thresholds.lines = b.value;
-		else if (b.metric === "functions") thresholds.functions = b.value;
-		else if (b.metric === "branches") thresholds.branches = b.value;
-		else if (b.metric === "statements") thresholds.statements = b.value;
-		const coverage = fileCovRows.length > 0 || trendRows.length > 0 ? {
-			totals,
-			thresholds: {
-				global: thresholds,
-				patterns: []
-			},
-			scoped: false,
-			lowCoverage,
-			lowCoverageFiles: lowCoverage.map((f) => f.file),
-			...belowTarget.length > 0 ? {
-				belowTarget,
-				belowTargetFiles: belowTarget.map((f) => f.file)
-			} : {}
-		} : void 0;
-		const report = {
-			timestamp: run.timestamp,
-			project: projectName,
-			reason: run.reason,
-			summary: {
-				total: run.total,
-				passed: run.passed,
-				failed: run.failed,
-				skipped: run.skipped,
-				duration: run.duration
-			},
-			failed: failedModuleReports,
-			unhandledErrors: unhandledErrors.map((e) => ({
-				message: e.message,
-				...e.stack != null ? { stack: e.stack } : {},
-				...e.diff != null ? { diff: e.diff } : {}
-			})),
-			failedFiles,
-			...coverage ? { coverage } : {}
-		};
-		return Option.some(report);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_runs",
-		reason: extractSqlReason(e)
-	})));
-	const getRunsByProject = () => Effect.gen(function* () {
-		yield* Effect.logDebug("getRunsByProject");
-		return (yield* sql`SELECT
-						t1.project,
-						t1.timestamp as last_run,
-						t1.reason as last_result,
-						t1.total,
-						t1.passed,
-						t1.failed,
-						t1.skipped
-					FROM test_runs t1
-					INNER JOIN (
-						SELECT project, MAX(timestamp) as max_ts
-						FROM test_runs
-						GROUP BY project
-					) t2 ON t1.project = t2.project
-						AND t1.timestamp = t2.max_ts`).map((r) => ({
-			project: r.project,
-			lastRun: r.last_run,
-			lastResult: r.last_result,
-			total: r.total,
-			passed: r.passed,
-			failed: r.failed,
-			skipped: r.skipped
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_runs",
-		reason: extractSqlReason(e)
-	})));
-	const getHistory = (project, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getHistory").pipe(Effect.annotateLogs({
-			project,
-			...options
-		}));
-		const testName = options?.testName ?? null;
-		const modulePath = options?.modulePath ?? null;
-		const limit = options?.limit ?? 20;
-		const rows = yield* sql`WITH ranked AS (
-						SELECT module_path, full_name, timestamp, state,
-							ROW_NUMBER() OVER (
-								PARTITION BY module_path, full_name
-								ORDER BY timestamp DESC
-							) AS rn
-						FROM test_history
-						WHERE project = ${project}
-							AND (${testName} IS NULL OR full_name = ${testName})
-							AND (${modulePath} IS NULL OR module_path = ${modulePath})
-					)
-					SELECT module_path, full_name, timestamp, state
-					FROM ranked
-					WHERE rn <= ${limit}
-					ORDER BY module_path, full_name, timestamp DESC`;
-		const testsMap = /* @__PURE__ */ new Map();
-		for (const row of rows) {
-			if (row.state !== "passed" && row.state !== "failed") continue;
-			const key = historyKey(row.module_path, row.full_name);
-			const existing = testsMap.get(key);
-			if (existing) existing.runs.push({
-				timestamp: row.timestamp,
-				state: row.state
-			});
-			else testsMap.set(key, {
-				modulePath: row.module_path,
-				fullName: row.full_name,
-				runs: [{
-					timestamp: row.timestamp,
-					state: row.state
-				}]
-			});
-		}
-		const tests = Array.from(testsMap.values()).map(({ modulePath, fullName, runs }) => ({
-			modulePath,
-			fullName,
-			runs
-		}));
-		return {
-			project,
-			updatedAt: tests.reduce((latest, t) => {
-				const ts = t.runs[0]?.timestamp ?? "";
-				return ts > latest ? ts : latest;
-			}, "") || (/* @__PURE__ */ new Date()).toISOString(),
-			tests
-		};
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_history",
-		reason: extractSqlReason(e)
-	})));
-	/**
-	* Shared read for the `coverage_baselines` table's per-`kind` rows
-	* (`baseline` / `threshold` / `target`). Returns `Option.none()` when
-	* no rows of that kind were ever persisted, so a caller can tell
-	* "never configured" apart from "configured with zero metrics"
-	* (issue #237).
-	*/
-	const getCoveragePolicy = (kind, project) => Effect.gen(function* () {
-		yield* Effect.logDebug("getCoveragePolicy").pipe(Effect.annotateLogs({
-			kind,
-			project
-		}));
-		const rows = yield* sql`SELECT metric, value, pattern, updated_at
-					FROM coverage_baselines
-					WHERE project = ${project} AND kind = ${kind}
-					ORDER BY pattern, metric`;
-		if (rows.length === 0) return Option.none();
-		const global = {};
-		const patternsMap = /* @__PURE__ */ new Map();
-		let updatedAt = rows[0].updated_at;
-		for (const row of rows) {
-			if (row.updated_at > updatedAt) updatedAt = row.updated_at;
-			if (row.pattern === "") global[row.metric] = row.value;
-			else {
-				const existing = patternsMap.get(row.pattern);
-				if (existing) existing[row.metric] = row.value;
-				else patternsMap.set(row.pattern, { [row.metric]: row.value });
-			}
-		}
-		const patterns = Array.from(patternsMap.entries());
-		const baselines = {
-			updatedAt,
-			global,
-			patterns
-		};
-		return Option.some(baselines);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "coverage_baselines",
-		reason: extractSqlReason(e)
-	})));
-	const getBaselines = (project) => getCoveragePolicy("baseline", project);
-	const getTrends = (project, limit) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTrends").pipe(Effect.annotateLogs({
-			project,
-			limit: limit ?? 50
-		}));
-		const rows = yield* sql`SELECT timestamp, lines, functions, branches, statements, direction, targets_hash
-					FROM coverage_trends
-					WHERE project = ${project}
-					ORDER BY timestamp DESC
-					LIMIT ${limit ?? 50}`;
-		if (rows.length === 0) return Option.none();
-		const chronological = [...rows].reverse();
-		const record = { entries: chronological.map((row, i) => {
-			const prev = i > 0 ? chronological[i - 1] : null;
-			return {
-				timestamp: row.timestamp,
-				coverage: {
-					lines: row.lines,
-					functions: row.functions,
-					branches: row.branches,
-					statements: row.statements
-				},
-				delta: prev ? {
-					lines: row.lines - prev.lines,
-					functions: row.functions - prev.functions,
-					branches: row.branches - prev.branches,
-					statements: row.statements - prev.statements
-				} : {
-					lines: 0,
-					functions: 0,
-					branches: 0,
-					statements: 0
-				},
-				direction: row.direction,
-				...row.targets_hash != null ? { targetsHash: row.targets_hash } : {}
-			};
-		}) };
-		return Option.some(record);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "coverage_trends",
-		reason: extractSqlReason(e)
-	})));
-	const getFlaky = (project, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getFlaky").pipe(Effect.annotateLogs({
-			project,
-			...options
-		}));
-		const testName = options?.testName ?? null;
-		const modulePath = options?.modulePath ?? null;
-		return (yield* sql`SELECT
-						th1.full_name,
-						th1.module_path,
-						th1.project,
-						SUM(CASE WHEN th1.state = 'passed' THEN 1 ELSE 0 END) as pass_count,
-						SUM(CASE WHEN th1.state = 'failed' THEN 1 ELSE 0 END) as fail_count,
-						(SELECT state FROM test_history th2
-						 WHERE th2.full_name = th1.full_name
-						   AND th2.module_path = th1.module_path
-						   AND th2.project = th1.project
-						 ORDER BY timestamp DESC LIMIT 1) as last_state,
-						MAX(th1.timestamp) as last_timestamp
-					FROM test_history th1
-					WHERE th1.project = ${project}
-						AND (${testName} IS NULL OR th1.full_name = ${testName})
-						AND (${modulePath} IS NULL OR th1.module_path = ${modulePath})
-					GROUP BY th1.full_name, th1.module_path, th1.project
-					-- Flaky means oscillation, not a clean recovery. A test with both
-						-- passes and fails is only flaky when at least one failure occurs at
-						-- or after the earliest pass (a fail-after-pass regression). A
-						-- monotonic red->green cycle — every failure precedes every pass — is
-						-- a recovery, not flakiness, so it is excluded here. ISO-8601
-						-- timestamps compare lexicographically. Grouping keys on module_path
-						-- so same-named tests in different files stay distinct series.
-						HAVING pass_count > 0 AND fail_count > 0
-							AND MAX(CASE WHEN th1.state = 'failed' THEN th1.timestamp END)
-								>= MIN(CASE WHEN th1.state = 'passed' THEN th1.timestamp END)`).map((r) => ({
-			fullName: r.full_name,
-			modulePath: r.module_path,
-			project: r.project,
-			passCount: r.pass_count,
-			failCount: r.fail_count,
-			lastState: r.last_state,
-			lastTimestamp: r.last_timestamp
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_history",
-		reason: extractSqlReason(e)
-	})));
-	const getPersistentFailures = (project, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getPersistentFailures").pipe(Effect.annotateLogs({
-			project,
-			...options
-		}));
-		const testName = options?.testName ?? null;
-		const modulePath = options?.modulePath ?? null;
-		return (yield* sql`WITH ranked AS (
-					SELECT full_name, module_path, project, state, timestamp, error_message,
-						ROW_NUMBER() OVER (
-							PARTITION BY project, module_path, full_name
-							ORDER BY timestamp DESC
-						) as rn
-					FROM test_history
-					WHERE project = ${project}
-						AND (${testName} IS NULL OR full_name = ${testName})
-						AND (${modulePath} IS NULL OR module_path = ${modulePath})
-				),
-				streak AS (
-					SELECT full_name, module_path, project, state, timestamp, error_message, rn,
-						MIN(CASE WHEN state != 'failed' THEN rn END) OVER (
-							PARTITION BY project, module_path, full_name
-						) as first_pass_rn
-					FROM ranked
-				)
-				SELECT
-					full_name, module_path, project,
-					COUNT(*) as consecutive_failures,
-					MIN(timestamp) as first_failed_at,
-					MAX(timestamp) as last_failed_at,
-					(SELECT error_message FROM streak s2
-					 WHERE s2.full_name = streak.full_name
-					   AND s2.module_path = streak.module_path
-					   AND s2.project = streak.project
-					   AND s2.rn = 1) as last_error_message
-				FROM streak
-				WHERE state = 'failed'
-					AND (first_pass_rn IS NULL OR rn < first_pass_rn)
-				GROUP BY full_name, module_path, project
-				HAVING consecutive_failures >= 2`).map((row) => ({
-			fullName: row.full_name,
-			modulePath: row.module_path,
-			project: row.project,
-			consecutiveFailures: row.consecutive_failures,
-			firstFailedAt: row.first_failed_at,
-			lastFailedAt: row.last_failed_at,
-			lastErrorMessage: row.last_error_message
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_history",
-		reason: extractSqlReason(e)
-	})));
-	const getFileCoverage = (runId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getFileCoverage").pipe(Effect.annotateLogs({ 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) => ({
-			file: r.file_path,
-			summary: {
-				statements: r.statements,
-				branches: r.branches,
-				functions: r.functions,
-				lines: r.lines
-			},
-			uncoveredLines: r.uncovered_lines ?? ""
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "file_coverage",
-		reason: extractSqlReason(e)
-	})));
-	const getCoverage = (project) => Effect.gen(function* () {
-		yield* Effect.logDebug("getCoverage").pipe(Effect.annotateLogs({ project }));
-		const runs = yield* sql`SELECT id, timestamp FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return Option.none();
-		const runId = 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}`;
-		const trendRows = yield* sql`SELECT statements, branches, functions, lines
-					FROM coverage_trends
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (fileCoverageRows.length === 0 && trendRows.length === 0) return Option.none();
-		let totals;
-		if (trendRows.length > 0) totals = {
-			statements: trendRows[0].statements,
-			branches: trendRows[0].branches,
-			functions: trendRows[0].functions,
-			lines: trendRows[0].lines
-		};
-		else {
-			const count = fileCoverageRows.length;
-			totals = {
-				statements: fileCoverageRows.reduce((sum, r) => sum + r.statements, 0) / count,
-				branches: fileCoverageRows.reduce((sum, r) => sum + r.branches, 0) / count,
-				functions: fileCoverageRows.reduce((sum, r) => sum + r.functions, 0) / count,
-				lines: fileCoverageRows.reduce((sum, r) => sum + r.lines, 0) / count
-			};
-		}
-		const thresholdsOpt = yield* getCoveragePolicy("threshold", "__global__");
-		const targetsOpt = yield* getCoveragePolicy("target", "__global__");
-		const baselinesOpt = yield* getCoveragePolicy("baseline", "__global__");
-		const thresholds = Option.getOrElse(thresholdsOpt, () => ({
-			updatedAt: "",
-			global: {},
-			patterns: []
-		}));
-		const baselines = Option.getOrElse(baselinesOpt, () => ({
-			updatedAt: "",
-			global: {},
-			patterns: []
-		}));
-		const toFileCoverageReport = (r) => ({
-			file: r.file_path,
-			summary: {
-				statements: r.statements,
-				branches: r.branches,
-				functions: r.functions,
-				lines: r.lines
-			},
-			uncoveredLines: r.uncovered_lines ?? ""
-		});
-		const lowCoverage = fileCoverageRows.filter((r) => r.tier === "below_threshold").map(toFileCoverageReport);
-		const belowTarget = fileCoverageRows.filter((r) => r.tier === "below_target").map(toFileCoverageReport);
-		const report = {
-			totals,
-			thresholds: {
-				global: thresholds.global,
-				patterns: thresholds.patterns
-			},
-			...Option.isSome(targetsOpt) ? { targets: {
-				global: targetsOpt.value.global,
-				patterns: targetsOpt.value.patterns
-			} } : {},
-			baselines: {
-				global: baselines.global,
-				patterns: baselines.patterns
-			},
-			scoped: false,
-			lowCoverage,
-			lowCoverageFiles: lowCoverage.map((f) => f.file),
-			...belowTarget.length > 0 ? {
-				belowTarget,
-				belowTargetFiles: belowTarget.map((f) => f.file)
-			} : {}
-		};
-		return Option.some(report);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "file_coverage",
-		reason: extractSqlReason(e)
-	})));
-	const getTestsForFile = (filePath) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTestsForFile").pipe(Effect.annotateLogs({ filePath }));
-		return (yield* sql`SELECT DISTINCT f.path
-					FROM source_test_map stm
-					JOIN files sf ON sf.id = stm.source_file_id
-					JOIN test_modules tm ON tm.id = stm.test_module_id
-					JOIN files f ON f.id = tm.file_id
-					WHERE sf.path = ${filePath}
-					ORDER BY f.path`).map((r) => r.path);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "source_test_map",
-		reason: extractSqlReason(e)
-	})));
-	const getErrors = (project, errorName) => Effect.gen(function* () {
-		yield* Effect.logDebug("getErrors").pipe(Effect.annotateLogs({
-			project,
-			errorName: errorName ?? null
-		}));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return [];
-		const runId = runs[0].id;
-		return (yield* errorName ? sql`SELECT te.id, sf.id AS top_stack_frame_id,
-							te.name, te.message, te.diff, te.actual, te.expected, te.stack, te.scope,
-							tc.full_name as test_full_name,
-							f.path as module_file
-						FROM test_errors te
-						LEFT JOIN test_cases tc ON tc.id = te.test_case_id
-						LEFT JOIN test_modules tm ON tm.id = COALESCE(te.module_id, tc.module_id)
-						LEFT JOIN files f ON f.id = tm.file_id
-						LEFT JOIN stack_frames sf ON sf.error_id = te.id AND sf.ordinal = 0
-						WHERE te.run_id = ${runId} AND te.name = ${errorName}` : sql`SELECT te.id, sf.id AS top_stack_frame_id,
-							te.name, te.message, te.diff, te.actual, te.expected, te.stack, te.scope,
-							tc.full_name as test_full_name,
-							f.path as module_file
-						FROM test_errors te
-						LEFT JOIN test_cases tc ON tc.id = te.test_case_id
-						LEFT JOIN test_modules tm ON tm.id = COALESCE(te.module_id, tc.module_id)
-						LEFT JOIN files f ON f.id = tm.file_id
-						LEFT JOIN stack_frames sf ON sf.error_id = te.id AND sf.ordinal = 0
-						WHERE te.run_id = ${runId}`).map((r) => ({
-			id: r.id,
-			topStackFrameId: r.top_stack_frame_id,
-			name: r.name,
-			message: r.message,
-			diff: r.diff,
-			actual: r.actual,
-			expected: r.expected,
-			stack: r.stack,
-			scope: r.scope,
-			testFullName: r.test_full_name,
-			moduleFile: r.module_file
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_errors",
-		reason: extractSqlReason(e)
-	})));
-	const latestRunId = (project) => Effect.gen(function* () {
-		const runs = yield* sql`SELECT id FROM test_runs WHERE project = ${project} ORDER BY timestamp DESC LIMIT 1`;
-		return runs.length === 0 ? null : runs[0].id;
-	});
-	const attachmentsFor = (column, ownerId) => Effect.gen(function* () {
-		return (column === "annotation_id" ? yield* sql`SELECT content_type, path, body, body_encoding, byte_size FROM attachments WHERE annotation_id = ${ownerId} ORDER BY id` : yield* sql`SELECT content_type, path, body, body_encoding, byte_size FROM attachments WHERE artifact_id = ${ownerId} ORDER BY id`).map((r) => ({
-			...r.content_type !== null && { contentType: r.content_type },
-			...r.path !== null && { path: r.path },
-			...r.body !== null && { body: r.body },
-			...r.body_encoding !== null && { bodyEncoding: r.body_encoding },
-			byteSize: r.byte_size
-		}));
-	});
-	const getAnnotationsForTest = (project, fullName, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getAnnotationsForTest").pipe(Effect.annotateLogs({
-			project,
-			fullName
-		}));
-		const runId = yield* latestRunId(project);
-		if (runId === null) return [];
-		const modulePath = options?.modulePath ?? null;
-		const rows = yield* sql`SELECT ta.id, ta.type, ta.message, ta.location_line, ta.location_column, f.path AS location_path
-					FROM test_annotations ta
-					JOIN test_cases tc ON tc.id = ta.test_case_id
-					JOIN test_modules tm ON tm.id = tc.module_id
-					LEFT JOIN files f ON f.id = ta.location_file_id
-					WHERE tm.run_id = ${runId} AND tc.full_name = ${fullName}
-						AND (${modulePath} IS NULL OR tm.relative_module_id = ${modulePath})
-					ORDER BY ta.id`;
-		const out = [];
-		for (const r of rows) {
-			const attachments = yield* attachmentsFor("annotation_id", r.id);
-			out.push({
-				id: r.id,
-				type: r.type,
-				message: r.message,
-				...r.location_path !== null && r.location_line !== null && r.location_column !== null && { location: {
-					file: r.location_path,
-					line: r.location_line,
-					column: r.location_column
-				} },
-				attachments
-			});
-		}
-		return out;
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_annotations",
-		reason: extractSqlReason(e)
-	})));
-	const getArtifactsForTest = (project, fullName, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getArtifactsForTest").pipe(Effect.annotateLogs({
-			project,
-			fullName
-		}));
-		const runId = yield* latestRunId(project);
-		if (runId === null) return [];
-		const modulePath = options?.modulePath ?? null;
-		const rows = yield* sql`SELECT ta.id, ta.type, ta.message, ta.data, ta.location_line, ta.location_column, f.path AS location_path
-					FROM test_artifacts ta
-					JOIN test_cases tc ON tc.id = ta.test_case_id
-					JOIN test_modules tm ON tm.id = tc.module_id
-					LEFT JOIN files f ON f.id = ta.location_file_id
-					WHERE tm.run_id = ${runId} AND tc.full_name = ${fullName}
-						AND (${modulePath} IS NULL OR tm.relative_module_id = ${modulePath})
-					ORDER BY ta.id`;
-		const out = [];
-		for (const r of rows) {
-			const attachments = yield* attachmentsFor("artifact_id", r.id);
-			out.push({
-				id: r.id,
-				type: r.type,
-				message: r.message,
-				data: r.data,
-				...r.location_path !== null && r.location_line !== null && r.location_column !== null && { location: {
-					file: r.location_path,
-					line: r.location_line,
-					column: r.location_column
-				} },
-				attachments
-			});
-		}
-		return out;
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_artifacts",
-		reason: extractSqlReason(e)
-	})));
-	const getNotes = (scope, project, testFullName) => Effect.gen(function* () {
-		yield* Effect.logDebug("getNotes").pipe(Effect.annotateLogs({
-			scope: scope ?? null,
-			project: project ?? null
-		}));
-		if (scope && project && testFullName) return (yield* sql`SELECT * FROM notes
-						WHERE scope = ${scope} AND project = ${project} AND test_full_name = ${testFullName}
-						ORDER BY created_at DESC`).map(mapNoteRow);
-		if (scope && project) return (yield* sql`SELECT * FROM notes
-						WHERE scope = ${scope} AND project = ${project}
-						ORDER BY created_at DESC`).map(mapNoteRow);
-		if (scope) return (yield* sql`SELECT * FROM notes
-						WHERE scope = ${scope}
-						ORDER BY created_at DESC`).map(mapNoteRow);
-		if (project) return (yield* sql`SELECT * FROM notes
-						WHERE project = ${project}
-						ORDER BY created_at DESC`).map(mapNoteRow);
-		return (yield* sql`SELECT * FROM notes ORDER BY created_at DESC`).map(mapNoteRow);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "notes",
-		reason: extractSqlReason(e)
-	})));
-	const getNoteById = (id) => Effect.gen(function* () {
-		yield* Effect.logDebug("getNoteById").pipe(Effect.annotateLogs({ id }));
-		const rows = yield* sql`SELECT * FROM notes WHERE id = ${id}`;
-		if (rows.length === 0) return Option.none();
-		return Option.some(mapNoteRow(rows[0]));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "notes",
-		reason: extractSqlReason(e)
-	})));
-	const searchNotes = (query) => Effect.gen(function* () {
-		yield* Effect.logDebug("searchNotes").pipe(Effect.annotateLogs({ query }));
-		return (yield* sql`SELECT n.*
-					FROM notes n
-					JOIN notes_fts ON n.id = notes_fts.rowid
-					WHERE notes_fts MATCH ${query}
-					ORDER BY rank`).map(mapNoteRow);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "notes",
-		reason: extractSqlReason(e)
-	})));
-	const getManifest = () => Effect.gen(function* () {
-		yield* Effect.logDebug("getManifest");
-		const rows = yield* sql`SELECT
-						t1.project,
-						t1.timestamp as last_run,
-						t1.reason as last_result
-					FROM test_runs t1
-					INNER JOIN (
-						SELECT project, MAX(timestamp) as max_ts
-						FROM test_runs
-						GROUP BY project
-					) t2 ON t1.project = t2.project
-						AND t1.timestamp = t2.max_ts`;
-		if (rows.length === 0) return Option.none();
-		const dbPath = (yield* sql`PRAGMA database_list`.pipe(Effect.catch(() => Effect.succeed([])))).find((d) => d.name === "main")?.file ?? "";
-		const projects = rows.map((r) => ({
-			project: r.project,
-			reportFile: dbPath,
-			historyFile: dbPath,
-			lastRun: r.last_run,
-			lastResult: r.last_result
-		}));
-		const manifest = {
-			updatedAt: rows.reduce((latest, r) => {
-				if (!r.last_run) return latest;
-				if (!latest) return r.last_run;
-				return r.last_run > latest ? r.last_run : latest;
-			}, null) ?? (/* @__PURE__ */ new Date()).toISOString(),
-			cacheDir: dbPath,
-			projects
-		};
-		return Option.some(manifest);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_runs",
-		reason: extractSqlReason(e)
-	})));
-	const getSettings = (hash) => Effect.gen(function* () {
-		yield* Effect.logDebug("getSettings").pipe(Effect.annotateLogs({ hash }));
-		const rows = yield* sql`SELECT hash, vitest_version, pool, environment, coverage_provider, created_at
-					FROM settings WHERE hash = ${hash}`;
-		if (rows.length === 0) return Option.none();
-		const row = rows[0];
-		const envRows = yield* sql`SELECT key, value FROM settings_env_vars WHERE settings_hash = ${hash}`;
-		const envVars = {};
-		for (const ev of envRows) envVars[ev.key] = ev.value;
-		const settings = {
-			hash: row.hash,
-			reporters: null,
-			coverageEnabled: row.coverage_provider != null,
-			coverageProvider: row.coverage_provider,
-			coverageThresholds: null,
-			coverageTargets: null,
-			pool: row.pool,
-			shard: null,
-			project: null,
-			environment: row.environment,
-			envVars,
-			capturedAt: row.created_at
-		};
-		return Option.some(settings);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "settings",
-		reason: extractSqlReason(e)
-	})));
-	const getLatestSettings = () => Effect.gen(function* () {
-		yield* Effect.logDebug("getLatestSettings");
-		const rows = yield* sql`SELECT hash, pool, environment, coverage_provider, created_at
-					FROM settings ORDER BY rowid DESC LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		const row = rows[0];
-		const envRows = yield* sql`SELECT key, value FROM settings_env_vars WHERE settings_hash = ${row.hash}`;
-		const envVars = {};
-		for (const ev of envRows) envVars[ev.key] = ev.value;
-		const settings = {
-			hash: row.hash,
-			reporters: null,
-			coverageEnabled: row.coverage_provider != null,
-			coverageProvider: row.coverage_provider,
-			coverageThresholds: null,
-			coverageTargets: null,
-			pool: row.pool,
-			shard: null,
-			project: null,
-			environment: row.environment,
-			envVars,
-			capturedAt: row.created_at
-		};
-		return Option.some(settings);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "settings",
-		reason: extractSqlReason(e)
-	})));
-	const getTestByFullName = (project, fullName, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTestByFullName").pipe(Effect.annotateLogs({
-			project,
-			fullName,
-			...options
-		}));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return Option.none();
-		const runId = runs[0].id;
-		const modulePath = options?.modulePath ?? null;
-		const rows = yield* sql`SELECT tc.id, tc.full_name, tc.state, tc.duration, f.path as relative_module_id, tc.classification
-					FROM test_cases tc
-					JOIN test_modules tm ON tm.id = tc.module_id
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${runId} AND tc.full_name = ${fullName}
-						AND (${modulePath} IS NULL OR f.path = ${modulePath})
-					ORDER BY f.path ASC, tc.id ASC
-					LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		const r = rows[0];
-		return Option.some({
-			id: r.id,
-			fullName: r.full_name,
-			state: r.state,
-			duration: r.duration,
-			module: r.relative_module_id,
-			classification: r.classification
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_cases",
-		reason: extractSqlReason(e)
-	})));
-	const getTestModulesByFullName = (project, fullName) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTestModulesByFullName").pipe(Effect.annotateLogs({
-			project,
-			fullName
-		}));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return [];
-		const runId = runs[0].id;
-		return (yield* sql`SELECT DISTINCT f.path as relative_module_id
-					FROM test_cases tc
-					JOIN test_modules tm ON tm.id = tc.module_id
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${runId} AND tc.full_name = ${fullName}
-					ORDER BY f.path ASC`).map((r) => r.relative_module_id);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_cases",
-		reason: extractSqlReason(e)
-	})));
-	const listTests = (project, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listTests").pipe(Effect.annotateLogs({ project }));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return [];
-		const runId = runs[0].id;
-		const effectiveLimit = Math.min(options?.limit ?? 100, 500);
-		const state = options?.state;
-		const mod = options?.module;
-		if (state && mod) return (yield* sql`SELECT tc.id, tc.full_name as "full_name", tc.state, tc.duration, f.path as file_path, tc.classification
-						FROM test_cases tc
-						JOIN test_modules tm ON tm.id = tc.module_id
-						JOIN files f ON f.id = tm.file_id
-						WHERE tm.run_id = ${runId} AND tc.state = ${state} AND f.path = ${mod}
-						ORDER BY tc.full_name
-						LIMIT ${effectiveLimit}`).map(mapTestListRow);
-		if (state) return (yield* sql`SELECT tc.id, tc.full_name as "full_name", tc.state, tc.duration, f.path as file_path, tc.classification
-						FROM test_cases tc
-						JOIN test_modules tm ON tm.id = tc.module_id
-						JOIN files f ON f.id = tm.file_id
-						WHERE tm.run_id = ${runId} AND tc.state = ${state}
-						ORDER BY tc.full_name
-						LIMIT ${effectiveLimit}`).map(mapTestListRow);
-		if (mod) return (yield* sql`SELECT tc.id, tc.full_name as "full_name", tc.state, tc.duration, f.path as file_path, tc.classification
-						FROM test_cases tc
-						JOIN test_modules tm ON tm.id = tc.module_id
-						JOIN files f ON f.id = tm.file_id
-						WHERE tm.run_id = ${runId} AND f.path = ${mod}
-						ORDER BY tc.full_name
-						LIMIT ${effectiveLimit}`).map(mapTestListRow);
-		return (yield* sql`SELECT tc.id, tc.full_name as "full_name", tc.state, tc.duration, f.path as file_path, tc.classification
-					FROM test_cases tc
-					JOIN test_modules tm ON tm.id = tc.module_id
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${runId}
-					ORDER BY tc.full_name
-					LIMIT ${effectiveLimit}`).map(mapTestListRow);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_cases",
-		reason: extractSqlReason(e)
-	})));
-	const listModules = (project) => Effect.gen(function* () {
-		yield* Effect.logDebug("listModules").pipe(Effect.annotateLogs({ project }));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return [];
-		const runId = runs[0].id;
-		return (yield* sql`SELECT tm.id, f.path as file_path, tm.state,
-						(SELECT COUNT(*) FROM test_cases tc WHERE tc.module_id = tm.id) as test_count,
-						tm.duration
-					FROM test_modules tm
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${runId}
-					ORDER BY f.path`).map((r) => ({
-			id: r.id,
-			file: r.file_path,
-			state: r.state,
-			testCount: r.test_count,
-			duration: r.duration
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_modules",
-		reason: extractSqlReason(e)
-	})));
-	const listSuites = (project, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listSuites").pipe(Effect.annotateLogs({ project }));
-		const runs = yield* sql`SELECT id FROM test_runs
-					WHERE project = ${project}
-					ORDER BY timestamp DESC LIMIT 1`;
-		if (runs.length === 0) return [];
-		const runId = runs[0].id;
-		const mod = options?.module;
-		if (mod) return (yield* sql`SELECT ts.id, ts.name, f.path as file_path, ts.state,
-							(SELECT COUNT(*) FROM test_cases tc WHERE tc.suite_id = ts.id) as test_count
-						FROM test_suites ts
-						JOIN test_modules tm ON tm.id = ts.module_id
-						JOIN files f ON f.id = tm.file_id
-						WHERE tm.run_id = ${runId} AND f.path = ${mod}
-						ORDER BY ts.name`).map((r) => ({
-			id: r.id,
-			name: r.name,
-			module: r.file_path,
-			state: r.state,
-			testCount: r.test_count
-		}));
-		return (yield* sql`SELECT ts.id, ts.name, f.path as file_path, ts.state,
-						(SELECT COUNT(*) FROM test_cases tc WHERE tc.suite_id = ts.id) as test_count
-					FROM test_suites ts
-					JOIN test_modules tm ON tm.id = ts.module_id
-					JOIN files f ON f.id = tm.file_id
-					WHERE tm.run_id = ${runId}
-					ORDER BY ts.name`).map((r) => ({
-			id: r.id,
-			name: r.name,
-			module: r.file_path,
-			state: r.state,
-			testCount: r.test_count
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_suites",
-		reason: extractSqlReason(e)
-	})));
-	const listSettings = () => Effect.gen(function* () {
-		yield* Effect.logDebug("listSettings");
-		return (yield* sql`SELECT hash, created_at FROM settings ORDER BY rowid DESC`).map((r) => ({
-			hash: r.hash,
-			capturedAt: r.created_at
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "settings",
-		reason: extractSqlReason(e)
-	})));
-	const sessionRowToDetail = (r) => ({
-		id: r.id,
-		chatId: r.chat_id,
-		project: r.project,
-		cwd: r.cwd,
-		agentKind: r.agent_kind,
-		agentType: r.agent_type,
-		parentSessionId: r.parent_session_id,
-		triageWasNonEmpty: r.triage_was_non_empty === 1,
-		startedAt: r.started_at,
-		endedAt: r.ended_at,
-		endReason: r.end_reason,
-		conversationId: r.conversation_id
-	});
-	const getSessionById = (id) => Effect.gen(function* () {
-		yield* Effect.logDebug("getSessionById").pipe(Effect.annotateLogs({ id }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE id = ${id} LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		return Option.some(sessionRowToDetail(rows[0]));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const getSessionByChatId = (chatId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getSessionByChatId").pipe(Effect.annotateLogs({ chatId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE chat_id = ${chatId} LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		return Option.some(sessionRowToDetail(rows[0]));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const findSessionsByChatPrefix = (prefix) => Effect.gen(function* () {
-		yield* Effect.logDebug("findSessionsByChatPrefix").pipe(Effect.annotateLogs({ prefix }));
-		const pattern = `${prefix}%`;
-		return (yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE chat_id LIKE ${pattern} ESCAPE '\\' ORDER BY started_at DESC`).map(sessionRowToDetail);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const findActiveSubagentSession = (parentSessionId) => Effect.gen(function* () {
-		yield* Effect.logDebug("findActiveSubagentSession").pipe(Effect.annotateLogs({ parentSessionId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE parent_session_id = ${parentSessionId} AND agent_kind = 'subagent' AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		return Option.some(sessionRowToDetail(rows[0]));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const getSessionByTddTaskId = (tddTaskId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getSessionByTddTaskId").pipe(Effect.annotateLogs({ tddTaskId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE id = (SELECT session_id FROM tdd_tasks WHERE id = ${tddTaskId}) LIMIT 1`;
-		if (rows.length === 0) return Option.none();
-		return Option.some(sessionRowToDetail(rows[0]));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const searchTurns = (options) => Effect.gen(function* () {
-		yield* Effect.logDebug("searchTurns").pipe(Effect.annotateLogs({ ...options }));
-		const limit = options.limit ?? 100;
-		const sessionFilter = options.sessionId !== void 0 ? sql` AND session_id = ${options.sessionId}` : sql``;
-		const typeFilter = options.type !== void 0 ? sql` AND type = ${options.type}` : sql``;
-		const sinceFilter = options.since !== void 0 ? sql` AND occurred_at >= ${options.since}` : sql``;
-		return (yield* sql`SELECT id, session_id, turn_no, type, payload, occurred_at FROM turns WHERE 1=1${sessionFilter}${typeFilter}${sinceFilter} ORDER BY occurred_at DESC, turn_no DESC LIMIT ${limit}`).map((r) => ({
-			id: r.id,
-			sessionId: r.session_id,
-			turnNo: r.turn_no,
-			type: r.type,
-			payload: r.payload,
-			occurredAt: r.occurred_at
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "turns",
-		reason: extractSqlReason(e)
-	})));
-	const computeAcceptanceMetrics = () => Effect.gen(function* () {
-		yield* Effect.logDebug("computeAcceptanceMetrics");
-		const m1 = yield* sql`
-					WITH task_orderings AS (
-						SELECT
-							p.tdd_task_id,
-							MIN(CASE WHEN a.artifact_kind = 'test_failed_run' THEN a.id END) AS first_failed_run,
-							MIN(CASE WHEN a.artifact_kind = 'code_written'    THEN a.id END) AS first_code_written
-						FROM tdd_artifacts a
-						JOIN tdd_phases p ON a.phase_id = p.id
-						WHERE a.artifact_kind IN ('test_failed_run', 'code_written')
-						GROUP BY p.tdd_task_id
-					)
-					SELECT
-						COUNT(*) AS total,
-						COALESCE(SUM(CASE WHEN first_failed_run < first_code_written THEN 1 ELSE 0 END), 0) AS compliant
-					FROM task_orderings
-					WHERE first_code_written IS NOT NULL
-				`;
-		const m2 = yield* sql`
-					WITH wrap_up_fires AS (
-						SELECT t.session_id
-						FROM turns t
-						WHERE t.type = 'hook_fire'
-							AND json_extract(t.payload, '$.hook_kind') IN ('SessionEnd', 'PreCompact', 'Stop')
-					),
-					followups AS (
-						SELECT DISTINCT t.session_id
-						FROM turns t
-						JOIN tool_invocations ti ON ti.turn_id = t.id
-						WHERE ti.tool_name IN ('note', 'hypothesis', 'tdd_task', 'note_create', 'hypothesis_validate', 'tdd_session_end')
-					)
-					SELECT
-						(SELECT COUNT(DISTINCT session_id) FROM wrap_up_fires) AS total,
-						(SELECT COUNT(DISTINCT wf.session_id)
-							FROM wrap_up_fires wf JOIN followups f ON f.session_id = wf.session_id) AS with_followup
-				`;
-		const m3 = yield* sql`
-					WITH triaged_sessions AS (
-						SELECT id AS session_id FROM sessions WHERE triage_was_non_empty = 1
-					),
-					ranked_tool_results AS (
-						SELECT session_id, id AS turn_id,
-							ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY turn_no) AS result_no
-						FROM turns
-						WHERE type = 'tool_result'
-					),
-					first_three_tool_calls AS (
-						SELECT r.session_id, ti.tool_name
-						FROM ranked_tool_results r
-						JOIN tool_invocations ti ON ti.turn_id = r.turn_id
-						WHERE r.result_no <= 3
-					),
-					referenced AS (
-						SELECT DISTINCT ts.session_id
-						FROM triaged_sessions ts
-						JOIN first_three_tool_calls ftc ON ftc.session_id = ts.session_id
-						WHERE ftc.tool_name IN ('tdd_session_resume', 'run_tests', 'test_history',
-							'failure_signature_get', 'tdd_session_start')
-					)
-					SELECT
-						(SELECT COUNT(*) FROM triaged_sessions) AS total,
-						(SELECT COUNT(*) FROM referenced) AS referenced_count
-				`;
-		const m4 = yield* sql`
-					SELECT
-						COUNT(*) AS total,
-						COALESCE(SUM(CASE WHEN weakened_count = 0 THEN 1 ELSE 0 END), 0) AS clean_sessions
-					FROM (
-						SELECT ts.id AS tdd_task_id,
-							COUNT(a.id) AS weakened_count
-						FROM tdd_tasks ts
-						LEFT JOIN tdd_phases p ON p.tdd_task_id = ts.id
-						LEFT JOIN tdd_artifacts a ON a.phase_id = p.id AND a.artifact_kind = 'test_weakened'
-						WHERE ts.ended_at IS NOT NULL
-						GROUP BY ts.id
-					) tasks_with_counts
-				`;
-		const ratio = (n, d) => d === 0 ? 0 : n / d;
-		return {
-			phaseEvidenceIntegrity: {
-				total: m1[0].total,
-				compliant: m1[0].compliant,
-				ratio: ratio(m1[0].compliant, m1[0].total)
-			},
-			complianceHookResponsiveness: {
-				total: m2[0].total,
-				withFollowup: m2[0].with_followup,
-				ratio: ratio(m2[0].with_followup, m2[0].total)
-			},
-			orientationUsefulness: {
-				total: m3[0].total,
-				referencedCount: m3[0].referenced_count,
-				ratio: ratio(m3[0].referenced_count, m3[0].total)
-			},
-			antiPatternDetectionRate: {
-				total: m4[0].total,
-				cleanSessions: m4[0].clean_sessions,
-				ratio: ratio(m4[0].clean_sessions, m4[0].total)
-			}
-		};
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_tasks",
-		reason: extractSqlReason(e)
-	})));
-	const listSessions = (options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listSessions").pipe(Effect.annotateLogs({ ...options }));
-		const limit = options.limit ?? 50;
-		const project = options.project ?? null;
-		const agentKind = options.agentKind ?? null;
-		return (yield* sql`
-					SELECT id, chat_id, project, cwd, agent_kind, agent_type,
-						parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id
-					FROM sessions
-					WHERE (${project} IS NULL OR project = ${project})
-						AND (${agentKind} IS NULL OR agent_kind = ${agentKind})
-					ORDER BY started_at DESC
-					LIMIT ${limit}
-				`).map(sessionRowToDetail);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "sessions",
-		reason: extractSqlReason(e)
-	})));
-	const getFailureSignatureByHash = (hash) => Effect.gen(function* () {
-		yield* Effect.logDebug("getFailureSignatureByHash").pipe(Effect.annotateLogs({ hash }));
-		const sigRows = yield* sql`
-					SELECT signature_hash, first_seen_run_id, first_seen_at, last_seen_at, occurrence_count
-					FROM failure_signatures WHERE signature_hash = ${hash} LIMIT 1
-				`;
-		if (sigRows.length === 0) return Option.none();
-		const errRows = yield* sql`
-					SELECT run_id, message, name FROM test_errors
-					WHERE signature_hash = ${hash}
-					ORDER BY run_id DESC
-					LIMIT 10
-				`;
-		const sig = sigRows[0];
-		return Option.some({
-			signatureHash: sig.signature_hash,
-			firstSeenRunId: sig.first_seen_run_id,
-			firstSeenAt: sig.first_seen_at,
-			lastSeenAt: sig.last_seen_at,
-			occurrenceCount: sig.occurrence_count,
-			recentErrors: errRows.map((e) => ({
-				runId: e.run_id,
-				message: e.message,
-				errorName: e.name
-			}))
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "failure_signatures",
-		reason: extractSqlReason(e)
-	})));
-	const goalRowFromDb = (row) => ({
-		id: row.id,
-		sessionId: row.session_id,
-		ordinal: row.ordinal,
-		goal: row.goal,
-		status: row.status,
-		createdAt: row.created_at
-	});
-	const behaviorRowFromDb = (row) => ({
-		id: row.id,
-		goalId: row.goal_id,
-		ordinal: row.ordinal,
-		behavior: row.behavior,
-		suggestedTestName: row.suggested_test_name,
-		status: row.status,
-		createdAt: row.created_at
-	});
-	const fetchGoalsWithBehaviors = (sessionId) => Effect.gen(function* () {
-		const goals = yield* sql`
-					SELECT id, session_id, ordinal, goal, status, created_at
-					FROM tdd_session_goals
-					WHERE session_id = ${sessionId}
-					ORDER BY ordinal
-				`;
-		if (goals.length === 0) return [];
-		const goalIds = goals.map((g) => g.id);
-		const behaviors = yield* sql`
-					SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
-					FROM tdd_session_behaviors
-					WHERE goal_id IN ${sql.in(goalIds)}
-					ORDER BY goal_id, ordinal
-				`;
-		const byGoal = /* @__PURE__ */ new Map();
-		for (const id of goalIds) byGoal.set(id, []);
-		for (const b of behaviors) {
-			const list = byGoal.get(b.goal_id);
-			if (list) list.push(behaviorRowFromDb(b));
-		}
-		return goals.map((g) => ({
-			...goalRowFromDb(g),
-			behaviors: byGoal.get(g.id) ?? []
-		}));
-	});
-	const getGoalById = (id) => Effect.gen(function* () {
-		const goalRows = yield* sql`
-					SELECT id, session_id, ordinal, goal, status, created_at
-					FROM tdd_session_goals
-					WHERE id = ${id}
-				`;
-		if (goalRows.length === 0) return Option.none();
-		const beh = yield* sql`
-					SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
-					FROM tdd_session_behaviors
-					WHERE goal_id = ${id}
-					ORDER BY ordinal
-				`;
-		return Option.some({
-			...goalRowFromDb(goalRows[0]),
-			behaviors: beh.map(behaviorRowFromDb)
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_goals",
-		reason: extractSqlReason(e)
-	})));
-	const getGoalsByTddTask = (tddTaskId) => fetchGoalsWithBehaviors(tddTaskId).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_goals",
-		reason: extractSqlReason(e)
-	})));
-	const getBehaviorById = (id) => Effect.gen(function* () {
-		const rows = yield* sql`
-					SELECT b.id AS b_id, b.goal_id AS b_goal_id, b.ordinal AS b_ordinal, b.behavior AS b_behavior,
-					       b.suggested_test_name AS b_suggested_test_name, b.status AS b_status,
-					       b.created_at AS b_created_at,
-					       g.id AS g_id, g.goal AS g_goal, g.status AS g_status
-					FROM tdd_session_behaviors b
-					JOIN tdd_session_goals g ON g.id = b.goal_id
-					WHERE b.id = ${id}
-				`;
-		if (rows.length === 0) return Option.none();
-		const r = rows[0];
-		const deps = yield* sql`
-					SELECT b.id, b.goal_id, b.ordinal, b.behavior, b.suggested_test_name, b.status, b.created_at
-					FROM tdd_behavior_dependencies d
-					JOIN tdd_session_behaviors b ON b.id = d.depends_on_id
-					WHERE d.behavior_id = ${id}
-					ORDER BY b.ordinal
-				`;
-		return Option.some({
-			id: r.b_id,
-			goalId: r.b_goal_id,
-			ordinal: r.b_ordinal,
-			behavior: r.b_behavior,
-			suggestedTestName: r.b_suggested_test_name,
-			status: r.b_status,
-			createdAt: r.b_created_at,
-			parentGoal: {
-				id: r.g_id,
-				goal: r.g_goal,
-				status: r.g_status
-			},
-			dependencies: deps.map(behaviorRowFromDb)
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_behaviors",
-		reason: extractSqlReason(e)
-	})));
-	const getBehaviorsByGoal = (goalId) => Effect.gen(function* () {
-		return (yield* sql`
-					SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
-					FROM tdd_session_behaviors
-					WHERE goal_id = ${goalId}
-					ORDER BY ordinal
-				`).map(behaviorRowFromDb);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_behaviors",
-		reason: extractSqlReason(e)
-	})));
-	const getBehaviorsByTddTask = (tddTaskId) => Effect.gen(function* () {
-		return (yield* sql`
-					SELECT b.id, b.goal_id, b.ordinal, b.behavior, b.suggested_test_name, b.status, b.created_at
-					FROM tdd_session_behaviors b
-					JOIN tdd_session_goals g ON g.id = b.goal_id
-					WHERE g.session_id = ${tddTaskId}
-					ORDER BY g.ordinal, b.ordinal
-				`).map(behaviorRowFromDb);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_behaviors",
-		reason: extractSqlReason(e)
-	})));
-	const getBehaviorDependencies = (behaviorId) => Effect.gen(function* () {
-		return (yield* sql`
-					SELECT b.id, b.goal_id, b.ordinal, b.behavior, b.suggested_test_name, b.status, b.created_at
-					FROM tdd_behavior_dependencies d
-					JOIN tdd_session_behaviors b ON b.id = d.depends_on_id
-					WHERE d.behavior_id = ${behaviorId}
-					ORDER BY b.ordinal
-				`).map(behaviorRowFromDb);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_behavior_dependencies",
-		reason: extractSqlReason(e)
-	})));
-	const resolveGoalIdForBehavior = (behaviorId) => Effect.gen(function* () {
-		const rows = yield* sql`
-					SELECT goal_id FROM tdd_session_behaviors WHERE id = ${behaviorId}
-				`;
-		return rows.length === 0 ? Option.none() : Option.some(rows[0].goal_id);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_session_behaviors",
-		reason: extractSqlReason(e)
-	})));
-	const getTddTaskById = (id) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTddTaskById").pipe(Effect.annotateLogs({ id }));
-		const taskRows = yield* sql`
-					SELECT id, session_id, goal, started_at, ended_at, outcome, run_id
-					FROM tdd_tasks WHERE id = ${id} LIMIT 1
-				`;
-		if (taskRows.length === 0) return Option.none();
-		const tddTask = taskRows[0];
-		const goals = yield* fetchGoalsWithBehaviors(id);
-		const phaseRows = yield* sql`
-					SELECT id, behavior_id, phase, started_at, ended_at, transition_reason
-					FROM tdd_phases WHERE tdd_task_id = ${id}
-					ORDER BY started_at ASC
-				`;
-		const artifactRows = yield* sql`
-					SELECT a.id, a.phase_id, a.artifact_kind, a.test_case_id, a.test_run_id, a.recorded_at
-					FROM tdd_artifacts a
-					JOIN tdd_phases p ON a.phase_id = p.id
-					WHERE p.tdd_task_id = ${id}
-					ORDER BY a.recorded_at ASC
-				`;
-		return Option.some({
-			id: tddTask.id,
-			sessionId: tddTask.session_id,
-			goal: tddTask.goal,
-			startedAt: tddTask.started_at,
-			endedAt: tddTask.ended_at,
-			outcome: tddTask.outcome,
-			runId: tddTask.run_id,
-			goals,
-			phases: phaseRows.map((p) => ({
-				id: p.id,
-				behaviorId: p.behavior_id,
-				phase: p.phase,
-				startedAt: p.started_at,
-				endedAt: p.ended_at,
-				transitionReason: p.transition_reason
-			})),
-			artifacts: artifactRows.map((a) => ({
-				id: a.id,
-				phaseId: a.phase_id,
-				artifactKind: a.artifact_kind,
-				testCaseId: a.test_case_id,
-				testRunId: a.test_run_id,
-				recordedAt: a.recorded_at
-			}))
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_tasks",
-		reason: extractSqlReason(e)
-	})));
-	const getCurrentTddPhase = (tddTaskId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getCurrentTddPhase").pipe(Effect.annotateLogs({ tddTaskId }));
-		const rows = yield* sql`
-					SELECT id, phase, started_at, behavior_id FROM tdd_phases
-					WHERE tdd_task_id = ${tddTaskId} AND ended_at IS NULL
-					ORDER BY started_at DESC LIMIT 1
-				`;
-		if (rows.length === 0) return Option.none();
-		return Option.some({
-			id: rows[0].id,
-			phase: rows[0].phase,
-			startedAt: rows[0].started_at,
-			behaviorId: rows[0].behavior_id
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_phases",
-		reason: extractSqlReason(e)
-	})));
-	const getTddArtifactWithContext = (artifactId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getTddArtifactWithContext").pipe(Effect.annotateLogs({ artifactId }));
-		const rows = yield* sql`
-					SELECT
-						a.id,
-						a.phase_id,
-						a.artifact_kind,
-						a.test_case_id,
-						ttc.occurred_at AS test_case_created_turn_at,
-						CASE
-							WHEN ttc.session_id = sess.id THEN 1
-							ELSE 0
-						END AS test_case_authored_in_session,
-						a.test_run_id,
-						a.test_first_failure_run_id,
-						p.behavior_id,
-						a.suite
-					FROM tdd_artifacts a
-					JOIN tdd_phases p ON p.id = a.phase_id
-					JOIN tdd_tasks ts ON ts.id = p.tdd_task_id
-					JOIN sessions sess ON sess.id = ts.session_id
-					LEFT JOIN test_cases tc ON tc.id = a.test_case_id
-					LEFT JOIN turns ttc ON ttc.id = tc.created_turn_id
-					WHERE a.id = ${artifactId}
-				`;
-		if (rows.length === 0) return Option.none();
-		const r = rows[0];
-		return Option.some({
-			id: r.id,
-			phase_id: r.phase_id,
-			artifact_kind: r.artifact_kind,
-			test_case_id: r.test_case_id,
-			test_case_created_turn_at: r.test_case_created_turn_at,
-			test_case_authored_in_session: r.test_case_authored_in_session === 1,
-			test_run_id: r.test_run_id,
-			test_first_failure_run_id: r.test_first_failure_run_id,
-			behavior_id: r.behavior_id,
-			suite: r.suite
-		});
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_artifacts",
-		reason: extractSqlReason(e)
-	})));
-	const getCommitChanges = (sha) => Effect.gen(function* () {
-		yield* Effect.logDebug("getCommitChanges").pipe(Effect.annotateLogs({ sha: sha ?? "ALL" }));
-		const commitRows = sha !== void 0 ? yield* sql`SELECT sha, parent_sha, message, author, committed_at, branch FROM commits WHERE sha = ${sha}` : yield* sql`
-							SELECT sha, parent_sha, message, author, committed_at, branch FROM commits
-							ORDER BY committed_at DESC NULLS LAST LIMIT 20
-						`;
-		const out = [];
-		for (const c of commitRows) {
-			const fileRows = yield* sql`
-						SELECT f.path, rcf.change_kind
-						FROM run_changed_files rcf
-						JOIN files f ON f.id = rcf.file_id
-						WHERE rcf.commit_sha = ${c.sha}
-					`;
-			out.push({
-				sha: c.sha,
-				parentSha: c.parent_sha,
-				message: c.message,
-				author: c.author,
-				committedAt: c.committed_at,
-				branch: c.branch,
-				files: fileRows.map((r) => ({
-					filePath: r.path,
-					changeKind: r.change_kind
-				}))
-			});
-		}
-		return out;
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "commits",
-		reason: extractSqlReason(e)
-	})));
-	const listTddTasksForSession = (sessionId, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listTddTasksForSession").pipe(Effect.annotateLogs({
-			sessionId,
-			walkParents: options?.walkParents ?? false,
-			walkConversation: options?.walkConversation ?? false
-		}));
-		const sessionIds = [sessionId];
-		if (options?.walkParents === true) {
-			let currentId = sessionId;
-			for (let i = 0; i < 64 && currentId !== null; i++) {
-				const next = (yield* sql`
-								SELECT parent_session_id FROM sessions WHERE id = ${currentId} LIMIT 1
-							`)[0]?.parent_session_id ?? null;
-				if (next === null || sessionIds.includes(next)) break;
-				sessionIds.push(next);
-				currentId = next;
-			}
-		}
-		if (options?.walkConversation === true) {
-			const conversationId = (yield* sql`
-							SELECT conversation_id FROM sessions WHERE id = ${sessionId} LIMIT 1
-						`)[0]?.conversation_id ?? null;
-			if (conversationId !== null) {
-				const conversationSessionRows = yield* sql`
-								SELECT id FROM sessions WHERE conversation_id = ${conversationId}
-							`;
-				for (const row of conversationSessionRows) if (!sessionIds.includes(row.id)) sessionIds.push(row.id);
-			}
-		}
-		return (yield* sql`
-					SELECT t.id, t.session_id, t.goal, t.started_at, t.ended_at, t.outcome, s.agent_kind
-					FROM tdd_tasks t
-					JOIN sessions s ON s.id = t.session_id
-					WHERE t.session_id IN ${sql.in(sessionIds)}
-					ORDER BY (CASE WHEN s.agent_kind = 'main' THEN 0 ELSE 1 END), t.started_at DESC
-				`).map((r) => ({
-			id: r.id,
-			sessionId: r.session_id,
-			goal: r.goal,
-			startedAt: r.started_at,
-			endedAt: r.ended_at,
-			outcome: r.outcome
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_tasks",
-		reason: extractSqlReason(e)
-	})));
-	const countRecentArtifactsInOtherSessionsOfConversation = (input) => Effect.gen(function* () {
-		yield* Effect.logDebug("countRecentArtifactsInOtherSessionsOfConversation").pipe(Effect.annotateLogs(input));
-		const owner = (yield* sql`
-						SELECT t.session_id, s.conversation_id
-						FROM tdd_tasks t
-						JOIN sessions s ON s.id = t.session_id
-						WHERE t.id = ${input.tddTaskId}
-						LIMIT 1
-					`)[0];
-		if (owner === void 0 || owner.conversation_id === null) return 0;
-		return (yield* sql`
-						SELECT COUNT(*) AS n
-						FROM tdd_artifacts a
-						JOIN tdd_phases p ON p.id = a.phase_id
-						JOIN tdd_tasks t ON t.id = p.tdd_task_id
-						JOIN sessions s ON s.id = t.session_id
-						WHERE s.conversation_id = ${owner.conversation_id}
-							AND s.id != ${owner.session_id}
-							AND a.recorded_at >= ${input.sinceIso}
-					`)[0]?.n ?? 0;
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_artifacts",
-		reason: extractSqlReason(e)
-	})));
-	const listTddArtifactsForTask = (input) => Effect.gen(function* () {
-		yield* Effect.logDebug("listTddArtifactsForTask").pipe(Effect.annotateLogs(input));
-		const limit = input.limit ?? 50;
-		return (yield* sql`
-					SELECT
-						a.id,
-						p.tdd_task_id AS tdd_task_id,
-						a.phase_id,
-						p.phase AS phase_name,
-						a.artifact_kind,
-						p.behavior_id,
-						a.test_case_id,
-						a.test_run_id,
-						a.test_first_failure_run_id,
-						a.recorded_at,
-						a.suite
-					FROM tdd_artifacts a
-					JOIN tdd_phases p ON p.id = a.phase_id
-					WHERE p.tdd_task_id = ${input.tddTaskId}
-						AND (${input.artifactKind ?? null} IS NULL OR a.artifact_kind = ${input.artifactKind ?? null})
-						AND (${input.phaseId ?? null} IS NULL OR a.phase_id = ${input.phaseId ?? null})
-						AND (${input.behaviorId ?? null} IS NULL OR p.behavior_id = ${input.behaviorId ?? null})
-					ORDER BY a.recorded_at DESC, a.id DESC
-					LIMIT ${limit}
-				`).map((r) => ({
-			id: r.id,
-			tddTaskId: r.tdd_task_id,
-			phaseId: r.phase_id,
-			phaseName: r.phase_name,
-			artifactKind: r.artifact_kind,
-			behaviorId: r.behavior_id,
-			testCaseId: r.test_case_id,
-			testRunId: r.test_run_id,
-			testFirstFailureRunId: r.test_first_failure_run_id,
-			recordedAt: r.recorded_at,
-			suite: r.suite
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tdd_artifacts",
-		reason: extractSqlReason(e)
-	})));
-	const listHypotheses = (options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listHypotheses").pipe(Effect.annotateLogs({ ...options }));
-		const limit = options.limit ?? 50;
-		const sessionId = options.sessionId ?? null;
-		const outcome = options.outcome ?? null;
-		return (yield* sql`
-					SELECT id, session_id, content, cited_test_error_id, cited_stack_frame_id,
-						validation_outcome, validated_at
-					FROM hypotheses
-					WHERE (${sessionId} IS NULL OR session_id = ${sessionId})
-						AND (
-							${outcome} IS NULL
-							OR (${outcome} = 'open' AND validation_outcome IS NULL)
-							OR (${outcome} != 'open' AND validation_outcome = ${outcome})
-						)
-					ORDER BY id DESC
-					LIMIT ${limit}
-				`).map((r) => ({
-			id: r.id,
-			sessionId: r.session_id,
-			content: r.content,
-			citedTestErrorId: r.cited_test_error_id,
-			citedStackFrameId: r.cited_stack_frame_id,
-			validationOutcome: r.validation_outcome,
-			validatedAt: r.validated_at
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "hypotheses",
-		reason: extractSqlReason(e)
-	})));
-	const findIdempotentResponse = (procedurePath, key) => Effect.gen(function* () {
-		yield* Effect.logDebug("findIdempotentResponse").pipe(Effect.annotateLogs({
-			procedurePath,
-			key
-		}));
-		const rows = yield* sql`
-					SELECT result_json FROM mcp_idempotent_responses
-					WHERE procedure_path = ${procedurePath} AND key = ${key}
-					LIMIT 1
-				`;
-		return rows.length === 0 ? Option.none() : Option.some(rows[0].result_json);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "mcp_idempotent_responses",
-		reason: extractSqlReason(e)
-	})));
-	const getLatestTestCaseForSession = (chatId) => Effect.gen(function* () {
-		yield* Effect.logDebug("getLatestTestCaseForSession").pipe(Effect.annotateLogs({ chatId }));
-		const rows = yield* sql`
-					SELECT tc.id
-					FROM test_cases tc
-					JOIN test_modules tm ON tc.module_id = tm.id
-					JOIN files f_mod ON f_mod.id = tm.file_id
-					WHERE tm.run_id = (SELECT id FROM test_runs ORDER BY id DESC LIMIT 1)
-					  AND EXISTS (
-						SELECT 1
-						FROM file_edits fe
-						JOIN turns t ON fe.turn_id = t.id
-						JOIN sessions s ON t.session_id = s.id
-						JOIN files f_edit ON fe.file_id = f_edit.id
-						WHERE s.chat_id = ${chatId}
-						  AND (
-							f_edit.path = f_mod.path
-							OR f_edit.path LIKE '%/' || f_mod.path
-							OR f_mod.path LIKE '%/' || f_edit.path
-						  )
-					  )
-					ORDER BY tc.id DESC
-					LIMIT 1
-				`;
-		return rows.length === 0 ? Option.none() : Option.some(rows[0].id);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "test_cases",
-		reason: extractSqlReason(e)
-	})));
-	const listTagInventory = (options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listTagInventory").pipe(Effect.annotateLogs({ project: options?.project }));
-		if (options?.project) {
-			const runs = yield* sql`SELECT id FROM test_runs
-						WHERE project = ${options.project}
-						ORDER BY timestamp DESC LIMIT 1`;
-			if (runs.length === 0) return [];
-			const runId = runs[0].id;
-			return (yield* sql`
-						SELECT t.name AS tag, ${options.project} AS project,
-							COUNT(DISTINCT tm.id) AS module_count,
-							COUNT(tc.id) AS test_count
-						FROM test_cases tc
-						JOIN test_modules tm ON tm.id = tc.module_id
-						JOIN test_case_tags tct ON tct.test_case_id = tc.id
-						JOIN tags t ON t.id = tct.tag_id
-						WHERE tm.run_id = ${runId}
-						GROUP BY t.name
-						ORDER BY t.name
-					`).map((r) => ({
-				tag: r.tag,
-				project: r.project,
-				moduleCount: r.module_count,
-				testCount: r.test_count
-			}));
-		}
-		return (yield* sql`
-					SELECT t.name AS tag, tr.project AS project,
-						COUNT(DISTINCT tm.id) AS module_count,
-						COUNT(tc.id) AS test_count
-					FROM test_runs tr
-					JOIN (
-						SELECT project, MAX(timestamp) AS max_ts
-						FROM test_runs
-						GROUP BY project
-					) latest ON tr.project = latest.project AND tr.timestamp = latest.max_ts
-					JOIN test_modules tm ON tm.run_id = tr.id
-					JOIN test_cases tc ON tc.module_id = tm.id
-					JOIN test_case_tags tct ON tct.test_case_id = tc.id
-					JOIN tags t ON t.id = tct.tag_id
-					GROUP BY tr.project, t.name
-					ORDER BY tr.project, t.name
-				`).map((r) => ({
-			tag: r.tag,
-			project: r.project,
-			moduleCount: r.module_count,
-			testCount: r.test_count
-		}));
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tags",
-		reason: extractSqlReason(e)
-	})));
-	const listTestsForTag = (tag, options) => Effect.gen(function* () {
-		yield* Effect.logDebug("listTestsForTag").pipe(Effect.annotateLogs({
-			tag,
-			project: options?.project
-		}));
-		if (options?.project) {
-			const runs = yield* sql`SELECT id FROM test_runs
-						WHERE project = ${options.project}
-						ORDER BY timestamp DESC LIMIT 1`;
-			if (runs.length === 0) return [];
-			const runId = runs[0].id;
-			return (yield* sql`
-						SELECT tc.id, tc.full_name, tc.state, tc.duration, f.path AS file_path, tc.classification
-						FROM test_cases tc
-						JOIN test_modules tm ON tm.id = tc.module_id
-						JOIN files f ON f.id = tm.file_id
-						JOIN test_case_tags tct ON tct.test_case_id = tc.id
-						JOIN tags t ON t.id = tct.tag_id
-						WHERE tm.run_id = ${runId} AND t.name = ${tag}
-						ORDER BY tc.full_name
-					`).map(mapTestListRow);
-		}
-		return (yield* sql`
-					SELECT tc.id, tc.full_name, tc.state, tc.duration, f.path AS file_path, tc.classification
-					FROM test_runs tr
-					JOIN (
-						SELECT project, MAX(timestamp) AS max_ts
-						FROM test_runs
-						GROUP BY project
-					) latest ON tr.project = latest.project AND tr.timestamp = latest.max_ts
-					JOIN test_modules tm ON tm.run_id = tr.id
-					JOIN files f ON f.id = tm.file_id
-					JOIN test_cases tc ON tc.module_id = tm.id
-					JOIN test_case_tags tct ON tct.test_case_id = tc.id
-					JOIN tags t ON t.id = tct.tag_id
-					WHERE t.name = ${tag}
-					ORDER BY tr.project, tc.full_name
-				`).map(mapTestListRow);
-	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
-		operation: "read",
-		table: "tags",
-		reason: extractSqlReason(e)
-	})));
-	return {
-		getLatestRun,
-		getRunsByProject,
-		getHistory,
-		getBaselines,
-		getTrends,
-		getFlaky,
-		getPersistentFailures,
-		getFileCoverage,
-		getCoverage,
-		getTestsForFile,
-		getErrors,
-		getAnnotationsForTest,
-		getArtifactsForTest,
-		getNotes,
-		getNoteById,
-		searchNotes,
-		getManifest,
-		getSettings,
-		getLatestSettings,
-		getTestByFullName,
-		getTestModulesByFullName,
-		listTests,
-		listModules,
-		listSuites,
-		listSettings,
-		getSessionById,
-		getSessionByChatId,
-		findSessionsByChatPrefix,
-		findActiveSubagentSession,
-		getSessionByTddTaskId,
-		listSessions,
-		searchTurns,
-		computeAcceptanceMetrics,
-		getFailureSignatureByHash,
-		getTddTaskById,
-		getGoalById,
-		getGoalsByTddTask,
-		getBehaviorById,
-		getBehaviorsByGoal,
-		getBehaviorsByTddTask,
-		getBehaviorDependencies,
-		resolveGoalIdForBehavior,
-		getCurrentTddPhase,
-		getTddArtifactWithContext,
-		getCommitChanges,
-		listTddTasksForSession,
-		countRecentArtifactsInOtherSessionsOfConversation,
-		listTddArtifactsForTask,
-		listHypotheses,
-		findIdempotentResponse,
-		getLatestTestCaseForSession,
-		listTagInventory,
-		listTestsForTag
-	};
-}));
-function mapTestListRow(row) {
-	return {
-		id: row.id,
-		fullName: row.full_name,
-		state: row.state,
-		duration: row.duration,
-		module: row.file_path,
-		classification: row.classification
-	};
-}
-function mapNoteRow(row) {
-	return {
-		id: row.id,
-		title: row.title,
-		content: row.content,
-		scope: row.scope,
-		project: row.project,
-		testFullName: row.test_full_name,
-		modulePath: row.module_path,
-		parentNoteId: row.parent_note_id,
-		createdBy: row.created_by,
-		expiresAt: row.expires_at,
-		pinned: row.pinned === 1,
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-
-//#endregion
-export { DataReaderLive };