@oh-my-pi/omp-stats 18.3.5 → 18.4.0

package/src/db.ts

@@ -10,30 +10,15 @@ import {
 import type { ModelCost } from "@oh-my-pi/pi-catalog/types";
 import { getConfigRootDir, getStatsDbPath } from "@oh-my-pi/pi-utils";
 import { classifyAgentType, type ParseSessionResult, type SessionParserState } from "./parser";
+import { ensureRollupSchema } from "./rollup";
 import type {
 	AgentType,
-	AgentTypeStats,
-	AggregatedStats,
-	BehaviorModelStats,
-	BehaviorOverallStats,
-	BehaviorTimeSeriesPoint,
-	CostTimeSeriesPoint,
 	DailyActivityPoint,
-	FolderStats,
+	FrustrationCounts,
 	MessageStats,
 	MessageStatsInput,
-	ModelPerformancePoint,
-	ModelStats,
-	ModelTimeSeriesPoint,
-	ProviderAggregate,
-	ProviderHourlyPoint,
-	ProviderTimeSeriesPoint,
-	TimeSeriesPoint,
 	ToolCallStats,
-	ToolModelStats,
 	ToolResultLink,
-	ToolTimeSeriesPoint,
-	ToolUsageStats,
 	UserMessageLink,
 	UserMessageStats,
 } from "./types";
@@ -66,13 +51,11 @@ const ZERO_USAGE_COST: UsageCost = {
  * parser's timestamp sentinel, because their zero is a real price.
  * `prefix` qualifies the columns for queries that alias `messages`.
  */
-function unpricedRequestSql(prefix = ""): string {
+export function unpricedRequestSql(prefix = ""): string {
 	return `CASE WHEN ${prefix}total_tokens > 0 AND ${prefix}cost_total = 0
 		AND (${prefix}provider = 'xai-oauth' OR ${prefix}cost_unpriced = 1) THEN 1 ELSE 0 END`;
 }
 
-const UNPRICED_REQUEST_SQL = unpricedRequestSql();
-
 interface CostBackfillRow {
 	id: number;
 	provider: string;
@@ -94,52 +77,16 @@ interface NoCacheInputCostBackfillRow {
 	cache_write_tokens: number;
 }
 
-interface AggregatedStatsRow {
-	total_requests: number;
-	failed_requests: number | null;
-	total_input_tokens: number | null;
-	total_output_tokens: number | null;
-	total_cache_read_tokens: number | null;
-	total_cache_write_tokens: number | null;
-	total_premium_requests: number | null;
-	total_cost: number | null;
-	unpriced_requests: number | null;
-	total_cached_prompt_cost: number | null;
-	total_no_cache_input_cost: number | null;
-	avg_duration: number | null;
-	avg_ttft: number | null;
-	avg_tokens_per_second: number | null;
-	first_timestamp: number | null;
-	last_timestamp: number | null;
-}
-
-interface ModelStatsRow extends AggregatedStatsRow {
-	model: string;
-	provider: string;
-}
-
-interface FolderStatsRow extends AggregatedStatsRow {
-	folder: string;
-}
+let db: Database | null = null;
 
-interface CostTimeSeriesRow {
-	bucket: number;
-	model: string;
-	provider: string;
-	cost: number | null;
-	unpriced_requests: number | null;
-	cost_input: number | null;
-	cost_output: number | null;
-	cost_cache_read: number | null;
-	cost_cache_write: number | null;
-	requests: number;
+/** The open stats database, or null before {@link initDb}. Used by the rollup query layer. */
+export function currentDb(): Database | null {
+	return db;
 }
 
-let db: Database | null = null;
-
 const BACKFILL_COMPLETE = "complete";
 const BACKFILL_PENDING = "pending";
-const USER_MESSAGES_BACKFILL_KEY = "user_messages_v8";
+const USER_MESSAGES_BACKFILL_KEY = "user_messages_v9";
 const USER_MESSAGE_LINKS_REPAIR_KEY = "user_message_links_v1";
 const PRIORITY_PREMIUM_REQUESTS_BACKFILL_KEY = "premium_requests_priority_v1";
 const AGENT_TYPE_BACKFILL_KEY = "agent_type_v1";
@@ -246,6 +193,8 @@ export async function initDb(): Promise<Database> {
 			negation INTEGER NOT NULL DEFAULT 0,
 			repetition INTEGER NOT NULL DEFAULT 0,
 			blame INTEGER NOT NULL DEFAULT 0,
+			prose TEXT NOT NULL DEFAULT '',
+			prose_hash TEXT NOT NULL DEFAULT '',
 			UNIQUE(session_file, entry_id)
 		);
 
@@ -253,6 +202,17 @@ export async function initDb(): Promise<Database> {
 		CREATE INDEX IF NOT EXISTS idx_user_messages_entry_timestamp ON user_messages(entry_id, timestamp);
 		CREATE INDEX IF NOT EXISTS idx_user_messages_timestamp_model ON user_messages(timestamp, model, provider);
 
+		-- Judge verdicts keyed by prose hash: identical messages share one verdict,
+		-- and verdicts outlive user_messages re-parses. No backfill wipes this table.
+		CREATE TABLE IF NOT EXISTS frustration_verdicts (
+			prose_hash TEXT PRIMARY KEY,
+			p_annoyed REAL NOT NULL,
+			p_angry REAL NOT NULL,
+			target TEXT NOT NULL,
+			judge TEXT NOT NULL,
+			judged_at INTEGER NOT NULL
+		);
+
 		CREATE TABLE IF NOT EXISTS tool_calls (
 			id INTEGER PRIMARY KEY AUTOINCREMENT,
 			session_file TEXT NOT NULL,
@@ -367,12 +327,20 @@ export async function initDb(): Promise<Database> {
 				negation INTEGER NOT NULL DEFAULT 0,
 				repetition INTEGER NOT NULL DEFAULT 0,
 				blame INTEGER NOT NULL DEFAULT 0,
+				prose TEXT NOT NULL DEFAULT '',
+				prose_hash TEXT NOT NULL DEFAULT '',
 				UNIQUE(session_file, entry_id)
 			);
 			CREATE INDEX IF NOT EXISTS idx_user_messages_timestamp ON user_messages(timestamp);
 			CREATE INDEX IF NOT EXISTS idx_user_messages_timestamp_model ON user_messages(timestamp, model, provider);
 		`);
+	} else if (!userMessageColumns.some(column => column.name === "prose")) {
+		// v9 judge prose: the backfill below clears the rows, so defaults are
+		// only placeholders until the re-parse repopulates them.
+		db.run("ALTER TABLE user_messages ADD COLUMN prose TEXT NOT NULL DEFAULT ''");
+		db.run("ALTER TABLE user_messages ADD COLUMN prose_hash TEXT NOT NULL DEFAULT ''");
 	}
+	db.run("CREATE INDEX IF NOT EXISTS idx_user_messages_prose_hash ON user_messages(prose_hash)");
 	backfillUserMessages(db);
 	backfillToolCalls(db);
 	backfillReingestCosts(db);
@@ -383,6 +351,7 @@ export async function initDb(): Promise<Database> {
 	backfillMissingCatalogCosts(db);
 	backfillNoCacheInputCosts(db);
 	backfillForkDuplicates(db);
+	ensureRollupSchema(db);
 	return db;
 }
 
@@ -598,23 +567,25 @@ function backfillNoCacheInputCosts(database: Database): void {
 	applyBackfill();
 }
 
-/**
- * Get the stored offset for a session file.
- */
-export function getFileOffset(
-	sessionFile: string,
-): { offset: number; lastModified: number; parserState?: SessionParserState } | null {
-	if (!db) return null;
+/** Persisted transcript identity and parser cursor used to resume stats ingestion. */
+export interface FileOffset {
+	offset: number;
+	lastModified: number;
+	parserState?: SessionParserState;
+}
 
-	const stmt = db.prepare("SELECT offset, last_modified, parser_state FROM file_offsets WHERE session_file = ?");
-	const row = stmt.get(sessionFile) as
-		| { offset: number; last_modified: number; parser_state: string | null }
-		| undefined;
-	if (!row) return null;
+interface FileOffsetRow {
+	session_file: string;
+	offset: number;
+	last_modified: number;
+	parser_state: string | null;
+}
+
+function decodeFileOffset(row: FileOffsetRow): FileOffset {
 	let parserState: SessionParserState | undefined;
 	if (row.parser_state) {
 		try {
-			const state = JSON.parse(row.parser_state) as SessionParserState;
+			const state: SessionParserState = JSON.parse(row.parser_state);
 			if (state?.version === 1 && state.offset === row.offset) parserState = state;
 		} catch {
 			/* A missing cursor is reconstructed from the transcript. */
@@ -623,6 +594,31 @@ export function getFileOffset(
 	return { offset: row.offset, lastModified: row.last_modified, parserState };
 }
 
+/** Read one persisted cursor for callers inspecting an individual transcript. */
+export function getFileOffset(sessionFile: string): FileOffset | null {
+	if (!db) return null;
+	const row = db
+		.query<FileOffsetRow, [string]>(
+			"SELECT session_file, offset, last_modified, parser_state FROM file_offsets WHERE session_file = ?",
+		)
+		.get(sessionFile);
+	return row ? decodeFileOffset(row) : null;
+}
+
+/** Read a bounded sync work set's cursors with one SQLite snapshot instead of one lookup per file. */
+export function getFileOffsets(sessionFiles: string[]): Map<string, FileOffset> {
+	const offsets = new Map<string, FileOffset>();
+	if (!db || sessionFiles.length === 0) return offsets;
+	const placeholders = sessionFiles.map(() => "?").join(",");
+	const rows = db
+		.query<FileOffsetRow, string[]>(
+			`SELECT session_file, offset, last_modified, parser_state FROM file_offsets WHERE session_file IN (${placeholders})`,
+		)
+		.all(...sessionFiles);
+	for (const row of rows) offsets.set(row.session_file, decodeFileOffset(row));
+	return offsets;
+}
+
 /**
  * Update the stored offset for a session file.
  */
@@ -634,62 +630,168 @@ export function setFileOffset(
 ): void {
 	if (!db) return;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		INSERT OR REPLACE INTO file_offsets (session_file, offset, last_modified, parser_state)
 		VALUES (?, ?, ?, ?)
 	`);
 	stmt.run(sessionFile, offset, lastModified, parserState ? JSON.stringify(parserState) : null);
 }
 
-export function applySessionParseResult(
-	sessionFile: string,
-	result: ParseSessionResult,
-	rebuild = false,
-): { processed: number; reconcile: boolean } {
-	const parserState = result.parserState;
-	if (!db || !parserState) return { processed: 0, reconcile: false };
+/** Parsed transcript queued by the sync loop for an atomic database batch. */
+export interface ParsedSession {
+	sessionFile: string;
+	result: ParseSessionResult;
+	rebuild: boolean;
+	/** Recover missing rows from a full-history scan without rewriting unchanged records. */
+	replay: boolean;
+}
+
+function* parsedRows<T>(
+	results: ParseSessionResult[],
+	select: (result: ParseSessionResult) => Iterable<T>,
+): Generator<T> {
+	for (const result of results) yield* select(result);
+}
+
+/** Commit distinct transcripts' rows, reconciliation state, and cursors together; failure rolls back the batch. */
+export function applySessionParseResults(sessions: ParsedSession[]): {
+	processed: number;
+	files: number;
+	reconcile: boolean;
+} {
+	if (!db) return { processed: 0, files: 0, reconcile: false };
 	const database = db;
 	return database.transaction(() => {
-		let reconcile = result.reset ?? false;
-		if (result.reset || rebuild) {
-			const retainedMessages = new Set(result.stats.map(row => JSON.stringify([row.entryId, row.timestamp])));
-			const retainedUsers = new Set(result.userStats.map(row => JSON.stringify([row.entryId, row.timestamp])));
-			const retainedTools = new Set(
-				result.toolCalls.map(row => JSON.stringify([row.entryId, row.timestamp, row.toolCallId])),
-			);
-			const messages = database
-				.prepare("SELECT entry_id, timestamp FROM messages WHERE session_file = ?")
-				.all(sessionFile) as {
-				entry_id: string;
-				timestamp: number;
-			}[];
-			const users = database
-				.prepare("SELECT entry_id, timestamp FROM user_messages WHERE session_file = ?")
-				.all(sessionFile) as { entry_id: string; timestamp: number }[];
-			const tools = database
-				.prepare("SELECT entry_id, timestamp, tool_call_id FROM tool_calls WHERE session_file = ?")
-				.all(sessionFile) as { entry_id: string; timestamp: number; tool_call_id: string }[];
-			// A removed owner may have surviving fork copies skipped earlier in this pass.
-			reconcile ||=
-				messages.some(row => !retainedMessages.has(JSON.stringify([row.entry_id, row.timestamp]))) ||
-				users.some(row => !retainedUsers.has(JSON.stringify([row.entry_id, row.timestamp]))) ||
-				tools.some(row => !retainedTools.has(JSON.stringify([row.entry_id, row.timestamp, row.tool_call_id])));
-			database.prepare("DELETE FROM messages WHERE session_file = ?").run(sessionFile);
-			database.prepare("DELETE FROM user_messages WHERE session_file = ?").run(sessionFile);
-			database.prepare("DELETE FROM tool_calls WHERE session_file = ?").run(sessionFile);
+		let processed = 0;
+		let files = 0;
+		let reconcile = false;
+		const writes: ParseSessionResult[] = [];
+		for (const { sessionFile, result, rebuild, replay } of sessions) {
+			const parserState = result.parserState;
+			if (!parserState) continue;
+			let rows = result;
+			if (result.reset || rebuild || replay) {
+				const messages = database
+					.query<{ entry_id: string; timestamp: number }, [string]>(
+						"SELECT entry_id, timestamp FROM messages WHERE session_file = ?",
+					)
+					.all(sessionFile);
+				const users = database
+					.query<{ entry_id: string; timestamp: number; model: string | null }, [string]>(
+						"SELECT entry_id, timestamp, model FROM user_messages WHERE session_file = ?",
+					)
+					.all(sessionFile);
+				const tools = database
+					.query<
+						{ entry_id: string; timestamp: number; tool_call_id: string; result_chars: number | null },
+						[string]
+					>("SELECT entry_id, timestamp, tool_call_id, result_chars FROM tool_calls WHERE session_file = ?")
+					.all(sessionFile);
+				const replace = result.reset || rebuild;
+				if (replace) {
+					// Only removed owners require another full replay, not an identity-only file replacement.
+					if (!reconcile && (messages.length > 0 || users.length > 0 || tools.length > 0)) {
+						const retainedMessages = new Set(
+							result.stats.map(row => JSON.stringify([row.entryId, row.timestamp])),
+						);
+						const retainedUsers = new Set(
+							result.userStats.map(row => JSON.stringify([row.entryId, row.timestamp])),
+						);
+						const retainedTools = new Set(
+							result.toolCalls.map(row => JSON.stringify([row.entryId, row.timestamp, row.toolCallId])),
+						);
+						reconcile =
+							messages.some(row => !retainedMessages.has(JSON.stringify([row.entry_id, row.timestamp]))) ||
+							users.some(row => !retainedUsers.has(JSON.stringify([row.entry_id, row.timestamp]))) ||
+							tools.some(
+								row => !retainedTools.has(JSON.stringify([row.entry_id, row.timestamp, row.tool_call_id])),
+							);
+					}
+				} else {
+					// A reconciliation replay only needs missing rows and unfinished links. Keep stable request
+					// IDs and avoid rewriting every table/index for transcripts whose contents did not change.
+					const messageById = new Map(messages.map(row => [row.entry_id, row.timestamp]));
+					const userById = new Map(users.map(row => [row.entry_id, row]));
+					const toolById = new Map(tools.map(row => [row.tool_call_id, row]));
+					const absentMessages = new Set(messageById.keys());
+					const absentUsers = new Set(userById.keys());
+					const absentTools = new Set(toolById.keys());
+					const stats = result.stats.filter(row => {
+						if (messageById.get(row.entryId) !== row.timestamp) return true;
+						absentMessages.delete(row.entryId);
+						return false;
+					});
+					const userStats = result.userStats.filter(row => {
+						if (userById.get(row.entryId)?.timestamp !== row.timestamp) return true;
+						absentUsers.delete(row.entryId);
+						return false;
+					});
+					const toolCalls = result.toolCalls.filter(row => {
+						const stored = toolById.get(row.toolCallId);
+						if (stored?.entry_id !== row.entryId || stored.timestamp !== row.timestamp) return true;
+						absentTools.delete(row.toolCallId);
+						return false;
+					});
+					rows = {
+						...result,
+						stats,
+						userStats,
+						toolCalls,
+						// A reused ID needs fresh linkage after its old identity is removed.
+						userLinks: result.userLinks.filter(
+							row => absentUsers.has(row.entryId) || userById.get(row.entryId)?.model == null,
+						),
+						toolResults: result.toolResults.filter(
+							row => absentTools.has(row.toolCallId) || toolById.get(row.toolCallId)?.result_chars == null,
+						),
+					};
+					// Repair stale owners without invalidating IDs of records still present in the transcript.
+					if (absentMessages.size > 0 || absentUsers.size > 0 || absentTools.size > 0) {
+						reconcile = true;
+						for (const id of absentMessages) {
+							database
+								.query("DELETE FROM messages WHERE session_file = ? AND entry_id = ?")
+								.run(sessionFile, id);
+						}
+						for (const id of absentUsers) {
+							database
+								.query("DELETE FROM user_messages WHERE session_file = ? AND entry_id = ?")
+								.run(sessionFile, id);
+						}
+						for (const id of absentTools) {
+							database
+								.query("DELETE FROM tool_calls WHERE session_file = ? AND tool_call_id = ?")
+								.run(sessionFile, id);
+						}
+					}
+				}
+				if (replace) {
+					if (messages.length > 0) database.query("DELETE FROM messages WHERE session_file = ?").run(sessionFile);
+					if (users.length > 0)
+						database.query("DELETE FROM user_messages WHERE session_file = ?").run(sessionFile);
+					if (tools.length > 0) database.query("DELETE FROM tool_calls WHERE session_file = ?").run(sessionFile);
+				}
+			}
+			writes.push(rows);
+			const count = rows.stats.length + rows.userStats.length;
+			processed += count;
+			if (count > 0) files++;
+		}
+		// Remove replaced rows before choosing new fork owners, then write each table once per batch.
+		insertMessageStats(parsedRows(writes, result => result.stats));
+		insertUserMessageStats(parsedRows(writes, result => result.userStats));
+		updateUserMessageLinks(parsedRows(writes, result => result.userLinks));
+		insertToolCalls(parsedRows(writes, result => result.toolCalls));
+		updateToolResults(parsedRows(writes, result => result.toolResults));
+		for (const { sessionFile, result } of sessions) {
+			if (result.parserState) {
+				setFileOffset(sessionFile, result.newOffset, result.parserState.mtimeMs, result.parserState);
+			}
 		}
 		if (reconcile) {
-			database
-				.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('session_reconciliation', 'pending')")
-				.run();
+			database.query("INSERT OR REPLACE INTO meta (key, value) VALUES ('session_reconciliation', 'pending')").run();
 		}
-		if (result.stats.length > 0) insertMessageStats(result.stats);
-		if (result.userStats.length > 0) insertUserMessageStats(result.userStats);
-		if (result.userLinks.length > 0) updateUserMessageLinks(result.userLinks);
-		if (result.toolCalls.length > 0) insertToolCalls(result.toolCalls);
-		if (result.toolResults.length > 0) updateToolResults(result.toolResults);
-		setFileOffset(sessionFile, result.newOffset, parserState.mtimeMs, parserState);
-		return { processed: result.stats.length + result.userStats.length, reconcile };
+		return { processed, files, reconcile };
 	})();
 }
 
@@ -717,10 +819,10 @@ export function completeSessionSync(reconcile: boolean): void {
  * stored cost (orchestration-aware) and keeps `premium_requests` monotonic, so
  * a forced re-parse repairs historical `premium_requests` and cost fix-ups.
  */
-export function insertMessageStats(stats: MessageStatsInput[]): number {
-	if (!db || stats.length === 0) return 0;
+export function insertMessageStats(stats: Iterable<MessageStatsInput>): number {
+	if (!db) return 0;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		INSERT INTO messages (
 			session_file, entry_id, folder, model, provider, api, timestamp,
 			duration, ttft, stop_reason, error_message,
@@ -789,483 +891,6 @@ export function insertMessageStats(stats: MessageStatsInput[]): number {
 	return inserted;
 }
 
-/**
- * Build aggregated stats from query results.
- */
-function buildAggregatedStats(rows: AggregatedStatsRow[]): AggregatedStats {
-	if (rows.length === 0) {
-		return {
-			totalRequests: 0,
-			successfulRequests: 0,
-			failedRequests: 0,
-			errorRate: 0,
-			totalInputTokens: 0,
-			totalOutputTokens: 0,
-			totalCacheReadTokens: 0,
-			totalCacheWriteTokens: 0,
-			cacheRate: 0,
-			cacheSavings: 0,
-			totalCost: 0,
-			unpricedRequests: 0,
-			totalPremiumRequests: 0,
-			avgDuration: null,
-			avgTtft: null,
-			avgTokensPerSecond: null,
-			firstTimestamp: 0,
-			lastTimestamp: 0,
-		};
-	}
-
-	const row = rows[0];
-	const totalRequests = row.total_requests || 0;
-	const failedRequests = row.failed_requests || 0;
-	const successfulRequests = totalRequests - failedRequests;
-	const totalInputTokens = row.total_input_tokens || 0;
-	const totalCacheReadTokens = row.total_cache_read_tokens || 0;
-	const totalPremiumRequests = row.total_premium_requests || 0;
-	const noCacheInputCost = row.total_no_cache_input_cost || 0;
-	const cachedPromptCost = row.total_cached_prompt_cost || 0;
-
-	return {
-		totalRequests,
-		successfulRequests,
-		failedRequests,
-		errorRate: totalRequests > 0 ? failedRequests / totalRequests : 0,
-		totalInputTokens,
-		totalOutputTokens: row.total_output_tokens || 0,
-		totalCacheReadTokens,
-		totalCacheWriteTokens: row.total_cache_write_tokens || 0,
-		cacheRate:
-			totalInputTokens + totalCacheReadTokens > 0
-				? totalCacheReadTokens / (totalInputTokens + totalCacheReadTokens)
-				: 0,
-		cacheSavings: noCacheInputCost > 0 ? (noCacheInputCost - cachedPromptCost) / noCacheInputCost : 0,
-		totalCost: row.total_cost || 0,
-		unpricedRequests: row.unpriced_requests || 0,
-		totalPremiumRequests,
-		avgDuration: row.avg_duration,
-		avgTtft: row.avg_ttft,
-		avgTokensPerSecond: row.avg_tokens_per_second,
-		firstTimestamp: row.first_timestamp || 0,
-		lastTimestamp: row.last_timestamp || 0,
-	};
-}
-
-/**
- * Get overall aggregated stats.
- */
-export function getOverallStats(cutoff?: number): AggregatedStats {
-	if (!db) return buildAggregatedStats([]);
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			COUNT(*) as total_requests,
-			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
-			SUM(input_tokens) as total_input_tokens,
-			SUM(output_tokens) as total_output_tokens,
-			SUM(cache_read_tokens) as total_cache_read_tokens,
-			SUM(cache_write_tokens) as total_cache_write_tokens,
-			SUM(premium_requests) as total_premium_requests,
-			SUM(cost_total) as total_cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			SUM(CASE WHEN cost_no_cache_input > 0
-				THEN cost_input + cost_cache_read + cost_cache_write
-				ELSE 0 END) as total_cached_prompt_cost,
-			SUM(cost_no_cache_input) as total_no_cache_input_cost,
-			AVG(duration) as avg_duration,
-			AVG(ttft) as avg_ttft,
-			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
-			MIN(timestamp) as first_timestamp,
-			MAX(timestamp) as last_timestamp
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-	`);
-
-	const rows = hasCutoff ? stmt.all(cutoff) : stmt.all();
-	return buildAggregatedStats(rows as AggregatedStatsRow[]);
-}
-/**
- * Get stats grouped by model.
- */
-export function getStatsByModel(cutoff?: number): ModelStats[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			model,
-			provider,
-			COUNT(*) as total_requests,
-			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
-			SUM(input_tokens) as total_input_tokens,
-			SUM(output_tokens) as total_output_tokens,
-			SUM(cache_read_tokens) as total_cache_read_tokens,
-			SUM(cache_write_tokens) as total_cache_write_tokens,
-			SUM(premium_requests) as total_premium_requests,
-			SUM(cost_total) as total_cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			SUM(CASE WHEN cost_no_cache_input > 0
-				THEN cost_input + cost_cache_read + cost_cache_write
-				ELSE 0 END) as total_cached_prompt_cost,
-			SUM(cost_no_cache_input) as total_no_cache_input_cost,
-			AVG(duration) as avg_duration,
-			AVG(ttft) as avg_ttft,
-			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
-			MIN(timestamp) as first_timestamp,
-			MAX(timestamp) as last_timestamp
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY model, provider
-		ORDER BY total_requests DESC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as ModelStatsRow[];
-	return rows.map(row => ({
-		model: row.model,
-		provider: row.provider,
-		...buildAggregatedStats([row]),
-	}));
-}
-
-/**
- * Get stats grouped by folder.
- */
-export function getStatsByFolder(cutoff?: number): FolderStats[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			folder,
-			COUNT(*) as total_requests,
-			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
-			SUM(input_tokens) as total_input_tokens,
-			SUM(output_tokens) as total_output_tokens,
-			SUM(cache_read_tokens) as total_cache_read_tokens,
-			SUM(cache_write_tokens) as total_cache_write_tokens,
-			SUM(premium_requests) as total_premium_requests,
-			SUM(cost_total) as total_cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			SUM(CASE WHEN cost_no_cache_input > 0
-				THEN cost_input + cost_cache_read + cost_cache_write
-				ELSE 0 END) as total_cached_prompt_cost,
-			SUM(cost_no_cache_input) as total_no_cache_input_cost,
-			AVG(duration) as avg_duration,
-			AVG(ttft) as avg_ttft,
-			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
-			MIN(timestamp) as first_timestamp,
-			MAX(timestamp) as last_timestamp
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY folder
-		ORDER BY total_requests DESC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as FolderStatsRow[];
-	return rows.map(row => ({
-		folder: row.folder,
-		...buildAggregatedStats([row]),
-	}));
-}
-
-/**
- * Get token usage grouped by agent type (main agent, task subagents, advisor).
- * Token columns are explicit so the dashboard's share denominator matches the
- * counts it renders. Rows missing `agent_type` (defensive) fall back to "main".
- */
-export function getStatsByAgentType(cutoff?: number): AgentTypeStats[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			agent_type,
-			COUNT(*) as total_requests,
-			SUM(input_tokens) as total_input_tokens,
-			SUM(output_tokens) as total_output_tokens,
-			SUM(cache_read_tokens) as total_cache_read_tokens,
-			SUM(cache_write_tokens) as total_cache_write_tokens,
-			SUM(cost_total) as total_cost
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY agent_type
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as any[];
-	return rows.map(row => ({
-		agentType: (row.agent_type as AgentType) ?? "main",
-		totalRequests: row.total_requests || 0,
-		totalInputTokens: row.total_input_tokens || 0,
-		totalOutputTokens: row.total_output_tokens || 0,
-		totalCacheReadTokens: row.total_cache_read_tokens || 0,
-		totalCacheWriteTokens: row.total_cache_write_tokens || 0,
-		totalCost: row.total_cost || 0,
-	}));
-}
-
-/**
- * Get time series data.
- */
-export function getTimeSeries(hours = 24, cutoff?: number | null, bucketMs = 60 * 60 * 1000): TimeSeriesPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - hours * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / ?) * ? as bucket,
-			COUNT(*) as requests,
-			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as errors,
-			SUM(total_tokens) as tokens,
-			SUM(cost_total) as cost
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket
-		ORDER BY bucket ASC
-	`);
-
-	const rows = hasCutoff
-		? (stmt.all(bucketMs, bucketMs, seriesCutoff) as any[])
-		: (stmt.all(bucketMs, bucketMs) as any[]);
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		requests: row.requests,
-		errors: row.errors,
-		tokens: row.tokens,
-		cost: row.cost,
-	}));
-}
-
-/**
- * Get daily performance time series data for the last N days.
- */
-/**
- * Get daily model usage time series data for the last N days.
- */
-export function getModelTimeSeries(
-	days = 14,
-	cutoff?: number | null,
-	bucketMs = 24 * 60 * 60 * 1000,
-): ModelTimeSeriesPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - days * 24 * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / ?) * ? as bucket,
-			model,
-			provider,
-			COUNT(*) as requests
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, model, provider
-		ORDER BY bucket ASC
-	`);
-
-	const rowsRaw = hasCutoff ? stmt.all(bucketMs, bucketMs, seriesCutoff) : stmt.all(bucketMs, bucketMs);
-	const rows = rowsRaw as Array<{ bucket: number; model: string; provider: string; requests: number }>;
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		model: row.model,
-		provider: row.provider,
-		requests: row.requests,
-	}));
-}
-
-/**
- * Get request/token/cost totals grouped by provider.
- */
-export function getStatsByProvider(cutoff?: number | null): ProviderAggregate[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff !== null && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			provider,
-			COUNT(*) as total_requests,
-			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
-			COUNT(DISTINCT model) as models,
-			SUM(input_tokens) as total_input_tokens,
-			SUM(output_tokens) as total_output_tokens,
-			SUM(cache_read_tokens) as total_cache_read_tokens,
-			SUM(cache_write_tokens) as total_cache_write_tokens,
-			SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) as total_tokens,
-			SUM(cost_total) as total_cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			SUM(premium_requests) as total_premium_requests,
-			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY provider
-		ORDER BY total_tokens DESC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as Array<{
-		provider: string;
-		total_requests: number;
-		failed_requests: number;
-		models: number;
-		total_input_tokens: number | null;
-		total_output_tokens: number | null;
-		total_cache_read_tokens: number | null;
-		total_cache_write_tokens: number | null;
-		total_tokens: number | null;
-		total_cost: number | null;
-		unpriced_requests: number | null;
-		total_premium_requests: number | null;
-		avg_tokens_per_second: number | null;
-	}>;
-	return rows.map(row => ({
-		provider: row.provider,
-		totalRequests: row.total_requests,
-		failedRequests: row.failed_requests,
-		models: row.models,
-		totalInputTokens: row.total_input_tokens ?? 0,
-		totalOutputTokens: row.total_output_tokens ?? 0,
-		totalCacheReadTokens: row.total_cache_read_tokens ?? 0,
-		totalCacheWriteTokens: row.total_cache_write_tokens ?? 0,
-		totalTokens: row.total_tokens ?? 0,
-		totalCost: row.total_cost ?? 0,
-		unpricedRequests: row.unpriced_requests ?? 0,
-		totalPremiumRequests: row.total_premium_requests ?? 0,
-		avgTokensPerSecond: row.avg_tokens_per_second,
-	}));
-}
-
-/**
- * Get token burn grouped by provider and local hour of day (0-23).
- * Hours use the server's timezone — the dashboard is a localhost tool, so
- * server-local and viewer-local time coincide.
- */
-export function getProviderHourlyBurn(cutoff?: number | null): ProviderHourlyPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff !== null && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			provider,
-			CAST(strftime('%H', timestamp / 1000, 'unixepoch', 'localtime') AS INTEGER) as hour,
-			SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) as total_tokens,
-			SUM(output_tokens) as output_tokens,
-			COUNT(*) as requests
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY provider, hour
-		ORDER BY provider, hour
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as Array<{
-		provider: string;
-		hour: number;
-		total_tokens: number | null;
-		output_tokens: number | null;
-		requests: number;
-	}>;
-	return rows.map(row => ({
-		provider: row.provider,
-		hour: row.hour,
-		totalTokens: row.total_tokens ?? 0,
-		outputTokens: row.output_tokens ?? 0,
-		requests: row.requests,
-	}));
-}
-
-/**
- * Get token/cost time series grouped by provider (bucketed like the model series).
- */
-export function getProviderTimeSeries(
-	days = 14,
-	cutoff?: number | null,
-	bucketMs = 24 * 60 * 60 * 1000,
-): ProviderTimeSeriesPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - days * 24 * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / ?) * ? as bucket,
-			provider,
-			SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) as total_tokens,
-			SUM(cost_total) as cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			COUNT(*) as requests
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, provider
-		ORDER BY bucket ASC
-	`);
-
-	const rowsRaw = hasCutoff ? stmt.all(bucketMs, bucketMs, seriesCutoff) : stmt.all(bucketMs, bucketMs);
-	const rows = rowsRaw as Array<{
-		bucket: number;
-		provider: string;
-		total_tokens: number | null;
-		cost: number | null;
-		unpriced_requests: number | null;
-		requests: number;
-	}>;
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		provider: row.provider,
-		totalTokens: row.total_tokens ?? 0,
-		cost: row.cost ?? 0,
-		unpricedRequests: row.unpriced_requests ?? 0,
-		requests: row.requests,
-	}));
-}
-
-/**
- * Get daily model performance time series data for the last N days.
- */
-export function getModelPerformanceSeries(
-	days = 14,
-	cutoff?: number | null,
-	bucketMs = 24 * 60 * 60 * 1000,
-): ModelPerformancePoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - days * 24 * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / ?) * ? as bucket,
-			model,
-			provider,
-			COUNT(*) as requests,
-			AVG(ttft) as avg_ttft,
-			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, model, provider
-		ORDER BY bucket ASC
-	`);
-
-	const rowsRaw = hasCutoff ? stmt.all(bucketMs, bucketMs, seriesCutoff) : stmt.all(bucketMs, bucketMs);
-	const rows = rowsRaw as Array<{
-		bucket: number;
-		model: string;
-		provider: string;
-		requests: number;
-		avg_ttft: number | null;
-		avg_tokens_per_second: number | null;
-	}>;
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		model: row.model,
-		provider: row.provider,
-		requests: row.requests,
-		avgTtft: row.avg_ttft,
-		avgTokensPerSecond: row.avg_tokens_per_second,
-	}));
-}
-
 /**
  * Get total message count.
  */
@@ -1350,92 +975,6 @@ export function getMessageById(id: number): MessageStats | null {
 	const row = stmt.get(id);
 	return row ? rowToMessageStats(row) : null;
 }
-/** Per-transcript-file rollup for the Traces session list. */
-export interface SessionRollupRow {
-	sessionFile: string;
-	requests: number;
-	startedAt: number;
-	endedAt: number;
-	totalTokens: number;
-	costTotal: number;
-	unpricedRequests: number;
-	/** Comma-joined DISTINCT models. */
-	models: string;
-}
-
-/** Aggregate every synced transcript file into one row (subagents unfolded). */
-export function getSessionRollups(): SessionRollupRow[] {
-	if (!db) return [];
-	const stmt = db.prepare(`
-		SELECT session_file AS sessionFile,
-		       COUNT(*) AS requests,
-		       MIN(timestamp) AS startedAt,
-		       MAX(timestamp + COALESCE(duration, 0)) AS endedAt,
-		       SUM(total_tokens) AS totalTokens,
-		       SUM(cost_total) AS costTotal,
-		       SUM(${UNPRICED_REQUEST_SQL}) AS unpricedRequests,
-		       GROUP_CONCAT(DISTINCT model) AS models
-		FROM messages
-		GROUP BY session_file
-	`);
-	return stmt.all() as SessionRollupRow[];
-}
-
-/** Tool-call counts keyed by transcript file, for the Traces session list. */
-export function getToolCallCountsBySession(): Map<string, number> {
-	const counts = new Map<string, number>();
-	if (!db) return counts;
-	const stmt = db.prepare(
-		"SELECT session_file AS sessionFile, COUNT(*) AS calls FROM tool_calls GROUP BY session_file",
-	);
-	for (const row of stmt.all() as Array<{ sessionFile: string; calls: number }>) {
-		counts.set(row.sessionFile, row.calls);
-	}
-	return counts;
-}
-
-/**
- * Get daily cost time series data for the last N days, broken down by model.
- */
-export function getCostTimeSeries(days = 90, cutoff?: number | null): CostTimeSeriesPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - days * 24 * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / 86400000) * 86400000 as bucket,
-			model,
-			provider,
-			SUM(cost_total) as cost,
-			SUM(${UNPRICED_REQUEST_SQL}) as unpriced_requests,
-			SUM(cost_input) as cost_input,
-			SUM(cost_output) as cost_output,
-			SUM(cost_cache_read) as cost_cache_read,
-			SUM(cost_cache_write) as cost_cache_write,
-			COUNT(*) as requests
-		FROM messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, model, provider
-		ORDER BY bucket ASC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(seriesCutoff) : stmt.all()) as CostTimeSeriesRow[];
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		model: row.model,
-		provider: row.provider,
-		cost: row.cost ?? 0,
-		unpricedRequests: row.unpriced_requests ?? 0,
-		costInput: row.cost_input ?? 0,
-		costOutput: row.cost_output ?? 0,
-		costCacheRead: row.cost_cache_read ?? 0,
-		costCacheWrite: row.cost_cache_write ?? 0,
-		requests: row.requests,
-	}));
-}
-
 /**
  * Per-local-day activity aggregates for the last `days` days, oldest first.
  * Self-initializing (opens the stats DB on first use) so the coding-agent TUI
@@ -1507,6 +1046,9 @@ export async function getDailyActivity(days = 371): Promise<DailyActivityPoint[]
  *   you` scores blame, `makes (no|zero) sense` scores negation. v7
  *   shipped briefly without these, so any database that completed the v7
  *   backfill needs one more re-derive.
