ompchamber 3.1.1 → 3.3.0

package/src/server/lib/omp/rpc/subagent-liveness.ts

@@ -21,22 +21,12 @@
  * goes stale).
  */
 
-import { parseSubagentLifecycle, parseSubagentProgress } from '@/shared/lib/omp/subagent/parse';
-import { isRecord } from '@/shared/lib/util/guards';
-import type { SubagentProgress } from '@/shared/types/omp/subagent';
+import { parseSubagentLifecycle, readSubagentProgressFrame } from '@/shared/lib/omp/subagent/parse';
 
 /** Statuses that end a subagent. Mirrors omp's own registry, which deletes an
  *  entry the moment a non-`started` lifecycle arrives. */
 const TERMINAL_STATUS: Record<string, true> = { completed: true, failed: true, aborted: true };
 
-/** Progress frames arrive AgentProgress-shaped; some wrappers nest the snapshot. */
-function readProgress(payload: unknown): SubagentProgress | undefined {
-  const direct = parseSubagentProgress(payload);
-  if (!isRecord(payload) || !isRecord(payload.progress)) return direct;
-  const nested = parseSubagentProgress(payload.progress);
-  return nested ? { ...nested, id: nested.id ?? direct?.id, index: nested.index ?? direct?.index } : direct;
-}
-
 export class SubagentLiveness {
   private readonly lastSeen = new Map<string, number>();
   /** index → key, so an id-less progress frame lands on the entry its lifecycle
@@ -54,7 +44,7 @@ export class SubagentLiveness {
     }
 
     if (frame.type === 'subagent_progress') {
-      const progress = readProgress(frame.payload);
+      const progress = readSubagentProgressFrame(frame.payload);
       if (!progress) return;
       const index = progress.index !== undefined && progress.index >= 0 ? progress.index : undefined;
       const key = progress.id ?? (index !== undefined ? this.keyByIndex.get(index) ?? `idx:${index}` : undefined);

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

@@ -37,6 +37,12 @@ export interface SessionFilePrefix {
   text: string;
   size: number;
   mtime: Date;
+  /**
+   * The same mtime as a raw `stat.mtimeMs`, for callers that key a cache on it.
+   * `Date.getTime()` truncates the fractional millisecond APFS reports, so a
+   * Date comparison never matches a fresh stat.
+   */
+  mtimeMs: number;
 }
 
 export async function readTextPrefix(filePath: string, prefixBytes: number): Promise<SessionFilePrefix> {
@@ -44,7 +50,7 @@ export async function readTextPrefix(filePath: string, prefixBytes: number): Pro
   const stat = await file.stat();
   const prefixLength = Math.min(prefixBytes, stat.size);
   const text = prefixLength > 0 ? await file.slice(0, prefixLength).text() : '';
-  return { text, size: stat.size, mtime: new Date(stat.mtimeMs) };
+  return { text, size: stat.size, mtime: new Date(stat.mtimeMs), mtimeMs: stat.mtimeMs };
 }
 
 /**

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

@@ -4,106 +4,32 @@
  */
 
 /**
- * Read-only session-file scanner for oh-my-pi (format v3).
+ * The session-file CACHE layer: which files exist, what each one's summary is,
+ * and how to resolve an id to a path without re-reading the tree.
  *
- * Faithful, trimmed port of omp-web/lib/omp/session-files.ts (itself a port of
- * oh-my-pi packages/coding-agent/src/session/session-listing.ts): it lists the
- * per-project session directories under ~/.omp/agent/sessions and derives a
- * compact summary per session from a small 4 KiB prefix window of each file —
- * enough for a sidebar list without ever loading a full session into memory.
+ * Three caches, all keyed so they invalidate for free:
  *
- * 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.
- * The lenient JSONL + header parsing lives in
- * `@/shared/lib/omp/session/jsonl`; the bounded window readers (head prefix
- * plus escalating tail) live in ./file-scan.ts.
+ *   - the file list, on the sessions root's per-project directory mtimes (a new
+ *     session bumps its project dir, so add/remove invalidates it);
+ *   - the per-file summary, on that file's `(size, mtimeMs)`;
+ *   - the `id → path` index, rebuilt from the file list.
+ *
+ * The mtime key is the RAW `stat.mtimeMs`, never a `Date`: `getTime()`
+ * truncates the fractional millisecond APFS reports, which made the summary
+ * cache miss on every call (measured: 451 of 452 files).
+ *
+ * The read itself lives in `./scan`; `clearSessionFileCaches()` is the one
+ * invalidation point every mutation path already calls.
  */
 
 import fs from 'fs';
 import * as path from 'path';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
-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';
 import { isRecord } from '@/shared/lib/util/guards';
+import { SESSION_TITLE_SLOT_BYTES, scanSessionInfo, type OmpSessionInfo } from '@/server/lib/omp/session/scan';
 
