@krtclcdy/tersio 2.24.0 → 2.25.0

package/extensions/shared/usage-ledger.ts

@@ -1,9 +1,7 @@
-// Shared usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and
-// the Dashboard. Best-effort; corrupt lines are skipped on read.
+// Shared usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and the Dashboard. Best-effort; corrupt lines are skipped on read.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
-import { isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
+import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
 import { execFileSync } from 'node:child_process';
 
 export type UsageKind = 'command' | 'toggle' | 'install' | 'update' | 'rtk-audit';
@@ -52,8 +50,7 @@ export function appendUsage(kind: UsageKind, detail: string): void {
   } catch { /* ledger is best-effort; never break the caller */ }
 }
 
-// --- Session tokens, tokscale-style ------------------------------------------
-// Assistant messages in the host transcripts carry usage, model, and a timestamp.
+// --- Session tokens, tokscale-style ------------------------------------------ Assistant messages in the host transcripts carry usage, model, and a timestamp.
 export interface TokenBreakdown {
   input: number;
   output: number;
@@ -70,6 +67,8 @@ export interface RecentRequest {
   o: number;
   t: number;
   d?: number;
+  /** Which agent wrote the session: pi, omp, or codex. */
+  h?: string;
   cr?: number;
   cw?: number;
   // Undefined when the host recorded no cost; never backfilled.
@@ -77,6 +76,8 @@ export interface RecentRequest {
   st: RunStatus;
   code?: number;
   note?: string;
+  /** Message id when the host provides one (transcript row id, opencode msg file). */
+  id?: string;
 }
 
 export interface SessionTokens {
@@ -87,6 +88,7 @@ export interface SessionTokens {
   byDayModel: Record<string, Record<string, number>>;
   byTool: Record<string, number>;
   byModelMessages: Record<string, number>;
+  byHost: Record<string, Record<string, TokenBreakdown>>;
   costMeasured: number;
   recent: RecentRequest[];
 }
@@ -109,12 +111,15 @@ export interface RtkRecallDiagnostics {
 function zeroBreakdown(): TokenBreakdown {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
+function stampMs(ts: string | number | undefined): number {
+  return ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+}
+
 export function durOf(v: unknown): number | undefined {
   return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
 }
 
-// Measured cost: usage.cost.total, or a bare number in old fixtures. Anything
-// else means unrecorded, which is deliberately not 0.
+// Measured cost: usage.cost.total, or a bare number in old fixtures. Anything else means unrecorded, which is deliberately not 0.
 export function costOf(usage: Record<string, unknown>): number | undefined {
   const c = usage.cost;
   if (typeof c === 'number') return Number.isFinite(c) ? c : undefined;
@@ -125,8 +130,7 @@ export function costOf(usage: Record<string, unknown>): number | undefined {
   return undefined;
 }
 
-// First line only: real messages carry multi-line provider errors, and this
-// ends up in a tooltip.
+// First line only: real messages carry multi-line provider errors, and this ends up in a tooltip.
 export function statusOf(msg: { stopReason?: unknown; errorStatus?: unknown; errorMessage?: unknown; isError?: unknown }): { st: RunStatus; code?: number; note?: string } {
   const stop = typeof msg.stopReason === 'string' ? msg.stopReason : '';
   const note = typeof msg.errorMessage === 'string' && msg.errorMessage.trim()
@@ -147,22 +151,108 @@ function addInto(into: TokenBreakdown, u: { input?: unknown; output?: unknown; c
   }
 }
 
-export function sessionsDir(): string {
+export function sessionsDirs(): string[] {
   const override = process.env.TERSIO_SESSIONS_DIR;
-  if (override) return override;
-  // The running host wins; the other host's directory is the fallback.
+  if (override) return [override];
+  // Both hosts, not just the running one: a session on pi is missing from the dashboard entirely if we stop at the first directory that exists.
   const dirs = isPiProcess()
-    ? [path.join(piAgentDir(), 'sessions'), path.join(os.homedir(), '.omp', 'agent', 'sessions')]
-    : [path.join(os.homedir(), '.omp', 'agent', 'sessions'), path.join(piAgentDir(), 'sessions')];
-  return dirs.find((dir) => fs.existsSync(dir)) ?? dirs[0];
+    ? [path.join(piAgentDir(), 'sessions'), path.join(homeDir(), '.omp', 'agent', 'sessions')]
+    : [path.join(homeDir(), '.omp', 'agent', 'sessions'), path.join(piAgentDir(), 'sessions')];
+  const found = dirs.filter((dir) => fs.existsSync(dir));
+  return found.length > 0 ? found : [dirs[0]];
+}
+
+export function sessionsDir(): string {
+  return sessionsDirs()[0];
 }
 
-export function codexSessionsDir(): string {
-  const override = process.env.TERSIO_CODEX_DIR;
+// One JSON file per message; probe XDG, then local, then macOS default.
+export function opencodeSessionsDir(): string {
+  const override = process.env.TERSIO_OPENCODE_DIR;
   if (override) return override;
-  const codexHome = process.env.CODEX_HOME;
-  if (codexHome) return path.join(codexHome, 'sessions');
-  return path.join(os.homedir(), '.codex', 'sessions');
+  const xdg = process.env.XDG_DATA_HOME;
+  if (xdg && xdg.trim() !== '') return path.join(xdg, 'opencode', 'storage', 'message');
+  const local = path.join(homeDir(), '.local', 'share', 'opencode', 'storage', 'message');
+  try {
+    if (fs.existsSync(local)) return local;
+  } catch { /* fall through to the platform default */ }
+  return path.join(homeDir(), 'Library', 'Application Support', 'opencode', 'storage', 'message');
+}
+
+// OpenCode v2 keeps messages in sqlite; the JSON tree above is only the pre-v2 layout.
+export function opencodeDbPath(): string {
+  const override = process.env.TERSIO_OPENCODE_DB;
+  if (override) return override;
+  const xdg = process.env.XDG_DATA_HOME;
+  if (xdg && xdg.trim() !== '') return path.join(xdg, 'opencode', 'opencode.db');
+  const local = path.join(homeDir(), '.local', 'share', 'opencode', 'opencode.db');
+  try {
+    if (fs.existsSync(local)) return local;
+  } catch { /* fall through to the platform default */ }
+  return path.join(homeDir(), 'Library', 'Application Support', 'opencode', 'opencode.db');
+}
+
+export interface OpencodeDbRow {
+  id: string;
+  created: number;
+  row: OpencodeMessage;
+}
+
+// Two on-disk shapes: legacy `message` (role/modelID/providerID live inside `data`),
+// current `session_message` (role in the `type` column, model under data.model).
+// Scalars only: the `data` blob holds newlines and tabs, which the sqlite3 CLI would split.
+const OC_DB_ORDER = ' ORDER BY time_created;';
+const OC_DB_COLUMNS =
+  'json_extract(data,\'$.time.created\'), json_extract(data,\'$.time.completed\'),' +
+  ' json_extract(data,\'$.tokens.input\'), json_extract(data,\'$.tokens.output\'),' +
+  ' json_extract(data,\'$.tokens.cache.read\'), json_extract(data,\'$.tokens.cache.write\'), json_extract(data,\'$.cost\')';
+const ocDbLegacy = (since: number): string =>
+  `SELECT id, time_created, json_extract(data,'$.role'), json_extract(data,'$.providerID'), json_extract(data,'$.modelID'), ${OC_DB_COLUMNS}` +
+  ` FROM message WHERE json_extract(data,'$.role')='assistant' AND time_created > ${since}${OC_DB_ORDER}`;
+const ocDbCurrent = (since: number): string =>
+  `SELECT id, time_created, 'assistant', json_extract(data,'$.model.providerID'), json_extract(data,'$.model.id'), ${OC_DB_COLUMNS}` +
+  ` FROM session_message WHERE type='assistant' AND time_created > ${since}${OC_DB_ORDER}`;
+
+// A re-scan window covers tokens that land after the row was created, so a late fill is not lost.
+export const OPENCODE_DB_OVERLAP_MS = 3_600_000;
+
+// execFileSync caps output at 1MB; a busy table clears it in one SELECT.
+export const SQLITE_READ_BUFFER = 50 * 1024 * 1024;
+
+// Empty when sqlite3 is absent or the db is unreadable; that is a sync skip, not a failure.
+export function readOpencodeDbRows(db: string, sinceMs: number): OpencodeDbRow[] {
+  if (!Number.isFinite(sinceMs)) return [];
+  try {
+    if (!fs.existsSync(db)) return [];
+    const since = Math.max(0, Math.floor(sinceMs));
+    // Separate calls: a db holding only one table must not cancel the other.
+const run = (sql: string): string =>
+  execFileSync('sqlite3', ['-separator', '\t', '-readonly', db, sql], { encoding: 'utf8', timeout: 30000, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: SQLITE_READ_BUFFER });
+let out = '';
+try { out += run(ocDbLegacy(since)); } catch { /* no legacy table or unreadable */ }
+try { out += run(ocDbCurrent(since)); } catch { /* no session_message table or unreadable */ }
+    const rows: OpencodeDbRow[] = [];
+    for (const line of out.split('\n')) {
+      if (!line.trim()) continue;
+      const [id, created, role, providerID, modelID, tCreated, tCompleted, input, output, cacheRead, cacheWrite, cost] = line.split('\t');
+      const n = (v: string | undefined): unknown => (v !== undefined && v !== '' && Number.isFinite(Number(v)) ? Number(v) : undefined);
+      rows.push({
+        id,
+        created: Number(created),
+        row: {
+          role,
+          modelID,
+          providerID,
+          tokens: { input: n(input), output: n(output), cache: { read: n(cacheRead), write: n(cacheWrite) } },
+          time: { created: n(tCreated), completed: n(tCompleted) },
+          cost: n(cost),
+        },
+      });
+    }
+    return rows;
+  } catch {
+    return [];
+  }
 }
 
 export function dayKey(ts: string | number): string | null {
@@ -172,7 +262,7 @@ export function dayKey(ts: string | number): string | null {
   const p = (n: number): string => String(n).padStart(2, '0');
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
-export function walkJsonl(dir: string, out: string[], cap: number): void {
+export function walkJsonl(dir: string, out: string[], cap: number, ext = '.jsonl'): void {
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -182,36 +272,35 @@ export function walkJsonl(dir: string, out: string[], cap: number): void {
   for (const e of entries) {
     if (out.length >= cap) return;
     const full = path.join(dir, e.name);
-    if (e.isDirectory()) walkJsonl(full, out, cap);
-    else if (e.isFile() && e.name.endsWith('.jsonl')) out.push(full);
+    if (e.isDirectory()) walkJsonl(full, out, cap, ext);
+    else if (e.isFile() && e.name.endsWith(ext)) out.push(full);
   }
 }
-// Recent requests get their own full-width table, so this bounds payload
-// rather than highlights; rows are small, so a few hundred cost little.
-export const RECENT_LIMIT = 200;
+// Recent rows are a newest-first window over lifetime history; aggregates keep everything.
+export const RECENT_LIMIT = 2000;
 const FREE_SUFFIX = /(?::free|-free)$/i;
 const RTK_ELIGIBLE_HEADS = new Set([
   'rtk', 'git', 'grep', 'rg', 'find', 'cat', 'ls', 'tree', 'diff', 'log',
   'npm', 'npx', 'pnpm', 'bun', 'bunx', 'cargo', 'go', 'python', 'pytest',
   'ruff', 'mypy', 'docker', 'kubectl', 'psql', 'aws', 'gh', 'glab', 'wc',
 ]);
-// Parse buffer shared by live reads and usage.db syncs, so the store is a
-// cache and never a fork.
+// Parse buffer shared by live reads and usage.db syncs, so the store is a cache and never a fork.
 export interface SessionAccum {
   byModel: Record<string, TokenBreakdown>;
   byDay: Record<string, TokenBreakdown>;
   byDayModel: Record<string, Record<string, number>>;
   byTool: Record<string, number>;
   byModelMessages: Record<string, number>;
+  byHost: Record<string, Record<string, TokenBreakdown>>;
   totals: TokenBreakdown;
   messages: number;
   costMeasured: number;
   recent: RecentRequest[];
 }
 export function newSessionAccum(): SessionAccum {
-  return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
+  return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
 }
-export function ingestSessionRow(accum: SessionAccum, model: string, usage: Record<string, unknown>, ts: string | number | undefined, durMs?: unknown, run?: { st: RunStatus; code?: number; note?: string }, toolNames?: string[]): boolean {
+export function ingestSessionRow(accum: SessionAccum, model: string, usage: Record<string, unknown>, ts: string | number | undefined, durMs?: unknown, run?: { st: RunStatus; code?: number; note?: string }, toolNames?: string[], host?: string, id?: string): boolean {
   const watermark = readResetWatermark();
   const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
   if (watermark > 0 && (!Number.isFinite(ms) || ms < watermark)) return false;
@@ -220,10 +309,15 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
   accum.byModel[key] ??= zeroBreakdown();
   addInto(accum.byModel[key], usage);
   accum.byModelMessages[key] = (accum.byModelMessages[key] ?? 0) + 1;
+  if (host) {
+    const hs = (accum.byHost[key] ??= {});
+    hs[host] ??= zeroBreakdown();
+    addInto(hs[host], usage);
+  }
   const num = (v: unknown): number => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0);
   if (Number.isFinite(ms)) {
     const outcome = run ?? { st: 'completed' as RunStatus };
-    accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note });
+    accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), h: host, cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note, id });
   }
   const day = ts !== undefined ? dayKey(ts) : null;
   if (day) {
@@ -241,11 +335,15 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
   for (const name of toolNames ?? []) accum.byTool[name] = (accum.byTool[name] ?? 0) + 1;
   return true;
 }
-export type SessionLineKind = 'codex_provider' | 'token_row' | 'assistant_row' | 'skip';
-export function classifySessionLine(row: { timestamp?: string | number; type?: unknown; message?: { role?: unknown; model?: unknown; usage?: Record<string, unknown>; duration?: unknown; completedAt?: unknown; timestamp?: unknown; stopReason?: unknown; errorStatus?: unknown; errorMessage?: unknown; isError?: unknown; content?: Array<{ type?: unknown; name?: unknown; arguments?: unknown }> }; payload?: { type?: unknown; model_provider?: unknown; info?: { last_token_usage?: Record<string, unknown> } } }): { kind: SessionLineKind; provider?: string; model?: string; usage?: Record<string, unknown>; durMs?: number; run?: { st: RunStatus; code?: number; note?: string }; tools?: string[]; ms?: number } {
+export type SessionLineKind = 'codex_provider' | 'codex_model' | 'token_row' | 'assistant_row' | 'skip';
+export function classifySessionLine(row: { timestamp?: string | number; type?: unknown; message?: { role?: unknown; model?: unknown; usage?: Record<string, unknown>; duration?: unknown; completedAt?: unknown; timestamp?: unknown; stopReason?: unknown; errorStatus?: unknown; errorMessage?: unknown; isError?: unknown; content?: Array<{ type?: unknown; name?: unknown; arguments?: unknown }> }; payload?: { type?: unknown; model?: unknown; model_provider?: unknown; info?: { last_token_usage?: Record<string, unknown> } } }): { kind: SessionLineKind; provider?: string; model?: string; usage?: Record<string, unknown>; durMs?: number; run?: { st: RunStatus; code?: number; note?: string }; tools?: string[]; ms?: number } {
   const payload = row.payload;
   if (payload && typeof payload === 'object') {
     if (row.type === 'session_meta' && typeof payload.model_provider === 'string') return { kind: 'codex_provider', provider: payload.model_provider };
+    // A Codex transcript states the model once per turn, in turn_context.
+    if (row.type === 'turn_context' && typeof payload.model === 'string' && payload.model) {
+      return { kind: 'codex_model', model: payload.model };
+    }
     if (payload.type === 'token_count') {
       const last = payload.info?.last_token_usage;
       if (last) {
@@ -258,7 +356,10 @@ export function classifySessionLine(row: { timestamp?: string | number; type?: u
   const msg = row.message;
   if (!msg || msg.role !== 'assistant' || !msg.usage) return { kind: 'skip' };
   const model = typeof msg.model === 'string' && msg.model ? msg.model : 'unknown';
-  const computedDur = (typeof msg.completedAt === 'number' && typeof msg.timestamp === 'number') ? msg.completedAt - msg.timestamp : undefined;
+  // pi omits duration, so derive Elapsed/Speed from the timestamp pair.
+  const startMs = typeof msg.timestamp === 'number' ? msg.timestamp : undefined;
+  const endMs = typeof msg.completedAt === 'number' ? msg.completedAt : stampMs(row.timestamp);
+  const computedDur = startMs !== undefined && Number.isFinite(endMs) && endMs > startMs ? endMs - startMs : undefined;
   const tools: string[] = [];
   for (const part of msg.content ?? []) {
     if (part?.type !== 'toolCall' || typeof part.name !== 'string' || !part.name) continue;
@@ -271,17 +372,139 @@ export function classifySessionLine(row: { timestamp?: string | number; type?: u
   }
   return { kind: 'assistant_row', model, usage: msg.usage, durMs: typeof msg.duration === 'number' ? msg.duration : computedDur, run: statusOf(msg), tools };
 }
+// True when at least one token bucket holds a positive finite count.
+export function hasPositiveUsage(usage: Record<string, unknown>): boolean {
+  for (const k of ['input', 'output', 'cacheRead', 'cacheWrite']) {
+    const v = usage[k];
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0) return true;
+  }
+  return false;
+}
+
+export interface OpencodeMessage {
+  role?: unknown;
+  tokens?: { input?: unknown; output?: unknown; reasoning?: unknown; cache?: { read?: unknown; write?: unknown } } | null;
+  modelID?: unknown;
+  providerID?: unknown;
+  time?: { created?: unknown; completed?: unknown } | null;
+  cost?: unknown;
+  finish?: unknown;
+}
+
+// One OpenCode message file; assistant rows carry the token buckets.
+export function classifyOpencodeMessage(obj: OpencodeMessage | null | undefined): { model: string; usage: Record<string, unknown>; ms: number | undefined; durMs: number | undefined } | null {
+  if (!obj || typeof obj !== 'object' || obj.role !== 'assistant') return null;
+  const t = obj.tokens;
+  if (!t || typeof t !== 'object') return null;
+  const usage: Record<string, unknown> = {
+    input: t.input,
+    output: t.output,
+    cacheRead: t.cache?.read,
+    cacheWrite: t.cache?.write,
+    cost: (obj as Record<string, unknown>).cost,
+  };
+  if (!hasPositiveUsage(usage)) return null;
+  const provider = typeof obj.providerID === 'string' && obj.providerID ? obj.providerID : 'unknown';
+  const model = typeof obj.modelID === 'string' && obj.modelID ? obj.modelID : 'unknown';
+  const num = (v: unknown): number | undefined => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined);
+  const created = num(obj.time?.created);
+  const completed = num(obj.time?.completed);
+  return {
+    model: `opencode/${provider}/${model}`,
+    usage,
+    ms: created,
+    durMs: created !== undefined && completed !== undefined && completed > created ? completed - created : undefined,
+  };
+}
+
+// One OpenCode message file into the shared accum. The msg id is the file name.
+export function processOpencodeFile(accum: SessionAccum, text: string, file?: string): void {
+  let obj: unknown;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return;
+  }
+  const parsed = classifyOpencodeMessage(obj as OpencodeMessage);
+  if (!parsed) return;
+  const id = file ? path.basename(file).replace(/\.[^.]+$/, '') || undefined : undefined;
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, undefined, 'opencode', id);
+}
+
+// One v2 message row into the shared accum. The msg id is the row primary key.
+export function ingestOpencodeDbRow(accum: SessionAccum, row: OpencodeDbRow): void {
+  const parsed = classifyOpencodeMessage(row.row);
+  if (!parsed) return;
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, undefined, 'opencode', row.id);
+}
+
 // Fold `:free`/`-free` suffixes and case variants into one chart key.
 export function canonicalModelId(model: string): string {
   return canonicalPriceId(model.replace(FREE_SUFFIX, ''));
 }
-// LiteLLM-style display: lowercase namespace, title-cased model segments with
-// version dots kept.
+// Transcript row id when the host provides one; anything else is not an id.
+export function messageRowId(row: unknown): string | undefined {
+  const id = (row as { id?: unknown }).id;
+  return typeof id === 'string' && id ? id : undefined;
+}
+
+// Vendor names mirror the dashboard map; CLI needs names only. Family first:
+// gateway segments shadow it (minimaxai holds xai, gemma rides nvidia).
+const VENDOR_RES: Array<[RegExp, string]> = [
+  [/inclusionai|ling-/i, 'InclusionAI'],
+  [/minimax/i, 'MiniMax'],
+  [/grok|xai/i, 'xAI'],
+  [/stealth|space-bunny/i, 'Stealth'],
+  [/openai|codex|gpt-|o1/i, 'OpenAI'],
+  [/muse|llama/i, 'Meta'],
+  [/deepseek/i, 'DeepSeek'],
+  [/qwen|qwq/i, 'Alibaba'],
+  [/glm|z-ai|zhipu/i, 'Z.ai'],
+  [/mimo/i, 'Xiaomi'],
+  [/kimi|moonshot/i, 'Moonshot'],
+  [/mistral/i, 'Mistral'],
+  [/claude|anthropic/i, 'Anthropic'],
+  [/gemini|google|gemma/i, 'Google'],
+  [/nemotron|nvidia/i, 'NVIDIA'],
+  [/devin|cognition|^swe[-/]/i, 'Cognition'],
+];
+
+function modelVendor(model: string): string {
+  for (const [re, name] of VENDOR_RES) {
+    if (re.test(model)) return name;
+  }
+  return 'Other';
+}
+
+// Gateway variants of one model share a row under the display label.
+export function foldModelsByLabel(
+  byModel: Record<string, TokenBreakdown>,
+  byModelMessages: Record<string, number>,
+): { byModel: Record<string, TokenBreakdown>; byModelMessages: Record<string, number> } {
+  const folded: Record<string, TokenBreakdown> = {};
+  const messages: Record<string, number> = {};
+  for (const [model, t] of Object.entries(byModel)) {
+    const label = displayModelId(model);
+    folded[label] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    const into = folded[label];
+    into.input += t.input;
+    into.output += t.output;
+    into.cacheRead += t.cacheRead;
+    into.cacheWrite += t.cacheWrite;
+    messages[label] = (messages[label] ?? 0) + (byModelMessages[model] ?? 0);
+  }
+  return { byModel: folded, byModelMessages: messages };
+}
+// Vendor-first labels, same fold as the dashboard: "Anthropic - Claude - Haiku-4.5".
 export function displayModelId(model: string): string {
   const bare = model.replace(FREE_SUFFIX, '');
+  // The report already folds keys; folding again would lowercase the caps.
+  if (bare.includes(' - ')) return bare;
   const cap = (s: string): string => {
     const low = s.toLowerCase();
     if (low === 'openai') return 'OpenAI';
+    if (low === 'gpt') return 'GPT';
+    if (low === 'swe') return 'SWE';
     if (low === 'ai') return 'AI';
     if (/^\d+[a-z]+$/.test(low)) return low.toUpperCase();
     if (s.length <= 2) return s.toUpperCase();
@@ -289,21 +512,42 @@ export function displayModelId(model: string): string {
   };
   const seg = (s: string): string => s.split('.').map(cap).join('.');
   const words = (s: string): string => s.split(/[-_:]+/).filter(Boolean).map(seg).join('-');
-  const slash = bare.indexOf('/');
-  if (slash >= 0) return `${bare.slice(0, slash).toLowerCase()}/${words(bare.slice(slash + 1))}`;
-  return words(bare);
+  const segs = bare.split('/').filter(Boolean);
+  const tail = segs[segs.length - 1] ?? bare;
+  // One free model under two spellings; fold the alpha variant onto it.
+  const pretty = /^space-bunny(-alpha)?$/i.test(tail) ? 'Space-Bunny' : words(tail);
+  const vendor = modelVendor(bare);
+  if (vendor === 'Other') return segs.length > 1 ? `${words(segs[segs.length - 2])} - ${pretty}` : pretty;
+  const claude = pretty.match(/^claude[-_](.+)$/i);
+  if (vendor === 'Anthropic' && claude) return `Anthropic - Claude - ${claude[1]}`;
+  if (pretty.toLowerCase().startsWith(vendor.toLowerCase())) return pretty;
+  return `${vendor} - ${pretty}`;
 }
 
 export function importSessionTokens(): SessionTokens {
   const accum = newSessionAccum();
   const files: string[] = [];
-  walkJsonl(sessionsDir(), files, 2000);
-  // An override means an isolated environment (tests, fixtures): only walk the
-  // real codex dir when one is explicitly set.
-  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
-    walkJsonl(codexSessionsDir(), files, 2000);
+  for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
+  // OpenCode message bodies are single JSON documents, not JSONL.
+  const ocFiles: string[] = [];
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DIR !== undefined) {
+    walkJsonl(opencodeSessionsDir(), ocFiles, 5000, '.json');
+  }
+  for (const file of ocFiles) {
+    let text: string;
+    try {
+      text = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    processOpencodeFile(accum, text, file);
+  }
+  // v2 hosts write sqlite, not the JSON tree above.
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DB !== undefined) {
+    for (const row of readOpencodeDbRows(opencodeDbPath(), 0)) ingestOpencodeDbRow(accum, row);
   }
   let codexProvider: string | null = null;
+  let codexModel: string | null = null;
   for (const file of files) {
     let text: string;
     try {
@@ -311,10 +555,24 @@ export function importSessionTokens(): SessionTokens {
     } catch {
       continue;
     }
-    processSessionText(accum, { get codexProvider() { return codexProvider; }, set codexProvider(v: string | null) { codexProvider = v; } }, text);
+    processSessionText(accum, {
+      get codexProvider() { return codexProvider; },
+      set codexProvider(v: string | null) { codexProvider = v; },
+      get codexModel() { return codexModel; },
+      set codexModel(v: string | null) { codexModel = v; },
+    }, text, hostOfSessionFile(file));
   }
   accum.recent.sort((a, b) => b.t - a.t);
-  return { messages: accum.messages, totals: accum.totals, byModel: accum.byModel, byDay: accum.byDay, byDayModel: accum.byDayModel, byTool: accum.byTool, byModelMessages: accum.byModelMessages, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
+  return { messages: accum.messages, totals: accum.totals, byModel: accum.byModel, byDay: accum.byDay, byDayModel: accum.byDayModel, byTool: accum.byTool, byModelMessages: accum.byModelMessages, byHost: accum.byHost, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
+}
+
+// Which agent wrote a session file, from the directory it sits in.
+export function hostOfSessionFile(file: string): string {
+  const norm = file.replace(/\\/g, '/');
+  if (norm.includes('/.omp/')) return 'omp';
+  if (norm.includes('/.codex/')) return 'codex';
+  if (norm.includes('/opencode/')) return 'opencode';
+  return 'pi';
 }
 
 const adoptionFileCache = new Map<string, { size: number; mtimeMs: number; counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number } }>();
@@ -355,10 +613,7 @@ export function clearRtkAdoptionCache(): void {
 
 export function readRtkAdoption(): RtkAdoption {
   const files: string[] = [];
-  walkJsonl(sessionsDir(), files, 2000);
-  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
-    walkJsonl(codexSessionsDir(), files, 2000);
-  }
+  for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
   const live = new Set(files);
   for (const file of adoptionFileCache.keys()) {
     if (!live.has(file)) adoptionFileCache.delete(file);
@@ -390,23 +645,30 @@ export function readRtkAdoption(): RtkAdoption {
   const missedCalls = Math.max(0, eligibleCalls - rtkCalls);
   return { sessions, bashCalls, eligibleCalls, rtkCalls, missedCalls, adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0 };
 }
-export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null }, text: string): void {
+export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null; codexModel?: string | null }, text: string, host?: string): void {
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
       const row = JSON.parse(line) as Parameters<typeof classifySessionLine>[0];
       const parsed = classifySessionLine(row);
+      const rid = messageRowId(row);
       if (parsed.kind === 'codex_provider') {
         if (parsed.provider) state.codexProvider = parsed.provider;
         continue;
       }
+      if (parsed.kind === 'codex_model') {
+        if (parsed.model) state.codexModel = parsed.model;
+        continue;
+      }
       if (parsed.kind === 'token_row') {
-        const model = parsed.provider ? `codex/${parsed.provider}` : (state.codexProvider ? `codex/${state.codexProvider}` : 'codex');
-        ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, undefined, { st: 'completed' as RunStatus });
+        const base = parsed.provider ? `codex/${parsed.provider}` : (state.codexProvider ? `codex/${state.codexProvider}` : 'codex');
+        // The provider alone told you nothing about which model ran.
+        const model = state.codexModel ? `${base}/${state.codexModel}` : base;
+        ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, parsed.durMs, { st: 'completed' as RunStatus }, undefined, host ?? 'codex', rid);
         continue;
       }
       if (parsed.kind !== 'assistant_row' || !parsed.model || !parsed.usage) continue;
-      ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools);
+      ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools, host, rid);
     } catch { /* skip corrupt lines */ }
   }
 }
@@ -416,8 +678,8 @@ export function readRtkRecallDiagnostics(binary: string | null = resolveRtkBinar
   try {
     const configPath = process.env.RTK_CONFIG
       || (process.platform === 'darwin'
-        ? path.join(os.homedir(), 'Library', 'Application Support', 'rtk', 'config.toml')
-        : path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'rtk', 'config.toml'));
+        ? path.join(homeDir(), 'Library', 'Application Support', 'rtk', 'config.toml')
+        : path.join(process.env.XDG_DATA_HOME || path.join(homeDir(), '.local', 'share'), 'rtk', 'config.toml'));
     let config = '';
     try { config = fs.readFileSync(configPath, 'utf8'); } catch { /* use RTK CLI fallback */ }
     const modeMatch = /^\s*mode\s*=\s*"(sqlite|tee|disabled)"/m.exec(config);
@@ -429,8 +691,7 @@ export function readRtkRecallDiagnostics(binary: string | null = resolveRtkBinar
     return { mode: 'unknown', entries: 0, available: false };
   }
 }
-// Lead binary of a shell string: first segment past `cd` chains and VAR=x
-// assignments. Falls back to `bash`.
+// Lead binary of a shell string: first segment past `cd` chains and VAR=x assignments. Falls back to `bash`.
 const SKIP_HEADS = ['cd', 'echo', 'export', 'true', 'false'];
 export function leadBinary(command: unknown): string {
   if (typeof command !== 'string' || !command.trim()) return 'bash';
@@ -493,8 +754,7 @@ export function readUsage(): UsageRow[] {
   return rows;
 }
 
-// Delete the ledger file and return the rows cleared. Tersio-owned data only:
-// transcripts and the RTK database are never touched.
+// Delete the ledger file and return the rows cleared. Tersio-owned data only: transcripts and the RTK database are never touched.
 export function clearUsageLedger(): number {
   const rows = readUsage().length;
   try {