@krtclcdy/tersio 2.17.0 → 2.19.0

package/extensions/shared/usage-ledger.js

@@ -50,12 +50,39 @@ export function appendUsage(kind, detail) {
 function zeroBreakdown() {
     return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
-// Message-level generation time in ms. OMP writes `duration` (ms, float);
-// codex token_count rows carry none. Non-positive/non-finite → undefined
-// so renderers print – instead of a fake 0.0s.
-function durOf(v) {
+export function durOf(v) {
     return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
 }
+// Measured cost for one message. OMP writes usage.cost as
+// { input, output, cacheRead, cacheWrite, total }; a bare number shows up in
+// older fixtures. Anything else means "not recorded" — deliberately not 0, so
+// the dashboard can tell a genuinely free run from an unrecorded one.
+export function costOf(usage) {
+    const c = usage.cost;
+    if (typeof c === 'number')
+        return Number.isFinite(c) ? c : undefined;
+    if (c && typeof c === 'object') {
+        const total = c.total;
+        if (typeof total === 'number' && Number.isFinite(total))
+            return total;
+    }
+    return undefined;
+}
+// First line only: real messages carry multi-line provider errors, and this
+// ends up in a tooltip.
+export function statusOf(msg) {
+    const stop = typeof msg.stopReason === 'string' ? msg.stopReason : '';
+    const note = typeof msg.errorMessage === 'string' && msg.errorMessage.trim()
+        ? msg.errorMessage.split('\n')[0].trim().slice(0, 180)
+        : undefined;
+    if (stop === 'error' || msg.isError === true) {
+        const code = typeof msg.errorStatus === 'number' && Number.isFinite(msg.errorStatus) ? msg.errorStatus : undefined;
+        return { st: 'error', code, note };
+    }
+    if (stop === 'aborted')
+        return { st: 'aborted', note };
+    return { st: 'completed', note };
+}
 function addInto(into, u) {
     for (const k of ['input', 'output', 'cacheRead', 'cacheWrite']) {
         const v = u[k];
@@ -78,7 +105,7 @@ export function codexSessionsDir() {
         return path.join(codexHome, 'sessions');
     return path.join(os.homedir(), '.codex', 'sessions');
 }
-function dayKey(ts) {
+export function dayKey(ts) {
     const ms = typeof ts === 'number' ? ts : Date.parse(ts);
     if (!Number.isFinite(ms))
         return null;
@@ -86,7 +113,7 @@ function dayKey(ts) {
     const p = (n) => String(n).padStart(2, '0');
     return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
-function walkJsonl(dir, out, cap) {
+export function walkJsonl(dir, out, cap) {
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -104,16 +131,104 @@ function walkJsonl(dir, out, cap) {
             out.push(full);
     }
 }
-export function importSessionTokens() {
+// Recent requests are their own full-width table in the dashboard, so this is
+// a payload bound rather than a "few highlights" bound. Rows are small
+// (model, tokens, timing, status), so a few hundred cost little to ship.
+export const RECENT_LIMIT = 200;
+const FREE_SUFFIX = /(?::free|-free)$/i;
+export function newSessionAccum() {
+    return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
+}
+export function ingestSessionRow(accum, model, usage, ts, durMs, run, toolNames) {
     const watermark = readResetWatermark();
-    const byModel = {};
-    const byDay = {};
-    const byDayModel = {};
-    const byTool = {};
-    const byModelMessages = {};
-    const totals = zeroBreakdown();
-    let messages = 0;
-    let costMeasured = 0;
+    const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+    if (watermark > 0 && (!Number.isFinite(ms) || ms < watermark))
+        return false;
+    addInto(accum.totals, usage);
+    const key = model.replace(FREE_SUFFIX, '').toLowerCase();
+    accum.byModel[key] ??= zeroBreakdown();
+    addInto(accum.byModel[key], usage);
+    accum.byModelMessages[key] = (accum.byModelMessages[key] ?? 0) + 1;
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0);
+    if (Number.isFinite(ms)) {
+        const outcome = run ?? { st: 'completed' };
+        accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note });
+    }
+    const day = ts !== undefined ? dayKey(ts) : null;
+    if (day) {
+        accum.byDay[day] ??= zeroBreakdown();
+        addInto(accum.byDay[day], usage);
+        const sum = ['input', 'output', 'cacheRead', 'cacheWrite'].reduce((a, k) => a + (typeof usage[k] === 'number' && Number.isFinite(usage[k]) ? Math.floor(usage[k]) : 0), 0);
+        if (sum > 0) {
+            accum.byDayModel[day] ??= {};
+            accum.byDayModel[day][key] = (accum.byDayModel[day][key] ?? 0) + sum;
+        }
+    }
+    accum.messages += 1;
+    const measured = costOf(usage);
+    if (measured !== undefined)
+        accum.costMeasured += measured;
+    for (const name of toolNames ?? [])
+        accum.byTool[name] = (accum.byTool[name] ?? 0) + 1;
+    return true;
+}
+export function classifySessionLine(row) {
+    const payload = row.payload;
+    if (payload && typeof payload === 'object') {
+        if (row.type === 'session_meta' && typeof payload.model_provider === 'string')
+            return { kind: 'codex_provider', provider: payload.model_provider };
+        if (payload.type === 'token_count') {
+            const last = payload.info?.last_token_usage;
+            if (last) {
+                const provider = typeof payload.model_provider === 'string' ? payload.model_provider : undefined;
+                const ts = row.timestamp === undefined ? NaN : typeof row.timestamp === 'number' ? row.timestamp : Date.parse(row.timestamp);
+                return { kind: 'token_row', provider, model: 'codex', usage: { input: last['input_tokens'], output: last['output_tokens'], cacheRead: last['cached_input_tokens'], cacheWrite: last['cache_write_input_tokens'] }, ms: Number.isFinite(ts) ? ts : undefined };
+            }
+        }
+    }
+    const msg = row.message;
+    if (!msg || msg.role !== 'assistant' || !msg.usage)
+        return { kind: 'skip' };
+    const model = typeof msg.model === 'string' && msg.model ? msg.model : 'unknown';
+    const computedDur = (typeof msg.completedAt === 'number' && typeof msg.timestamp === 'number') ? msg.completedAt - msg.timestamp : undefined;
+    const tools = [];
+    for (const part of msg.content ?? []) {
+        if (part?.type === 'toolCall' && typeof part.name === 'string' && part.name) {
+            tools.push(part.name === 'bash' ? `bash:${leadBinary(part.arguments?.command)}` : part.name);
+        }
+    }
+    return { kind: 'assistant_row', model, usage: msg.usage, durMs: typeof msg.duration === 'number' ? msg.duration : computedDur, run: statusOf(msg), tools };
+}
+// Fold `:free`/`-free` suffixes and case variants into one chart key, so the
+// same model from two providers stops splitting into separate rows.
+export function canonicalModelId(model) {
+    return model.replace(FREE_SUFFIX, '').toLowerCase();
+}
+// LiteLLM-style display: namespace stays lowercase, model segments title-case
+// with version dots kept (`deepseek-v4.1-flash` → `Deepseek-V4.1-Flash`).
+export function displayModelId(model) {
+    const bare = model.replace(FREE_SUFFIX, '');
+    const cap = (s) => {
+        const low = s.toLowerCase();
+        if (low === 'openai')
+            return 'OpenAI';
+        if (low === 'ai')
+            return 'AI';
+        if (/^\d+[a-z]+$/.test(low))
+            return low.toUpperCase();
+        if (s.length <= 2)
+            return s.toUpperCase();
+        return s[0].toUpperCase() + s.slice(1).toLowerCase();
+    };
+    const seg = (s) => s.split('.').map(cap).join('.');
+    const words = (s) => s.split(/[-_:]+/).filter(Boolean).map(seg).join('-');
+    const slash = bare.indexOf('/');
+    if (slash >= 0)
+        return `${bare.slice(0, slash).toLowerCase()}/${words(bare.slice(slash + 1))}`;
+    return words(bare);
+}
+export function importSessionTokens() {
+    const accum = newSessionAccum();
     const files = [];
     walkJsonl(sessionsDir(), files, 2000);
     // A sessions override signals an isolated environment (tests, fixtures):
@@ -122,32 +237,6 @@ export function importSessionTokens() {
         walkJsonl(codexSessionsDir(), files, 2000);
     }
     let codexProvider = null;
-    const recent = [];
-    // Rows from before the reset watermark (and rows with no usable timestamp,
-    function ingest(model, usage, ts, durMs) {
-        const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
-        if (watermark > 0 && (!Number.isFinite(ms) || ms < watermark))
-            return false;
-        addInto(totals, usage);
-        byModel[model] ??= zeroBreakdown();
-        addInto(byModel[model], usage);
-        byModelMessages[model] = (byModelMessages[model] ?? 0) + 1;
-        const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0);
-        if (Number.isFinite(ms))
-            recent.push({ m: model, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), cr: num(usage.cacheRead), cw: num(usage.cacheWrite) });
-        const day = ts !== undefined ? dayKey(ts) : null;
-        if (day) {
-            byDay[day] ??= zeroBreakdown();
-            addInto(byDay[day], usage);
-            const sum = ['input', 'output', 'cacheRead', 'cacheWrite'].reduce((a, k) => a + (typeof usage[k] === 'number' && Number.isFinite(usage[k]) ? Math.floor(usage[k]) : 0), 0);
-            if (sum > 0) {
-                byDayModel[day] ??= {};
-                byDayModel[day][model] = (byDayModel[day][model] ?? 0) + sum;
-            }
-        }
-        messages += 1;
-        return true;
-    }
     for (const file of files) {
         let text;
         try {
@@ -156,56 +245,39 @@ export function importSessionTokens() {
         catch {
             continue;
         }
-        for (const line of text.split('\n')) {
-            if (!line.trim())
+        processSessionText(accum, { get codexProvider() { return codexProvider; }, set codexProvider(v) { codexProvider = v; } }, 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, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
+}
+export function processSessionText(accum, state, text) {
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            const parsed = classifySessionLine(row);
+            if (parsed.kind === 'codex_provider') {
+                if (parsed.provider)
+                    state.codexProvider = parsed.provider;
                 continue;
-            try {
-                const row = JSON.parse(line);
-                const codexRow = row;
-                const payload = codexRow.payload;
-                if (payload && typeof payload === 'object') {
-                    if (codexRow.type === 'session_meta' && typeof payload.model_provider === 'string') {
-                        codexProvider = payload.model_provider;
-                    }
-                    else if (payload.type === 'token_count') {
-                        const last = payload.info?.last_token_usage;
-                        if (last) {
-                            ingest(codexProvider ? `codex/${codexProvider}` : 'codex', {
-                                input: last['input_tokens'],
-                                output: last['output_tokens'],
-                                cacheRead: last['cached_input_tokens'],
-                                cacheWrite: last['cache_write_input_tokens'],
-                            }, row.timestamp);
-                            continue;
-                        }
-                    }
-                }
-                const msg = row.message;
-                if (!msg || msg.role !== 'assistant' || !msg.usage)
-                    continue;
-                const model = typeof msg.model === 'string' && msg.model ? msg.model : 'unknown';
-                const counted = ingest(model, msg.usage, row.timestamp, msg.duration);
-                if (counted && typeof msg.usage.cost === 'number' && Number.isFinite(msg.usage.cost))
-                    costMeasured += msg.usage.cost;
-                if (!counted)
-                    continue;
-                for (const part of msg.content ?? []) {
-                    if (part?.type === 'toolCall' && typeof part.name === 'string' && part.name) {
-                        const key = part.name === 'bash' ? `bash:${leadBinary(part.arguments?.command)}` : part.name;
-                        byTool[key] = (byTool[key] ?? 0) + 1;
-                    }
-                }
             }
-            catch { /* skip corrupt lines */ }
+            if (parsed.kind === 'token_row') {
+                const model = parsed.provider ? `codex/${parsed.provider}` : (state.codexProvider ? `codex/${state.codexProvider}` : 'codex');
+                ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, undefined, { st: 'completed' });
+                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);
         }
+        catch { /* skip corrupt lines */ }
     }
-    recent.sort((a, b) => b.t - a.t);
-    return { messages, totals, byModel, byDay, byDayModel, byTool, byModelMessages, costMeasured, recent: recent.slice(0, 25) };
 }
 // Lead binary of a shell string: first segment head past `cd` chains and
 // VAR=x assignments (`cd /x && git status` → `git`). Falls back to `bash`.
 const SKIP_HEADS = ['cd', 'echo', 'export', 'true', 'false'];
-function leadBinary(command) {
+export function leadBinary(command) {
     if (typeof command !== 'string' || !command.trim())
         return 'bash';
     for (const seg of command.split(/&&|;|\n|\|(?!\|)/)) {

package/extensions/shared/usage-store.js

@@ -0,0 +1,294 @@
+// 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.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { RECENT_LIMIT, canonicalModelId, classifySessionLine, codexSessionsDir, costOf, durOf, ingestSessionRow, newSessionAccum, sessionsDir, walkJsonl, } from './usage-ledger.js';
+export function usageDbPath() {
+    const override = process.env.TERSIO_USAGE_DB;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.omp', 'plugins', 'tersio-usage.db');
+}
+function esc(v) {
+    return `'${v.replace(/'/g, "''")}'`;
+}
+function intOf(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0;
+}
+function nullNum(v) {
+    return v === undefined ? 'NULL' : String(v);
+}
+function nullStr(v) {
+    return v === undefined ? 'NULL' : esc(v);
+}
+function run(db, sql) {
+    execFileSync('sqlite3', [db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: 30000 });
+}
+function query(db, sql) {
+    const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
+        encoding: 'utf8',
+        timeout: 30000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out
+        .split('\n')
+        .filter((line) => line.trim())
+        .map((line) => line.split('\t'));
+}
+function ensureSchema(db) {
+    fs.mkdirSync(path.dirname(db), { recursive: true });
+    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);`);
+}
+function readFiles(db) {
+    const known = {};
+    try {
+        for (const [p, mtime, size] of query(db, `SELECT path, mtime, size FROM files;`)) {
+            known[p] = { mtime: Number(mtime) || 0, size: Number(size) || 0 };
+        }
+    }
+    catch { /* fresh db */ }
+    return known;
+}
+function parseFile(text) {
+    const rows = [];
+    let codexProvider = null;
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            const parsed = classifySessionLine(row);
+            if (parsed.kind === 'codex_provider') {
+                if (parsed.provider)
+                    codexProvider = parsed.provider;
+                continue;
+            }
+            const ts = row.timestamp;
+            const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+            const t = Number.isFinite(ms) ? ms : null;
+            if (parsed.kind === 'token_row') {
+                const provider = parsed.provider ?? codexProvider;
+                const usage = parsed.usage ?? {};
+                rows.push({
+                    t,
+                    model: canonicalModelId(provider ? `codex/${provider}` : 'codex'),
+                    i: intOf(usage.input),
+                    o: intOf(usage.output),
+                    d: undefined,
+                    cr: intOf(usage.cacheRead),
+                    cw: intOf(usage.cacheWrite),
+                    usd: costOf(usage),
+                    st: 'completed',
+                    code: undefined,
+                    note: undefined,
+                    tools: [],
+                });
+                continue;
+            }
+            if (parsed.kind !== 'assistant_row' || !parsed.model || !parsed.usage)
+                continue;
+            const usage = parsed.usage;
+            const dur = durOf(parsed.durMs);
+            const run = parsed.run ?? { st: 'completed' };
+            const note = run.note?.replace(/[\t\n\r]/g, ' ').slice(0, 180);
+            rows.push({
+                t,
+                model: canonicalModelId(parsed.model),
+                i: intOf(usage.input),
+                o: intOf(usage.output),
+                d: dur,
+                cr: intOf(usage.cacheRead),
+                cw: intOf(usage.cacheWrite),
+                usd: costOf(usage),
+                st: run.st,
+                code: run.code,
+                note,
+                tools: parsed.tools ?? [],
+            });
+        }
+        catch { /* skip corrupt lines */ }
+    }
+    return rows;
+}
+function insertSql(file, r) {
+    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},` +
+        `${nullNum(r.d)},${r.cr},${r.cw},${nullNum(r.usd)},${esc(r.st)},` +
+        `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))});`;
+}
+// Incremental sync: unchanged transcripts are skipped via mtime+size, changed
+// ones are deleted and re-inserted, removed ones are dropped. True on success
+// (including nothing-to-do), false when sqlite3 or disk is unavailable.
+export function syncUsageDb() {
+    let db;
+    try {
+        db = usageDbPath();
+        ensureSchema(db);
+    }
+    catch {
+        return false;
+    }
+    const files = [];
+    try {
+        walkJsonl(sessionsDir(), files, 2000);
+        if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
+            walkJsonl(codexSessionsDir(), files, 2000);
+        }
+    }
+    catch {
+        return false;
+    }
+    const known = readFiles(db);
+    const current = {};
+    const changed = [];
+    for (const file of files) {
+        let st;
+        try {
+            st = fs.statSync(file);
+        }
+        catch {
+            continue;
+        }
+        const entry = { mtime: st.mtimeMs, size: st.size };
+        current[file] = entry;
+        const prev = known[file];
+        if (!prev || prev.mtime !== entry.mtime || prev.size !== entry.size)
+            changed.push(file);
+    }
+    const removed = Object.keys(known).filter((p) => current[p] === undefined);
+    if (!changed.length && !removed.length)
+        return true;
+    const chunks = [];
+    let chunkBytes = 0;
+    const flush = () => {
+        if (!chunks.length)
+            return true;
+        try {
+            run(db, `BEGIN;${chunks.join('')}COMMIT;`);
+        }
+        catch {
+            return false;
+        }
+        chunks.length = 0;
+        chunkBytes = 0;
+        return true;
+    };
+    const push = (sql) => {
+        chunks.push(sql);
+        chunkBytes += sql.length;
+        if (chunkBytes < 400_000)
+            return true;
+        return flush();
+    };
+    for (const file of [...changed, ...removed]) {
+        if (!push(`DELETE FROM messages WHERE file=${esc(file)};DELETE 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)) {
+                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;
+        }
+    }
+    catch {
+        return false;
+    }
+    if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('last_sync',${esc(String(Date.now()))});`))
+        return false;
+    return flush();
+}
+export function readUsageDb() {
+    const db = usageDbPath();
+    try {
+        if (!fs.existsSync(db))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    let rows;
+    try {
+        rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools FROM messages;`);
+    }
+    catch {
+        return null;
+    }
+    const accum = newSessionAccum();
+    for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools] of rows) {
+        const ts = t === '' ? undefined : Number(t);
+        let toolNames = [];
+        try {
+            const parsed = JSON.parse(tools || '[]');
+            if (Array.isArray(parsed))
+                toolNames = parsed.filter((x) => typeof x === 'string');
+        }
+        catch { /* keep empty */ }
+        const usage = {
+            input: Number(i) || 0,
+            output: Number(o) || 0,
+            cacheRead: Number(cr) || 0,
+            cacheWrite: Number(cw) || 0,
+        };
+        if (usd !== '') {
+            const measured = Number(usd);
+            if (Number.isFinite(measured))
+                usage.cost = measured;
+        }
+        ingestSessionRow(accum, model || 'unknown', usage, Number.isFinite(ts) ? ts : undefined, d === '' ? undefined : Number(d), {
+            st: st === 'error' || st === 'aborted' ? st : 'completed',
+            code: code === '' ? undefined : Number(code),
+            note: note === '' ? undefined : note,
+        }, toolNames);
+    }
+    accum.recent.sort((a, b) => b.t - a.t);
+    let syncedAt = 0;
+    try {
+        const meta = query(db, `SELECT v FROM meta WHERE k='last_sync';`);
+        if (meta.length)
+            syncedAt = Number(meta[0][0]) || 0;
+    }
+    catch { /* keep 0 */ }
+    return {
+        tokens: {
+            messages: accum.messages,
+            totals: accum.totals,
+            byModel: accum.byModel,
+            byDay: accum.byDay,
+            byDayModel: accum.byDayModel,
+            byTool: accum.byTool,
+            byModelMessages: accum.byModelMessages,
+            costMeasured: accum.costMeasured,
+            recent: accum.recent.slice(0, RECENT_LIMIT),
+        },
+        syncedAt,
+    };
+}
+// Delete the store file. Returns 1 when removed, 0 when already absent.
+export function clearUsageDb() {
+    try {
+        fs.unlinkSync(usageDbPath());
+        return 1;
+    }
+    catch {
+        return 0;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "description": "✂️ Token-saving OMP add-ons: terse Caveman replies, compact RTK shell output, lean Ponytail code calls — one-command combo presets.",
   "keywords": [
     "omp",
@@ -109,6 +109,23 @@
           "review"
         ],
         "default": "off"
+      },
+      "currency": {
+        "type": "enum",
+        "description": "Display currency for usage/gain reports (--currency overrides per run)",
+        "values": [
+          "USD",
+          "PHP",
+          "EUR",
+          "GBP",
+          "JPY",
+          "KRW",
+          "SGD",
+          "AUD",
+          "CAD",
+          "INR"
+        ],
+        "default": "USD"
       }
     }
   },

package/tersio.js

@@ -2,7 +2,7 @@
 // tersio.ts — Install Tersio (caveman/rtk/ponytail) add-ons on any OMP device.
 // Usage: node tersio.js [install|update|reinstall|doctor|uninstall|version|help] [options]
 // Requires: node/npm and omp CLI
-import { PACKAGE_BIN, PACKAGE_VERSION, applyUpdate, commandArg, gain, dashboardExport, dashboardOpen, dashboardPort, doctor, reset, showHelp, showVersion, uninstall, unknownCommand, update, usage, } from './cli/common.js';
+import { PACKAGE_BIN, PACKAGE_VERSION, applyUpdate, commandArg, gain, dashboardExport, dashboardOpen, dashboardPort, doctor, reset, settings, showHelp, showVersion, uninstall, unknownCommand, update, usage, } from './cli/common.js';
 import { closeRL } from './cli/interactive.js';
 import { runInstall } from './cli/install.js';
 import { runDoctor } from './cli/doctor.js';
@@ -10,6 +10,7 @@ import { runLatestUpdate } from './cli/update.js';
 import { runUninstall } from './cli/uninstall.js';
 import { runUsage } from './cli/usage.js';
 import { runReset } from './cli/reset.js';
+import { runSettings } from './cli/settings.js';
 import { runDashboard } from './cli/dashboard.js';
 function printHelp() {
     console.log(`Usage: ${PACKAGE_BIN} [command] [options]
@@ -22,6 +23,7 @@ Commands:
   usage        Ledger-backed usage + savings report
   gain         Open the gain dashboard (localhost only)
   reset        Clear tersio statistics (usage ledger)
+  settings     View/change session-start defaults (combo, caveman, rtk, ponytail)
   uninstall    Remove the managed extensions
   version      Print the package version
   help         Show this help
@@ -40,6 +42,7 @@ Options:
   --port <n> (gain: pin port, default ephemeral)
   --open (gain: open browser)
   --export <file> (gain: write HTML file instead of serving)
+  --currency <code> (usage|gain: display currency; flag wins, then tersio settings default, then USD)
   --version, -v
   --help, -h`);
 }
@@ -86,6 +89,10 @@ async function main() {
         closeRL();
         return;
     }
+    if (settings) {
+        await runSettings();
+        return;
+    }
     if (uninstall) {
         await runUninstall();
         closeRL();