-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;
-  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 } = 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,
-      messageCount: Math.max(parsedMessageCount, countMessageMarkers(prefix)),
-      size,
-      firstMessage: firstMessage || '(no messages)',
-    };
-  } catch {
-    return undefined;
-  }
-}
+export { SESSION_TITLE_SLOT_BYTES, scanSessionInfo };
+export type { OmpSessionInfo };
 
 // ============================================================================
 // File-list walk + per-file memo, both mtime-keyed
@@ -125,7 +51,7 @@ interface SessionFileListCacheEntry {
  * missing a scan. Bump this whenever OmpSessionInfo changes; the cache is
  * discarded instead of misread.
  */
-const SESSION_SCAN_CACHE_VERSION = 2;
+const SESSION_SCAN_CACHE_VERSION = 3;
 
 interface SessionScanCache {
   version: number;
@@ -205,6 +131,10 @@ export async function listSessionFiles(sessionsRoot: string = getSessionsDir()):
   }
 
   cache.set(sessionsRoot, { dirMtimes, files });
+  // A rebuilt list means the directory moved (a session was added or removed),
+  // which is exactly when the `id → path` index is stale — it is derived from
+  // this list, and its own mtime key cannot see a file that is not in it yet.
+  globalThis.__ompChamberSessionIdIndex?.delete(sessionsRoot);
   return files;
 }
 
@@ -235,7 +165,11 @@ export async function scanSessionInfoCached(filePath: string): Promise<OmpSessio
     // `modified` — the latter is now an entry timestamp, and a title-slot
     // rewrite that bumps the file without appending an entry must still be
     // picked up (it can change the title the row displays).