+ * - v9: stored judge prose (`prose` / `prose_hash`) for the frustration
+ *   judge, so every session re-parses once to populate it. Verdicts live in
+ *   `frustration_verdicts`, keyed by prose hash, which this reset never touches.
  *
  * Existing `messages` rows are unaffected - `INSERT OR IGNORE` keeps them.
  */
@@ -1728,16 +1270,16 @@ export function markSessionBackfillsComplete(): void {
  * copy user entries verbatim into the child JSONL, so the same
  * `(entry_id, timestamp)` must not land twice across different session files.
  */
-export function insertUserMessageStats(stats: UserMessageStats[]): number {
-	if (!db || stats.length === 0) return 0;
+export function insertUserMessageStats(stats: Iterable<UserMessageStats>): number {
+	if (!db) return 0;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		INSERT OR IGNORE INTO user_messages (
 			session_file, entry_id, folder, timestamp, model, provider,
 			chars, words, yelling, profanity, anguish,
-			negation, repetition, blame
+			negation, repetition, blame, prose, prose_hash
 		)
-		SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+		SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 		WHERE NOT EXISTS (
 			SELECT 1 FROM user_messages
 			WHERE entry_id = ? AND timestamp = ? AND session_file <> ?
@@ -1762,6 +1304,8 @@ export function insertUserMessageStats(stats: UserMessageStats[]): number {
 				s.negation,
 				s.repetition,
 				s.blame,
+				s.prose,
+				s.proseHash,
 				// `WHERE NOT EXISTS` binds: skip when a different session_file
 				// already holds this (entry_id, timestamp).
 				s.entryId,
@@ -1777,17 +1321,16 @@ export function insertUserMessageStats(stats: UserMessageStats[]): number {
 
 /**
  * Backfill the responding `model`/`provider` on user-message rows that were
- * persisted before their assistant reply was parsed (a side effect of
- * incremental `fromOffset` syncing: the `userByEntryId` map in
- * `parseSessionFile` only spans a single pass). Each row is updated at most
- * once because the `model IS NULL` guard short-circuits subsequent passes.
+ * persisted before their assistant reply was parsed by an incremental tail
+ * read. Each row is updated at most once because the `model IS NULL` guard
+ * short-circuits subsequent passes.
  *
  * Returns the number of rows actually updated.
  */
-export function updateUserMessageLinks(links: UserMessageLink[]): number {
-	if (!db || links.length === 0) return 0;
+export function updateUserMessageLinks(links: Iterable<UserMessageLink>): number {
+	if (!db) return 0;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		UPDATE user_messages
 		   SET model = ?, provider = ?
 		 WHERE session_file = ? AND entry_id = ? AND model IS NULL
@@ -1804,181 +1347,162 @@ export function updateUserMessageLinks(links: UserMessageLink[]): number {
 	return updated;
 }
 
-const UNKNOWN_MODEL = "unknown";
-
-interface BehaviorSeriesRow {
-	bucket: number;
+/** Frustration tallies of one responding (model, provider) pair, before identity merging. */
+export interface FrustrationModelRow extends FrustrationCounts {
 	model: string;
-	provider: string;
+	provider: string | null;
+	/** Earliest message timestamp (ms) in range. */
+	firstSeen: number;
+}
+
+/** One unique unjudged prose text: identical messages share a hash and one verdict. */
+export interface PendingProse {
+	hash: string;
+	prose: string;
+}
+
+/** Cached judge verdict for one prose hash. */
+export interface FrustrationVerdict {
+	proseHash: string;
+	/** P(clearly annoyed) + P(angry) on the `annoyed` score question. */
+	pAnnoyed: number;
+	/** P(angry, hostile, or swearing). */
+	pAngry: number;
+	/** Most likely `target` choice: `assistant`, `other`, or `none`. */
+	target: string;
+	/** `provider/model` that produced the verdict. */
+	judge: string;
+	judgedAt: number;
+}
+
+interface FrustrationCountsRow {
 	messages: number;
-	yelling: number | null;
-	profanity: number | null;
-	anguish: number | null;
-	negation: number | null;
-	repetition: number | null;
-	blame: number | null;
-	chars: number | null;
+	judged: number;
+	annoyed: number;
+	at_assistant: number;
+	angry: number;
+}
+
+interface FrustrationModelSqlRow extends FrustrationCountsRow {
+	model: string;
+	provider: string | null;
+	first_seen: number;
+}
+
+// Each message is classified once: by its cached verdict when `v` joined,
+// else by the regex signals stored at ingest. Keep in sync with the rules
+// documented on `FrustrationCounts` / `frustration.ts`.
+const JUDGED_SQL = "v.prose_hash IS NOT NULL";
+const JUDGED_ANNOYED_SQL = "v.p_annoyed >= 0.5";
+const JUDGED_AT_ASSISTANT_SQL = `${JUDGED_ANNOYED_SQL} AND v.target = 'assistant'`;
+const REGEX_AT_ASSISTANT_SQL = "u.negation + u.repetition + u.blame > 0";
+const FRUSTRATION_COUNTS_SQL = `
+	COUNT(*) AS messages,
+	COALESCE(SUM(${JUDGED_SQL}), 0) AS judged,
+	COALESCE(SUM(CASE WHEN ${JUDGED_SQL} THEN ${JUDGED_ANNOYED_SQL}
+		ELSE u.yelling + u.profanity + u.anguish + u.negation + u.repetition + u.blame > 0 END), 0) AS annoyed,
+	COALESCE(SUM(CASE WHEN ${JUDGED_SQL} THEN ${JUDGED_AT_ASSISTANT_SQL}
+		ELSE ${REGEX_AT_ASSISTANT_SQL} END), 0) AS at_assistant,
+	COALESCE(SUM(CASE WHEN ${JUDGED_SQL} THEN ${JUDGED_AT_ASSISTANT_SQL} AND v.p_angry >= 0.5
+		ELSE ${REGEX_AT_ASSISTANT_SQL} AND (u.profanity > 0 OR u.yelling > 0) END), 0) AS angry
+`;
+
+function hasRangeCutoff(cutoff: number | null | undefined): cutoff is number {
+	return cutoff !== null && cutoff !== undefined && cutoff > 0;
+}
+
+function toFrustrationCounts(row: FrustrationCountsRow | undefined): FrustrationCounts {
+	return {
+		messages: row?.messages ?? 0,
+		judged: row?.judged ?? 0,
+		annoyed: row?.annoyed ?? 0,
+		atAssistant: row?.at_assistant ?? 0,
+		angry: row?.angry ?? 0,
+	};
+}
+
+/** Frustration tallies over every user message with prose in range, linked to a model or not. */
+export function getFrustrationOverall(cutoff?: number | null): FrustrationCounts {
+	if (!db) return toFrustrationCounts(undefined);
+	const hasCutoff = hasRangeCutoff(cutoff);
+	const stmt = db.prepare(`
+		SELECT ${FRUSTRATION_COUNTS_SQL}
+		FROM user_messages u
+		LEFT JOIN frustration_verdicts v ON v.prose_hash = u.prose_hash
+		WHERE u.prose != ''${hasCutoff ? " AND u.timestamp >= ?" : ""}
+	`);
+	const row = (hasCutoff ? stmt.get(cutoff) : stmt.get()) as FrustrationCountsRow | undefined;
+	return toFrustrationCounts(row);
 }
 
 /**
- * Daily behavioral time series, grouped by responding model+provider.
+ * Frustration tallies per responding (model, provider) over the range. User
+ * messages that never got a reply (null model) are only in the overall tally.
  */
-export function getBehaviorTimeSeries(cutoff?: number | null): BehaviorTimeSeriesPoint[] {
+export function getFrustrationByModel(cutoff?: number | null): FrustrationModelRow[] {
 	if (!db) return [];
-	const hasCutoff = cutoff !== null && cutoff !== undefined && cutoff > 0;
+	const hasCutoff = hasRangeCutoff(cutoff);
 	const stmt = db.prepare(`
-		SELECT
-			(timestamp / 86400000) * 86400000 as bucket,
-			COALESCE(model, ?) as model,
-			COALESCE(provider, ?) as provider,
-			COUNT(*) as messages,
-			SUM(yelling) as yelling,
-			SUM(profanity) as profanity,
-			SUM(anguish) as anguish,
-			SUM(negation) as negation,
-			SUM(repetition) as repetition,
-			SUM(blame) as blame,
-			SUM(chars) as chars
-		FROM user_messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, model, provider
-		ORDER BY bucket ASC
+		SELECT u.model AS model, u.provider AS provider, MIN(u.timestamp) AS first_seen, ${FRUSTRATION_COUNTS_SQL}
+		FROM user_messages u
+		LEFT JOIN frustration_verdicts v ON v.prose_hash = u.prose_hash
+		WHERE u.prose != '' AND u.model IS NOT NULL${hasCutoff ? " AND u.timestamp >= ?" : ""}
+		GROUP BY u.model, u.provider
 	`);
-	const rows = (
-		hasCutoff ? stmt.all(UNKNOWN_MODEL, UNKNOWN_MODEL, cutoff) : stmt.all(UNKNOWN_MODEL, UNKNOWN_MODEL)
-	) as BehaviorSeriesRow[];
+	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as FrustrationModelSqlRow[];
 	return rows.map(row => ({
-		timestamp: row.bucket,
 		model: row.model,
 		provider: row.provider,
-		messages: row.messages,
-		yelling: row.yelling ?? 0,
-		profanity: row.profanity ?? 0,
-		anguish: row.anguish ?? 0,
-		negation: row.negation ?? 0,
-		repetition: row.repetition ?? 0,
-		blame: row.blame ?? 0,
-		chars: row.chars ?? 0,
+		firstSeen: row.first_seen,
+		...toFrustrationCounts(row),
 	}));
 }
 
-interface BehaviorOverallRow {
-	total_messages: number;
-	total_yelling: number | null;
-	total_profanity: number | null;
-	total_anguish: number | null;
-	total_negation: number | null;
-	total_repetition: number | null;
-	total_blame: number | null;
-	total_chars: number | null;
-	first_timestamp: number | null;
-	last_timestamp: number | null;
+/** Unique unjudged prose in range, one row per prose hash. */
+function pendingProseSql(hasCutoff: boolean): string {
+	return `
+		SELECT u.prose_hash AS hash, MIN(u.prose) AS prose
+		FROM user_messages u
+		WHERE u.prose != ''${hasCutoff ? " AND u.timestamp >= ?" : ""}
+		  AND NOT EXISTS (SELECT 1 FROM frustration_verdicts v WHERE v.prose_hash = u.prose_hash)
+		GROUP BY u.prose_hash
+	`;
 }
 
-/**
- * Overall behavioral totals across the cutoff window.
- */
-export function getBehaviorOverall(cutoff?: number | null): BehaviorOverallStats {
-	const empty: BehaviorOverallStats = {
-		totalMessages: 0,
-		totalYelling: 0,
-		totalProfanity: 0,
-		totalAnguish: 0,
-		totalNegation: 0,
-		totalRepetition: 0,
-		totalBlame: 0,
-		totalChars: 0,
-		firstTimestamp: 0,
-		lastTimestamp: 0,
-	};
-	if (!db) return empty;
-	const hasCutoff = cutoff !== null && cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			COUNT(*) as total_messages,
-			SUM(yelling) as total_yelling,
-			SUM(profanity) as total_profanity,
-			SUM(anguish) as total_anguish,
-			SUM(negation) as total_negation,
-			SUM(repetition) as total_repetition,
-			SUM(blame) as total_blame,
-			SUM(chars) as total_chars,
-			MIN(timestamp) as first_timestamp,
-			MAX(timestamp) as last_timestamp
-		FROM user_messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-	`);
-	const row = (hasCutoff ? stmt.get(cutoff) : stmt.get()) as BehaviorOverallRow | undefined;
-	if (!row?.total_messages) return empty;
-	return {
-		totalMessages: row.total_messages,
-		totalYelling: row.total_yelling ?? 0,
-		totalProfanity: row.total_profanity ?? 0,
-		totalAnguish: row.total_anguish ?? 0,
-		totalNegation: row.total_negation ?? 0,
-		totalRepetition: row.total_repetition ?? 0,
-		totalBlame: row.total_blame ?? 0,
-		totalChars: row.total_chars ?? 0,
-		firstTimestamp: row.first_timestamp ?? 0,
-		lastTimestamp: row.last_timestamp ?? 0,
-	};
+/** Unique prose texts in range that have no cached verdict yet. */
+export function getPendingFrustrationProse(cutoff?: number | null): PendingProse[] {
+	if (!db) return [];
+	const hasCutoff = hasRangeCutoff(cutoff);
+	const stmt = db.prepare(pendingProseSql(hasCutoff));
+	return (hasCutoff ? stmt.all(cutoff) : stmt.all()) as PendingProse[];
 }
 
-interface BehaviorByModelRow {
-	model: string;
-	provider: string;
-	total_messages: number;
-	total_yelling: number | null;
-	total_profanity: number | null;
-	total_anguish: number | null;
-	total_negation: number | null;
-	total_repetition: number | null;
-	total_blame: number | null;
-	total_chars: number | null;
-	last_timestamp: number | null;
+/** Count and total characters of {@link getPendingFrustrationProse} without loading the text. */
+export function getPendingFrustrationTotals(cutoff?: number | null): { messages: number; chars: number } {
+	if (!db) return { messages: 0, chars: 0 };
+	const hasCutoff = hasRangeCutoff(cutoff);
+	const stmt = db.prepare(
+		`SELECT COUNT(*) AS messages, COALESCE(SUM(LENGTH(prose)), 0) AS chars FROM (${pendingProseSql(hasCutoff)})`,
+	);
+	const row = (hasCutoff ? stmt.get(cutoff) : stmt.get()) as { messages: number; chars: number } | undefined;
+	return { messages: row?.messages ?? 0, chars: row?.chars ?? 0 };
 }
 
 /**
- * Per-model behavioral totals over the cutoff window. "Unknown" represents
- * user messages that never received an assistant reply.
+ * Cache (or replace) verdicts, all in one transaction: a judge run lands
+ * dozens per second, and a commit per verdict would contend with ingest for
+ * the write lock every time.
  */
-export function getBehaviorByModel(cutoff?: number | null): BehaviorModelStats[] {
-	if (!db) return [];
-	const hasCutoff = cutoff !== null && cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT
-			COALESCE(model, ?) as model,
-			COALESCE(provider, ?) as provider,
-			COUNT(*) as total_messages,
-			SUM(yelling) as total_yelling,
-			SUM(profanity) as total_profanity,
-			SUM(anguish) as total_anguish,
-			SUM(negation) as total_negation,
-			SUM(repetition) as total_repetition,
-			SUM(blame) as total_blame,
-			SUM(chars) as total_chars,
-			MAX(timestamp) as last_timestamp
-		FROM user_messages
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY model, provider
-		ORDER BY total_messages DESC
-	`);
-	const rows = (
-		hasCutoff ? stmt.all(UNKNOWN_MODEL, UNKNOWN_MODEL, cutoff) : stmt.all(UNKNOWN_MODEL, UNKNOWN_MODEL)
-	) as BehaviorByModelRow[];
-	return rows.map(row => ({
-		model: row.model,
-		provider: row.provider,
-		totalMessages: row.total_messages,
-		totalYelling: row.total_yelling ?? 0,
-		totalProfanity: row.total_profanity ?? 0,
-		totalAnguish: row.total_anguish ?? 0,
-		totalNegation: row.total_negation ?? 0,
-		totalRepetition: row.total_repetition ?? 0,
-		totalBlame: row.total_blame ?? 0,
-		totalChars: row.total_chars ?? 0,
-		lastTimestamp: row.last_timestamp ?? 0,
-	}));
+export function upsertFrustrationVerdicts(verdicts: readonly FrustrationVerdict[]): void {
+	if (!db || verdicts.length === 0) return;
+	const database = db;
+	const stmt = database.query(
+		`INSERT OR REPLACE INTO frustration_verdicts (prose_hash, p_annoyed, p_angry, target, judge, judged_at)
+		 VALUES (?, ?, ?, ?, ?, ?)`,
+	);
+	database.transaction(() => {
+		for (const v of verdicts) stmt.run(v.proseHash, v.pAnnoyed, v.pAngry, v.target, v.judge, v.judgedAt);
+	})();
 }
 
 /**
@@ -1990,10 +1514,10 @@ export function getBehaviorByModel(cutoff?: number | null): BehaviorModelStats[]
  * identity, not the call id alone — provider call ids are not a global
  * namespace across unrelated sessions.
  */
-export function insertToolCalls(calls: ToolCallStats[]): number {
-	if (!db || calls.length === 0) return 0;
+export function insertToolCalls(calls: Iterable<ToolCallStats>): number {
+	if (!db) return 0;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		INSERT OR IGNORE INTO tool_calls (
 			session_file, entry_id, tool_call_id, folder, tool_name,
 			model, provider, timestamp, agent_type, calls_in_turn, args_chars
@@ -2041,10 +1565,10 @@ export function insertToolCalls(calls: ToolCallStats[]): number {
  * guard makes re-syncs idempotent; rows skipped by the fork guard simply
  * never match.
  */
-export function updateToolResults(links: ToolResultLink[]): number {
-	if (!db || links.length === 0) return 0;
+export function updateToolResults(links: Iterable<ToolResultLink>): number {
+	if (!db) return 0;
 
-	const stmt = db.prepare(`
+	const stmt = db.query(`
 		UPDATE tool_calls
 		SET result_chars = ?, is_error = ?
 		WHERE session_file = ? AND tool_call_id = ? AND result_chars IS NULL
@@ -2060,131 +1584,3 @@ export function updateToolResults(links: ToolResultLink[]): number {
 	apply();
 	return updated;
 }
-
-/**
- * Shared SELECT list for tool aggregates. Real provider usage comes from the
- * invoking assistant turn (`messages` join) divided by `calls_in_turn`, so
- * per-tool token/cost shares stay additive across tools. The unpriced share
- * reuses the request predicate against the joined message, whose stored cost
- * it attributes.
- */
-const TOOL_AGGREGATE_COLUMNS = `
-	COUNT(*) as calls,
-	SUM(CASE WHEN t.is_error = 1 THEN 1 ELSE 0 END) as errors,
-	SUM(t.args_chars) as args_chars,
-	SUM(COALESCE(t.result_chars, 0)) as result_chars,
-	SUM(COALESCE(m.total_tokens, 0) * 1.0 / t.calls_in_turn) as total_tokens_share,
-	SUM(COALESCE(m.output_tokens, 0) * 1.0 / t.calls_in_turn) as output_tokens_share,
-	SUM(COALESCE(m.cost_total, 0) / t.calls_in_turn) as cost_share,
-	SUM(${unpricedRequestSql("m.")} * 1.0 / t.calls_in_turn) as unpriced_requests_share,
-	MAX(t.timestamp) as last_used
-`;
-
-interface ToolAggregateRow {
-	tool_name: string;
-	model?: string;
-	provider?: string;
-	calls: number;
-	errors: number;
-	args_chars: number | null;
-	result_chars: number | null;
-	total_tokens_share: number | null;
-	output_tokens_share: number | null;
-	cost_share: number | null;
-	unpriced_requests_share: number | null;
-	last_used: number;
-}
-
-function rowToToolUsage(row: ToolAggregateRow): ToolUsageStats {
-	return {
-		tool: row.tool_name,
-		calls: row.calls,
-		errors: row.errors,
-		argsChars: row.args_chars ?? 0,
-		resultChars: row.result_chars ?? 0,
-		totalTokensShare: row.total_tokens_share ?? 0,
-		outputTokensShare: row.output_tokens_share ?? 0,
-		costShare: row.cost_share ?? 0,
-		unpricedRequestsShare: row.unpriced_requests_share ?? 0,
-		lastUsed: row.last_used,
-	};
-}
-
-/**
- * Get tool usage aggregated by tool name.
- */
-export function getToolStats(cutoff?: number): ToolUsageStats[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT t.tool_name, ${TOOL_AGGREGATE_COLUMNS}
-		FROM tool_calls t
-		LEFT JOIN messages m ON m.session_file = t.session_file AND m.entry_id = t.entry_id
-		${hasCutoff ? "WHERE t.timestamp >= ?" : ""}
-		GROUP BY t.tool_name
-		ORDER BY calls DESC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as ToolAggregateRow[];
-	return rows.map(rowToToolUsage);
-}
-
-/**
- * Get tool usage aggregated by (tool, model, provider).
- */
-export function getToolStatsByModel(cutoff?: number): ToolModelStats[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== undefined && cutoff > 0;
-	const stmt = db.prepare(`
-		SELECT t.tool_name, t.model, t.provider, ${TOOL_AGGREGATE_COLUMNS}
-		FROM tool_calls t
-		LEFT JOIN messages m ON m.session_file = t.session_file AND m.entry_id = t.entry_id
-		${hasCutoff ? "WHERE t.timestamp >= ?" : ""}
-		GROUP BY t.tool_name, t.model, t.provider
-		ORDER BY calls DESC
-	`);
-
-	const rows = (hasCutoff ? stmt.all(cutoff) : stmt.all()) as ToolAggregateRow[];
-	return rows.map(row => ({
-		...rowToToolUsage(row),
-		model: row.model ?? "",
-		provider: row.provider ?? "",
-	}));
-}
-
-/**
- * Get tool-call time series (one point per bucket per tool).
- */
-export function getToolTimeSeries(
-	days = 14,
-	cutoff?: number | null,
-	bucketMs = 24 * 60 * 60 * 1000,
-): ToolTimeSeriesPoint[] {
-	if (!db) return [];
-
-	const hasCutoff = cutoff !== null;
-	const seriesCutoff = hasCutoff ? (cutoff ?? Date.now() - days * 24 * 60 * 60 * 1000) : 0;
-
-	const stmt = db.prepare(`
-		SELECT
-			(timestamp / ?) * ? as bucket,
-			tool_name,
-			COUNT(*) as calls,
-			SUM(CASE WHEN is_error = 1 THEN 1 ELSE 0 END) as errors
-		FROM tool_calls
-		${hasCutoff ? "WHERE timestamp >= ?" : ""}
-		GROUP BY bucket, tool_name
-		ORDER BY bucket ASC
-	`);
-
-	const rowsRaw = hasCutoff ? stmt.all(bucketMs, bucketMs, seriesCutoff) : stmt.all(bucketMs, bucketMs);
-	const rows = rowsRaw as Array<{ bucket: number; tool_name: string; calls: number; errors: number }>;
-	return rows.map(row => ({
-		timestamp: row.bucket,
-		tool: row.tool_name,
-		calls: row.calls,
-		errors: row.errors,
-	}));
-}