@krtclcdy/tersio 2.4.1 → 2.6.0

package/cli/uninstall.js

@@ -0,0 +1,171 @@
+// cli/uninstall.ts — remove managed extensions, plugins, and binaries.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { cancel as clackCancel, confirm as clackConfirm } from '@clack/prompts';
+import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, RTK_BINARY_NAME, dryRun, keepPonytail, removePonytail, removeRtk, yes, debug, writeConfigLines, } from './common.js';
+import { ask, closeRL, tty } from './interactive.js';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+// Read-modify-write a JSON file. mutate returns true when it changed
+// something; no change (or unreadable file) means no output at all.
+async function updateJsonFile(filePath, mutate, dryRunNote, writeNote, dryRun) {
+    const raw = await readTextIfExists(filePath);
+    if (!raw)
+        return;
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        debug(`Could not parse ${filePath}`);
+        return;
+    }
+    if (!mutate(data))
+        return;
+    if (dryRun) {
+        console.log(`  [dry-run] ${dryRunNote}`);
+        return;
+    }
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    console.log(`  [write] ${writeNote}`);
+}
+function dropKey(section, key) {
+    if (!section || typeof section !== 'object')
+        return false;
+    const record = section;
+    if (!(key in record))
+        return false;
+    delete record[key];
+    return true;
+}
+async function removeUninstallTarget(target, shouldDryRun, recursive = true) {
+    try {
+        if (shouldDryRun) {
+            console.log(`  [dry-run] would remove ${target}`);
+            return;
+        }
+        if (recursive)
+            await fs.rm(target, { recursive: true, force: true });
+        else
+            await fs.unlink(target);
+        console.log(`  [rm] ${target}`);
+    }
+    catch {
+        debug(`Could not remove ${target}`);
+    }
+}
+async function runUninstall(options = {}) {
+    const shouldDryRun = options.dryRun ?? dryRun;
+    const confirmed = (options.yes ?? yes) || shouldDryRun;
+    // Ponytail ships with Tersio's presets, so a full uninstall removes it too;
+    // --keep-ponytail opts out and reinstall always preserves it.
+    const shouldRemovePonytail = options.removePonytail ?? (removePonytail || !keepPonytail);
+    const shouldRemoveRtk = options.removeRtk ?? removeRtk;
+    console.log('\n=== Tersio Uninstall ===\n');
+    const extDir = path.join(OMP_AGENT_DIR, 'extensions');
+    const configPath = path.join(OMP_AGENT_DIR, 'config.yml');
+    const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
+    const pluginsDir = OMP_PLUGINS_DIR;
+    const ponytailPkgDir = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail');
+    const targets = [
+        'caveman-session',
+        'rtk-session',
+        'ai-addons-updater',
+        'combo-toggle',
+        'shared',
+        // Only consumed by ai-addons-updater (removed above); otherwise orphaned.
+        'lib',
+        // Legacy always-on combo helper; imports shared/session-state.js, so it
+        // breaks with a module-not-found warning once the shared dir is removed.
+        'aaa-combo-boot',
+    ].map((dir) => path.join(extDir, dir));
+    console.log('Will remove:');
+    for (const t of targets) {
+        console.log(`  ${t}`);
+    }
+    if (shouldRemovePonytail) {
+        console.log(`  ${ponytailPkgDir} (ponytail plugin package)`);
+    }
+    if (shouldRemoveRtk) {
+        console.log(`  ${rtkBin}`);
+    }
+    if (!confirmed) {
+        if (tty()) {
+            closeRL();
+            const confirmedChoice = await clackConfirm({ message: 'Remove the listed Tersio files?', initialValue: false });
+            if (typeof confirmedChoice !== 'boolean') {
+                clackCancel('Aborted.');
+                closeRL();
+                return false;
+            }
+            if (!confirmedChoice) {
+                console.log('Aborted.');
+                closeRL();
+                return false;
+            }
+        }
+        else {
+            const answer = await ask('\nProceed? [y/N]: ');
+            if (!answer.toLowerCase().startsWith('y')) {
+                console.log('Aborted.');
+                closeRL();
+                return false;
+            }
+        }
+    }
+    // Remove extension directories (independent paths, so concurrently).
+    await Promise.all(targets.map((t) => removeUninstallTarget(t, shouldDryRun)));
+    // Remove Combo and mode-reinforcement registrations; Ponytail only when requested.
+    const configRaw = await readTextIfExists(configPath);
+    if (configRaw) {
+        let lines = configRaw.split('\n');
+        const before = lines.length;
+        lines = lines.filter((l) => {
+            if (l.includes('combo-toggle') || l.includes('mode-reinforcement'))
+                return false;
+            if (shouldRemovePonytail && l.includes('ponytail') && l.includes('pi-extension'))
+                return false;
+            return true;
+        });
+        if (lines.length !== before) {
+            if (shouldDryRun)
+                console.log(`  [dry-run] would remove ${before - lines.length} config.yml entries`);
+            else
+                await writeConfigLines(configPath, lines, `  [write] Updated config.yml (removed ${before - lines.length} entries)`);
+        }
+    }
+    // Remove the Ponytail plugin package the installer added (dep, files,
+    // lock entry); the config.yml entry was filtered above.
+    if (shouldRemovePonytail) {
+        const pluginsPkgPath = path.join(pluginsDir, 'package.json');
+        await updateJsonFile(pluginsPkgPath, (data) => dropKey(data.dependencies, '@dietrichgebert/ponytail'), `would remove @dietrichgebert/ponytail from ${pluginsPkgPath}`, 'Removed @dietrichgebert/ponytail from plugins/package.json', shouldDryRun);
+        try {
+            if (shouldDryRun)
+                console.log(`  [dry-run] would remove ${ponytailPkgDir}`);
+            else {
+                await fs.rm(ponytailPkgDir, { recursive: true, force: true });
+                console.log(`  [rm] ${ponytailPkgDir}`);
+                await fs.rm(path.dirname(ponytailPkgDir));
+                console.log(`  [rm] ${path.dirname(ponytailPkgDir)} (empty scope)`);
+            }
+        }
+        catch {
+            debug('Could not remove ponytail package dir (scope may hold other packages)');
+        }
+        const lockPath = path.join(pluginsDir, 'omp-plugins.lock.json');
+        await updateJsonFile(lockPath, (data) => dropKey(data.plugins, '@dietrichgebert/ponytail'), `would remove @dietrichgebert/ponytail from ${lockPath}`, `Removed @dietrichgebert/ponytail from ${lockPath}`, shouldDryRun);
+    }
+    // Remove our plugin registration from ~/.omp/plugins
+    const pluginsPkgPath = path.join(pluginsDir, 'package.json');
+    await updateJsonFile(pluginsPkgPath, (data) => dropKey(data.dependencies, PACKAGE_NAME), `would remove ${PACKAGE_NAME} from ${pluginsPkgPath}`, `Removed ${PACKAGE_NAME} from plugins/package.json`, shouldDryRun);
+    const selfPluginDir = path.join(pluginsDir, 'node_modules', PACKAGE_NAME);
+    if ((await readTextIfExists(path.join(selfPluginDir, 'package.json'))) !== null) {
+        await removeUninstallTarget(selfPluginDir, shouldDryRun);
+    }
+    // Remove RTK binary if requested
+    if (shouldRemoveRtk)
+        await removeUninstallTarget(rtkBin, shouldDryRun, false);
+    console.log('\nDone. Restart OMP for changes to take effect.');
+    return true;
+}
+const SCOPE_MAP = { user: '1', project: '2', both: '3' };
+export { runUninstall };

