@oh-my-pi/omp-stats 18.6.3 → 18.8.0

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/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 "@oh-my-pi/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/parser.ts

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import {
 	type AssistantMessage,
 	coerceServiceTierByFamily,
-	getPriorityPremiumRequests,
+	getPremiumServiceTierRequests,
+	parseServiceTier,
 	resolveModelServiceTier,
 	type ServiceTierByFamily,
 	type ToolCall,
@@ -236,20 +237,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) &&
@@ -291,6 +298,7 @@ function extractStats(
 		errorMessage: msg.errorMessage ?? null,
 		usage,
 		agentType,
+		serviceTier: servedTier ?? null,
 	};
 }
 
@@ -680,14 +688,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) {
-		const files = await listSessionFiles(folder);
-		allFiles.push(...files);
-	}
-
-	return allFiles;
+	return (await Promise.all(folders.map(listSessionFiles))).flat();
 }
 
 /**

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

package/src/server.ts

@@ -14,9 +14,11 @@ import {
 	getRecentErrors,
 	getRecentRequests,
 	getRequestDetails,
+	getTimeRangeConfig,
 	getToolDashboardStats,
 } from "./aggregator";
-import { decodeEmbeddedClientArchive } from "./embedded-client";
+import { initDb } from "./db";
+import { decodeEmbeddedClientArchive, hasEmbeddedClientArchive } from "./embedded-client";
 import embeddedClientArchiveTxt from "./embedded-client.generated.txt";
 import {
 	cancelFrustrationRun,
@@ -36,18 +38,17 @@ import {
 	STATS_DASHBOARD_HOSTNAME_HEADER,
 	STATS_DASHBOARD_SECURITY_VERSION,
 } from "./port-conflict";
-import type { LiveStatus } from "./shared-types";
+import { getStatsByModel, getTimeSeries } from "./rollup";
 import {
 	buildSessionTrace,
 	getTraceEntry,
 	listSessionSummaries,
 	TRACE_ETAG_VERSION,
+	type TraceFingerprint,
 	traceFingerprintForEtag,
 	TracePathError,
 } from "./trace";
 
-const EMBEDDED_CLIENT_ARCHIVE = decodeEmbeddedClientArchive(embeddedClientArchiveTxt);
-
 const CLIENT_DIR = path.join(import.meta.dir, "client");
 const STATIC_DIR = path.join(import.meta.dir, "..", "dist", "client");
 const IS_BUN_COMPILED =
@@ -60,21 +61,24 @@ const IS_BUN_COMPILED =
 // dashboard sources or prebuilt dist/client next to the bundle, so the
 // embedded archive is the only viable asset source.
 const IS_PREBUILT = IS_BUN_COMPILED || Boolean(process.env.PI_BUNDLED || Bun.env.PI_BUNDLED);
-const USE_EMBEDDED_CLIENT = EMBEDDED_CLIENT_ARCHIVE !== null || IS_PREBUILT;
+// Sniff the base64 gzip magic instead of decoding: importing this module (every
+// TUI start) must not pay for a multi-megabyte archive nobody may serve.
+const USE_EMBEDDED_CLIENT = hasEmbeddedClientArchive(embeddedClientArchiveTxt) || IS_PREBUILT;
 
 let embeddedClientFilesPromise: Promise<Map<string, Blob>> | null = null;
 
 async function getEmbeddedClientFiles(): Promise<Map<string, Blob>> {
 	if (embeddedClientFilesPromise) return embeddedClientFilesPromise;
 
-	if (!EMBEDDED_CLIENT_ARCHIVE) {
+	const archive = decodeEmbeddedClientArchive(embeddedClientArchiveTxt);
+	if (!archive) {
 		throw new Error(
 			"Embedded stats client bundle missing. Rebuild the omp binary or npm bundle with embedded stats assets.",
 		);
 	}
 
 	// Keep bundled assets in memory so OS temporary-file cleanup cannot break a live dashboard.
-	embeddedClientFilesPromise = new Bun.Archive(EMBEDDED_CLIENT_ARCHIVE).files().then(files => {
+	embeddedClientFilesPromise = new Bun.Archive(archive).files().then(files => {
 		for (const [name, file] of files) {
 			// Archive entries are untyped blobs; infer MIME types just as disk-backed Bun files do.
 			files.set(name, new File([file], name, { type: Bun.file(name).type }));
@@ -241,8 +245,9 @@ export async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/stats/models") {
-		const stats = await getDashboardStats(range);
-		return Response.json(stats.byModel);
+		// Also the port-conflict identity probe: keep it to the one query it serves.
+		await initDb();
+		return Response.json(getStatsByModel(getTimeRangeConfig(range).cutoff));
 	}
 
 	if (path === "/api/stats/folders") {
@@ -251,8 +256,8 @@ export async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/stats/timeseries") {
-		const stats = await getDashboardStats(range);
-		return Response.json(stats.timeSeries);
+		await initDb();
+		return Response.json(getTimeSeries(getTimeRangeConfig(range)));
 	}
 
 	if (path.startsWith("/api/request/")) {
@@ -293,14 +298,15 @@ export async function handleApi(req: Request): Promise<Response> {
 			// The fingerprint covers child transcripts, so a subagent-only
 			// append changes the ETag and never 304s stale.
 			const clientEtag = req.headers.get("if-none-match");
+			let fingerprint: TraceFingerprint | undefined;
 			if (clientEtag) {
-				const fingerprint = await traceFingerprintForEtag(file);
+				fingerprint = await traceFingerprintForEtag(file);
 				if (fingerprint !== undefined) {
-					const etag = `"${TRACE_ETAG_VERSION}:${fingerprint}"`;
+					const etag = `"${TRACE_ETAG_VERSION}:${fingerprint.rootMtimeMs}:${fingerprint.childFingerprint}"`;
 					if (clientEtag === etag) return new Response(null, { status: 304 });
 				}
 			}
-			const trace = await buildSessionTrace(file);
+			const trace = await buildSessionTrace(file, fingerprint);
 			const etag = `"${TRACE_ETAG_VERSION}:${trace.etag}"`;
 			if (clientEtag === etag) return new Response(null, { status: 304 });
 			return Response.json(trace, { headers: { ETag: etag } });
@@ -383,7 +389,7 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 			if (path === "/api/events") {
 				// Long-lived stream: exempt from the idle timeout.
 				server.timeout(req, 0);
-				return liveEventStream(dashboardHeaders);
+				return liveEventStream(dashboardHeaders, req.signal);
 			}
 
 			try {
@@ -423,8 +429,9 @@ const EVENT_HEARTBEAT_MS = 15_000;
 /**
  * Server-sent events of {@link LiveStatus}: the current status immediately,
  * then every change (sync progress, data version bumps, indexing backlog).
+ * Disconnects unsubscribe, so ingest winds down once no page is listening.
  */
