ompchamber 0.3.0

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

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only orchestrator over the oh-my-pi agent directory — the OMPChamber
+ * analog of omp-web's lib/session-reader.ts sidebar data path.
+ *
+ * Composes the pieces of the omp-web sidebar data source so a future UI fork
+ * can consume "which workspaces exist and which sessions live under them"
+ * without touching omp-web or oh-my-pi:
+ *
+ *   - session file scan          → lib/omp/session-files.ts
+ *   - cwd → repository root      → lib/omp/worktree.ts
+ *   - managed projects registry  → lib/omp/project-registry.ts
+ *
+ * All reads are bounded (4 KiB prefix per session file), cached by mtime, and
+ * never mutate the agent's files.
+ */
+
+import { listAllSessionInfos, type OmpSessionInfo } from '@/server/lib/omp/session/files';
+import { loadProjectRegistry, mergeProjects } from '@/server/lib/omp/core/registry';
+import { resolveProjectRoot } from '@/server/lib/omp/core/worktree';
+import { getAgentDir, getSessionsDir, pathExists } from '@/server/lib/omp/core/paths';
+import { SIDEBAR_DATA_TTL_MS } from '@/shared/lib/workspace/refresh-cadence';
+import type { OmpProject, OmpSession, OmpSidebarData } from '@/shared/types/omp/session';
+
+const CONCURRENCY = 6;
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberSidebarDataCache: {
+    data: OmpSidebarData;
+    expiresAt: number;
+    inFlight: Promise<OmpSidebarData> | null;
+  } | undefined;
+}
+
+/**
+ * Per-process TTL cache for the sidebar dataset. The loader revalidates on
+ * every stream event; deduplicating concurrent requests and re-serving a
+ * snapshot for a few seconds turns a burst of revalidations into one disk scan
+ * (4 KiB prefix per session file) instead of one scan each. The TTL sits just
+ * under the fastest sidebar poll so a poll misses deterministically.
+ */
+export async function loadOmpSidebarData(): Promise<OmpSidebarData> {
+  let slot = globalThis.__ompChamberSidebarDataCache;
+  if (!slot) {
+    slot = { data: undefined as unknown as OmpSidebarData, expiresAt: 0, inFlight: null };
+    globalThis.__ompChamberSidebarDataCache = slot;
+  }
+  const now = Date.now();
+  if (slot.data && slot.expiresAt > now) return slot.data;
+  if (slot.inFlight) return slot.inFlight;
+
+  slot.inFlight = buildOmpSidebarData().finally(() => {
+    if (slot && slot.inFlight) slot.inFlight = null;
+  });
+  return slot.inFlight;
+}
+
+/** Resolve each unique cwd to its project root; bounded concurrency so 100+
+ *  unique cwds don't spawn 100 parallel git processes. */
+async function resolveRootsByCwd(cwds: string[]): Promise<Map<string, string>> {
+  const projectByCwd = new Map<string, string>();
+  for (let i = 0; i < cwds.length; i += CONCURRENCY) {
+    const chunk = cwds.slice(i, i + CONCURRENCY);
+    await Promise.all(
+      chunk.map(async (cwd) => {
+        projectByCwd.set(cwd, await resolveProjectRoot(cwd));
+      }),
+    );
+  }
+  return projectByCwd;
+}
+
+/** Map a scanned session file to the sidebar session shape. */
+function toOmpSession(
+  info: OmpSessionInfo,
+  projectRootByCwd: Map<string, string>,
+): OmpSession {
+  const projectRoot = info.cwd ? projectRootByCwd.get(info.cwd) : undefined;
+  return {
+    path: info.path,
+    id: info.id,
+    cwd: info.cwd,
+    name: info.title,
+    created: info.created.toISOString(),
+    modified: info.modified.toISOString(),
+    messageCount: info.messageCount,
+    firstMessage: info.firstMessage,
+    ...(info.parentSessionPath ? { parentSessionId: info.parentSessionPath } : {}),
+    projectRoot,
+  };
+}
+
+/** Workspaces that own at least one session file on disk (session-discovered). */
+function discoveredProjectPaths(sessions: OmpSessionInfo[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const session of sessions) {
+    if (!session.cwd) continue;
+    if (seen.has(session.cwd)) continue;
+    seen.add(session.cwd);
+    out.push(session.cwd);
+  }
+  return out;
+}
+
+/**
+ * Build the complete sidebar dataset in omp-web's shape:
+ * registered + discovered projects, plus every session (newest first).
+ */
+async function buildOmpSidebarData(): Promise<OmpSidebarData> {
+  const agentDir = getAgentDir();
+  const sessionsDir = getSessionsDir();
+  const available = await pathExists(sessionsDir);
+
+  const ompSessions = await listAllSessionInfos(sessionsDir);
+  const projectRootByCwd = await resolveRootsByCwd(
+    [...new Set(ompSessions.map((s) => s.cwd).filter(Boolean))],
+  );
+
+  const registry = await loadProjectRegistry();
+  const projects = mergeProjects(registry, discoveredProjectPaths(ompSessions));
+  const sessions = ompSessions.map((info) => toOmpSession(info, projectRootByCwd));
+
+  const data: OmpSidebarData = {
+    projects,
+    sessions,
+    agentDir,
+    available,
+    generatedAt: new Date().toISOString(),
+  };
+  const slot = globalThis.__ompChamberSidebarDataCache;
+  if (slot) {
+    slot.data = data;
+    slot.expiresAt = Date.now() + SIDEBAR_DATA_TTL_MS;
+  }
+  return data;
+}
+
+/** Convenience: only the project list (cheap — no per-session git lookups). */
+export async function loadOmpProjects(): Promise<OmpProject[]> {
+  const sessionsDir = getSessionsDir();
+  const ompSessions = (await pathExists(sessionsDir)) ? await listAllSessionInfos(sessionsDir) : [];
+  const registry = await loadProjectRegistry();
+  return mergeProjects(registry, discoveredProjectPaths(ompSessions));
+}