package/cli/update.js

@@ -0,0 +1,202 @@
+// cli/update.ts — update check, per-add-on plan, latest-installer run.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { BUN_BIN_DIR, IS_WINDOWS, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_BIN, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, SCOPE_MAP, dryRun, execP, parseJsonObject, scopeFlag, verbose, } from './common.js';
+import { execNetwork } from './interactive.js';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
+const UPDATE_CHECK_TTL_MS = 6 * 60 * 60 * 1000;
+function newerThan(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) !== (pb[i] || 0))
+            return (pa[i] || 0) > (pb[i] || 0);
+    }
+    return false;
+}
+async function latestPublishedVersion() {
+    try {
+        const args = IS_WINDOWS
+            ? ['/d', '/s', '/c', 'npm', 'view', PACKAGE_NAME, 'version', '--prefer-online']
+            : ['view', PACKAGE_NAME, 'version', '--prefer-online'];
+        const r = await execNetwork('Checking npm registry for tersio updates', IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm', args, {
+            timeout: 4000,
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+            shell: false,
+        });
+        return r.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// Returns a newer published version, or null. Reads the registry at most once
+// per TTL (cached under OMP_PLUGINS_DIR) and stays silent on failure.
+async function checkForUpdate() {
+    const cachePath = path.join(OMP_PLUGINS_DIR, 'tersio-update-check.json');
+    const cached = parseJsonObject(await readTextIfExists(cachePath));
+    const cacheFresh = typeof cached?.lastCheck === 'number' && Date.now() - cached.lastCheck < UPDATE_CHECK_TTL_MS;
+    if (cacheFresh && cached?.latest)
+        return newerThan(cached.latest, PACKAGE_VERSION) ? cached.latest : null;
+    const latest = await latestPublishedVersion();
+    if (latest) {
+        await fs.mkdir(OMP_PLUGINS_DIR, { recursive: true }).catch(() => { });
+        await fs.writeFile(cachePath, JSON.stringify({ latest, lastCheck: Date.now() }) + '\n', 'utf8').catch(() => { });
+        return newerThan(latest, PACKAGE_VERSION) ? latest : null;
+    }
+    // Registry unreachable: fall back to a stale cache rather than staying silent.
+    return cached?.latest && newerThan(cached.latest, PACKAGE_VERSION) ? cached.latest : null;
+}
+// Race a probe against a timeout; slow or failing probes resolve null so the
+// update plan stays best-effort and never blocks the update itself.
+async function settle(work, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            work.then((value) => value, () => null),
+            new Promise((resolve) => { timer = setTimeout(() => resolve(null), ms); }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// Plain `npm view <spec> version` with no spinner, for background probes.
+async function npmViewVersion(spec, timeoutMs) {
+    try {
+        const exe = IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm';
+        const args = IS_WINDOWS
+            ? ['/d', '/s', '/c', 'npm', 'view', spec, 'version', '--prefer-online']
+            : ['view', spec, 'version', '--prefer-online'];
+        const r = await execP(exe, args, { timeout: timeoutMs, maxBuffer: 1024 * 1024, windowsHide: true, shell: false });
+        return r.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// Run a child with inherited stdio for live output. Used when the child
+// renders its own interactive UI (the delegated installer runs Clack
+// spinners), which a concurrent outer spinner would corrupt into stray bars.
+async function execInherit(cmd, args) {
+    const code = await new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('close', resolve);
+    });
+    if (code !== 0)
+        throw new Error(`${cmd} exited with code ${code}`);
+}
+// Current → latest per add-on. Every probe is capped and nullable; the plan
+// prints `unknown` for anything unreachable and the update proceeds anyway.
+async function probeUpdatePlan(cliLatest) {
+    const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
+    const ponytailPkg = path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
+    const ruleDest = path.join(OMP_AGENT_DIR, 'extensions', 'caveman-session', 'rule.md');
+    const [rtkLocal, rtkRelease, ruleLocalText, ruleRemoteText, ponytailLocalText, ponytailLatest] = await Promise.all([
+        settle(execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => normalizeRtkVersion(r.stdout.trim() || r.stderr.trim()) || null), 6000),
+        settle(fetchJson(RTK_RELEASE_API).then((r) => normalizeRtkVersion(r.tag_name) || null), 4000),
+        readTextIfExists(ruleDest),
+        settle(httpsGet(CAVEMAN_REMOTE_RULE), 4000),
+        readTextIfExists(ponytailPkg),
+        settle(npmViewVersion('@dietrichgebert/ponytail', 4000), 5000),
+    ]);
+    const shortHash = (text) => text === null ? null : sha256Hex(text).slice(0, 8);
+    return {
+        cli: cliLatest,
+        rtk: [rtkLocal, rtkRelease],
+        rule: [shortHash(ruleLocalText), shortHash(ruleRemoteText)],
+        ponytail: [ponytailLocalText ? parseJsonObject(ponytailLocalText)?.version ?? null : null, ponytailLatest],
+    };
+}
+function planLine(name, current, latest) {
+    if (!current && !latest)
+        console.log(`  ${name}: unknown`);
+    else if (!latest)
+        console.log(`  ${name}: ${current} (latest unknown)`);
+    else if (current === latest)
+        console.log(`  ${name}: ${current} (up to date)`);
+    else
+        console.log(`  ${name}: ${current ?? 'missing'} → ${latest}`);
+}
+async function runLatestUpdate() {
+    const updateScope = scopeFlag || 'user';
+    if (!Object.hasOwn(SCOPE_MAP, updateScope)) {
+        console.error(`[fail] Invalid --scope: ${updateScope}. Use: user, project, both`);
+        process.exitCode = 1;
+        return;
+    }
+    const forwardedArgs = ['--yes', '--scope', updateScope];
+    if (dryRun)
+        forwardedArgs.push('--dry-run');
+    if (verbose)
+        forwardedArgs.push('--verbose');
+    const npmCommand = IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm';
+    console.log('=== Updating Tersio ===');
+    // Resolve the target explicitly: `npm view --prefer-online` beats the local
+    // metadata cache, so a stale `@latest` can never pin an older release.
+    const cliLatest = await latestPublishedVersion();
+    const target = cliLatest && /^\d+\.\d+\.\d+$/.test(cliLatest) ? `@${cliLatest}` : '@latest';
+    // Current → latest per add-on. Best-effort; unreachable probes print as
+    // unknown and never block the update.
+    const plan = await probeUpdatePlan(cliLatest);
+    planLine('Tersio', PACKAGE_VERSION, plan.cli);
+    planLine('RTK', plan.rtk[0], plan.rtk[1]);
+    planLine('Caveman rule', plan.rule[0], plan.rule[1]);
+    planLine('Ponytail', plan.ponytail[0], plan.ponytail[1]);
+    console.log('');
+    // The npx delegation below only refreshes the OMP-side files; the globally
+    // installed CLI keeps its old version until npm -g runs. Refresh both.
+    const globalArgs = IS_WINDOWS
+        ? ['/d', '/s', '/c', 'npm', 'install', '-g', `${PACKAGE_NAME}${target}`, '--no-audit', '--no-fund', '--prefer-online']
+        : ['install', '-g', `${PACKAGE_NAME}${target}`, '--no-audit', '--no-fund', '--prefer-online'];
+    if (dryRun) {
+        console.log(`  [dry-run] would run: npm install -g ${PACKAGE_NAME}${target} --no-audit --no-fund --prefer-online`);
+    }
+    else {
+        try {
+            const globalResult = await execNetwork(`Updating global Tersio CLI to ${PACKAGE_NAME}${target}`, npmCommand, globalArgs, {
+                timeout: 300000,
+                maxBuffer: 10 * 1024 * 1024,
+                windowsHide: true,
+                shell: false,
+            });
+            if (globalResult.stdout)
+                process.stdout.write(globalResult.stdout);
+            if (globalResult.stderr)
+                process.stderr.write(globalResult.stderr);
+            console.log(`  [ok] CLI updated to ${PACKAGE_NAME}${target}`);
+        }
+        catch (e) {
+            console.log(`  [warn] Global CLI update skipped: ${e.message}`);
+            console.log(`  [hint] Manual: npm install -g ${PACKAGE_NAME}${target} --no-audit --no-fund --prefer-online`);
+        }
+    }
+    const npmArgs = [
+        'exec',
+        '--yes',
+        '--prefer-online',
+        `--package=${PACKAGE_NAME}${target}`,
+        '--',
+        PACKAGE_BIN,
+        '--apply-update',
+        ...forwardedArgs,
+    ];
+    const npmCommandArgs = IS_WINDOWS ? ['/d', '/s', '/c', 'npm', ...npmArgs] : npmArgs;
+    // Inherited stdio, no outer spinner: the delegated installer renders its
+    // own Clack UI live, which capture-then-dump would corrupt into stray bars.
+    console.log(`  Running ${PACKAGE_NAME}${target} installer...`);
+    try {
+        await execInherit(npmCommand, npmCommandArgs);
+        console.log('\n=== Update complete ===');
+    }
+    catch (e) {
+        const err = e;
+        console.error(`\n[fail] Could not run ${PACKAGE_NAME}${target}: ${err.message}`);
+        process.exitCode = 1;
+    }
+}
+export { checkForUpdate, runLatestUpdate };

package/cli/usage.js

@@ -0,0 +1,71 @@
+// cli/usage.ts — ledger + session-token usage report, tokscale-style.
+import { co2Grams, importSessionTokens, readUsage, usdCost, } from '../extensions/shared/usage-ledger.js';
+import { withInteractiveSpinner } from './interactive.js';
+export function summarizeUsage(rows) {
+    const byKind = {};
+    const detailCounts = {};
+    for (const r of rows) {
+        byKind[r.kind] = (byKind[r.kind] ?? 0) + 1;
+        detailCounts[r.detail] = (detailCounts[r.detail] ?? 0) + 1;
+    }
+    const byDetail = Object.entries(detailCounts).sort((a, b) => b[1] - a[1]).slice(0, 10);
+    const session = importSessionTokens();
+    let usd = 0;
+    let priced = true;
+    for (const [model, t] of Object.entries(session.byModel)) {
+        const c = usdCost(t, model);
+        usd += c.usd;
+        if (!c.priced)
+            priced = false;
+    }
+    return {
+        total: rows.length,
+        byKind,
+        byDetail,
+        lastWrite: rows.length ? new Date(rows[rows.length - 1].ts).toISOString() : null,
+        empty: rows.length === 0 && session.messages === 0,
+        messages: session.messages,
+        tokens: session.totals,
+        byModel: session.byModel,
+        byDay: session.byDay,
+        usd,
+        priced,
+        co2g: co2Grams(session.totals.output),
+    };
+}
+function fmt(n) {
+    return n.toLocaleString('en-US');
+}
+function printReport(report) {
+    console.log('\n=== Tersio Usage ===');
+    if (report.empty) {
+        console.log('  No ledger rows or session tokens yet — run session commands first.');
+        return;
+    }
+    const t = report.tokens;
+    console.log(`  Tokens  input ${fmt(t.input)} · output ${fmt(t.output)} · cache read ${fmt(t.cacheRead)} · cache write ${fmt(t.cacheWrite)} (${report.messages} assistant messages)`);
+    console.log(`  Cost    $${report.usd.toFixed(2)}${report.priced ? '' : ' (includes default pricing for unknown models)'} · CO2 ~${report.co2g.toFixed(1)}g (est.)`);
+    const models = Object.entries(report.byModel).sort((a, b) => (b[1].input + b[1].output) - (a[1].input + a[1].output)).slice(0, 5);
+    if (models.length) {
+        console.log('  By model');
+        for (const [model, b] of models) {
+            console.log(`    ${model}: in ${fmt(b.input)} · out ${fmt(b.output)} · cache r/w ${fmt(b.cacheRead)}/${fmt(b.cacheWrite)}`);
+        }
+    }
+    if (report.total) {
+        console.log('  Activity');
+        for (const [kind, n] of Object.entries(report.byKind)) {
+            console.log(`    ${kind}: ${n}`);
+        }
+        console.log('  Top commands');
+        for (const [detail, n] of report.byDetail) {
+            console.log(`    ${n}× ${detail}`);
+        }
+        console.log(`  Total rows: ${report.total} · last write: ${report.lastWrite}`);
+    }
+}
+async function runUsage() {
+    const report = await withInteractiveSpinner('Reading usage ledger', async () => summarizeUsage(readUsage()));
+    printReport(report);
+}
+export { runUsage };

package/extensions/ai-addons-updater/index.js

@@ -82,6 +82,33 @@ function checkCaveman() {
         return `Caveman ${status}: local=${localHash || '—'} remote=${remoteHash}`;
     });
 }
