@vitest-agent/sdk 2.4.12 → 2.5.0

package/layers/DataReaderLive.js

@@ -118,7 +118,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 			lines: 0
 		};
 		const baselineRows = yield* sql`SELECT metric, value FROM coverage_baselines
-					WHERE project = '__global__' AND pattern = ''`;
+					WHERE project = '__global__' AND kind = 'baseline' AND pattern = ''`;
 		const thresholds = {};
 		for (const b of baselineRows) if (b.metric === "lines") thresholds.lines = b.value;
 		else if (b.metric === "functions") thresholds.functions = b.value;
@@ -253,11 +253,21 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		table: "test_history",
 		reason: extractSqlReason(e)
 	})));
-	const getBaselines = (project) => Effect.gen(function* () {
-		yield* Effect.logDebug("getBaselines").pipe(Effect.annotateLogs({ project }));
+	/**
+	* Shared read for the `coverage_baselines` table's per-`kind` rows
+	* (`baseline` / `threshold` / `target`). Returns `Option.none()` when
+	* no rows of that kind were ever persisted, so a caller can tell
+	* "never configured" apart from "configured with zero metrics"
+	* (issue #237).
+	*/
+	const getCoveragePolicy = (kind, project) => Effect.gen(function* () {
+		yield* Effect.logDebug("getCoveragePolicy").pipe(Effect.annotateLogs({
+			kind,
+			project
+		}));
 		const rows = yield* sql`SELECT metric, value, pattern, updated_at
 					FROM coverage_baselines
-					WHERE project = ${project}
+					WHERE project = ${project} AND kind = ${kind}
 					ORDER BY pattern, metric`;
 		if (rows.length === 0) return Option.none();
 		const global = {};
@@ -284,6 +294,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		table: "coverage_baselines",
 		reason: extractSqlReason(e)
 	})));
+	const getBaselines = (project) => getCoveragePolicy("baseline", project);
 	const getTrends = (project, limit) => Effect.gen(function* () {
 		yield* Effect.logDebug("getTrends").pipe(Effect.annotateLogs({
 			project,
@@ -454,7 +465,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 					ORDER BY timestamp DESC LIMIT 1`;
 		if (runs.length === 0) return Option.none();
 		const runId = runs[0].id;
-		const fileCoverageRows = yield* sql`SELECT f.path as file_path, fc.statements, fc.branches, fc.functions, fc.lines, fc.uncovered_lines
+		const fileCoverageRows = yield* sql`SELECT f.path as file_path, fc.statements, fc.branches, fc.functions, fc.lines, fc.uncovered_lines, fc.tier
 					FROM file_coverage fc JOIN files f ON f.id = fc.file_id
 					WHERE fc.run_id = ${runId}`;
 		const trendRows = yield* sql`SELECT statements, branches, functions, lines
@@ -478,13 +489,20 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 				lines: fileCoverageRows.reduce((sum, r) => sum + r.lines, 0) / count
 			};
 		}
-		const baselinesOpt = yield* getBaselines("__global__");
+		const thresholdsOpt = yield* getCoveragePolicy("threshold", "__global__");
+		const targetsOpt = yield* getCoveragePolicy("target", "__global__");
+		const baselinesOpt = yield* getCoveragePolicy("baseline", "__global__");
+		const thresholds = Option.getOrElse(thresholdsOpt, () => ({
+			updatedAt: "",
+			global: {},
+			patterns: []
+		}));
 		const baselines = Option.getOrElse(baselinesOpt, () => ({
 			updatedAt: "",
 			global: {},
 			patterns: []
 		}));