-    if (info.size === stat.size && info.fileMtime.getTime() === stat.mtimeMs) {
+    //
+    // The comparison is against the RAW `stat.mtimeMs`: `Date.getTime()`
+    // truncates the fractional millisecond APFS reports, so a Date comparison
+    // never matched and this cache never hit (measured: 451 of 452 files).
+    if (info.size === stat.size && info.fileMtimeMs === stat.mtimeMs) {
       cache.delete(filePath);
       cache.set(filePath, info);
       return info;
@@ -256,6 +190,32 @@ export async function scanSessionInfoCached(filePath: string): Promise<OmpSessio
   return info;
 }
 
+/**
+ * Map `items` through an async `worker`, at most `limit` in flight.
+ *
+ * The session scans are I/O-bound, so a sequential loop serializes round trips
+ * the filesystem answers in parallel (measured 36 ms sequential against 12 ms
+ * for the same warm work over 452 files). The bound is what keeps an unbounded
+ * `Promise.all` from opening one descriptor per session file on a host with a
+ * low soft limit.
+ */
+async function mapBounded<T, R>(items: readonly T[], limit: number, worker: (item: T) => Promise<R>): Promise<R[]> {
+  const out = new Array<R>(items.length);
+  let next = 0;
+  const runners = new Array(Math.min(limit, items.length)).fill(null).map(async () => {
+    for (;;) {
+      const index = next++;
+      if (index >= items.length) return;
+      out[index] = await worker(items[index]);
+    }
+  });
+  await Promise.all(runners);
+  return out;
+}
+
+/** Concurrent per-file scans; each holds one descriptor while it stats/reads. */
+const SESSION_SCAN_CONCURRENCY = 32;
+
 /**
  * List every session across all project subdirectories of the sessions root,
  * newest-modified first. Invalidates are automatic via mtime keys; callers
@@ -263,26 +223,65 @@ export async function scanSessionInfoCached(filePath: string): Promise<OmpSessio
  */
 export async function listAllSessionInfos(sessionsRoot: string = getSessionsDir()): Promise<OmpSessionInfo[]> {
   const files = await listSessionFiles(sessionsRoot);
+  const scanned = await mapBounded(files, SESSION_SCAN_CONCURRENCY, (file) => scanSessionInfoCached(file));
   const sessions: OmpSessionInfo[] = [];
-  for (const file of files) {
-    const info = await scanSessionInfoCached(file);
+  for (const info of scanned) {
     if (info) sessions.push(info);
   }
   sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
   return sessions;
 }
 
+/**
+ * `id → path` for every session file under `sessionsRoot`, built from the same
+ * mtime-keyed scan cache the sidebar list fills.
+ *
+ * Resolving one id used to mean scanning every file until it matched —
+ * measured 34.8 ms for the 452 files on this machine, on the hot path of eight
+ * routes. The index is derived from `listAllSessionInfos`' own results, so it
+ * costs one map build and invalidates with the caches it reads.
+ *
+ * Cached per root on `globalThis` (a `bun --hot` reload keeps it) and dropped
+ * by `clearSessionFileCaches()`, which every mutation path already calls.
+ */
+interface SessionIdIndex {
+  entries: Map<string, string>;
+}
+
+declare global {
+  var __ompChamberSessionIdIndex: Map<string, SessionIdIndex> | undefined;
+}
+
+/** The `id → path` index for `sessionsRoot`, building it on first use. */
+export async function sessionIdIndex(sessionsRoot: string = getSessionsDir()): Promise<Map<string, string>> {
+  const host = (globalThis.__ompChamberSessionIdIndex ??= new Map());
+  const cached = host.get(sessionsRoot);
+  if (cached) return cached.entries;
+  const entries = new Map<string, string>();
+  for (const info of await listAllSessionInfos(sessionsRoot)) {
+    // A duplicate id cannot happen (omp ids are UUIDs), but first-wins keeps
+    // the answer stable if a copied session file ever appears.
+    if (!entries.has(info.id)) entries.set(info.id, info.path);
+  }
+  host.set(sessionsRoot, { entries });
+  return entries;
+}
+
 /** Clear in-memory file-list and per-file scan caches (e.g. after a mutation
  *  that mtime keys cannot detect). */
 export function clearSessionFileCaches(): void {
   globalThis.__ompChamberSessionFileListCache?.clear();
   globalThis.__ompChamberSessionScanCache?.entries.clear();
+  globalThis.__ompChamberSessionIdIndex?.clear();
 }
 
 /** Exported for tests/spot-checks: read a raw JSONL session header directly. */
 export async function readRawHeaderLine(filePath: string): Promise<Record<string, unknown> | undefined> {
   try {
-    const head = (await Bun.file(filePath).text()).slice(0, SESSION_TITLE_SLOT_BYTES + 4096);
+    // A bounded Blob slice, not `.text().slice(0, n)`: the header lives in the
+    // first few hundred bytes, and decoding a whole session to look at them
+    // cost 4.9 ms on an 11 MB file against 0.1 ms for the slice.
+    const head = await Bun.file(filePath).slice(0, SESSION_TITLE_SLOT_BYTES + 4096).text();
     const lines = head.split('\n').filter(Boolean);
     for (const line of lines) {
       try {

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

@@ -11,19 +11,29 @@
 
 import { json } from '@/server/lib/remix-compat';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
-import { listSessionFiles, readRawHeaderLine, scanSessionInfoCached } from '@/server/lib/omp/session/files';
+import { clearSessionFileCaches, readRawHeaderLine, sessionIdIndex } from '@/server/lib/omp/session/files';
 
-/** Find the absolute path of the .jsonl whose header id matches. */
+/**
+ * Locate an oh-my-pi session file by its session UUID.
+ *
+ * Resolves through the `id → path` index (files.ts), which is built from the
+ * same mtime-keyed scan cache the sidebar list fills. A linear scan over every
+ * session file measured 34.8 ms on the 452 files this machine holds — and it
+ * runs on the hot path of eight routes — against an O(1) map lookup.
+ *
+ * A miss is re-checked once against a freshly built index: a session created
+ * since the index was built would otherwise 404 until something else cleared
+ * the caches.
+ */
 export async function findSessionFileById(
   sessionId: string,
   sessionsRoot: string = getSessionsDir(),
 ): Promise<string | undefined> {
-  const files = await listSessionFiles(sessionsRoot);
-  for (const file of files) {
-    const info = await scanSessionInfoCached(file);
-    if (info?.id === sessionId) return file;
-  }
-  return undefined;
+  const index = await sessionIdIndex(sessionsRoot);
+  const hit = index.get(sessionId);
+  if (hit) return hit;
+  clearSessionFileCaches();
+  return (await sessionIdIndex(sessionsRoot)).get(sessionId);
 }
 
 /** The JSON 404 envelope every session-resolve guard answers with. */

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

@@ -161,13 +161,13 @@ async function resolveImageBlobs(messages: ChatMessageData[]): Promise<void> {
 /** Derive the display title from the JSONL header/title slot (cheap read). */
 export async function loadSessionTitle(filePath: string): Promise<string | undefined> {
   try {
-    const file = Bun.file(filePath);
-    if ((await file.stat()).size > 10 * 1024 * 1024) return undefined; // only need the head
-  } catch {
-    return undefined;
-  }
-  try {
-    const head = (await Bun.file(filePath).text()).slice(0, 32 * 1024);
+    // A bounded Blob slice, and deliberately NO size guard. The title slot and
+    // the session header live in the first few hundred bytes, so the 32 KiB
+    // window is what makes the read cheap — a file-size refusal on top of it
+    // only discarded titles that were sitting right there (measured: an 11 MB
+    // session reported `title: undefined` while its title slot held
+    // "Debug file attachment read failure").
+    const head = await Bun.file(filePath).slice(0, 32 * 1024).text();
     const records = parseJsonlLenient<Record<string, unknown>>(head);
     const first = records[0];
     if (first?.type === 'title' && typeof first.title === 'string' && first.title.trim()) {

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;
 }