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

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

@@ -688,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();

package/src/trace.ts

@@ -750,11 +750,6 @@ async function buildTrackTree(
 // ---------------------------------------------------------------------------
 // Public surface
 
-/**
- * Assemble the full span tree for one root session transcript.
- * Throws {@link TracePathError} for paths outside the sessions root; ENOENT
- * passes through for the caller's 404 mapping.
- */
 // Single-entry memo: the dashboard polls one open trace every 15s. Keyed on
 // the root file's mtime PLUS a fingerprint of the child-transcript SET under
 // the root's artifacts tree (one cheap readdir+stat walk, no parse). A
@@ -788,35 +783,46 @@ async function childTranscriptsFingerprint(rootFile: string, depth = 0): Promise
 		return "";
 	}
 	names.sort();
+	const dir = transcriptStem(rootFile);
 	const transcriptNames = names.filter(name => name.endsWith(".jsonl") || name.endsWith(".jsonl.gz"));
-	const parts: string[] = [`n=${transcriptNames.length}`];
-	for (const name of transcriptNames) {
-		const childFile = path.join(transcriptStem(rootFile), name);
-		try {
-			const stat = await fs.stat(childFile);
-			parts.push(`${name}@${stat.mtimeMs}`);
-			// Recurse like the builder (nested subagents), without parsing.
-			const nested = await childTranscriptsFingerprint(childFile, depth + 1);
-			if (nested) parts.push(`${name}/{${nested}}`);
-		} catch {
-			parts.push(`${name}@gone`);
-		}
-	}
-	return parts.join(",");
+	const childParts = await Promise.all(
+		transcriptNames.map(async name => {
+			const childFile = path.join(dir, name);
+			try {
+				const stat = await fs.stat(childFile);
+				// Recurse like the builder (nested subagents), without parsing.
+				const nested = await childTranscriptsFingerprint(childFile, depth + 1);
+				return nested ? `${name}@${stat.mtimeMs},${name}/{${nested}}` : `${name}@${stat.mtimeMs}`;
+			} catch {
+				return `${name}@gone`;
+			}
+		}),
+	);
+	return [`n=${transcriptNames.length}`, ...childParts].join(",");
+}
+
+/** Freshness of a root trace: root mtime plus the child-transcript set fingerprint. */
+export interface TraceFingerprint {
+	rootMtimeMs: number;
+	childFingerprint: string;
+}
+
+/** Stat the root and walk its child transcripts (readdir+stat, no parse). */
+async function readTraceFingerprint(resolved: string): Promise<TraceFingerprint> {
+	const rootMtimeMs = (await fs.stat(resolved)).mtimeMs;
+	const childFingerprint = await childTranscriptsFingerprint(resolved);
+	return { rootMtimeMs, childFingerprint };
 }
 
 /**
- * Freshness fingerprint for the trace ETag pre-check: root mtime plus the
- * child-transcript set fingerprint (readdir+stat walk, no parse). Returns
- * undefined when the path is rejected or missing (the caller falls through
- * to the full build, which maps those to 400/404).
+ * Freshness fingerprint for the trace ETag pre-check; `SessionTrace.etag` is
+ * `${rootMtimeMs}:${childFingerprint}` for an unraced build. Returns undefined
+ * when the path is rejected or missing (the caller falls through to the full
+ * build, which maps those to 400/404).
  */
