teamshare-bridge 0.26.20 → 0.26.21

package/dist/lib/llm/usage-reader.js

@@ -1,40 +1,141 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_USAGE_HARNESSES = exports.USAGE_HARNESSES = void 0;
+exports.todayLocalDay = todayLocalDay;
+exports.dayBounds = dayBounds;
+exports.estimateModelCost = estimateModelCost;
+exports.readOpencodeSessions = readOpencodeSessions;
+exports.readClaudeSessions = readClaudeSessions;
+exports.readCodexSessions = readCodexSessions;
 exports.readUsageReport = readUsageReport;
 /**
- * Usage report reader — reads cost data directly from harness databases.
+ * Usage report reader — reads cost data directly from harness-local stores.
  *
- * Replaces the Python tools/usage_report.py with in-process Node reads via
- * better-sqlite3. Supports multiple providers:
- *   - opencode: ~/.local/share/opencode/opencode.db (session table)
- *   - codex: ~/.codex/logs_2.sqlite (logs table, no cost data yet)
- *   - claude/gemini: no local cost database (returns empty)
+ * Each supported harness keeps its own ledger on this machine:
+ *   - opencode: ~/.local/share/opencode/opencode.db (`session_v2` table;
+ *     the legacy `session` table stopped at V2 and is only a fallback).
+ *     Cost + all token counts are recorded per session.
+ *   - claude: ~/.claude/projects (jsonl transcripts holding `message.usage`
+ *     per assistant message). Tokens are real; cost is ESTIMATED from
+ *     catalogue (`~/.cache/opencode/models.json`).
+ *   - codex: ~/.codex/sessions (rollout-*.jsonl files holding `token_count`
+ *     events with `last_token_usage`). Tokens are real; cost is ESTIMATED the
+ *     same way. Only `last_token_usage` deltas are summed — `total_token_usage`
+ *     is cumulative per session and summing it would massively overcount.
+ *
+ * Every other harness the bridge knows (gemini, antigravity, copilot, cursor,
+ * goose, openhands, aider, cline, openrouter) keeps no local token/cost data,
+ * so it is listed as unavailable with the reason instead of a silent zero.
  *
  * The report is fully offline, needs neither the backend nor the daemon.
  */
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
-// ── Provider-specific database paths ──────────────────────────────────────
-function opencodeDbPath() {
-    return (0, node_path_1.join)((0, node_os_1.homedir)(), '.local', 'share', 'opencode', 'opencode.db');
-}
-function codexDbPath() {
-    return (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex', 'logs_2.sqlite');
-}
-/** Returns the first available provider path, or null if none found. */
-function detectProvider() {
-    const opencodePath = opencodeDbPath();
-    if ((0, node_fs_1.existsSync)(opencodePath))
-        return { name: 'opencode', dbPath: opencodePath };
-    const codexPath = codexDbPath();
-    if ((0, node_fs_1.existsSync)(codexPath))
-        return { name: 'codex', dbPath: codexPath };
-    return null;
+exports.USAGE_HARNESSES = [
+    {
+        id: 'opencode',
+        label: 'Opencode',
+        supported: true,
+        costSource: 'recorded',
+    },
+    {
+        id: 'claude',
+        label: 'Claude Code',
+        supported: true,
+        costSource: 'estimated',
+    },
+    { id: 'codex', label: 'Codex', supported: true, costSource: 'estimated' },
+    {
+        id: 'gemini',
+        label: 'Gemini CLI',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Gemini CLI keeps chat logs only — no token or cost data is stored locally',
+    },
+    {
+        id: 'antigravity',
+        label: 'Antigravity',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Antigravity transcripts record steps only — no token or cost data',
+    },
+    {
+        id: 'copilot',
+        label: 'Copilot CLI',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Copilot CLI has no local usage store',
+    },
+    {
+        id: 'cursor',
+        label: 'Cursor',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Cursor usage lives in the Cursor dashboard — no local store',
+    },
+    {
+        id: 'goose',
+        label: 'Goose',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Goose has no local usage store on this machine',
+    },
+    {
+        id: 'openhands',
+        label: 'OpenHands',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'OpenHands has no local usage store on this machine',
+    },
+    {
+        id: 'aider',
+        label: 'Aider',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Aider has no local usage store',
+    },
+    {
+        id: 'cline',
+        label: 'Cline',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'Cline session files record provider and model but no token counts',
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        supported: false,
+        costSource: 'unavailable',
+        unavailableReason: 'OpenRouter is a hosted gateway — usage lives on its dashboard',
+    },
+];
+exports.SUPPORTED_USAGE_HARNESSES = exports.USAGE_HARNESSES.filter((h) => h.supported).map((h) => h.id);
+function harnessDef(id) {
+    return exports.USAGE_HARNESSES.find((h) => h.id === id);
+}
+// ── Paths ───────────────────────────────────────────────────────────────────
+function opencodeDbPath(home) {
+    return (0, node_path_1.join)(home, '.local', 'share', 'opencode', 'opencode.db');
+}
+function claudeProjectsPath(home) {
+    return (0, node_path_1.join)(home, '.claude', 'projects');
 }
-// ── Day bounds (local midnight ms-epoch) ─────────────────────────────────
-function today() {
-    return new Date().toISOString().slice(0, 10);
+function codexSessionsPath(home) {
+    return (0, node_path_1.join)(home, '.codex', 'sessions');
+}
+function codexIndexPath(home) {
+    return (0, node_path_1.join)(home, '.codex', 'session_index.jsonl');
+}
+function modelsCatalogPath(home) {
+    return (0, node_path_1.join)(home, '.cache', 'opencode', 'models.json');
+}
+// ── Day bounds (local midnight ms-epoch) ────────────────────────────────────
+function todayLocalDay() {
+    const now = new Date();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const date = String(now.getDate()).padStart(2, '0');
+    return `${now.getFullYear()}-${month}-${date}`;
 }
 function dayBounds(day) {
     const d = new Date(`${day}T00:00:00`);
@@ -43,6 +144,113 @@ function dayBounds(day) {
     const end = new Date(start.getTime() + 86_400_000);
     return { startMs: start.getTime(), endMs: end.getTime() };
 }
+let priceCache = null;
+function stripDateSuffix(id) {
+    return id.replace(/-20\d{6}(-\d+)?$/, '').replace(/-\d{4}-\d{2}-\d{2}$/, '');
+}
+function toPrice(raw, fallbackOutput) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const c = raw;
+    const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : 0;
+    // Catalogue rates are per MTok USD.
+    return {
+        input: num(c.input),
+        output: num(c.output) || fallbackOutput,
+        cacheRead: num(c.cache_read ?? c.cacheRead),
+        cacheWrite: num(c.cache_write ?? c.cacheWrite),
+    };
+}
+function loadPricing(home) {
+    const path = modelsCatalogPath(home);
+    let mtimeMs = 0;
+    try {
+        mtimeMs = (0, node_fs_1.statSync)(path).mtimeMs;
+    }
+    catch {
+        priceCache = { home, mtimeMs: -1, map: new Map() };
+        return priceCache.map;
+    }
+    if (priceCache &&
+        priceCache.home === home &&
+        priceCache.mtimeMs === mtimeMs) {
+        return priceCache.map;
+    }
+    const map = new Map();
+    try {
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+        for (const provider of Object.values(raw)) {
+            if (!provider || typeof provider !== 'object')
+                continue;
+            const models = provider.models;
+            if (!models || typeof models !== 'object')
+                continue;
+            for (const [id, entry] of Object.entries(models)) {
+                if (map.has(id))
+                    continue;
+                const price = toPrice(entry?.cost ?? entry, 0);
+                if (price)
+                    map.set(id, price);
+            }
+        }
+    }
+    catch {
+        /* corrupt catalogue reads as empty — tokens still reported */
+    }
+    priceCache = { home, mtimeMs, map };
+    return map;
+}
+/**
+ * Estimate a session/message cost from the catalogue. Returns cost 0 with
+ * known=false when the model has no price — the caller still reports tokens.
+ * `style` decides how cached input is charged: claude reports cache tokens
+ * separately from input; codex `input_tokens` already include the cached
+ * ones, so only the fresh remainder is charged at the input rate.
+ */
+function estimateModelCost(modelId, tokens, style, home = (0, node_os_1.homedir)()) {
+    if (!modelId || modelId === '<synthetic>')
+        return { cost: 0, known: false };
+    const map = loadPricing(home);
+    const price = map.get(modelId) ??
+        map.get(stripDateSuffix(modelId)) ??
+        map.get(modelId.toLowerCase());
+    if (!price)
+        return { cost: 0, known: false };
+    const freshInput = style === 'codex'
+        ? Math.max(0, tokens.input - tokens.cacheRead)
+        : tokens.input;
+    const cost = (freshInput * price.input +
+        tokens.cacheRead * (price.cacheRead || 0) +
+        tokens.cacheWrite * (price.cacheWrite || price.output) +
+        tokens.output * price.output) /
+        1_000_000;
+    return { cost: round6(cost), known: true };
+}
+// ── Attribution ─────────────────────────────────────────────────────────────
+/**
+ * The exact title shapes the bridge passes as `--title` (case-sensitive):
+ * `TeamShare task <taskId> (agent <agentId>)` (run.ts), `TeamShare chat/doc …`,
+ * `Tool run <key> (<runId>)` (research.ts), `Plan task <taskId>` (plan.ts).
+ * A loose prefix would mislabel a human's own window that merely mentions
+ * TeamShare (e.g. "Teamshare quota display …"), so the shape is matched.
+ */
+const TEAMSHARE_TITLE_RE = /^(TeamShare (task|chat|doc) |Tool run [\w-]+ \(|Plan task )/;
+function isTeamshareWork(title, directory) {
+    if (directory.includes('.teamshare-runs') ||
+        directory.includes('.teamshare-worktrees')) {
+        return true;
+    }
+    return TEAMSHARE_TITLE_RE.test(title);
+}
+function attributeSession(title, directory) {
+    // NOTE: opencode's `agent` column is the subagent lane (build/explore/plan)
+    // and is set on interactive windows too, so it can never discriminate.
+    // The only reliable join key is where the session ran / what it is titled.
+    if (isTeamshareWork(title, directory))
+        return { attribution: 'agent', teamshare: true };
+    return { attribution: 'user', teamshare: false };
+}
+// ── Model parsing ───────────────────────────────────────────────────────────
 function parseModel(modelJson) {
     if (!modelJson)
         return {};
@@ -54,31 +262,54 @@ function parseModel(modelJson) {
         return {};
     }
 }
-// ── Attribution ───────────────────────────────────────────────────────────
-function attributeSession(title, providerId) {
-    if (title?.startsWith('TeamShare '))
-        return { attribution: 'agent', teamshare: true };
-    // opencode-go / opencode: providerID == "opencode" or "opencode-go" = user sessions
-    if (providerId === 'opencode' || providerId === 'opencode-go')
-        return { attribution: 'user', teamshare: false };
-    // claude, codex, gemini, etc. — treat as agent sessions
-    return { attribution: 'agent', teamshare: false };
-}
-// ── opencode reader ──────────────────────────────────────────────────────
-function readOpencode(dbPath, day, agentFilter) {
-    // Lazy-import better-sqlite3 so non-opencode providers don't need it loaded.
+function pickOpencodeTable(db) {
+    try {
+        const tables = new Set(db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+            .all().map((t) => t.name));
+        // V2 is the live table; legacy `session` stopped in 2026-10. Never read
+        // both — every legacy id also exists in session_v2, so a union would
+        // double-count.
+        if (tables.has('session_v2'))
+            return 'session_v2';
+        if (tables.has('session'))
+            return 'session';
+    }
+    catch {
+        /* fall through */
+    }
+    throw new Error('opencode.db has neither session_v2 nor session table');
+}
+function hasColumn(db, table, col) {
+    try {
+        const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+        return cols.some((c) => c.name === col);
+    }
+    catch {
+        return false;
+    }
+}
+function readOpencodeSessions(day, agentFilter, home = (0, node_os_1.homedir)()) {
+    const dbPath = opencodeDbPath(home);
+    if (!(0, node_fs_1.existsSync)(dbPath)) {
+        throw new Error(`opencode db not found at ${dbPath} — has opencode ever run?`);
+    }
+    // Lazy-import better-sqlite3 so jsonl-only harnesses never load it.
     const Database = require('better-sqlite3');
     const db = new Database(dbPath, {
         readonly: true,
         fileMustExist: true,
     });
     try {
+        const table = pickOpencodeTable(db);
+        const wantDir = hasColumn(db, table, 'directory');
+        const wantAgent = hasColumn(db, table, 'agent');
         const { startMs, endMs } = dayBounds(day);
         const rows = db
             .prepare(`SELECT title, model, cost, tokens_input, tokens_output,
               tokens_reasoning, tokens_cache_read, tokens_cache_write,
-              time_created, time_updated
-       FROM session WHERE time_created >= ? AND time_created < ?
+              time_created, time_updated${wantDir ? ', directory' : ''}${wantAgent ? ', agent' : ''}
+       FROM ${table} WHERE time_created >= ? AND time_created < ?
        ORDER BY time_created`)
             .all(startMs, endMs);
         const sessions = [];
@@ -97,7 +328,8 @@ function readOpencode(dbPath, day, agentFilter) {
                 continue;
             const model = parseModel(row.model);
             const providerId = model.providerID ?? '';
-            const { attribution, teamshare } = attributeSession(title, providerId);
+            const directory = row.directory ?? '';
+            const { attribution, teamshare } = attributeSession(title, directory);
             // Agent filter
             if (agentFilter &&
                 !title.toLowerCase().includes(`agent ${agentFilter}`.toLowerCase()))
@@ -106,7 +338,10 @@ function readOpencode(dbPath, day, agentFilter) {
                 title,
                 model: model.id ?? '',
                 providerID: providerId,
+                harness: 'opencode',
                 cost: round6(cost),
+                costEstimated: false,
+                costKnown: true,
                 tokensInput: tIn,
                 tokensOutput: tOut,
                 tokensReasoning: tReason,
@@ -119,108 +354,512 @@ function readOpencode(dbPath, day, agentFilter) {
                 teamshare,
             });
         }
-        return buildReport(day, dbPath, 'opencode', sessions);
+        return { sessions, source: dbPath };
     }
     finally {
         db.close();
     }
 }
-// ── Codex reader (placeholder — no cost data yet) ────────────────────────
-function readCodex(dbPath, day) {
-    const Database = require('better-sqlite3');
-    const db = new Database(dbPath, {
-        readonly: true,
-        fileMustExist: true,
-    });
+// ── jsonl helpers ───────────────────────────────────────────────────────────
+function walkJsonl(root, cap, newerThanMs, out = []) {
+    if (out.length >= cap)
+        return out;
+    let entries;
     try {
-        // Codex logs_2.sqlite has a logs table but no cost/token columns yet.
-        // Return empty report — ready for when codex adds cost data.
-        return buildReport(day, dbPath, 'codex', []);
+        entries = (0, node_fs_1.readdirSync)(root, { withFileTypes: true });
     }
-    finally {
-        db.close();
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (out.length >= cap)
+            break;
+        const full = (0, node_path_1.join)(root, entry.name);
+        try {
+            if (entry.isDirectory()) {
+                walkJsonl(full, cap, newerThanMs, out);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                try {
+                    if ((0, node_fs_1.statSync)(full).mtimeMs >= newerThanMs)
+                        out.push(full);
+                }
+                catch {
+                    /* unreadable — skip */
+                }
+            }
+        }
+        catch {
+            /* best-effort walk */
+        }
+    }
+    return out;
+}
+function parseTimeMs(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value > 1e12 ? value : value * 1000;
+    }
+    if (typeof value === 'string' && value) {
+        const ms = new Date(value).getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    return null;
+}
+function readClaudeSessions(day, agentFilter, home = (0, node_os_1.homedir)()) {
+    const root = claudeProjectsPath(home);
+    if (!(0, node_fs_1.existsSync)(root)) {
+        throw new Error(`no Claude projects at ${root} — has Claude Code ever run here?`);
+    }
+    const { startMs, endMs } = dayBounds(day);
+    const files = walkJsonl(root, 2000, startMs);
+    const buckets = new Map();
+    for (const file of files) {
+        let text;
+        try {
+            text = (0, node_fs_1.readFileSync)(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (obj.type !== 'assistant')
+                continue;
+            const message = obj.message;
+            const usage = message?.usage;
+            if (!usage)
+                continue;
+            const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : 0;
+            const tIn = num(usage.input_tokens);
+            const tOut = num(usage.output_tokens);
+            const tCr = num(usage.cache_read_input_tokens);
+            const tCw = num(usage.cache_creation_input_tokens ?? usage.cache_creation_tokens);
+            if (!tIn && !tOut && !tCr && !tCw)
+                continue;
+            const at = parseTimeMs(obj.timestamp);
+            if (at === null || at < startMs || at >= endMs)
+                continue;
+            const sessionId = typeof obj.sessionId === 'string' && obj.sessionId
+                ? obj.sessionId
+                : file;
+            const cwd = typeof obj.cwd === 'string' ? obj.cwd : '';
+            const model = typeof message?.model === 'string' && message.model
+                ? message.model
+                : '';
+            let bucket = buckets.get(sessionId);
+            if (!bucket) {
+                bucket = {
+                    sessionId,
+                    cwd,
+                    model,
+                    firstMs: at,
+                    lastMs: at,
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    cost: 0,
+                    known: false,
+                };
+                buckets.set(sessionId, bucket);
+            }
+            if (model && model !== '<synthetic>')
+                bucket.model = model;
+            if (cwd && !bucket.cwd)
+                bucket.cwd = cwd;
+            bucket.firstMs = Math.min(bucket.firstMs, at);
+            bucket.lastMs = Math.max(bucket.lastMs, at);
+            bucket.input += tIn;
+            bucket.output += tOut;
+            bucket.cacheRead += tCr;
+            bucket.cacheWrite += tCw;
+            if (model) {
+                const est = estimateModelCost(model, { input: tIn, output: tOut, cacheRead: tCr, cacheWrite: tCw }, 'claude', home);
+                bucket.cost = round6(bucket.cost + est.cost);
+                if (est.known)
+                    bucket.known = true;
+            }
+        }
+    }
+    const sessions = [];
+    for (const bucket of buckets.values()) {
+        const shortCwd = bucket.cwd ? (0, node_path_1.basename)(bucket.cwd) : '';
+        const title = shortCwd
+            ? `Claude · ${shortCwd}`
+            : `Claude ${bucket.sessionId.slice(0, 8)}`;
+        if (agentFilter &&
+            !title.toLowerCase().includes(`agent ${agentFilter}`.toLowerCase()) &&
+            !bucket.cwd.toLowerCase().includes(agentFilter.toLowerCase())) {
+            continue;
+        }
+        const { attribution, teamshare } = attributeSession(title, bucket.cwd);
+        sessions.push({
+            title,
+            model: bucket.model,
+            providerID: 'anthropic',
+            harness: 'claude',
+            cost: bucket.cost,
+            costEstimated: true,
+            costKnown: bucket.known,
+            tokensInput: bucket.input,
+            tokensOutput: bucket.output,
+            tokensReasoning: 0,
+            tokensCacheRead: bucket.cacheRead,
+            tokensCacheWrite: bucket.cacheWrite,
+            timeCreated: bucket.firstMs,
+            timeUpdated: bucket.lastMs,
+            durationMin: round1(Math.max(0, bucket.lastMs - bucket.firstMs) / 60_000),
+            attribution,
+            teamshare,
+        });
+    }
+    sessions.sort((a, b) => a.timeCreated - b.timeCreated);
+    return { sessions, source: root };
+}
+// ── codex reader ────────────────────────────────────────────────────────────
+function readCodexSessions(day, agentFilter, home = (0, node_os_1.homedir)()) {
+    const root = codexSessionsPath(home);
+    if (!(0, node_fs_1.existsSync)(root)) {
+        throw new Error(`no Codex sessions at ${root} — has Codex ever run here?`);
+    }
+    const { startMs, endMs } = dayBounds(day);
+    // Cross-midnight sessions live in the previous day's directory, so the
+    // mtime gate opens a day early and each event is filtered by its own time.
+    const files = walkJsonl(root, 500, startMs - 86_400_000);
+    // Thread names live beside the sessions, not in them.
+    const threadNames = new Map();
+    try {
+        const indexText = (0, node_fs_1.readFileSync)(codexIndexPath(home), 'utf8');
+        for (const line of indexText.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const row = JSON.parse(trimmed);
+                if (typeof row.id === 'string' && typeof row.thread_name === 'string') {
+                    threadNames.set(row.id, row.thread_name);
+                }
+            }
+            catch {
+                /* malformed index line — skip */
+            }
+        }
+    }
+    catch {
+        /* no index — titles fall back to the session id */
+    }
+    const buckets = new Map();
+    for (const file of files) {
+        let text;
+        try {
+            text = (0, node_fs_1.readFileSync)(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const base = (0, node_path_1.basename)(file, '.jsonl');
+        const fileSessionId = base.startsWith('rollout-')
+            ? base.slice('rollout-'.length)
+            : base;
+        const ensure = () => {
+            let b = buckets.get(file);
+            if (!b) {
+                b = {
+                    key: file,
+                    sessionId: fileSessionId,
+                    cwd: '',
+                    model: '',
+                    firstMs: Number.MAX_SAFE_INTEGER,
+                    lastMs: 0,
+                    input: 0,
+                    cached: 0,
+                    output: 0,
+                    reasoning: 0,
+                };
+                buckets.set(file, b);
+            }
+            return b;
+        };
+        for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const payload = obj.payload;
+            if (obj.type === 'session_meta' && payload) {
+                const b = ensure();
+                if (typeof payload.id === 'string' && payload.id) {
+                    b.sessionId = payload.id;
+                }
+                if (typeof payload.cwd === 'string')
+                    b.cwd = payload.cwd;
+                if (typeof payload.model === 'string' && payload.model) {
+                    b.model = payload.model;
+                }
+                continue;
+            }
+            if (obj.type === 'turn_context' && payload) {
+                const model = payload.model;
+                if (typeof model === 'string' && model)
+                    ensure().model = model;
+                continue;
+            }
+            if (obj.type !== 'event_msg' || !payload)
+                continue;
+            if (payload.type !== 'token_count')
+                continue;
+            const info = payload.info;
+            const last = info?.last_token_usage;
+            if (!last)
+                continue;
+            const at = parseTimeMs(obj.timestamp);
+            if (at === null || at < startMs || at >= endMs)
+                continue;
+            const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : 0;
+            const b = ensure();
+            b.firstMs = Math.min(b.firstMs, at);
+            b.lastMs = Math.max(b.lastMs, at);
+            b.input += num(last.input_tokens);
+            b.cached += num(last.cached_input_tokens);
+            b.output += num(last.output_tokens);
+            b.reasoning += num(last.reasoning_output_tokens);
+        }
+    }
+    const sessions = [];
+    for (const bucket of buckets.values()) {
+        if (bucket.lastMs === 0)
+            continue;
+        const title = threadNames.get(bucket.sessionId) ??
+            `Codex ${bucket.sessionId.slice(0, 8)}`;
+        if (agentFilter &&
+            !title.toLowerCase().includes(`agent ${agentFilter}`.toLowerCase()) &&
+            !bucket.cwd.toLowerCase().includes(agentFilter.toLowerCase())) {
+            continue;
+        }
+        const est = estimateModelCost(bucket.model, {
+            input: bucket.input,
+            output: bucket.output,
+            cacheRead: bucket.cached,
+            cacheWrite: 0,
+        }, 'codex', home);
+        const { attribution, teamshare } = attributeSession(title, bucket.cwd);
+        sessions.push({
+            title,
+            model: bucket.model,
+            providerID: 'openai',
+            harness: 'codex',
+            cost: est.cost,
+            costEstimated: true,
+            costKnown: est.known,
+            tokensInput: bucket.input,
+            tokensOutput: bucket.output,
+            // Reasoning tokens ride inside output_tokens on the Responses API —
+            // recorded for display, never charged twice.
+            tokensReasoning: bucket.reasoning,
+            tokensCacheRead: bucket.cached,
+            tokensCacheWrite: 0,
+            timeCreated: bucket.firstMs,
+            timeUpdated: bucket.lastMs,
+            durationMin: round1(Math.max(0, bucket.lastMs - bucket.firstMs) / 60_000),
+            attribution,
+            teamshare,
+        });
+    }
+    sessions.sort((a, b) => a.timeCreated - b.timeCreated);
+    return { sessions, source: root };
+}
+// ── Availability probe ──────────────────────────────────────────────────────
+function probeHarness(def, home) {
+    if (!def.supported) {
+        return { available: false, reason: def.unavailableReason };
+    }
+    if (def.id === 'opencode') {
+        const p = opencodeDbPath(home);
+        return (0, node_fs_1.existsSync)(p)
+            ? { available: true, source: p }
+            : {
+                available: false,
+                reason: 'opencode has not run on this machine yet (no opencode.db)',
+            };
     }
+    if (def.id === 'claude') {
+        const p = claudeProjectsPath(home);
+        return (0, node_fs_1.existsSync)(p)
+            ? { available: true, source: p }
+            : {
+                available: false,
+                reason: 'no Claude Code history on this machine yet',
+            };
+    }
+    const p = codexSessionsPath(home);
+    return (0, node_fs_1.existsSync)(p)
+        ? { available: true, source: p }
+        : { available: false, reason: 'no Codex history on this machine yet' };
+}
+// ── Report builder ──────────────────────────────────────────────────────────
+function emptyTotals() {
+    return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
 }
-// ── Report builder ────────────────────────────────────────────────────────
-function buildReport(day, dbPath, provider, sessions) {
+function buildReport(day, harness, sessions, harnesses, totalsByHarness, sources, dbPath, notice) {
     const totalCost = round6(sessions.reduce((s, x) => s + x.cost, 0));
     const userCost = round6(sessions
         .filter((s) => s.attribution === 'user')
         .reduce((s, x) => s + x.cost, 0));
     const agentCost = round6(totalCost - userCost);
     const teamshareCost = round6(sessions.filter((s) => s.teamshare).reduce((s, x) => s + x.cost, 0));
+    const tokens = emptyTotals();
+    for (const s of sessions) {
+        tokens.input += s.tokensInput;
+        tokens.output += s.tokensOutput;
+        tokens.reasoning += s.tokensReasoning;
+        tokens.cacheRead += s.tokensCacheRead;
+        tokens.cacheWrite += s.tokensCacheWrite;
+    }
     return {
         day,
+        harness,
         dbPath,
-        provider,
+        sources,
+        provider: harness,
         totalCost,
         sessionCount: sessions.length,
         userCost,
         agentCost,
         teamshareCost,
-        tokens: {
-            input: sessions.reduce((s, x) => s + x.tokensInput, 0),
-            output: sessions.reduce((s, x) => s + x.tokensOutput, 0),
-            reasoning: sessions.reduce((s, x) => s + x.tokensReasoning, 0),
-            cacheRead: sessions.reduce((s, x) => s + x.tokensCacheRead, 0),
-            cacheWrite: sessions.reduce((s, x) => s + x.tokensCacheWrite, 0),
-        },
+        unpricedSessions: sessions.filter((s) => !s.costKnown).length,
+        ...(notice ? { notice } : {}),
+        harnesses,
+        totalsByHarness,
+        tokens,
         sessions,
     };
 }
-// ── Helpers ───────────────────────────────────────────────────────────────
-function round6(n) {
-    return Math.round(n * 1_000_000) / 1_000_000;
-}
-function round1(n) {
-    return Math.round(n * 10) / 10;
-}
-// ── Public API ────────────────────────────────────────────────────────────
+// ── Public API ──────────────────────────────────────────────────────────────
 /**
- * Read the usage report directly from the harness database.
- * Auto-detects the provider (opencode > codex) or uses the explicit option.
- * Throws if no provider database is found.
+ * Read one harness (or 'all' supported harnesses) for a local day.
+ * Each harness is its own report slice: sessions carry `harness`,
+ * `costEstimated` and `costKnown`, and the UI switches between them.
+ * Throws when no local store exists for an explicitly requested harness.
  */
 function readUsageReport(opts = {}) {
-    const day = opts.day ?? today();
-    if (opts.provider === 'opencode') {
-        const dbPath = opencodeDbPath();
-        if (!(0, node_fs_1.existsSync)(dbPath))
-            throw new Error(`opencode db not found at ${dbPath} — has opencode ever run?`);
-        return readOpencode(dbPath, day, opts.agent ?? null);
-    }
-    if (opts.provider === 'codex') {
-        const dbPath = codexDbPath();
-        if (!(0, node_fs_1.existsSync)(dbPath))
-            throw new Error(`codex db not found at ${dbPath} — has codex ever run?`);
-        return readCodex(dbPath, day);
-    }
-    // Auto-detect
-    const detected = detectProvider();
-    if (!detected) {
-        return {
-            day,
-            dbPath: '(no provider database found)',
-            provider: 'none',
-            totalCost: 0,
-            sessionCount: 0,
-            userCost: 0,
-            agentCost: 0,
-            teamshareCost: 0,
+    const home = opts.homeDir ?? (0, node_os_1.homedir)();
+    const day = opts.day ?? todayLocalDay();
+    const requested = opts.harness ?? (opts.provider === 'codex' ? 'codex' : 'opencode');
+    const agentFilter = opts.agent ?? null;
+    const infos = new Map();
+    const totals = {};
+    const sources = {};
+    const allSessions = [];
+    const readOne = (id) => {
+        const def = harnessDef(id);
+        if (!def) {
+            throw new Error(`unknown harness "${id}" — supported: ${exports.SUPPORTED_USAGE_HARNESSES.join(', ')}`);
+        }
+        if (!def.supported) {
+            // The honest answer carries the reason, not a silent zero.
+            throw new Error(def.unavailableReason ?? `usage is not supported for harness "${id}"`);
+        }
+        const probe = probeHarness(def, home);
+        if (!probe.available) {
+            throw new Error(probe.reason ?? `no local data for ${id}`);
+        }
+        const { sessions, source } = id === 'opencode'
+            ? readOpencodeSessions(day, agentFilter, home)
+            : id === 'claude'
+                ? readClaudeSessions(day, agentFilter, home)
+                : readCodexSessions(day, agentFilter, home);
+        sources[id] = source;
+        const cost = round6(sessions.reduce((s, x) => s + x.cost, 0));
+        const info = {
+            id,
+            label: def.label,
+            available: true,
+            costSource: def.costSource,
+            sessions: sessions.length,
+            cost,
             tokens: {
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
+                input: sessions.reduce((s, x) => s + x.tokensInput, 0),
+                output: sessions.reduce((s, x) => s + x.tokensOutput, 0),
             },
-            sessions: [],
         };
+        infos.set(id, info);
+        totals[id] = {
+            sessions: sessions.length,
+            cost,
+            costEstimated: def.costSource === 'estimated',
+            unpricedSessions: sessions.filter((s) => !s.costKnown).length,
+        };
+        allSessions.push(...sessions);
+    };
+    if (requested === 'all') {
+        for (const id of exports.SUPPORTED_USAGE_HARNESSES) {
+            try {
+                readOne(id);
+            }
+            catch {
+                // A harness with no local store contributes nothing — its
+                // unavailability is still listed below.
+            }
+        }
+    }
+    else {
+        readOne(requested);
+    }
+    // Every known harness is listed so the UI can offer exactly the
+    // supported ones and explain the rest.
+    const harnesses = exports.USAGE_HARNESSES.map((def) => {
+        const read = infos.get(def.id);
+        if (read)
+            return read;
+        const probe = probeHarness(def, home);
+        return {
+            id: def.id,
+            label: def.label,
+            available: false,
+            ...(probe.reason ? { reason: probe.reason } : {}),
+            costSource: def.costSource,
+            sessions: 0,
+            cost: 0,
+            tokens: { input: 0, output: 0 },
+        };
+    });
+    for (const def of exports.USAGE_HARNESSES) {
+        if (!totals[def.id]) {
+            totals[def.id] = {
+                sessions: 0,
+                cost: 0,
+                costEstimated: def.costSource === 'estimated',
+                unpricedSessions: 0,
+            };
+        }
     }
-    if (detected.name === 'opencode')
-        return readOpencode(detected.dbPath, day, opts.agent ?? null);
-    if (detected.name === 'codex')
-        return readCodex(detected.dbPath, day);
-    return buildReport(day, '(unknown)', 'none', []);
+    allSessions.sort((a, b) => a.timeCreated - b.timeCreated);
+    const dbPath = sources[requested] ??
+        sources.opencode ??
+        sources[Object.keys(sources)[0] ?? ''] ??
+        '(no provider database found)';
+    return buildReport(day, requested, allSessions, harnesses, totals, sources, dbPath);
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function round6(n) {
+    return Math.round(n * 1_000_000) / 1_000_000;
+}
+function round1(n) {
+    return Math.round(n * 10) / 10;
 }
 //# sourceMappingURL=usage-reader.js.map