@krtclcdy/tersio 2.23.0 → 2.24.1

package/extensions/shared/usage-store.js

@@ -1,16 +1,12 @@
-// extensions/shared/usage-store.ts — tersio-owned usage.db.
-// Persists the same per-message rows importSessionTokens derives live (model,
-// tokens, cache, cost input, timing, status, tools), so top models, costing,
-// cache, CO2 inputs, and activity survive session-file rotation. Sync is
-// incremental: a files ledger (mtime+size) skips unchanged transcripts, and
-// every read applies the current reset watermark — the store is a cache,
-// never a fork. Missing sqlite3 CLI → sync false / read null, callers fall
-// back to the live path. 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 path from 'node:path';
-import { RECENT_LIMIT, canonicalModelId, classifySessionLine, codexSessionsDir, costOf, durOf, ingestSessionRow, newSessionAccum, sessionsDir, walkJsonl, } from './usage-ledger.js';
+import { RECENT_LIMIT, canonicalModelId, classifySessionLine, classifyOpencodeMessage, codexSessionsDir, costOf, durOf, hostOfSessionFile, ingestSessionRow, opencodeSessionsDir, newSessionAccum, sessionsDirs, walkJsonl, } from './usage-ledger.js';
 import { tersioDataPath } from '../lib/utils.js';
