@krtclcdy/tersio 2.25.3 → 2.25.5

package/extensions/shared/usage-ledger.ts

@@ -1,7 +1,7 @@
 // Shared usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and the Dashboard. Best-effort; corrupt lines are skipped on read.
 import fs from 'node:fs';
 import path from 'node:path';
-import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
+import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from './utils.ts';
 import { execFileSync } from 'node:child_process';
 
 export type UsageKind = 'command' | 'toggle' | 'install' | 'update' | 'rtk-audit';
@@ -89,6 +89,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[];
 }
@@ -292,15 +300,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): 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 +332,30 @@ 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 });
+    // The store holds every message ever recorded, but only the newest few are ever read. Skip
+    // anything older than the floor, and re-read the floor when the list is full, so a 50k-row
+    // store costs 2000 rows of memory instead of 50k.
+    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), 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,7 +369,11 @@ 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;
 }
@@ -428,14 +470,14 @@ export function processOpencodeFile(accum: SessionAccum, text: string, file?: st
   const parsed = classifyOpencodeMessage(obj as OpencodeMessage);
   if (!parsed) return;
   const id = file ? path.basename(file).replace(/\.[^.]+$/, '') || undefined : undefined;
-  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, undefined, 'opencode', id);
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, undefined, 'opencode', id, 'main');
 }
 
 // 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 }, undefined, 'opencode', row.id, 'main');
 }
 
 // Fold `:free`/`-free` suffixes and case variants into one chart key.
@@ -560,10 +602,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 +617,21 @@ export function hostOfSessionFile(file: string): string {
   return 'pi';
 }
 
+// Which agent ran a session file, from its own `session` row: a transcript with a parent
+// session is a subagent's, and everything else is the main agent. The row is the host's own
+// record, so a mirrored transcript carries the same answer as the stats database.
+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 +702,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 +721,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);
     } catch { /* skip corrupt lines */ }
   }
 }
@@ -706,17 +763,32 @@ export function leadBinary(command: unknown): string {
 }
 
 // --- Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table) ---
-import { DEFAULT_PRICE, canonicalPriceId, priceFor, refreshPricesIfStale } from './pricing.ts';
+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 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 };
+export type { PriceHit, PriceTier, ModelPrice };
+
+/**
+ * Price one model's tokens. `measured` is the cost the host reported for those tokens; it outranks
+ * every rate card, because it is the only figure from the party that billed. Pass undefined rather
+ * than 0 for a cost nobody reported: `costOf` keeps the two apart.
+ */
+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 +797,10 @@ export function usdCost(t: TokenBreakdown, model?: string): { usd: number; price
   };
   return {
     usd: buckets.input + buckets.output + buckets.cacheRead + buckets.cacheWrite,
-    priced: model ? known : false,
+    // A tier the caller cannot stand behind is not a price. `tail` and `default` are estimates,
+    // and a report that sums them beside measured cost reads as a bill it is not.
+    priced: PRICE_TIERS_FIRM.includes(hit.tier),
+    tier: hit.tier,
     buckets,
   };
 }

package/extensions/shared/usage-store.ts