-		const lowCoverage = fileCoverageRows.map((r) => ({
+		const toFileCoverageReport = (r) => ({
 			file: r.file_path,
 			summary: {
 				statements: r.statements,
@@ -493,16 +511,30 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 				lines: r.lines
 			},
 			uncoveredLines: r.uncovered_lines ?? ""
-		}));
+		});
+		const lowCoverage = fileCoverageRows.filter((r) => r.tier === "below_threshold").map(toFileCoverageReport);
+		const belowTarget = fileCoverageRows.filter((r) => r.tier === "below_target").map(toFileCoverageReport);
 		const report = {
 			totals,
 			thresholds: {
+				global: thresholds.global,
+				patterns: thresholds.patterns
+			},
+			...Option.isSome(targetsOpt) ? { targets: {
+				global: targetsOpt.value.global,
+				patterns: targetsOpt.value.patterns
+			} } : {},
+			baselines: {
 				global: baselines.global,
 				patterns: baselines.patterns
 			},
 			scoped: false,
 			lowCoverage,
-			lowCoverageFiles: lowCoverage.map((f) => f.file)
+			lowCoverageFiles: lowCoverage.map((f) => f.file),
+			...belowTarget.length > 0 ? {
+				belowTarget,
+				belowTargetFiles: belowTarget.map((f) => f.file)
+			} : {}
 		};
 		return Option.some(report);
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -895,11 +927,12 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		triageWasNonEmpty: r.triage_was_non_empty === 1,
 		startedAt: r.started_at,
 		endedAt: r.ended_at,
