@krtclcdy/tersio 2.25.4 → 2.25.6

package/extensions/shared/sqlite.ts

@@ -0,0 +1,168 @@
+// One place that runs SQL against a database file.
+//
+// Bun and Node 22.5+ carry SQLite in process, so the `sqlite3` binary is a fallback rather than a
+// requirement: hosts without it kept silently reading nothing. Reads come back exactly as the sqlite3
+// CLI printed them -- rows on their own lines, cells joined by tabs, NULL an empty cell, one trailing
+// newline -- because every caller already parses that shape. The engine rungs take one statement per
+// read, so a caller with several queries calls once per query.
+//
+// The write path leaves the journal mode alone. The store's own schema sets WAL so a reader (the
+// dashboard) never blocks a writer, and changing the mode needs exclusive access: with a reader holding
+// the file the pragma fails, which is a failure reported after the caller's rows have already committed.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+
+/** A read this large used to vanish behind a 1MB cap, which cleared on one busy session_message table. */
+const SQLITE_READ_BUFFER = 50 * 1024 * 1024;
+
+const TIMEOUT = 30_000;
+const requireOptional = createRequire(import.meta.url);
+
+interface Engine {
+  kind: 'bun' | 'node';
+  read(db: string, sql: string): unknown[][];
+  exec(db: string, sql: string): void;
+}
+
+interface BunDatabase {
+  query(sql: string): { values(): unknown[][] };
+  exec(sql: string): void;
+  close(): void;
+}
+
+interface NodeStatement {
+  all(): unknown[][];
+  setReturnArrays?(on: boolean): unknown;
+}
+
+interface NodeDatabase {
+  prepare(sql: string): NodeStatement;
+  exec(sql: string): void;
+  close(): void;
+}
+
+let cached: Engine | null | undefined;
+let cachedFor: string | undefined;
+
+/** Bun's SQLite, or Node's when this build carries one. Null when neither runtime has an engine. */
+function engine(): Engine | null {
+  const asked = process.env.TERSIO_SQLITE ?? '';
+  if (cached !== undefined && cachedFor === asked) return cached;
+  cachedFor = asked;
+  cached = null;
+  if (asked === 'cli') return cached;
+  try {
+    const { Database } = requireOptional('bun:sqlite') as { Database: new (db: string, opts?: { readonly?: boolean }) => BunDatabase };
+    cached = {
+      kind: 'bun',
+      read: (db, sql) => { const d = new Database(db, { readonly: true }); try { return d.query(sql).values(); } finally { d.close(); } },
+      exec: (db, sql) => { const d = new Database(db); try { d.exec(sql); } finally { d.close(); } },
+    };
+    return cached;
+  } catch { /* not Bun, or no SQLite in this build */ }
+  try {
+    const { DatabaseSync } = requireOptional('node:sqlite') as { DatabaseSync: new (db: string, opts?: { readOnly?: boolean }) => NodeDatabase };
+    // Rows arrive keyed by column name unless the statement returns arrays. A duplicate name collapses
+    // its key and shifts every later cell, so a Node that cannot return arrays is no engine at all.
+    const probe = new DatabaseSync(':memory:');
+    try {
+      if (typeof probe.prepare('SELECT 1').setReturnArrays !== 'function') throw new Error('no positional rows');
+    } finally {
+      probe.close();
+    }
+    cached = {
+      kind: 'node',
+      read: (db, sql) => {
+        const d = new DatabaseSync(db, { readOnly: true });
+        try {
+          const st = d.prepare(sql);
+          st.setReturnArrays?.(true);
+          return st.all();
+        } finally { d.close(); }
+      },
+      exec: (db, sql) => { const d = new DatabaseSync(db); try { d.exec(sql); } finally { d.close(); } },
+    };
+    return cached;
+  } catch { /* Node older than 22.5, or one built without SQLite or positional rows */ }
+  return cached;
+}
+
+/** The `sqlite3` binary, resolved once from PATH so a missing one costs one scan, not one spawn per call. */
+let binary: string | null | undefined;
+function findBinary(): string | null {
+  if (binary !== undefined) return binary;
+  binary = null;
+  for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+    if (!dir) continue;
+    for (const name of process.platform === 'win32' ? ['sqlite3.exe', 'sqlite3'] : ['sqlite3']) {
+      const at = path.join(dir, name);
+      try {
+        fs.accessSync(at, fs.constants.X_OK);
+        binary = at;
+        return binary;
+      } catch { /* not here */ }
+    }
+  }
+  return binary;
+}
+
+/** `bun`, `node`, `cli`, or null when this host has no way to read SQLite at all. */
+export function sqliteEngine(): 'bun' | 'node' | 'cli' | null {
+  return engine()?.kind ?? (findBinary() === null ? null : 'cli');
+}
+
+/** Whether any path can run SQL: what the tests guard their skips on. */
+export function sqliteAvailable(): boolean {
+  return sqliteEngine() !== null;
+}
+
+/** Rows as the CLI prints them, so a caller cannot tell which engine answered. */
+function toTsv(rows: unknown[][]): string {
+  if (rows.length === 0) return '';
+  return `${rows.map((row) => row.map((cell) => (cell === null || cell === undefined ? '' : String(cell))).join('\t')).join('\n')}\n`;
+}
+
+function cliRead(db: string, sql: string): string {
+  const opts = { encoding: 'utf8' as const, timeout: TIMEOUT, stdio: ['pipe', 'pipe', 'ignore'] as ['pipe', 'pipe', 'ignore'], maxBuffer: SQLITE_READ_BUFFER, input: sql };
+  try {
+    return execFileSync('sqlite3', ['-separator', '\t', '-readonly', db], opts);
+  } catch { /* the side files may be gone; try the next rung */ }
+  if (!fs.existsSync(`${db}-wal`)) {
+    try {
+      return execFileSync('sqlite3', ['-separator', '\t', `file:${db}?immutable=1`], opts);
+    } catch { /* fall through to the copy */ }
+  }
+  // A live database cannot be read without its write-ahead log, so copy the set and read the copy.
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tersio-sqlite-'));
+  const target = path.join(dir, path.basename(db));
+  try {
+    fs.copyFileSync(db, target);
+    for (const suffix of ['-wal', '-shm']) {
+      if (fs.existsSync(`${db}${suffix}`)) fs.copyFileSync(`${db}${suffix}`, `${target}${suffix}`);
+    }
+    return execFileSync('sqlite3', ['-separator', '\t', '-readonly', target], opts);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** Run a read and return the tab-separated rows. Throws when the file is missing, as the callers expect. */
+export function sqliteRead(db: string, sql: string): string {
+  if (!fs.existsSync(db)) throw new Error(`missing database: ${db}`);
+  const e = engine();
+  if (e !== null) return toTsv(e.read(db, sql));
+  return cliRead(db, sql);
+}
+
+/** Run a script, creating the file if needed. Stops at the first error, so a failed INSERT leaves no DELETEs. */
+export function sqliteExec(db: string, sql: string): void {
+  const e = engine();
+  if (e !== null) {
+    e.exec(db, sql);
+    return;
+  }
+  execFileSync('sqlite3', ['-bail', db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: TIMEOUT });
+}

package/extensions/shared/status.ts

@@ -1,4 +1,4 @@
-// One status string every surface renders: host footer bar, CLI menu title, dashboard banner. Nothing else formats mode state.
+// One status string every surface renders: host footer, CLI title, dashboard banner. Nothing else formats mode state.
 import { getSharedComboState } from './session-state.ts';
 import type { ExtensionCtx, UiApi } from './types.ts';
 
@@ -7,19 +7,20 @@ export interface StatusState {
   caveman: string;
   rtk: string;
   ponytail: string;
+  pstack: string;
 }
 
-/** OFF collapses the three modes into one word; a preset or a mix names itself. */
+/** OFF collapses every mode into one word; a preset or a mix names itself. */
 export function formatStatus(state: StatusState): string {
-  const { level, caveman, rtk, ponytail } = state;
-  if (level === 'off' && caveman === 'off' && rtk === 'off' && ponytail === 'off') return '🧩 combo OFF';
+  const { level, caveman, rtk, ponytail, pstack } = state;
+  if (level === 'off' && caveman === 'off' && rtk === 'off' && ponytail === 'off' && pstack === 'off') return '🧩 combo OFF';
   const label = level === 'custom' ? 'CUSTOM' : level.toUpperCase();
-  return `🧩 combo ${label}: 🪨caveman=${caveman.toUpperCase()} ⚡rtk=${rtk.toUpperCase()} 🦥ponytail=${ponytail.toUpperCase()}`;
+  return `🧩 combo ${label}: 🪨caveman=${caveman.toUpperCase()} ⚡rtk=${rtk.toUpperCase()} 🦥ponytail=${ponytail.toUpperCase()} 🥔pstack=${pstack.toUpperCase()}`;
 }
 
-// The string upstream's skill tells the model to relay for `/caveman status`.
+// The string upstream's skill tells the model to relay for `/caveman status`; `off` is a mode, so it reads as one.
 export function formatCavemanStatus(mode: string): string {
-  return `Caveman mode: ${mode && mode !== 'off' ? mode : 'unknown'}`;
+  return `Caveman mode: ${mode || 'unknown'}`;
 }
 
 // Stale ctx access throws, so never let it abort a mode restore.
@@ -38,6 +39,7 @@ let lastText: string | undefined;
 let lastUi: UiApi | undefined;
 
 // Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
+// One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
 export function announceStatus(ctx: ExtensionCtx | undefined): void {
   const state = getSharedComboState();
   const text = formatStatus(state);
@@ -48,5 +50,4 @@ export function announceStatus(ctx: ExtensionCtx | undefined): void {
   lastText = text;
   lastUi = ui;
   ui.setStatus?.('tersio', text);
-  ui.setStatus?.('caveman', formatCavemanStatus(state.caveman));
 }

package/extensions/shared/types.ts

@@ -1,10 +1,11 @@
-// Shared OMP extension host types. Structural — the real `pi` object comes from the OMP runtime; these describe the surface this package touches.
+// Shared OMP extension host types. Structural — the real `pi` object comes from the OMP runtime.
 
 export interface ComboState {
   level: string;
   caveman: string;
   rtk: string;
   ponytail: string;
+  pstack: string;
 }
 
 export type ComboLevel = 'off' | 'medium' | 'balanced' | 'max' | 'custom';

package/extensions/shared/usage-ledger.ts

@@ -1,8 +1,9 @@
-// Shared usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and the Dashboard. Best-effort; corrupt lines are skipped on read.
+// Usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and the Dashboard. Corrupt lines are skipped.
 import fs from 'node:fs';
 import path from 'node:path';
-import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
 import { execFileSync } from 'node:child_process';
+import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from './utils.ts';
+import { sqliteRead } from './sqlite.ts';
 
 export type UsageKind = 'command' | 'toggle' | 'install' | 'update' | 'rtk-audit';
 
@@ -50,7 +51,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;
@@ -67,6 +68,8 @@ export interface RecentRequest {
   o: number;
   t: number;
   d?: number;
+  /** First-token latency, when the host recorded one. */
+  tf?: number;
   /** Which agent wrote the session: pi, omp, or codex. */
   h?: string;
   cr?: number;
@@ -89,6 +92,14 @@ export interface SessionTokens {
   byTool: Record<string, number>;
   byModelMessages: Record<string, number>;
   byHost: Record<string, Record<string, TokenBreakdown>>;
+  /** Model -> agent kind (`main`, `subagent`), so a subagent's work reads apart from its root's. */
+  byAgent: Record<string, Record<string, TokenBreakdown>>;
+  /** Model -> agent kind -> message count, so a share can read requests beside the tokens. */
+  byAgentMessages: Record<string, Record<string, number>>;
+  /** Model -> cost the host reported, over the messages that carried one. */
+  byModelMeasured: Record<string, number>;
+  /** Model -> messages that carried a cost. Compare to `byModelMessages` before trusting the sum. */
+  byModelCostMessages: Record<string, number>;
   costMeasured: number;
   recent: RecentRequest[];
 }
@@ -119,7 +130,7 @@ 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, 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;
@@ -154,7 +165,7 @@ function addInto(into: TokenBreakdown, u: { input?: unknown; output?: unknown; c
 export function sessionsDirs(): string[] {
   const override = process.env.TERSIO_SESSIONS_DIR;
   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.
+  // Both hosts, not just the running one: a pi session is missing if we stop at the first existing directory.
   const dirs = isPiProcess()
     ? [path.join(piAgentDir(), 'sessions'), path.join(homeDir(), '.omp', 'agent', 'sessions')]
     : [path.join(homeDir(), '.omp', 'agent', 'sessions'), path.join(piAgentDir(), 'sessions')];
@@ -196,55 +207,55 @@ export interface OpencodeDbRow {
   id: string;
   created: number;
   row: OpencodeMessage;
+  /** Tool names this message called, comma-joined. Empty when it called none. */
+  tools?: string;
 }
 
-// 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.
+// `message` vs `session_message`: read scalars only, since the blob's newlines break the row-per-line output.
 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,\'$.time.created\'), json_extract(data,\'$.time.streamed\'), 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 OC_DB_TOOLS =
+  '(SELECT group_concat(json_extract(j.value,\'$.name\')) FROM json_each(data,\'$.content\') j' +
+  ' WHERE json_extract(j.value,\'$.type\')=\'tool\')';
 const ocDbLegacy = (since: number): string =>
-  `SELECT id, time_created, json_extract(data,'$.role'), json_extract(data,'$.providerID'), json_extract(data,'$.modelID'), ${OC_DB_COLUMNS}` +
+  `SELECT id, time_created, json_extract(data,'$.role'), json_extract(data,'$.providerID'), json_extract(data,'$.modelID'), ${OC_DB_COLUMNS}, ${OC_DB_TOOLS}` +
   ` 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}` +
+  `SELECT id, time_created, 'assistant', json_extract(data,'$.model.providerID'), json_extract(data,'$.model.id'), ${OC_DB_COLUMNS}, ${OC_DB_TOOLS}` +
   ` 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.
+// Empty when no SQLite is available 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 });
+    const run = (sql: string): string => sqliteRead(db, sql);
 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 [id, created, role, providerID, modelID, tCreated, tStreamed, tCompleted, input, output, cacheRead, cacheWrite, cost, tools] = 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),
+        tools: tools ?? '',
         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) },
+          time: { created: n(tCreated), streamed: n(tStreamed), completed: n(tCompleted) },
           cost: n(cost),
         },
       });
@@ -292,15 +303,25 @@ export interface SessionAccum {
   byTool: Record<string, number>;
   byModelMessages: Record<string, number>;
   byHost: Record<string, Record<string, TokenBreakdown>>;
+  /** Model -> agent kind (`main`, `subagent`), so a subagent's work reads apart from its root's. */
+  byAgent: Record<string, Record<string, TokenBreakdown>>;
+  /** Model -> agent kind -> message count. */
+  byAgentMessages: Record<string, Record<string, number>>;
+  /** Model -> cost the host itself reported, summed over the messages that carried one. */
+  byModelMeasured: Record<string, number>;
+  /** Model -> messages that carried a cost. Compare to `byModelMessages` before trusting the sum. */
+  byModelCostMessages: Record<string, number>;
   totals: TokenBreakdown;
   messages: number;
   costMeasured: number;
   recent: RecentRequest[];
+  /** Oldest timestamp held in `recent`, so the list stays bounded instead of growing with the store. */
+  recentFloor: number;
 }
 export function newSessionAccum(): SessionAccum {
-  return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
+  return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, byAgent: {}, byAgentMessages: {}, byModelMeasured: {}, byModelCostMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [], recentFloor: Number.POSITIVE_INFINITY };
 }
-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 {
+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, agent?: string, ttftMs?: unknown): 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;
@@ -314,10 +335,28 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
     hs[host] ??= zeroBreakdown();
     addInto(hs[host], usage);
   }
+  if (agent) {
+    const as = (accum.byAgent[key] ??= {});
+    as[agent] ??= zeroBreakdown();
+    addInto(as[agent], usage);
+    const am = (accum.byAgentMessages[key] ??= {});
+    am[agent] = (am[agent] ?? 0) + 1;
+  }
   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), h: host, cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note, id });
+    // Only the newest rows are read: skip below the floor, and a 50k-row store costs 2000 rows of memory.
+    if (accum.recent.length < RECENT_LIMIT || ms >= accum.recentFloor) {
+      accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), tf: durOf(ttftMs), h: host, cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note, id });
+      if (accum.recent.length > RECENT_LIMIT) {
+        let drop = 0;
+        for (let k = 1; k < accum.recent.length; k += 1) if (accum.recent[k].t < accum.recent[drop].t) drop = k;
+        accum.recent.splice(drop, 1);
+        accum.recentFloor = accum.recent.reduce((lo, r) => Math.min(lo, r.t), Number.POSITIVE_INFINITY);
+      } else if (ms < accum.recentFloor) {
+        accum.recentFloor = ms;
+      }
+    }
   }
   const day = ts !== undefined ? dayKey(ts) : null;
   if (day) {
@@ -331,12 +370,16 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
   }
   accum.messages += 1;
   const measured = costOf(usage);
-  if (measured !== undefined) accum.costMeasured += measured;
+  if (measured !== undefined) {
+    accum.costMeasured += measured;
+    accum.byModelMeasured[key] = (accum.byModelMeasured[key] ?? 0) + measured;
+    accum.byModelCostMessages[key] = (accum.byModelCostMessages[key] ?? 0) + 1;
+  }
   for (const name of toolNames ?? []) accum.byTool[name] = (accum.byTool[name] ?? 0) + 1;
   return true;
 }
 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 } {
+export function classifySessionLine(row: { timestamp?: string | number; type?: unknown; message?: { role?: unknown; model?: unknown; usage?: Record<string, unknown>; duration?: unknown; ttft?: 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; ttftMs?: 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 };
@@ -370,7 +413,7 @@ export function classifySessionLine(row: { timestamp?: string | number; type?: u
     const command = (part.arguments as { command?: unknown } | null)?.command;
     tools.push(`bash:${leadBinary(command)}`);
   }
-  return { kind: 'assistant_row', model, usage: msg.usage, durMs: typeof msg.duration === 'number' ? msg.duration : computedDur, run: statusOf(msg), tools };
+  return { kind: 'assistant_row', model, usage: msg.usage, durMs: typeof msg.duration === 'number' ? msg.duration : computedDur, ttftMs: typeof msg.ttft === 'number' ? msg.ttft : undefined, run: statusOf(msg), tools };
 }
 // True when at least one token bucket holds a positive finite count.
 export function hasPositiveUsage(usage: Record<string, unknown>): boolean {
@@ -386,13 +429,30 @@ export interface OpencodeMessage {
   tokens?: { input?: unknown; output?: unknown; reasoning?: unknown; cache?: { read?: unknown; write?: unknown } } | null;
   modelID?: unknown;
   providerID?: unknown;
-  time?: { created?: unknown; completed?: unknown } | null;
+  time?: { created?: unknown; streamed?: unknown; completed?: unknown } | null;
   cost?: unknown;
   finish?: unknown;
+  /** The message's parts. Tool calls sit here, named under a part of type `tool`. */
+  content?: unknown;
+}
+
+/** Tool names an OpenCode message called; v2 passes SQL's comma-joined string as the blob holds newlines. */
+export function opencodeToolNames(message: OpencodeMessage, joined?: string): string[] {
+  if (joined !== undefined) return joined === '' ? [] : joined.split(',');
+  const parts = message?.content;
+  if (!Array.isArray(parts)) return [];
+  const names: string[] = [];
+  for (const part of parts) {
+    if (!part || typeof part !== 'object') continue;
+    if ((part as Record<string, unknown>).type !== 'tool') continue;
+    const name = (part as Record<string, unknown>).name;
+    if (typeof name === 'string' && name) names.push(name);
+  }
+  return names;
 }
 
 // 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 {
+export function classifyOpencodeMessage(obj: OpencodeMessage | null | undefined): { model: string; usage: Record<string, unknown>; ms: number | undefined; durMs: number | undefined; ttftMs: number | undefined } | null {
   if (!obj || typeof obj !== 'object' || obj.role !== 'assistant') return null;
   const t = obj.tokens;
   if (!t || typeof t !== 'object') return null;
@@ -409,15 +469,17 @@ export function classifyOpencodeMessage(obj: OpencodeMessage | null | undefined)
   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);
+  // `streamed` is when the first token arrived, so it is the host's own first-token latency.
+  const streamed = num(obj.time?.streamed);
   return {
     model: `opencode/${provider}/${model}`,
     usage,
     ms: created,
     durMs: created !== undefined && completed !== undefined && completed > created ? completed - created : undefined,
+    ttftMs: created !== undefined && streamed !== undefined && streamed > created ? streamed - 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 {
@@ -425,17 +487,18 @@ export function processOpencodeFile(accum: SessionAccum, text: string, file?: st
   } catch {
     return;
   }
-  const parsed = classifyOpencodeMessage(obj as OpencodeMessage);
+  const message = obj as OpencodeMessage;
+  const parsed = classifyOpencodeMessage(message);
   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);
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, opencodeToolNames(message), 'opencode', id, 'main', parsed.ttftMs);
 }
 
 // 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);
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, opencodeToolNames(row.row, row.tools), 'opencode', row.id, 'main', parsed.ttftMs);
 }
 
 // Fold `:free`/`-free` suffixes and case variants into one chart key.
@@ -448,8 +511,7 @@ export function messageRowId(row: unknown): string | undefined {
   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).
+// Vendor names mirror the dashboard map; family first, so gateway segments shadow it (minimaxai holds xai).
 const VENDOR_RES: Array<[RegExp, string]> = [
   [/inclusionai|ling-/i, 'InclusionAI'],
   [/minimax/i, 'MiniMax'],
@@ -560,10 +622,10 @@ export function importSessionTokens(): SessionTokens {
       set codexProvider(v: string | null) { codexProvider = v; },
       get codexModel() { return codexModel; },
       set codexModel(v: string | null) { codexModel = v; },
-    }, text, hostOfSessionFile(file));
+    }, text, hostOfSessionFile(file), agentOfSessionText(text));
   }
   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, byHost: accum.byHost, 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, byAgent: accum.byAgent, byAgentMessages: accum.byAgentMessages, byModelMeasured: accum.byModelMeasured, byModelCostMessages: accum.byModelCostMessages, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
 }
 
 // Which agent wrote a session file, from the directory it sits in.
@@ -575,6 +637,19 @@ export function hostOfSessionFile(file: string): string {
   return 'pi';
 }
 
+// A transcript with a parent session ran as a subagent; the host's own row, so a mirror answers the same.
+export function agentOfSessionText(text: string): string {
+  if (!text.includes('parentSession')) return 'main';
+  for (const line of text.split('\n')) {
+    if (!line.includes('parentSession')) continue;
+    try {
+      const row = JSON.parse(line) as { type?: unknown; parentSession?: unknown };
+      if (row.type === 'session' && typeof row.parentSession === 'string' && row.parentSession !== '') return 'subagent';
+    } catch { /* skip a corrupt line */ }
+  }
+  return 'main';
+}
+
 const adoptionFileCache = new Map<string, { size: number; mtimeMs: number; counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number } }>();
 
 function parseAdoptionFile(file: string): { counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number }; sessions: number } {
@@ -645,7 +720,7 @@ 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; codexModel?: string | null }, text: string, host?: string): void {
+export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null; codexModel?: string | null }, text: string, host?: string, agent?: string): void {
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
@@ -664,11 +739,11 @@ export function processSessionText(accum: SessionAccum, state: { codexProvider:
         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);
+        ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, parsed.durMs, { st: 'completed' as RunStatus }, undefined, host ?? 'codex', rid, agent);
         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, host, rid);
+      ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools, host, rid, agent, parsed.ttftMs);
     } catch { /* skip corrupt lines */ }
   }
 }
@@ -705,18 +780,29 @@ export function leadBinary(command: unknown): string {
   return 'bash';
 }
 
-// --- Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table) ---
-import { DEFAULT_PRICE, canonicalPriceId, priceFor, refreshPricesIfStale } from './pricing.ts';
+// Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table).
+import { DEFAULT_PRICE, PRICE_TIERS_FIRM, canonicalPriceId, priceFor, pricesOverridePath, refreshPricesIfStale, type PriceHit, type PriceTier } from './pricing.ts';
 import { co2GramsFor, energyWhFor } from './carbon.ts';
 import type { ModelPrice } from './pricing.ts';
 
-export { DEFAULT_PRICE, priceFor, refreshPricesIfStale };
+export { DEFAULT_PRICE, PRICE_TIERS_FIRM, priceFor, pricesOverridePath, refreshPricesIfStale };
 export { co2GramsFor, energyWhFor };
-export type { ModelPrice };
+export type { PriceHit, PriceTier, ModelPrice };
 
-export function usdCost(t: TokenBreakdown, model?: string): { usd: number; priced: boolean; buckets: { input: number; output: number; cacheRead: number; cacheWrite: number } } {
-  const { price, known } = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false };
+/** Price one model's tokens; `measured` outranks every rate card, so pass undefined when unreported. */
+export function usdCost(t: TokenBreakdown, model?: string, measured?: number): { usd: number; priced: boolean; tier: PriceTier; buckets: { input: number; output: number; cacheRead: number; cacheWrite: number } } {
   const m = 1 / 1_000_000;
+  if (measured !== undefined) {
+    // Only a bare total arrives, so it attributes to input, the largest bucket for every model here.
+    return {
+      usd: measured,
+      priced: true,
+      tier: 'measured',
+      buckets: { input: measured, output: 0, cacheRead: 0, cacheWrite: 0 },
+    };
+  }
+  const hit: PriceHit = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false, live: false, tier: 'default' };
+  const price = hit.price;
   const buckets = {
     input: t.input * price.input * m,
     output: t.output * price.output * m,
@@ -725,7 +811,9 @@ export function usdCost(t: TokenBreakdown, model?: string): { usd: number; price
   };
   return {
     usd: buckets.input + buckets.output + buckets.cacheRead + buckets.cacheWrite,
-    priced: model ? known : false,
+    // `tail`/`default` are estimates; summing them beside measured cost reads as a bill it is not.
+    priced: PRICE_TIERS_FIRM.includes(hit.tier),
+    tier: hit.tier,
     buckets,
   };
 }
@@ -754,7 +842,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 stay.
 export function clearUsageLedger(): number {
   const rows = readUsage().length;
   try {