@@ -8,14 +8,13 @@ import {
   SQLITE_READ_BUFFER,
   canonicalModelId,
   classifySessionLine,
-  OpencodeMessage,
   classifyOpencodeMessage,
   costOf,
   durOf,
+  agentOfSessionText,
   hostOfSessionFile,
   ingestSessionRow,
   messageRowId,
-  OpencodeDbRow,
   OPENCODE_DB_OVERLAP_MS,
   opencodeDbPath,
   opencodeSessionsDir,
@@ -24,10 +23,10 @@ import {
   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;
@@ -75,7 +74,7 @@ function query(db: string, sql: string): string[][] {
 }
 
 // Bump on a parse change: unchanged transcripts are never re-read.
-const PARSER_VERSION = '11';
+const PARSER_VERSION = '12';
 
 // 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;
@@ -92,8 +91,27 @@ const SCHEMA_SQL =
   `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);`;
+  ` 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 each read
+  // walks the whole table: the watermark scan, the day buckets, and the recent list all scan.
+  `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 plus a checkpoint at the end of a sync: the write path stops paying an fsync per commit,
+ * and the main file still holds every row, so a backup that copies only usage.db loses nothing.
+ */
+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 +122,14 @@ function storedParserVersion(db: string): string | null {
   }
 }
 
+// A store written by a newer tersio: this code has no forward migration, so a re-parse would swap rotated history for whatever transcripts are 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;`);
@@ -156,7 +182,7 @@ function migrateInPlace(db: string, preCount: number): boolean {
       `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);` +
+      ` 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 +199,29 @@ function migrateInPlace(db: string, preCount: number): boolean {
   }
 }
 
+// v12 shape gains the agent kind (`main`, `subagent`) with a bare ALTER for the two names the
+// store already holds. No rows move and no re-parse is forced, so the existing rows read
+// `NULL` for it: a report then shows them under the main agent only, and new rows carry it.
+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;
+  }
+}
+
+// v12 shape gains the agent kind (`main`, `subagent`) with a bare ALTER: no rows move, so no
+// re-parse is forced. Existing rows read NULL, which a report folds under the main agent.
+function addAgentColumn(db: string): boolean {
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN a TEXT;`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
 // 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 +241,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 +268,12 @@ 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 on the current shape: adding it keeps every row, and the
+    // unchanged transcripts that already hold their rows simply 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;
+    }
     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 */ }
@@ -335,10 +396,13 @@ 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.
+// OpenCode rows carry no status, code, note, tool list, or subagent marker: only tokens and the
+// msg id. They record as the main agent, so a store never holds a NULL kind.
 function opencodeStoredRow(oc: NonNullable<ReturnType<typeof classifyOpencodeMessage>>, host: string | undefined, id: string | undefined): StoredRow {
   return {
     t: oc.ms ?? null,
@@ -354,11 +418,12 @@ function opencodeStoredRow(oc: NonNullable<ReturnType<typeof classifyOpencodeMes
     note: undefined,
     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;
@@ -403,6 +468,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
           note: undefined,
           tools: [],
           host,
+          agent,
           id: rid,
         });
         continue;
@@ -426,6 +492,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
         note,
         tools: parsed.tools ?? [],
         host,
+        agent,
         id: rid,
       });
     } catch { /* skip corrupt lines */ }
@@ -434,10 +501,10 @@ 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, 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.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.
@@ -449,11 +516,14 @@ 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);
     maybeScheduledBackup(db);
   } catch {
     return false;
@@ -526,7 +596,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;
       }
     }
@@ -561,6 +631,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 +645,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 `tools` column is the widest by far and the common case is the literal `[]`, so it is
+    // read as one column and skipped in JS rather than parsed per row. A store written before
+    // the agent column does not hold it, so the row is read without that column.
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    const agentCol = names.includes('a') ? 'a' : "''";
+    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, ${agentCol}, id 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] 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 +688,7 @@ export function readUsageDb(): StoredUsage | null {
       toolNames,
       h === '' ? undefined : h,
       id === '' || id === undefined ? undefined : id,
+      a === '' ? undefined : a,
     );
   }
   accum.recent.sort((a, b) => b.t - a.t);
@@ -627,6 +707,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

@@ -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; });

package/extensions/{ai-addons-updater → updater}/index.ts

@@ -2,6 +2,7 @@
 
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -12,35 +13,44 @@ import {
   CAVEMAN_REMOTE_ULTRA,
   CAVEMAN_REMOTE_MEGACAVE,
   RTK_RELEASE_API,
-  RtkRelease,
   fetchJson,
   findFile,
   findHoistedPackage,
   httpsGet,
   httpsDownload,
-  isPiProcess,
   sha256Hex,
   parseChecksum,
   normalizeRtkVersion,
   readTextIfExists,
   rtkPlatformSpec,
   resolveRtkBinary,
-} from '../lib/utils.ts';
+} from '../shared/utils.ts';
+import type { RtkRelease } from '../shared/utils.ts';
 
 const IS_WINDOWS = process.platform === 'win32';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
 const RTK_BINARY = resolveRtkBinary();
