@linxiraos/pi-stats 1.1.27 → 1.2.1

package/src/embedded-client.ts

@@ -8,6 +8,14 @@
  * keeps building the dashboard from source.
  */
 
+/**
+ * Cheap check whether the generated text carries a gzip archive: sniffs the
+ * base64 of the gzip magic (`1f 8b 08`) without decoding megabytes.
+ */
+export function hasEmbeddedClientArchive(txt: string): boolean {
+	return /^\s*H4s/.test(txt);
+}
+
 /**
  * Decode the generated archive text.
  *
@@ -17,6 +25,7 @@
  * rather than decoded into garbage bytes.
  */
 export function decodeEmbeddedClientArchive(txt: string): Buffer | null {
+	if (!hasEmbeddedClientArchive(txt)) return null;
 	const normalized = txt.replaceAll(/\s+/g, "");
 	if (!normalized) return null;
 	if (!/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) return null;

package/src/frustration.ts

@@ -16,7 +16,7 @@
  * using the judge the omp host registered through `startServer`. Standalone
  * `omp-stats` has none and only shows the regex fallback.
  */
-import type { ChoiceQuestion, Judge, Model, ScoreQuestion } from "@linxiraos/pi-ai";
+import { type Judge, judgeQuestions, type Model } from "@linxiraos/pi-ai";
 import { compareRevision, parseRevision } from "@linxiraos/pi-catalog/compat/revision";
 import { classifyModel } from "@linxiraos/pi-catalog/compat/taxonomy";
 import { logger } from "@linxiraos/pi-utils";
@@ -32,6 +32,7 @@ import {
 	type PendingProse,
 	upsertFrustrationVerdicts,
 } from "./db";
+import questionFile from "./prompts/judge/frustration.json" with { type: "json" };
 import type {
 	FrustrationDashboardStats,
 	FrustrationEstimate,
@@ -44,40 +45,16 @@ export interface StatsJudge extends Judge {
 	primaryModel(): Model | undefined;
 }
 
-/** Lazily resolves the host judge on first estimate/run so `omp stats` startup stays fast. */
+/** Lazily resolves the host judge on first estimate/run so `zetacode stats` startup stays fast. */
 export type StatsJudgeProvider = () => Promise<StatsJudge>;
 
-/** Where the user's annoyance is aimed. */
-export type FrustrationTarget = "assistant" | "other" | "none";
-
 /**
- * The two questions asked about every prose text, in ONE judge request.
+ * The two questions asked about every prose text, in ONE judge request:
+ * `annoyed` (four levels) and `target` (`assistant`, `other`, or `none`).
  * The cost constants below were measured with exactly these strings; changing
  * them invalidates both the estimate and every cached verdict's meaning.
  */
-export const FRUSTRATION_QUESTIONS: { annoyed: ScoreQuestion; target: ChoiceQuestion<FrustrationTarget> } = {
-	annoyed: {
-		type: "score",
-		instructions:
-			"A user typed this message to an AI coding assistant (code blocks and markup were removed). Rate how frustrated or annoyed the user sounds. Judge tone and wording only (caps, swearing, 'again', 'why did you', 'stop', 'wtf', exasperation), not task difficulty. Plain instructions or questions are neutral.",
-		criteria: [
-			"neutral / no frustration",
-			"mild irritation or impatience",
-			"clearly annoyed or exasperated",
-			"angry, hostile, or swearing",
-		],
-	},
-	target: {
-		type: "choice",
-		instructions: "If the user sounds annoyed, what is the annoyance aimed at?",
-		criteria: {
-			assistant:
-				"the AI's own behavior in this session: what it did, wrote, ignored, repeated, took too long on, or misunderstood (incl. reacting to its output with 'wtf', 'no', 'stop', 'again', 'why did you')",
-			other: "build tools, third-party libraries/services, pre-existing code or tests, the user's own past design, other people, or general product/UX feedback about the thing being built",
-			none: "not annoyed: a plain question, instruction, design musing, or casual chat",
-		},
-	},
-};
+export const FRUSTRATION_QUESTIONS = judgeQuestions(questionFile);
 
 /** Per-request input-token overhead of {@link FRUSTRATION_QUESTIONS}, measured on jev-1.13. */
 const REQUEST_OVERHEAD_TOKENS = 561;
@@ -101,7 +78,7 @@ const ATTEMPTS_PER_TEXT = 3;
 const CIRCUIT_BREAKER_FAILURES = 25;
 
 const NO_PROVIDER_REASON =
-	"This dashboard was started without a judge (standalone zeta stats). Run `zeta-c stats` to classify.";
+	"This dashboard was started without a judge (standalone zetacode stats). Run `zetacode stats` to classify.";
 const NO_MODEL_REASON = "No judge model is available. Configure the `judge` model role.";
 
 let judgeProvider: StatsJudgeProvider | undefined;
@@ -166,6 +143,7 @@ export function mergeFrustrationRows(rows: readonly FrustrationModelRow[]): Frus
 		if (existing) {
 			existing.messages += row.messages;
 			existing.judged += row.judged;
+			existing.unscored += row.unscored;
 			existing.annoyed += row.annoyed;
 			existing.atAssistant += row.atAssistant;
 			existing.angry += row.angry;
@@ -186,6 +164,7 @@ export function mergeFrustrationRows(rows: readonly FrustrationModelRow[]): Frus
 			firstSeen: row.firstSeen,
 			messages: row.messages,
 			judged: row.judged,
+			unscored: row.unscored,
 			annoyed: row.annoyed,
 			atAssistant: row.atAssistant,
 			angry: row.angry,

package/src/live.ts

@@ -5,15 +5,16 @@
  * The dashboard never waits for ingest. {@link StatsLive.start} kicks a full
  * sync in the background and watches the sessions directory; changed
  * transcripts are re-synced (only those files) shortly after they are written.
- * Every committed batch bumps {@link LiveStatus.version} (throttled), so open
- * pages refetch and fill in while parsing is still running.
+ * Every batch that changes stored rows bumps {@link LiveStatus.version}
+ * (throttled), so open pages refetch and fill in while parsing is still
+ * running; syncs that change nothing leave the version alone.
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getSessionsDir, logger } from "@linxiraos/pi-utils";
 import { syncAllSessions } from "./aggregator";
-import { initDb } from "./db";
+import { getDataVersion, initDb } from "./db";
 import { getRollupStatus, refreshRollups } from "./rollup";
 import type { LiveStatus, LiveSyncStatus } from "./shared-types";
 
@@ -28,7 +29,8 @@ const SYNC_RETRY_MS = 10_000;
 /** Minimum spacing of progress-only status events. */
 const PROGRESS_THROTTLE_MS = 150;
 
-type Listener = (status: LiveStatus) => void;
+/** Receives each distinct status and its JSON serialization (shared by every listener). */
+type Listener = (status: LiveStatus, frame: string) => void;
 
 /** One per process; owned by the dashboard server (see `startServer`). */
 export class StatsLive {
@@ -36,6 +38,10 @@ export class StatsLive {
 	#sync: LiveSyncStatus = { phase: "idle", current: 0, total: 0, processed: 0, lastSyncedAt: null, error: null };
 	#indexingHours = 0;
 	#listeners = new Set<Listener>();
+	/** Last frame sent to listeners; identical statuses are not re-sent. */
+	#lastFrame: string | null = null;
+	/** `PRAGMA data_version` at the last sync; null before the first. */
+	#dataVersion: number | null = null;
 
 	#started = false;
 	#watcher: fs.FSWatcher | null = null;
@@ -133,8 +139,9 @@ export class StatsLive {
 						};
 						this.#emitProgress();
 					}
-					if (event.processed > committed) {
-						committed = event.processed;
+					// Only committed row changes make pages refetch; unchanged transcripts cost nothing.
+					if (event.changes > committed) {
+						committed = event.changes;
 						this.#changed();
 					}
 				},
@@ -159,14 +166,28 @@ export class StatsLive {
 				}, SYNC_RETRY_MS);
 			}
 		}