+export async function checkAddonsSummary(ctx) {
+    return checkAddons(ctx);
+}
+export async function runAddonUpdate(pi, ctx, target, dryRun = false) {
+    const results = [];
+    const updaters = {
+        ponytail: () => updatePonytail(pi, ctx, dryRun),
+        rtk: () => updateRtk(ctx, dryRun),
+        caveman: () => updateCaveman(ctx, dryRun),
+    };
+    if (target === 'all') {
+        notify(ctx, `ai-addons update all${dryRun ? ' dry-run' : ''}: starting ponytail → rtk → caveman sequentially…`, 'info');
+        for (const name of ['ponytail', 'rtk', 'caveman'])
+            results.push(await updaters[name]());
+        if (!dryRun)
+            results.push(RELOAD_MSG);
+        notify(ctx, `ai-addons update all ${dryRun ? 'dry-run ' : ''}complete.${dryRun ? '' : ` ${RELOAD_MSG}`}`, 'info');
+    }
+    else if (Object.hasOwn(updaters, target)) {
+        results.push(await updaters[target]());
+    }
+    else {
+        const m = 'Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]';
+        return report(ctx, m, 'warning');
+    }
+    return results.join('\n\n');
+}
 async function checkAddons(ctx) {
     const [ponytail, rtk, caveman] = await Promise.all([checkPonytail(), checkRtk(), checkCaveman()]);
     const lines = [];
@@ -294,29 +321,7 @@ export default function aiAddonsUpdaterExtension(pi) {
                 return summary;
             }
             if (sub === 'update' && cleanParts[1]) {
-                const target = cleanParts.slice(1).join(' ');
-                const results = [];
-                const updaters = {
-                    ponytail: () => updatePonytail(pi, ctx, dryRun),
-                    rtk: () => updateRtk(ctx, dryRun),
-                    caveman: () => updateCaveman(ctx, dryRun),
-                };
-                if (target === 'all') {
-                    notify(ctx, `ai-addons update all${dryRun ? ' dry-run' : ''}: starting ponytail → rtk → caveman sequentially…`, 'info');
-                    for (const name of ['ponytail', 'rtk', 'caveman'])
-                        results.push(await updaters[name]());
-                    if (!dryRun)
-                        results.push(RELOAD_MSG);
-                    notify(ctx, `ai-addons update all ${dryRun ? 'dry-run ' : ''}complete.${dryRun ? '' : ` ${RELOAD_MSG}`}`, 'info');
-                }
-                else if (Object.hasOwn(updaters, target)) {
-                    results.push(await updaters[target]());
-                }
-                else {
-                    const m = 'Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]';
-                    return report(ctx, m, 'warning');
-                }
-                return results.join('\n\n');
+                return runAddonUpdate(pi, ctx, cleanParts.slice(1).join(' '), dryRun);
             }
             const m = 'Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]';
             return report(ctx, m, 'warning');

package/extensions/shared/usage-ledger.js

@@ -0,0 +1,156 @@
+// Shared usage ledger: append-only JSON-lines file. One source of truth read
+// by `tersio usage`, `/tersio usage`, and the gain dashboard.
+// Best-effort by design: a ledger failure never breaks the caller, and
+// corrupt lines are skipped on read (same pattern as the config normalizer).
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function ledgerPath() {
+    const override = process.env.TERSIO_USAGE_FILE;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.omp', 'plugins', 'tersio-usage.jsonl');
+}
+export function appendUsage(kind, detail) {
+    const row = JSON.stringify({ ts: Date.now(), kind, detail }) + '\n';
+    try {
+        fs.mkdirSync(path.dirname(ledgerPath()), { recursive: true });
+        fs.appendFileSync(ledgerPath(), row, 'utf8');
+    }
+    catch { /* ledger is best-effort; never break the caller */ }
+}
+function zeroBreakdown() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function addInto(into, u) {
+    for (const k of ['input', 'output', 'cacheRead', 'cacheWrite']) {
+        const v = u[k];
+        if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+            into[k] += Math.floor(v);
+    }
+}
+export function sessionsDir() {
+    const override = process.env.TERSIO_SESSIONS_DIR;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.omp', 'agent', 'sessions');
+}
+function dayKey(ts) {
+    const ms = typeof ts === 'number' ? ts : Date.parse(ts);
+    if (!Number.isFinite(ms))
+        return null;
+    const d = new Date(ms);
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+function walkJsonl(dir, out, cap) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (out.length >= cap)
+            return;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            walkJsonl(full, out, cap);
+        else if (e.isFile() && e.name.endsWith('.jsonl'))
+            out.push(full);
+    }
+}
+export function importSessionTokens() {
+    const byModel = {};
+    const byDay = {};
+    const totals = zeroBreakdown();
+    let messages = 0;
+    const files = [];
+    walkJsonl(sessionsDir(), files, 2000);
+    for (const file of files) {
+        let text;
+        try {
+            text = fs.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const row = JSON.parse(line);
+                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);
+                }
+                messages += 1;
+            }
+            catch { /* skip corrupt lines */ }
+        }
+    }
+    return { messages, totals, byModel, byDay };
+}
+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 };
+}
+export function usdCost(t, model) {
+    const { price, known } = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false };
+    const m = 1 / 1_000_000;
+    return {
+        usd: (t.input * price.input + t.output * price.output + t.cacheRead * price.cacheRead + t.cacheWrite * price.cacheWrite) * m,
+        priced: model ? known : false,
+    };
+}
+// ponytail: CO2 is a rough server-energy multiple on output tokens, not metered.
+// Always render with ~est. and never merge with measured figures.
+export const CO2_G_PER_1K_OUTPUT = 0.2;
+export function co2Grams(outputTokens) {
+    return (outputTokens / 1000) * CO2_G_PER_1K_OUTPUT;
+}
+export function readUsage() {
+    let text;
+    try {
+        text = fs.readFileSync(ledgerPath(), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            if (typeof row.ts === 'number' && typeof row.kind === 'string' && typeof row.detail === 'string') {
+                rows.push({ ts: row.ts, kind: row.kind, detail: row.detail });
+            }
+        }
+        catch { /* skip corrupt lines */ }
+    }
+    return rows;
+}