package/src/server/lib/omp/session/sidebar-data.server.ts

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Single source of truth for the sidebar session list (folders + sessions +
+ * live stream statuses). Shared by:
+ *
+ *   - GET /api/sessions/list — the client-side fetch endpoint the session
+ *     sidebars refresh through (`useSidebarData`), skeleton-first.
+ *   - Kept importable by any future consumer (mobile native, external poll).
+ *
+ * Previously this logic lived inline in the `routes/_index` loader; it moved
+ * here when the folder list was decoupled from SSR (settings + mobile UA
+ * stay server-rendered, the heavy omp JSONL scan is fetched client-side).
+ */
+
+import { getDb } from '@/server/db.server';
+import { isMockMode } from '@/server/mock.server';
+import { isValidSessionSortOption, sortFolders } from '@/shared/lib/workspace/sidebar-sort';
+import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
+import { sessionHasSubagents } from '@/server/lib/omp/session/subagent-presence';
+import { healStaleStreamStatuses, loadStreamStatuses } from '@/shared/lib/omp/session/stream-state.server';
+import { getRunningRpcSessionIds } from '@/server/lib/omp/rpc/session-registry';
+import type { SessionItemData, SessionSortOption, WorkspaceFolderData } from '@/shared/types';
+import type { OmpSession } from '@/shared/types/omp/session';
+
+/** What `GET /api/sessions/list` returns and sidebars consume. */
+export interface SessionListPayload {
+  folders: WorkspaceFolderData[];
+  isMock: boolean;
+}
+
+/** workspace_folders row: only the columns the sidebar reads. */
+interface FolderRow {
+  id: number;
+  name: string;
+  project_path?: string | null;
+  is_pinned?: number;
+  is_expanded?: number;
+  model?: string;
+  accent_color?: string;
+  icon?: string;
+  custom_icon_url?: string;
+}
+
+/** archived_sessions row. */
+interface ArchivedRow {
+  session_id: string;
+}
+
+/** Mock-mode `sessions` table row (numeric ids), per the db.server seed. */
+interface MockSessionRow extends SessionItemData {
+  id: number;
+  folder_id: number;
+}
+
+export async function loadSidebarData(): Promise<SessionListPayload> {
+  const mock = isMockMode();
+  const db = await getDb();
+  const folderRows = (await db.all('SELECT * FROM workspace_folders ORDER BY id ASC')) as FolderRow[];
+
+  const groupedFolders: WorkspaceFolderData[] = [];
+  // Archive state lives in archived_sessions (session_id TEXT PK) so it works
+  // for both numeric mock ids and omp session UUIDs in real mode.
+  const archivedRows = (await db.all('SELECT session_id FROM archived_sessions')) as ArchivedRow[];
+  const archivedIds = new Set(archivedRows.map((r) => String(r.session_id)));
+  if (mock) {
+    // Demo mode: sessions come from the SQLite `sessions` table.
+    const { hasMockSubagents, getMockSubagents } = await import('@/client/data/mock/subagents');
+    const sessions = (await db.all('SELECT * FROM sessions ORDER BY id ASC')) as MockSessionRow[];
+    for (const folder of folderRows) {
+      const folderSessions = sessions
+        .filter((s) => String(s.folder_id) === String(folder.id))
+        .map((s) => {
+          const hasSub = hasMockSubagents(s.id);
+          const subCount = getMockSubagents(s.id).length;
+          return {
+            ...s,
+            is_archived: archivedIds.has(String(s.id)) ? 1 : 0,
+            hasSubagents: hasSub,
+            subagentCount: subCount,
+          };
+        });
+      groupedFolders.push({
+        id: folder.id,
+        name: folder.name,
+        project_path: folder.project_path ?? null,
+        isPinned: folder.is_pinned === 1,
+        isExpanded: folder.is_expanded === 1,
+        model: folder.model || 'Not selected',
+        accentColor: folder.accent_color || '',
+        icon: folder.icon || 'default',
+        customIconUrl: folder.custom_icon_url || undefined,
+        sessions: folderSessions,
+        hasMore: folderSessions.length > 7,
+        totalSessions: folderSessions.length,
+      });
+    }
+  } else {
+    // Real mode: workspace folders are bound to omp projects via project_path;
+    // the session items under each folder come from the omp JSONL discovery.
+    groupedFolders.push(...(await buildRealFolders(folderRows, archivedIds)));
+  }
+
+  // Sidebar ordering is a server concern: the endpoint applies the persisted
+  // preference so the payload already matches the client's render. Shipping
+  // one order and re-sorting in the browser is what read as a flicker on load.
+  const sidebarSort = await serverSidebarSort();
+
+  // Live stream status per session (spinner / one-shot done badge), written by
+  // the RPC manager on agent_start/agent_end/abort/error. `stream` rows whose
+  // session is no longer running are stale (restart mid-run) and heal to
+  // `finish` right here — the authoritative status travels with the same
+  // fetch that refreshes the sidebar list.
+  const streamStatuses: Record<string, 'stream' | 'finish' | 'abort' | 'error'> = {};
+  if (!mock) {
+    await healStaleStreamStatuses(new Set(getRunningRpcSessionIds()));
+    Object.assign(streamStatuses, await loadStreamStatuses());
+  }
+  const foldersWithStatus = groupedFolders.map((folder) => ({
+    ...folder,
+    sessions: (folder.sessions ?? []).map((s) => ({
+      ...s,
+      streamStatus: streamStatuses[String(s.id)],
+    })),
+  }));
+
+  return {
+    folders: sortFolders(foldersWithStatus, sidebarSort),
+    isMock: mock,
+  };
+}
+
+/** Persisted sidebar sort preference (SQLite app_settings), defaulting to A-Z. */
+async function serverSidebarSort(): Promise<SessionSortOption> {
+  try {
+    const db = await getDb();
+    const row = await db.get('SELECT value FROM app_settings WHERE key = ?', ['omp_sidebar_sort']);
+    if (row && isValidSessionSortOption(row.value)) {
+      return row.value;
+    }
+  } catch {
+    // Table may not exist yet right after creation.
+  }
+  return 'A-Z';
+}
+
+/**
+ * Real-mode folder assembly: run the omp discovery scan once and bucket the
+ * discovered sessions under each folder whose project_path matches the
+ * session's resolved project root. Folders without a project_path render with
+ * no omp sessions (a local/empty workspace).
+ */
+async function buildRealFolders(folderRows: FolderRow[], archivedIds: Set<string>): Promise<WorkspaceFolderData[]> {
+  const { sessionTitleFor, groupSessionsByRoot } = await import('@/shared/lib/omp/session/sidebar');
+
+  const data = await loadOmpSidebarData();
+  const sessionsByRoot = groupSessionsByRoot(data.sessions);
+
+  return Promise.all(folderRows.map(async (folder) => {
+    const root = folder.project_path ?? '';
+    const rootSessions: OmpSession[] = root ? sessionsByRoot.get(root) ?? [] : [];
+    const folderSessions = await Promise.all(rootSessions.map(async (session: OmpSession) => {
+      const hasSub = session.path
+        ? await sessionHasSubagents(session.path, session.modified)
+        : false;
+      return {
+        id: session.id,
+        folder_id: folder.id,
+        title: sessionTitleFor(session),
+        created_at: session.created,
+        updated_at: session.modified,
+        is_active: 0,
+        is_archived: archivedIds.has(String(session.id)) ? 1 : 0,
+        hasSubagents: hasSub,
+      };
+    }));
+    return {
+      id: folder.id,
+      name: folder.name,
+      project_path: folder.project_path ?? null,
+      isPinned: folder.is_pinned === 1,
+      isExpanded: folder.is_expanded === 1,
+      model: folder.model || 'Not selected',
+      accentColor: folder.accent_color || '',
+      icon: folder.icon || 'default',
+      customIconUrl: folder.custom_icon_url || undefined,
+      sessions: folderSessions,
+      hasMore: folderSessions.length > 7,
+      totalSessions: folderSessions.length,
+    };
+  }));
+}

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Per-session enrichment for the session browser: model history, thinking
+ * levels, compaction events, and token/cost rollups parsed from a session
+ * 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';
+
+export interface SessionStats {
+  /** Model switch history (most settings tabs show only the latest). */
+  models: Array<{ model: string; at: string }>;
+  thinkingLevels: Array<{ level: string; at: string }>;
+  compactions: number;
+  messageCount: number;
+  assistantMessageCount: number;
+  tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; reasoning: number };
+  cost: { total: number };
+  /** First and last entry timestamps (ISO) when present. */
+  startedAt?: string;
+  lastActivityAt?: string;
+}
+
+const MAX_SESSION_BYTES = 64 * 1024 * 1024;
+
+export async function readSessionStats(filePath: string): Promise<SessionStats | undefined> {
+  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;
+        }
+        default:
+          break;
+      }
+    }
+    return stats;
+  } catch {
+    return undefined;
+  }
+}

