@krtclcdy/tersio 2.25.3 → 2.25.5

package/dist/cli/backups.js

@@ -0,0 +1,194 @@
+// Data snapshots: what tersio keeps, where the copies live, and how one is put back.
+//
+// A snapshot is a directory with a manifest, not a single file, so one copy holds the whole set.
+// Older installs wrote a lone `usage-<stamp>.db`; those still list and restore, over the ledger alone.
+import { promises as fs } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { agentDbPath, statsDbPath } from '../extensions/shared/agent-stats.js';
+import { rtkDbPath } from '../extensions/shared/rtk-gain.js';
+import { pricesCachePath } from '../extensions/shared/pricing.js';
+import { usageDbPath } from '../extensions/shared/usage-store.js';
+import { resetMarkerPath } from '../extensions/shared/usage-ledger.js';
+import { tersioHome } from '../extensions/shared/utils.js';
+/** Snapshots kept on disk; the oldest is pruned first. Six keeps the list past one screen, so
+ *  the pane scrolls instead of showing the whole history at once. */
+export const BACKUP_KEEP = 6;
+/** Where a snapshot's files live. */
+export function backupDir() {
+    return path.join(tersioHome(), 'backups');
+}
+/** A snapshot directory's manifest, read back out with its files. */
+function manifestPath(dir) {
+    return path.join(dir, 'manifest.json');
+}
+/** Every file this build knows how to snapshot, whether or not it exists yet. */
+export function dataSources() {
+    const sources = [
+        ['Usage ledger', usageDbPath()],
+        ['Reset watermark', resetMarkerPath()],
+        ['Settings', path.join(tersioHome(), 'settings.json')],
+        ['Price cache', pricesCachePath()],
+        ['Model price cache', path.join(tersioHome(), 'prices-modelsdev.json')],
+        ['Agent stats', statsDbPath()],
+        ['Agent quota windows', agentDbPath()],
+        ['Command history', rtkDbPath()],
+    ];
+    return sources.map(([label, source]) => ({ label, source, bytes: sizeOf(source) }));
+}
+/** Byte size of a file, zero when it is absent or unreadable. */
+function sizeOf(file) {
+    try {
+        return statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Snapshot label for a legacy single-file backup, so the list reads the same for both. */
+function legacyLabel(name) {
+    return name.startsWith('usage-') ? 'Usage ledger' : 'Snapshot';
+}
+/** Newest first: the directories this build wrote, then the lone `usage-*.db` files. */
+export function listDataBackups() {
+    let names = [];
+    try {
+        names = readdirSync(backupDir());
+    }
+    catch {
+        return [];
+    }
+    const dirs = [];
+    const legacy = [];
+    for (const name of names) {
+        const full = path.join(backupDir(), name);
+        let stat;
+        try {
+            stat = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            const files = readManifest(full);
+            if (files.length === 0)
+                continue;
+            dirs.push({ name, path: full, mtime: stat.mtimeMs, bytes: totalOf(full), files, legacy: false });
+            continue;
+        }
+        if (/^usage-\d{14}\.db$/.test(name)) {
+            legacy.push({
+                name,
+                path: full,
+                mtime: stat.mtimeMs,
+                bytes: stat.size,
+                files: [{ label: legacyLabel(name), source: usageDbPath(), bytes: stat.size }],
+                legacy: true,
+            });
+        }
+    }
+    return [...dirs, ...legacy].toSorted((a, b) => b.mtime - a.mtime);
+}
+/** The files a snapshot directory holds, read from its manifest. */
+function readManifest(dir) {
+    try {
+        const raw = JSON.parse(readFileSync(manifestPath(dir), 'utf8'));
+        if (!Array.isArray(raw))
+            return [];
+        return raw
+            .map((entry) => {
+            const record = (entry ?? {});
+            const source = String(record.source ?? '');
+            const name = path.basename(source);
+            const file = path.join(dir, name);
+            const bytes = sizeOf(file);
+            if (!source || bytes === 0)
+                return null;
+            return { label: String(record.label ?? name), source, bytes };
+        })
+            .filter((entry) => entry !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Disk size of a snapshot, counting the manifest. */
+function totalOf(dir) {
+    return sizeOf(manifestPath(dir)) + readdirSync(dir).reduce((sum, name) => sum + sizeOf(path.join(dir, name)), 0);
+}
+/** Put the sqlite ledger's write-ahead log back in the main file, so a copy is one whole database. */
+function checkpointLedger() {
+    try {
+        execFileSync('sqlite3', [usageDbPath(), 'PRAGMA wal_checkpoint(TRUNCATE);'], { stdio: 'ignore', timeout: 10_000 });
+    }
+    catch {
+        /* no sqlite3, or no ledger: the plain file copy is the best available */
+    }
+}
+/** Take a snapshot now: one copy of every file that exists, under a stamp directory, then keep only the newest {@link BACKUP_KEEP}. */
+export async function createDataBackup() {
+    // The stamp keeps milliseconds: two snapshots in the same second must not land in one directory.
+    const stamp = new Date().toISOString().replace(/[-:TZ.]/g, '');
+    const dir = path.join(backupDir(), `data-${stamp}`);
+    checkpointLedger();
+    await fs.mkdir(dir, { recursive: true });
+    const files = [];
+    for (const source of dataSources()) {
+        if (source.bytes === 0)
+            continue;
+        const target = path.join(dir, path.basename(source.source));
+        await fs.copyFile(source.source, target);
+        files.push({ ...source, bytes: sizeOf(target) });
+    }
+    await fs.writeFile(manifestPath(dir), JSON.stringify(files.map(({ label, source }) => ({ label, source }))), 'utf8');
+    await pruneBackups();
+    return { name: path.basename(dir), path: dir, mtime: Date.now(), bytes: files.reduce((sum, f) => sum + f.bytes, 0), files, legacy: false };
+}
+/** Keep the newest {@link BACKUP_KEEP} snapshots and drop the rest, legacy files included. */
+export async function pruneBackups() {
+    const all = listDataBackups();
+    for (const old of all.slice(BACKUP_KEEP)) {
+        await fs.rm(old.path, { recursive: true, force: true }).catch(() => { });
+    }
+}
+/** A snapshot name resolves to a path inside the backup directory, or null when it does not. */
+function resolveBackup(name) {
+    if (!name || path.basename(name) !== name || /[\\/]/.test(name))
+        return null;
+    const found = listDataBackups().find((entry) => entry.name === name);
+    return found ?? null;
+}
+/** Put a snapshot back: every file it holds is copied over its live source. A file it lacks is left alone, so a restore never deletes what it does not carry. */
+export async function restoreDataBackup(name) {
+    const found = resolveBackup(name);
+    if (!found)
+        return false;
+    if (found.legacy) {
+        await fs.mkdir(path.dirname(usageDbPath()), { recursive: true });
+        await fs.copyFile(found.path, usageDbPath());
+        return true;
+    }
+    for (const file of found.files) {
+        const from = path.join(found.path, path.basename(file.source));
+        await fs.mkdir(path.dirname(file.source), { recursive: true });
+        await fs.copyFile(from, file.source);
+    }
+    return true;
+}
+/** Remove one snapshot. Only ever touches a path inside the backup directory. */
+export async function deleteDataBackup(name) {
+    const found = resolveBackup(name);
+    if (!found)
+        return false;
+    await fs.rm(found.path, { recursive: true, force: true });
+    return true;
+}
+/** Total size of every snapshot on disk, for the pane's footer. */
+export function backupDiskBytes() {
+    return listDataBackups().reduce((sum, entry) => sum + entry.bytes, 0);
+}
+/** The home directory the snapshots live under, for the pane's path line. */
+export function backupHome() {
+    return tersioHome();
+}

package/dist/cli/common.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
-import { findPackageRoot, readTextIfExists } from '../extensions/lib/utils.js';
+import { findPackageRoot, readTextIfExists } from '../extensions/shared/utils.js';
 import { parseCurrencyFlag, readStoredCurrency } from './currency.js';
 const IS_WINDOWS = process.platform === 'win32';
 const RTK_BINARY_NAME = IS_WINDOWS ? 'rtk.exe' : 'rtk';
@@ -300,4 +300,4 @@ function relTime(ageMs) {
     const weeks = Math.floor(days / 7);
     return `${weeks} week${weeks === 1 ? '' : 's'} ago`;
 }
-export { IS_WINDOWS, RTK_BINARY_NAME, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, BUN_BIN_DIR, OMP_BIN, PACKAGE_NAME, PACKAGE_BIN, PACKAGE_VERSION, CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS, RTK_DEFAULTS, DIAG_SCHEDULES, COMBO_PRESET_MODES, COMBO_DEFAULTS, parseEnum, flagValue, COMMANDS, commandArg, command, settingArg, unknownCommand, install, update, showVersion, showHelp, applyUpdate, args, dryRun, yes, verbose, doctor, fix, uninstall, usage, dashboard, reset, settings, allowUnverified, dashboardPort, dashboardOpen, dashboardExport, currency, currencyGiven, removePonytail, keepPonytail, removeRtk, comboDefaultFlag, cavemanDefaultFlag, ponytailDefaultFlag, rtkDefaultFlag, diagScheduleFlag, profileFlagsGiven, subagentMarkerFlags, subagentMarkersGiven, debug, execFileP, execP, writeIfChanged, normalizeExtensionsKey, EXTENSIONS_KEY_RE, writeConfigLines, ensureExtensionInConfig, removeExtensionFromConfig, readPonytailConfig, parseJsonObject, parsePonytailConfig, patchPonytailConfig, ensurePonytailConfigValue, readPluginsPackage, relTime, };
+export { IS_WINDOWS, RTK_BINARY_NAME, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, BUN_BIN_DIR, OMP_BIN, PACKAGE_NAME, PACKAGE_BIN, PACKAGE_VERSION, CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS, RTK_DEFAULTS, DIAG_SCHEDULES, COMBO_PRESET_MODES, COMBO_DEFAULTS, parseEnum, flagValue, COMMANDS, commandArg, command, settingArg, unknownCommand, install, update, showVersion, showHelp, applyUpdate, args, dryRun, yes, verbose, doctor, fix, uninstall, usage, dashboard, reset, settings, allowUnverified, dashboardPort, dashboardOpen, dashboardExport, currency, currencyGiven, removePonytail, keepPonytail, removeRtk, comboDefaultFlag, cavemanDefaultFlag, ponytailDefaultFlag, rtkDefaultFlag, diagScheduleFlag, profileFlagsGiven, subagentMarkerFlags, subagentMarkersGiven, debug, execFileP, execP, writeIfChanged, normalizeExtensionsKey, writeConfigLines, ensureExtensionInConfig, removeExtensionFromConfig, readPonytailConfig, parseJsonObject, parsePonytailConfig, patchPonytailConfig, ensurePonytailConfigValue, readPluginsPackage, relTime, };

package/dist/cli/dashboard.js

@@ -6,17 +6,17 @@ import { promises as fs } from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { clearUsageLedger, markReset, readUsage } from '../extensions/shared/usage-ledger.js';
 import { pricesCachePath } from '../extensions/shared/pricing.js';
-import { summarizeUsage } from './usage.js';
-import { backupUsageDb, deleteUsageBackup, listUsageBackups, restoreUsageBackup, usageDbPath } from '../extensions/shared/usage-store.js';
 import { isCurrencyCode } from './currency.js';
 import { OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_VERSION, } from './common.js';
 import { BACKUP_SCHEDULES, formatCliStatus, storedProfile, writePluginSettings } from './profile.js';
 import { normalizeComboLevel } from '../extensions/shared/session-state.js';
 import { CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS } from './common.js';
 import { PACKAGE_NAME } from './common.js';
-import { findPackageRoot, resolveRtkBinary } from '../extensions/lib/utils.js';
+import { findPackageRoot, resolveRtkBinary } from '../extensions/shared/utils.js';
+import { BACKUP_KEEP, backupDir, backupDiskBytes, createDataBackup, dataSources, deleteDataBackup, listDataBackups, restoreDataBackup } from './backups.js';
+import { readBackupSchedule } from '../extensions/shared/usage-store.js';
+import { agentDbPath, emptyRequestEntry, isAgentView, isRangeKey, readAgentRequestEntry, readAgentStats, readSessionTrace, statsDbPath } from '../extensions/shared/agent-stats.js';
 const DASHBOARD_DIST = path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), 'dashboard', 'dist');
 const DASHBOARD_INDEX = path.join(DASHBOARD_DIST, 'index.html');
 const DASHBOARD_BRAND = path.join(DASHBOARD_DIST, 'brand.webp');
@@ -49,8 +49,45 @@ async function brandDataUri() {
     const brand = await fs.readFile(DASHBOARD_BRAND);
     return `data:image/webp;base64,${brand.toString('base64')}`;
 }
-function dataJson() {
-    return JSON.stringify(summarizeUsage(readUsage()));
+/** The range a page opens on, matching the reference dashboard. */
+const DEFAULT_AGENT_RANGE = '24h';
+/** The omp aggregate spawns a sqlite3 process per query group, so a repeat poll reuses it. */
+const AGENT_REFRESH_MS = 5000;
+let agentMemo = null;
+function fileStamp(file) {
+    try {
+        const stat = statSync(file);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    catch {
+        return '-';
+    }
+}
+/** Reads the omp databases, unless the same window and view were read recently and nothing moved. */
+function agentStats(range, view = 'all') {
+    const stamp = `${fileStamp(statsDbPath())}|${fileStamp(agentDbPath())}`;
+    const held = agentMemo;
+    if (held && held.range === range && held.view === view && held.stamp === stamp && Date.now() - held.at < AGENT_REFRESH_MS) {
+        return held.value;
+    }
+    const value = readAgentStats(range, view);
+    agentMemo = { range, view, stamp, at: Date.now(), value };
+    return value;
+}
+/** `?range=` on any of the omp routes; an unknown value falls back to the default. */
+function queryParam(url, name) {
+    return (url.split('?')[1] ?? '').split('&').find((part) => part.startsWith(`${name}=`))?.slice(name.length + 1) ?? null;
+}
+function rangeFrom(url) {
+    const raw = queryParam(url, 'range');
+    return isRangeKey(raw) ? raw : DEFAULT_AGENT_RANGE;
+}
+function viewFrom(url) {
+    const raw = queryParam(url, 'view');
+    return isAgentView(raw) ? raw : 'all';
+}
+function agentJson(range, view) {
+    return JSON.stringify({ range, view, agent: agentStats(range, view) });
 }
 // Runs outside any agent session, so it reports the persisted defaults.
 async function statusJson() {
@@ -374,50 +411,6 @@ async function saveDashboardCurrency(raw) {
     await writePluginSettings(profile, {});
     return code;
 }
-export const EXPORT_FORMATS = ['json', 'jsonl', 'csv'];
-export function exportRows(report) {
-    return report.recent.map((r) => ({
-        timestamp: new Date(r.t).toISOString(),
-        local: new Date(r.t).toLocaleString(),
-        agent: r.h ?? 'pi',
-        model: r.m,
-        input: r.i,
-        output: r.o,
-        cacheRead: r.cr ?? 0,
-        cacheWrite: r.cw ?? 0,
-        costUsd: r.usd,
-        elapsedMs: r.d,
-        status: r.st,
-    }));
-}
-export function csvCell(v) {
-    const s = v === undefined || v === null ? '' : String(v);
-    return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
-}
-export function exportBody(format, report) {
-    const stamp = new Date().toISOString().slice(0, 10);
-    if (format === 'json') {
-        return { body: JSON.stringify({ exportedAt: new Date().toISOString(), version: report.version, source: report.source, report }, null, 2), type: 'application/json' };
-    }
-    const rows = exportRows(report);
-    if (format === 'jsonl') {
-        return { body: rows.map((r) => JSON.stringify(r)).join('\n') + '\n', type: 'application/x-ndjson' };
-    }
-    const cols = Object.keys(rows[0] ?? { timestamp: '', agent: '' });
-    const head = cols.join(',');
-    const body = [head, ...rows.map((r) => cols.map((c) => csvCell(r[c])).join(','))].join('\n') + '\n';
-    return { body, type: 'text/csv; charset=utf-8' };
-}
-function serveExport(req, res) {
-    const format = ((req.url || '').split('?')[1] || '').match(/format=([a-z]+)/)?.[1];
-    const fmt = format && EXPORT_FORMATS.includes(format) ? format : 'json';
-    const { body, type } = exportBody(fmt, summarizeUsage(readUsage()));
-    res.writeHead(200, {
-        'Content-Type': type,
-        'Content-Disposition': `attachment; filename="tersio-usage-${new Date().toISOString().slice(0, 10)}.${fmt === 'jsonl' ? 'ndjson' : fmt}"`,
-    });
-    res.end(body);
-}
 function readBody(req) {
     return new Promise((resolve) => {
         let body = '';
@@ -448,73 +441,85 @@ function parseOwnJson(json, field) {
     }
     return parsed;
 }
-async function exportDashboard(exportFile) {
+async function exportDashboard(exportFile, currency) {
     requireDashboardBundle();
     const [bundle, icon] = await Promise.all([readSegment(DASHBOARD_INDEX), brandDataUri()]);
+    // The bundle is minified, so the brand fetch reaches the file as `fetch(\`brand.webp\`)` or
+    // `fetch("brand.webp")` depending on the bundler's quote choice. Match either, or the exported
+    // card silently loses its mark. `atob` returns one char per byte, and a Blob encodes a string
+    // as UTF-8, so the bytes go through a Uint8Array first: a webp is binary and every byte at or
+    // above 0x80 would otherwise double and corrupt the image.
+    const b64 = icon.split(',')[1] ?? '';
+    // atob yields one char per byte; a Blob encodes a string as UTF-8, so the bytes pass through a
+    // Uint8Array or every byte at or above 0x80 doubles and the webp comes out corrupt.
+    const brandBytes = `(() => { const c = atob(${JSON.stringify(b64)}); const v = new Uint8Array(c.length); for (let i = 0; i < c.length; i++) v[i] = c.charCodeAt(i); return v; })()`;
     const inline = bundle
-        .replace('window.__TERSIO_SNAP = null;', () => `window.__TERSIO_SNAP = ${escapeInline(JSON.stringify({ data: parseOwnJson(dataJson(), 'usage data'), health: parseOwnJson(healthJson(), 'health'), doctor: getDoctorReport(false) }))};`)
-        .replace(/href="brand\.webp"/g, () => `href="${icon}"`)
-        .replace(/src="brand\.webp"/g, () => `src="${icon}"`)
-        .replace('fetch("brand.webp")', () => `Promise.resolve({ ok: true, blob: async () => new Blob([atob("${icon.split(',')[1]}")], { type: "image/webp" }) })`);
+        .replace('window.__TERSIO_SNAP = null;', () => `window.__TERSIO_SNAP = ${escapeInline(JSON.stringify({ currency, agent: agentStats(DEFAULT_AGENT_RANGE), health: parseOwnJson(healthJson(), 'health'), doctor: getDoctorReport(false) }))};`)
+        // A mark reaches the bundle three ways: an HTML attribute in `index.html`, and a JSX prop
+        // esbuild compiled with a backtick. Match any of `"`, `'`, and `` ` ``, or an exported file
+        // keeps a bare reference that file:// cannot resolve.
+        .replace(/((?:src|href)[=:][ \t]*)([`"'])brand\.webp\2/g, (_all, head, quote) => `${head}${quote}${icon}${quote}`)
+        .replace(/fetch\(([`"])brand\.webp\1\)/g, () => `Promise.resolve({ ok: true, blob: async () => new Blob([${brandBytes}], { type: "image/webp" }) })`);
     await fs.writeFile(exportFile, inline, 'utf8');
     console.log(`[ok] Dashboard exported → ${exportFile}`);
 }
 async function runDashboard(options) {
     if (options.exportFile) {
-        await exportDashboard(options.exportFile);
+        await exportDashboard(options.exportFile, options.currency);
         return;
     }
     requireDashboardBundle();
     const server = http.createServer(async (req, res) => {
-        if (req.url === '/reset' && req.method === 'POST') {
-            const rows = clearUsageLedger();
-            markReset();
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok: true, rows }));
-            return;
-        }
-        if (req.url === '/backups' && req.method === 'GET') {
-            const rows = listUsageBackups().map((b) => ({ file: path.basename(b.file), mtime: b.mtime, size: b.size }));
+        if (req.url === '/api/data' && req.method === 'GET') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ backups: rows }));
+            res.end(JSON.stringify({
+                dir: backupDir(),
+                keep: BACKUP_KEEP,
+                sources: dataSources(),
+                backups: listDataBackups(),
+                schedule: readBackupSchedule(),
+                bytes: backupDiskBytes(),
+            }));
             return;
         }
-        if (req.url === '/backups/create' && req.method === 'POST') {
-            try {
-                backupUsageDb(usageDbPath());
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-            }
-            catch {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'backup failed' }));
-            }
-            return;
-        }
-        if (req.url === '/backups/delete' && req.method === 'POST') {
-            let file = '';
+        if (req.url === '/api/data' && req.method === 'POST') {
+            let body = {};
             try {
-                file = String(JSON.parse(await readBody(req)).file ?? '');
+                body = JSON.parse(await readBody(req)) ?? {};
             }
             catch {
-                file = '';
+                body = {};
             }
-            const ok = deleteUsageBackup(file);
-            res.writeHead(ok ? 200 : 400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(ok ? { ok: true, file } : { ok: false, error: 'unknown backup' }));
-            return;
-        }
-        if (req.url === '/backups/restore' && req.method === 'POST') {
-            let file = '';
+            const action = String(body.action ?? '');
+            const name = String(body.name ?? '');
+            // A missing sqlite3, or a locked file, is a 500 with a message rather than a silent no-op.
             try {
-                file = String(JSON.parse(await readBody(req)).file ?? '');
+                if (action === 'create') {
+                    const made = await createDataBackup();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, name: made.name, files: made.files.length }));
+                    return;
+                }
+                if (action === 'restore') {
+                    const ok = await restoreDataBackup(name);
+                    res.writeHead(ok ? 200 : 400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(ok ? { ok: true, name } : { ok: false, error: 'unknown snapshot' }));
+                    return;
+                }
+                if (action === 'delete') {
+                    const ok = await deleteDataBackup(name);
+                    res.writeHead(ok ? 200 : 400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(ok ? { ok: true, name } : { ok: false, error: 'unknown snapshot' }));
+                    return;
+                }
             }
-            catch {
-                file = '';
+            catch (error) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: error.message || 'backup failed' }));
+                return;
             }
-            const ok = restoreUsageBackup(file);
-            res.writeHead(ok ? 200 : 400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(ok ? { ok: true, file } : { ok: false, error: 'unknown backup' }));
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'unknown action' }));
             return;
         }
         if (req.url === '/settings' && req.method === 'GET') {
@@ -526,6 +531,7 @@ async function runDashboard(options) {
                     rtkDefault: profile.rtkDefault,
                     ponytailDefault: profile.ponytailDefault,
                     backupSchedule: profile.backupSchedule,
+                    currency: options.currency,
                 }));
             });
             return;
