@vitest-agent/engine 0.1.0

package/layers/DataStoreLive.js

@@ -0,0 +1,1283 @@
+import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "../services/DataStore.js";
+import { Agent, AgentNotFoundError, BehaviorNotFoundError, DataStoreError, GoalNotFoundError, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, coerceErrorText, extractSqlReason } from "@vitest-agent/sdk";
+import { Effect, Layer, Option } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+
+//#region src/layers/DataStoreLive.ts
+const isLegalLifecycleTransition = (from, to) => {
+	if (from === to) return true;
+	if (from === "done" || from === "abandoned") return false;
+	if (from === "pending") return to === "in_progress" || to === "done" || to === "abandoned";
+	if (from === "in_progress") return to === "done" || to === "abandoned";
+	return false;
+};
+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 boolToInt = (v) => v === void 0 ? null : v ? 1 : 0;
+/** @public */
+const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	yield* sql`PRAGMA foreign_keys=ON`.pipe(Effect.catch(() => Effect.void));
+	const ensureFile = (filePath) => Effect.gen(function* () {
+		yield* Effect.logDebug("ensureFile").pipe(Effect.annotateLogs({ filePath }));
+		yield* sql`INSERT OR IGNORE INTO files (path) VALUES (${filePath})`;
+		return (yield* sql`SELECT id FROM files WHERE path = ${filePath}`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "files",
+		reason: extractSqlReason(e)
+	})));
+	const writeSettings = (hash, settings, envVars) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeSettings").pipe(Effect.annotateLogs({ hash }));
+		yield* sql`INSERT OR IGNORE INTO settings (hash, vitest_version, pool, environment, test_timeout, hook_timeout, slow_test_threshold, max_concurrency, max_workers, isolate, bail, globals, file_parallelism, sequence_seed, coverage_provider) VALUES (${hash}, ${settings.vitestVersion}, ${settings.pool ?? null}, ${settings.environment ?? null}, ${settings.testTimeout ?? null}, ${settings.hookTimeout ?? null}, ${settings.slowTestThreshold ?? null}, ${settings.maxConcurrency ?? null}, ${settings.maxWorkers ?? null}, ${boolToInt(settings.isolate)}, ${settings.bail ?? null}, ${boolToInt(settings.globals)}, ${boolToInt(settings.fileParallelism)}, ${settings.sequenceSeed ?? null}, ${settings.coverageProvider ?? null})`;
+		for (const [key, value] of Object.entries(envVars)) yield* sql`INSERT OR IGNORE INTO settings_env_vars (settings_hash, key, value) VALUES (${hash}, ${key}, ${value})`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "settings",
+		reason: extractSqlReason(e)
+	})));
+	const writeRun = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeRun").pipe(Effect.annotateLogs({
+			project: input.project,
+			invocationId: input.invocationId
+		}));
+		const actorType = input.actorType ?? "system";
+		const agentId = input.agentId ?? null;
+		const conversationId = input.conversationId ?? null;
+		const gitDirtyInt = input.gitDirty === void 0 || input.gitDirty === null ? null : input.gitDirty ? 1 : 0;
+		const hostMetadataJson = input.hostMetadata == null ? null : JSON.stringify(input.hostMetadata);
+		yield* sql`INSERT INTO test_runs (invocation_id, project, settings_hash, timestamp, commit_sha, branch, reason, duration, total, passed, failed, skipped, scoped, snapshot_added, snapshot_matched, snapshot_unmatched, snapshot_updated, snapshot_unchecked, snapshot_total, snapshot_failure, snapshot_did_update, snapshot_files_added, snapshot_files_removed, snapshot_files_unmatched, snapshot_files_updated, actor_type, agent_id, conversation_id, git_branch, git_commit_sha, git_dirty, git_upstream, git_worktree_dir, host_source, host_value, host_metadata) VALUES (${input.invocationId}, ${input.project}, ${input.settingsHash}, ${input.timestamp}, ${input.commitSha ?? null}, ${input.branch ?? null}, ${input.reason}, ${input.duration}, ${input.total}, ${input.passed}, ${input.failed}, ${input.skipped}, ${input.scoped ? 1 : 0}, ${input.snapshotAdded ?? 0}, ${input.snapshotMatched ?? 0}, ${input.snapshotUnmatched ?? 0}, ${input.snapshotUpdated ?? 0}, ${input.snapshotUnchecked ?? 0}, ${input.snapshotTotal ?? 0}, ${boolToInt(input.snapshotFailure) ?? 0}, ${boolToInt(input.snapshotDidUpdate) ?? 0}, ${input.snapshotFilesAdded ?? 0}, ${input.snapshotFilesRemoved ?? 0}, ${input.snapshotFilesUnmatched ?? 0}, ${input.snapshotFilesUpdated ?? 0}, ${actorType}, ${agentId}, ${conversationId}, ${input.gitBranch ?? null}, ${input.gitCommitSha ?? null}, ${gitDirtyInt}, ${input.gitUpstream ?? null}, ${input.gitWorktreeDir ?? null}, ${input.hostSource ?? null}, ${input.hostValue ?? null}, ${hostMetadataJson})`;
+		return (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_runs",
+		reason: extractSqlReason(e)
+	})));
+	const writeModules = (runId, modules) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeModules").pipe(Effect.annotateLogs({
+			runId,
+			count: modules.length
+		}));
+		const ids = [];
+		for (const mod of modules) {
+			yield* sql`INSERT INTO test_modules (run_id, file_id, relative_module_id, state, duration, environment_setup_duration, prepare_duration, collect_duration, setup_duration, heap) VALUES (${runId}, ${mod.fileId}, ${mod.relativeModuleId}, ${mod.state}, ${mod.duration ?? null}, ${mod.environmentSetupDuration ?? null}, ${mod.prepareDuration ?? null}, ${mod.collectDuration ?? null}, ${mod.setupDuration ?? null}, ${mod.heap ?? null})`;
+			const rows = yield* sql`SELECT last_insert_rowid() as id`;
+			ids.push(rows[0].id);
+		}
+		return ids;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_modules",
+		reason: extractSqlReason(e)
+	})));
+	const writeSuites = (moduleId, suites) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeSuites").pipe(Effect.annotateLogs({
+			moduleId,
+			count: suites.length
+		}));
+		const ids = [];
+		for (const suite of suites) {
+			yield* sql`INSERT INTO test_suites (module_id, parent_suite_id, name, full_name, state, mode, concurrent, shuffle, retry, repeats, location_line, location_column) VALUES (${moduleId}, ${suite.parentSuiteId ?? null}, ${suite.name}, ${suite.fullName}, ${suite.state}, ${suite.mode ?? null}, ${boolToInt(suite.concurrent)}, ${boolToInt(suite.shuffle)}, ${suite.retry ?? null}, ${suite.repeats ?? null}, ${suite.locationLine ?? null}, ${suite.locationColumn ?? null})`;
+			const rows = yield* sql`SELECT last_insert_rowid() as id`;
+			ids.push(rows[0].id);
+		}
+		return ids;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_suites",
+		reason: extractSqlReason(e)
+	})));
+	const writeTestCases = (moduleId, tests) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeTestCases").pipe(Effect.annotateLogs({
+			moduleId,
+			count: tests.length
+		}));
+		const ids = [];
+		for (const tc of tests) {
+			yield* sql`INSERT INTO test_cases (module_id, suite_id, vitest_id, name, full_name, state, classification, duration, start_time, flaky, slow, retry_count, repeat_count, heap, mode, each, fails, concurrent, shuffle, timeout, skip_note, location_line, location_column, created_turn_id) VALUES (${moduleId}, ${tc.suiteId ?? null}, ${tc.vitestId ?? null}, ${tc.name}, ${tc.fullName}, ${tc.state}, ${tc.classification ?? null}, ${tc.duration ?? null}, ${tc.startTime ?? null}, ${boolToInt(tc.flaky)}, ${boolToInt(tc.slow)}, ${tc.retryCount ?? 0}, ${tc.repeatCount ?? 0}, ${tc.heap ?? null}, ${tc.mode ?? null}, ${boolToInt(tc.each)}, ${boolToInt(tc.fails)}, ${boolToInt(tc.concurrent)}, ${boolToInt(tc.shuffle)}, ${tc.timeout ?? null}, ${tc.skipNote ?? null}, ${tc.locationLine ?? null}, ${tc.locationColumn ?? null}, ${tc.createdTurnId ?? null})`;
+			const testCaseId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+			ids.push(testCaseId);
+			if (tc.tags && tc.tags.length > 0) for (const tag of tc.tags) {
+				yield* sql`INSERT OR IGNORE INTO tags (name) VALUES (${tag})`;
+				const tagRows = yield* sql`SELECT id FROM tags WHERE name = ${tag}`;
+				if (tagRows.length > 0) yield* sql`INSERT OR IGNORE INTO test_case_tags (test_case_id, tag_id) VALUES (${testCaseId}, ${tagRows[0].id})`;
+			}
+		}
+		return ids;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_cases",
+		reason: extractSqlReason(e)
+	})));
+	const writeErrors = (runId, errors) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeErrors").pipe(Effect.annotateLogs({
+			runId,
+			count: errors.length
+		}));
+		for (const err of errors) {
+			const message = coerceErrorText(err.message) ?? "<missing message>";
+			yield* sql`INSERT INTO test_errors (run_id, test_case_id, test_suite_id, module_id, scope, name, message, diff, actual, expected, stack, cause_error_id, signature_hash, ordinal) VALUES (${runId}, ${err.testCaseId ?? null}, ${err.testSuiteId ?? null}, ${err.moduleId ?? null}, ${err.scope}, ${coerceErrorText(err.name) ?? null}, ${message}, ${coerceErrorText(err.diff) ?? null}, ${coerceErrorText(err.actual) ?? null}, ${coerceErrorText(err.expected) ?? null}, ${coerceErrorText(err.stack) ?? null}, ${err.causeErrorId ?? null}, ${err.signatureHash ?? null}, ${err.ordinal ?? 0})`;
+			const stackText = coerceErrorText(err.stack);
+			if (err.frames && err.frames.length > 0) {
+				const errorId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+				for (const frame of err.frames) {
+					const fileId = yield* ensureFile(frame.filePath);
+					yield* sql`INSERT INTO stack_frames (error_id, ordinal, method, file_id, line, col, source_mapped_line, function_boundary_line) VALUES (${errorId}, ${frame.ordinal}, ${frame.method}, ${fileId}, ${frame.line}, ${frame.col}, ${frame.sourceMappedLine ?? null}, ${frame.functionBoundaryLine ?? null})`;
+				}
+			} else if (stackText) {
+				const errorId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+				const frames = [...stackText.matchAll(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/g)];
+				for (let frameOrdinal = 0; frameOrdinal < frames.length; frameOrdinal++) {
+					const m = frames[frameOrdinal];
+					const method = m[1] ?? null;
+					const filePath = m[2];
+					const line = Number.parseInt(m[3], 10);
+					const col = Number.parseInt(m[4], 10);
+					const fileId = yield* ensureFile(filePath);
+					yield* sql`INSERT INTO stack_frames (error_id, ordinal, method, file_id, line, col, source_mapped_line, function_boundary_line) VALUES (${errorId}, ${frameOrdinal}, ${method}, ${fileId}, ${line}, ${col}, NULL, NULL)`;
+				}
+			}
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_errors",
+		reason: extractSqlReason(e)
+	})));
+	const writeAttachments = (owner, attachments) => Effect.gen(function* () {
+		for (const att of attachments) {
+			const artifactId = "artifactId" in owner ? owner.artifactId : null;
+			const annotationId = "annotationId" in owner ? owner.annotationId : null;
+			const storedBytes = att.body === void 0 ? 0 : Buffer.byteLength(att.body, "utf8");
+			const inline = att.body !== void 0 && Math.max(storedBytes, att.byteSize) <= 65536;
+			const body = inline ? att.body : null;
+			const bodyEncoding = inline ? att.bodyEncoding ?? null : null;
+			yield* sql`INSERT INTO attachments (artifact_id, annotation_id, content_type, path, body, body_encoding, byte_size) VALUES (${artifactId}, ${annotationId}, ${att.contentType ?? null}, ${att.path ?? null}, ${body}, ${bodyEncoding}, ${att.byteSize})`;
+		}
+	});
+	const writeAnnotations = (runId, annotations) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeAnnotations").pipe(Effect.annotateLogs({
+			runId,
+			count: annotations.length
+		}));
+		for (const anno of annotations) {
+			const locationFileId = anno.locationFile !== void 0 ? yield* ensureFile(anno.locationFile) : null;
+			yield* sql`INSERT INTO test_annotations (test_case_id, type, message, location_file_id, location_line, location_column) VALUES (${anno.testCaseId}, ${anno.type}, ${anno.message}, ${locationFileId}, ${anno.locationLine ?? null}, ${anno.locationColumn ?? null})`;
+			const idRows = yield* sql`SELECT last_insert_rowid() as id`;
+			yield* writeAttachments({ annotationId: idRows[0].id }, anno.attachments ?? []);
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_annotations",
+		reason: extractSqlReason(e)
+	})));
+	const writeArtifacts = (runId, artifacts) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeArtifacts").pipe(Effect.annotateLogs({
+			runId,
+			count: artifacts.length
+		}));
+		for (const art of artifacts) {
+			const locationFileId = art.locationFile !== void 0 ? yield* ensureFile(art.locationFile) : null;
+			yield* sql`INSERT INTO test_artifacts (test_case_id, type, message, data, location_file_id, location_line, location_column) VALUES (${art.testCaseId}, ${art.type}, ${art.message ?? null}, ${art.data ?? null}, ${locationFileId}, ${art.locationLine ?? null}, ${art.locationColumn ?? null})`;
+			const idRows = yield* sql`SELECT last_insert_rowid() as id`;
+			yield* writeAttachments({ artifactId: idRows[0].id }, art.attachments ?? []);
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_artifacts",
+		reason: extractSqlReason(e)
+	})));
+	const writeCoverage = (runId, coverage) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeCoverage").pipe(Effect.annotateLogs({
+			runId,
+			count: coverage.length
+		}));
+		for (const cov of coverage) {
+			const tier = cov.tier ?? "below_threshold";
+			yield* sql`INSERT INTO file_coverage (run_id, file_id, statements, branches, functions, lines, uncovered_lines, tier) VALUES (${runId}, ${cov.fileId}, ${cov.statements}, ${cov.branches}, ${cov.functions}, ${cov.lines}, ${cov.uncoveredLines ?? null}, ${tier})`;
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "file_coverage",
+		reason: extractSqlReason(e)
+	})));
+	const writeHistory = (project, fullName, modulePath, runId, timestamp, state, duration, flaky, retryCount, errorMessage) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeHistory").pipe(Effect.annotateLogs({
+			project,
+			modulePath,
+			runId
+		}));
+		yield* sql`INSERT INTO test_history (run_id, project, module_path, full_name, timestamp, state, duration, flaky, retry_count, error_message) VALUES (${runId}, ${project}, ${modulePath}, ${fullName}, ${timestamp}, ${state}, ${duration}, ${flaky ? 1 : 0}, ${retryCount}, ${errorMessage}) ON CONFLICT(project, module_path, full_name, timestamp) DO UPDATE SET run_id = excluded.run_id, state = excluded.state, duration = excluded.duration, flaky = excluded.flaky, retry_count = excluded.retry_count, error_message = excluded.error_message`;
+		yield* sql`DELETE FROM test_history WHERE id NOT IN (SELECT id FROM test_history WHERE project = ${project} AND module_path = ${modulePath} AND full_name = ${fullName} ORDER BY timestamp DESC LIMIT 10) AND project = ${project} AND module_path = ${modulePath} AND full_name = ${fullName}`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_history",
+		reason: extractSqlReason(e)
+	})));
+	const writeBaselines = (baselines) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeBaselines").pipe(Effect.annotateLogs({ updatedAt: baselines.updatedAt }));
+		const { updatedAt, global: g, patterns = [] } = baselines;
+		const metrics = [
+			"lines",
+			"functions",
+			"branches",
+			"statements"
+		];
+		for (const metric of metrics) {
+			const value = g[metric];
+			if (value !== void 0 && Number.isFinite(value)) yield* sql`INSERT INTO coverage_baselines (project, kind, metric, value, pattern, updated_at) VALUES ('__global__', 'baseline', ${metric}, ${value}, '', ${updatedAt}) ON CONFLICT (project, kind, metric, pattern) DO UPDATE SET value = ${value}, updated_at = ${updatedAt}`;
+		}
+		for (const [pattern, thresholds] of patterns) for (const metric of metrics) {
+			const value = thresholds[metric];
+			if (value !== void 0 && Number.isFinite(value)) yield* sql`INSERT INTO coverage_baselines (project, kind, metric, value, pattern, updated_at) VALUES ('__global__', 'baseline', ${metric}, ${value}, ${pattern}, ${updatedAt}) ON CONFLICT (project, kind, metric, pattern) DO UPDATE SET value = ${value}, updated_at = ${updatedAt}`;
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "coverage_baselines",
+		reason: extractSqlReason(e)
+	})));
+	/**
+	* Shared upsert for the `coverage_baselines` table's non-baseline
+	* `kind` rows (`threshold` / `target`). Distinct from `writeBaselines`
+	* so the ratcheted high-water mark never collides with the resolved,
+	* enforced Vitest thresholds or the aspirational coverageTargets
+	* (issue #237).
+	*/
+	const writeCoveragePolicy = (kind, policy) => sql.withTransaction(Effect.gen(function* () {
+		yield* Effect.logDebug("writeCoveragePolicy").pipe(Effect.annotateLogs({ kind }));
+		const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const { global: g, patterns = [] } = policy;
+		const metrics = [
+			"lines",
+			"functions",
+			"branches",
+			"statements"
+		];
+		yield* sql`DELETE FROM coverage_baselines WHERE project = '__global__' AND kind = ${kind}`;
+		for (const metric of metrics) {
+			const value = g[metric];
+			if (value !== void 0 && Number.isFinite(value)) yield* sql`INSERT INTO coverage_baselines (project, kind, metric, value, pattern, updated_at) VALUES ('__global__', ${kind}, ${metric}, ${value}, '', ${updatedAt})`;
+		}
+		for (const [pattern, thresholds] of patterns) for (const metric of metrics) {
+			const value = thresholds[metric];
+			if (value !== void 0 && Number.isFinite(value)) yield* sql`INSERT INTO coverage_baselines (project, kind, metric, value, pattern, updated_at) VALUES ('__global__', ${kind}, ${metric}, ${value}, ${pattern}, ${updatedAt})`;
+		}
+	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "coverage_baselines",
+		reason: extractSqlReason(e)
+	})));
+	const writeThresholds = (thresholds) => writeCoveragePolicy("threshold", thresholds);
+	const writeTargets = (targets) => writeCoveragePolicy("target", targets);
+	const writeTrends = (project, runId, entry) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeTrends").pipe(Effect.annotateLogs({
+			project,
+			runId
+		}));
+		yield* sql`INSERT OR REPLACE INTO coverage_trends (run_id, project, timestamp, lines, functions, branches, statements, direction, targets_hash) VALUES (${runId}, ${project}, ${entry.timestamp}, ${entry.coverage.lines}, ${entry.coverage.functions}, ${entry.coverage.branches}, ${entry.coverage.statements}, ${entry.direction}, ${entry.targetsHash ?? null})`;
+		yield* sql`DELETE FROM coverage_trends WHERE id NOT IN (SELECT id FROM coverage_trends WHERE project = ${project} ORDER BY timestamp DESC LIMIT 50) AND project = ${project}`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "coverage_trends",
+		reason: extractSqlReason(e)
+	})));
+	const writeSourceMap = (sourceFilePath, testModuleId, mappingType) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeSourceMap").pipe(Effect.annotateLogs({
+			sourceFilePath,
+			testModuleId,
+			mappingType
+		}));
+		const sourceFileId = yield* ensureFile(sourceFilePath);
+		yield* sql`INSERT OR IGNORE INTO source_test_map (source_file_id, test_module_id, mapping_type) VALUES (${sourceFileId}, ${testModuleId}, ${mappingType})`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "source_test_map",
+		reason: extractSqlReason(e)
+	})));
+	const writeNote = (note) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeNote").pipe(Effect.annotateLogs({
+			scope: note.scope,
+			project: note.project ?? null
+		}));
+		yield* sql`INSERT INTO notes (title, content, scope, project, test_full_name, module_path, parent_note_id, created_by, expires_at, pinned) VALUES (${note.title}, ${note.content}, ${note.scope}, ${note.project ?? null}, ${note.testFullName ?? null}, ${note.modulePath ?? null}, ${note.parentNoteId ?? null}, ${note.createdBy ?? null}, ${note.expiresAt ?? null}, ${note.pinned ? 1 : 0})`;
+		return (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "notes",
+		reason: extractSqlReason(e)
+	})));
+	const updateNote = (id, fields) => Effect.gen(function* () {
+		yield* Effect.logDebug("updateNote").pipe(Effect.annotateLogs({ id }));
+		const setClauses = [];
+		const values = [];
+		if (fields.title !== void 0) {
+			setClauses.push("title = ?");
+			values.push(fields.title);
+		}
+		if (fields.content !== void 0) {
+			setClauses.push("content = ?");
+			values.push(fields.content);
+		}
+		if (fields.scope !== void 0) {
+			setClauses.push("scope = ?");
+			values.push(fields.scope);
+		}
+		if (fields.project !== void 0) {
+			setClauses.push("project = ?");
+			values.push(fields.project);
+		}
+		if (fields.testFullName !== void 0) {
+			setClauses.push("test_full_name = ?");
+			values.push(fields.testFullName);
+		}
+		if (fields.modulePath !== void 0) {
+			setClauses.push("module_path = ?");
+			values.push(fields.modulePath);
+		}
+		if (fields.parentNoteId !== void 0) {
+			setClauses.push("parent_note_id = ?");
+			values.push(fields.parentNoteId);
+		}
+		if (fields.createdBy !== void 0) {
+			setClauses.push("created_by = ?");
+			values.push(fields.createdBy);
+		}
+		if (fields.expiresAt !== void 0) {
+			setClauses.push("expires_at = ?");
+			values.push(fields.expiresAt);
+		}
+		if (fields.pinned !== void 0) {
+			setClauses.push("pinned = ?");
+			values.push(fields.pinned ? 1 : 0);
+		}
+		if (setClauses.length === 0) return;
+		setClauses.push("updated_at = datetime('now')");
+		yield* sql.unsafe(`UPDATE notes SET ${setClauses.join(", ")} WHERE id = ?`, [...values, id]);
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "notes",
+		reason: extractSqlReason(e)
+	})));
+	const deleteNote = (id) => Effect.gen(function* () {
+		yield* Effect.logDebug("deleteNote").pipe(Effect.annotateLogs({ id }));
+		yield* sql`DELETE FROM notes WHERE id = ${id}`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "notes",
+		reason: extractSqlReason(e)
+	})));
+	const writeSession = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeSession").pipe(Effect.annotateLogs({ chatId: input.chatId }));
+		yield* sql`INSERT INTO sessions (chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, conversation_id) VALUES (${input.chatId}, ${input.project}, ${input.cwd}, ${input.agentKind}, ${input.agentType ?? null}, ${input.parentSessionId ?? null}, ${boolToInt(input.triageWasNonEmpty) ?? 0}, ${input.startedAt}, ${input.conversationId ?? null})`;
+		return (yield* sql`SELECT id FROM sessions WHERE chat_id = ${input.chatId}`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "sessions",
+		reason: extractSqlReason(e)
+	})));
+	const upsertSession = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("upsertSession").pipe(Effect.annotateLogs({ chatId: input.chatId }));
+		yield* sql`INSERT INTO sessions (chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, conversation_id) VALUES (${input.chatId}, ${input.project}, ${input.cwd}, ${input.agentKind}, ${input.agentType ?? null}, ${input.parentSessionId ?? null}, ${boolToInt(input.triageWasNonEmpty) ?? 0}, ${input.startedAt}, ${input.conversationId ?? null}) ON CONFLICT(chat_id) DO NOTHING`;
+		return (yield* sql`SELECT id FROM sessions WHERE chat_id = ${input.chatId}`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "sessions",
+		reason: extractSqlReason(e)
+	})));
+	const setSessionConversationIdIfNull = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("setSessionConversationIdIfNull").pipe(Effect.annotateLogs(input));
+		yield* sql`
+					UPDATE sessions SET conversation_id = ${input.conversationId}
+					WHERE id = ${input.sessionId} AND conversation_id IS NULL
+				`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "sessions",
+		reason: extractSqlReason(e)
+	})));
+	const writeTurn = (input) => sql.withTransaction(Effect.gen(function* () {
+		yield* Effect.logDebug("writeTurn").pipe(Effect.annotateLogs({
+			sessionId: input.sessionId,
+			type: input.type
+		}));
+		if (input.turnNo !== void 0) yield* sql`INSERT INTO turns (session_id, turn_no, type, payload, occurred_at) VALUES (${input.sessionId}, ${input.turnNo}, ${input.type}, ${input.payload}, ${input.occurredAt})`;
+		else yield* sql`INSERT INTO turns (session_id, turn_no, type, payload, occurred_at) SELECT ${input.sessionId}, COALESCE(MAX(turn_no), 0) + 1, ${input.type}, ${input.payload}, ${input.occurredAt} FROM turns WHERE session_id = ${input.sessionId}`;
+		const turnId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+		if (input.type === "file_edit" || input.type === "tool_result") {
+			const payload = yield* Effect.try({
+				try: () => JSON.parse(input.payload),
+				catch: (e) => new DataStoreError({
+					operation: "write",
+					table: input.type === "file_edit" ? "file_edits" : "tool_invocations",
+					reason: `invalid turn payload JSON: ${e.message}`
+				})
+			});
+			if (input.type === "file_edit") {
+				const filePath = payload.file_path;
+				yield* sql`INSERT OR IGNORE INTO files (path) VALUES (${filePath})`;
+				const fileId = (yield* sql`SELECT id FROM files WHERE path = ${filePath}`)[0].id;
+				yield* sql`
+									INSERT INTO file_edits (turn_id, file_id, edit_kind, lines_added, lines_removed, diff)
+									VALUES (
+										${turnId},
+										${fileId},
+										${payload.edit_kind},
+										${payload.lines_added ?? null},
+										${payload.lines_removed ?? null},
+										${payload.diff ?? null}
+									)
+								`;
+			} else {
+				const rawToolName = payload.tool_name;
+				const toolName = typeof rawToolName === "string" && rawToolName.startsWith("mcp__") ? rawToolName.split("__").at(-1) ?? rawToolName : rawToolName;
+				yield* sql`
+									INSERT INTO tool_invocations (turn_id, tool_name, params_hash, result_summary, duration_ms, success)
+									VALUES (
+										${turnId},
+										${toolName},
+										${null},
+										${payload.result_summary ?? null},
+										${payload.duration_ms ?? null},
+										${boolToInt(payload.success) ?? 0}
+									)
+								`;
+			}
+		}
+		return turnId;
+	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError ? e : new DataStoreError({
+		operation: "write",
+		table: "turns",
+		reason: extractSqlReason(e)
+	})));
+	const endSession = (chatId, endedAt, endReason) => Effect.gen(function* () {
+		yield* Effect.logDebug("endSession").pipe(Effect.annotateLogs({
+			chatId,
+			endReason
+		}));
+		yield* sql`UPDATE sessions SET ended_at = ${endedAt}, end_reason = ${endReason} WHERE chat_id = ${chatId}`;
+		if ((yield* sql`SELECT changes() as changes`)[0].changes === 0) return yield* Effect.fail(new DataStoreError({
+			operation: "write",
+			table: "sessions",
+			reason: `unknown chat_id: ${chatId}`
+		}));
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError ? e : new DataStoreError({
+		operation: "write",
+		table: "sessions",
+		reason: extractSqlReason(e)
+	})));
+	const writeFailureSignature = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeFailureSignature").pipe(Effect.annotateLogs({
+			signatureHash: input.signatureHash,
+			runId: input.runId
+		}));
+		yield* sql`INSERT INTO failure_signatures (signature_hash, first_seen_run_id, first_seen_at, last_seen_at, occurrence_count) VALUES (${input.signatureHash}, ${input.runId}, ${input.seenAt}, ${input.seenAt}, 1) ON CONFLICT(signature_hash) DO UPDATE SET occurrence_count = occurrence_count + 1, last_seen_at = excluded.last_seen_at`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "failure_signatures",
+		reason: extractSqlReason(e)
+	})));
+	const writeHypothesis = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeHypothesis").pipe(Effect.annotateLogs({ sessionId: input.sessionId }));
+		yield* sql`INSERT INTO hypotheses (session_id, content, created_turn_id, cited_test_error_id, cited_stack_frame_id) VALUES (${input.sessionId}, ${input.content}, ${input.createdTurnId ?? null}, ${input.citedTestErrorId ?? null}, ${input.citedStackFrameId ?? null})`;
+		return (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "hypotheses",
+		reason: extractSqlReason(e)
+	})));
+	const validateHypothesis = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("validateHypothesis").pipe(Effect.annotateLogs({
+			id: input.id,
+			outcome: input.outcome
+		}));
+		yield* sql`UPDATE hypotheses SET validation_outcome = ${input.outcome}, validated_at = ${input.validatedAt}, validated_turn_id = ${input.validatedTurnId ?? null} WHERE id = ${input.id}`;
+		if ((yield* sql`SELECT changes() as changes`)[0].changes === 0) return yield* Effect.fail(new DataStoreError({
+			operation: "write",
+			table: "hypotheses",
+			reason: `unknown hypothesis id: ${input.id}`
+		}));
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError ? e : new DataStoreError({
+		operation: "write",
+		table: "hypotheses",
+		reason: extractSqlReason(e)
+	})));
+	const writeTddTask = (input) => sql.withTransaction(Effect.gen(function* () {
+		yield* Effect.logDebug("writeTddTask").pipe(Effect.annotateLogs({
+			sessionId: input.sessionId,
+			goal: input.goal
+		}));
+		const rows = yield* sql`
+							INSERT OR IGNORE INTO tdd_tasks (session_id, goal, started_at, parent_tdd_task_id, run_id)
+							VALUES (
+								${input.sessionId},
+								${input.goal},
+								${input.startedAt},
+								${input.parentTddTaskId ?? null},
+								${input.runId ?? null}
+							)
+							RETURNING id
+						`;
+		let tddTaskId;
+		let isNewTask;
+		if (rows.length > 0) {
+			tddTaskId = rows[0].id;
+			isNewTask = true;
+		} else {
+			const existing = yield* sql`
+								SELECT id, goal FROM tdd_tasks
+								WHERE session_id = ${input.sessionId} AND run_id = ${input.runId}
+								LIMIT 1
+							`;
+			if (existing.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("writeTddTask: INSERT was ignored but no existing row found"));
+			if (existing[0].goal !== input.goal) return yield* Effect.fail(/* @__PURE__ */ new Error(`writeTddTask: runId conflict — existing task has goal "${existing[0].goal}", caller provided "${input.goal}"`));
+			tddTaskId = existing[0].id;
+			isNewTask = false;
+		}
+		if (isNewTask) yield* sql`
+								INSERT INTO tdd_phases
+									(tdd_task_id, behavior_id, phase, started_at, transition_reason, parent_phase_id)
+								VALUES
+									(
+										${tddTaskId},
+										${null},
+										${"spike"},
+										${input.startedAt},
+										${"opened by tdd_task_start"},
+										${null}
+									)
+							`;
+		return tddTaskId;
+	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "tdd_tasks",
+		reason: extractSqlReason(e)
+	})));
+	const endTddTask = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("endTddTask").pipe(Effect.annotateLogs({
+			id: input.id,
+			outcome: input.outcome
+		}));
+		yield* sql`
+					UPDATE tdd_tasks
+					SET ended_at = ${input.endedAt},
+					    outcome = ${input.outcome},
+					    summary_note_id = ${input.summaryNoteId ?? null}
+					WHERE id = ${input.id}
+				`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "tdd_tasks",
+		reason: extractSqlReason(e)
+	})));
+	const ensureTddTaskOpen = (tddTaskId) => Effect.gen(function* () {
+		const rows = yield* sql`
+					SELECT ended_at, outcome FROM tdd_tasks WHERE id = ${tddTaskId}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_tasks",
+			reason: extractSqlReason(e)
+		})));
+		if (rows.length === 0) return yield* Effect.fail(new TddTaskNotFoundError({
+			id: tddTaskId,
+			reason: "no tdd_tasks row for that id"
+		}));
+		const row = rows[0];
+		if (row.ended_at !== null) return yield* Effect.fail(new TddTaskAlreadyEndedError({
+			id: tddTaskId,
+			endedAt: row.ended_at,
+			outcome: row.outcome ?? "abandoned"
+		}));
+	});
+	const ensureTddTaskExists = (tddTaskId) => Effect.gen(function* () {
+		if ((yield* sql`SELECT id FROM tdd_tasks WHERE id = ${tddTaskId}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_tasks",
+			reason: extractSqlReason(e)
+		})))).length === 0) return yield* Effect.fail(new TddTaskNotFoundError({
+			id: tddTaskId,
+			reason: "no tdd_tasks row for that id"
+		}));
+	});
+	const createGoal = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("createGoal").pipe(Effect.annotateLogs({
+			tddTaskId: input.tddTaskId,
+			goal: input.goal
+		}));
+		yield* ensureTddTaskOpen(input.tddTaskId);
+		const rows = yield* sql`
+					INSERT INTO tdd_session_goals (session_id, ordinal, goal)
+					SELECT ${input.tddTaskId},
+					       COALESCE(MAX(ordinal), -1) + 1,
+					       ${input.goal}
+					FROM tdd_session_goals
+					WHERE session_id = ${input.tddTaskId}
+					RETURNING id, session_id, ordinal, goal, status, created_at
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+		return goalRowFromDb(rows[0]);
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const getGoal = (id) => Effect.gen(function* () {
+		const rows = yield* sql`
+					SELECT id, session_id, ordinal, goal, status, created_at
+					FROM tdd_session_goals
+					WHERE id = ${id}
+				`;
+		return rows.length === 0 ? Option.none() : Option.some(goalRowFromDb(rows[0]));
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "read",
+		table: "tdd_session_goals",
+		reason: extractSqlReason(e)
+	})));
+	const updateGoal = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("updateGoal").pipe(Effect.annotateLogs({ id: input.id }));
+		const existing = yield* sql`
+					SELECT id, session_id, ordinal, goal, status, created_at
+					FROM tdd_session_goals
+					WHERE id = ${input.id}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+		if (existing.length === 0) return yield* Effect.fail(new GoalNotFoundError({
+			id: input.id,
+			reason: "no tdd_session_goals row for that id"
+		}));
+		const current = existing[0];
+		yield* ensureTddTaskOpen(current.session_id).pipe(Effect.catchTag("TddTaskNotFoundError", (e) => Effect.fail(new DataStoreError({
+			operation: "read",
+			table: "tdd_tasks",
+			reason: `FK integrity violation: goal ${input.id} references missing tdd_tasks row ${e.id}`
+		}))));
+		const fromStatus = current.status;
+		const toStatus = input.status ?? fromStatus;
+		if (input.status !== void 0 && !isLegalLifecycleTransition(fromStatus, input.status)) return yield* Effect.fail(new IllegalStatusTransitionError({
+			entity: "goal",
+			id: input.id,
+			from: fromStatus,
+			to: input.status,
+			reason: "transition forbidden by goal lifecycle rules"
+		}));
+		const newGoalText = input.goal ?? current.goal;
+		yield* sql`
+					UPDATE tdd_session_goals
+					SET goal = ${newGoalText},
+					    status = ${toStatus}
+					WHERE id = ${input.id}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+		return {
+			id: current.id,
+			sessionId: current.session_id,
+			ordinal: current.ordinal,
+			goal: newGoalText,
+			status: toStatus,
+			createdAt: current.created_at
+		};
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const deleteGoal = (id) => Effect.gen(function* () {
+		yield* Effect.logDebug("deleteGoal").pipe(Effect.annotateLogs({ id }));
+		if ((yield* sql`SELECT id FROM tdd_session_goals WHERE id = ${id}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})))).length === 0) return yield* Effect.fail(new GoalNotFoundError({
+			id,
+			reason: "no tdd_session_goals row for that id"
+		}));
+		yield* sql`DELETE FROM tdd_session_goals WHERE id = ${id}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const listGoalsByTddTask = (tddTaskId) => Effect.gen(function* () {
+		yield* ensureTddTaskExists(tddTaskId);
+		return (yield* sql`
+					SELECT id, session_id, ordinal, goal, status, created_at
+					FROM tdd_session_goals
+					WHERE session_id = ${tddTaskId}
+					ORDER BY ordinal
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})))).map(goalRowFromDb);
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const ensureGoalOpenAndTaskOpen = (goalId) => Effect.gen(function* () {
+		const goals = yield* sql`
+					SELECT id, session_id, status FROM tdd_session_goals WHERE id = ${goalId}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+		if (goals.length === 0) return yield* Effect.fail(new GoalNotFoundError({
+			id: goalId,
+			reason: "no tdd_session_goals row"
+		}));
+		const goal = goals[0];
+		yield* ensureTddTaskOpen(goal.session_id).pipe(Effect.catchTag("TddTaskNotFoundError", (e) => Effect.fail(new DataStoreError({
+			operation: "read",
+			table: "tdd_tasks",
+			reason: `FK integrity violation: goal ${goalId} references missing tdd_tasks row ${e.id}`
+		}))));
+		if (goal.status === "done" || goal.status === "abandoned") return yield* Effect.fail(new IllegalStatusTransitionError({
+			entity: "goal",
+			id: goalId,
+			from: goal.status,
+			to: "in_progress",
+			reason: "cannot create a behavior under a closed goal"
+		}));
+		return {
+			goalTddTaskId: goal.session_id,
+			goalStatus: goal.status
+		};
+	});
+	const writeBehaviorDependencies = (behaviorId, goalId, depIds) => Effect.gen(function* () {
+		const uniqueDepIds = Array.from(new Set(depIds));
+		if (uniqueDepIds.length === 0) return;
+		const verified = yield* sql`
+					SELECT id FROM tdd_session_behaviors
+					WHERE goal_id = ${goalId} AND id IN ${sql.in(uniqueDepIds)}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})));
+		const verifiedIds = new Set(verified.map((r) => r.id));
+		for (const depId of uniqueDepIds) if (!verifiedIds.has(depId)) return yield* Effect.fail(new BehaviorNotFoundError({
+			id: depId,
+			reason: `dependency id ${depId} does not belong to goal ${goalId}`
+		}));
+		for (const depId of uniqueDepIds) yield* sql`
+						INSERT INTO tdd_behavior_dependencies (behavior_id, depends_on_id)
+						VALUES (${behaviorId}, ${depId})
+					`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_behavior_dependencies",
+			reason: extractSqlReason(e)
+		})));
+	});
+	const createBehavior = (input) => sql.withTransaction(Effect.gen(function* () {
+		yield* Effect.logDebug("createBehavior").pipe(Effect.annotateLogs({
+			goalId: input.goalId,
+			behavior: input.behavior
+		}));
+		yield* ensureGoalOpenAndTaskOpen(input.goalId);
+		const beh = (yield* sql`
+							INSERT INTO tdd_session_behaviors (goal_id, ordinal, behavior, suggested_test_name)
+							SELECT ${input.goalId},
+							       COALESCE(MAX(ordinal), -1) + 1,
+							       ${input.behavior},
+							       ${input.suggestedTestName ?? null}
+							FROM tdd_session_behaviors
+							WHERE goal_id = ${input.goalId}
+							RETURNING id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
+						`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		}))))[0];
+		if (input.dependsOnBehaviorIds && input.dependsOnBehaviorIds.length > 0) yield* writeBehaviorDependencies(beh.id, input.goalId, input.dependsOnBehaviorIds);
+		return behaviorRowFromDb(beh);
+	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError || e instanceof GoalNotFoundError || e instanceof BehaviorNotFoundError || e instanceof TddTaskAlreadyEndedError || e instanceof IllegalStatusTransitionError ? e : new DataStoreError({
+		operation: "write",
+		table: "tdd_session_behaviors",
+		reason: extractSqlReason(e)
+	})));
+	const getBehavior = (id) => Effect.gen(function* () {
+		const rows = yield* sql`
+					SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
+					FROM tdd_session_behaviors
+					WHERE id = ${id}
+				`;
+		return rows.length === 0 ? Option.none() : Option.some(behaviorRowFromDb(rows[0]));
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "read",
+		table: "tdd_session_behaviors",
+		reason: extractSqlReason(e)
+	})));
+	const updateBehavior = (input) => sql.withTransaction(Effect.gen(function* () {
+		yield* Effect.logDebug("updateBehavior").pipe(Effect.annotateLogs({ id: input.id }));
+		const existing = yield* sql`
+							SELECT id, goal_id, ordinal, behavior, suggested_test_name, status, created_at
+							FROM tdd_session_behaviors
+							WHERE id = ${input.id}
+						`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})));
+		if (existing.length === 0) return yield* Effect.fail(new BehaviorNotFoundError({
+			id: input.id,
+			reason: "no tdd_session_behaviors row for that id"
+		}));
+		const current = existing[0];
+		const goalRows = yield* sql`
+							SELECT session_id FROM tdd_session_goals WHERE id = ${current.goal_id}
+						`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})));
+		if (goalRows.length === 0) return yield* Effect.fail(new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: `FK integrity violation: behavior ${input.id} references missing tdd_session_goals row ${current.goal_id}`
+		}));
+		yield* ensureTddTaskOpen(goalRows[0].session_id).pipe(Effect.catchTag("TddTaskNotFoundError", (e) => Effect.fail(new DataStoreError({
+			operation: "read",
+			table: "tdd_tasks",
+			reason: `FK integrity violation: goal ${current.goal_id} references missing tdd_tasks row ${e.id}`
+		}))));
+		const fromStatus = current.status;
+		if (input.status !== void 0 && !isLegalLifecycleTransition(fromStatus, input.status)) return yield* Effect.fail(new IllegalStatusTransitionError({
+			entity: "behavior",
+			id: input.id,
+			from: fromStatus,
+			to: input.status,
+			reason: "transition forbidden by behavior lifecycle rules"
+		}));
+		const newBehaviorText = input.behavior ?? current.behavior;
+		const newStatus = input.status ?? fromStatus;
+		const newSuggested = input.suggestedTestName === void 0 ? current.suggested_test_name : input.suggestedTestName;
+		yield* sql`
+							UPDATE tdd_session_behaviors
+							SET behavior = ${newBehaviorText},
+							    suggested_test_name = ${newSuggested},
+							    status = ${newStatus}
+							WHERE id = ${input.id}
+						`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})));
+		if (input.dependsOnBehaviorIds !== void 0) {
+			yield* sql`DELETE FROM tdd_behavior_dependencies WHERE behavior_id = ${input.id}`.pipe(Effect.mapError((e) => new DataStoreError({
+				operation: "write",
+				table: "tdd_behavior_dependencies",
+				reason: extractSqlReason(e)
+			})));
+			if (input.dependsOnBehaviorIds.length > 0) yield* writeBehaviorDependencies(input.id, current.goal_id, input.dependsOnBehaviorIds);
+		}
+		return {
+			id: current.id,
+			goalId: current.goal_id,
+			ordinal: current.ordinal,
+			behavior: newBehaviorText,
+			suggestedTestName: newSuggested,
+			status: newStatus,
+			createdAt: current.created_at
+		};
+	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError || e instanceof BehaviorNotFoundError || e instanceof TddTaskAlreadyEndedError || e instanceof IllegalStatusTransitionError ? e : new DataStoreError({
+		operation: "write",
+		table: "tdd_session_behaviors",
+		reason: extractSqlReason(e)
+	})));
+	const deleteBehavior = (id) => Effect.gen(function* () {
+		yield* Effect.logDebug("deleteBehavior").pipe(Effect.annotateLogs({ id }));
+		if ((yield* sql`SELECT id FROM tdd_session_behaviors WHERE id = ${id}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})))).length === 0) return yield* Effect.fail(new BehaviorNotFoundError({
+			id,
+			reason: "no tdd_session_behaviors row for that id"
+		}));
+		yield* sql`DELETE FROM tdd_session_behaviors WHERE id = ${id}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})));
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const ensureGoalExists = (goalId) => Effect.gen(function* () {
+		if ((yield* sql`SELECT id FROM tdd_session_goals WHERE id = ${goalId}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_goals",
+			reason: extractSqlReason(e)
+		})))).length === 0) return yield* Effect.fail(new GoalNotFoundError({
+			id: goalId,
+			reason: "no tdd_session_goals row"
+		}));
+	});
+	const listBehaviorsByGoal = (goalId) => Effect.gen(function* () {
+		yield* ensureGoalExists(goalId);
+		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
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})))).map(behaviorRowFromDb);
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const listBehaviorsByTddTask = (tddTaskId) => Effect.gen(function* () {
+		yield* ensureTddTaskExists(tddTaskId);
+		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
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "tdd_session_behaviors",
+			reason: extractSqlReason(e)
+		})))).map(behaviorRowFromDb);
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const writeTddArtifact = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeTddArtifact").pipe(Effect.annotateLogs({
+			phaseId: input.phaseId,
+			artifactKind: input.artifactKind
+		}));
+		const truncatedDiff = input.diffExcerpt !== void 0 && input.diffExcerpt.length > 4096 ? input.diffExcerpt.slice(0, 4096) : input.diffExcerpt ?? null;
+		return (yield* sql`
+					INSERT INTO tdd_artifacts
+						(phase_id, artifact_kind, file_id, test_case_id, test_run_id,
+						 test_first_failure_run_id, diff_excerpt, recorded_at, suite)
+					VALUES
+						(
+							${input.phaseId},
+							${input.artifactKind},
+							${input.fileId ?? null},
+							${input.testCaseId ?? null},
+							${input.testRunId ?? null},
+							${input.testFirstFailureRunId ?? null},
+							${truncatedDiff},
+							${input.recordedAt},
+							${input.suite ?? "vitest"}
+						)
+					RETURNING id
+				`)[0].id;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "tdd_artifacts",
+		reason: extractSqlReason(e)
+	})));
+	const writeTddPhase = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeTddPhase").pipe(Effect.annotateLogs({
+			tddTaskId: input.tddTaskId,
+			phase: input.phase
+		}));
+		const open = yield* sql`
+					SELECT id FROM tdd_phases
+					WHERE tdd_task_id = ${input.tddTaskId} AND ended_at IS NULL
+					ORDER BY started_at DESC LIMIT 1
+				`;
+		const previousPhaseId = open.length === 0 ? null : open[0].id;
+		if (previousPhaseId !== null) yield* sql`
+						UPDATE tdd_phases SET ended_at = ${input.startedAt}
+						WHERE id = ${previousPhaseId}
+					`;
+		return {
+			id: (yield* sql`
+					INSERT INTO tdd_phases
+						(tdd_task_id, behavior_id, phase, started_at, transition_reason, parent_phase_id)
+					VALUES
+						(
+							${input.tddTaskId},
+							${input.behaviorId ?? null},
+							${input.phase},
+							${input.startedAt},
+							${input.transitionReason ?? null},
+							${input.parentPhaseId ?? null}
+						)
+					RETURNING id
+				`)[0].id,
+			previousPhaseId
+		};
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "tdd_phases",
+		reason: extractSqlReason(e)
+	})));
+	const writeCommit = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeCommit").pipe(Effect.annotateLogs({ sha: input.sha }));
+		yield* sql`
+					INSERT INTO commits (sha, parent_sha, message, author, committed_at, branch)
+					VALUES (
+						${input.sha},
+						${input.parentSha ?? null},
+						${input.message ?? null},
+						${input.author ?? null},
+						${input.committedAt ?? null},
+						${input.branch ?? null}
+					)
+					ON CONFLICT(sha) DO NOTHING
+				`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "commits",
+		reason: extractSqlReason(e)
+	})));
+	const writeRunChangedFiles = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("writeRunChangedFiles").pipe(Effect.annotateLogs({
+			runId: input.runId,
+			count: input.files.length
+		}));
+		for (const file of input.files) {
+			const fileId = yield* ensureFile(file.filePath);
+			yield* sql`
+						INSERT INTO run_changed_files (run_id, file_id, change_kind, commit_sha)
+						VALUES (${input.runId}, ${fileId}, ${file.changeKind}, ${file.commitSha ?? null})
+						ON CONFLICT(run_id, file_id) DO UPDATE SET
+							change_kind = excluded.change_kind,
+							commit_sha = excluded.commit_sha
+					`;
+		}
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "run_changed_files",
+		reason: extractSqlReason(e)
+	})));
+	const recordIdempotentResponse = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("recordIdempotentResponse").pipe(Effect.annotateLogs({
+			procedurePath: input.procedurePath,
+			key: input.key
+		}));
+		yield* sql`INSERT INTO mcp_idempotent_responses (procedure_path, key, result_json, created_at) VALUES (${input.procedurePath}, ${input.key}, ${input.resultJson}, ${input.createdAt}) ON CONFLICT(procedure_path, key) DO NOTHING`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "mcp_idempotent_responses",
+		reason: extractSqlReason(e)
+	})));
+	const pruneSessions = (keepRecent) => Effect.gen(function* () {
+		yield* Effect.logDebug("pruneSessions").pipe(Effect.annotateLogs({ keepRecent }));
+		const cutoffRows = yield* sql`
+					SELECT started_at FROM sessions ORDER BY started_at DESC LIMIT 1 OFFSET ${keepRecent}
+				`;
+		if (cutoffRows.length === 0) return {
+			affectedSessions: 0,
+			prunedTurns: 0
+		};
+		const cutoff = cutoffRows[0].started_at;
+		const prunedTurns = (yield* sql`
+					SELECT COUNT(*) AS count FROM turns
+					WHERE session_id IN (SELECT id FROM sessions WHERE started_at <= ${cutoff})
+				`)[0]?.count ?? 0;
+		const affectedSessions = (yield* sql`
+					SELECT COUNT(*) AS count FROM sessions WHERE started_at <= ${cutoff}
+				`)[0]?.count ?? 0;
+		yield* sql`
+					DELETE FROM turns WHERE session_id IN (
+						SELECT id FROM sessions WHERE started_at <= ${cutoff}
+					)
+				`;
+		return {
+			affectedSessions,
+			prunedTurns
+		};
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "turns",
+		reason: extractSqlReason(e)
+	})));
+	const associateLatestRunWithSession = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("associateLatestRunWithSession").pipe(Effect.annotateLogs({
+			chatId: input.chatId,
+			invocationMethod: input.invocationMethod
+		}));
+		yield* sql`
+					INSERT OR IGNORE INTO run_triggers (run_id, trigger, invocation_method, agent_session_id)
+					SELECT r.id, 'agent', ${input.invocationMethod}, s.id
+					FROM (SELECT id FROM test_runs ORDER BY id DESC LIMIT 1) r
+					CROSS JOIN (SELECT id FROM sessions WHERE chat_id = ${input.chatId} LIMIT 1) s
+				`;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "run_triggers",
+		reason: extractSqlReason(e)
+	})));
+	const backfillTestCaseTurns = (chatId) => Effect.gen(function* () {
+		yield* Effect.logDebug("backfillTestCaseTurns").pipe(Effect.annotateLogs({ chatId }));
+		yield* sql`
+					UPDATE test_cases
+					SET created_turn_id = (
+						SELECT t.id
+						FROM turns t
+						JOIN file_edits fe ON fe.turn_id = t.id
+						JOIN files f_edit ON fe.file_id = f_edit.id
+						JOIN sessions s ON t.session_id = s.id
+						WHERE s.chat_id = ${chatId}
+						  AND EXISTS (
+							SELECT 1
+							FROM test_modules tm
+							JOIN files f_mod ON f_mod.id = tm.file_id
+							WHERE tm.id = test_cases.module_id
+							  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 t.occurred_at DESC
+						LIMIT 1
+					)
+					WHERE test_cases.created_turn_id IS NULL
+					  AND test_cases.module_id IN (
+						SELECT id FROM test_modules
+						WHERE run_id = (SELECT id FROM test_runs ORDER BY id DESC LIMIT 1)
+					  )
+				`;
+		return (yield* sql`SELECT changes() AS n`)[0]?.n ?? 0;
+	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
+		operation: "write",
+		table: "test_cases",
+		reason: extractSqlReason(e)
+	})));
+	const registerAgent = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("registerAgent").pipe(Effect.annotateLogs({
+			sessionId: input.sessionId,
+			agentType: input.agentType
+		}));
+		const existing = yield* sql`
+					SELECT agent_id FROM agents WHERE session_id = ${input.sessionId} AND idempotency_key = ${input.idempotencyKey}
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "agents",
+			reason: extractSqlReason(e)
+		})));
+		if (existing.length > 0) return new IdempotencyHit({ existingAgentId: existing[0].agent_id });
+		if (input.parentAgentId !== null) {
+			const parentRows = yield* sql`
+						SELECT session_id FROM agents WHERE agent_id = ${input.parentAgentId}
+					`.pipe(Effect.mapError((e) => new DataStoreError({
+				operation: "read",
+				table: "agents",
+				reason: extractSqlReason(e)
+			})));
+			if (parentRows.length === 0) return yield* Effect.fail(new RegistrationConflictError({ reason: `parent agent ${input.parentAgentId} does not exist` }));
+			const registeringParentSessionId = (yield* sql`
+						SELECT parent_session_id FROM sessions WHERE id = ${input.sessionId} LIMIT 1
+					`.pipe(Effect.mapError((e) => new DataStoreError({
+				operation: "read",
+				table: "sessions",
+				reason: extractSqlReason(e)
+			}))))[0]?.parent_session_id ?? null;
+			const parentSession = parentRows[0].session_id;
+			if (parentSession !== input.sessionId && parentSession !== registeringParentSessionId) return yield* Effect.fail(new RegistrationConflictError({ reason: `parent agent ${input.parentAgentId} belongs to session ${parentSession}, which is neither the registering session ${input.sessionId} nor its parent session ${registeringParentSessionId ?? "(none)"}` }));
+		}
+		const agentId = input.agentId ?? randomUUID();
+		yield* sql`
+					INSERT INTO agents (
+						agent_id, session_id, parent_agent_id, conversation_id, agent_type,
+						started_at, ended_at, start_git_branch, start_git_commit_sha, start_worktree_dir,
+						idempotency_key
+					) VALUES (
+						${agentId}, ${input.sessionId}, ${input.parentAgentId}, ${input.conversationId},
+						${input.agentType}, ${input.startedAt}, ${null}, ${input.startGitBranch ?? null},
+						${input.startGitCommitSha ?? null}, ${input.startWorktreeDir ?? null}, ${input.idempotencyKey}
+					)
+				`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "agents",
+			reason: extractSqlReason(e)
+		})));
+		return new Agent({
+			agentId,
+			sessionId: input.sessionId,
+			parentAgentId: input.parentAgentId,
+			conversationId: input.conversationId,
+			agentType: input.agentType,
+			startedAt: input.startedAt,
+			endedAt: null,
+			startGitBranch: input.startGitBranch ?? null,
+			startGitCommitSha: input.startGitCommitSha ?? null,
+			startWorktreeDir: input.startWorktreeDir ?? null,
+			idempotencyKey: input.idempotencyKey
+		});
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	const endAgent = (agentId, endedAt) => Effect.gen(function* () {
+		yield* Effect.logDebug("endAgent").pipe(Effect.annotateLogs({ agentId }));
+		yield* sql`UPDATE agents SET ended_at = ${endedAt} WHERE agent_id = ${agentId}`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "agents",
+			reason: extractSqlReason(e)
+		})));
+		if (((yield* sql`SELECT changes() AS n`.pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "read",
+			table: "agents",
+			reason: extractSqlReason(e)
+		}))))[0]?.n ?? 0) === 0) return yield* Effect.fail(new AgentNotFoundError({ agentId }));
+	}).pipe(Effect.annotateLogs("service", "DataStore"));
+	return {
+		ensureFile,
+		writeSettings,
+		writeRun,
+		writeModules,
+		writeSuites,
+		writeTestCases,
+		writeErrors,
+		writeAnnotations,
+		writeArtifacts,
+		writeCoverage,
+		writeHistory,
+		writeBaselines,
+		writeThresholds,
+		writeTargets,
+		writeTrends,
+		writeSourceMap,
+		writeNote,
+		updateNote,
+		deleteNote,
+		writeSession,
+		upsertSession,
+		setSessionConversationIdIfNull,
+		writeTurn,
+		writeFailureSignature,
+		endSession,
+		writeHypothesis,
+		validateHypothesis,
+		writeTddTask,
+		endTddTask,
+		createGoal,
+		getGoal,
+		updateGoal,
+		deleteGoal,
+		listGoalsByTddTask,
+		createBehavior,
+		getBehavior,
+		updateBehavior,
+		deleteBehavior,
+		listBehaviorsByGoal,
+		listBehaviorsByTddTask,
+		writeTddPhase,
+		writeTddArtifact,
+		writeCommit,
+		writeRunChangedFiles,
+		recordIdempotentResponse,
+		pruneSessions,
+		associateLatestRunWithSession,
+		backfillTestCaseTurns,
+		registerAgent,
+		endAgent
+	};
+}));
+
+//#endregion
+export { DataStoreLive };