-		endReason: r.end_reason
+		endReason: r.end_reason,
+		conversationId: r.conversation_id
 	});
 	const getSessionById = (id) => Effect.gen(function* () {
 		yield* Effect.logDebug("getSessionById").pipe(Effect.annotateLogs({ id }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason FROM sessions WHERE id = ${id} LIMIT 1`;
+		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE id = ${id} LIMIT 1`;
 		if (rows.length === 0) return Option.none();
 		return Option.some(sessionRowToDetail(rows[0]));
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -909,7 +942,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	})));
 	const getSessionByChatId = (chatId) => Effect.gen(function* () {
 		yield* Effect.logDebug("getSessionByChatId").pipe(Effect.annotateLogs({ chatId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason FROM sessions WHERE chat_id = ${chatId} LIMIT 1`;
+		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE chat_id = ${chatId} LIMIT 1`;
 		if (rows.length === 0) return Option.none();
 		return Option.some(sessionRowToDetail(rows[0]));
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -920,7 +953,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	const findSessionsByChatPrefix = (prefix) => Effect.gen(function* () {
 		yield* Effect.logDebug("findSessionsByChatPrefix").pipe(Effect.annotateLogs({ prefix }));
 		const pattern = `${prefix}%`;
-		return (yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason FROM sessions WHERE chat_id LIKE ${pattern} ESCAPE '\\' ORDER BY started_at DESC`).map(sessionRowToDetail);
+		return (yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE chat_id LIKE ${pattern} ESCAPE '\\' ORDER BY started_at DESC`).map(sessionRowToDetail);
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
 		operation: "read",
 		table: "sessions",
@@ -928,7 +961,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	})));
 	const findActiveSubagentSession = (parentSessionId) => Effect.gen(function* () {
 		yield* Effect.logDebug("findActiveSubagentSession").pipe(Effect.annotateLogs({ parentSessionId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason FROM sessions WHERE parent_session_id = ${parentSessionId} AND agent_kind = 'subagent' AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1`;
+		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE parent_session_id = ${parentSessionId} AND agent_kind = 'subagent' AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1`;
 		if (rows.length === 0) return Option.none();
 		return Option.some(sessionRowToDetail(rows[0]));
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -938,7 +971,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	})));
 	const getSessionByTddTaskId = (tddTaskId) => Effect.gen(function* () {
 		yield* Effect.logDebug("getSessionByTddTaskId").pipe(Effect.annotateLogs({ tddTaskId }));
-		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason FROM sessions WHERE id = (SELECT session_id FROM tdd_tasks WHERE id = ${tddTaskId}) LIMIT 1`;
+		const rows = yield* sql`SELECT id, chat_id, project, cwd, agent_kind, agent_type, parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id FROM sessions WHERE id = (SELECT session_id FROM tdd_tasks WHERE id = ${tddTaskId}) LIMIT 1`;
 		if (rows.length === 0) return Option.none();
 		return Option.some(sessionRowToDetail(rows[0]));
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
@@ -1078,7 +1111,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		const agentKind = options.agentKind ?? null;
 		return (yield* sql`
 					SELECT id, chat_id, project, cwd, agent_kind, agent_type,
-						parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason
+						parent_session_id, triage_was_non_empty, started_at, ended_at, end_reason, conversation_id
 					FROM sessions
 					WHERE (${project} IS NULL OR project = ${project})
 						AND (${agentKind} IS NULL OR agent_kind = ${agentKind})
@@ -1364,7 +1397,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 						END AS test_case_authored_in_session,
 						a.test_run_id,
 						a.test_first_failure_run_id,
-						p.behavior_id
+						p.behavior_id,
+						a.suite
 					FROM tdd_artifacts a
 					JOIN tdd_phases p ON p.id = a.phase_id
 					JOIN tdd_tasks ts ON ts.id = p.tdd_task_id
@@ -1384,7 +1418,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 			test_case_authored_in_session: r.test_case_authored_in_session === 1,
 			test_run_id: r.test_run_id,
 			test_first_failure_run_id: r.test_first_failure_run_id,
-			behavior_id: r.behavior_id
+			behavior_id: r.behavior_id,
+			suite: r.suite
 		});
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
 		operation: "read",
@@ -1427,7 +1462,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 	const listTddTasksForSession = (sessionId, options) => Effect.gen(function* () {
 		yield* Effect.logDebug("listTddTasksForSession").pipe(Effect.annotateLogs({
 			sessionId,
-			walkParents: options?.walkParents ?? false
+			walkParents: options?.walkParents ?? false,
+			walkConversation: options?.walkConversation ?? false
 		}));
 		const sessionIds = [sessionId];
 		if (options?.walkParents === true) {
@@ -1441,9 +1477,23 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 				currentId = next;
 			}
 		}
+		if (options?.walkConversation === true) {
+			const conversationId = (yield* sql`
+							SELECT conversation_id FROM sessions WHERE id = ${sessionId} LIMIT 1
+						`)[0]?.conversation_id ?? null;
+			if (conversationId !== null) {
+				const conversationSessionRows = yield* sql`
+								SELECT id FROM sessions WHERE conversation_id = ${conversationId}
+							`;
+				for (const row of conversationSessionRows) if (!sessionIds.includes(row.id)) sessionIds.push(row.id);
+			}
+		}
 		return (yield* sql`
-					SELECT id, session_id, goal, started_at, ended_at, outcome FROM tdd_tasks
-					WHERE session_id IN ${sql.in(sessionIds)} ORDER BY started_at DESC
+					SELECT t.id, t.session_id, t.goal, t.started_at, t.ended_at, t.outcome, s.agent_kind
+					FROM tdd_tasks t
+					JOIN sessions s ON s.id = t.session_id
+					WHERE t.session_id IN ${sql.in(sessionIds)}
+					ORDER BY (CASE WHEN s.agent_kind = 'main' THEN 0 ELSE 1 END), t.started_at DESC
 				`).map((r) => ({
 			id: r.id,
 			sessionId: r.session_id,
@@ -1457,6 +1507,31 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		table: "tdd_tasks",
 		reason: extractSqlReason(e)
 	})));
+	const countRecentArtifactsInOtherSessionsOfConversation = (input) => Effect.gen(function* () {
+		yield* Effect.logDebug("countRecentArtifactsInOtherSessionsOfConversation").pipe(Effect.annotateLogs(input));
+		const owner = (yield* sql`
+						SELECT t.session_id, s.conversation_id
+						FROM tdd_tasks t
+						JOIN sessions s ON s.id = t.session_id
+						WHERE t.id = ${input.tddTaskId}
+						LIMIT 1
+					`)[0];
+		if (owner === void 0 || owner.conversation_id === null) return 0;
+		return (yield* sql`
+						SELECT COUNT(*) AS n
+						FROM tdd_artifacts a
+						JOIN tdd_phases p ON p.id = a.phase_id
+						JOIN tdd_tasks t ON t.id = p.tdd_task_id
+						JOIN sessions s ON s.id = t.session_id
+						WHERE s.conversation_id = ${owner.conversation_id}
+							AND s.id != ${owner.session_id}
+							AND a.recorded_at >= ${input.sinceIso}
+					`)[0]?.n ?? 0;
+	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
+		operation: "read",
+		table: "tdd_artifacts",
+		reason: extractSqlReason(e)
+	})));
 	const listTddArtifactsForTask = (input) => Effect.gen(function* () {
 		yield* Effect.logDebug("listTddArtifactsForTask").pipe(Effect.annotateLogs(input));
 		const limit = input.limit ?? 50;
@@ -1471,7 +1546,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 						a.test_case_id,
 						a.test_run_id,
 						a.test_first_failure_run_id,
-						a.recorded_at
+						a.recorded_at,
+						a.suite
 					FROM tdd_artifacts a
 					JOIN tdd_phases p ON p.id = a.phase_id
 					WHERE p.tdd_task_id = ${input.tddTaskId}
@@ -1490,7 +1566,8 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 			testCaseId: r.test_case_id,
 			testRunId: r.test_run_id,
 			testFirstFailureRunId: r.test_first_failure_run_id,
-			recordedAt: r.recorded_at
+			recordedAt: r.recorded_at,
+			suite: r.suite
 		}));
 	}).pipe(Effect.annotateLogs("service", "DataReader"), Effect.mapError((e) => new DataStoreError({
 		operation: "read",
@@ -1715,6 +1792,7 @@ const DataReaderLive = Layer.effect(DataReader, Effect.gen(function* () {
 		getTddArtifactWithContext,
 		getCommitChanges,
 		listTddTasksForSession,
+		countRecentArtifactsInOtherSessionsOfConversation,
 		listTddArtifactsForTask,
 		listHypotheses,
 		findIdempotentResponse,

package/layers/DataStoreLive.js

@@ -201,17 +201,50 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		];
 		for (const metric of metrics) {
 			const value = g[metric];
-			if (value !== void 0 && Number.isFinite(value)) yield* sql`INSERT INTO coverage_baselines (project, metric, value, pattern, updated_at) VALUES ('__global__', ${metric}, ${value}, '', ${updatedAt}) ON CONFLICT (project, metric, pattern) DO UPDATE SET value = ${value}, updated_at = ${updatedAt}`;
+			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, metric, value, pattern, updated_at) VALUES ('__global__', ${metric}, ${value}, ${pattern}, ${updatedAt}) ON CONFLICT (project, metric, pattern) DO UPDATE SET value = ${value}, updated_at = ${updatedAt}`;
+			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,
@@ -311,7 +344,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	})));
 	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) VALUES (${input.chatId}, ${input.project}, ${input.cwd}, ${input.agentKind}, ${input.agentType ?? null}, ${input.parentSessionId ?? null}, ${boolToInt(input.triageWasNonEmpty) ?? 0}, ${input.startedAt})`;
+		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",
@@ -320,13 +353,24 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	})));
 	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) VALUES (${input.chatId}, ${input.project}, ${input.cwd}, ${input.agentKind}, ${input.agentType ?? null}, ${input.parentSessionId ?? null}, ${boolToInt(input.triageWasNonEmpty) ?? 0}, ${input.startedAt}) ON CONFLICT(chat_id) DO NOTHING`;
+		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,
@@ -875,7 +919,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		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)
+						 test_first_failure_run_id, diff_excerpt, recorded_at, suite)
 					VALUES
 						(
 							${input.phaseId},
@@ -885,7 +929,8 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 							${input.testRunId ?? null},
 							${input.testFirstFailureRunId ?? null},
 							${truncatedDiff},
-							${input.recordedAt}
+							${input.recordedAt},
+							${input.suite ?? "vitest"}
 						)
 					RETURNING id
 				`)[0].id;
