tokens-metric 0.4.2 → 0.4.4

package/dist/core/detect.js

@@ -8,6 +8,12 @@ export function claudeHome() {
 export function claudeConfigPath() {
     return join(homedir(), '.claude.json');
 }
+export function codexHome() {
+    return join(homedir(), '.codex');
+}
+export function codexSessionsDir() {
+    return join(codexHome(), 'sessions');
+}
 /**
  * Detect whether Claude Code is installed, the user is logged in, and best-
  * effort what plan they're on. All signals are LOCAL and BEST-EFFORT — we

package/dist/core/format.js

@@ -17,15 +17,37 @@ const PRICES_PER_MTOK = {
     'claude-opus-4': { in: 15, out: 75, cacheWrite: 18.75, cacheRead: 1.5 },
     // Haiku 4.x family
     'claude-haiku-4': { in: 0.8, out: 4, cacheWrite: 1, cacheRead: 0.08 },
+    // OpenAI o4-mini — default Codex CLI model; also used for "codex" key
+    'openai-o4-mini': { in: 1.1, out: 4.4, cacheWrite: 0, cacheRead: 0.275 },
+    // OpenAI o3
+    'openai-o3': { in: 10, out: 40, cacheWrite: 0, cacheRead: 2.5 },
+    // OpenAI o3-mini
+    'openai-o3-mini': { in: 1.1, out: 4.4, cacheWrite: 0, cacheRead: 0.275 },
+    // OpenAI GPT-4o
+    'openai-gpt-4o': { in: 2.5, out: 10, cacheWrite: 0, cacheRead: 1.25 },
+    // OpenAI GPT-4o mini
+    'openai-gpt-4o-mini': { in: 0.15, out: 0.6, cacheWrite: 0, cacheRead: 0.075 },
 };
 function priceKey(model) {
     const m = model.toLowerCase();
+    // Claude
     if (m.includes('opus'))
         return 'claude-opus-4';
     if (m.includes('haiku'))
         return 'claude-haiku-4';
     if (m.includes('sonnet'))
         return 'claude-sonnet-4';
+    // OpenAI / Codex — "codex" key maps to o4-mini (Codex CLI default)
+    if (m === 'codex' || m.includes('o4-mini'))
+        return 'openai-o4-mini';
+    if (m.includes('o3-mini'))
+        return 'openai-o3-mini';
+    if (m === 'o3' || m.endsWith('-o3'))
+        return 'openai-o3';
+    if (m.includes('gpt-4o-mini'))
+        return 'openai-gpt-4o-mini';
+    if (m.includes('gpt-4o'))
+        return 'openai-gpt-4o';
     return null;
 }
 export function estimateCostUSD(model, u) {

package/dist/core/history.js

@@ -1,7 +1,7 @@
 import { readdirSync, statSync, createReadStream, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { claudeHome } from './detect.js';
+import { claudeHome, codexSessionsDir } from './detect.js';
 import { addUsage, EMPTY_USAGE, totalTokens } from './types.js';
 import { estimateCostUSD } from './format.js';
 import { loadStore, replaceDayIn, saveStore, } from './history-store.js';
@@ -10,16 +10,21 @@ let storedDays = null;
 export async function buildHistory(now = Date.now()) {
     if (storedDays === null)
         storedDays = loadStore();
-    const root = join(claudeHome(), 'projects');
-    if (!existsSync(root)) {
-        // No transcripts available; surface whatever the store has.
+    const claudeRoot = join(claudeHome(), 'projects');
+    const codexRoot = codexSessionsDir();
+    const allFiles = [];
+    if (existsSync(claudeRoot))
+        allFiles.push(...listAllJsonl(claudeRoot));
+    if (existsSync(codexRoot))
+        allFiles.push(...listCodexJsonl(codexRoot));
+    if (allFiles.length === 0)
         return aggregate(now);
-    }
-    const files = listAllJsonl(root);
-    for (const f of files) {
+    for (const f of allFiles) {
         const cached = cache.get(f.path);
         if (!cached || cached.mtimeMs < f.mtimeMs) {
-            const parsed = await parseFile(f.path);
+            const parsed = f.path.includes('/.codex/sessions/')
+                ? await parseCodexFile(f.path)
+                : await parseFile(f.path);
             cache.set(f.path, {
                 mtimeMs: f.mtimeMs,
                 byDay: parsed.byDay,
@@ -30,7 +35,7 @@ export async function buildHistory(now = Date.now()) {
             });
         }
     }
-    const known = new Set(files.map((f) => f.path));
+    const known = new Set(allFiles.map((f) => f.path));
     for (const key of Array.from(cache.keys())) {
         if (!known.has(key))
             cache.delete(key);
@@ -245,6 +250,83 @@ async function parseFile(path) {
 function numberOr0(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
 }
+function listCodexJsonl(root) {
+    const out = [];
+    for (const year of safeReaddir(root)) {
+        for (const month of safeReaddir(join(root, year))) {
+            for (const day of safeReaddir(join(root, year, month))) {
+                const dayDir = join(root, year, month, day);
+                for (const f of safeReaddir(dayDir)) {
+                    if (!f.endsWith('.jsonl'))
+                        continue;
+                    const p = join(dayDir, f);
+                    try {
+                        const s = statSync(p);
+                        out.push({ path: p, mtimeMs: s.mtimeMs });
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+    return out;
+}
+async function parseCodexFile(path) {
+    const byDay = new Map();
+    const sessionId = (path.split('/').pop() ?? path).replace(/\.jsonl$/, '');
+    let earliestEventMs = null;
+    let latestEventMs = null;
+    let cwd;
+    const stream = createReadStream(path, { encoding: 'utf8' });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (evt?.type === 'session_meta' && typeof evt?.payload?.cwd === 'string') {
+            if (!cwd)
+                cwd = evt.payload.cwd;
+        }
+        const ts = typeof evt?.timestamp === 'string' ? Date.parse(evt.timestamp) : NaN;
+        if (Number.isFinite(ts)) {
+            if (earliestEventMs === null || ts < earliestEventMs)
+                earliestEventMs = ts;
+            if (latestEventMs === null || ts > latestEventMs)
+                latestEventMs = ts;
+        }
+        if (evt?.type !== 'event_msg')
+            continue;
+        if (evt?.payload?.type !== 'token_count')
+            continue;
+        const info = evt?.payload?.info;
+        if (!info)
+            continue;
+        const last = info.last_token_usage;
+        if (!last)
+            continue;
+        if (!Number.isFinite(ts))
+            continue;
+        const day = startOfDay(ts);
+        const u = {
+            input_tokens: numberOr0(last.input_tokens),
+            output_tokens: numberOr0(last.output_tokens) + numberOr0(last.reasoning_output_tokens),
+            cache_read_input_tokens: numberOr0(last.cached_input_tokens),
+            cache_creation_input_tokens: 0,
+        };
+        const bucket = byDay.get(day) ?? {};
+        bucket['codex'] = addUsage(bucket['codex'] ?? EMPTY_USAGE(), u);
+        byDay.set(day, bucket);
+    }
+    return { byDay, sessionId, earliestEventMs, latestEventMs, cwd };
+}
 /**
  * Returns all sessions (transcripts) that had activity today, sorted by
  * start time descending (most recent first). Marks the active one.

package/dist/core/parser.js

@@ -1,7 +1,7 @@
 import { readdirSync, statSync, createReadStream, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { claudeHome } from './detect.js';
+import { claudeHome, codexSessionsDir } from './detect.js';
 import { addUsage, EMPTY_USAGE, } from './types.js';
 const PROJECTS_DIR = () => join(claudeHome(), 'projects');
 /**
@@ -142,3 +142,133 @@ function parseTimestamp(v) {
     const n = Date.parse(v);
     return Number.isFinite(n) ? n : undefined;
 }
+/**
+ * Aggregate a transcript using the appropriate parser (auto-detected by path).
+ */
+export async function aggregateAnyTranscript(path) {
+    if (path.includes('/.codex/sessions/')) {
+        const stats = {
+            sessionId: deriveSessionId(path),
+            transcriptPath: path,
+            totals: EMPTY_USAGE(),
+            byModel: {},
+            messageCount: 0,
+            lastMsgUsage: null,
+        };
+        const stream = (await import('node:fs')).createReadStream(path, { encoding: 'utf8' });
+        const rl = (await import('node:readline')).createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (line.trim())
+                applyCodexLine(stats, line);
+        }
+        return stats;
+    }
+    return aggregateTranscript(path);
+}
+/**
+ * Returns the most recently active transcript across Claude Code and Codex CLI,
+ * or null if neither has a session within the window.
+ */
+export function findMostRecentActiveTranscript(withinMs = 5 * 60_000) {
+    const claude = findActiveTranscript(withinMs);
+    const codex = findActiveCodexTranscript(withinMs);
+    if (!claude && !codex)
+        return null;
+    if (!claude)
+        return codex;
+    if (!codex)
+        return claude;
+    // Both exist — pick the one with the most recent file
+    const claudeMtime = listTranscripts()[0]?.mtimeMs ?? 0;
+    const codexMtime = listCodexTranscripts()[0]?.mtimeMs ?? 0;
+    return codexMtime > claudeMtime ? codex : claude;
+}
+// ─── Codex CLI support ────────────────────────────────────────────────────────
+const CODEX_SESSIONS_DIR = () => codexSessionsDir();
+/**
+ * Walk ~/.codex/sessions/YYYY/MM/DD/*.jsonl and return transcript files
+ * sorted by mtime descending.
+ */
+export function listCodexTranscripts() {
+    const root = CODEX_SESSIONS_DIR();
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const year of safeReaddir(root)) {
+        for (const month of safeReaddir(join(root, year))) {
+            for (const day of safeReaddir(join(root, year, month))) {
+                const dayDir = join(root, year, month, day);
+                for (const f of safeReaddir(dayDir)) {
+                    if (!f.endsWith('.jsonl'))
+                        continue;
+                    const p = join(dayDir, f);
+                    try {
+                        const s = statSync(p);
+                        out.push({ path: p, mtimeMs: s.mtimeMs, cwd: '' });
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+    return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+/**
+ * Pick the most recently active Codex transcript within `withinMs`.
+ */
+export function findActiveCodexTranscript(withinMs = 5 * 60_000) {
+    const list = listCodexTranscripts();
+    if (list.length === 0)
+        return null;
+    const top = list[0];
+    if (Date.now() - top.mtimeMs > withinMs) {
+        return { path: top.path, cwd: top.cwd };
+    }
+    return { path: top.path, cwd: top.cwd };
+}
+/**
+ * Apply a single Codex JSONL line to a running stats object.
+ * Codex emits `event_msg / token_count` events with `last_token_usage`
+ * (per-turn delta). Summing deltas across a session equals the cumulative
+ * total, so we use the same additive approach as the Claude parser.
+ */
+export function applyCodexLine(stats, line) {
+    let evt;
+    try {
+        evt = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    const ts = parseTimestamp(evt?.timestamp);
+    if (ts) {
+        stats.startedAt = stats.startedAt ? Math.min(stats.startedAt, ts) : ts;
+        stats.lastEventAt = stats.lastEventAt ? Math.max(stats.lastEventAt, ts) : ts;
+    }
+    if (evt?.type === 'session_meta' && typeof evt?.payload?.cwd === 'string') {
+        if (!stats.cwd)
+            stats.cwd = evt.payload.cwd;
+    }
+    if (evt?.type !== 'event_msg')
+        return;
+    if (evt?.payload?.type !== 'token_count')
+        return;
+    const info = evt?.payload?.info;
+    if (!info)
+        return;
+    const last = info.last_token_usage;
+    if (!last)
+        return;
+    const u = {
+        input_tokens: numberOr0(last.input_tokens),
+        output_tokens: numberOr0(last.output_tokens) + numberOr0(last.reasoning_output_tokens),
+        cache_read_input_tokens: numberOr0(last.cached_input_tokens),
+        cache_creation_input_tokens: 0,
+    };
+    stats.totals = addUsage(stats.totals, u);
+    stats.byModel['codex'] = addUsage(stats.byModel['codex'] ?? EMPTY_USAGE(), u);
+    stats.lastModel = 'codex';
+    stats.messageCount += 1;
+}

package/dist/core/tailer.js

@@ -1,13 +1,15 @@
 import { open, watch } from 'node:fs/promises';
 import { statSync } from 'node:fs';
-import { applyLine } from './parser.js';
+import { applyLine, applyCodexLine } from './parser.js';
 import { EMPTY_USAGE } from './types.js';
 import { deriveSessionId } from './parser.js';
 /**
  * Open a JSONL transcript, read everything currently in it, then watch for
  * appended lines. Calls onUpdate whenever the stats change.
  */
-export async function tailTranscript(path) {
+export async function tailTranscript(path, format) {
+    const isCodex = format === 'codex' || path.includes('/.codex/sessions/');
+    const lineApplier = isCodex ? applyCodexLine : applyLine;
     const stats = {
         sessionId: deriveSessionId(path),
         transcriptPath: path,
@@ -44,7 +46,7 @@ export async function tailTranscript(path) {
             const line = buf.slice(0, nl);
             buf = buf.slice(nl + 1);
             if (line.trim()) {
-                applyLine(stats, line);
+                lineApplier(stats, line);
                 changed = true;
             }
         }

package/dist/statusline/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { aggregateTranscript, findActiveTranscript } from '../core/parser.js';
+import { aggregateAnyTranscript, findMostRecentActiveTranscript } from '../core/parser.js';
 import { detectAuth } from '../core/detect.js';
 import { estimateCostUSD, fmtNumber, fmtUSD } from '../core/format.js';
 import { totalTokens } from '../core/types.js';
@@ -16,13 +16,13 @@ if (OPTS.help) {
  */
 async function main() {
     try {
-        const active = findActiveTranscript();
+        const active = findMostRecentActiveTranscript();
         const auth = detectAuth();
         if (!active) {
             process.stdout.write(authBadge(auth) + ' · no active session');
             return;
         }
-        const s = await aggregateTranscript(active.path);
+        const s = await aggregateAnyTranscript(active.path);
         const model = s.lastModel ?? 'unknown';
         const tot = totalTokens(s.totals);
         const cost = estimateCostUSD(model, s.totals);

package/dist/tui/index.js

@@ -4,7 +4,7 @@ import { useEffect, useRef, useState } from 'react';
 import { render, Box, Text, useApp, useInput } from 'ink';
 import { createInterface } from 'node:readline';
 import { spawnSync } from 'node:child_process';
-import { findActiveTranscript, listTranscripts } from '../core/parser.js';
+import { findActiveTranscript, findActiveCodexTranscript, listTranscripts } from '../core/parser.js';
 import { tailTranscript } from '../core/tailer.js';
 import { detectAuth } from '../core/detect.js';
 import { categoryCostUSD, contextWindowSize, estimateCostUSD, fmtNumber, fmtUSD } from '../core/format.js';
@@ -29,11 +29,19 @@ const BAR_WIDTH = 20;
 function App() {
     const { exit } = useApp();
     const [auth] = useState(() => detectAuth());
-    const [stats, setStats] = useState(null);
-    const [transcriptPath, setTranscriptPath] = useState(null);
-    const [series, setSeries] = useState(() => Array(SPARK_WIDTH).fill(0));
+    // Claude source
+    const [claudeStats, setClaudeStats] = useState(null);
+    const [claudePath, setClaudePath] = useState(null);
+    const [claudeSeries, setClaudeSeries] = useState(() => Array(SPARK_WIDTH).fill(0));
+    const [claudeLastTailAt, setClaudeLastTailAt] = useState(null);
+    const claudeLastTotalRef = useRef(0);
+    // Codex source
+    const [codexStats, setCodexStats] = useState(null);
+    const [codexPath, setCodexPath] = useState(null);
+    const [codexSeries, setCodexSeries] = useState(() => Array(SPARK_WIDTH).fill(0));
+    const [codexLastTailAt, setCodexLastTailAt] = useState(null);
+    const codexLastTotalRef = useRef(0);
     const [now, setNow] = useState(Date.now());
-    const [lastTailAt, setLastTailAt] = useState(null);
     const [history, setHistory] = useState(null);
     const [updateAvailable, setUpdateAvailable] = useState(null);
     // focusedTab: where the cursor sits (arrow navigation)
@@ -41,7 +49,6 @@ function App() {
     const [focusedTab, setFocusedTab] = useState(1);
     const [openTab, setOpenTab] = useState(null);
     const startedAtRef = useRef(Date.now());
-    const lastTotalRef = useRef(0);
     // useInput requires raw mode (interactive TTY). Skip it when stdin is piped
     // or otherwise non-interactive, so `node dist/tui/index.js | cat` still
     // renders instead of crashing.
@@ -120,45 +127,88 @@ function App() {
     useEffect(() => {
         const t = setInterval(() => {
             setNow(Date.now());
-            setSeries((s) => [...s.slice(1), 0]);
+            setClaudeSeries((s) => [...s.slice(1), 0]);
+            setCodexSeries((s) => [...s.slice(1), 0]);
         }, 1000);
         return () => clearInterval(t);
     }, []);
+    // Claude tailing
     useEffect(() => {
         let handle = null;
         let cancelled = false;
         async function attach(path) {
             handle?.stop().catch(() => undefined);
-            setTranscriptPath(path);
+            setClaudePath(path);
             handle = await tailTranscript(path);
             if (cancelled) {
                 handle.stop();
                 return;
             }
-            // Seed initial state — tailTranscript already drained the file once
-            // before returning, but its first notify() fires before any listener
-            // is attached, so we'd otherwise wait for the next appended line.
-            lastTotalRef.current = totalTokens(handle.stats.totals);
-            setLastTailAt(Date.now());
-            setStats({ ...handle.stats });
+            claudeLastTotalRef.current = totalTokens(handle.stats.totals);
+            setClaudeLastTailAt(Date.now());
+            setClaudeStats({ ...handle.stats });
             handle.onUpdate((s) => {
-                setLastTailAt(Date.now());
+                setClaudeLastTailAt(Date.now());
                 const tot = totalTokens(s.totals);
-                const delta = Math.max(0, tot - lastTotalRef.current);
+                const delta = Math.max(0, tot - claudeLastTotalRef.current);
                 if (delta > 0) {
-                    setSeries((arr) => {
+                    setClaudeSeries((arr) => {
                         const next = arr.slice();
                         next[next.length - 1] = (next[next.length - 1] ?? 0) + delta;
                         return next;
                     });
                 }
-                lastTotalRef.current = tot;
-                setStats({ ...s });
+                claudeLastTotalRef.current = tot;
+                setClaudeStats({ ...s });
             });
         }
         async function rescan() {
             const active = findActiveTranscript();
-            if (active && active.path !== transcriptPath)
+            if (active && active.path !== claudePath)
+                await attach(active.path);
+        }
+        rescan();
+        const interval = setInterval(rescan, RESCAN_MS);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+            handle?.stop().catch(() => undefined);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Codex tailing
+    useEffect(() => {
+        let handle = null;
+        let cancelled = false;
+        async function attach(path) {
+            handle?.stop().catch(() => undefined);
+            setCodexPath(path);
+            handle = await tailTranscript(path);
+            if (cancelled) {
+                handle.stop();
+                return;
+            }
+            codexLastTotalRef.current = totalTokens(handle.stats.totals);
+            setCodexLastTailAt(Date.now());
+            setCodexStats({ ...handle.stats });
+            handle.onUpdate((s) => {
+                setCodexLastTailAt(Date.now());
+                const tot = totalTokens(s.totals);
+                const delta = Math.max(0, tot - codexLastTotalRef.current);
+                if (delta > 0) {
+                    setCodexSeries((arr) => {
+                        const next = arr.slice();
+                        next[next.length - 1] = (next[next.length - 1] ?? 0) + delta;
+                        return next;
+                    });
+                }
+                codexLastTotalRef.current = tot;
+                setCodexStats({ ...s });
+            });
+        }
+        async function rescan() {
+            const active = findActiveCodexTranscript();
+            if (active && active.path !== codexPath)
                 await attach(active.path);
         }
         rescan();
@@ -173,9 +223,21 @@ function App() {
     const allTranscripts = listTranscripts();
     const transcripts = allTranscripts.slice(0, 5);
     const today = countToday(allTranscripts, now);
-    const ratePerSec = series.reduce((a, b) => a + b, 0) / SPARK_WIDTH;
-    const todaySessions = getTodaySessions(now, transcriptPath);
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Header, { auth: auth, sessionsToday: today.sessions, projectsToday: today.projects, lastTailAt: lastTailAt, startedAt: startedAtRef.current, now: now, updateAvailable: updateAvailable }), _jsx(Box, { marginTop: 1, children: _jsx(SessionStatusBar, { stats: stats, ratePerSec: ratePerSec, now: now, series: series }) }), _jsx(Box, { marginTop: 1, children: _jsx(TabBar, { focusedTab: focusedTab, openTab: openTab }) }), openTab !== null && (_jsxs(Box, { marginTop: 1, children: [openTab === 1 && (_jsx(BreakdownPanel, { stats: stats, series: series, ratePerSec: ratePerSec })), openTab === 2 && _jsx(HistoryPanel, { history: history }), openTab === 3 && _jsx(TodaySessionsPanel, { sessions: todaySessions, now: now }), openTab === 4 && (_jsx(TranscriptsPanel, { transcripts: transcripts, activePath: transcriptPath, now: now }))] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: "magenta", children: "q" }), " quit \u00B7", ' ', _jsx(Text, { color: "magenta", children: "\u2190\u2192" }), " move \u00B7", ' ', _jsx(Text, { color: "magenta", children: "enter" }), " open/close \u00B7", ' ', _jsx(Text, { color: "magenta", children: "1\u20134" }), " jump \u00B7 pricing is", ' ', _jsx(Text, { italic: true, children: "API-equivalent" }), ", not your real bill on a subscription"] }) })] }));
+    const claudeRate = claudeSeries.reduce((a, b) => a + b, 0) / SPARK_WIDTH;
+    const codexRate = codexSeries.reduce((a, b) => a + b, 0) / SPARK_WIDTH;
+    const todaySessions = getTodaySessions(now, claudePath);
+    // BreakdownPanel follows the most recently active source
+    const claudeAt = claudeStats?.lastEventAt ?? 0;
+    const codexAt = codexStats?.lastEventAt ?? 0;
+    const primaryStats = codexAt > claudeAt ? codexStats : claudeStats;
+    const primarySeries = codexAt > claudeAt ? codexSeries : claudeSeries;
+    const primaryRate = codexAt > claudeAt ? codexRate : claudeRate;
+    const lastTailAt = claudeLastTailAt && codexLastTailAt
+        ? Math.max(claudeLastTailAt, codexLastTailAt)
+        : claudeLastTailAt ?? codexLastTailAt;
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Header, { auth: auth, sessionsToday: today.sessions, projectsToday: today.projects, lastTailAt: lastTailAt, startedAt: startedAtRef.current, now: now, updateAvailable: updateAvailable }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [claudeStats
+                        ? _jsx(SessionStatusBar, { stats: claudeStats, ratePerSec: claudeRate, now: now, series: claudeSeries })
+                        : !codexStats && _jsx(SessionStatusBar, { stats: null, ratePerSec: 0, now: now, series: claudeSeries }), codexStats && (_jsx(Box, { marginTop: claudeStats ? 1 : 0, children: _jsx(SessionStatusBar, { stats: codexStats, ratePerSec: codexRate, now: now, series: codexSeries }) }))] }), _jsx(Box, { marginTop: 1, children: _jsx(TabBar, { focusedTab: focusedTab, openTab: openTab }) }), openTab !== null && (_jsxs(Box, { marginTop: 1, children: [openTab === 1 && (_jsx(BreakdownPanel, { stats: primaryStats, series: primarySeries, ratePerSec: primaryRate })), openTab === 2 && _jsx(HistoryPanel, { history: history }), openTab === 3 && _jsx(TodaySessionsPanel, { sessions: todaySessions, now: now }), openTab === 4 && (_jsx(TranscriptsPanel, { transcripts: transcripts, activePath: claudePath, now: now }))] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: "magenta", children: "q" }), " quit \u00B7", ' ', _jsx(Text, { color: "magenta", children: "\u2190\u2192" }), " move \u00B7", ' ', _jsx(Text, { color: "magenta", children: "enter" }), " open/close \u00B7", ' ', _jsx(Text, { color: "magenta", children: "1\u20134" }), " jump \u00B7 pricing is", ' ', _jsx(Text, { italic: true, children: "API-equivalent" }), ", not your real bill on a subscription"] }) })] }));
 }
 // ── Header ───────────────────────────────────────────────────────────────────
 function Header({ auth, sessionsToday, projectsToday, lastTailAt, startedAt, now, updateAvailable, }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokens-metric",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Real-time token usage meter for Claude Code — statusline + Ink TUI.",
   "type": "module",
   "bin": {