@krtclcdy/tersio 2.24.0 → 2.25.0

package/extensions/shared/usage-store.ts

@@ -1,27 +1,32 @@
-// extensions/shared/usage-store.ts — tersio-owned usage.db.
-// Persists the rows importSessionTokens derives live, so reports survive
-// session-file rotation. Sync is incremental (a files ledger skips unchanged
-// transcripts) and every read applies the reset watermark, so the store is a
-// cache, never a fork. Missing sqlite3 → sync false / read null. Never touches
-// RTK's history.db or host transcripts.
+// 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';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import {
   RECENT_LIMIT,
+  SQLITE_READ_BUFFER,
   canonicalModelId,
   classifySessionLine,
-  codexSessionsDir,
+  OpencodeMessage,
+  classifyOpencodeMessage,
   costOf,
   durOf,
+  hostOfSessionFile,
   ingestSessionRow,
+  messageRowId,
+  OpencodeDbRow,
+  OPENCODE_DB_OVERLAP_MS,
+  opencodeDbPath,
+  opencodeSessionsDir,
   newSessionAccum,
-  sessionsDir,
+  readOpencodeDbRows,
+  sessionsDirs,
   walkJsonl,
 } from './usage-ledger.ts';
 import { tersioDataPath } from '../lib/utils.ts';
 import { MODEL_ALIASES } from './pricing.ts';
