@vitest-agent/sdk 1.0.0

package/layers/DataReaderLive.js

@@ -0,0 +1,1666 @@
+import { DataStoreError, extractSqlReason } from "../errors/DataStoreError.js";
+import { DataReader } from "../services/DataReader.js";
+import { Effect, Layer, Option } from "effect";
+import { SqlClient } from "@effect/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 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) => Effect.gen(function* () {
+		yield* Effect.logDebug("getHistory").pipe(Effect.annotateLogs({ project }));
+		const rows = yield* sql`SELECT full_name, timestamp, state
+					FROM test_history
+					WHERE project = ${project}
+					ORDER BY full_name, timestamp DESC`;
+		const testsMap = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			if (row.state !== "passed" && row.state !== "failed") continue;
+			const existing = testsMap.get(row.full_name);
+			if (existing) existing.push({
+				timestamp: row.timestamp,
+				state: row.state
+			});
+			else testsMap.set(row.full_name, [{
+				timestamp: row.timestamp,
+				state: row.state
+			}]);
+		}
+		const tests = Array.from(testsMap.entries()).map(([fullName, runs]) => ({
+			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)
+	})));
+	const getBaselines = (project) => Effect.gen(function* () {
+		yield* Effect.logDebug("getBaselines").pipe(Effect.annotateLogs({ project }));
+		const rows = yield* sql`SELECT metric, value, pattern, updated_at
+					FROM coverage_baselines
+					WHERE project = ${project}
+					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 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) => Effect.gen(function* () {
+		yield* Effect.logDebug("getFlaky").pipe(Effect.annotateLogs({ project }));
+		return (yield* sql`SELECT
+						th1.full_name,
+						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.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}
+					GROUP BY th1.full_name, 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.
+						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,
+			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) => Effect.gen(function* () {
+		yield* Effect.logDebug("getPersistentFailures").pipe(Effect.annotateLogs({ project }));
+		return (yield* sql`WITH ranked AS (
+					SELECT full_name, project, state, timestamp, error_message,
+						ROW_NUMBER() OVER (
+							PARTITION BY project, full_name
+							ORDER BY timestamp DESC
+						) as rn
+					FROM test_history
+					WHERE project = ${project}
+				),
+				streak AS (
+					SELECT full_name, project, state, timestamp, error_message, rn,
+						MIN(CASE WHEN state != 'failed' THEN rn END) OVER (
+							PARTITION BY project, full_name
+						) as first_pass_rn
+					FROM ranked
+				)
+				SELECT
+					full_name, 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.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, project
+				HAVING consecutive_failures >= 2`).map((row) => ({
+			fullName: row.full_name,
+			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 fileCoverageRows = 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 = ${runs[0].id}`;
+		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 baselinesOpt = yield* getBaselines("__global__");
+		const baselines = Option.getOrElse(baselinesOpt, () => ({
+			updatedAt: "",
+			global: {},
+			patterns: []
+		}));
+		const lowCoverage = fileCoverageRows.map((r) => ({
+			file: r.file_path,
+			summary: {
+				statements: r.statements,
+				branches: r.branches,
+				functions: r.functions,
+				lines: r.lines
+			},
+			uncoveredLines: r.uncovered_lines ?? ""
+		}));
+		const report = {
+			totals,
+			thresholds: {
+				global: baselines.global,
+				patterns: baselines.patterns
+			},
+			scoped: false,
+			lowCoverage,
+			lowCoverageFiles: lowCoverage.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 = te.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 = te.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 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.catchAll(() => 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) => Effect.gen(function* () {
+		yield* Effect.logDebug("getTestByFullName").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 Option.none();
+		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 = ${runs[0].id} AND tc.full_name = ${fullName}
+					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 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 [];
+		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 = ${runs[0].id}
+					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
+	});
+	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 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 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 }));
+		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 FROM sessions WHERE chat_id LIKE ${`${prefix}%`} 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 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 searchTurns = (options) => Effect.gen(function* () {
+		yield* Effect.logDebug("searchTurns").pipe(Effect.annotateLogs({ ...options }));
+		const limit = options.limit ?? 100;
+		return (yield* sql`SELECT id, session_id, turn_no, type, payload, occurred_at FROM turns WHERE 1=1${options.sessionId !== void 0 ? sql` AND session_id = ${options.sessionId}` : sql``}${options.type !== void 0 ? sql` AND type = ${options.type}` : sql``}${options.since !== void 0 ? sql` AND occurred_at >= ${options.since}` : sql``} 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
+					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
+					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
+		});
+	}).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
+		}));
+		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;
+			}
+		}
+		return (yield* sql`
+					SELECT id, session_id, goal, started_at, ended_at, outcome FROM tdd_tasks
+					WHERE session_id IN ${sql.in(sessionIds)} ORDER BY 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 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
+					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
+		}));
+	}).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 [];
+			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 = ${runs[0].id} 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,
+		getNotes,
+		getNoteById,
+		searchNotes,
+		getManifest,
+		getSettings,
+		getLatestSettings,
+		getTestByFullName,
+		listTests,
+		listModules,
+		listSuites,
+		listSettings,
+		getSessionById,
+		getSessionByChatId,
+		findSessionsByChatPrefix,
+		findActiveSubagentSession,
+		listSessions,
+		searchTurns,
+		computeAcceptanceMetrics,
+		getFailureSignatureByHash,
+		getTddTaskById,
+		getGoalById,
+		getGoalsByTddTask,
+		getBehaviorById,
+		getBehaviorsByGoal,
+		getBehaviorsByTddTask,
+		getBehaviorDependencies,
+		resolveGoalIdForBehavior,
+		getCurrentTddPhase,
+		getTddArtifactWithContext,
+		getCommitChanges,
+		listTddTasksForSession,
+		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 };