ompchamber 3.1.1 → 3.2.0

package/src/server/lib/omp/session/scan.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * One oh-my-pi session file → its compact sidebar summary.
+ *
+ * Split out of `./files` so that module holds only the cache layer (the
+ * mtime-keyed file list, the per-file memo, and the `id → path` index) while
+ * this one holds the read: a 4 KiB prefix window for the header, title and
+ * first message, plus a bounded tail window for last activity. Nothing here
+ * touches a cache, so a scan is always a real read of the file's current bytes.
+ *
+ * File layout: optional fixed-width 256-byte title-slot line, then the
+ * {"type":"session"} header line, then message entries. Legacy pi v1/v2 shapes
+ * parse leniently (raw-text scans); nothing here mutates on-disk data.
+ */
+
+import { readLastEntryTimestamp, readTextPrefix, SESSION_LIST_PREFIX_BYTES } from '@/server/lib/omp/session/file-scan';
+import { countMessageMarkers, extractFirstDisplayMessageFromPrefix, extractTextFromContent, parseJsonlLenient, parseSessionListHeader } from '@/shared/lib/omp/session/jsonl';
+
+export const SESSION_TITLE_SLOT_BYTES = 256;
+
+/** Compact summary of one session file — the sidebar list row. */
+export interface OmpSessionInfo {
+  /** Absolute path of the .jsonl file. */
+  path: string;
+  id: string;
+  /** Working directory the session ran in (from the header). */
+  cwd: string;
+  /** User-facing title (title slot wins; falls back to header title). */
+  title?: string;
+  parentSessionPath?: string;
+  created: Date;
+  /** Last activity: the newest JSONL entry's own `timestamp`, falling back to
+   *  the file mtime for a file the tail window cannot date. */
+  modified: Date;
+  /** Filesystem mtime. Scan-cache version only — never user-visible, and never
+   *  an ordering key (see readLastEntryTimestamp for why). */
+  fileMtime: Date;
+  /**
+   * The same mtime as a raw `stat.mtimeMs`. The cache compares THIS, not
+   * `fileMtime`: `Date.getTime()` truncates the fractional millisecond that
+   * APFS/HFS+ report, so comparing the Date never matched and the cache never
+   * hit — every request re-read 452 files' prefix and tail (measured 36-45 ms
+   * warm against 5.6 ms with the raw key).
+   */
+  fileMtimeMs: number;
+  messageCount: number;
+  size: number;
+  firstMessage: string;
+}
+
+/**
+ * Scan a single session file into an OmpSessionInfo from a 4 KiB prefix window
+ * (header, title, first message) plus a bounded tail window (last activity).
+ * Faithful port of omp's scanSessionFile except for `modified`, which is the
+ * last entry's timestamp rather than the file mtime. Missing/unreadable/
+ * header-less files yield undefined instead of throwing.
+ */
+export async function scanSessionInfo(filePath: string): Promise<OmpSessionInfo | undefined> {
+  try {
+    const { text: prefix, size, mtime, mtimeMs } = await readTextPrefix(filePath, SESSION_LIST_PREFIX_BYTES);
+    const lastEntryAt = await readLastEntryTimestamp(filePath, size, prefix);
+    const entries = parseJsonlLenient<Record<string, unknown>>(prefix);
+    const header = parseSessionListHeader(prefix, entries);
+    if (!header) return undefined;
+
+    let parsedMessageCount = 0;
+    let firstMessage = '';
+    let shortSummary: string | undefined;
+    for (let i = 1; i < entries.length; i++) {
+      const entry = entries[i] as {
+        type?: string;
+        message?: { role?: string; content?: unknown };
+        shortSummary?: string;
+      };
+      if (entry.type === 'compaction' && typeof entry.shortSummary === 'string') {
+        shortSummary = entry.shortSummary;
+      }
+      if (entry.type === 'message' && entry.message) {
+        parsedMessageCount++;
+        if (entry.message.role === 'user' && !firstMessage) {
+          firstMessage = extractTextFromContent(entry.message.content);
+        }
+      }
+    }
+
+    firstMessage ||= extractFirstDisplayMessageFromPrefix(prefix) ?? '';
+    return {
+      path: filePath,
+      id: header.id,
+      cwd: header.cwd ?? '',
+      title: header.title ?? shortSummary,
+      parentSessionPath: header.parentSession,
+      created: new Date(header.timestamp ?? ''),
+      modified: lastEntryAt ?? mtime,
+      fileMtime: mtime,
+      fileMtimeMs: mtimeMs,
+      messageCount: Math.max(parsedMessageCount, countMessageMarkers(prefix)),
+      size,
+      firstMessage: firstMessage || '(no messages)',
+    };
+  } catch {
+    return undefined;
+  }
+}