-export async function traceFingerprintForEtag(fileParam: string): Promise<string | undefined> {
+export async function traceFingerprintForEtag(fileParam: string): Promise<TraceFingerprint | undefined> {
 	try {
-		const resolved = resolveSessionPath(fileParam);
-		const rootMs = (await fs.stat(resolved)).mtimeMs;
-		const childFp = await childTranscriptsFingerprint(resolved);
-		return `${rootMs}:${childFp}`;
+		return await readTraceFingerprint(resolveSessionPath(fileParam));
 	} catch {
 		return undefined;
 	}
@@ -827,16 +833,22 @@ export function traceMemoForTests(): { file: string; mtimeMs: number } | undefin
 	return { file: traceMemo.file, mtimeMs: traceMemo.entry.mtimeMs };
 }
 
-export async function buildSessionTrace(fileParam: string): Promise<SessionTrace> {
+/**
+ * Assemble the full span tree for one root session transcript.
+ * Throws {@link TracePathError} for paths outside the sessions root; ENOENT
+ * passes through for the caller's 404 mapping. `fingerprint` may carry the
+ * {@link traceFingerprintForEtag} value the caller just computed for the same
+ * file (its ETag pre-check), sparing a second walk.
+ */
+export async function buildSessionTrace(fileParam: string, fingerprint?: TraceFingerprint): Promise<SessionTrace> {
 	const resolved = resolveSessionPath(fileParam);
-	const rootStat = await fs.stat(resolved);
 	const memo = traceMemo?.file === resolved ? traceMemo.entry : undefined;
 	// Pre-build child fingerprint on EVERY path (hit check and rebuild
 	// alike): the post-build race guard compares against this, so a child
 	// append landing mid-parse is detected even on first builds and
 	// memo-less rebuilds, where no prior fingerprint exists to compare.
-	const preChildFingerprint = await childTranscriptsFingerprint(resolved);
-	if (memo && memo.mtimeMs === rootStat.mtimeMs) {
+	const { rootMtimeMs, childFingerprint: preChildFingerprint } = fingerprint ?? (await readTraceFingerprint(resolved));
+	if (memo && memo.mtimeMs === rootMtimeMs) {
 		// Equality, not <=: a LOWER mark (delete/older-mtime replace) is
 		// also stale — only an identical child set may reuse the trace.
 		if (preChildFingerprint === memo.childFingerprint) return memo.trace;
@@ -901,7 +913,7 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 		else if (span.kind === "turn") turns++;
 	}
 
-	const start = startedAt ?? rootScan.headerTs ?? rootStat.mtimeMs;
+	const start = startedAt ?? rootScan.headerTs ?? rootMtimeMs;
 	const end = endedAt ?? start;
 	const wallMs = end - start;
 
@@ -925,7 +937,7 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 	// neither the trace nor the key.
 	const childFingerprint = await childTranscriptsFingerprint(resolved);
 	// Root rewritten mid-build: same no-cache rule as the child race below.
-	const rootChanged = (await fs.stat(resolved).catch(() => null))?.mtimeMs !== rootStat.mtimeMs;
+	const rootChanged = (await fs.stat(resolved).catch(() => null))?.mtimeMs !== rootMtimeMs;
 	const raced = childFingerprint !== preChildFingerprint;
 	// Raced builds keep the PRE-build fingerprint as their ETag: the parsed
 	// bytes predate the racy write, so claiming the post-write state would
@@ -941,15 +953,15 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 		cwd: rootScan.cwd,
 		startedAt: start,
 		endedAt: end,
-		mtimeMs: rootStat.mtimeMs,
-		etag: `${rootStat.mtimeMs}:${etagFingerprint}`,
+		mtimeMs: rootMtimeMs,
+		etag: `${rootMtimeMs}:${etagFingerprint}`,
 		tracks,
 		summary,
 	};
 	if (!raced && !rootChanged) {
 		traceMemo = {
 			file: resolved,
-			entry: { mtimeMs: rootStat.mtimeMs, childFingerprint, trace },
+			entry: { mtimeMs: rootMtimeMs, childFingerprint, trace },
 		};
 	}
 	return trace;
@@ -1068,7 +1080,8 @@ function basenameTimestamp(base: string): number | undefined {
 // Short-TTL memo for the disk sweep behind /api/sessions (30s poll): the
 // session list changes only on create/edit, so readdir+stat of every file per
 // poll is pure syscall churn. TTL is deliberately short so a just-created
-// session appears within seconds.
+// session appears within seconds. Only the newest `limit` roots are kept, so
+// the memo stays small however many sessions exist.
 let diskRootsMemo:
 	| {
 			atMs: number;
@@ -1117,8 +1130,9 @@ async function scanDiskRoots(limit: number): Promise<Array<{ file: string; mtime
 		}),
 	);
 	roots.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	if (roots.length <= 1000) diskRootsMemo = { atMs: Date.now(), sessionsDir, limit, roots };
-	return roots.slice(0, limit);
+	const newest = roots.slice(0, limit);
+	diskRootsMemo = { atMs: Date.now(), sessionsDir, limit, roots: newest };
+	return newest.slice();
 }
 
 /**