ompchamber 2.0.2 → 3.1.0

package/src/server/lib/omp/config/providers.ts

@@ -13,27 +13,48 @@
  * schema before it reaches disk. Reading lives in `./models-config.ts`.
  */
 
-import { isMap, isSeq, type Document, type YAMLMap } from 'yaml';
+import { isMap, isSeq, type YAMLMap } from 'yaml';
 import { getModelsConfigPath } from '@/server/lib/omp/config/models-config';
 import { plainOf, withOmpYamlDocument, OmpConfigError } from '@/server/lib/omp/config/document';
-import { validateModelsDocument, sanitizeModelEntry } from '@/server/lib/omp/config/models-validation';
-import { isRecord } from '@/shared/lib/util/guards';
+import { validateModelsDocument } from '@/server/lib/omp/config/models-validation';
+import {
+  backfillableIds,
+  backfillEntry,
+  knownModelIds,
+  toModelEntry,
+  type OmpProviderModelSeed,
+} from '@/server/lib/omp/config/provider-seeds';
+import { isMaskedApiKey } from '@/shared/lib/models/provider/dialect';
+import type {
+  OmpProviderApi,
+  ProviderAuthMode,
+  ProviderDiscoveryType,
+} from '@/shared/types/settings/provider';
 
-/** One model entry destined for models.yml (cost numbers are USD per 1M tokens). */
-export interface OmpProviderModelSeed {
-  id: string;
-  name?: string;
-  reasoning?: boolean;
-  imageInput?: boolean;
-  contextWindow?: number;
-  maxTokens?: number;
-  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
-}
+export type { OmpProviderModelSeed } from '@/server/lib/omp/config/provider-seeds';
 
 export interface OmpProviderUpsertInput {
   baseUrl: string;
   apiKey?: string;
-  api?: 'openai-completions' | 'anthropic-messages' | 'google-generative-ai';
+  api?: OmpProviderApi;
+  /**
+   * omp's auth mode. `none` is what registers a keyless local server: without
+   * it omp demands an `apiKey` and rejects the provider as unconfigured.
+   */
+  auth?: ProviderAuthMode;
+  /**
+   * Let OMP list this provider's models live instead of the chamber writing a
+   * snapshot of ids. A discovery provider is legitimately registered with an
+   * empty `models` array.
+   */
+  discovery?: ProviderDiscoveryType;
+  /**
+   * Register/override the provider WITHOUT writing any model ids — the shape
+   * omp documents as an "override-only provider". Used when the provider is one
+   * omp already bundles (its own catalog supplies the models) or when its
+   * model list is owned by discovery.
+   */
+  overrideOnly?: boolean;
   models: OmpProviderModelSeed[];
 }
 
@@ -46,75 +67,30 @@ export interface OmpProviderUpsertResult {
   reason?: string;
 }
 
