@krtclcdy/tersio 2.25.4 → 2.25.6

package/extensions/shared/usage-store.ts

@@ -1,33 +1,32 @@
-// extensions/shared/usage-store.ts — tersio-owned usage.db. A cache of the live parse, never a fork; missing sqlite3 → sync false / read null.
-import { execFileSync } from 'node:child_process';
+// usage-store.ts — tersio-owned usage.db. A cache of the live parse, not a fork; no SQLite → sync false / read null.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { sqliteExec, sqliteRead } from './sqlite.ts';
 import {
   RECENT_LIMIT,
-  SQLITE_READ_BUFFER,
   canonicalModelId,
   classifySessionLine,
-  OpencodeMessage,
   classifyOpencodeMessage,
   costOf,
   durOf,
+  agentOfSessionText,
   hostOfSessionFile,
   ingestSessionRow,
   messageRowId,
-  OpencodeDbRow,
   OPENCODE_DB_OVERLAP_MS,
   opencodeDbPath,
   opencodeSessionsDir,
   newSessionAccum,
+  opencodeToolNames,
   readOpencodeDbRows,
   sessionsDirs,
   walkJsonl,
 } from './usage-ledger.ts';
-import { tersioDataPath } from '../lib/utils.ts';
+import { tersioDataPath } from './utils.ts';
 import { MODEL_ALIASES } from './pricing.ts';
 import { tersioSettingsFile } from './plugin-settings.ts';
-import type { RunStatus, SessionTokens } from './usage-ledger.ts';
+import type { OpencodeDbRow, OpencodeMessage, RunStatus, SessionTokens } from './usage-ledger.ts';
 
 export function usageDbPath(): string {
   const override = process.env.TERSIO_USAGE_DB;
@@ -56,28 +55,25 @@ function nullStr(v: string | undefined): string {
   return v === undefined ? 'NULL' : esc(v);
 }
 
+// A failed INSERT stops before COMMIT, so it leaves no DELETEs behind.
 function run(db: string, sql: string): void {
-  // -bail stops the script before COMMIT, so a failed INSERT never leaves DELETEs behind.
-  execFileSync('sqlite3', ['-bail', db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: 30000 });
+  sqliteExec(db, sql);
 }
 
 function query(db: string, sql: string): string[][] {
-  const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
-    encoding: 'utf8',
-    timeout: 30000,
-    stdio: ['ignore', 'pipe', 'ignore'],
-    maxBuffer: SQLITE_READ_BUFFER,
-  });
-  return out
+  return sqliteRead(db, sql)
     .split('\n')
     .filter((line) => line.trim())
     .map((line) => line.split('\t'));
 }
 
 // Bump on a parse change: unchanged transcripts are never re-read.
-const PARSER_VERSION = '11';
+const PARSER_VERSION = '13';
 
-// A re-parse that keeps less than half the rows means transcripts vanished mid-migration; the backup is restored instead of publishing the loss.
+/** OpenCode rows gained tool names; re-read by id, since a PARSER_VERSION bump drops rotated history. */
+const OPENCODE_TOOLS_VERSION = '1';
+
+// A re-parse keeping under half the rows means transcripts vanished mid-migration; the backup is restored instead.
 const REPARSE_GUARD_RATIO = 0.5;
 
 let guardReport: string | null = null;
@@ -91,9 +87,24 @@ const SCHEMA_SQL =
   `CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);` +
   `CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT UNIQUE NOT NULL, mtime REAL NOT NULL, size INTEGER NOT NULL);` +
   `CREATE TABLE IF NOT EXISTS messages (file_id INTEGER NOT NULL REFERENCES files(id), t REAL, model TEXT NOT NULL,` +