+import { tersioSettingsFile } from './plugin-settings.ts';
 import type { RunStatus, SessionTokens } from './usage-ledger.ts';
 
 export function usageDbPath(): string {
@@ -52,7 +57,8 @@ function nullStr(v: string | undefined): string {
 }
 
 function run(db: string, sql: string): void {
-  execFileSync('sqlite3', [db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: 30000 });
+  // -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 });
 }
 
 function query(db: string, sql: string): string[][] {
@@ -60,6 +66,7 @@ function query(db: string, sql: string): string[][] {
     encoding: 'utf8',
     timeout: 30000,
     stdio: ['ignore', 'pipe', 'ignore'],
+    maxBuffer: SQLITE_READ_BUFFER,
   });
   return out
     .split('\n')
@@ -67,21 +74,240 @@ function query(db: string, sql: string): string[][] {
     .map((line) => line.split('\t'));
 }
 
+// Bump on a parse change: unchanged transcripts are never re-read.
+const PARSER_VERSION = '11';
+
+// A re-parse that keeps less than half the rows means transcripts vanished mid-migration; the backup is restored instead of publishing the loss.
+const REPARSE_GUARD_RATIO = 0.5;
+
+let guardReport: string | null = null;
+
+/** Why the last sync refused to publish a re-parse, if it did. */
+export function reparseGuardReport(): string | null {
+  return guardReport;
+}
+
+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);`;
+
+function storedParserVersion(db: string): string | null {
+  try {
+    const stored = query(db, `SELECT v FROM meta WHERE k='parser_version';`);
+    return stored.length ? stored[0][0] : null;
+  } catch {
+    return null;
+  }
+}
+
+function countMessages(db: string): number {
+  try {
+    const rows = query(db, `SELECT COUNT(*) FROM messages;`);
+    return Number(rows[0]?.[0]) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+// Watermark for the sqlite scan: the newest opencode row already stored.
+function newestOpencodeMs(db: string): number | null {
+  try {
+    const rows = query(db, `SELECT MAX(t) FROM messages WHERE h='opencode';`);
+    const v = Number(rows[0]?.[0]);
+    return Number.isFinite(v) && v > 0 ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+// 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;
+  try {
+    const newest = listUsageBackups()[0];
+    if (!newest) return false;
+    const out = query(newest.file, `SELECT v FROM meta WHERE k='parser_version';`);
+    return out.length > 0 && out[0][0] === stored;
+  } catch {
+    return false;
+  }
+}
+
+// v9 shape (path-keyed rows) migrates in place with zero re-parse, so history survives even when transcripts are gone.
+function canMigrateInPlace(db: string): boolean {
+  try {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file') && names.includes('h') && !names.includes('file_id');
+  } catch {
+    return false;
+  }
+}
+
+function migrateInPlace(db: string, preCount: number): boolean {
+  const cols = `t, model, i, o, d, cr, cw, usd, st, code, note, tools, h`;
+  try {
+    run(db,
+      `BEGIN;` +
+      `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);` +
+      `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;` +
+      `CREATE INDEX idx_messages_file ON messages(file_id);` +
+      `COMMIT;`);
+  } catch {
+    return false;
+  }
+  try {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file_id') && !names.includes('file') && countMessages(db) === preCount;
+  } catch {
+    return false;
+  }
+}
+
+// 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 {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file_id') && !names.includes('id');
+  } catch {
+    return false;
+  }
+}
+
+function alterInPlace(db: string): boolean {
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN id TEXT;`);
+  } catch {
+    return false;
+  }
+  return !canAlterInPlace(db);
+}
+
 function ensureSchema(db: string): void {
   fs.mkdirSync(path.dirname(db), { recursive: true });
-  // Rows imported before an alias existed keep the spelling they were stored
-  // with, and the mtime ledger will not re-read those transcripts. Fold them in
-  // once, so the merge shows up without a reset.
+  // 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('');
-  run(
-    db,
-    `CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);` +
-      `CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, mtime REAL NOT NULL, size INTEGER NOT NULL);` +
-      `CREATE TABLE IF NOT EXISTS messages (file TEXT NOT NULL, 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 '[]');` +
-      `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file);` + rekeys,
-  );
+  const stored = storedParserVersion(db);
+  if (stored === PARSER_VERSION) {
+    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);
+    if (stored !== null && canMigrateInPlace(db) && migrateInPlace(db, countMessages(db))) {
+      run(db, `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
+      try { run(db, `VACUUM;`); } catch { /* best-effort */ }
+      return;
+    }
+    if (stored !== null && canAlterInPlace(db) && alterInPlace(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 */ }
+}
+
+// The one destructive thing we do; keep the last few so a bad bump is recoverable.
+const BACKUP_KEEP = 3;
+
+export function backupUsageDir(): string {
+  return path.join(path.dirname(usageDbPath()), 'backups');
+}
+
+export function listUsageBackups(): Array<{ file: string; mtime: number; size: number }> {
+  try {
+    return fs.readdirSync(backupUsageDir())
+      .filter((n) => /^usage-\d{14}\.db$/.test(n))
+      .map((n) => {
+        const full = path.join(backupUsageDir(), n);
+        const st = fs.statSync(full);
+        return { file: full, mtime: st.mtimeMs, size: st.size };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+  } catch {
+    return [];
+  }
+}
+
+export function backupUsageDb(db: string): void {
+  try {
+    const dir = backupUsageDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    fs.copyFileSync(db, path.join(dir, `usage-${stamp}.db`));
+    for (const old of listUsageBackups().slice(BACKUP_KEEP)) {
+      fs.rmSync(old.file, { force: true });
+    }
+  } catch { /* a missing backup must not block the sync */ }
+}
+
+const SCHEDULE_MS: Record<string, number> = { daily: 86_400_000, weekly: 604_800_000, monthly: 2_592_000_000 };
+
+/** Read the schedule straight from settings; this module must not import cli/. */
+export function readBackupSchedule(): string {
+  try {
+    const raw = JSON.parse(fs.readFileSync(tersioSettingsFile(), 'utf8')) as { backupSchedule?: unknown };
+    return typeof raw?.backupSchedule === 'string' ? raw.backupSchedule : 'monthly';
+  } catch {
+    return 'monthly';
+  }
+}
+
+/** Snapshot on the schedule, skipping when the newest one is still fresh. */
+export function maybeScheduledBackup(db: string): boolean {
+  const every = SCHEDULE_MS[readBackupSchedule()];
+  if (!every) return false;
+  try {
+    const newest = listUsageBackups()[0];
+    if (newest && Date.now() - newest.mtime < every) return false;
+    backupUsageDb(db);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// basename only: a crafted `../` must not escape the backup dir.
+function resolveBackupFile(file: string): string | null {
+  const dir = path.resolve(backupUsageDir());
+  const target = path.join(dir, path.basename(String(file || '')));
+  if (!target.startsWith(dir + path.sep)) return null;
+  return fs.existsSync(target) ? target : null;
+}
+
+/** Put a backup back in place. The next sync then re-parses over it. */
+export function restoreUsageBackup(file: string): boolean {
+  try {
+    const src = resolveBackupFile(file);
+    if (!src) return false;
+    fs.copyFileSync(src, usageDbPath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Delete one snapshot. Only ever touches a file inside the backup dir. */
+export function deleteUsageBackup(file: string): boolean {
+  try {
+    const target = resolveBackupFile(file);
+    if (!target) return false;
+    fs.rmSync(target, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function readFiles(db: string): Record<string, { mtime: number; size: number }> {
@@ -94,8 +320,7 @@ 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, as stored. `t` is null when the source row has no usable timestamp: counted, but skipped in the recent list.
 interface StoredRow {
   t: number | null;
   model: string;
@@ -109,20 +334,55 @@ interface StoredRow {
   code: number | undefined;
   note: string | undefined;
   tools: string[];
+  host?: string;
+  id?: string;
 }
 
-function parseFile(text: string): StoredRow[] {
+// 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 {
+  return {
+    t: oc.ms ?? null,
+    model: canonicalModelId(oc.model),
+    i: intOf(oc.usage.input),
+    o: intOf(oc.usage.output),
+    d: durOf(oc.durMs),
+    cr: intOf(oc.usage.cacheRead),
+    cw: intOf(oc.usage.cacheWrite),
+    usd: costOf(oc.usage),
+    st: 'completed',
+    code: undefined,
+    note: undefined,
+    tools: [],
+    host,
+    id,
+  };
+}
+
+function parseFile(text: string, host?: string, file?: 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;
+  }
   let codexProvider: string | null = null;
+  let codexModel: string | null = null;
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
       const row = JSON.parse(line) as Parameters<typeof classifySessionLine>[0];
+      const rid = messageRowId(row);
       const parsed = classifySessionLine(row);
       if (parsed.kind === 'codex_provider') {
         if (parsed.provider) codexProvider = parsed.provider;
         continue;
       }
+      if (parsed.kind === 'codex_model') {
+        if (parsed.model) codexModel = parsed.model;
+        continue;
+      }
       const ts = row.timestamp;
       const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
       const t = Number.isFinite(ms) ? ms : null;
@@ -131,7 +391,7 @@ function parseFile(text: string): StoredRow[] {
         const usage = parsed.usage ?? {};
         rows.push({
           t,
-          model: canonicalModelId(provider ? `codex/${provider}` : 'codex'),
+          model: canonicalModelId(provider ? (codexModel ? `codex/${provider}/${codexModel}` : `codex/${provider}`) : 'codex'),
           i: intOf(usage.input),
           o: intOf(usage.output),
           d: undefined,
@@ -142,6 +402,8 @@ function parseFile(text: string): StoredRow[] {
           code: undefined,
           note: undefined,
           tools: [],
+          host,
+          id: rid,
         });
         continue;
       }
@@ -163,6 +425,8 @@ function parseFile(text: string): StoredRow[] {
         code: run.code,
         note,
         tools: parsed.tools ?? [],
+        host,
+        id: rid,
       });
     } catch { /* skip corrupt lines */ }
   }
@@ -170,32 +434,51 @@ function parseFile(text: string): StoredRow[] {
 }
 
 function insertSql(file: string, r: StoredRow): string {
-  return `INSERT INTO messages (file, t, model, i, o, d, cr, cw, usd, st, code, note, tools) VALUES (` +
-    `${esc(file)},${r.t === null ? 'NULL' : String(r.t)},${esc(r.model)},${r.i},${r.o},` +
+  return `INSERT INTO messages (file_id, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, 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))});`;
+    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))},${nullStr(r.host)},${nullStr(r.id)});`;
 }
 