package/src/server/lib/omp/session/stats.ts

@@ -9,8 +9,7 @@
  * jsonl file (v3 format — see docs in lib/omp/session).
  */
 
-import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
-import type { OmpMessageEntry } from '@/shared/types/omp/session';
+import { loadSessionEntries } from '@/server/lib/omp/session/telemetry/scan';
 
 export interface SessionStats {
   /** Model switch history (most settings tabs show only the latest). */
@@ -29,57 +28,58 @@ export interface SessionStats {
 const MAX_SESSION_BYTES = 64 * 1024 * 1024;
 
 export async function readSessionStats(filePath: string): Promise<SessionStats | undefined> {
+  let size: number;
   try {
-    const file = Bun.file(filePath);
-    if ((await file.stat()).size > MAX_SESSION_BYTES) return undefined;
-    const entries = parseJsonlLenient<OmpMessageEntry>(await file.text());
-    const stats: SessionStats = {
-      models: [],
-      thinkingLevels: [],
-      compactions: 0,
-      messageCount: 0,
-      assistantMessageCount: 0,
-      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 },
-      cost: { total: 0 },
-    };
-    for (const entry of entries) {
-      const ts = typeof entry.timestamp === 'string' ? entry.timestamp : undefined;
-      if (ts) {
-        stats.startedAt ??= ts;
-        stats.lastActivityAt = ts;
-      }
-      switch (entry.type) {
-        case 'model_change':
-          if (typeof entry.model === 'string' && ts) stats.models.push({ model: entry.model, at: ts });
-          break;
-        case 'thinking_level_change':
-          if (typeof entry.thinkingLevel === 'string' && ts) stats.thinkingLevels.push({ level: entry.thinkingLevel, at: ts });
-          break;
-        case 'compaction':
-          stats.compactions++;
-          break;
-        case 'message': {
-          const message = entry.message;
-          if (!message) break;
-          stats.messageCount++;
-          if (message.role === 'assistant') stats.assistantMessageCount++;
-          const usage = message.usage;
-          if (usage) {
-            stats.tokens.input += usage.input ?? 0;
-            stats.tokens.output += usage.output ?? 0;
-            stats.tokens.cacheRead += usage.cacheRead ?? 0;
-            stats.tokens.cacheWrite += usage.cacheWrite ?? 0;
-            stats.tokens.reasoning += usage.reasoningTokens ?? 0;
-            stats.cost.total += usage.cost?.total ?? 0;
-          }
-          break;
+    size = (await Bun.file(filePath).stat()).size;
+  } catch {
+    return undefined;
+  }
+  if (size > MAX_SESSION_BYTES) return undefined;
+  const entries = await loadSessionEntries(filePath);
+  const stats: SessionStats = {
+    models: [],
+    thinkingLevels: [],
+    compactions: 0,
+    messageCount: 0,
+    assistantMessageCount: 0,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 },
+    cost: { total: 0 },
+  };
+  for (const entry of entries) {
+    const ts = typeof entry.timestamp === 'string' ? entry.timestamp : undefined;
+    if (ts) {
+      stats.startedAt ??= ts;
+      stats.lastActivityAt = ts;
+    }
+    switch (entry.type) {
+      case 'model_change':
+        if (typeof entry.model === 'string' && ts) stats.models.push({ model: entry.model, at: ts });
+        break;
+      case 'thinking_level_change':
+        if (typeof entry.thinkingLevel === 'string' && ts) stats.thinkingLevels.push({ level: entry.thinkingLevel, at: ts });
+        break;
+      case 'compaction':
+        stats.compactions++;
+        break;
+      case 'message': {
+        const message = entry.message;
+        if (!message) break;
+        stats.messageCount++;
+        if (message.role === 'assistant') stats.assistantMessageCount++;
+        const usage = message.usage;
+        if (usage) {
+          stats.tokens.input += usage.input ?? 0;
+          stats.tokens.output += usage.output ?? 0;
+          stats.tokens.cacheRead += usage.cacheRead ?? 0;
+          stats.tokens.cacheWrite += usage.cacheWrite ?? 0;
+          stats.tokens.reasoning += usage.reasoningTokens ?? 0;
+          stats.cost.total += usage.cost?.total ?? 0;
         }
-        default:
-          break;
+        break;
       }
+      default:
+        break;
     }
-    return stats;
-  } catch {
-    return undefined;
   }
+  return stats;
 }

package/src/server/lib/omp/session/telemetry/scan.ts

@@ -1,18 +1,100 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The JSONL pass behind both telemetry endpoints.
+ *
+ * `visit` is called per entry and may return `false` to stop early. The parse
+ * itself is cached by `(path, size, mtimeMs)`, because `/api/telemetry/context`
+ * and `/api/telemetry/raw-messages` are two polling endpoints that parse the
+ * SAME file — measured 70.6 ms and 64.2 ms on an 11 MB session, per request,
+ * with no cache between them. One parse now serves both until the file moves.
+ *
+ * The cache is keyed on the raw `stat.mtimeMs`, never a `Date`: `getTime()`
+ * truncates the fractional millisecond APFS reports, which is what made the
+ * session-scan cache miss on every call (see files.ts).
+ */
+
 import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
 import type { OmpMessageEntry } from '@/shared/types/omp/session';
 
-/** Streaming JSONL pass for the telemetry builders; `visit` returns `false` to stop early. */
-export async function scanSessionEntries(
-  filePath: string,
-  visit: (entry: OmpMessageEntry, index: number) => boolean | void,
-): Promise<void> {
+/** Sessions larger than this are not cached; a transcript past it is pathological. */
+const MAX_CACHED_SESSION_BYTES = 64 * 1024 * 1024;
+/** Bound on remembered transcripts, so a long session list cannot retain them all. */
+const MAX_CACHED_SESSIONS = 16;
+
+interface CachedEntries {
+  size: number;
+  mtimeMs: number;
+  entries: OmpMessageEntry[];
+}
+
+interface ScanCacheHost {
+  entries: Map<string, CachedEntries>;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberTelemetryScanCache: ScanCacheHost | undefined;
+}
+
+function cache(): Map<string, CachedEntries> {
+  globalThis.__ompChamberTelemetryScanCache ??= { entries: new Map() };
+  return globalThis.__ompChamberTelemetryScanCache.entries;
+}
+
+/**
+ * Every entry of `filePath`, parsed once per file version.
+ *
+ * Callers must treat the returned array (and its entries) as immutable — the
+ * same array is handed to the next caller, and the builders only read.
+ */
+export async function loadSessionEntries(filePath: string): Promise<OmpMessageEntry[]> {
+  let size: number;
+  let mtimeMs: number;
+  try {
+    const stat = await Bun.file(filePath).stat();
+    size = stat.size;
+    mtimeMs = stat.mtimeMs;
+  } catch {
+    return [];
+  }
+
+  const slot = cache();
+  const cached = slot.get(filePath);
+  if (cached && cached.size === size && cached.mtimeMs === mtimeMs) {
+    // Refresh insertion order so the bound evicts the least recently used.
+    slot.delete(filePath);
+    slot.set(filePath, cached);
+    return cached.entries;
+  }
+
   let body: string;
   try {
     body = await Bun.file(filePath).text();
   } catch {
-    return;
+    return [];
   }
-  const records = parseJsonlLenient<OmpMessageEntry>(body);
+  const entries = parseJsonlLenient<OmpMessageEntry>(body);
+  if (size <= MAX_CACHED_SESSION_BYTES) {
+    slot.set(filePath, { size, mtimeMs, entries });
+    while (slot.size > MAX_CACHED_SESSIONS) {
+      const oldest = slot.keys().next().value;
+      if (oldest === undefined) break;
+      slot.delete(oldest);
+    }
+  }
+  return entries;
+}
+
+/** JSONL pass for the telemetry builders; `visit` returns `false` to stop early. */
+export async function scanSessionEntries(
+  filePath: string,
+  visit: (entry: OmpMessageEntry, index: number) => boolean | void,
+): Promise<void> {
+  const records = await loadSessionEntries(filePath);
   for (let index = 0; index < records.length; index++) {
     const entry = records[index];
     if (!entry) continue;

package/src/server/lib/omp/session/telemetry-raw.ts

@@ -7,6 +7,10 @@
  * Server-side pagination for the raw messages panel. Scans the session JSONL
  * like ./telemetry.ts but materializes at most one page of `RawMessageItem`s,
  * so the payload-heavy entries never leave the server in bulk.
+ *
+ * The sliding window keeps MATCHES, and only the page that is returned is
+ * built — building every match to discard all but one page cost 48.9 ms on an
+ * 11 MB session against 1.9 ms for the page itself.
  */
 
 import type { RawMessageItem } from '@/shared/types/context';
@@ -33,14 +37,20 @@ export async function computeRawMessagesPage(
   role: RawMessageRole = 'all',
 ): Promise<RawMessagesPage> {
   const windowSize = Math.max(1, page) * pageSize;
-  const window: RawMessageItem[] = [];
+  // The window holds the last `windowSize` MATCHES, not built items. Building
+  // every match and discarding all but one page was the whole cost of this
+  // endpoint: on an 11 MB session, `buildRawItem` over all 1017 matches took
+  // 48.9 ms while building only the 50 that are returned took 1.9 ms — the scan
+  // that collects them is 0.2 ms.
+  const window: { entry: OmpMessageEntry; msg: OmpMessage; index: number }[] = [];
+  let head = 0;
   let total = 0;
   let filteredTotal = 0;
-  let header: OmpMessageEntry | undefined;
+  let cwd = '';
 
   await scanSessionEntries(filePath, (entry, index) => {
-    if (entry.type === 'session' && !header) {
-      header = entry;
+    if (entry.type === 'session') {
+      if (!cwd) cwd = entry.cwd ?? '';
       return;
     }
     if (entry.type !== 'message' || !entry.message) return;
@@ -54,8 +64,8 @@ export async function computeRawMessagesPage(
     if (role !== 'all' && msgRole !== role) return;
     filteredTotal++;
 
-    if (window.length >= windowSize) window.shift();
-    window.push(buildRawItem(entry, msg, header?.cwd ?? '', index));
+    window.push({ entry, msg, index });
+    if (window.length - head > windowSize) head++;
   });
 
   // `window` holds the last `windowSize` matches, oldest→newest, where
@@ -63,9 +73,15 @@ export async function computeRawMessagesPage(
   // rows: skip the (page-1) newest chunks, take one, flip for display. Both
   // bounds clamp at 0 so out-of-range pages return an empty list.
   const skipNewest = (Math.max(1, page) - 1) * pageSize;
-  const end = Math.max(0, window.length - skipNewest);
+  const live = window.length - head;
+  const end = Math.max(0, live - skipNewest);
   const start = Math.max(0, end - pageSize);
-  const items = window.slice(start, end).reverse();
+  const items: RawMessageItem[] = [];
+  for (let i = head + start; i < head + end; i++) {
+    const match = window[i];
+    items.push(buildRawItem(match.entry, match.msg, cwd, match.index));
+  }
+  items.reverse();
   return { items, total, filteredTotal };
 }
 

package/src/server/lib/omp/session/usage/aggregate.ts

@@ -23,7 +23,10 @@ export type UsageWindow =
   | { kind: 'custom'; from: string; to: string }
   | { kind: 'all' };
 
-const PRESET_DAYS: Record<Exclude<TimeRangeType, 'custom' | 'all'>, number> = { today: 1, '7d': 7, '30d': 30, '90d': 90 };
+const PRESET_DAYS: Record<Exclude<TimeRangeType, 'custom' | 'all' | 'today'>, number> = { '7d': 7, '30d': 30, '90d': 90 };
+
+/** Every range the tokens endpoint reports, in display order. */
+export const PRESET_RANGES: Exclude<TimeRangeType, 'custom'>[] = ['today', '7d', '30d', '90d', 'all'];
 
 const TTL_MS = 60_000;
 const cache = new Map<string, { at: number; data: UsageAggregate }>();
@@ -75,49 +78,65 @@ function bump(map: Map<string, { tokens: number; cost: number }>, key: string, t
   map.set(key, current);
 }
 
-function inRange(timestampIso: string | undefined, window: UsageWindow, now: number): boolean {
-  if (window.kind === 'all') return true;
-  if (!timestampIso) return true; // keep entries without timestamps (conservative)
-  const ts = Date.parse(timestampIso);
-  if (Number.isNaN(ts)) return true;
-  if (window.kind === 'custom') {
-    const from = Date.parse(`${window.from}T00:00:00`);
-    const to = Date.parse(`${window.to}T23:59:59.999`);
-    if (Number.isNaN(from) || Number.isNaN(to) || from > to) return true;
-    return ts >= from && ts <= to;
-  }
-  if (window.range === 'today') {
-    const d = new Date(ts);
-    const n = new Date(now);
-    return d.getFullYear() === n.getFullYear() && d.getMonth() === n.getMonth() && d.getDate() === n.getDate();
-  }
-  if (window.range === 'all') return true;
-  return now - ts <= PRESET_DAYS[window.range] * 24 * 60 * 60 * 1000;
-}
-
 function cacheKey(window: UsageWindow): string {
   if (window.kind === 'all') return 'all';
   if (window.kind === 'custom') return `custom:${window.from}:${window.to}`;
   return window.range;
 }
 
-/** Aggregate all omp session files within a time window. Cached for 60s. */
-export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregate> {
-  const key = cacheKey(window);
-  const cached = cache.get(key);
-  if (cached && Date.now() - cached.at < TTL_MS) return cached.data;
+/**
+ * One usage record, with everything a window needs to decide whether it counts.
+ *
+ * The scan that produces these is the expensive part — measured 795 ms over 455
+ * transcripts / 327 MB — so it runs ONCE and every window is derived from the
+ * same array. Aggregating per window re-read the whole tree for each of the five
+ * presets plus the active window, which is why `/api/telemetry/tokens` took
+ * 3.3 s cold.
+ */
+interface UsageRecord {
+  /** Epoch ms of the entry's timestamp, or undefined when it has none. */
+  at: number | undefined;
+  /** `YYYY-MM-DD` of `at`, or undefined. */
+  day: string | undefined;
+  model: string;
+  project: string;
+  cost: number;
+  costInput: number;
+  costOutput: number;
+  costCacheRead: number;
+  costCacheWrite: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning: number;
+  total: number;
+}
+
+interface UsageScan {
+  at: number;
+  records: UsageRecord[];
+  /** Transcripts visited, counted once for every window. */
+  scannedTranscripts: number;
+}
+
+let scanCache: UsageScan | null = null;
+
+/** Every usage record in the sessions tree, read at most once per TTL. */
+async function scanUsage(): Promise<UsageScan> {
+  if (scanCache && Date.now() - scanCache.at < TTL_MS) return scanCache;
 
   const sessionsRoot = getSessionsDir();
-  const aggregate = emptyAggregate();
-  const now = Date.now();
+  const records: UsageRecord[] = [];
+  let scannedTranscripts = 0;
   let projectDirs: string[] = [];
   try {
     projectDirs = (await fs.promises.readdir(sessionsRoot, { withFileTypes: true }))
       .filter((d) => d.isDirectory() || d.isFile())
       .map((d) => d.name);
   } catch {
-    cache.set(key, { at: Date.now(), data: aggregate });
-    return aggregate;
+    scanCache = { at: Date.now(), records, scannedTranscripts };
+    return scanCache;
   }
 
   for (const project of projectDirs) {
@@ -136,37 +155,33 @@ export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregat
     }
 
     for (const file of files) {
-      aggregate.scannedTranscripts++;
+      scannedTranscripts++;
       try {
         const ufile = Bun.file(file);
         if ((await ufile.stat()).size > 64 * 1024 * 1024) continue;
         const entries = parseJsonlLenient<OmpMessageEntry>(await ufile.text());
         for (const entry of entries) {
           if (entry.type !== 'message' || !entry.message?.usage) continue;
-          const ts = entry.timestamp;
-          if (!inRange(ts, window, now)) continue;
           const usage = entry.message.usage;
-          const cost = usage.cost?.total ?? 0;
-          const total = usage.totalTokens ?? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-          aggregate.usageRecords++;
-          aggregate.costTotal += cost;
-          aggregate.costInput += usage.cost?.input ?? 0;
-          aggregate.costOutput += usage.cost?.output ?? 0;
-          aggregate.costCacheRead += usage.cost?.cacheRead ?? 0;
-          aggregate.costCacheWrite += usage.cost?.cacheWrite ?? 0;
-          aggregate.inputTokens += usage.input ?? 0;
-          aggregate.outputTokens += usage.output ?? 0;
-          aggregate.cacheReadTokens += usage.cacheRead ?? 0;
-          aggregate.cacheWriteTokens += usage.cacheWrite ?? 0;
-          aggregate.reasoningTokens += usage.reasoningTokens ?? 0;
-          if (ts) {
-            const day = ts.slice(0, 10);
-            aggregate.activeDays.add(day);
-            bump(aggregate.byDay, day, total, cost);
-          }
-          const model = entry.message.model || 'unknown';
-          bump(aggregate.byModel, model, total, cost);
-          bump(aggregate.byProject, project, total, cost);
+          const ts = entry.timestamp;
+          const parsed = ts ? Date.parse(ts) : Number.NaN;
+          records.push({
+            at: Number.isNaN(parsed) ? undefined : parsed,
+            day: ts ? ts.slice(0, 10) : undefined,
+            model: entry.message.model || 'unknown',
+            project,
+            cost: usage.cost?.total ?? 0,
+            costInput: usage.cost?.input ?? 0,
+            costOutput: usage.cost?.output ?? 0,
+            costCacheRead: usage.cost?.cacheRead ?? 0,
+            costCacheWrite: usage.cost?.cacheWrite ?? 0,
+            input: usage.input ?? 0,
+            output: usage.output ?? 0,
+            cacheRead: usage.cacheRead ?? 0,
+            cacheWrite: usage.cacheWrite ?? 0,
+            reasoning: usage.reasoningTokens ?? 0,
+            total: usage.totalTokens ?? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0),
+          });
         }
       } catch {
         // Unreadable transcript — skip rather than failing the whole report.
@@ -174,8 +189,108 @@ export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregat
     }
   }
 
-  const data = aggregate;
+  scanCache = { at: Date.now(), records, scannedTranscripts };
+  return scanCache;
+}
+
+/** Fold the scanned records that fall inside `window` into an aggregate. */
+function foldWindow(records: readonly UsageRecord[], window: UsageWindow, now: number, scannedTranscripts: number): UsageAggregate {
+  const aggregate = emptyAggregate();
+  aggregate.scannedTranscripts = scannedTranscripts;
+  const bounds = windowBounds(window, now);
+  for (const record of records) {
+    // An entry with no usable timestamp is kept by EVERY window — a missing
+    // date is not evidence of age, and this matches the previous per-record
+    // behaviour.
+    if (record.at !== undefined && (record.at < bounds.from || record.at > bounds.to)) continue;
+    aggregate.usageRecords++;
+    aggregate.costTotal += record.cost;
+    aggregate.costInput += record.costInput;
+    aggregate.costOutput += record.costOutput;
+    aggregate.costCacheRead += record.costCacheRead;
+    aggregate.costCacheWrite += record.costCacheWrite;
+    aggregate.inputTokens += record.input;
+    aggregate.outputTokens += record.output;
+    aggregate.cacheReadTokens += record.cacheRead;
+    aggregate.cacheWriteTokens += record.cacheWrite;
+    aggregate.reasoningTokens += record.reasoning;
+    if (record.day) {
+      aggregate.activeDays.add(record.day);
+      bump(aggregate.byDay, record.day, record.total, record.cost);
+    }
+    bump(aggregate.byModel, record.model, record.total, record.cost);
+    bump(aggregate.byProject, record.project, record.total, record.cost);
+  }
+  return aggregate;
+}
+
+interface WindowBounds {
+  /** Inclusive epoch-ms bounds; `-Infinity`/`Infinity` for an unbounded side. */
+  from: number;
+  to: number;
+}
+
+/**
+ * Epoch-ms bounds for a window, computed once per fold.
+ *
+ * `today` is a local CALENDAR day (`setHours(0,0,0,0)`), not "the last 24h":
+ * the panel's "today" tab counts the day the user is in, and the previous
+ * implementation compared year/month/date for the same reason.
+ */
+function windowBounds(window: UsageWindow, now: number): WindowBounds {
+  if (window.kind === 'custom') {
+    const from = Date.parse(`${window.from}T00:00:00`);
+    const to = Date.parse(`${window.to}T23:59:59.999`);
+    if (Number.isNaN(from) || Number.isNaN(to) || from > to) return { from: -Infinity, to: Infinity };
+    return { from, to };
+  }
+  if (window.kind === 'all') return { from: -Infinity, to: Infinity };
+  switch (window.range) {
+    case 'all':
+      return { from: -Infinity, to: Infinity };
+    case 'today': {
+      const start = new Date(now);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      return { from: start.getTime(), to: end.getTime() - 1 };
+    }
+    default:
+      return { from: now - PRESET_DAYS[window.range] * 24 * 60 * 60 * 1000, to: Infinity };
+  }
+}
+
+/** Aggregate all omp session files within a time window. Cached for 60s. */
+export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregate> {
+  const key = cacheKey(window);
+  const cached = cache.get(key);
+  if (cached && Date.now() - cached.at < TTL_MS) return cached.data;
+
+  const scan = await scanUsage();
+  const data = foldWindow(scan.records, window, Date.now(), scan.scannedTranscripts);
   if (cache.size > 20) cache.clear();
   cache.set(key, { at: Date.now(), data });
   return data;
 }
+
+/**
+ * Aggregate EVERY preset range plus `window` from one scan.
+ *
+ * The tokens endpoint needs all six, and folding them from one scan costs the
+ * fold (linear in records) rather than six more tree reads.
+ */
+export async function aggregateUsageWindows(
+  window: UsageWindow,
+): Promise<{ ranges: Record<Exclude<TimeRangeType, 'custom'>, UsageAggregate>; active: UsageAggregate }> {
+  const scan = await scanUsage();
+  const now = Date.now();
+  const ranges = {} as Record<Exclude<TimeRangeType, 'custom'>, UsageAggregate>;
+  for (const range of PRESET_RANGES) {
+    ranges[range] = foldWindow(scan.records, { kind: 'preset', range }, now, scan.scannedTranscripts);
+  }
+  const active = foldWindow(scan.records, window, now, scan.scannedTranscripts);
+  // Cache each fold under its own key so a later single-window call reuses it.
+  for (const range of PRESET_RANGES) cache.set(range, { at: now, data: ranges[range] });
+  cache.set(cacheKey(window), { at: now, data: active });
+  return { ranges, active };
+}