+import { MODEL_ALIASES } from './pricing.js';
+import { tersioSettingsFile } from './plugin-settings.js';
 export function usageDbPath() {
     const override = process.env.TERSIO_USAGE_DB;
     if (override)
@@ -43,14 +39,134 @@ function query(db, sql) {
         .filter((line) => line.trim())
         .map((line) => line.split('\t'));
 }
+// Bump on a parse change: unchanged transcripts are never re-read.
+const PARSER_VERSION = '6';
 function ensureSchema(db) {
     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('');
     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);`);
+        ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT);` +
+        `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file);` + rekeys);
+    // An older db has no h column; CREATE TABLE IF NOT EXISTS will not add one.
+    try {
+        run(db, `ALTER TABLE messages ADD COLUMN h TEXT;`);
+    }
+    catch { /* already present */ }
+    // Host is derivable from the path, so backfill without re-reading transcripts.
+    try {
+        for (const [file] of query(db, `SELECT DISTINCT file FROM messages WHERE h IS NULL;`)) {
+            run(db, `UPDATE messages SET h='${esc(hostOfSessionFile(file))}' WHERE file=${esc(file)};`);
+        }
+    }
+    catch { /* fresh or unreadable db */ }
+    // Drop the cache when the parser has moved on, so every transcript is read
+    // again and the new columns actually fill.
+    try {
+        const stored = query(db, `SELECT v FROM meta WHERE k='parser_version';`);
+        if (stored.length && stored[0][0] === PARSER_VERSION)
+            return;
+        backupUsageDb(db);
+        run(db, `DELETE FROM messages;DELETE FROM files;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() {
+    return path.join(path.dirname(usageDbPath()), 'backups');
+}
+export function listUsageBackups() {
+    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 [];
+    }
+}
+function backupUsageDb(db) {
+    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 = { 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() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(tersioSettingsFile(), 'utf8'));
+        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) {
+    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) {
+    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) {
+    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) {
+    try {
+        const target = resolveBackupFile(file);
+        if (!target)
+            return false;
+        fs.rmSync(target, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 function readFiles(db) {
     const known = {};
@@ -62,9 +178,34 @@ function readFiles(db) {
     catch { /* fresh db */ }
     return known;
 }
-function parseFile(text) {
+function parseFile(text, host) {
     const rows = [];
+    // Guarded: a JSONL transcript must fall through, not abort the sync.
+    let oc = null;
+    try {
+        oc = classifyOpencodeMessage(JSON.parse(text));
+    }
+    catch { /* JSONL */ }
+    if (oc) {
+        rows.push({
+            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,
+        });
+        return rows;
+    }
     let codexProvider = null;
+    let codexModel = null;
     for (const line of text.split('\n')) {
         if (!line.trim())
             continue;
@@ -76,6 +217,11 @@ function parseFile(text) {
                     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;
@@ -84,7 +230,7 @@ function parseFile(text) {
                 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,
@@ -95,6 +241,7 @@ function parseFile(text) {
                     code: undefined,
                     note: undefined,
                     tools: [],
+                    host,
                 });
                 continue;
             }
@@ -117,6 +264,7 @@ function parseFile(text) {
                 code: run.code,
                 note,
                 tools: parsed.tools ?? [],
+                host,
             });
         }
         catch { /* skip corrupt lines */ }
@@ -124,34 +272,40 @@ function parseFile(text) {
     return rows;
 }
 function insertSql(file, r) {
-    return `INSERT INTO messages (file, t, model, i, o, d, cr, cw, usd, st, code, note, tools) VALUES (` +
+    return `INSERT INTO messages (file, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h) VALUES (` +
         `${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)});`;
 }
-// Incremental sync: unchanged transcripts are skipped via mtime+size,
-// changed ones are deleted and re-inserted. Rows for deleted transcripts
-// are kept, so OMP session rotation never erases history. True on success
-// (including nothing-to-do), 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() {
     let db;
     try {
         db = usageDbPath();
         ensureSchema(db);
+        maybeScheduledBackup(db);
     }
     catch {
         return false;
     }
     const files = [];
+    const ocFiles = [];
     try {
-        walkJsonl(sessionsDir(), files, 2000);
+        for (const dir of sessionsDirs())
+            walkJsonl(dir, files, 2000);
         if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
             walkJsonl(codexSessionsDir(), 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);
     const known = readFiles(db);
     const current = {};
     const changed = [];
@@ -201,7 +355,7 @@ export function syncUsageDb() {
         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))) {
                 if (!push(insertSql(file, r)))
                     return false;
             }
@@ -227,13 +381,13 @@ export function readUsageDb() {
     }
     let rows;
     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 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] of rows) {
         const ts = t === '' ? undefined : Number(t);
         let toolNames = [];
         try {
@@ -257,7 +411,7 @@ export function readUsageDb() {
             st: st === 'error' || st === 'aborted' ? st : 'completed',
             code: code === '' ? undefined : Number(code),
             note: note === '' ? undefined : note,
-        }, toolNames);
+        }, toolNames, h === '' ? undefined : h);
     }
     accum.recent.sort((a, b) => b.t - a.t);
     let syncedAt = 0;

package/extensions/shared/usage-store.ts

@@ -1,11 +1,5 @@
-// extensions/shared/usage-store.ts — tersio-owned usage.db.
-// Persists the same per-message rows importSessionTokens derives live (model,
-// tokens, cache, cost input, timing, status, tools), so top models, costing,
-// cache, CO2 inputs, and activity survive session-file rotation. Sync is
-// incremental: a files ledger (mtime+size) skips unchanged transcripts, and
-// every read applies the current reset watermark — the store is a cache,
-// never a fork. Missing sqlite3 CLI → sync false / read null, callers fall
-// back to the live path. 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';
@@ -14,15 +8,21 @@ import {
   RECENT_LIMIT,
   canonicalModelId,
   classifySessionLine,
+  OpencodeMessage,
+  classifyOpencodeMessage,
   codexSessionsDir,
   costOf,
   durOf,
+  hostOfSessionFile,
   ingestSessionRow,
+  opencodeSessionsDir,
   newSessionAccum,
-  sessionsDir,
+  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 {
@@ -68,17 +68,133 @@ 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 = '6';
+
 function ensureSchema(db: string): 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('');
   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);`,
+      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT);` +
+      `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file);` + rekeys,
   );
+  // An older db has no h column; CREATE TABLE IF NOT EXISTS will not add one.
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN h TEXT;`);
+  } catch { /* already present */ }
+  // Host is derivable from the path, so backfill without re-reading transcripts.
+  try {
+    for (const [file] of query(db, `SELECT DISTINCT file FROM messages WHERE h IS NULL;`)) {
+      run(db, `UPDATE messages SET h='${esc(hostOfSessionFile(file))}' WHERE file=${esc(file)};`);
+    }
+  } catch { /* fresh or unreadable db */ }
+  // Drop the cache when the parser has moved on, so every transcript is read
+  // again and the new columns actually fill.
+  try {
+    const stored = query(db, `SELECT v FROM meta WHERE k='parser_version';`);
+    if (stored.length && stored[0][0] === PARSER_VERSION) return;
+    backupUsageDb(db);
+    run(db, `DELETE FROM messages;DELETE FROM files;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 [];
+  }
+}
+
+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 }> {
@@ -91,8 +207,8 @@ function readFiles(db: string): Record<string, { mtime: number; size: number }>
   return known;
 }
 
-// One parsed assistant message, as stored. `t` is epoch ms or null when the
-// source row carries no usable timestamp (live counts it, skips its recent).
+// 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;
@@ -106,11 +222,34 @@ interface StoredRow {
   code: number | undefined;
   note: string | undefined;
   tools: string[];
+  host?: string;
 }
 
-function parseFile(text: string): StoredRow[] {
+function parseFile(text: string, host?: 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({
+      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,
+    });
+    return rows;
+  }
   let codexProvider: string | null = null;
+  let codexModel: string | null = null;
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
@@ -120,6 +259,10 @@ function parseFile(text: string): StoredRow[] {
         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;
@@ -128,7 +271,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,
@@ -139,6 +282,7 @@ function parseFile(text: string): StoredRow[] {
           code: undefined,
           note: undefined,
           tools: [],
+          host,
         });
         continue;
       }
@@ -160,6 +304,7 @@ function parseFile(text: string): StoredRow[] {
         code: run.code,
         note,
         tools: parsed.tools ?? [],
+        host,
       });
     } catch { /* skip corrupt lines */ }
   }
@@ -167,33 +312,38 @@ 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 (` +
+  return `INSERT INTO messages (file, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h) VALUES (` +
     `${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)});`;
 }
 
-// Incremental sync: unchanged transcripts are skipped via mtime+size,
-// changed ones are deleted and re-inserted. Rows for deleted transcripts
-// are kept, so OMP session rotation never erases history. True on success
-// (including nothing-to-do), 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;
   try {
     db = usageDbPath();
     ensureSchema(db);
+    maybeScheduledBackup(db);
   } catch {
     return false;
   }
   const files: string[] = [];
+  const ocFiles: string[] = [];
   try {
-    walkJsonl(sessionsDir(), files, 2000);
+    for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
     if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
       walkJsonl(codexSessionsDir(), 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);
   const known = readFiles(db);
   const current: Record<string, { mtime: number; size: number }> = {};
   const changed: string[] = [];
@@ -236,7 +386,7 @@ export function syncUsageDb(): boolean {
     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))) {
         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;
@@ -257,12 +407,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 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] of rows) {
     const ts = t === '' ? undefined : Number(t);
     let toolNames: string[] = [];
     try {
@@ -291,6 +441,7 @@ export function readUsageDb(): StoredUsage | null {
         note: note === '' ? undefined : note,
       },
       toolNames,
+      h === '' ? undefined : h,
     );
   }
   accum.recent.sort((a, b) => b.t - a.t);

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.
+// Root command plus mode switches; sibling mirrors sync with no reload.
 import { getSharedComboState, reconcileSharedComboEntries, sessionEntries, } from '../shared/session-state.js';
+import { setExtensionLabel } from '../shared/host.js';
 import os from 'node:os';
 import path from 'node:path';
 import { appendUsage, readUsage } from '../shared/usage-ledger.js';
@@ -48,7 +45,7 @@ async function openDashboard(pi, ctx) {
     }
 }
 export default function tersioCommandsExtension(pi) {
-    pi.setLabel?.('Tersio unified root command');
+    setExtensionLabel(pi, 'Tersio unified root command');
     pi.registerCommand?.('tersio', {
         description: 'Tersio root: status|check|update|dashboard|usage|help',
         handler: async (args, ctx) => {