-// Incremental sync: unchanged transcripts are skipped via mtime+size, changed
-// ones re-inserted. Rows for deleted transcripts are kept, so rotation never
-// erases history. False when sqlite3 or disk is unavailable.
+// Unchanged transcripts are skipped via mtime+size; rows for deleted ones are kept so rotation never erases history. False when sqlite3 is unavailable.
 export function syncUsageDb(): boolean {
   let db: string;
+  guardReport = null;
+  let preWipe = -1;
+  let migrated = false;
   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';
+    if (migrated && !forced) preWipe = countMessages(db);
     ensureSchema(db);
+    maybeScheduledBackup(db);
   } catch {
     return false;
   }
   const files: string[] = [];
+  const ocFiles: string[] = [];
   try {
-    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);
+    // OpenCode stores one JSON document per message, not JSONL.
+    if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DIR !== undefined) {
+      walkJsonl(opencodeSessionsDir(), ocFiles, 5000, '.json');
     }
   } catch {
     return false;
   }
+  files.push(...ocFiles);
+  // v2 hosts keep messages in sqlite; rows past the watermark are new. Overlap re-reads the tail idempotently.
+  const ocDbRows: OpencodeDbRow[] = [];
+  const ocDbPath = opencodeDbPath();
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DB !== undefined) {
+    const newest = newestOpencodeMs(db);
+    if (newest !== null || fs.existsSync(ocDbPath)) {
+      ocDbRows.push(...readOpencodeDbRows(ocDbPath, newest === null ? 0 : newest - OPENCODE_DB_OVERLAP_MS));
+    }
+  }
   const known = readFiles(db);
   const current: Record<string, { mtime: number; size: number }> = {};
   const changed: string[] = [];