package/src/server/lib/omp/session/subagent-presence.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Cached "does this session have subagents?" probe.
+ *
+ * The sidebar loader asks this for EVERY session on EVERY fetch. The honest
+ * answer needs the session file's `task` toolCalls, which is the authoritative
+ * roster — but reading them means parsing a file that can reach hundreds of
+ * megabytes, and doing that per session per poll dominated the endpoint's cost
+ * (the dataset scan itself is cached; this probe was not).
+ *
+ * The roster can only change when the session file or its sibling artifacts
+ * directory changes, so that (session mtime, sibling-dir mtime) pair is a
+ * sufficient cache version. Both cost one stat — orders of magnitude cheaper
+ * than the parse they gate.
+ */
+
+import { promises as fs } from 'fs';
+import { extractSubagentHistory } from '@/server/lib/omp/subagent/history';
+import { siblingDirForSession } from '@/server/lib/omp/subagent/history/paths';
+
+interface PresenceEntry {
+  version: string;
+  hasSubagents: boolean;
+}
+
+/** Bounded so a long-lived server with many sessions cannot grow unbounded. */
+const MAX_ENTRIES = 2_000;
+
+const cache = new Map<string, PresenceEntry>();
+
+async function siblingDirMtimeMs(dir: string): Promise<number> {
+  try {
+    return (await fs.stat(dir)).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+export async function sessionHasSubagents(
+  sessionPath: string,
+  sessionModified: string,
+): Promise<boolean> {
+  const siblingDir = siblingDirForSession(sessionPath);
+  const version = `${sessionModified}:${await siblingDirMtimeMs(siblingDir)}`;
+
+  const cached = cache.get(sessionPath);
+  if (cached && cached.version === version) return cached.hasSubagents;
+
+  let hasSubagents = false;
+  try {
+    const files = await fs.readdir(siblingDir);
+    hasSubagents = files.some((file) => file.endsWith('.jsonl'));
+  } catch {
+    hasSubagents = false;
+  }
+  if (!hasSubagents) {
+    try {
+      hasSubagents = (await extractSubagentHistory(sessionPath)).length > 0;
+    } catch {
+      hasSubagents = false;
+    }
+  }
+
+  if (!cached && cache.size >= MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+  cache.set(sessionPath, { version, hasSubagents });
+  return hasSubagents;
+}

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

@@ -0,0 +1,188 @@
+import { formatNewSessionTitle } from '@/shared/lib/omp/session/default-title';
+import { contentProfile } from '@/shared/lib/omp/session/telemetry-blocks';
+import type { RawMessageItem, SessionContextTelemetry } from '@/shared/types/context';
+import type { OmpMessageEntry, OmpUsage } from '@/shared/types/omp/session';
+import { CONTEXT_LIMIT, buildInfo, contextAnchorTokens, emptyTelemetry, formatCost, formatTs, textOf, tokensOf } from '@/server/lib/omp/session/telemetry/format';
+import { scanSessionEntries } from '@/server/lib/omp/session/telemetry/scan';
+
+/**
+ * Compute real `SessionContextTelemetry` for a session file (all-zero on
+ * unreadable/empty). `rawLimit` caps materialized raw items (0 = none): the
+ * panel reads full pages from `computeRawMessagesPage` in ./telemetry-raw.ts.
+ */
+export async function computeRealSessionTelemetry(
+  filePath: string,
+  sessionId: string,
+  fallbackTitle?: string,
+  rawLimit = 0,
+): Promise<SessionContextTelemetry> {
+  const defaultTitle = fallbackTitle || 'New Session';
+
+  let header: OmpMessageEntry | undefined;
+  let userCount = 0;
+  let assistantCount = 0;
+  let userChars = 0;
+  let assistantChars = 0;
+  let toolChars = 0;
+  let totalCost = 0;
+  let contextAnchor = 0;
+  let modelProvider = '';
+  let modelId = '';
+  let effectiveTitle = '';
+  let shortSummary = '', firstUserText = '';
+  let lastAsstUsage: OmpUsage | undefined;
+  let sumInput = 0;
+  let sumOutput = 0;
+  let sumCacheRead = 0;
+  let sumCacheWrite = 0;
+  // Cache-hit average only counts warmed calls — any assistant call that read
+  // zero cache tokens (cold request) is excluded, not just the very first one.
+  let cacheAvgInput = 0;
+  let cacheAvgCacheRead = 0;
+  let costInput = 0;
+  let costOutput = 0;
+  let costCacheRead = 0;
+  let costCacheWrite = 0;
+  let messagesCount = 0;
+  const rawMessages: RawMessageItem[] = [];
+  let cwd = '';
+
+  await scanSessionEntries(filePath, (entry, index) => {
+    // Modern session files start with a fixed-width title slot line, so the
+    // header is never at index 0 when one exists. A filled slot (auto/user
+    // rename) outranks the header's own title field.
+    if (entry.type === 'title') {
+      if (typeof entry.title === 'string' && entry.title.trim()) effectiveTitle = entry.title.trim();
+      return;
+    }
+    if (entry.type === 'session' && !header) {
+      header = entry;
+      cwd = entry.cwd ?? '';
+      if (!effectiveTitle && typeof entry.title === 'string') effectiveTitle = entry.title;
+      return;
+    }
+    if (entry.type === 'compaction' && typeof entry.shortSummary === 'string' && !shortSummary) shortSummary = entry.shortSummary;
+    if (entry.type !== 'message' || !entry.message) return;
+
+    const msg = entry.message;
+    const role = msg.role ?? '';
+    const text = textOf(msg.content);
+    const profile = contentProfile(msg.content);
+    const info = buildInfo(entry, msg, cwd, index);
+    const tokens = tokensOf(msg.usage);
+
+    toolChars += profile.toolChars;
+
+    if (role === 'user') {
+      userCount++;
+      userChars += text.length;
+      if (!firstUserText && text.trim()) firstUserText = text.trim();
+    } else if (role === 'assistant') {
+      assistantCount++;
+      assistantChars += text.length;
+      if (msg.usage) lastAsstUsage = msg.usage;
+      const anchor = contextAnchorTokens(msg);
+      if (anchor !== undefined) contextAnchor = anchor;
+    }
+
+    if (msg.usage) {
+      totalCost += msg.usage.cost?.total ?? 0;
+      sumInput += tokens.input;
+      sumOutput += tokens.output;
+      sumCacheRead += tokens.cacheRead;
+      sumCacheWrite += tokens.cacheWrite;
+      if (msg.role === 'assistant' && tokens.cacheRead > 0) {
+        cacheAvgInput += tokens.input;
+        cacheAvgCacheRead += tokens.cacheRead;
+      }
+      costInput += msg.usage.cost?.input ?? 0;
+      costOutput += msg.usage.cost?.output ?? 0;
+      costCacheRead += msg.usage.cost?.cacheRead ?? 0;
+      costCacheWrite += msg.usage.cost?.cacheWrite ?? 0;
+    }
+    if (msg.provider) modelProvider = msg.provider;
+    if (msg.model) modelId = msg.model;
+
+    if (role === 'user' || role === 'assistant') {
+      messagesCount++;
+      if (rawLimit === 0 || rawMessages.length < rawLimit) {
+        const isAssistant = role === 'assistant';
+        const snippet = text.slice(0, 70);
+        rawMessages.push({
+          id: entry.id ?? `m${index}`,
+          type: isAssistant ? (profile.parts.length ? profile.parts.join('_') : 'text') : 'user',
+          badgeLabel: isAssistant
+            ? (profile.parts.length ? profile.parts.join(' + ') : 'text')
+            : `user: ${snippet}${text.length > 70 ? '...' : ''}`,
+          tokenSummary: isAssistant
+            ? `${tokens.input.toLocaleString()} / ${tokens.output.toLocaleString()}`
+            : '',
+          timestamp: formatTs(entry.timestamp),
+          info,
+          rawPayload: entry as unknown as Record<string, any>,
+        });
+      }
+    }
+  });
+
+  if (messagesCount === 0 && !header && !effectiveTitle) return emptyTelemetry(sessionId, defaultTitle);
+
+  const providerModel = modelProvider && modelId ? `${modelProvider}/${modelId}` : '';
+  const contextUsed = contextAnchor;
+  const contextPercent = Math.min(100, Math.max(0, Number(((contextUsed / CONTEXT_LIMIT) * 100).toFixed(1))));
+
+  // Distribution: real token categories (input→user, output→assistant, cacheWrite→tool, cacheRead→other); char fallback when no usage.
+  const hasUsage = sumInput + sumOutput + sumCacheRead + sumCacheWrite > 0;
+  const userTokens = hasUsage ? sumInput : userChars;
+  const assistantTokens = hasUsage ? sumOutput : assistantChars;
+  const toolTokens = hasUsage ? sumCacheWrite : toolChars;
+  const otherTokens = hasUsage ? sumCacheRead : 0;
+  const grand = Math.max(1, userTokens + assistantTokens + toolTokens + otherTokens);
+  const userPercent = Math.max(0, Math.round((userTokens / grand) * 100));
+  const assistantPercent = Math.max(0, Math.round((assistantTokens / grand) * 100));
+  const toolPercent = Math.max(0, Math.round((toolTokens / grand) * 100));
+  const otherPercent = Math.max(0, 100 - userPercent - assistantPercent - toolPercent);
+
+  const lastTokens = tokensOf(lastAsstUsage);
+  const cacheHitPercent = lastAsstUsage && lastTokens.input + lastTokens.output + lastTokens.cacheRead > 0 ? Number(((lastTokens.cacheRead / (lastTokens.input + lastTokens.output + lastTokens.cacheRead)) * 100).toFixed(1)) : 0;
+  const cacheHitAverage = cacheAvgInput + cacheAvgCacheRead > 0 ? Number(((cacheAvgCacheRead / (cacheAvgInput + cacheAvgCacheRead)) * 100).toFixed(1)) : 0;
+
+  return {
+    sessionId,
+    sessionTitle: effectiveTitle || shortSummary || firstUserText
+      || (header?.timestamp ? formatNewSessionTitle(new Date(header.timestamp)) : defaultTitle),
+    modelId: providerModel,
+    modelName: providerModel,
+    timestamp: formatTs(header?.timestamp),
+    contextUsed,
+    contextLimit: CONTEXT_LIMIT,
+    contextPercent,
+    messagesCount,
+    userCount,
+    assistantCount,
+    totalCost,
+    costFormatted: formatCost(totalCost),
+    cacheHitAverage,
+    costBreakdown: { input: costInput, output: costOutput, cacheRead: costCacheRead, cacheWrite: costCacheWrite, total: totalCost },
+    lastMessage: {
+      input: lastTokens.input,
+      output: lastTokens.output,
+      reasoning: lastTokens.reasoning,
+      cacheRead: lastTokens.cacheRead,
+      cacheWrite: lastTokens.cacheWrite,
+      cacheHitPercent,
+    },
+    distribution: {
+      userTokens,
+      userPercent,
+      assistantTokens,
+      assistantPercent,
+      toolTokens,
+      toolPercent,
+      otherTokens,
+      otherPercent,
+    },
+    // Held to `rawLimit` items — the panel pages via computeRawMessagesPage.
+    rawMessages,
+  };
+}