-function liveEventStream(headers: Record<string, string>): Response {
+function liveEventStream(headers: Record<string, string>, signal: AbortSignal): Response {
 	const live = statsLive();
 	// Ingest starts when the first page connects, not when the server binds.
 	live.start();
@@ -432,19 +439,26 @@ function liveEventStream(headers: Record<string, string>): Response {
 	let cleanup = () => {};
 	const stream = new ReadableStream<Uint8Array>({
 		start(controller) {
-			const send = (status: LiveStatus) => {
-				controller.enqueue(encoder.encode(`data: ${JSON.stringify(status)}\n\n`));
+			const write = (chunk: string) => {
+				try {
+					controller.enqueue(encoder.encode(chunk));
+				} catch {
+					// Stream already closed: the client left without a cancel.
+					cleanup();
+				}
 			};
-			send(live.status());
-			const unsubscribe = live.subscribe(send);
-			const heartbeat = setInterval(
-				() => controller.enqueue(encoder.encode(": keep-alive\n\n")),
-				EVENT_HEARTBEAT_MS,
-			);
+			write(`data: ${JSON.stringify(live.status())}\n\n`);
+			const unsubscribe = live.subscribe((_status, frame) => write(`data: ${frame}\n\n`));
+			const heartbeat = setInterval(() => write(": keep-alive\n\n"), EVENT_HEARTBEAT_MS);
+			const onAbort = () => cleanup();
 			cleanup = () => {
+				cleanup = () => {};
 				unsubscribe();
 				clearInterval(heartbeat);
+				signal.removeEventListener("abort", onAbort);
 			};
+			if (signal.aborted) cleanup();
+			else signal.addEventListener("abort", onAbort, { once: true });
 		},
 		cancel() {
 			cleanup();