@@ -211,7 +494,7 @@ export function syncUsageDb(): boolean {
     const prev = known[file];
     if (!prev || prev.mtime !== entry.mtime || prev.size !== entry.size) changed.push(file);
   }
-  if (!changed.length) return true;
+  if (!changed.length && !ocDbRows.length) return true;
   const chunks: string[] = [];
   let chunkBytes = 0;
   const flush = (): boolean => {
@@ -228,26 +511,57 @@ export function syncUsageDb(): boolean {
   const push = (sql: string): boolean => {
     chunks.push(sql);
     chunkBytes += sql.length;
-    if (chunkBytes < 400_000) return true;
+    // One argv string caps at 128KB on Linux (E2BIG); stay well under it.
+    if (chunkBytes < 100_000) return true;
     return flush();
   };
   for (const file of changed) {
-    if (!push(`DELETE FROM messages WHERE file=${esc(file)};DELETE FROM files WHERE path=${esc(file)};`)) return false;
+    const entry = current[file];
+    if (!push(
+      `INSERT INTO files (path, mtime, size) VALUES (${esc(file)},${entry.mtime},${entry.size})` +
+      ` ON CONFLICT(path) DO UPDATE SET mtime=excluded.mtime,size=excluded.size;` +
+      `DELETE FROM messages WHERE file_id=(SELECT id FROM files WHERE path=${esc(file)});`,
+    )) return false;
   }
   try {
     for (const file of changed) {
-      const entry = current[file];
       const text = fs.readFileSync(file, 'utf8');
-      for (const r of parseFile(text)) {
+      for (const r of parseFile(text, hostOfSessionFile(file), file)) {
         if (!push(insertSql(file, r))) return false;
       }
-      if (!push(`INSERT OR REPLACE INTO files (path, mtime, size) VALUES (${esc(file)},${entry.mtime},${entry.size});`)) return false;
+    }
+    for (const row of ocDbRows) {
+      const parsed = classifyOpencodeMessage(row.row);
+      if (!parsed) continue;
+      // One synthetic path per row id, so the delete-and-reinsert that follows is idempotent.
+      const key = `${ocDbPath}#${row.id}`;
+      if (!push(
+        `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)),
+      )) return false;
     }
   } catch {
     return false;
   }
   if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('last_sync',${esc(String(Date.now()))});`)) return false;
-  return flush();
+  if (!flush()) return false;
+  if (preWipe > 0) {
+    const kept = countMessages(db);
+    if (kept < preWipe * REPARSE_GUARD_RATIO) {
+      const newest = listUsageBackups()[0];
+      if (newest && restoreUsageBackup(path.basename(newest.file))) {
+        guardReport = `re-parse kept ${kept} of ${preWipe} rows; restored ${path.basename(newest.file)} (set TERSIO_FORCE_REPARSE=1 to accept the loss)`;
+        return false;
+      }
+    }
+  }
+  // Reclaim the migration's DELETE storm so the file stays small.
+  if (migrated) {
+    try { run(db, `VACUUM;`); } catch { /* best-effort */ }
+  }
+  return true;
 }
 
 export function readUsageDb(): StoredUsage | null {
@@ -259,12 +573,12 @@ 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 FROM messages;`);
+    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id FROM messages;`);
   } catch {
     return null;
   }
   const accum = newSessionAccum();
-  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools] of rows) {
+  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id] of rows) {
     const ts = t === '' ? undefined : Number(t);
     let toolNames: string[] = [];
     try {
@@ -293,6 +607,8 @@ export function readUsageDb(): StoredUsage | null {
         note: note === '' ? undefined : note,
       },
       toolNames,
+      h === '' ? undefined : h,
+      id === '' || id === undefined ? undefined : id,
     );
   }
   accum.recent.sort((a, b) => b.t - a.t);
@@ -310,6 +626,7 @@ export function readUsageDb(): StoredUsage | null {
       byDayModel: accum.byDayModel,
       byTool: accum.byTool,
       byModelMessages: accum.byModelMessages,
+      byHost: accum.byHost,
       costMeasured: accum.costMeasured,
       recent: accum.recent.slice(0, RECENT_LIMIT),
     },

package/extensions/tersio-commands/index.js

@@ -1,9 +1,6 @@
-// /tersio root command — status, check, update, dashboard, usage, help.
-// Mode switches live on their own commands (/caveman, /rtk, /combo, and the
-// upstream /ponytail): the router keeps no redundant copies. Shared-state
-// publishes sync sibling mirrors live, so switches notify and take effect
-// next turn — no reload.
-import { getSharedComboState, reconcileSharedComboEntries, sessionEntries, } from '../shared/session-state.js';
+// Root command plus mode switches; sibling mirrors sync with no reload.
+import { reconcileSharedComboEntries, sessionEntries, } from '../shared/session-state.js';
+import { announceStatus } from '../shared/status.js';
 import { setExtensionLabel } from '../shared/host.js';
 import os from 'node:os';
 import path from 'node:path';