-/** Masks a stored credential echoed back by the UI; not a value to persist. */
-const MASKED_KEY_PATTERN = /•{3,}/;
-
-/** True when `value` is a credential the UI masked rather than a real key. */
-export function isMaskedApiKey(value: unknown): boolean {
-  return typeof value === 'string' && MASKED_KEY_PATTERN.test(value);
-}
-
-/** The model ids already registered under `provider`, array form only. */
-function knownModelIds(provider: Record<string, unknown> | undefined): Set<string> {
-  if (!Array.isArray(provider?.models)) return new Set();
-  return new Set(
-    provider.models
-      .map((model) => (isRecord(model) && typeof model.id === 'string' ? model.id : ''))
-      .filter(Boolean),
-  );
-}
-
-/** The model entry as omp expects it, omitting anything omp would reject. */
-function toModelEntry(model: OmpProviderModelSeed): Record<string, unknown> {
-  return sanitizeModelEntry({
-    id: model.id,
-    ...(model.name ? { name: model.name } : {}),
-    ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
-    ...(model.imageInput ? { input: ['text', 'image'] } : { input: ['text'] }),
-    ...(model.contextWindow && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
-    ...(model.maxTokens && model.maxTokens > 0 ? { maxTokens: model.maxTokens } : {}),
-    ...(model.cost ? { cost: model.cost } : {}),
-  });
-}
-
-/**
- * Metadata a bare existing entry is missing, taken from the freshly fetched
- * seed. Values already present are never touched. Writes through the YAML node
- * so the entry's own comments and key order stay as the user wrote them.
- */
-function backfillEntry(doc: Document, entry: YAMLMap, seed: OmpProviderModelSeed): void {
-  if (seed.name && !entry.has('name')) entry.set('name', seed.name);
-  if (seed.reasoning !== undefined && !entry.has('reasoning')) {
-    entry.set('reasoning', seed.reasoning);
-  }
-  const currentInput = plainOf<string[]>(doc, entry.get('input'));
-  if (seed.imageInput && (!Array.isArray(currentInput) || !currentInput.includes('image'))) {
-    entry.set('input', ['text', 'image']);
-  }
-  if (seed.contextWindow && seed.contextWindow > 0 && !plainOf(doc, entry.get('contextWindow'))) {
-    entry.set('contextWindow', seed.contextWindow);
-  }
-  if (seed.maxTokens && seed.maxTokens > 0 && !plainOf(doc, entry.get('maxTokens'))) {
-    entry.set('maxTokens', seed.maxTokens);
-  }
-  if (seed.cost && !entry.has('cost')) {
-    entry.set('cost', seed.cost);
-  }
-}
-
 /**
  * Add-only upsert of a provider (and its models) into the native omp
  * models.yml — the agent's own registry, where per-model cost feeds usage
- * tracking. Existing provider fields (apiKey, baseUrl) and existing model
+ * tracking. Existing provider fields (apiKey, baseUrl, api) and existing model
  * entries are never modified; only models whose id is not yet registered are
- * appended. Merges preserve unrelated keys, comments and formatting (document
- * model), and the write is atomic and mode-preserving.
+ * appended, and only fields the entry is MISSING are filled. Merges preserve
+ * unrelated keys, comments and formatting (document model), and the write is
+ * atomic and mode-preserving.
+ *
+ * Three provider shapes are written here, and omp's rules differ for each:
+ *
+ * - **full** (`models` non-empty): `baseUrl` plus an `apiKey` unless
+ *   `auth: none`/`oauth`.
+ * - **discovery** (`discovery` set): a shell omp lists models from itself. The
+ *   model list stays empty — writing ids as well would freeze a snapshot omp
+ *   would then serve alongside its live discovery.
+ * - **override** (`overrideOnly`, or an empty model list for a provider omp
+ *   already bundles): keep omp's own catalog models and only change the
+ *   endpoint. A provider with neither models nor any config field is rejected
+ *   by omp, so one of `baseUrl`/`apiKey`/`auth: none`/`discovery` must be set.
  *
- * Provider creation requires an apiKey — omp rejects models-cfg providers
- * without one unless auth is "none" or "oauth"; existing providers keep
- * whatever credential they already have. The finished document is validated
- * against omp's own rules before the write: a schema violation anywhere in the
- * file makes omp disable every custom provider at once.
+ * The finished document is validated against omp's own rules before the write:
+ * a schema violation anywhere in the file makes omp disable every custom
+ * provider at once.
  */
 export async function upsertOmpProviderModels(
   slug: string,
@@ -144,11 +120,18 @@ export async function upsertOmpProviderModels(
         + 'Fix that entry before adding models; omp currently disables every custom provider because of it.',
       );
     }
+    // omp demands an `apiKey` only when a provider carries MODELS: an
+    // override-only entry (baseUrl/discovery/auth) is valid without one, which
+    // is how a proxy override for a bundled provider keeps using `/login`
+    // credentials, and how a keyless local server is declared.
+    const overrideOnly = input.overrideOnly === true || input.discovery !== undefined;
+    const writesModels = !overrideOnly && input.models.length > 0;
+    const keyless = input.auth === 'none' || input.auth === 'oauth';
     const known = knownModelIds(existing);
     const incomingById = new Map(input.models.map((model) => [model.id, model]));
     const additions = input.models.filter((model) => model.id && !known.has(model.id));
 
-    if (!existing && !input.apiKey) {
+    if (!existing && writesModels && !input.apiKey && !keyless) {
       return {
         result: {
           written: false,
@@ -164,7 +147,7 @@ export async function upsertOmpProviderModels(
     // writer is the last gate before a file omp will authenticate with — a
     // masked placeholder persisted here would look like a configured provider
     // that cannot authenticate.
-    if (!existing && isMaskedApiKey(input.apiKey)) {
+    if (!existing && writesModels && isMaskedApiKey(input.apiKey)) {
       return {
         result: {
           written: false,
@@ -179,22 +162,21 @@ export async function upsertOmpProviderModels(
 
     // Existing entries with bare ids (no context, no capabilities) get the
     // fetched metadata filled in — values already present are never touched.
-    const backfillIds = (Array.isArray(existing?.models) ? existing.models : [])
-      .filter((model): model is Record<string, unknown> => {
-        if (!isRecord(model) || typeof model.id !== 'string') return false;
-        const seed = incomingById.get(model.id);
-        if (!seed) return false;
-        const missingContext = typeof model.contextWindow !== 'number' || !model.contextWindow;
-        return Boolean(
-          (missingContext && (seed.contextWindow || seed.maxTokens))
-          || (!model.cost && seed.cost)
-          || (seed.reasoning !== undefined && model.reasoning === undefined)
-          || (!Array.isArray(model.input) && seed.imageInput),
-        );
-      })
-      .map((model) => String(model.id));
+    // A discovery provider keeps its empty list: omp owns those models.
+    const backfillIds = overrideOnly ? [] : backfillableIds(existing?.models, incomingById);
 
-    if (additions.length === 0 && backfillIds.length === 0) {
+    // A provider the user re-saves without any new model and without a dialect
+    // change has nothing to write — reporting `written: true` there would claim
+    // a file edit that never happened. A provider that does NOT exist yet is
+    // always a change: the entry itself is the write, which is the whole point
+    // of a discovery or override registration that carries no model ids.
+    const providerChanged = !existing || Boolean(
+      (input.api && !existing.api)
+      || (input.auth && input.auth !== 'apiKey' && !existing.auth)
+      || (input.discovery && !existing.discovery),
+    );
+
+    if (additions.length === 0 && backfillIds.length === 0 && !providerChanged) {
       return {
         result: {
           written: false,
@@ -213,16 +195,28 @@ export async function upsertOmpProviderModels(
     if (!existing) {
       doc.setIn(['providers', slug], doc.createNode({
         baseUrl: input.baseUrl,
-        apiKey: input.apiKey,
+        // `auth: none` makes an apiKey optional, so a keyless shell omits it
+        // rather than writing an empty string omp rejects.
+        ...(input.apiKey ? { apiKey: input.apiKey } : {}),
         // omp disables every custom provider when a models-carrying provider
         // lacks "api" (provider or model level) — always set one.
         api: input.api ?? 'openai-completions',
+        ...(input.auth && input.auth !== 'apiKey' ? { auth: input.auth } : {}),
+        ...(input.discovery ? { discovery: { type: input.discovery } } : {}),
         models: [],
       }));
-    } else if (!existing.api) {
-      // Existing provider without an api: adding models without one would make
-      // the whole models.yml fail omp validation, so fill it.
-      doc.setIn(['providers', slug, 'api'], input.api ?? 'openai-completions');
+    } else {
+      // Add-only: a field the entry already carries belongs to the user, and
+      // rewriting it would discard a credential or endpoint they pinned.
+      if (!existing.api) {
+        doc.setIn(['providers', slug, 'api'], input.api ?? 'openai-completions');
+      }
+      if (input.auth && input.auth !== 'apiKey' && !existing.auth) {
+        doc.setIn(['providers', slug, 'auth'], input.auth);
+      }
+      if (input.discovery && !existing.discovery) {
+        doc.setIn(['providers', slug, 'discovery'], doc.createNode({ type: input.discovery }));
+      }
     }
 
     // `addIn` on a missing key creates a MAP, not a sequence — exactly the

package/src/server/lib/omp/core/auth-credentials.ts

@@ -85,3 +85,48 @@ export async function readOmpProviderApiKey(slug: string): Promise<string | null
   if (fromYml) return fromYml;
   return readAgentDbApiKey(slug);
 }
+
+/**
+ * Slugs holding a live (non-disabled) credential in omp's agent.db. Used to
+ * decide which providers a usage surface may list — a provider with no
+ * credential must not be shown at all. Returns slugs only, never key material.
+ */
+export async function listAgentDbCredentialSlugs(): Promise<string[]> {
+  const dbPath = join(getAgentDir(), 'agent.db');
+  if (!(await Bun.file(dbPath).exists())) return [];
+  let db: Database | null = null;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const rows = db
+      .query<{ provider: string }, []>(
+        `SELECT DISTINCT provider FROM ${AUTH_CREDENTIALS_TABLE} WHERE disabled_cause IS NULL`,
+      )
+      .all();
+    return rows
+      .map((row) => (typeof row.provider === 'string' ? row.provider.trim().toLowerCase() : ''))
+      .filter(Boolean);
+  } catch {
+    return []; // no-excuse-ok: catch — best-effort read of an external store
+  } finally {
+    db?.close();
+  }
+}
+
+/** Slugs carrying an `apiKey` in models.yml. Returns slugs only. */
+export async function listModelsYmlCredentialSlugs(): Promise<string[]> {
+  const path = await getModelsConfigPath();
+  if (!(await Bun.file(path).exists())) return [];
+  try {
+    const data = Bun.YAML.parse(await Bun.file(path).text());
+    if (!isRecord(data) || !isRecord(data.providers)) return [];
+    const slugs: string[] = [];
+    for (const [slug, value] of Object.entries(data.providers)) {
+      if (!isRecord(value)) continue;
+      const key = typeof value.apiKey === 'string' ? value.apiKey.trim() : '';
+      if (key.length > 0) slugs.push(slug.trim().toLowerCase());
+    }
+    return slugs;
+  } catch {
+    return []; // no-excuse-ok: catch — a malformed models.yml is a soft miss
+  }
+}

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

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read one session's todo state from its transcript.
+ *
+ * The list is omp's, and its only durable home is the session JSONL — there is
+ * no separate todo file and no chamber-side copy to fall out of date. So the
+ * read is: locate the session file, parse it, and take the deepest committed
+ * snapshot on the active branch (`latestTodoSnapshot`).
+ *
+ * Two properties of this read are deliberate:
+ *
+ *   - **It is a full-file parse, cached by size+mtime.** Measured on real
+ *     sessions (7.2 MB / 1905 entries) a full parse is ~15 ms, and the todos
+ *     may sit megabytes from EOF — a `todo` call near the start of a long
+ *     session stays the live list for the rest of it, so a bounded tail window
+ *     would report "no todos" for exactly the sessions that have the most. omp
+ *     flushes each entry as it appends, so a poll sees a new list within the
+ *     second it was written.
+ *   - **It never creates an omp process.** The session is read-only here; a
+ *     panel that spawned a child per poll would fight the chat's own session
+ *     wrapper for the same session file.
+ */
+
+import { findSessionFileById } from '@/server/lib/omp/session/locator';
+import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
+import { latestTodoSnapshot, todoProgress } from '@/shared/lib/chat/todo/snapshot';
+import type { SessionTodoState } from '@/shared/types/todo';
+
+/** Sessions larger than this are refused rather than parsed; a transcript past
+ *  it is pathological, and the read runs behind an HTTP request. */
+const MAX_TODO_SESSION_BYTES = 512 * 1024 * 1024;
+
+interface TodoCacheEntry {
+  size: number;
+  mtimeMs: number;
+  state: SessionTodoState;
+}
+
+/**
+ * Cache keyed by session id. Hangs off `globalThis` for the same reason the
+ * session-file caches do: a `bun --hot` reload re-evaluates modules but keeps
+ * `globalThis`, and a cache that vanished on every edit would re-parse a
+ * multi-megabyte file per poll during development.
+ */
+interface TodoCacheHost {
+  entries: Map<string, TodoCacheEntry>;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberTodoCache: TodoCacheHost | undefined;
+}
+
+function cache(): TodoCacheHost {
+  globalThis.__ompChamberTodoCache ??= { entries: new Map() };
+  return globalThis.__ompChamberTodoCache;
+}
+
+const EMPTY_TODO_STATE: SessionTodoState = { snapshot: null, progress: todoProgress([]) };
+
+/**
+ * The todo state of one session. Returns an empty state (never a throw) when
+ * the transcript cannot be read: a session whose file is gone is a normal
+ * condition for a sidebar entry the user has not opened yet, and the panel
+ * reports "no todos" rather than an error for it.
+ */
+export async function readSessionTodos(sessionId: string): Promise<SessionTodoState> {
+  const filePath = await findSessionFileById(sessionId);
+  if (!filePath) return EMPTY_TODO_STATE;
+
+  let size: number;
+  let mtimeMs: number;
+  try {
+    const stats = await Bun.file(filePath).stat();
+    if (stats.size > MAX_TODO_SESSION_BYTES) return EMPTY_TODO_STATE;
+    size = stats.size;
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return EMPTY_TODO_STATE;
+  }
+
+  const slot = cache().entries.get(sessionId);
+  if (slot && slot.size === size && slot.mtimeMs === mtimeMs) return slot.state;
+
+  let body: string;
+  try {
+    body = await Bun.file(filePath).text();
+  } catch {
+    return EMPTY_TODO_STATE;
+  }
+
+  const snapshot = latestTodoSnapshot(parseJsonlLenient<Record<string, unknown>>(body));
+  const state: SessionTodoState = { snapshot, progress: todoProgress(snapshot?.phases ?? []) };
+  cache().entries.set(sessionId, { size, mtimeMs, state });
+  return state;
+}

package/src/server/lib/omp/session/{usage.ts → usage/aggregate.ts}

@@ -15,7 +15,7 @@ import fs from 'fs';
 import { join } from 'path';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
 import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
-import type { BreakdownRow, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
+import type { TimeRangeType } from '@/shared/types';
 import type { OmpMessageEntry } from '@/shared/types/omp/session';
 
 export type UsageWindow =
@@ -179,120 +179,3 @@ export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregat
   cache.set(key, { at: Date.now(), data });
   return data;
 }
-
-const fmtInt = (value: number): string => value.toLocaleString('en-US');
-const fmtUsd = (value: number): string => `$${value.toFixed(2)}`;
-
-const MONTH_LABELS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] as const;
-
-function dayLabel(dayKey: string): string {
-  const date = new Date(`${dayKey}T00:00:00`);
-  return Number.isNaN(date.getTime()) ? dayKey : `${MONTH_LABELS[date.getMonth()]} ${date.getDate()}`;
-}
-
-function bucketKey(dayKey: string, cadence: CadenceType): string {
-  if (cadence === 'monthly') return dayKey.slice(0, 7);
-  if (cadence === 'weekly') {
-    const date = new Date(`${dayKey}T00:00:00`);
-    if (Number.isNaN(date.getTime())) return dayKey;
-    const monday = new Date(date);
-    const shift = (date.getDay() + 6) % 7;
-    monday.setDate(date.getDate() - shift);
-    return monday.toISOString().slice(0, 10);
-  }
-  return dayKey;
-}
-
-function labelForBucket(key: string, cadence: CadenceType): string {
-  if (cadence === 'monthly') {
-    const [year, month] = key.split('-');
-    const monthIndex = Number(month) - 1;
-    const label = MONTH_LABELS[monthIndex] ?? key;
-    return year && Number(year) !== new Date().getFullYear() ? `${label} ${year}` : label;
-  }
-  return dayLabel(key);
-}
-
-/** Shape the per-day aggregate into an ordered chart series for the cadence:
- * weekly buckets align to Monday, monthly to YYYY-MM, and the series is
- * truncated to the last 60 buckets so the SVG path stays readable. */
-export function buildChartSeries(a: UsageAggregate, cadence: CadenceType): ChartSeriesPoint[] {
-  const buckets = new Map<string, { cost: number; tokens: number }>();
-  for (const [dayKey, v] of a.byDay) {
-    const key = bucketKey(dayKey, cadence);
-    const current = buckets.get(key) ?? { cost: 0, tokens: 0 };
-    current.cost += v.cost;
-    current.tokens += v.tokens;
-    buckets.set(key, current);
-  }
-  return [...buckets.entries()]
-    .sort(([aKey], [bKey]) => (aKey < bKey ? -1 : aKey > bKey ? 1 : 0))
-    .slice(-60)
-    .map(([key, v]) => ({ label: labelForBucket(key, cadence), cost: v.cost, tokens: v.tokens }));
-}
-
-export function toMetricSet(a: UsageAggregate, cadence: CadenceType = 'daily'): TokenUsageMetricSet {
-  const observedInput = a.inputTokens + a.cacheReadTokens;
-  const cachedPercent = observedInput > 0 ? ((a.cacheReadTokens / observedInput) * 100).toFixed(1) : '0.0';
-  const unit = cadence === 'weekly' ? 'week' : cadence === 'monthly' ? 'month' : 'day';
-  return {
-    rawCost: fmtUsd(a.costTotal),
-    processedTokens: fmtInt(a.inputTokens + a.outputTokens + a.cacheReadTokens + a.cacheWriteTokens),
-    activeRate: `${a.activeDays.size} active ${unit}${a.activeDays.size === 1 ? '' : 's'}`,
-    cachedInput: fmtInt(a.cacheReadTokens),
-    cachedPercent: `${cachedPercent}% of observed input`,
-    uncachedInput: fmtInt(a.inputTokens),
-    outputTokens: fmtInt(a.outputTokens),
-    reasoning: `includes ${fmtInt(a.reasoningTokens)} reasoning`,
-    cacheSavings: fmtUsd(a.costCacheRead),
-    scannedTranscripts: a.scannedTranscripts,
-    usageRecords: a.usageRecords,
-  };
-}
-
-const BREAKDOWN_DOT_COLORS = [
-  'bg-[var(--theme-ink)]',
-  'bg-[var(--theme-ink)]/70',
-  'bg-[var(--theme-ink)]/50',
-  'bg-[var(--theme-ink)]/35',
-  'bg-[var(--theme-ink)]/20',
-] as const;
-
-/** Build breakdown rows (model/day/project) from the aggregate; the `day` tab
- * is bucketed by the cadence (day/week/month) so it stays consistent with the chart. */
-export function toBreakdownRows(
-  a: UsageAggregate,
-  tab: 'model' | 'day' | 'project',
-  cadence: CadenceType = 'daily',
-): BreakdownRow[] {
-  if (tab === 'day' && cadence !== 'daily') {
-    const buckets = new Map<string, { tokens: number; cost: number }>();
-    for (const [dayKey, v] of a.byDay) {
-      const key = bucketKey(dayKey, cadence);
-      const current = buckets.get(key) ?? { tokens: 0, cost: 0 };
-      current.tokens += v.tokens;
-      current.cost += v.cost;
-      buckets.set(key, current);
-    }
-    const merged: UsageAggregate = { ...a, byDay: buckets };
-    return toBreakdownRows(merged, 'day', 'daily');
-  }
-  const source = tab === 'model' ? a.byModel : tab === 'day' ? a.byDay : a.byProject;
-  return [...source.entries()]
-    .map(([name, v]) => ({
-      name: tab === 'day' ? labelForBucket(name, cadence) : name,
-      tokens: v.tokens,
-      cost: v.cost,
-      sharePercent: a.costTotal > 0 ? Math.round((v.cost / a.costTotal) * 100) : 0,
-    }))
-    .sort((x, y) => y.cost - x.cost)
-    .slice(0, 12)
-    .map((row, index) => ({
-      name: row.name,
-      tokens: fmtInt(row.tokens),
-      cost: fmtUsd(row.cost),
-      share: `${row.sharePercent}%`,
-      sharePercent: row.sharePercent,
-      dotColorClass: BREAKDOWN_DOT_COLORS[index % BREAKDOWN_DOT_COLORS.length],
-    }));
-}

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

@@ -0,0 +1,130 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Presentation shaping over the aggregate built by `./usage`: chart series,
+ * metric set, and breakdown rows. Split from the aggregator so the disk-scanning
+ * module stays focused (and under the repo's per-file size ceiling).
+ */
+
+import type { BreakdownRow, CadenceType, ChartSeriesPoint, TokenUsageMetricSet } from '@/shared/types';
+import type { UsageAggregate } from '@/server/lib/omp/session/usage/aggregate';
+
+const fmtInt = (value: number): string => value.toLocaleString('en-US');
+const fmtUsd = (value: number): string => `$${value.toFixed(2)}`;
+
+const MONTH_LABELS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] as const;
+
+function dayLabel(dayKey: string): string {
+  const date = new Date(`${dayKey}T00:00:00`);
+  return Number.isNaN(date.getTime()) ? dayKey : `${MONTH_LABELS[date.getMonth()]} ${date.getDate()}`;
+}
+
+function bucketKey(dayKey: string, cadence: CadenceType): string {
+  if (cadence === 'monthly') return dayKey.slice(0, 7);
+  if (cadence === 'weekly') {
+    const date = new Date(`${dayKey}T00:00:00`);
+    if (Number.isNaN(date.getTime())) return dayKey;
+    const monday = new Date(date);
+    const shift = (date.getDay() + 6) % 7;
+    monday.setDate(date.getDate() - shift);
+    return monday.toISOString().slice(0, 10);
+  }
+  return dayKey;
+}
+
+function labelForBucket(key: string, cadence: CadenceType): string {
+  if (cadence === 'monthly') {
+    const [year, month] = key.split('-');
+    const monthIndex = Number(month) - 1;
+    const label = MONTH_LABELS[monthIndex] ?? key;
+    return year && Number(year) !== new Date().getFullYear() ? `${label} ${year}` : label;
+  }
+  return dayLabel(key);
+}
+
+/** Shape the per-day aggregate into an ordered chart series for the cadence:
+ * weekly buckets align to Monday, monthly to YYYY-MM, and the series is
+ * truncated to the last 60 buckets so the SVG path stays readable. */
+export function buildChartSeries(a: UsageAggregate, cadence: CadenceType): ChartSeriesPoint[] {
+  const buckets = new Map<string, { cost: number; tokens: number }>();
+  for (const [dayKey, v] of a.byDay) {
+    const key = bucketKey(dayKey, cadence);
+    const current = buckets.get(key) ?? { cost: 0, tokens: 0 };
+    current.cost += v.cost;
+    current.tokens += v.tokens;
+    buckets.set(key, current);
+  }
+  return [...buckets.entries()]
+    .sort(([aKey], [bKey]) => (aKey < bKey ? -1 : aKey > bKey ? 1 : 0))
+    .slice(-60)
+    .map(([key, v]) => ({ label: labelForBucket(key, cadence), cost: v.cost, tokens: v.tokens }));
+}
+
+export function toMetricSet(a: UsageAggregate, cadence: CadenceType = 'daily'): TokenUsageMetricSet {
+  const observedInput = a.inputTokens + a.cacheReadTokens;
+  const cachedPercent = observedInput > 0 ? ((a.cacheReadTokens / observedInput) * 100).toFixed(1) : '0.0';
+  const unit = cadence === 'weekly' ? 'week' : cadence === 'monthly' ? 'month' : 'day';
+  return {
+    rawCost: fmtUsd(a.costTotal),
+    processedTokens: fmtInt(a.inputTokens + a.outputTokens + a.cacheReadTokens + a.cacheWriteTokens),
+    activeRate: `${a.activeDays.size} active ${unit}${a.activeDays.size === 1 ? '' : 's'}`,
+    cachedInput: fmtInt(a.cacheReadTokens),
+    cachedPercent: `${cachedPercent}% of observed input`,
+    uncachedInput: fmtInt(a.inputTokens),
+    outputTokens: fmtInt(a.outputTokens),
+    reasoning: `includes ${fmtInt(a.reasoningTokens)} reasoning`,
+    cacheSavings: fmtUsd(a.costCacheRead),
+    scannedTranscripts: a.scannedTranscripts,
+    usageRecords: a.usageRecords,
+  };
+}
+
+const BREAKDOWN_DOT_COLORS = [
+  'bg-[var(--theme-ink)]',
+  'bg-[var(--theme-ink)]/70',
+  'bg-[var(--theme-ink)]/50',
+  'bg-[var(--theme-ink)]/35',
+  'bg-[var(--theme-ink)]/20',
+] as const;
+
+/** Build breakdown rows (model/day/project) from the aggregate; the `day` tab
+ * is bucketed by the cadence (day/week/month) so it stays consistent with the chart. */
+export function toBreakdownRows(
+  a: UsageAggregate,
+  tab: 'model' | 'day' | 'project',
+  cadence: CadenceType = 'daily',
+): BreakdownRow[] {
+  if (tab === 'day' && cadence !== 'daily') {
+    const buckets = new Map<string, { tokens: number; cost: number }>();
+    for (const [dayKey, v] of a.byDay) {
+      const key = bucketKey(dayKey, cadence);
+      const current = buckets.get(key) ?? { tokens: 0, cost: 0 };
+      current.tokens += v.tokens;
+      current.cost += v.cost;
+      buckets.set(key, current);
+    }
+    const merged: UsageAggregate = { ...a, byDay: buckets };
+    return toBreakdownRows(merged, 'day', 'daily');
+  }
+  const source = tab === 'model' ? a.byModel : tab === 'day' ? a.byDay : a.byProject;
+  return [...source.entries()]
+    .map(([name, v]) => ({
+      name: tab === 'day' ? labelForBucket(name, cadence) : name,
+      tokens: v.tokens,
+      cost: v.cost,
+      sharePercent: a.costTotal > 0 ? Math.round((v.cost / a.costTotal) * 100) : 0,
+    }))
+    .sort((x, y) => y.cost - x.cost)
+    .slice(0, 12)
+    .map((row, index) => ({
+      name: row.name,
+      tokens: fmtInt(row.tokens),
+      cost: fmtUsd(row.cost),
+      share: `${row.sharePercent}%`,
+      sharePercent: row.sharePercent,
+      dotColorClass: BREAKDOWN_DOT_COLORS[index % BREAKDOWN_DOT_COLORS.length],
+    }));
+}