ompchamber 0.3.0

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

@@ -0,0 +1,110 @@
+import { isRecord } from '@/shared/lib/util/guards';
+import type { RawMessageInfo, SessionContextTelemetry } from '@/shared/types/context';
+import type { OmpMessage, OmpMessageEntry, OmpUsage } from '@/shared/types/omp/session';
+
+/** Model context window assumed when a session records none. */
+export const CONTEXT_LIMIT = 1_000_000;
+
+/** Flatten an omp content value (string or block array) to plain text. */
+export function textOf(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (typeof block.text === 'string') parts.push(block.text);
+    else if (typeof block.thinking === 'string') parts.push(block.thinking);
+  }
+  return parts.join(' ').trim();
+}
+
+export function formatTs(ts: string | number | undefined): string {
+  if (ts === undefined) return '';
+  const date = typeof ts === 'number' ? new Date(ts) : new Date(ts);
+  if (Number.isNaN(date.getTime())) return '';
+  return date.toLocaleString('en-US', {
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+  });
+}
+
+export function formatCost(value: number): string {
+  return value < 0.01 ? '$0.01' : `$${value.toFixed(2)}`;
+}
+
+export function tokensOf(usage: OmpUsage | undefined): {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning: number;
+  total: number;
+} {
+  const input = usage?.input ?? 0;
+  const output = usage?.output ?? 0;
+  const cacheRead = usage?.cacheRead ?? 0;
+  const cacheWrite = usage?.cacheWrite ?? 0;
+  const reasoning = usage?.reasoningTokens ?? 0;
+  const total = usage?.totalTokens ?? input + output + cacheRead + cacheWrite;
+  return { input, output, cacheRead, cacheWrite, reasoning, total };
+}
+
+export function contextAnchorTokens(msg: OmpMessage): number | undefined {
+  const snapshot = msg.contextSnapshot;
+  const usage = msg.usage;
+  let promptTokens: number;
+  if (snapshot?.promptTokens !== undefined) promptTokens = snapshot.promptTokens;
+  else if (usage?.contextTokens !== undefined && usage.contextTokens > 0) promptTokens = usage.contextTokens;
+  else if (usage) promptTokens = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+  else return undefined;
+  if (promptTokens <= 0) return undefined;
+  return Math.max(0, promptTokens - (snapshot?.historyRewriteTokensRemoved ?? 0));
+}
+
+export function buildInfo(
+  entry: OmpMessageEntry,
+  msg: OmpMessage,
+  cwd: string,
+  index: number,
+): RawMessageInfo {
+  const usage = tokensOf(msg.usage);
+  return {
+    id: entry.id ?? `m${index}`,
+    parentID: entry.parentId ?? undefined,
+    role: msg.role === 'user' ? 'user' : 'assistant',
+    path: { cwd, root: cwd },
+    cost: msg.usage?.cost?.total ?? 0,
+    tokens: {
+      total: usage.total,
+      input: usage.input,
+      output: usage.output,
+      reasoning: usage.reasoning,
+      cache: { write: usage.cacheWrite, read: usage.cacheRead },
+    },
+    modelID: msg.provider && msg.model ? `${msg.provider}/${msg.model}` : '',
+  };
+}
+
+export function emptyTelemetry(sessionId: string, sessionTitle: string): SessionContextTelemetry {
+  return {
+    sessionId,
+    sessionTitle,
+    modelId: '',
+    modelName: '',
+    timestamp: '',
+    contextUsed: 0,
+    contextLimit: CONTEXT_LIMIT,
+    contextPercent: 0,
+    messagesCount: 0,
+    userCount: 0,
+    assistantCount: 0,
+    totalCost: 0,
+    costFormatted: '$0.01',
+    lastMessage: { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, cacheHitPercent: 0 },
+    distribution: { userTokens: 0, userPercent: 0, assistantTokens: 0, assistantPercent: 0, toolTokens: 0, toolPercent: 0, otherTokens: 0, otherPercent: 100 },
+    rawMessages: [],
+  };
+}

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

@@ -0,0 +1,4 @@
+export type { OmpContextSnapshot, OmpMessage, OmpMessageEntry, OmpUsage } from '@/shared/types/omp/session';
+export { CONTEXT_LIMIT, buildInfo, contextAnchorTokens, formatCost, formatTs, textOf, tokensOf } from '@/server/lib/omp/session/telemetry/format';
+export { scanSessionEntries } from '@/server/lib/omp/session/telemetry/scan';
+export { computeRealSessionTelemetry } from '@/server/lib/omp/session/telemetry/compute';

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

