@krtclcdy/tersio 2.9.0 → 2.11.0

package/extensions/shared/carbon.js

@@ -0,0 +1,88 @@
+// extensions/shared/carbon.ts — CO2/energy footprints, EcoLogits-style.
+//
+// Port of the EcoLogits v0.8.2 LLM impact model (genai-impact/ecologits,
+// MPL-2.0 — see ECO_NOTICE.md), following the same served-estimate approach
+// as honey-for-devs' hooks/eco.js: the faithful single-stream (batch-1)
+// ceiling divided by serving_concurrency for continuous-batching amortization.
+//
+// Model params come from EcoLogits' registry where it covers the model;
+// otherwise a documented class borrow (never a silent guess — every borrow
+// carries its source). Unknown ids fall to the gpt-4o default. Everything
+// rendered from here must carry ~est. and never merge with measured figures.
+// EcoLogits 0.8.2 constants — kWh, kgCO2eq, seconds, GB.
+const Q_BITS = 4;
+const E_ALPHA = 8.91e-8;
+const E_BETA = 1.43e-6;
+const L_ALPHA = 8.02e-4;
+const L_BETA = 2.23e-2;
+const GPU_MEM = 80;
+const GPU_EMB_GWP = 143;
+const SRV_GPUS = 8;
+const SRV_POWER = 1;
+const SRV_EMB_GWP = 3000;
+const LIFETIME = 5 * 365 * 24 * 3600;
+const PUE = 1.2;
+// Per-provider grid intensity, gCO2eq/kWh (location-based research values).
+const GRIDS = {
+    anthropic: 500,
+    openai: 400,
+    google: 330,
+    default: 450,
+};
+// Serving amortization: single-stream ceiling ÷ concurrency ≈ served impact.
+export const SERVING_CONCURRENCY = 32;
+// Registry values verbatim from EcoLogits' model_repository; borrows cite
+// the public param disclosure they stand in for (MoE active/total).
+const TABLE = [
+    { match: 'opus', active: 625.0, total: 2000, provider: 'anthropic', source: 'registry' },
+    { match: 'sonnet', active: 137.5, total: 440, provider: 'anthropic', source: 'registry' },
+    { match: 'haiku', active: 18.0, total: 18.0, provider: 'anthropic', source: 'registry' },
+    { match: 'gpt-5', active: 93.75, total: 300, provider: 'openai', source: 'registry' },
+    { match: 'gpt', active: 137.5, total: 440, provider: 'openai', source: 'registry' },
+    { match: 'gemini', active: 137.5, total: 440, provider: 'google', source: 'registry' },
+    { match: 'deepseek', active: 37, total: 671, provider: 'default', source: 'borrowed' },
+    { match: 'qwen', active: 22, total: 235, provider: 'default', source: 'borrowed' },
+    { match: 'glm', active: 37, total: 671, provider: 'default', source: 'borrowed' },
+    { match: 'kimi', active: 32, total: 1000, provider: 'default', source: 'borrowed' },
+    { match: 'muse', active: 70, total: 70, provider: 'default', source: 'borrowed' },
+    { match: 'flash', active: 18.0, total: 18.0, provider: 'default', source: 'borrowed' },
+];
+const DEFAULT_ENTRY = { active: 137.5, total: 440, provider: 'openai' };
+export function carbonParamsFor(model) {
+    const name = model.toLowerCase();
+    for (const row of TABLE) {
+        if (row.match && name.includes(row.match)) {
+            return { activeB: row.active, totalB: row.total, provider: row.provider, source: row.source };
+        }
+    }
+    return { activeB: DEFAULT_ENTRY.active, totalB: DEFAULT_ENTRY.total, provider: DEFAULT_ENTRY.provider, source: 'default' };
+}
+function impacts(activeB, totalB, outTokens, gridKg) {
+    const gpuEnergy = outTokens * (E_ALPHA * activeB + E_BETA);
+    const latency = outTokens * (L_ALPHA * activeB + L_BETA);
+    const gpuCount = Math.ceil(((1.2 * totalB * Q_BITS) / 8 / GPU_MEM));
+    const serverEnergy = (latency / 3600) * SRV_POWER * (gpuCount / SRV_GPUS);
+    const energyKwh = PUE * (serverEnergy + gpuCount * gpuEnergy);
+    const embGwp = (latency / LIFETIME) * ((gpuCount / SRV_GPUS) * SRV_EMB_GWP + gpuCount * GPU_EMB_GWP);
+    return { energyKwh, gco2: (energyKwh * gridKg + embGwp) * 1000 };
+}
+export function footprintFor(model, outputTokens) {
+    const p = carbonParamsFor(model);
+    const gridKg = (GRIDS[p.provider] ?? GRIDS.default) / 1000;
+    const ceiling = impacts(p.activeB, p.totalB, Math.max(0, Math.floor(outputTokens)), gridKg);
+    const b = SERVING_CONCURRENCY > 0 ? SERVING_CONCURRENCY : 1;
+    return {
+        energyWh: (ceiling.energyKwh / b) * 1000,
+        gco2: ceiling.gco2 / b,
+        gco2Ceiling: ceiling.gco2,
+        concurrency: b,
+        provider: p.provider,
+        paramSource: p.source,
+    };
+}
+export function co2GramsFor(model, outputTokens) {
+    return footprintFor(model, outputTokens).gco2;
+}
+export function energyWhFor(model, outputTokens) {
+    return footprintFor(model, outputTokens).energyWh;
+}