-// Beside this file, not a host path: these are the rules /caveman reads.
-const cavemanRule = (name: string) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+// Beside this file, not a host path: these are the rules /caveman reads. A retired
+// agent-tree copy has no `caveman` sibling, so the OMP plugin install is the
+// fallback: it is the one the plugin manifest loads from.
+const CAVEMAN_SIBLING = (name: string): string => path.join(EXTENSION_DIR, '..', 'caveman', name);
+
+function cavemanRule(name: string): string {
+  const beside = CAVEMAN_SIBLING(name);
+  if (fsSync.existsSync(beside)) return beside;
+  const plugin = path.join(os.homedir(), '.omp', 'plugins', 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman', name);
+  return fsSync.existsSync(plugin) ? plugin : beside;
+}
+
 const CAVEMAN_LOCAL = cavemanRule('rule.md');
 const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string }> = [
   { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },
   { file: cavemanRule('rule-megacave.md'), remote: CAVEMAN_REMOTE_MEGACAVE },
 ];
-const HOST_NAME = isPiProcess() ? 'Pi' : 'OMP';
-const RELOAD_MSG = `Reminder: restart ${HOST_NAME} (or reload extensions) for updates to take effect.`;
+// Host-neutral: this updater runs inside pi, OMP, and OpenCode alike.
+const RELOAD_MSG = 'Reminder: restart your agent (or reload extensions) for updates to take effect.';
 
 // Ponytail is a hoisted dependency, so the installed copy is found by walking up rather than by naming a host directory.
 function ponytailLocal(): string | null {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.25.3",
+  "version": "2.25.5",
   "description": "✂️ Token saver and usage tracker for coding agents: terse Caveman replies, compact RTK shell output, lean Ponytail code calls, and a gain dashboard — one-command combo presets over one shared extension tree.",
   "keywords": [
     "token-saving",
@@ -24,16 +24,17 @@
     "tersio": "dist/tersio.js"
   },
   "exports": {
-    "./server": "./dist/extensions/opencode/server.js"
+    "./server": "./dist/extensions/server.js"
   },
   "omp": {
     "name": "Tersio",
     "description": "Toggleable Caveman/RTK/Ponytail session modes with Combo presets",
     "extensions": [
-      "./extensions/caveman-session/index.ts",
-      "./extensions/rtk-session/index.ts",
-      "./extensions/combo-toggle/index.ts",
-      "./extensions/tersio-commands/index.ts"
+      "./extensions/caveman/index.ts",
+      "./extensions/rtk/session.ts",
+      "./extensions/rtk/filter.ts",
+      "./extensions/combo/index.ts",
+      "./extensions/commands/index.ts"
     ],
     "skills": [
       "./node_modules/@dietrichgebert/ponytail/skills"
@@ -43,7 +44,7 @@
         "description": "In-session updater for Ponytail, RTK, and Caveman (/ai-addons)",
         "default": true,
         "extensions": [
-          "./extensions/ai-addons-updater/index.ts"
+          "./extensions/updater/index.ts"
         ]
       }
     },
@@ -115,16 +116,16 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/extensions/caveman-session/*.md",
+    "dist/extensions/caveman/*.md",
     "dashboard/dist/**/*",
     "extensions/**/*.ts",
-    "extensions/caveman-session/rule.md",
-    "extensions/caveman-session/rule-ultra.md",
-    "extensions/caveman-session/rule-megacave.md"
+    "extensions/caveman/rule.md",
+    "extensions/caveman/rule-ultra.md",
+    "extensions/caveman/rule-megacave.md"
   ],
   "scripts": {
     "clean": "rm -rf dist dashboard/dist",
-    "build": "tsc && bun run build:dashboard && cp extensions/caveman-session/*.md dist/extensions/caveman-session/",
+    "build": "tsc && bun run build:dashboard && cp extensions/caveman/*.md dist/extensions/caveman/",
     "build:dashboard": "bun install --cwd dashboard/app --frozen-lockfile && bun run --cwd dashboard/app build",
     "prepublishOnly": "bun run build",
     "check": "tsc --noEmit",