@@ -568,13 +574,34 @@ async function runDashboard(options) {
             }
             return;
         }
-        if (req.url === '/data.json') {
+        if (req.url === '/api/agent' || req.url?.startsWith('/api/agent?')) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(agentJson(rangeFrom(req.url), viewFrom(req.url)));
+            return;
+        }
+        if (req.url?.startsWith('/api/agent/session')) {
+            const file = decodeURIComponent(queryParam(req.url, 'file') ?? '');
+            const body = file ? readSessionTrace(file) : {
+                sessionFile: '', project: '', title: '', cwd: '', startedAt: 0, endedAt: 0,
+                tracks: [], markers: [], summary: {
+                    wallMs: 0, modelMs: 0, toolMs: 0, idleMs: 0, turns: 0, requests: 0, toolCalls: 0, agents: 0,
+                    totalTokens: 0, costUsd: 0,
+                },
+                toolStats: [], truncated: false,
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(body));
+            return;
+        }
+        if (req.url?.startsWith('/api/agent/entry')) {
+            const file = decodeURIComponent(queryParam(req.url, 'file') ?? '');
+            const entry = decodeURIComponent(queryParam(req.url, 'entry') ?? '');
+            const body = file && entry ? readAgentRequestEntry(file, entry) : emptyRequestEntry();
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(dataJson());
+            res.end(JSON.stringify(body));
             return;
         }
         if (req.url?.startsWith('/export')) {
-            serveExport(req, res);
             return;
         }
         if (req.url === '/health') {

package/dist/cli/doctor-fix.js

@@ -1,27 +1,31 @@
 import { existsSync, promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, execP, readPluginsPackage, writeIfChanged, } from './common.js';
+import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, execP, readPluginsPackage, } from './common.js';
 import { execNetwork, sayTagged } from './interactive.js';
 import { wireRtkOmp, wireRtkOpencode, wireRtkPi, ensureRtkInConfig } from './rtk-wiring.js';