package/extensions/shared/pricing.js

@@ -0,0 +1,121 @@
+// extensions/shared/pricing.ts — model pricing with live LiteLLM refresh.
+// Lookup order: exact id in the live cache → built-in substring table → default.
+// Network only in refreshPrices (called from `tersio update`); every reader is
+// sync and offline-safe. Best-effort throughout: pricing never breaks a caller.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+// Rough list rates (USD per 1M tokens) for the models OMP sessions cite.
+// Refresh against LiteLLM pricing data when adding families.
+const PRICE_TABLE = [
+    { match: ':free', price: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+    { match: 'opus', price: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 } },
+    { match: 'sonnet', price: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 } },
+    { match: 'haiku', price: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 } },
+    { match: 'gpt', price: { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 2.5 } },
+    { match: 'gemini', price: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 1.25 } },
+    { match: 'glm', price: { input: 0.5, output: 1, cacheRead: 0.05, cacheWrite: 0.5 } },
+];
+export const DEFAULT_PRICE = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
+const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
+const KEEP_RE = /claude|sonnet|opus|haiku|gpt|gemini|glm|deepseek|qwen|kimi|mistral|grok|llama|muse|nemotron|ministral|codestral|qwen/i;
+export function pricesCachePath() {
+    const override = process.env.TERSIO_PRICES_FILE;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.omp', 'plugins', 'tersio-prices.json');
+}
+export function pricesUrl() {
+    return process.env.TERSIO_PRICES_URL || LITELLM_URL;
+}
+export function loadLivePrices() {
+    let raw;
+    try {
+        raw = fs.readFileSync(pricesCachePath(), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.fetchedAt !== 'number' || !parsed.exact || typeof parsed.exact !== 'object')
+            return null;
+        if (Date.now() - parsed.fetchedAt > CACHE_TTL_MS)
+            return null;
+        return { fetchedAt: parsed.fetchedAt, exact: parsed.exact };
+    }
+    catch {
+        return null;
+    }
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : null;
+}
+export function priceFor(model, live) {
+    const table = live === undefined ? loadLivePrices() : live;
+    if (table) {
+        const hit = table.exact[model] ?? table.exact[model.toLowerCase()];
+        if (hit && [hit.input, hit.output, hit.cacheRead, hit.cacheWrite].every((v) => typeof v === 'number')) {
+            return { price: hit, known: true, live: true };
+        }
+    }
+    const name = model.toLowerCase();
+    for (const row of PRICE_TABLE) {
+        if (name.includes(row.match))
+            return { price: row.price, known: true, live: false };
+    }
+    return { price: DEFAULT_PRICE, known: false, live: false };
+}
+// Fetch LiteLLM pricing, keep relevant families, write the cache. False on
+// any failure (offline, timeout, shape change) — callers fall back silently.
+export async function refreshPrices() {
+    let res;
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 15000);
+        try {
+            res = await fetch(pricesUrl(), { signal: ctl.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!res.ok)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    let data;
+    try {
+        data = (await res.json());
+    }
+    catch {
+        return false;
+    }
+    const exact = {};
+    for (const [id, row] of Object.entries(data)) {
+        if (!row || typeof row !== 'object' || !KEEP_RE.test(id))
+            continue;
+        const input = num(row.input_cost_per_token);
+        const output = num(row.output_cost_per_token);
+        if (input === null || output === null)
+            continue;
+        exact[id] = {
+            input: input * 1e6,
+            output: output * 1e6,
+            cacheRead: (num(row.cache_read_input_token_cost) ?? input) * 1e6,
+            cacheWrite: (num(row.cache_creation_input_token_cost) ?? input) * 1e6,
+        };
+    }
+    if (!Object.keys(exact).length)
+        return false;
+    try {
+        fs.mkdirSync(path.dirname(pricesCachePath()), { recursive: true });
+        fs.writeFileSync(pricesCachePath(), JSON.stringify({ fetchedAt: Date.now(), exact }), 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/extensions/shared/rtk-gain.js

@@ -0,0 +1,61 @@
+// extensions/shared/rtk-gain.ts — measured RTK savings from its own store.
+// RTK records every invocation (input/output/saved tokens, savings %, exec
+// time) in history.db; `rtk gain` renders the same rows. We read them with
+// the sqlite3 CLI (present on macOS; best-effort elsewhere) so the dashboard
+// shows measured figures, never estimates. Missing DB/CLI → empty, no throw.
+//
+// Caveman and Ponytail have no per-command counters (instruction-following
+// isn't metered); their gains are bench-measured in BENCHMARK.md and cited
+// as static figures wherever RTK rows appear.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const EMPTY = { commands: 0, saved: 0, input: 0, avgPct: 0, totalMs: 0, byCommand: [] };
+export function rtkDbPath() {
+    const override = process.env.TERSIO_RTK_DB;
+    if (override)
+        return override;
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'rtk', 'history.db');
+    }
+    const xdg = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+    return path.join(xdg, 'rtk', 'history.db');
+}
+function query(db, sql) {
+    const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
+        encoding: 'utf8',
+        timeout: 5000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out
+        .split('\n')
+        .filter((line) => line.trim())
+        .map((line) => line.split('\t'));
+}
+export function readRtkGain(limit = 10) {
+    try {
+        if (!fs.existsSync(rtkDbPath()))
+            return EMPTY;
+        const [[commands = '0', saved = '0', input = '0', avgPct = '0', totalMs = '0'] = []] = query(rtkDbPath(), 'SELECT COUNT(*), COALESCE(SUM(saved_tokens),0), COALESCE(SUM(input_tokens),0), COALESCE(AVG(savings_pct),0), COALESCE(SUM(exec_time_ms),0) FROM commands;');
+        const byCommand = query(rtkDbPath(), `SELECT rtk_cmd, COUNT(*), SUM(saved_tokens), AVG(savings_pct), AVG(exec_time_ms) FROM commands GROUP BY rtk_cmd ORDER BY SUM(saved_tokens) DESC LIMIT ${Math.max(1, Math.floor(limit))};`).map(([command, count, savedRow, pct, ms]) => ({
+            command,
+            count: Number(count) || 0,
+            saved: Number(savedRow) || 0,
+            avgPct: Number(pct) || 0,
+            avgMs: Number(ms) || 0,
+        }));
+        const totalIn = Number(input) || 0;
+        return {
+            commands: Number(commands) || 0,
+            saved: Number(saved) || 0,
+            input: totalIn,
+            avgPct: totalIn ? ((Number(saved) || 0) / totalIn) * 100 : 0,
+            totalMs: Number(totalMs) || 0,
+            byCommand,
+        };
+    }
+    catch {
+        return EMPTY;
+    }
+}

package/extensions/shared/session-state.js

@@ -49,12 +49,13 @@ function bridge() {
     if (existing?.state)
         return existing;
     const initial = normalizedState((existing || COMBO_LEVELS.off));
-    return (globalThis[BRIDGE_KEY] = { state: initial, listener: null });
+    return (globalThis[BRIDGE_KEY] = { state: initial, listeners: new Set() });
 }
 function publish(state) {
     const shared = bridge();
     shared.state = state;
-    shared.listener?.(state);
+    for (const listener of shared.listeners)
+        listener(state);
     return state;
 }
 export function normalizeInputCommand(value) {
@@ -148,7 +149,13 @@ export function activeModesSummary(state) {
     return `caveman=${state.caveman.toUpperCase()}, rtk=${state.rtk.toUpperCase()}, ponytail=${state.ponytail.toUpperCase()}`;
 }
 export function setSharedComboListener(listener) {
-    bridge().listener = typeof listener === 'function' ? listener : null;
+    // Additive: every sibling extension syncs its local mirror on publish, so
+    // a /tersio or /combo switch takes effect next turn with no session reload.
+    // A null listener clears all (no current callers; reserved for teardown).
+    if (typeof listener === 'function')
+        bridge().listeners.add(listener);
+    else
+        bridge().listeners.clear();
 }
 export function resetSharedComboState() {
     return setSharedComboLevel('off');

package/extensions/shared/usage-ledger.js

@@ -35,6 +35,15 @@ export function sessionsDir() {
         return override;
     return path.join(os.homedir(), '.omp', 'agent', 'sessions');
 }
+export function codexSessionsDir() {
+    const override = process.env.TERSIO_CODEX_DIR;
+    if (override)
+        return override;
+    const codexHome = process.env.CODEX_HOME;
+    if (codexHome)
+        return path.join(codexHome, 'sessions');
+    return path.join(os.homedir(), '.codex', 'sessions');
+}
 function dayKey(ts) {
     const ms = typeof ts === 'number' ? ts : Date.parse(ts);
     if (!Number.isFinite(ms))
@@ -66,11 +75,40 @@ export function importSessionTokens() {
     const byDay = {};
     const byDayModel = {};
     const byTool = {};
+    const byModelMessages = {};
     const totals = zeroBreakdown();
     let messages = 0;
     let costMeasured = 0;
     const files = [];
     walkJsonl(sessionsDir(), files, 2000);
+    // A sessions override signals an isolated environment (tests, fixtures):
+    // only walk the real codex dir when it is explicitly set.
+    if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
+        walkJsonl(codexSessionsDir(), files, 2000);
+    }
+    let codexProvider = null;
+    const recent = [];
+    function ingest(model, usage, ts) {
+        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);
+        const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+        if (Number.isFinite(ms))
+            recent.push({ m: model, i: num(usage.input), o: num(usage.output), t: ms });
+        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;
+    }
     for (const file of files) {
         let text;
         try {
@@ -84,24 +122,30 @@ export function importSessionTokens() {
                 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';
-                addInto(totals, msg.usage);
-                byModel[model] ??= zeroBreakdown();
-                addInto(byModel[model], msg.usage);
-                const day = row.timestamp !== undefined ? dayKey(row.timestamp) : null;
-                if (day) {
-                    byDay[day] ??= zeroBreakdown();
-                    addInto(byDay[day], msg.usage);
-                    const n = msg.usage;
-                    const sum = ['input', 'output', 'cacheRead', 'cacheWrite'].reduce((a, k) => a + (typeof n[k] === 'number' && Number.isFinite(n[k]) ? Math.floor(n[k]) : 0), 0);
-                    if (sum > 0) {
-                        byDayModel[day] ??= {};
-                        byDayModel[day][model] = (byDayModel[day][model] ?? 0) + sum;
-                    }
-                }
+                ingest(model, msg.usage, row.timestamp);
                 if (typeof msg.usage.cost === 'number' && Number.isFinite(msg.usage.cost))
                     costMeasured += msg.usage.cost;
                 for (const part of msg.content ?? []) {
@@ -110,12 +154,12 @@ export function importSessionTokens() {
                         byTool[key] = (byTool[key] ?? 0) + 1;
                     }
                 }
-                messages += 1;
             }
             catch { /* skip corrupt lines */ }
         }
     }
-    return { messages, totals, byModel, byDay, byDayModel, byTool, costMeasured };
+    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`.
@@ -134,24 +178,11 @@ function leadBinary(command) {
     }
     return 'bash';
 }
-const PRICE_TABLE = [
-    { match: ':free', price: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
-    { match: 'opus', price: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 } },
-    { match: 'sonnet', price: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 } },
-    { match: 'haiku', price: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 } },
-    { match: 'gpt', price: { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 2.5 } },
-    { match: 'gemini', price: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 1.25 } },
-    { match: 'glm', price: { input: 0.5, output: 1, cacheRead: 0.05, cacheWrite: 0.5 } },
-];
-const DEFAULT_PRICE = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
-export function priceFor(model) {
-    const name = model.toLowerCase();
-    for (const row of PRICE_TABLE) {
-        if (name.includes(row.match))
-            return { price: row.price, known: true };
-    }
-    return { price: DEFAULT_PRICE, known: false };
-}
+// --- Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table) ---
+import { DEFAULT_PRICE, priceFor } from './pricing.js';
+import { co2GramsFor, energyWhFor } from './carbon.js';
+export { DEFAULT_PRICE, priceFor };
+export { co2GramsFor, energyWhFor };
 export function usdCost(t, model) {
     const { price, known } = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false };
     const m = 1 / 1_000_000;
@@ -160,11 +191,13 @@ export function usdCost(t, model) {
         priced: model ? known : false,
     };
 }
-// ponytail: CO2 is a rough server-energy multiple on output tokens, not metered.
+// CO2 now model-differentiated via ./carbon.ts (EcoLogits 0.8.2 port).
 // Always render with ~est. and never merge with measured figures.
+// The constant below is the served gCO2eq per 1K output tokens for the
+// default (gpt-4o-class) model, kept so single-figure callers stay honest.
 export const CO2_G_PER_1K_OUTPUT = 0.2;
-export function co2Grams(outputTokens) {
-    return (outputTokens / 1000) * CO2_G_PER_1K_OUTPUT;
+export function co2Grams(outputTokens, model) {
+    return co2GramsFor(model ?? 'gpt-4o', outputTokens);
 }
 export function readUsage() {
     let text;
@@ -188,3 +221,14 @@ export function readUsage() {
     }
     return rows;
 }
+// Delete the ledger file. Returns the rows cleared (0 when already absent).
+// Only tersio-owned data lives here; session transcripts and the RTK
+// database are never touched.
+export function clearUsageLedger() {
+    const rows = readUsage().length;
+    try {
+        fs.unlinkSync(ledgerPath());
+    }
+    catch { /* already absent */ }
+    return rows;
+}

package/extensions/tersio-commands/index.js

@@ -1,8 +1,8 @@
 // /tersio unified root command — routes every tersio capability through one
 // namespaced entrypoint. Aliases (/caveman, /rtk, /combo, /ai-addons) keep
 // working: this router drives the same shared bridge + session entries the
-// sibling extensions restore from, then reloads so their local mirrors sync
-// (same mechanism /combo already uses to drive its siblings).
+// sibling extensions restore from. Shared-state publishes sync their local
+// mirrors live, so switches notify and take effect next turn — no reload.
 import { COMBO_LEVELS, activeModesSummary, getSharedComboState, normalizeComboLevel, normalizeMode, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboMode, } from '../shared/session-state.js';
 import os from 'node:os';
 import path from 'node:path';
@@ -56,10 +56,9 @@ async function openGainDashboard(pi, ctx) {
 }
 export default function tersioCommandsExtension(pi) {
     pi.setLabel?.('Tersio unified root command');
-    async function reload(ctx) {
-        if (ctx?.reload)
-            await ctx.reload();
-    }
+    // Mode switches never reload the session: entries persist, the shared
+    // bridge publishes to every sibling mirror, and the change injects on the
+    // next turn like a normal input message. Only notify below.
     pi.registerCommand?.('tersio', {
         description: 'Tersio root: caveman|combo|rtk|ponytail|status|check|update|gain|usage|help',
         handler: async (args, ctx) => {
@@ -86,7 +85,6 @@ export default function tersioCommandsExtension(pi) {
                 setSharedComboMode('caveman', mode);
                 appendUsage('toggle', `caveman=${mode}`);
                 ctx?.ui?.notify?.(`Caveman ${mode} on — Active: ${activeModesSummary(getSharedComboState())}.`, 'info');
-                await reload(ctx);
                 return;
             }
             if (sub === 'rtk') {
@@ -104,7 +102,6 @@ export default function tersioCommandsExtension(pi) {
                 setSharedComboMode('rtk', enabled);
                 appendUsage('toggle', `rtk=${rest}`);
                 ctx?.ui?.notify?.(`RTK ${rest} — Active: ${activeModesSummary(getSharedComboState())}.`, 'info');
-                await reload(ctx);
                 return;
             }
             if (sub === 'ponytail') {
@@ -117,7 +114,6 @@ export default function tersioCommandsExtension(pi) {
                 setSharedComboMode('ponytail', mode);
                 appendUsage('toggle', `ponytail=${mode}`);
                 ctx?.ui?.notify?.(`Ponytail ${mode} — Active: ${activeModesSummary(getSharedComboState())}.`, 'info');
-                await reload(ctx);
                 return;
             }
             if (sub === 'combo') {
@@ -140,7 +136,6 @@ export default function tersioCommandsExtension(pi) {
                 setSharedComboLevel(level);
                 appendUsage('toggle', `combo=${level}`);
                 ctx?.ui?.notify?.(`Combo ${level} on — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
-                await reload(ctx);
                 return;
             }
             if (sub === 'check') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "✂️ Token-saving OMP add-ons: terse Caveman replies, compact RTK shell output, lean Ponytail code calls — one-command combo presets.",
   "keywords": [
     "omp",
@@ -115,8 +115,7 @@
   "files": [
     "tersio.js",
     "cli/**/*.js",
-    "cli/dashboard.html",
-    "cli/brand.webp",
+    "dashboard/**/*",
     "extensions/**/*.js"
   ],
   "scripts": {

package/tersio.js

@@ -2,13 +2,14 @@
 // 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, showHelp, showVersion, uninstall, unknownCommand, update, usage, } from './cli/common.js';
+import { PACKAGE_BIN, PACKAGE_VERSION, applyUpdate, commandArg, gain, dashboardExport, dashboardOpen, dashboardPort, doctor, reset, 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';
 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 { runDashboard } from './cli/dashboard.js';
 function printHelp() {
     console.log(`Usage: ${PACKAGE_BIN} [command] [options]
@@ -20,6 +21,7 @@ Commands:
   doctor       Check the current installation
   usage        Ledger-backed usage + savings report
   gain         Open the gain dashboard (localhost only)
+  reset        Clear tersio statistics (usage ledger)
   uninstall    Remove the managed extensions
   version      Print the package version
   help         Show this help
@@ -79,6 +81,11 @@ async function main() {
         closeRL();
         return;
     }
+    if (reset) {
+        await runReset();
+        closeRL();
+        return;
+    }
     if (uninstall) {
         await runUninstall();
         closeRL();