@vitest-agent/sdk 3.1.2 → 4.0.0

package/layers/DataStoreLive.js

@@ -1,1287 +0,0 @@
-import { AgentNotFoundError, RegistrationConflictError } from "../errors/AgentErrors.js";
-import { DataStoreError, extractSqlReason } from "../errors/DataStoreError.js";
-import { BehaviorNotFoundError, GoalNotFoundError, IllegalStatusTransitionError, TddTaskAlreadyEndedError, TddTaskNotFoundError } from "../errors/TddErrors.js";
-import { Agent, IdempotencyHit } from "../schemas/Agent.js";
-import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "../services/DataStore.js";
-import { coerceErrorText } from "../utils/coerce-error-text.js";
-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 };