-import { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
+import { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/shared/utils.js';
 import { runLatestUpdate } from './update.js';
-import { EXT_DIR, OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
+import { OPENCODE_ENTRY, TREE_FILES, syncTreeFiles, treeFilesFor } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
 // A written tree is the install for both hosts now, so --fix restores it for whichever hosts have it, alongside the OMP package when that is present.
 async function fixExtensionTrees() {
-    // The opencode entrypoint is foreign to pi/omp loaders: never copy it there, and remove strays.
-    const forHost = (id) => TREE_FILES.filter((file) => id === 'opencode' || !file.startsWith('opencode/'));
-    const scrubOpencodeDir = async (dest) => {
-        const dir = path.join(dest, 'opencode');
-        if (!existsSync(dir))
-            return;
-        if (dryRun) {
-            sayTagged(`  [dry-run] would remove foreign ${dir}`);
-            return;
+    // The OpenCode entry is foreign to the pi and omp loaders: it imports @opencode/plugin, which
+    // those hosts do not carry. One shared filter, so a repair cannot drop it into the wrong tree.
+    const forHost = (id) => treeFilesFor(id);
+    // A tree from before the entry moved to the extensions root held a nested copy, and a repair
+    // written against the old filter may have left the entry at the root. Remove both strays.
+    const scrubOpencodeEntry = async (dest) => {
+        for (const target of [path.join(dest, OPENCODE_ENTRY), path.join(dest, 'opencode')]) {
+            if (!existsSync(target))
+                continue;
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove foreign ${target}`);
+                continue;
+            }
+            await fs.rm(target, { recursive: true, force: true });
+            sayTagged(`  [rm] foreign ${target}`);
         }
-        await fs.rm(dir, { recursive: true, force: true });
-        sayTagged(`  [rm] foreign ${dir}`);
     };
     for (const host of detectHosts()) {
         const dest = hostExtensionsDir(host.id);
@@ -29,20 +33,15 @@ async function fixExtensionTrees() {
         const present = forHost(host.id).filter((file) => existsSync(path.join(dest, file))).length;
         if (present === 0) {
             if (host.id !== 'opencode')
-                await scrubOpencodeDir(dest);
+                await scrubOpencodeEntry(dest);
             continue;
         }
         await fs.mkdir(dest, { recursive: true });
-        for (const file of forHost(host.id)) {
-            const from = path.join(EXT_DIR, ...file.split('/'));
-            const text = await readTextIfExists(from);
-            if (text === null)
-                sayTagged(`  [warn] bundled source missing: ${from}`);
-            else
-                await writeIfChanged(path.join(dest, file), text, { dryRun, verbose });
-        }
+        const missing = await syncTreeFiles(dest, forHost(host.id), { dryRun, verbose });
+        for (const from of missing)
+            sayTagged(`  [warn] bundled source missing: ${from}`);
         if (host.id !== 'opencode')
-            await scrubOpencodeDir(dest);
+            await scrubOpencodeEntry(dest);
         if (!dryRun)
             sayTagged(`  [ok] ${host.label} extension tree: ${dest}`);
     }
@@ -53,11 +52,14 @@ async function fixOpencodeEntry() {
     const { HOME } = await import('./common.js');
     const dir = path.join(HOME, '.config', 'opencode', 'plugins', 'tersio');
     const configPath = path.join(HOME, '.config', 'opencode', 'opencode.json');
-    const nested = path.join(dir, 'opencode', 'server.ts');
-    if (!(await readTextIfExists(nested)))
-        return;
-    // The loader resolves <pluginDir>/server.ts, so mirror the entry at the tree root.
-    await writeIfChanged(path.join(dir, 'server.ts'), OPENCODE_SERVER_SHIM, { dryRun, verbose });
+    // The loader resolves <pluginDir>/server.ts, and the entry is that file. A tree from before the
+    // entry moved to the extensions root held a root shim that re-exported a nested copy, so the
+    // real entry is written in place and the stale nested tree is dropped.
+    const nested = path.join(dir, 'opencode');
+    const staleNested = (await readTextIfExists(path.join(nested, 'server.ts'))) !== null;
+    await syncTreeFiles(dir, TREE_FILES.filter((file) => !file.includes('/')), { dryRun, verbose });
+    if (staleNested && !dryRun)
+        await fs.rm(nested, { recursive: true, force: true }).catch(() => { });
     if (dryRun)
         sayTagged(`  [dry-run] would remove the redundant rtk plugin entry`);
     else
@@ -91,23 +93,16 @@ async function fixExtensions(pluginsDir) {
     const pluginExtDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio', 'extensions');
     await fs.mkdir(pluginExtDir, { recursive: true });
     // Rule bodies are never overwritten: they can be newer upstream fetches.
-    const ruleFile = (f) => /^caveman-session\/rule.*\.md$/.test(f);
-    for (const file of TREE_FILES) {
-        const dest = path.join(pluginExtDir, ...file.split('/'));
-        if (ruleFile(file) && existsSync(dest))
-            continue;
-        const text = await readTextIfExists(sourcePath(file));
-        if (text === null)
-            sayTagged(`  [warn] bundled source missing: ${sourcePath(file)}`);
-        else
-            await writeIfChanged(dest, text, { dryRun, verbose });
-    }
+    const ruleFile = (f) => /^caveman\/rule.*\.md$/.test(f);
+    const missing = await syncTreeFiles(pluginExtDir, TREE_FILES, { dryRun, verbose }, (file) => ruleFile(file) && existsSync(path.join(pluginExtDir, ...file.split('/'))));
+    for (const from of missing)
+        sayTagged(`  [warn] bundled source missing: ${from}`);
     // Writing is not atomic, so re-read rather than assume the tree is whole.
     if (dryRun)
         return;
-    const missing = TREE_FILES.filter((file) => !existsSync(path.join(pluginExtDir, ...file.split('/'))));
-    if (missing.length > 0)
-        sayTagged(`  [fail] tree incomplete: ${missing.join(', ')}`);
+    const stillMissing = TREE_FILES.filter((file) => !existsSync(path.join(pluginExtDir, ...file.split('/'))));
+    if (stillMissing.length > 0)
+        sayTagged(`  [fail] tree incomplete: ${stillMissing.join(', ')}`);
     else
         sayTagged(`  [ok] extension tree: ${TREE_FILES.length} files`);
 }
@@ -127,7 +122,9 @@ async function fixRegistrations(agentDir, pluginsDir) {
     if ((await readTextIfExists(rtkTs)) !== null)
         await ensureRtkInConfig({ dryRun, verbose });
     const ponytailExtPath = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js');
-    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo-toggle', 'index.ts'), 'manifest-loaded combo', { dryRun, verbose });
+    // A tree from before the fold still names `combo-toggle`; both lines name the same module.
+    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo', 'index.ts'), 'manifest-loaded combo', { dryRun, verbose });
+    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo-toggle', 'index.ts'), 'retired manifest-loaded combo', { dryRun, verbose });
     await removeExtensionFromConfig(configPath, ponytailExtPath, 'manifest-loaded ponytail', { dryRun, verbose });
     await removeExtensionFromConfig(configPath, path.join(extDir, 'shared', 'mode-reinforcement.ts'), 'retired mode reinforcement', { dryRun, verbose });
     const pkgPath = path.join(pluginsDir, 'package.json');
@@ -146,7 +143,7 @@ async function fixRtk(binDir) {
     console.log('  Doctor --fix: repairing RTK binary + wiring');
     const binDest = path.join(binDir, RTK_BINARY_NAME);
     if (dryRun) {
-        sayTagged(`  [dry-run] would download a checksum-verified rtk to ${binDest} and wire it into OMP`);
+        sayTagged(`  [dry-run] would download a checksum-verified rtk to ${binDest} and wire it into the installed hosts`);
         return;
     }
     const spec = rtkPlatformSpec();