-  ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
-  ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, id TEXT);` +
-  `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file_id);`;
+  ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, tf REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
+  ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, a TEXT, id TEXT);` +
+  // Every read filters or orders by one of these three; without them each sync and read scans the table.
+  `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file_id);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_t ON messages(t);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_h_t ON messages(h, t);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_model ON messages(model);`;
+
+/** WAL + a checkpoint: the write path avoids an fsync per commit, and usage.db alone holds every row. */
+function pragmas(db: string): void {
+  run(db,
+    'PRAGMA journal_mode=WAL;' +
+    'PRAGMA synchronous=NORMAL;' +
+    'PRAGMA wal_autocheckpoint=256;' +
+    'PRAGMA cache_size=-8000;' +
+    'PRAGMA temp_store=MEMORY;' +
+    'PRAGMA mmap_size=268435456;');
+}
 
 function storedParserVersion(db: string): string | null {
   try {
@@ -104,6 +115,14 @@ function storedParserVersion(db: string): string | null {
   }
 }
 
+// A store written by a newer tersio: no forward migration, so a re-parse would swap rotated history for what is left.
+function isDowngrade(stored: string | null): boolean {
+  if (stored === null) return false;
+  const storedNum = Number(stored);
+  const currentNum = Number(PARSER_VERSION);
+  return Number.isFinite(storedNum) && Number.isFinite(currentNum) && storedNum > currentNum;
+}
+
 function countMessages(db: string): number {
   try {
     const rows = query(db, `SELECT COUNT(*) FROM messages;`);
@@ -124,6 +143,16 @@ function newestOpencodeMs(db: string): number | null {
   }
 }
 
+/** Whether the OpenCode tools backfill ran; unfilled rows stay empty, so this widens the scan once. */
+function opencodeToolsBackfilled(db: string): boolean {
+  try {
+    const rows = query(db, `SELECT v FROM meta WHERE k='opencode_tools';`);
+    return rows.length > 0 && rows[0][0] === OPENCODE_TOOLS_VERSION;
+  } catch {
+    return false;
+  }
+}
+
 // Same pre-migration state as the newest backup: another copy churns the 3-slot rotation for nothing.
 function newestBackupMatches(stored: string | null): boolean {
   if (stored === null) return false;
@@ -137,7 +166,7 @@ function newestBackupMatches(stored: string | null): boolean {
   }
 }
 
-// v9 shape (path-keyed rows) migrates in place with zero re-parse, so history survives even when transcripts are gone.
+// v9 shape (path-keyed rows) migrates in place with zero re-parse, so history survives even without transcripts.
 function canMigrateInPlace(db: string): boolean {
   try {
     const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
@@ -155,8 +184,8 @@ function migrateInPlace(db: string, preCount: number): boolean {
       `CREATE TABLE files_new (id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT UNIQUE NOT NULL, mtime REAL NOT NULL, size INTEGER NOT NULL);` +
       `INSERT INTO files_new (path, mtime, size) SELECT path, mtime, size FROM files;` +
       `CREATE TABLE messages_new (file_id INTEGER NOT NULL REFERENCES files_new(id), t REAL, model TEXT NOT NULL,` +
-      ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
-      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, id TEXT);` +
+      ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, tf REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
+      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, a TEXT, id TEXT);` +
       `INSERT INTO messages_new (file_id, ${cols}) SELECT (SELECT id FROM files_new WHERE files_new.path = messages.file), ${cols} FROM messages;` +
       `DROP TABLE messages;DROP TABLE files;` +
       `ALTER TABLE files_new RENAME TO files;ALTER TABLE messages_new RENAME TO messages;` +
@@ -173,6 +202,64 @@ function migrateInPlace(db: string, preCount: number): boolean {
   }
 }
 
+// v12 adds the agent kind with a bare ALTER; existing rows read NULL and report under the main agent.
+function canAddAgent(db: string): boolean {
+  try {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file_id') && !names.includes('a');
+  } catch {
+    return false;
+  }
+}
+
+function addAgentColumn(db: string): boolean {
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN a TEXT;`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+// v13 shape gains the first-token latency with a bare ALTER, so no row moves and no wipe runs.
+function canAddTtft(db: string): boolean {
+  try {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file_id') && !names.includes('tf');
+  } catch {
+    return false;
+  }
+}
+
+// The column is additive, and a rotated transcript cannot be re-parsed, so the ALTER precedes the backfill.
+function addTtftColumn(db: string): boolean {
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN tf REAL;`);
+  } catch {
+    return false;
+  }
+  return !canAddTtft(db);
+}
+
+/** First-token-latency marker; unchanged transcripts are never revisited, so old stores stay null. */
+const TTFT_VERSION = '1';
+
+function ttftBackfilled(db: string): boolean {
+  try {
+    const rows = query(db, `SELECT v FROM meta WHERE k='ttft_backfill';`);
+    return rows.length > 0 && rows[0][0] === TTFT_VERSION;
+  } catch {
+    return false;
+  }
+}
+
+/** Clears ledger mtimes so every transcript re-reads; synthetic `db#row-id` OpenCode keys stay untouched. */
+function markTranscriptsDirty(db: string): void {
+  try {
+    run(db, `UPDATE files SET mtime = 0 WHERE path NOT LIKE '%#%';`);
+  } catch { /* a store with no files table yet, or a read-only file: nothing to backfill */ }
+}
+
 // v10 shape gains the message id with a bare ALTER: no rows move, so no re-parse and no guard trip.
 function canAlterInPlace(db: string): boolean {
   try {
@@ -192,15 +279,21 @@ function alterInPlace(db: string): boolean {
   return !canAlterInPlace(db);
 }
 
-function ensureSchema(db: string): void {
+function ensureSchema(db: string, forceWipe: boolean): void {
   fs.mkdirSync(path.dirname(db), { recursive: true });
   // Fold in rows stored under a pre-alias spelling; the mtime ledger will not re-read those transcripts.
   const rekeys = MODEL_ALIASES.map((a) => `UPDATE messages SET model='${a.id}' WHERE model='${a.feed}';`).join('');
   const stored = storedParserVersion(db);
+  pragmas(db);
   if (stored === PARSER_VERSION) {
     run(db, SCHEMA_SQL + rekeys);
     return;
   }
+  // A newer store keeps its rows: only an explicit force re-parse may wipe it.
+  if (!forceWipe && isDowngrade(stored)) {
+    run(db, SCHEMA_SQL + rekeys);
+    return;
+  }
   // A version bump rebuilds both tables, so no ALTER patchwork survives a migration.
   try {
     if (countMessages(db) > 0 && !newestBackupMatches(stored)) backupUsageDb(db);
@@ -213,6 +306,16 @@ function ensureSchema(db: string): void {
       run(db, `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
       return;
     }
+    // The agent column is additive: every row survives and unchanged transcripts read NULL until a re-parse.
+    if (stored !== null && canAddAgent(db) && addAgentColumn(db)) {
+      run(db, `INSERT OR REPLACE INTO meta (k, v) VALUES ('parser_version','${PARSER_VERSION}');`);
+      return;
+    }
+    // The ttft column is additive too; its values come from the backfill in `syncUsageDb`.
+    if (stored !== null && canAddTtft(db) && addTtftColumn(db)) {
+      run(db, `INSERT OR REPLACE INTO meta (k, v) VALUES ('parser_version','${PARSER_VERSION}');`);
+      return;
+    }
     run(db, `DROP TABLE IF EXISTS messages;DROP TABLE IF EXISTS files;` + SCHEMA_SQL +
       `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
   } catch { /* fresh db, nothing to invalidate */ }
@@ -320,13 +423,15 @@ function readFiles(db: string): Record<string, { mtime: number; size: number }>
   return known;
 }
 
-// One parsed assistant message, as stored. `t` is null when the source row has no usable timestamp: counted, but skipped in the recent list.
+// One parsed assistant message. `t` is null with no usable timestamp: still counted, but skipped in the recent list.
 interface StoredRow {
   t: number | null;
   model: string;
   i: number;
   o: number;
   d: number | undefined;
+  /** First-token latency in ms. Only omp records it; the rest read null rather than a guess. */
+  tf: number | undefined;
   cr: number;
   cw: number;
   usd: number | undefined;
@@ -335,38 +440,50 @@ interface StoredRow {
   note: string | undefined;
   tools: string[];
   host?: string;
+  /** `main` or `subagent`; null on a row written before the store carried it. */
+  agent?: string | null;
   id?: string;
 }
 
-// OpenCode rows carry no status, code, note, or tool list; only tokens and the msg id.
-function opencodeStoredRow(oc: NonNullable<ReturnType<typeof classifyOpencodeMessage>>, host: string | undefined, id: string | undefined): StoredRow {
+// OpenCode rows carry only tokens, msg id, and tools; they record as the main agent, so no NULL kind.
+function opencodeStoredRow(
+  oc: NonNullable<ReturnType<typeof classifyOpencodeMessage>>,
+  host: string | undefined,
+  id: string | undefined,
+  tools: string[],
+): StoredRow {
   return {
     t: oc.ms ?? null,
     model: canonicalModelId(oc.model),
     i: intOf(oc.usage.input),
     o: intOf(oc.usage.output),
     d: durOf(oc.durMs),
+    tf: durOf(oc.ttftMs),
     cr: intOf(oc.usage.cacheRead),
     cw: intOf(oc.usage.cacheWrite),
     usd: costOf(oc.usage),
     st: 'completed',
     code: undefined,
     note: undefined,
-    tools: [],
+    tools,
     host,
+    agent: 'main',
     id,
   };
 }
 
-function parseFile(text: string, host?: string, file?: string): StoredRow[] {
+function parseFile(text: string, host?: string, file?: string, agent?: string): StoredRow[] {
   const rows: StoredRow[] = [];
   // Guarded: a JSONL transcript must fall through, not abort the sync.
   let oc: ReturnType<typeof classifyOpencodeMessage> = null;
-  try { oc = classifyOpencodeMessage(JSON.parse(text) as OpencodeMessage); } catch { /* JSONL */ }
-  if (oc) {
-    rows.push(opencodeStoredRow(oc, host, file ? path.basename(file).replace(/\.[^.]+$/, '') : undefined));
-    return rows;
-  }
+  try {
+    const message = JSON.parse(text) as OpencodeMessage;
+    oc = classifyOpencodeMessage(message);
+    if (oc) {
+      rows.push(opencodeStoredRow(oc, host, file ? path.basename(file).replace(/\.[^.]+$/, '') : undefined, opencodeToolNames(message)));
+      return rows;
+    }
+  } catch { /* JSONL */ }
   let codexProvider: string | null = null;
   let codexModel: string | null = null;
   for (const line of text.split('\n')) {
@@ -395,6 +512,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
           i: intOf(usage.input),
           o: intOf(usage.output),
           d: undefined,
+          tf: undefined,
           cr: intOf(usage.cacheRead),
           cw: intOf(usage.cacheWrite),
           usd: costOf(usage),
@@ -403,6 +521,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
           note: undefined,
           tools: [],
           host,
+          agent,
           id: rid,
         });
         continue;
@@ -418,6 +537,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
         i: intOf(usage.input),
         o: intOf(usage.output),
         d: dur,
+        tf: durOf(parsed.ttftMs),
         cr: intOf(usage.cacheRead),
         cw: intOf(usage.cacheWrite),
         usd: costOf(usage),
@@ -426,6 +546,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
         note,
         tools: parsed.tools ?? [],
         host,
+        agent,
         id: rid,
       });
     } catch { /* skip corrupt lines */ }
@@ -434,13 +555,13 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
 }
 
 function insertSql(file: string, r: StoredRow): string {
-  return `INSERT INTO messages (file_id, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id) VALUES (` +
+  return `INSERT INTO messages (file_id, t, model, i, o, d, tf, cr, cw, usd, st, code, note, tools, h, a, id) VALUES (` +
     `(SELECT id FROM files WHERE path=${esc(file)}),${r.t === null ? 'NULL' : String(r.t)},${esc(r.model)},${r.i},${r.o},` +
-    `${nullNum(r.d)},${r.cr},${r.cw},${nullNum(r.usd)},${esc(r.st)},` +
-    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))},${nullStr(r.host)},${nullStr(r.id)});`;
+    `${nullNum(r.d)},${nullNum(r.tf)},${r.cr},${r.cw},${nullNum(r.usd)},${esc(r.st)},` +
+    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))},${nullStr(r.host)},${nullStr(r.agent ?? undefined)},${nullStr(r.id)});`;
 }
 
-// Unchanged transcripts are skipped via mtime+size; rows for deleted ones are kept so rotation never erases history. False when sqlite3 is unavailable.
+// Unchanged transcripts are skipped via mtime+size; rows for deleted ones are kept so rotation never erases history.
 export function syncUsageDb(): boolean {
   let db: string;
   guardReport = null;
@@ -449,11 +570,16 @@ export function syncUsageDb(): boolean {
   try {
     db = usageDbPath();
     const stored = storedParserVersion(db);
-    migrated = stored !== null && stored !== PARSER_VERSION;
     // The operator deleted sessions on purpose and wants the mirror to match: bypass the guard.
     const forced = process.env.TERSIO_FORCE_REPARSE === '1';
+    // A downgrade keeps its rows: the wipe below cannot rebuild them from rotated transcripts.
+    const downgrade = !forced && isDowngrade(stored);
+    migrated = stored !== null && stored !== PARSER_VERSION && !downgrade;
+    if (downgrade) guardReport = `store was written by a newer tersio (parser ${stored} > ${PARSER_VERSION}); kept its rows and skipped the re-parse`;
     if (migrated && !forced) preWipe = countMessages(db);
-    ensureSchema(db);
+    ensureSchema(db, forced);
+    // One rewrite so the additive column's NULL rows gain latency; runs while the marker is absent.
+    if (!downgrade && !ttftBackfilled(db)) markTranscriptsDirty(db);
     maybeScheduledBackup(db);
   } catch {
     return false;
@@ -475,8 +601,10 @@ export function syncUsageDb(): boolean {
   const ocDbPath = opencodeDbPath();
   if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DB !== undefined) {
     const newest = newestOpencodeMs(db);
+    // A store predating the tool names re-reads the whole table once; the marker closes the window.
+    const since = newest === null || !opencodeToolsBackfilled(db) ? 0 : newest - OPENCODE_DB_OVERLAP_MS;
     if (newest !== null || fs.existsSync(ocDbPath)) {
-      ocDbRows.push(...readOpencodeDbRows(ocDbPath, newest === null ? 0 : newest - OPENCODE_DB_OVERLAP_MS));
+      ocDbRows.push(...readOpencodeDbRows(ocDbPath, since));
     }
   }
   const known = readFiles(db);
@@ -494,6 +622,7 @@ export function syncUsageDb(): boolean {
     const prev = known[file];
     if (!prev || prev.mtime !== entry.mtime || prev.size !== entry.size) changed.push(file);
   }
+  // `ocDbRows` is non-empty whenever the backfill window is open, so this never skips it.
   if (!changed.length && !ocDbRows.length) return true;
   const chunks: string[] = [];
   let chunkBytes = 0;
@@ -526,7 +655,7 @@ export function syncUsageDb(): boolean {
   try {
     for (const file of changed) {
       const text = fs.readFileSync(file, 'utf8');
-      for (const r of parseFile(text, hostOfSessionFile(file), file)) {
+      for (const r of parseFile(text, hostOfSessionFile(file), file, agentOfSessionText(text))) {
         if (!push(insertSql(file, r))) return false;
       }
     }
@@ -539,13 +668,21 @@ export function syncUsageDb(): boolean {
         `INSERT INTO files (path, mtime, size) VALUES (${esc(key)},${row.created},0)` +
         ` ON CONFLICT(path) DO UPDATE SET mtime=excluded.mtime;` +
         `DELETE FROM messages WHERE file_id=(SELECT id FROM files WHERE path=${esc(key)});` +
-        insertSql(key, opencodeStoredRow(parsed, 'opencode', row.id)),
+        insertSql(key, opencodeStoredRow(parsed, 'opencode', row.id, opencodeToolNames(row.row, row.tools))),
       )) return false;
     }
   } catch {
     return false;
   }
   if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('last_sync',${esc(String(Date.now()))});`)) return false;
+  // Only once the rows are written, so a sync that fails midway widens the scan again.
+  if (ocDbRows.length > 0) {
+    if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('opencode_tools','${OPENCODE_TOOLS_VERSION}');`)) return false;
+  }
+  // Set only after the rewrite commits: a crash mid-backfill leaves mtimes cleared and the marker absent.
+  if (changed.length > 0) {
+    if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('ttft_backfill','${TTFT_VERSION}');`)) return false;
+  }
   if (!flush()) return false;
   if (preWipe > 0) {
     const kept = countMessages(db);
@@ -561,6 +698,8 @@ export function syncUsageDb(): boolean {
   if (migrated) {
     try { run(db, `VACUUM;`); } catch { /* best-effort */ }
   }
+  // Fold the WAL back into the main file: a backup copies one file, and a checkpoint keeps it whole.
+  try { run(db, `PRAGMA wal_checkpoint(TRUNCATE);`); } catch { /* best-effort */ }
   return true;
 }
 
@@ -573,18 +712,25 @@ export function readUsageDb(): StoredUsage | null {
   }
   let rows: string[][];
   try {
-    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id FROM messages;`);
+    // The wide `tools` column is read as one string and skipped in JS; a pre-agent store is read without it.
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    const agentCol = names.includes('a') ? 'a' : "''";
+    // A store predating first-token latency has no `tf` column; read NULL so the row still loads.
+    const tfCol = names.includes('tf') ? 'tf' : 'NULL';
+    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, ${agentCol}, id, ${tfCol} FROM messages;`);
   } catch {
     return null;
   }
   const accum = newSessionAccum();
-  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id] of rows) {
+  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, a, id, tf] of rows) {
     const ts = t === '' ? undefined : Number(t);
     let toolNames: string[] = [];
-    try {
-      const parsed: unknown = JSON.parse(tools || '[]');
-      if (Array.isArray(parsed)) toolNames = parsed.filter((x): x is string => typeof x === 'string');
-    } catch { /* keep empty */ }
+    if (tools && tools !== '[]' && tools !== '') {
+      try {
+        const parsed: unknown = JSON.parse(tools);
+        if (Array.isArray(parsed)) toolNames = parsed.filter((x): x is string => typeof x === 'string');
+      } catch { /* keep empty */ }
+    }
     const usage: Record<string, unknown> = {
       input: Number(i) || 0,
       output: Number(o) || 0,
@@ -609,6 +755,8 @@ export function readUsageDb(): StoredUsage | null {
       toolNames,
       h === '' ? undefined : h,
       id === '' || id === undefined ? undefined : id,
+      a === '' ? undefined : a,
+      tf === undefined || tf === '' ? undefined : Number(tf),
     );
   }
   accum.recent.sort((a, b) => b.t - a.t);
@@ -627,6 +775,10 @@ export function readUsageDb(): StoredUsage | null {
       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),
     },

package/extensions/{lib → shared}/utils.ts

@@ -1,4 +1,4 @@
-// Shared helpers for the installer and the AI add-ons updater. Node built-ins only — this module must stay dependency-free.
+// Shared helpers for the installer and AI add-ons updater. Node built-ins only — must stay dependency-free.
 
 import { createHash } from 'node:crypto';
 import { accessSync, constants, createWriteStream, existsSync, mkdirSync, renameSync, statSync } from 'node:fs';
@@ -13,7 +13,7 @@ export interface HttpOptions {
 }
 
 // Promise.withResolvers is Node 22+; the package supports Node 18+.
-export function withResolvers<T>(): PromiseWithResolvers<T> {
+function withResolvers<T>(): PromiseWithResolvers<T> {
   let resolve!: (value: T | PromiseLike<T>) => void;
   let reject!: (reason?: unknown) => void;
   const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
@@ -112,7 +112,7 @@ function redirectNext(res: { statusCode?: number; headers: { location?: string }
   return null;
 }
 
-// pi sets PI_CODING_AGENT; OMP does not. OMP does read PI_CODING_AGENT_DIR as its own relocation variable, so the override only counts under that marker.
+// pi sets PI_CODING_AGENT; OMP does not. It reads PI_CODING_AGENT_DIR to relocate, so the override only counts there.
 export function isPiProcess(): boolean {
   return process.env.PI_CODING_AGENT === 'true';
 }
@@ -122,7 +122,7 @@ export function piAgentDir(): string {
   return isPiProcess() && override ? override : path.join(homeDir(), '.pi', 'agent');
 }
 
-// Ponytail is a Tersio dependency that npm hoists, so it can sit in Tersio's node_modules, a host's plugin dir, or beside it. Walking up covers all.
+// Ponytail is hoisted, so it sits in Tersio's node_modules, a host's plugin dir, or beside it; walking up covers all.
 export function findHoistedPackage(pkg: string, fromDir: string, ...relInside: string[]): string | null {
   let dir = fromDir;
   for (;;) {
@@ -240,7 +240,7 @@ export async function readTextIfExists(p: string): Promise<string | null> {
   try { return await fs.readFile(p, 'utf8'); } catch { return null; }
 }
 
-// Chunked so a 200 MiB host binary is never held in memory. `tail` keeps the last needle.length-1 bytes of the previous chunk, because a match can begin near the end of one chunk and finish inside the next.
+// Chunked: a 200 MiB binary never fits memory. `tail` keeps needle.length-1 bytes in case a match spans chunks.
 export async function fileContains(filePath: string, needleText: string): Promise<boolean> {
   const needle = Buffer.from(needleText, 'utf8');
   if (needle.length === 0) return false;
@@ -267,7 +267,7 @@ export async function fileContains(filePath: string, needleText: string): Promis
   }
 }
 
-// Tersio-owned data home: ~/.tersio. First use moves legacy ~/.omp/plugins/tersio-* files over so existing installs keep their history.
+// Tersio data home: ~/.tersio. First use moves legacy ~/.omp/plugins/tersio-* files over so installs keep history.
 const migratedTersioFiles = new Set<string>();
 
 export function tersioHome(): string {

package/extensions/timing/index.ts

@@ -0,0 +1,45 @@
+// pi records a response's total duration but no first-token latency, so TTFT reads null there.
+// omp writes its own `ttft` and OpenCode records `time.streamed`, so this fills the gap only for pi.
+import type { ExtensionApi } from '../shared/types.ts';
+
+interface AssistantMessage {
+  role?: unknown;
+  /** Unix ms when the request started, which pi sets before the stream opens. */
+  timestamp?: unknown;
+  ttft?: unknown;
+}
+
+interface MessageEvent {
+  message?: AssistantMessage;
+}
+
+interface UpdateEvent extends MessageEvent {
+  assistantMessageEvent?: { type?: unknown };
+}
+
+export default function timingExtension(pi: ExtensionApi): void {
+  // First token per request, keyed by the request's own start stamp, which survives every stream event.
+  const firstTokenAt = new Map<number, number>();
+
+  pi.on<UpdateEvent>('message_update', (event: UpdateEvent) => {
+    const message = event.message;
+    if (!message || message.role !== 'assistant') return;
+    const anchor = typeof message.timestamp === 'number' ? message.timestamp : 0;
+    if (anchor <= 0 || firstTokenAt.has(anchor)) return;
+    // `start` opens the stream with no token yet; the first delta is the first token.
+    if (!String(event.assistantMessageEvent?.type ?? '').endsWith('_delta')) return;
+    firstTokenAt.set(anchor, Date.now());
+  });
+
+  pi.on<MessageEvent>('message_end', (event: MessageEvent) => {
+    const message = event.message;
+    if (!message || message.role !== 'assistant') return;
+    const anchor = typeof message.timestamp === 'number' ? message.timestamp : 0;
+    const at = anchor > 0 ? firstTokenAt.get(anchor) : undefined;
+    if (anchor > 0) firstTokenAt.delete(anchor);
+    // A host that recorded its own latency wins; this only fills the gap.
+    if (at === undefined || message.ttft !== undefined) return;
+    const ttft = at - anchor;
+    if (ttft > 0) message.ttft = ttft;
+  });
+}