@@ -0,0 +1,21 @@
+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> {
+  let body: string;
+  try {
+    body = await Bun.file(filePath).text();
+  } catch {
+    return;
+  }
+  const records = parseJsonlLenient<OmpMessageEntry>(body);
+  for (let index = 0; index < records.length; index++) {
+    const entry = records[index];
+    if (!entry) continue;
+    if (visit(entry, index) === false) break;
+  }
+}

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

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * 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.
+ */
+
+import type { RawMessageItem } from '@/shared/types/context';
+import { buildInfo, formatTs, scanSessionEntries, textOf, tokensOf, type OmpMessage, type OmpMessageEntry } from '@/server/lib/omp/session/telemetry';
+import { contentProfile } from '@/shared/lib/omp/session/telemetry-blocks';
+
+export type RawMessageRole = 'all' | 'assistant' | 'user';
+
+export interface RawMessagesPage {
+  items: RawMessageItem[];
+  total: number;
+  filteredTotal: number;
+}
+
+/**
+ * Read one page of raw messages, newest-first. The scan keeps a sliding
+ * window of the last `page * pageSize` matches and slices its tail, so
+ * server memory stays O(page) regardless of session length.
+ */
+export async function computeRawMessagesPage(
+  filePath: string,
+  page: number,
+  pageSize: number,
+  role: RawMessageRole = 'all',
+): Promise<RawMessagesPage> {
+  const windowSize = Math.max(1, page) * pageSize;
+  const window: RawMessageItem[] = [];
+  let total = 0;
+  let filteredTotal = 0;
+  let header: OmpMessageEntry | undefined;
+
+  await scanSessionEntries(filePath, (entry, index) => {
+    if (entry.type === 'session' && !header) {
+      header = entry;
+      return;
+    }
+    if (entry.type !== 'message' || !entry.message) return;
+
+    const msg = entry.message;
+    // Match computeRealSessionTelemetry: only user/assistant messages are raw
+    // panel items — toolResult entries are bookkeeping, not listed.
+    if (msg.role !== 'assistant' && msg.role !== 'user') return;
+    const msgRole: 'assistant' | 'user' = msg.role;
+    total++;
+    if (role !== 'all' && msgRole !== role) return;
+    filteredTotal++;
+
+    if (window.length >= windowSize) window.shift();
+    window.push(buildRawItem(entry, msg, header?.cwd ?? '', index));
+  });
+
+  // `window` holds the last `windowSize` matches, oldest→newest, where
+  // windowSize = page * pageSize. Page N is the Nth-newest chunk of pageSize
+  // 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 start = Math.max(0, end - pageSize);
+  const items = window.slice(start, end).reverse();
+  return { items, total, filteredTotal };
+}
+
+function buildRawItem(
+  entry: OmpMessageEntry,
+  msg: OmpMessage,
+  cwd: string,
+  index: number,
+): RawMessageItem {
+  const isAssistant = msg.role === 'assistant';
+  const text = textOf(msg.content);
+  const profile = contentProfile(msg.content);
+  const snippet = text.slice(0, 70);
+  const tokens = tokensOf(msg.usage);
+  return {
+    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: buildInfo(entry, msg, cwd, index),
+    rawPayload: entry as unknown as Record<string, any>,
+  };
+}

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

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+
+import { computeRealSessionTelemetry } from '@/server/lib/omp/session/telemetry';
+
+const tempDirs: string[] = [];
+
+async function writeSession(records: unknown[]): Promise<string> {
+  const dir = await fs.promises.mkdtemp('omp-telemetry-');
+  tempDirs.push(dir);
+  const file = `${dir}/session.jsonl`;
+  await Bun.write(file, records.map((record) => JSON.stringify(record)).join('\n'));
+  return file;
+}
+
+afterAll(() => {
+  for (const dir of tempDirs) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+const header = {
+  type: 'session',
+  id: 'ses_telemetry',
+  cwd: '/tmp/project',
+  timestamp: '2026-09-16T02:31:04.338Z',
+};
+
+function userMessage(id: string, text: string): Record<string, unknown> {
+  return {
+    type: 'message',
+    id,
+    timestamp: '2026-09-16T02:31:30.000Z',
+    message: { role: 'user', content: text },
+  };
+}
+
+function assistantMessage(id: string, message: Record<string, unknown>): Record<string, unknown> {
+  return {
+    type: 'message',
+    id,
+    timestamp: '2026-09-16T02:32:00.000Z',
+    message: {
+      role: 'assistant',
+      provider: 'anthropic',
+      model: '',
+      content: [{ type: 'text', text: 'ok' }],
+      ...message,
+    },
+  };
+}
+
+describe('computeRealSessionTelemetry context anchor', () => {
+  test('uses the latest assistant anchor, never cumulative totalTokens', async () => {
+    const file = await writeSession([
+      header,
+      userMessage('u1', 'first turn'),
+      assistantMessage('a1', {
+        usage: { input: 900, output: 100, cacheRead: 0, cacheWrite: 0, totalTokens: 1_000_000 },
+        contextSnapshot: { promptTokens: 2000, nonMessageTokens: 10 },
+      }),
+      userMessage('u2', 'second turn'),
+      assistantMessage('a2', {
+        usage: { input: 950, output: 50, cacheRead: 0, cacheWrite: 0, totalTokens: 2_000_000 },
+        contextSnapshot: { promptTokens: 3000, nonMessageTokens: 10 },
+      }),
+    ]);
+
+    const telemetry = await computeRealSessionTelemetry(file, 'ses_telemetry');
+    expect(telemetry.contextUsed).toBe(3000);
+    expect(telemetry.contextPercent).toBe(0.3);
+  });
+
+  test('subtracts historyRewriteTokensRemoved from the anchor snapshot', async () => {
+    const file = await writeSession([
+      header,
+      userMessage('u1', 'rewritten turn'),
+      assistantMessage('a1', {
+        usage: { input: 5000, output: 10, cacheRead: 0, cacheWrite: 0, totalTokens: 5010 },
+        contextSnapshot: { promptTokens: 5000, nonMessageTokens: 10, historyRewriteTokensRemoved: 1200 },
+      }),
+    ]);
+
+    const telemetry = await computeRealSessionTelemetry(file, 'ses_telemetry');
+    expect(telemetry.contextUsed).toBe(3800);
+  });
+
+  test('falls back to usage.contextTokens when no snapshot exists', async () => {
+    const file = await writeSession([
+      header,
+      userMessage('u1', 'context tokens'),
+      assistantMessage('a1', {
+        usage: { input: 100, output: 50, cacheRead: 100, cacheWrite: 0, totalTokens: 250, contextTokens: 4000 },
+      }),
+    ]);
+
+    const telemetry = await computeRealSessionTelemetry(file, 'ses_telemetry');
+    expect(telemetry.contextUsed).toBe(4000);
+  });
+
+  test('falls back to input + cacheRead + cacheWrite when contextTokens is absent', async () => {
+    const file = await writeSession([
+      header,
+      userMessage('u1', 'prompt sum'),
+      assistantMessage('a1', {
+        usage: { input: 1000, output: 10, cacheRead: 500, cacheWrite: 250, totalTokens: 1760 },
+      }),
+    ]);
+
+    const telemetry = await computeRealSessionTelemetry(file, 'ses_telemetry');
+    expect(telemetry.contextUsed).toBe(1750);
+  });
+
+  test('sets distribution.otherTokens to cumulative cacheRead and keeps aggregate stats', async () => {
+    const file = await writeSession([
+      header,
+      userMessage('u1', 'first turn'),
+      assistantMessage('a1', {
+        usage: {
+          input: 1000,
+          output: 100,
+          cacheRead: 100,
+          cacheWrite: 20,
+          totalTokens: 1220,
+          cost: { total: 0.01, input: 0.005, output: 0.003, cacheRead: 0.001, cacheWrite: 0.001 },
+        },
+        contextSnapshot: { promptTokens: 1100, nonMessageTokens: 10 },
+      }),
+      userMessage('u2', 'second turn'),
+      assistantMessage('a2', {
+        usage: {
+          input: 2000,
+          output: 200,
+          cacheRead: 250,
+          cacheWrite: 30,
+          totalTokens: 2480,
+          cost: { total: 0.02, input: 0.01, output: 0.006, cacheRead: 0.002, cacheWrite: 0.002 },
+        },
+        contextSnapshot: { promptTokens: 2200, nonMessageTokens: 10 },
+      }),
+    ]);
+
+    const telemetry = await computeRealSessionTelemetry(file, 'ses_telemetry');
+    expect(telemetry.distribution.userTokens).toBe(3000);
+    expect(telemetry.distribution.assistantTokens).toBe(300);
+    expect(telemetry.distribution.toolTokens).toBe(50);
+    expect(telemetry.distribution.otherTokens).toBe(350);
+    expect(telemetry.totalCost).toBeCloseTo(0.03, 5);
+    expect(telemetry.contextUsed).toBe(2200);
+  });
+});

package/src/server/lib/omp/session/title-slot.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Fixed-width session-title slot writer for oh-my-pi JSONL session files.
+ *
+ * Faithful port of omp-web/lib/omp/session-files.ts (itself a port of
+ * oh-my-pi packages/coding-agent/src/session/session-title-slot.ts). The first
+ * line of a v3 session file is an optional 256-byte JSON record holding the
+ * display title. Because the width is fixed, a rename can overwrite just that
+ * line in place — a bounded write that never shifts the rest of the file, so
+ * it cannot corrupt a session a live omp process still holds.
+ *
+ * Legacy files without the slot are rewritten atomically (temp + rename) with
+ * a fresh slot line inserted and the header's title fields updated.
+ */
+
+import fs from 'fs';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { SESSION_TITLE_SLOT_BYTES } from '@/server/lib/omp/session/files';
+
+/**
+ * Ceiling for the legacy full-file rewrite path. A slot-less file larger than
+ * this is refused rather than loaded into memory (matching the
+ * MAX_SESSION_LOAD_BYTES ceiling in ./messages.ts).
+ */
+const MAX_TITLE_REWRITE_BYTES = 512 * 1024 * 1024;
+
+export interface SessionTitleSlot {
+  type: 'title';
+  v: 1;
+  title: string;
+  source?: 'auto' | 'user';
+  updatedAt: string;
+  pad: string;
+}
+
+function titleSlotLine(
+  title: string,
+  source: 'auto' | 'user' | undefined,
+  updatedAt: string,
+  pad: string,
+): string {
+  const slot: SessionTitleSlot = source
+    ? { type: 'title', v: 1, title, source, updatedAt, pad }
+    : { type: 'title', v: 1, title, updatedAt, pad };
+  return `${JSON.stringify(slot)}\n`;
+}
+
+/** Longest code-point prefix of `title` whose serialized line fits the slot. */
+function truncateTitleForSlot(
+  title: string,
+  source: 'auto' | 'user' | undefined,
+  updatedAt: string,
+): string {
+  const codePoints = [...title];
+  let low = 0;
+  let high = codePoints.length;
+  let best = '';
+  while (low <= high) {
+    const mid = (low + high) >>> 1;
+    const candidate = codePoints.slice(0, mid).join('');
+    if (Buffer.byteLength(titleSlotLine(candidate, source, updatedAt, ''), 'utf8') <= SESSION_TITLE_SLOT_BYTES) {
+      best = candidate;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return best;
+}
+
+function isSessionTitleSource(value: unknown): value is 'auto' | 'user' {
+  return value === 'auto' || value === 'user';
+}
+
+/** Parse a physical title-slot JSONL line. Returns undefined for anything else. */
+export function parseTitleSlotLine(line: string): SessionTitleSlot | undefined {
+  let value: unknown;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return undefined;
+  }
+  if (typeof value !== 'object' || value === null) return undefined;
+  const record = value as Record<string, unknown>;
+  if (record.type !== 'title' || record.v !== 1) return undefined;
+  if (typeof record.title !== 'string' || typeof record.updatedAt !== 'string' || typeof record.pad !== 'string') {
+    return undefined;
+  }
+  if (record.source !== undefined && !isSessionTitleSource(record.source)) return undefined;
+  const slot: SessionTitleSlot = {
+    type: 'title',
+    v: 1,
+    title: record.title,
+    updatedAt: record.updatedAt,
+    pad: record.pad,
+  };
+  if (record.source !== undefined) slot.source = record.source;
+  return slot;
+}
+
+/** Serialize the title slot to exactly 256 UTF-8 bytes including the newline. */
+export function serializeTitleSlot(update: { title?: string; source?: 'auto' | 'user'; updatedAt: string }): string {
+  const title = truncateTitleForSlot(update.title ?? '', update.source, update.updatedAt);
+  const unpadded = titleSlotLine(title, update.source, update.updatedAt, '');
+  const padBytes = SESSION_TITLE_SLOT_BYTES - Buffer.byteLength(unpadded, 'utf8');
+  if (padBytes < 0) throw new Error('Session title slot metadata exceeds fixed slot size');
+  const line = titleSlotLine(title, update.source, update.updatedAt, ' '.repeat(padBytes));
+  if (Buffer.byteLength(line, 'utf8') !== SESSION_TITLE_SLOT_BYTES) {
+    throw new Error('Session title slot serialization failed to produce fixed-width output');
+  }
+  return line;
+}
+
+/** Read only the fixed-size head window to detect a physical title slot. */
+export async function readTitleSlot(filePath: string): Promise<SessionTitleSlot | undefined> {
+  try {
+    const head = await Bun.file(filePath).slice(0, SESSION_TITLE_SLOT_BYTES).text();
+    const newlineIndex = head.indexOf('\n');
+    if (newlineIndex < 0) return undefined;
+    return parseTitleSlotLine(head.slice(0, newlineIndex));
+  } catch {
+    return undefined;
+  }
+}
+
+/** Strip control characters and collapse runs of spaces (omp's #cleanTitle). */
+export function cleanSessionTitle(raw: string): string {
+  return raw
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
+    .replace(/ +/g, ' ')
+    .trim();
+}
+
+/**
+ * Persist a session title. When line 1 is already a title slot the new slot is
+ * rewritten IN PLACE: serializeTitleSlot always produces exactly 256 bytes
+ * (title truncated by code points to fit), so the overwrite never shifts the
+ * rest of the file. Fallback for legacy files without a slot: rewrite the
+ * whole file atomically (temp + rename), inserting a fresh slot line and
+ * updating the header's title fields.
+ *
+ * Note: unlike omp's SessionManager.setSessionName this does not append a
+ * title_change audit entry — a bounded 256-byte write cannot corrupt a file a
+ * live omp process may hold, and the display title is all callers need.
+ */
+export async function setSessionTitle(filePath: string, title: string, source: 'auto' | 'user'): Promise<boolean> {
+  const cleaned = cleanSessionTitle(title);
+  if (!cleaned) return false;
+  const update = { title: cleaned, source, updatedAt: new Date().toISOString() };
+
+  if (await readTitleSlot(filePath)) {
+    // In-place 256-byte slot overwrite via an r+ handle; a positioned write is
+    // the only way to write at an offset — Bun's FileSink cannot seek.
+    const slotLine = Buffer.from(serializeTitleSlot(update), 'utf8');
+    const handle = await fs.promises.open(filePath, 'r+');
+    try {
+      let offset = 0;
+      while (offset < slotLine.length) {
+        const { bytesWritten } = await handle.write(slotLine, offset, slotLine.length - offset, offset);
+        if (bytesWritten === 0) throw new Error('Short write while updating session title slot');
+        offset += bytesWritten;
+      }
+    } finally {
+      await handle.close();
+    }
+    return true;
+  }
+
+  // Legacy file without a slot: full rewrite through a temp file. Refuse to
+  // materialize a file larger than the load ceiling — renaming a session
+  // should never risk OOMing the server, and legacy slot-less files are rare.
+  let legacySize: number;
+  try {
+    legacySize = (await Bun.file(filePath).stat()).size;
+  } catch {
+    return false;
+  }
+  if (legacySize > MAX_TITLE_REWRITE_BYTES) {
+    return false;
+  }
+  const content = await Bun.file(filePath).text();
+  const lines = content.split('\n');
+  const headerIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (headerIndex === -1) throw new Error('Cannot rename an empty session file');
+  let header: Record<string, unknown>;
+  try {
+    header = JSON.parse(lines[headerIndex]) as Record<string, unknown>;
+  } catch {
+    throw new Error('Cannot rename a session file with a malformed header');
+  }
+  if (header.type !== 'session') throw new Error('Not a session file');
+  header.title = cleaned;
+  header.titleSource = source;
+  lines[headerIndex] = JSON.stringify(header);
+  const body = serializeTitleSlot(update) + lines.join('\n');
+
+  await writeFileAtomic(filePath, body);
+  return true;
+}