@@ -18,11 +15,6 @@ const HELP = [
     '/tersio help — this table',
     'mode switches: /caveman /rtk /combo (tersio) + /ponytail (upstream)',
 ].join('\n');
-function statusLine() {
-    const s = getSharedComboState();
-    const level = s.level === 'custom' ? 'INACTIVE' : s.level.toUpperCase();
-    return `tersio — caveman=${s.caveman.toUpperCase()} · rtk=${s.rtk.toUpperCase()} · ponytail=${s.ponytail.toUpperCase()} (combo ${level})`;
-}
 function usageSummary() {
     const rows = readUsage();
     if (rows.length === 0)
@@ -59,7 +51,7 @@ export default function tersioCommandsExtension(pi) {
             if (!sub || sub === 'status') {
                 if (ctx?.hasUI)
                     reconcileSharedComboEntries(sessionEntries(ctx));
-                ctx?.ui?.notify?.(statusLine(), 'info');
+                announceStatus(ctx);
                 return;
             }
             if (sub === 'help') {
@@ -88,8 +80,7 @@ export default function tersioCommandsExtension(pi) {
                 ctx?.ui?.notify?.(usageSummary(), 'info');
                 return;
             }
-            // Removed mode switches redirect to their own commands so only one
-            // spelling exists to learn: /caveman, /rtk, /combo, /ponytail.
+            // Removed mode switches redirect to their own commands so only one spelling exists to learn: /caveman, /rtk, /combo, /ponytail.
             if (sub === 'caveman' || sub === 'rtk' || sub === 'combo' || sub === 'ponytail') {
                 ctx?.ui?.notify?.(`Use /${sub} instead — /tersio no longer duplicates mode switches.\n${HELP}`, 'warning');
                 return;

package/extensions/tersio-commands/index.ts

@@ -1,13 +1,10 @@
-// /tersio root command — status, check, update, dashboard, usage, help.
-// Mode switches live on their own commands (/caveman, /rtk, /combo, and the
-// upstream /ponytail): the router keeps no redundant copies. Shared-state
-// publishes sync sibling mirrors live, so switches notify and take effect
-// next turn — no reload.
+// Root command plus mode switches; sibling mirrors sync with no reload.
 import {
-  getSharedComboState,
+
   reconcileSharedComboEntries,
   sessionEntries,
 } from '../shared/session-state.ts';
+import { announceStatus } from '../shared/status.ts';
 import { setExtensionLabel } from '../shared/host.ts';
 import os from 'node:os';
 import path from 'node:path';
@@ -25,11 +22,6 @@ const HELP = [
   'mode switches: /caveman /rtk /combo (tersio) + /ponytail (upstream)',
 ].join('\n');
 
-function statusLine(): string {
-  const s = getSharedComboState();
-  const level = s.level === 'custom' ? 'INACTIVE' : s.level.toUpperCase();
-  return `tersio — caveman=${s.caveman.toUpperCase()} · rtk=${s.rtk.toUpperCase()} · ponytail=${s.ponytail.toUpperCase()} (combo ${level})`;
-}
 
 function usageSummary(): string {
   const rows = readUsage();
@@ -67,7 +59,7 @@ export default function tersioCommandsExtension(pi: ExtensionApi): void {
 
       if (!sub || sub === 'status') {
         if (ctx?.hasUI) reconcileSharedComboEntries(sessionEntries(ctx));
-        ctx?.ui?.notify?.(statusLine(), 'info');
+        announceStatus(ctx);
         return;
       }
       if (sub === 'help') {
@@ -96,8 +88,7 @@ export default function tersioCommandsExtension(pi: ExtensionApi): void {
         ctx?.ui?.notify?.(usageSummary(), 'info');
         return;
       }
-      // Removed mode switches redirect to their own commands so only one
-      // spelling exists to learn: /caveman, /rtk, /combo, /ponytail.
+      // Removed mode switches redirect to their own commands so only one spelling exists to learn: /caveman, /rtk, /combo, /ponytail.
       if (sub === 'caveman' || sub === 'rtk' || sub === 'combo' || sub === 'ponytail') {
         ctx?.ui?.notify?.(`Use /${sub} instead — /tersio no longer duplicates mode switches.\n${HELP}`, 'warning');
         return;