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

package/dist/types/aggregator.d.ts

@@ -13,11 +13,14 @@ export declare function withStatsSyncLock<T>(dbPath: string, fn: () => Promise<T
  * `current` is the number of files completed (skipped + parsed),
  * `total` is the size of the work set. `processed` is the running total
  * of inserted rows. Parsed files are reported only after their batch commits.
+ * `changes` is the running total of stored rows the sync inserted, updated or
+ * deleted (0 while every transcript is unchanged).
  */
 export interface SyncProgress {
     current: number;
     total: number;
     processed: number;
+    changes: number;
     sessionFile: string;
 }
 export interface SyncOptions {

package/dist/types/client/api.d.ts

@@ -25,7 +25,11 @@ export declare function getProviderDashboardStats(range?: TimeRange, signal?: Ab
 /** Subscription-window insights (all providers) plus utilization series for `provider` only. */
 export declare function getProviderWindowStats(range: TimeRange, provider: string | null, signal?: AbortSignal): Promise<ProviderWindowStats>;
 export declare function getSessions(limit?: number, q?: string, signal?: AbortSignal): Promise<SessionSummary[]>;
-export declare function getSessionTrace(file: string, signal?: AbortSignal): Promise<SessionTrace>;
+/**
+ * Pass the last trace for `file` as `previous` to revalidate it: an unchanged
+ * trace resolves to that same object without downloading or parsing the body.
+ */
+export declare function getSessionTrace(file: string, signal?: AbortSignal, previous?: SessionTrace): Promise<SessionTrace>;
 /** Fetch one full journal entry for the span drawer. Entries are opaque JSON. */
 export declare function getSessionEntryDetail(file: string, id: string, signal?: AbortSignal): Promise<{
     entry: unknown;

package/dist/types/client/data/live.d.ts

@@ -3,18 +3,14 @@
  * version every query revalidates against, background ingest progress, and
  * the rollup indexing backlog.
  *
- * Any component can `useLive()`; queries (see `useQuery`) refetch whenever
- * `version` advances, so rows ingested in the background repaint the active
- * page without a manual refresh.
+ * The state lives in a module store read through narrow selectors, so a
+ * progress tick only re-renders what shows progress: `useLiveVersion()` for
+ * queries (see `useQuery`), `useLiveStatus()` for the chrome.
  */
 import { type ReactNode } from "react";
 import type { LiveSyncStatus } from "../types.js";
-export interface LiveState {
-    /**
-     * Client-side data version; bumps whenever the server's version changes
-     * (including after reconnecting to a restarted server).
-     */
-    version: number;
+/** Ingest status shown by the chrome. */
+export interface LiveStatusView {
     sync: LiveSyncStatus;
     /** Hours whose rollups are still being built; wide ranges may be incomplete. */
     indexingHours: number;
@@ -23,7 +19,16 @@ export interface LiveState {
     /** Ask the server to ingest new session data now. */
     requestSync: () => void;
 }
+/** Current data version, read outside render (e.g. when a fetch starts). */
+export declare function currentLiveVersion(): number;
+/** Owns the `/api/events` stream; mount once at the app root. */
 export declare function LiveProvider({ children }: {
     children: ReactNode;
-}): import("react").JSX.Element;
-export declare function useLive(): LiveState;
+}): ReactNode;
+/** Ingest status for the chrome; data-version bumps alone don't re-render. */
+export declare function useLiveStatus(): LiveStatusView;
+/**
+ * Data version for queries. Disabled (hidden) consumers read a constant -1 so
+ * live traffic never re-renders them.
+ */
+export declare function useLiveVersion(enabled?: boolean): number;

package/dist/types/client/data/query-store.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Framework-free query cache behind `useQuery`: per-key cached results in
+ * size-bounded buckets, and one shared in-flight request per key that is
+ * aborted once its last waiter leaves.
+ */
+export interface CacheEntry {
+    data: unknown;
+    updatedAt: number;
+    version: number;
+}
+export interface Inflight {
+    promise: Promise<unknown>;
+    controller: AbortController;
+    /** Queries (and prefetches) waiting on this request. */
+    waiters: number;
+}
+/** Handed to every fetcher. */
+export interface QueryFetchContext {
+    /** Aborted once no query waits for this request any more. */
+    signal: AbortSignal;
+}
+/**
+ * Loads one key's data. `previous` is the cached data for this key, for
+ * conditional revalidation; `undefined` on first load. It is a separate
+ * parameter so fetchers that ignore it still let `T` be inferred from their
+ * return type.
+ */
+export type QueryFetcher<T> = (context: QueryFetchContext, previous: T | undefined) => Promise<T>;
+export declare function cachedEntry(key: string): CacheEntry | undefined;
+/** The shared request currently running for `key`, if any. */
+export declare function inflightRequest(key: string): Inflight | undefined;
+/**
+ * Fetch into the cache (tagged with live data `version`), sharing one request
+ * among concurrent callers of the same key. The caller holds one waiter on
+ * the returned request; pair with {@link releaseQuery}.
+ */
+export declare function loadQuery<T>(key: string, version: number, fetcher: QueryFetcher<T>): Inflight;
+/** Drop one waiter; the last one out aborts the request. */
+export declare function releaseQuery(key: string, request: Inflight): void;

package/dist/types/client/data/query.d.ts

@@ -2,14 +2,19 @@
  * `useQuery`: cached, live-revalidating data fetching for dashboard pages.
  *
  * - Results are cached per key for the page session, so revisiting a page or
- *   a range renders instantly from memory.
+ *   a range renders instantly from memory. Multi-MB detail payloads (traces,
+ *   request details) live in their own small LRUs so they don't pile up.
  * - A key change keeps the previous key's data on screen (`stale: true`) until
  *   the new data lands, so charts morph instead of flashing skeletons.
  * - Every cached entry remembers the live data version it was fetched at
- *   (see `useLive`); when the version advances, enabled queries refetch in the
- *   background, throttled so a burst of ingest batches costs one request.
- * - Identical keys share one in-flight request.
+ *   (see `useLiveVersion`); when the version advances, enabled queries refetch
+ *   in the background, throttled so a burst of ingest batches costs one request.
+ * - Identical keys share one in-flight request; it is aborted once no query
+ *   waits for it any more.
+ * - Fetchers receive the cached data for their key, so conditional requests
+ *   can resolve to that same object; an unchanged reference does not re-render.
  */
+import { type QueryFetcher } from "./query-store.js";
 export interface QueryOptions {
     /** Only enabled queries fetch; hidden (kept-alive) pages pass `false`. Default true. */
     enabled?: boolean;
@@ -32,4 +37,4 @@ export interface QueryResult<T> {
 }
 /** Warm the cache for a key the user is likely to open next. No-op if cached for this version. */
 export declare function prefetchQuery<T>(key: readonly unknown[], fetcher: () => Promise<T>, version: number): void;
-export declare function useQuery<T>(key: readonly unknown[], fetcher: () => Promise<T>, options?: QueryOptions): QueryResult<T>;
+export declare function useQuery<T>(key: readonly unknown[], fetcher: QueryFetcher<T>, options?: QueryOptions): QueryResult<T>;

package/dist/types/client/traces/Minimap.d.ts

@@ -1,6 +1,8 @@
 /**
  * Timeline overview strip: per-category density over the full virtual domain
  * plus a draggable/resizable viewport brush, mirroring DevTools' overview.
+ * The density layer is painted once per trace/scale/size/theme into an
+ * offscreen canvas; pan and zoom only blit it and redraw the brush.
  */
 import type { TraceTrack } from "../types.js";
 import type { TimelineViewport } from "./TimelineCanvas.js";

package/dist/types/client/traces/TimelineCanvas.d.ts

@@ -1,10 +1,11 @@
 /**
- * The trace flamegraph: one DPR-scaled canvas with a DOM gutter (track/lane
- * labels, collapse chevrons) and a DOM tooltip. Implements the Chrome
- * DevTools interaction contract: cursor-anchored wheel zoom, drag pan, WASD,
- * fit/focus keys, hover tooltips, click-to-select, double-click-to-zoom.
+ * The trace flamegraph: a DPR-scaled scene canvas with DOM hover/selection
+ * boxes on top, a DOM gutter (track/lane labels, collapse chevrons) and a
+ * DOM tooltip. Implements the Chrome DevTools interaction contract:
+ * cursor-anchored wheel zoom, drag pan, WASD, fit/focus keys, hover tooltips,
+ * click-to-select, double-click-to-zoom.
  */
-import type { TraceTrack } from "../types.js";
+import type { TraceSpan, TraceTrack } from "../types.js";
 import { type TraceScale } from "./time-scale.js";
 export interface TimelineViewport {
     u0: number;
@@ -15,11 +16,31 @@ export interface TimelineCanvasProps {
     scale: TraceScale;
     viewport: TimelineViewport;
     onViewportChange: (viewport: TimelineViewport) => void;
-    selection: string | null;
+    /** The selected span with its track (resolved by the trace view). */
+    selected: {
+        span: TraceSpan;
+        track: TraceTrack;
+    } | null;
     onSelect: (spanId: string | null) => void;
-    search: string;
+    /** Spans matching the search; `null` when not searching (everything at full opacity). */
+    matchIds: ReadonlySet<string> | null;
     collapsed: ReadonlySet<string>;
     onToggleCollapse: (trackId: string) => void;
     traceStart: number;
 }
-export declare function TimelineCanvas({ tracks, scale, viewport, onViewportChange, selection, onSelect, search, collapsed, onToggleCollapse, traceStart, }: TimelineCanvasProps): import("react").JSX.Element;
+/** Per-lane span positions on the virtual axis, parallel to `LaneRow.spans`. */
+interface LaneAxis {
+    startU: Float64Array;
+    endU: Float64Array;
+    /** Running max of `endU`; monotonic, so the first visible span is a binary search away. */
+    maxEndU: Float64Array;
+}
+export declare function buildLaneAxes(layout: {
+    lanes: ReadonlyArray<{
+        spans: ReadonlyArray<Pick<TraceSpan, "start" | "end">>;
+    }>;
+}, scale: Pick<TraceScale, "toU">): LaneAxis[];
+/** First index whose running-max end reaches `u0`: every earlier span ends before the viewport. */
+export declare function firstVisible(maxEndU: Float64Array, u0: number): number;
+export declare function TimelineCanvas({ tracks, scale, viewport, onViewportChange, selected, onSelect, matchIds, collapsed, onToggleCollapse, traceStart, }: TimelineCanvasProps): import("react").JSX.Element;
+export {};

package/dist/types/client/traces/TranscriptList.d.ts

@@ -17,8 +17,10 @@ export interface TranscriptListProps {
     selection: string | null;
     onSelect: (spanId: string) => void;
     search: string;
+    /** Spans matching `search` (from the trace view); `null` when not searching. */
+    matchIds: ReadonlySet<string> | null;
     traceStart: number;
 }
 /** Flatten all spans and markers across tracks into chronological rows. */
 export declare function buildTranscriptRows(tracks: TraceTrack[]): TranscriptRow[];
-export declare function TranscriptList({ tracks, selection, onSelect, search, traceStart }: TranscriptListProps): import("react").JSX.Element;
+export declare const TranscriptList: import("react").MemoExoticComponent<({ tracks, selection, onSelect, search, matchIds, traceStart, }: TranscriptListProps) => import("react").JSX.Element>;

package/dist/types/db.d.ts

@@ -49,12 +49,23 @@ export interface ParsedSession {
     /** Recover missing rows from a full-history scan without rewriting unchanged records. */
     replay: boolean;
 }
-/** Commit distinct transcripts' rows, reconciliation state, and cursors together; failure rolls back the batch. */
+/**
+ * Commit distinct transcripts' rows, reconciliation state, and cursors together; failure rolls back the batch.
+ * `changes` counts stored rows inserted, updated or deleted (cursor bookkeeping excluded), so callers can
+ * tell a batch that changed nothing.
+ */
 export declare function applySessionParseResults(sessions: ParsedSession[]): {
     processed: number;
     files: number;
     reconcile: boolean;
+    changes: number;
 };
+/**
+ * SQLite `PRAGMA data_version` of the open connection, or null before
+ * {@link initDb}. It moves only when another connection (another omp process)
+ * commits, so a caller can detect foreign writes without scanning.
+ */
+export declare function getDataVersion(): number | null;
 export declare function prepareSessionSync(): boolean;
 export declare function completeSessionSync(reconcile: boolean): void;
 /**
@@ -90,7 +101,8 @@ export declare function getMessageById(id: number): MessageStats | null;
  * Self-initializing (opens the stats DB on first use) so the coding-agent TUI
  * can query without the dashboard server's init flow. Days use the machine's
  * timezone — this is a localhost tool, same rationale as
- * {@link getProviderHourlyBurn}.
+ * {@link getProviderHourlyBurn}. Reads the hourly rollup, falling back to the
+ * raw rows while its rebuild backlog is too large for exact reads.
  */
 export declare function getDailyActivity(days?: number): Promise<DailyActivityPoint[]>;
 /**

package/dist/types/embedded-client.d.ts

@@ -7,6 +7,11 @@
  * prepacked npm bundle, and reset to an empty file afterwards so the dev tree
  * 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 declare function hasEmbeddedClientArchive(txt: string): boolean;
 /**
  * Decode the generated archive text.
  *

package/dist/types/live.d.ts

@@ -5,11 +5,13 @@
  * 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 type { LiveStatus } from "./shared-types.js";
-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 declare class StatsLive {
     #private;

package/dist/types/rollup.d.ts

@@ -25,7 +25,7 @@
  * (an hour of data is small and indexed by timestamp).
  */
 import type { Database } from "bun:sqlite";
-import type { AgentTypeStats, AggregatedStats, CostTimeSeriesPoint, FolderStats, ModelPerformancePoint, ModelStats, ModelTimeSeriesPoint, ProviderAggregate, ProviderHourlyPoint, ProviderTimeSeriesPoint, TimeSeriesPoint, ToolModelStats, ToolTimeSeriesPoint, ToolUsageStats } from "./types.js";
+import type { AgentTypeStats, AggregatedStats, CostTimeSeriesPoint, DailyActivityPoint, FolderStats, ModelPerformancePoint, ModelStats, ModelTimeSeriesPoint, ProviderAggregate, ProviderHourlyPoint, ProviderTimeSeriesPoint, TimeSeriesPoint, ToolModelStats, ToolTimeSeriesPoint, ToolUsageStats } from "./types.js";
 /**
  * Create (or rebuild after a version bump) the rollup tables and the triggers
  * that mark hours dirty. Called from `initDb` after the raw tables exist.
@@ -87,6 +87,14 @@ export declare function getStatsByProvider(cutoff?: number | null): ProviderAggr
  * up to 30 minutes.
  */
 export declare function getProviderHourlyBurn(cutoff?: number | null): ProviderHourlyPoint[];
+/**
+ * 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 declare function getDailyActivityFromRollup(cutoff: number): DailyActivityPoint[] | null;
 /** Tokens/cost per bucket per provider. */
 export declare function getProviderTimeSeries({ cutoff, bucketMs }: RangeWindow): ProviderTimeSeriesPoint[];
 /** Per-transcript-file rollup for the Traces session list. */

package/dist/types/trace.d.ts

@@ -18,18 +18,30 @@ export declare class TracePathError extends Error {
  * against an unchanged transcript mtime.
  */
 export declare const TRACE_ETAG_VERSION = 3;
+/** Freshness of a root trace: root mtime plus the child-transcript set fingerprint. */
+export interface TraceFingerprint {
+    rootMtimeMs: number;
+    childFingerprint: string;
+}
 /**
- * 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 declare function traceFingerprintForEtag(fileParam: string): Promise<string | undefined>;
+export declare function traceFingerprintForEtag(fileParam: string): Promise<TraceFingerprint | undefined>;
 export declare function traceMemoForTests(): {
     file: string;
     mtimeMs: number;
 } | undefined;
-export declare 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 declare function buildSessionTrace(fileParam: string, fingerprint?: TraceFingerprint): Promise<SessionTrace>;
 /** Fetch one full journal entry by id from a transcript, for the span drawer. */
 export declare function getTraceEntry(fileParam: string, entryId: string): Promise<SessionEntry | null>;
 /**

package/dist/types/types.d.ts

@@ -33,6 +33,14 @@ export interface MessageStats {
     usage: Usage;
     /** Which agent produced this message (main agent, task subagent, advisor) */
     agentType: AgentType;
+    /**
+     * Service tier the provider reported serving this turn, or `null` when the
+     * provider reported none. Lets consumers separate a fast serving path's
+     * throughput and premium traffic from standard-tier traffic. Always written by
+     * `rowToMessageStats`; optional only because session fixtures that stand in
+     * for ingest input are typed as `MessageStats` too.
+     */
+    serviceTier?: ServiceTier | null;
     /**
      * Ingest refused to price this request: a scheduled (time-based) card with no
      * recoverable request timestamp, so `usage.cost.total` of 0 is unknown spend

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omp-stats",
-	"version": "18.6.3",
+	"version": "18.8.0",
 	"description": "Local observability dashboard for omp AI usage statistics",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -42,9 +42,9 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.6.3",
-		"@oh-my-pi/pi-catalog": "18.6.3",
-		"@oh-my-pi/pi-utils": "18.6.3",
+		"@oh-my-pi/pi-ai": "18.8.0",
+		"@oh-my-pi/pi-catalog": "18.8.0",
+		"@oh-my-pi/pi-utils": "18.8.0",
 		"lucide-react": "^1.24.0",
 		"react": "19.2.7",
 		"react-dom": "19.2.7"

package/src/aggregator.ts

@@ -85,11 +85,14 @@ export async function withStatsSyncLock<T>(dbPath: string, fn: () => Promise<T>)
  * `current` is the number of files completed (skipped + parsed),
  * `total` is the size of the work set. `processed` is the running total
  * of inserted rows. Parsed files are reported only after their batch commits.
+ * `changes` is the running total of stored rows the sync inserted, updated or
+ * deleted (0 while every transcript is unchanged).
  */
 export interface SyncProgress {
 	current: number;
 	total: number;
 	processed: number;
+	changes: number;
 	sessionFile: string;
 }
 
@@ -297,6 +300,7 @@ async function syncAllSessionsLocked(
 
 	const files = opts?.files ?? (await orderForIngest(await listAllSessionFiles()));
 	let totalProcessed = 0;
+	let totalChanges = 0;
 	let filesProcessed = 0;
 	let completed = 0;
 	let cursor = 0;
@@ -314,6 +318,7 @@ async function syncAllSessionsLocked(
 			current: completed,
 			total: files.length,
 			processed: totalProcessed,
+			changes: totalChanges,
 			sessionFile,
 		});
 	};
@@ -325,6 +330,7 @@ async function syncAllSessionsLocked(
 		pending = [];
 		pendingRows = 0;
 		totalProcessed += applied.processed;
+		totalChanges += applied.changes;
 		filesProcessed += applied.files;
 		reconcile ||= applied.reconcile;
 		// Report only durable progress: callbacks may interrupt the sync.
@@ -358,9 +364,9 @@ async function syncAllSessionsLocked(
 			metadataEnd = index + batch.length;
 			metadata = Promise.all(
 				batch.map(async sessionFile => {
+					const stored = offsets.get(sessionFile);
 					try {
-						const fileStats = await fs.promises.stat(sessionFile);
-						return { fileStats, stored: offsets.get(sessionFile) };
+						return { fileStats: await fs.promises.stat(sessionFile), stored };
 					} catch {
 						return {};
 					}
@@ -415,7 +421,13 @@ async function syncAllSessionsLocked(
 		if (pending.length >= SYNC_BATCH_FILES || pendingRows >= SYNC_BATCH_ROWS) flush();
 	};
 
-	const requestedWorkers = Math.max(1, Math.floor(opts?.workers ?? defaultWorkerCount()));
+	let requestedWorkers = Math.max(1, Math.floor(opts?.workers ?? defaultWorkerCount()));
+	// A few already-tracked transcripts (the watcher's usual work) need only
+	// kilobyte tail reads: parsing them inline beats starting a worker.
+	if (requestedWorkers > 1 && opts?.workers === undefined && files.length <= SYNC_INLINE_READS) {
+		const offsets = getFileOffsets([...files]);
+		if (files.every(file => offsets.get(file)?.parserState)) requestedWorkers = 1;
+	}
 	if (requestedWorkers === 1) {
 		for (let start = 0; start < files.length; start += SYNC_INLINE_READS) {
 			const results = await Promise.allSettled(
@@ -437,14 +449,20 @@ async function syncAllSessionsLocked(
 
 	const handles: WorkerHandle[] = [];
 
-	async function drain(handle: WorkerHandle): Promise<void> {
+	// Each lane spawns its worker on its first real parse, so unchanged transcripts cost no worker.
+	async function drain(): Promise<void> {
+		let handle: WorkerHandle | null = null;
 		try {
 			while (!failed) {
 				const idx = cursor++;
 				if (idx >= files.length) return;
-				const parsed = await prepareFile(idx, (file, fromOffset, parserState, replay) =>
-					dispatch(handle, { sessionFile: file, fromOffset, parserState, replay }),
-				);
+				const parsed = await prepareFile(idx, (file, fromOffset, parserState, replay) => {
+					if (!handle) {
+						handle = spawnWorker();
+						handles.push(handle);
+					}
+					return dispatch(handle, { sessionFile: file, fromOffset, parserState, replay });
+				});
 				if (!failed) acceptFile(files[idx], parsed);
 			}
 		} catch (error) {
@@ -454,9 +472,8 @@ async function syncAllSessionsLocked(
 	}
 
 	try {
-		for (let i = 0; i < poolSize; i++) handles.push(spawnWorker());
 		// Drain in-flight work before releasing the sync lock, even after a failed batch.
-		const results = await Promise.allSettled(handles.map(drain));
+		const results = await Promise.allSettled(Array.from({ length: poolSize }, drain));
 		for (const result of results) {
 			if (result.status === "rejected") throw result.reason;
 		}

package/src/client/api.ts

@@ -45,12 +45,34 @@ async function readErrorMessage(res: Response, endpoint: string): Promise<string
 	return `HTTP error ${res.status} on ${endpoint}`;
 }
 
-async function fetchJson<T>(endpoint: string, options?: RequestInit): Promise<T> {
-	const res = await fetch(endpoint, options);
+/**
+ * Response validators keyed by the parsed body they describe. Revalidating a
+ * body sends its ETag; the entry dies with the body when callers drop it.
+ */
+const validators = new WeakMap<object, string>();
+
+/**
+ * Fetch `endpoint` as JSON, revalidating `previous` when it came from an
+ * ETag-bearing response: a 304 resolves to `previous` itself (same reference,
+ * no re-parse).
+ */
+async function fetchJson<T>(endpoint: string, options?: RequestInit, previous?: T): Promise<T> {
+	const etag = typeof previous === "object" && previous !== null ? validators.get(previous) : undefined;
+	let init = options;
+	if (etag) {
+		const headers = new Headers(options?.headers);
+		headers.set("If-None-Match", etag);
+		init = { ...options, headers };
+	}
+	const res = await fetch(endpoint, init);
+	if (res.status === 304 && etag) return previous as T;
 	if (!res.ok) {
 		throw new ApiError(res.status, endpoint, await readErrorMessage(res, endpoint));
 	}
-	return res.json() as Promise<T>;
+	const data = (await res.json()) as T;
+	const nextEtag = res.headers.get("ETag");
+	if (nextEtag && typeof data === "object" && data !== null) validators.set(data, nextEtag);
+	return data;
 }
 
 /**
@@ -182,8 +204,21 @@ export async function getSessions(limit = 100, q?: string, signal?: AbortSignal)
 	return fetchJson<SessionSummary[]>(`${API_BASE}/sessions?${params}`, { signal });
 }
 
-export async function getSessionTrace(file: string, signal?: AbortSignal): Promise<SessionTrace> {
-	return fetchJson<SessionTrace>(`${API_BASE}/session/trace?file=${encodeURIComponent(file)}`, { signal });
+/**
+ * Pass the last trace for `file` as `previous` to revalidate it: an unchanged
+ * trace resolves to that same object without downloading or parsing the body.
+ */
+export async function getSessionTrace(
+	file: string,
+	signal?: AbortSignal,
+	previous?: SessionTrace,
+): Promise<SessionTrace> {
+	// `no-store`: validation is ours (above); the browser cache would only keep a second multi-MB copy.
+	return fetchJson<SessionTrace>(
+		`${API_BASE}/session/trace?file=${encodeURIComponent(file)}`,
+		{ signal, cache: "no-store" },
+		previous,
+	);
 }
 
 /** Fetch one full journal entry for the span drawer. Entries are opaque JSON. */

package/src/client/app/LiveChip.tsx

@@ -1,12 +1,12 @@
 import { RefreshCw } from "lucide-react";
 import { type ReactNode, useEffect, useState } from "react";
 import { formatInteger } from "../data/formatters";
-import { useLive } from "../data/live";
+import { useLiveStatus } from "../data/live";
 import { Dot } from "../ui";
 
 /** Topbar ingest status; click to sync now. */
 export function LiveChip() {
-	const { sync, indexingHours, connected, requestSync } = useLive();
+	const { sync, indexingHours, connected, requestSync } = useLiveStatus();
 	const now = useNow(sync.phase === "idle" ? 15_000 : null);
 
 	let body: ReactNode;

package/src/client/app/Shell.tsx

@@ -1,7 +1,7 @@
 import { Menu } from "lucide-react";
 import { type ReactNode, useEffect, useState } from "react";
 import { rangeMeta, TIME_RANGES } from "../data/range";
-import { useLive } from "../data/live";
+import { useLiveStatus } from "../data/live";
 import type { TimeRange } from "../types";
 import { Segmented } from "../ui";
 import { LiveChip } from "./LiveChip";
@@ -30,7 +30,7 @@ const RANGE_OPTIONS = TIME_RANGES.map((range, i) => ({
 export function Shell({ section, onSectionChange, range, onRangeChange, children }: ShellProps) {
 	const [menuOpen, setMenuOpen] = useState(false);
 	const scrolled = useScrolled();
-	const { sync } = useLive();
+	const { sync } = useLiveStatus();
 	useShortcuts(onSectionChange, onRangeChange);
 
 	const go = (next: DashboardSection) => {