-		// Another process may have ingested too; always let clients revalidate.
-		this.#changed();
+		// Another process may have ingested too; its commits move SQLite's data_version.
+		if (this.#externalWrites()) this.#changed();
 		this.#emit();
 	}
 
+	/** Whether another connection committed since the last check (always true on the first). */
+	#externalWrites(): boolean {
+		const current = getDataVersion();
+		if (current === null) return false;
+		const changed = current !== this.#dataVersion;
+		this.#dataVersion = current;
+		return changed;
+	}
+
 	/** Stored data changed: refresh rollups and (throttled) bump the version. */
 	#changed(): void {
 		void this.#refresh();
+		this.#bumpVersion();
+	}
+
+	/** Bump the data version (throttled), making open pages refetch. */
+	#bumpVersion(): void {
 		if (this.#versionTimer) return;
 		const wait = Math.max(0, this.#lastVersionAt + VERSION_THROTTLE_MS - Date.now());
 		this.#versionTimer = setTimeout(() => {
@@ -190,8 +211,9 @@ export class StatsLive {
 				await refreshRollups({
 					onProgress: remaining => {
 						this.#indexingHours = remaining;
-						// Each rolled batch fills in more history for open pages.
-						if (remaining > 0) this.#changed();
+						// Each rolled batch fills in more history for open pages; the rows
+						// themselves are already being rolled, so only the version moves.
+						if (remaining > 0) this.#bumpVersion();
 					},
 				});
 			} while (this.#refreshAgain);
@@ -240,9 +262,12 @@ export class StatsLive {
 
 	#emit(): void {
 		const status = this.status();
+		const frame = JSON.stringify(status);
+		if (frame === this.#lastFrame) return;
+		this.#lastFrame = frame;
 		for (const listener of this.#listeners) {
 			try {
-				listener(status);
+				listener(status, frame);
 			} catch (error) {
 				logger.warn("Stats live listener failed", { error: String(error) });
 			}

package/src/locale.ts

@@ -0,0 +1,29 @@
+/**
+ * Locale resolution shared by the stats server (which stamps the host's
+ * language into the served HTML) and the client bundle (which renders it).
+ * Lives outside `client/` so the server never imports browser code.
+ */
+
+/** Locales the dashboard ships: English and Simplified Chinese. */
+export type StatsLocale = "en" | "zh-CN";
+
+/**
+ * Map a language tag to a shipped locale. Any `zh` variant is Simplified
+ * Chinese (the dashboard ships no Traditional pack); everything else —
+ * including browser tags such as `tr-TR` — is English, matching the
+ * dashboard's single number/date convention rather than the browser's.
+ */
+export function resolveLocaleTag(tag: string | undefined | null): StatsLocale {
+	const normalized = tag?.trim().toLowerCase() ?? "";
+	if (normalized === "zh" || normalized.startsWith("zh-") || normalized.startsWith("zh_")) return "zh-CN";
+	return "en";
+}
+
+/** Pick the first shipped locale from a `navigator.languages` list; English when none match. */
+export function resolveBrowserLocale(languages: readonly string[] | undefined): StatsLocale {
+	for (const language of languages ?? []) {
+		const resolved = resolveLocaleTag(language);
+		if (resolved !== "en") return resolved;
+	}
+	return "en";
+}

package/src/parser.ts

@@ -1,11 +1,11 @@
 import type * as nodeFs from "node:fs";
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
 import {
 	type AssistantMessage,
 	coerceServiceTierByFamily,
-	getPriorityPremiumRequests,
+	getPremiumServiceTierRequests,
+	parseServiceTier,
 	resolveModelServiceTier,
 	type ServiceTierByFamily,
 	type ToolCall,
@@ -67,53 +67,6 @@ export function extractFolderFromPath(sessionPath: string): string {
 	return projectDir.replace(/^--/, "/").replace(/--/g, "/");
 }
 
-/**
- * Decode a session project folder name back to its source cwd, mirroring the
- * encoder in the coding agent's session-paths module: home-relative cwds
- * encode as `-<segments>`, temp-relative ones as `-tmp<segments>`, and legacy
- * absolute ones as `--<absolute>--`, with `/`, `\`, and `:` collapsed to `-`.
- * Returns null when the name carries no decodable cwd.
- */
-export function decodeProjectFolderCwd(projectDir: string): string | null {
-	if (projectDir === "-tmp" || projectDir.startsWith("-tmp-")) return os.tmpdir();
-	if (projectDir.startsWith("--")) {
-		const inner = projectDir.replace(/^--/, "").replace(/--$/, "");
-		if (!inner) return path.resolve("/");
-		// POSIX legacy names had their leading `/` stripped, so restore it;
-		// Windows names collapsed a drive letter's `:` into a dash too
-		// (`C--Users` decodes to `C:\Users`), so re-attach the colon.
-		if (path.sep === "/") return path.resolve(`/${inner.replaceAll("-", "/")}`);
-		return path.resolve(inner.replaceAll("-", "\\").replace(/^([A-Za-z])\\/, "$1:\\"));
-	}
-	if (projectDir.startsWith("-")) {
-		const inner = projectDir.replace(/^-/, "");
-		return path.resolve(os.homedir(), inner.replaceAll("-", path.sep));
-	}
-	// Folder names without the leading marker predate the encoder; no cwd is
-	// recoverable, so they are never treated as temp.
-	return null;
-}
-
-/**
- * Whether a session project folder decodes to a cwd inside the OS temp dir.
- * Test suites spawn agents under `os.tmpdir()` and re-create their transcripts
- * on every run; those sessions are throwaway usage that must not reach the
- * stats DB. The `-` collapse in the encoder is lossy (a literal `-` inside a
- * path segment is indistinguishable from a separator), which can only produce
- * false positives here — a skipped ingestion, never a misattributed row.
- */
-export function isTempProjectFolder(projectDir: string): boolean {
-	const decoded = decodeProjectFolderCwd(projectDir);
-	if (!decoded) return false;
-	const tmp = path.resolve(os.tmpdir());
-	const candidate = path.resolve(decoded);
-	// NTFS comparisons are case-insensitive; resolve() normalizes separators.
-	const caseFold = process.platform === "win32";
-	const normalizedTmp = caseFold ? tmp.toLowerCase() : tmp;
-	const normalizedCandidate = caseFold ? candidate.toLowerCase() : candidate;
-	return normalizedCandidate === normalizedTmp || normalizedCandidate.startsWith(normalizedTmp + path.sep);
-}
-
 /**
  * Check if an entry is an assistant message.
  */
@@ -177,12 +130,17 @@ function extractUserText(content: unknown): string {
 /**
  * Build user-message stats from an entry. Returns null for empty/synthetic content.
  */
-function extractUserStats(sessionFile: string, folder: string, entry: SessionMessageEntry): UserMessageStats | null {
+function extractUserStats(
+	sessionFile: string,
+	folder: string,
+	entry: SessionMessageEntry,
+	prevText: string,
+): UserMessageStats | null {
 	const msg = entry.message as { role: "user"; content?: unknown; synthetic?: boolean };
 	if (msg.role !== "user" || msg.synthetic) return null;
 	const text = extractUserText(msg.content);
 	if (!text.trim()) return null;
-	const metrics = computeUserMessageMetrics(text);
+	const metrics = computeUserMessageMetrics(text, { prevText });
 	const prose = judgeProse(text);
 	const ts = Date.parse(entry.timestamp);
 	return {
@@ -200,6 +158,8 @@ function extractUserStats(sessionFile: string, folder: string, entry: SessionMes
 		negation: metrics.negation,
 		repetition: metrics.repetition,
 		blame: metrics.blame,
+		emphasis: metrics.emphasis,
+		unsupportedScript: metrics.unsupportedScript,
 		prose,
 		proseHash: prose ? Bun.hash(prose).toString(16) : "",
 	};
@@ -284,20 +244,26 @@ function extractStats(
 	const rawUsage = msg.usage as Partial<Usage> | undefined;
 	if (!rawUsage || typeof rawUsage !== "object") return null;
 
-	// Backfill: when the session recorded `priority` as the active service tier
-	// at this point but the AI usage payload was captured before priority
-	// requests were folded into `premiumRequests`, derive the count here so the
-	// "Premium Reqs" stat aggregates priority traffic on re-sync. Trust any
-	// non-zero value already in `usage.premiumRequests` (Copilot multipliers or
-	// the new AI code path) and only synthesise when the field is missing/zero.
+	// Backfill: when the session recorded a premium tier (`priority`/`ultrafast`)
+	// as the active service tier at this point but the AI usage payload was
+	// captured before premium requests were folded into `premiumRequests`, derive
+	// the count here so the "Premium Reqs" stat aggregates premium traffic on
+	// re-sync. The tier the provider reported serving the turn (`msg.serviceTier`)
+	// is authoritative — it is proof the tier reached the wire, so the
+	// discovery-metadata gate is skipped; the session's live setting is only a
+	// fallback for turns recorded before that field existed. Trust any non-zero
+	// value already in `usage.premiumRequests` (Copilot multipliers or the new AI
+	// code path) and only synthesise when the field is missing/zero.
 	const recorded = rawUsage.premiumRequests ?? 0;
 	const model = {
 		provider: msg.provider,
 		api: msg.api,
 		identity: classifyModel(msg.provider, msg.model, { lenient: true }),
 	};
-	const tier = resolveModelServiceTier(currentServiceTier, model);
-	const derived = recorded > 0 ? recorded : getPriorityPremiumRequests(tier, model);
+	const servedTier = parseServiceTier(msg.serviceTier);
+	const tier = servedTier ?? resolveModelServiceTier(currentServiceTier, model);
+	const derived =
+		recorded > 0 ? recorded : getPremiumServiceTierRequests(tier, model, { served: servedTier !== undefined });
 	const wellFormed =
 		isFiniteCount(rawUsage.input) &&
 		isFiniteCount(rawUsage.output) &&
@@ -339,6 +305,7 @@ function extractStats(
 		errorMessage: msg.errorMessage ?? null,
 		usage,
 		agentType,
+		serviceTier: servedTier ?? null,
 	};
 }
 
@@ -594,6 +561,11 @@ export async function parseSessionFile(
 	const toolCalls: ToolCallStats[] = [];
 	const toolResults: ToolResultLink[] = [];
 
+	// The previous user message, for the whole-message repetition signal. An
+	// incremental parse starts mid-session, so the first message of a resumed
+	// pass simply carries no predecessor.
+	let prevUserText = "";
+
 	// Reduce each entry immediately so full replays do not retain tool-output/message bodies.
 	const visit = (entry: SessionEntry): void => {
 		if (isServiceTierChange(entry)) {
@@ -601,8 +573,11 @@ export async function parseSessionFile(
 			return;
 		}
 		if (isUserMessage(entry)) {
-			const userMsg = extractUserStats(sessionPath, folder, entry);
-			if (userMsg) userStats.push(userMsg);
+			const userMsg = extractUserStats(sessionPath, folder, entry, prevUserText);
+			if (userMsg) {
+				userStats.push(userMsg);
+				prevUserText = userMsg.prose || prevUserText;
+			}
 			return;
 		}
 		if (isToolResultMessage(entry)) {
@@ -728,17 +703,7 @@ export async function listSessionFiles(folderPath: string): Promise<string[]> {
  */
 export async function listAllSessionFiles(): Promise<string[]> {
 	const folders = await listSessionFolders();
-	const allFiles: string[] = [];
-
-	for (const folder of folders) {
-		// Skip at enumeration: temp-cwd project folders re-create their
-		// transcripts on every test run and must never reach the parser or DB.
-		if (isTempProjectFolder(path.basename(folder))) continue;
-		const files = await listSessionFiles(folder);
-		allFiles.push(...files);
-	}
-
-	return allFiles;
+	return (await Promise.all(folders.map(listSessionFiles))).flat();
 }
 
 /**

package/src/port-conflict.ts

@@ -265,7 +265,7 @@ async function reclaimStatsPort(port: number, hasDashboardIdentity = false): Pro
 		/(?:^|\/)(?:zeta-c|zeta-cli|zetacode|omp)(?:\.exe)?["'\s]+stats(?:["'\s]|$)/.test(normalizedCommand);
 	if (!STATS_RUNTIME_IMAGES[normalizedImage] || (!hasStatsIdentity && !hasDashboardIdentity)) {
 		throw new Error(
-			`Port ${port} is in use by ${holder.image} (PID ${holder.pid}), which is not identifiable as a zeta stats dashboard; refusing to stop it.`,
+			`Port ${port} is in use by ${holder.image} (PID ${holder.pid}), which is not identifiable as a zetacode stats dashboard; refusing to stop it.`,
 		);
 	}
 

package/src/prompts/judge/frustration.json

@@ -0,0 +1,19 @@
+{
+	"annoyed": {
+		"instructions": "A user typed this message to an AI coding assistant (code blocks and markup were removed). Rate how frustrated or annoyed the user sounds. Judge tone and wording only (caps, swearing, 'again', 'why did you', 'stop', 'wtf', exasperation), not task difficulty. Plain instructions or questions are neutral.",
+		"criteria": [
+			"neutral / no frustration",
+			"mild irritation or impatience",
+			"clearly annoyed or exasperated",
+			"angry, hostile, or swearing"
+		]
+	},
+	"target": {
+		"instructions": "If the user sounds annoyed, what is the annoyance aimed at?",
+		"criteria": {
+			"assistant": "the AI's own behavior in this session: what it did, wrote, ignored, repeated, took too long on, or misunderstood (incl. reacting to its output with 'wtf', 'no', 'stop', 'again', 'why did you')",
+			"other": "build tools, third-party libraries/services, pre-existing code or tests, the user's own past design, other people, or general product/UX feedback about the thing being built",
+			"none": "not annoyed: a plain question, instruction, design musing, or casual chat"
+		}
+	}
+}

package/src/rollup.ts

@@ -32,6 +32,7 @@ import type {
 	AgentTypeStats,
 	AggregatedStats,
 	CostTimeSeriesPoint,
+	DailyActivityPoint,
 	FolderStats,
 	ModelPerformancePoint,
 	ModelStats,
@@ -179,7 +180,7 @@ const EXACT_DIRTY_SESSIONS = 512;
  */
 export function ensureRollupSchema(database: Database): void {
 	const readMeta = (key: string) =>
-		(database.prepare("SELECT value FROM meta WHERE key = ?").get(key) as { value: string } | undefined)?.value;
+		(database.query("SELECT value FROM meta WHERE key = ?").get(key) as { value: string } | undefined)?.value;
 	const fresh = readMeta(ROLLUP_VERSION_KEY) !== ROLLUP_VERSION;
 	// Steady state touches no schema: DDL on every open would contend with
 	// other omp processes writing the same database.
@@ -273,7 +274,7 @@ export function ensureRollupSchema(database: Database): void {
 				}
 			}
 			database
-				.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
+				.query("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
 				.run(TRIGGER_VERSION_KEY, TRIGGER_VERSION);
 			if (fresh) {
 				database.run(`
@@ -286,7 +287,7 @@ export function ensureRollupSchema(database: Database): void {
 				SELECT DISTINCT session_file FROM messages UNION SELECT DISTINCT session_file FROM tool_calls
 			`);
 				database
-					.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
+					.query("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
 					.run(ROLLUP_VERSION_KEY, ROLLUP_VERSION);
 			}
 		})
@@ -307,7 +308,7 @@ export function getRollupStatus(): RollupStatus {
 	const database = currentDb();
 	if (!database) return { dirtyHours: 0, dirtySessions: 0 };
 	return database
-		.prepare(
+		.query(
 			"SELECT (SELECT COUNT(*) FROM rollup_dirty) AS dirtyHours, (SELECT COUNT(*) FROM session_dirty) AS dirtySessions",
 		)
 		.get() as RollupStatus;
@@ -322,25 +323,25 @@ export function refreshRollupBatch(limit: number): number {
 	const database = currentDb();
 	if (!database) return 0;
 	const run = database.transaction(() => {
-		const buckets = database.prepare("SELECT bucket FROM rollup_dirty ORDER BY bucket DESC LIMIT ?").all(limit) as {
+		const buckets = database.query("SELECT bucket FROM rollup_dirty ORDER BY bucket DESC LIMIT ?").all(limit) as {
 			bucket: number;
 		}[];
-		const clearMessages = database.prepare("DELETE FROM message_rollup WHERE bucket = ?");
-		const clearTools = database.prepare("DELETE FROM tool_rollup WHERE bucket = ?");
-		const fillMessages = database.prepare(`
+		const clearMessages = database.query("DELETE FROM message_rollup WHERE bucket = ?");
+		const clearTools = database.query("DELETE FROM tool_rollup WHERE bucket = ?");
+		const fillMessages = database.query(`
 			INSERT INTO message_rollup (${MESSAGE_ROLLUP_COLUMNS})
 			SELECT ${messageFacts("?1", "")}
 			FROM messages WHERE timestamp >= ?1 AND timestamp < ?1 + ${HOUR_MS}
 			GROUP BY ${MESSAGE_DIMENSIONS}
 		`);
-		const fillTools = database.prepare(`
+		const fillTools = database.query(`
 			INSERT INTO tool_rollup (${TOOL_ROLLUP_COLUMNS})
 			SELECT ${toolFacts("?1")}
 			FROM tool_calls t ${TOOL_JOIN}
 			WHERE t.timestamp >= ?1 AND t.timestamp < ?1 + ${HOUR_MS}
 			GROUP BY t.tool_name, t.model, t.provider
 		`);
-		const clean = database.prepare("DELETE FROM rollup_dirty WHERE bucket = ?");
+		const clean = database.query("DELETE FROM rollup_dirty WHERE bucket = ?");
 		for (const { bucket } of buckets) {
 			clearMessages.run(bucket);
 			clearTools.run(bucket);
@@ -351,16 +352,16 @@ export function refreshRollupBatch(limit: number): number {
 
 		// Transcripts are cheap (indexed by session_file); roll many per hour-batch.
 		const sessions = database
-			.prepare("SELECT session_file FROM session_dirty LIMIT ?")
+			.query("SELECT session_file FROM session_dirty LIMIT ?")
 			.all(limit * SESSIONS_PER_HOUR) as { session_file: string }[];
-		const clearSession = database.prepare("DELETE FROM session_rollup WHERE session_file = ?");
-		const fillSession = database.prepare(`
+		const clearSession = database.query("DELETE FROM session_rollup WHERE session_file = ?");
+		const fillSession = database.query(`
 			INSERT INTO session_rollup (${SESSION_ROLLUP_COLUMNS})
 			SELECT ${sessionFacts("m.")}
 			FROM messages m WHERE m.session_file = ?1
 			GROUP BY m.session_file
 		`);
-		const cleanSession = database.prepare("DELETE FROM session_dirty WHERE session_file = ?");
+		const cleanSession = database.query("DELETE FROM session_dirty WHERE session_file = ?");
 		for (const { session_file } of sessions) {
 			clearSession.run(session_file);
 			fillSession.run(session_file);
@@ -393,7 +394,7 @@ export async function refreshRollups(opts?: RefreshOptions): Promise<void> {
 		const elapsed = performance.now() - started;
 		if (elapsed < REFRESH_TARGET_MS / 2) batch = Math.min(REFRESH_MAX_BATCH, batch * 2);
 		else if (elapsed > REFRESH_TARGET_MS * 2) batch = Math.max(1, Math.floor(batch / 2));
-		opts?.onProgress?.(getRollupStatus().dirtyHours);
+		if (opts?.onProgress) opts.onProgress(getRollupStatus().dirtyHours);
 		await Bun.sleep(0);
 	}
 }
@@ -416,7 +417,7 @@ interface Source {
 
 function dirtyIsSmall(database: Database): boolean {
 	const row = database
-		.prepare(`SELECT COUNT(*) AS n FROM (SELECT 1 FROM rollup_dirty LIMIT ${EXACT_DIRTY_LIMIT + 1})`)
+		.query(`SELECT COUNT(*) AS n FROM (SELECT 1 FROM rollup_dirty LIMIT ${EXACT_DIRTY_LIMIT + 1})`)
 		.get() as {
 		n: number;
 	};
@@ -508,7 +509,8 @@ function queryMessages<T>(window: Pick<RangeWindow, "cutoff"> & { bucketMs?: num
 	if (!database) return [];
 	const fine = window.bucketMs !== undefined && window.bucketMs < HOUR_MS;
 	const source = messageSource(database, normalizeCutoff(window.cutoff), fine);
-	return database.prepare(`SELECT ${select} FROM (${source.sql}) f ${tail}`).all(...source.params) as T[];
+	// `query` caches the compiled statement: the SQL varies only over a small set of shapes.
+	return database.query(`SELECT ${select} FROM (${source.sql}) f ${tail}`).all(...source.params) as T[];
 }
 
 function queryTools<T>(window: Pick<RangeWindow, "cutoff"> & { bucketMs?: number }, select: string, tail = ""): T[] {
@@ -516,7 +518,7 @@ function queryTools<T>(window: Pick<RangeWindow, "cutoff"> & { bucketMs?: number
 	if (!database) return [];
 	const fine = window.bucketMs !== undefined && window.bucketMs < HOUR_MS;
 	const source = toolSource(database, normalizeCutoff(window.cutoff), fine);
-	return database.prepare(`SELECT ${select} FROM (${source.sql}) f ${tail}`).all(...source.params) as T[];
+	return database.query(`SELECT ${select} FROM (${source.sql}) f ${tail}`).all(...source.params) as T[];
 }
 
 function normalizeCutoff(cutoff: number | null | undefined): number | null {
@@ -804,6 +806,25 @@ export function getProviderHourlyBurn(cutoff: number | null = null): ProviderHou
 	}));
 }
 
+/**
+ * Per-local-day request/token/cost totals since `cutoff`, oldest first, read
+ * from the hourly rollup. Returns null when the local UTC offset is not a whole
+ * hour (now or at `cutoff`), since hourly buckets then straddle local midnight,
+ * or while the dirty backlog is too large for exact reads; callers then
+ * aggregate the raw rows instead.
+ */
+export function getDailyActivityFromRollup(cutoff: number): DailyActivityPoint[] | null {
+	if (new Date().getTimezoneOffset() % 60 !== 0 || new Date(cutoff).getTimezoneOffset() % 60 !== 0) return null;
+	const database = currentDb();
+	if (!database || !dirtyIsSmall(database)) return null;
+	return queryMessages<{ day: string; cost: number; requests: number; total_tokens: number | null }>(
+		{ cutoff },
+		`date(f.bucket / 1000, 'unixepoch', 'localtime') AS day, TOTAL(f.cost_total) AS cost,
+		 SUM(f.requests) AS requests, SUM(f.total_tokens) AS total_tokens`,
+		"GROUP BY day ORDER BY day",
+	).map(row => ({ day: row.day, cost: row.cost, requests: row.requests, totalTokens: row.total_tokens ?? 0 }));
+}
+
 /** Tokens/cost per bucket per provider. */
 export function getProviderTimeSeries({ cutoff, bucketMs }: RangeWindow): ProviderTimeSeriesPoint[] {
 	return queryMessages<{
@@ -855,7 +876,7 @@ export function getSessionRollups(): SessionRollupRow[] {
 	const database = currentDb();
 	if (!database) return [];
 	const { n } = database
-		.prepare(`SELECT COUNT(*) AS n FROM (SELECT 1 FROM session_dirty LIMIT ${EXACT_DIRTY_SESSIONS + 1})`)
+		.query(`SELECT COUNT(*) AS n FROM (SELECT 1 FROM session_dirty LIMIT ${EXACT_DIRTY_SESSIONS + 1})`)
 		.get() as { n: number };
 	const exact = n <= EXACT_DIRTY_SESSIONS;
 	const parts = [
@@ -869,7 +890,7 @@ export function getSessionRollups(): SessionRollupRow[] {
 		);
 	}
 	return database
-		.prepare(
+		.query(
 			`SELECT session_file AS sessionFile, requests, started_at AS startedAt, ended_at AS endedAt,
 			 total_tokens AS totalTokens, cost_total AS costTotal, unpriced AS unpricedRequests, models,
 			 tool_calls AS toolCalls