@@ -1151,6 +1196,8 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		writeCoverage,
 		writeHistory,
 		writeBaselines,
+		writeThresholds,
+		writeTargets,
 		writeTrends,
 		writeSourceMap,
 		writeNote,
@@ -1158,6 +1205,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		deleteNote,
 		writeSession,
 		upsertSession,
+		setSessionConversationIdIfNull,
 		writeTurn,
 		writeFailureSignature,
 		endSession,

package/migrations/0001_initial.js

@@ -340,13 +340,16 @@ const migration = Effect.gen(function* () {
 		CREATE TABLE coverage_baselines (
 			id INTEGER PRIMARY KEY AUTOINCREMENT,
 			project TEXT NOT NULL,
+			kind TEXT NOT NULL DEFAULT 'baseline' CHECK (kind IN (
+				'baseline', 'threshold', 'target'
+			)),
 			metric TEXT NOT NULL CHECK (metric IN (
 				'lines', 'functions', 'branches', 'statements'
 			)),
 			value REAL NOT NULL,
 			pattern TEXT NOT NULL DEFAULT '',
 			updated_at TEXT NOT NULL,
-			UNIQUE(project, metric, pattern)
+			UNIQUE(project, kind, metric, pattern)
 		)
 	`;
 	yield* sql`
@@ -691,6 +694,7 @@ const migration = Effect.gen(function* () {
 			test_first_failure_run_id INTEGER REFERENCES test_runs(id) ON DELETE SET NULL,
 			diff_excerpt TEXT,
 			recorded_at TEXT NOT NULL,
+			suite TEXT NOT NULL DEFAULT 'vitest' CHECK (suite IN ('vitest', 'bats')),
 			UNIQUE (phase_id, artifact_kind, file_id, test_run_id)
 		)
 	`;
@@ -764,7 +768,7 @@ const migration = Effect.gen(function* () {
 		CREATE TRIGGER trg_sessions_conv_id_immutable
 		AFTER UPDATE ON sessions
 		FOR EACH ROW
-		WHEN OLD.conversation_id IS NOT NEW.conversation_id
+		WHEN OLD.conversation_id IS NOT NULL AND OLD.conversation_id IS NOT NEW.conversation_id
 		BEGIN
 			SELECT RAISE(ABORT, 'sessions.conversation_id is immutable');
 		END

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/sdk",
-	"version": "2.4.12",
+	"version": "2.5.0",
 	"private": false,
 	"description": "Shared Effect Schema, SQLite migrations, data layer, services, formatters, and utilities for vitest-agent packages.",
 	"keywords": [
@@ -51,7 +51,7 @@
 		"@effected/jsonc": "^0.8.1",
 		"@effected/toml": "^0.5.0",
 		"@effected/walker": "^0.5.0",
-		"@effected/workspaces": "^0.18.3",
+		"@effected/workspaces": "^0.19.0",
 		"@effected/xdg": "^0.3.0",
 		"@effected/yaml": "^0.12.0",
 		"acorn": "^8.18.0",

package/schemas/ConsoleLeaks.js

@@ -14,15 +14,32 @@ const ConsoleLeakFile = Schema.Struct({
 	sample: Schema.optional(Schema.String)
 }).annotate({ identifier: "ConsoleLeakFile" });
 /**
+* Summary of console output logged inside tests that did NOT pass. Kept
+* separate from `total`/`byFile` so it can never be mistaken for a leak in a
+* passing test — assertion-failure logging that routes through `console.*`
+* (common with logger-backed assertion libraries) would otherwise camouflage
+* genuine leaks on every red run.
+* @public
+*/
+const ConsoleLeaksFromFailingTests = Schema.Struct({
+	total: Schema.Number,
+	files: Schema.Number
+}).annotate({ identifier: "ConsoleLeaksFromFailingTests" });
+/**
 * Aggregate stray-console-output signal for a single test run. Omitted from
-* a report entirely when the run produced no user console output.
+* a report entirely when the run produced no user console output at all
+* (neither non-failing nor failing-test writes). `total`/`byFile` count only
+* output from tests that did not fail; `fromFailingTests`, when present,
+* summarizes the output Vitest captured from failing tests so it stays
+* visible without polluting the actionable leak signal (issue #263).
 * @public
 */
 const ConsoleLeaks = Schema.Struct({
 	total: Schema.Number,
 	byFile: Schema.Array(ConsoleLeakFile),
-	truncated: Schema.optional(Schema.Boolean)
+	truncated: Schema.optional(Schema.Boolean),
+	fromFailingTests: Schema.optional(ConsoleLeaksFromFailingTests)
 }).annotate({ identifier: "ConsoleLeaks" });
 
 //#endregion
-export { ConsoleLeakFile, ConsoleLeaks };
+export { ConsoleLeakFile, ConsoleLeaks, ConsoleLeaksFromFailingTests };

package/schemas/Coverage.js

@@ -41,6 +41,7 @@ const CoverageReport = Schema.Struct({
 	})),
 	scoped: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
 	scopedFiles: Schema.optional(Schema.Array(Schema.String)),
+	totalFiles: Schema.optional(Schema.Number),
 	lowCoverage: Schema.Array(FileCoverageReport),
 	lowCoverageFiles: Schema.Array(Schema.String),
 	belowTarget: Schema.optional(Schema.Array(FileCoverageReport)),

package/schemas/RenderState.js

@@ -76,7 +76,10 @@ const CoverageRenderState = Schema.Struct({
 		metric: CoverageMetric,
 		expected: Schema.Number,
 		actual: Schema.Number
-	}))
+	})),
+	scoped: Schema.optional(Schema.Boolean),
+	scopedFiles: Schema.optional(Schema.Number),
+	totalFiles: Schema.optional(Schema.Number)
 }).annotate({ identifier: "CoverageRenderState" });
 /**
 * A `SuggestedAction` event, denormalized into the queue the renderer reads.
@@ -145,7 +148,14 @@ const RenderState = Schema.Struct({
 	* that never carried the field (older replay data, hand-built
 	* fixtures) falls back to `moduleOrder.length`.
 	*/
-	collectedModules: Schema.optional(Schema.Number)
+	collectedModules: Schema.optional(Schema.Number),
+	/**
+	* Process-level errors with no owning module, folded from
+	* `RunFinished.unhandledErrors`. A run that never carried the field
+	* (older replay data, hand-built fixtures) defaults to `[]`. See
+	* issue #240.
+	*/
+	unhandledErrors: Schema.Array(ReportError)
 }).annotate({ identifier: "RenderState" });
 /**
 * Initial state — what the reducer returns when no events have been
@@ -171,7 +181,8 @@ const initialRenderState = {
 	coverage: null,
 	trend: null,
 	failures: [],
-	suggestedActions: []
+	suggestedActions: [],
+	unhandledErrors: []
 };
 
 //#endregion

package/schemas/RunEvent.js

@@ -169,7 +169,10 @@ const RunEvent = Schema.Union([
 	Schema.TaggedStruct("CoverageReady", {
 		metrics: CoverageTotals,
 		thresholds: MetricThresholds,
-		gaps: Schema.Array(CoverageGap)
+		gaps: Schema.Array(CoverageGap),
+		scoped: Schema.optional(Schema.Boolean),
+		scopedFiles: Schema.optional(Schema.Number),
+		totalFiles: Schema.optional(Schema.Number)
 	}),
 	Schema.TaggedStruct("ThresholdViolation", {
 		metric: CoverageMetric,
@@ -202,7 +205,14 @@ const RunEvent = Schema.Union([
 		* true count into `RenderState` even when `moduleOrder` only
 		* tracks failing modules (report replay). See issue #204.
 		*/
-		collectedModules: Schema.optional(Schema.Number)
+		collectedModules: Schema.optional(Schema.Number),
+		/**
+		* Process-level errors with no owning module (an unhandled
+		* rejection, a worker crash) — Vitest's `unhandledErrors`
+		* argument to `onTestRunEnd`. Optional so hand-built fixtures
+		* and older replay data keep decoding. See issue #240.
+		*/
+		unhandledErrors: Schema.optional(Schema.Array(ReportError))
 	})
 ]).annotate({ identifier: "RunEvent" });