letmecode 0.1.2 → 0.1.4

package/ink-app/dist/index.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React, { useEffect, useState } from "react";
-import { Box, Text, useApp, useInput, render } from "ink";
+import React, { useEffect, useRef, useState } from "react";
+import { Box, Text, measureElement, useApp, useInput, useStdout, render } from "ink";
 import { configureCopilotVsCodeLogging, createProviders } from "./providers/index.js";
 const VERTICAL_TABS = [
     { id: "limit-windows", label: "Limits" },
@@ -17,27 +17,52 @@ const LIMIT_WINDOW_COLUMNS = {
     date: 17,
     value: 10
 };
-const MODEL_USAGE_COLUMNS = {
+const OPENAI_MODEL_USAGE_COLUMNS = {
     model: 17,
     input: 12,
     cached: 12,
-    nonCached: 12,
     output: 11,
     credits: 12,
     value: 12
 };
-const DAY_USAGE_COLUMNS = {
+const ANTHROPIC_MODEL_USAGE_COLUMNS = {
+    model: 17,
+    input: 10,
+    cacheWrite5m: 10,
+    cacheWrite1h: 10,
+    cacheRead: 10,
+    output: 10,
+    credits: 12,
+    value: 12
+};
+const OPENAI_DAY_USAGE_COLUMNS = {
     day: 11,
     events: 6,
     input: 11,
     output: 10,
     value: 10
 };
+const ANTHROPIC_DAY_USAGE_COLUMNS = {
+    day: 11,
+    events: 6,
+    input: 10,
+    cacheWrite5m: 10,
+    cacheWrite1h: 10,
+    cacheRead: 10,
+    output: 10,
+    value: 10
+};
 const COPILOT_ACTIONS = [
     { id: "vscode", label: "Start logging VS Code", enabled: true }
 ];
+const ENTER_FULLSCREEN_MODE = "\u001B[?1049h\u001B[2J\u001B[H";
+const EXIT_FULLSCREEN_MODE = "\u001B[?1049l";
+const SCROLLBAR_TRACK_GLYPH = "│";
+const SCROLLBAR_THUMB_GLYPH = "█";
 function App(props) {
     const { exit } = useApp();
+    const viewportHeight = useViewportHeight();
+    const { ref: contentPanelRef, height: contentPanelHeight } = useMeasuredElementSize();
     const providers = React.useState(() => createProviders())[0];
     const [providerStates, setProviderStates] = useState(providers.map((provider) => ({ provider, status: "loading" })));
     const [selectedProviderId, setSelectedProviderId] = useState(providers[0]?.id ?? "");
@@ -166,7 +191,7 @@ function App(props) {
             setSelectedVerticalTabIndex((current) => (current - 1 + VERTICAL_TABS.length) % VERTICAL_TABS.length);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsx(Text, { color: "gray", children: "[/]/tab to switch providers, j/k or up/down for details, left/right to select a row, enter for actions, q to quit" }), _jsx(Box, { marginTop: 1, children: sortedProviderStates.map((state) => (_jsx(ProviderTab, { label: state.provider.label, active: state.provider.id === selectedProvider.provider.id, status: state.status }, state.provider.id))) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { flexDirection: "column", width: VERTICAL_TAB_WIDTH, marginRight: 2, children: VERTICAL_TABS.map((tab, index) => (_jsx(VerticalTab, { label: tab.label, active: index === selectedVerticalTabIndex }, tab.id))) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRowKey: selectedLimitRow ? getLimitRowKey(selectedLimitRow) : undefined, selectedDayKey: selectedDayRow?.dayKey, selectedModelId: selectedModelRow?.modelId }) })] }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRow: selectedLimitRow, selectedDayRow: selectedDayRow, selectedModelRow: selectedModelRow }), _jsx(CopilotActionsPanel, { providerState: selectedProvider, actionMessage: copilotActionMessage, selectedActionIndex: selectedCopilotActionIndex }), selectedProvider.status === "ready" && selectedProvider.stats.warnings.length > 0 ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Warnings" }), selectedProvider.stats.warnings.map((warning) => (_jsx(Text, { children: warning }, warning)))] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: viewportHeight, overflow: "hidden", children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsx(Text, { color: "gray", children: "[/]/tab to switch providers, j/k or up/down for details, left/right to select a row, enter for actions, q to quit" }), _jsx(Box, { marginTop: 1, children: sortedProviderStates.map((state) => (_jsx(ProviderTab, { label: state.provider.label, active: state.provider.id === selectedProvider.provider.id, status: state.status }, state.provider.id))) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [_jsxs(Box, { flexGrow: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: VERTICAL_TAB_WIDTH, marginRight: 2, overflow: "hidden", children: VERTICAL_TABS.map((tab, index) => (_jsx(VerticalTab, { label: tab.label, active: index === selectedVerticalTabIndex }, tab.id))) }), _jsx(Box, { ref: contentPanelRef, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRowKey: selectedLimitRow ? getLimitRowKey(selectedLimitRow) : undefined, selectedDayKey: selectedDayRow?.dayKey, selectedModelId: selectedModelRow?.modelId, availableHeight: contentPanelHeight }) })] }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRow: selectedLimitRow, selectedDayRow: selectedDayRow, selectedModelRow: selectedModelRow }), _jsx(CopilotActionsPanel, { providerState: selectedProvider, actionMessage: copilotActionMessage, selectedActionIndex: selectedCopilotActionIndex }), selectedProvider.status === "ready" && selectedProvider.stats.warnings.length > 0 ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", overflow: "hidden", children: [_jsx(Text, { color: "yellow", children: "Warnings" }), selectedProvider.stats.warnings.map((warning) => (_jsx(Text, { children: warning }, warning)))] })) : null] })] }));
 }
 function CopilotActionsPanel(props) {
     if (props.providerState.provider.id !== "copilot") {
@@ -210,8 +235,7 @@ function VerticalTab(props) {
 }
 function SummaryPanel(props) {
     const { summary } = props.stats;
-    const inputPerOutput = formatInputPerOutput(summary.totals);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: props.stats.providerLabel }), _jsxs(Text, { children: ["root: ", summary.rootLabel, " (", summary.rootPath, ")"] }), _jsxs(Text, { children: ["files: ", formatInteger(summary.filesScanned), "  lines: ", formatInteger(summary.linesRead), "  token events: ", formatInteger(summary.tokenEvents)] }), _jsxs(Text, { children: ["input: ", formatInteger(summary.totals.inputTokens), "  cached: ", formatCacheTokens(summary.totals, "cached"), "  non-cached: ", formatCacheTokens(summary.totals, "non-cached")] }), _jsxs(Text, { children: ["output: ", formatInteger(summary.totals.outputTokens), "  reasoning: ", formatInteger(summary.totals.reasoningOutputTokens), "  total: ", formatInteger(summary.totals.totalTokens)] }), _jsxs(Text, { children: ["estimated credits: ", formatUsageCredits(summary.totals)] }), _jsxs(Text, { children: ["IpO: ", inputPerOutput.cached, ":", inputPerOutput.nonCached, ":", inputPerOutput.output] }), _jsxs(Text, { children: ["models: ", summary.distinctModels.join(", ") || "none"] }), _jsxs(Text, { children: ["plans: ", summary.distinctPlanTypes.join(", ") || "none"] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: props.stats.providerLabel }), _jsxs(Text, { children: ["root: ", summary.rootLabel, " (", summary.rootPath, ")"] }), _jsxs(Text, { children: ["files: ", formatInteger(summary.filesScanned), "  lines: ", formatInteger(summary.linesRead), "  token events: ", formatInteger(summary.tokenEvents)] }), _jsx(UsageBreakdownLines, { totals: summary.totals }), _jsxs(Text, { children: ["estimated credits: ", formatUsageCredits(summary.totals)] }), _jsxs(Text, { children: ["IpO: ", formatInputPerOutput(summary.totals)] }), _jsxs(Text, { children: ["models: ", summary.distinctModels.join(", ") || "none"] }), _jsxs(Text, { children: ["plans: ", summary.distinctPlanTypes.join(", ") || "none"] })] }));
 }
 function ContentPanel(props) {
     if (props.providerState.status === "loading") {
@@ -221,48 +245,171 @@ function ContentPanel(props) {
         return _jsxs(Text, { color: "red", children: ["Provider error: ", props.providerState.errorMessage] });
     }
     if (props.tabId === "limit-windows") {
-        return _jsx(LimitWindowsPanel, { stats: props.providerState.stats, selectedRowKey: props.selectedLimitRowKey });
+        return (_jsx(LimitWindowsPanel, { stats: props.providerState.stats, selectedRowKey: props.selectedLimitRowKey, availableHeight: props.availableHeight }));
     }
     if (props.tabId === "summary") {
         return _jsx(SummaryPanel, { stats: props.providerState.stats });
     }
     if (props.tabId === "day-to-day-analyses") {
-        return _jsx(DayToDayPanel, { stats: props.providerState.stats, selectedDayKey: props.selectedDayKey });
+        return (_jsx(DayToDayPanel, { stats: props.providerState.stats, selectedDayKey: props.selectedDayKey, availableHeight: props.availableHeight }));
     }
-    return _jsx(UsageByModelPanel, { stats: props.providerState.stats, selectedModelId: props.selectedModelId });
+    return (_jsx(UsageByModelPanel, { stats: props.providerState.stats, selectedModelId: props.selectedModelId, availableHeight: props.availableHeight }));
 }
 function LimitWindowsPanel(props) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Primary Limit Windows" }), _jsx(LimitWindowSection, { windows: props.stats.primaryLimitWindows, selectedRowKey: props.selectedRowKey }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { bold: true, children: "Secondary Limit Windows" }), _jsx(LimitWindowSection, { windows: props.stats.secondaryLimitWindows, selectedRowKey: props.selectedRowKey })] }));
-}
-function LimitWindowSection(props) {
-    if (props.windows.length === 0) {
-        return _jsx(Text, { color: "gray", children: "No windows found." });
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: [pad("plan", LIMIT_WINDOW_COLUMNS.plan), " ", pad("window", LIMIT_WINDOW_COLUMNS.window), " ", pad("used", LIMIT_WINDOW_COLUMNS.used), " ", pad("start", LIMIT_WINDOW_COLUMNS.date), " ", pad("end", LIMIT_WINDOW_COLUMNS.date), " value"] }), props.windows.map((window) => {
-                const windowLabel = formatWindowMinutes(window.windowMinutes);
-                const usedLabel = `${window.minUsedPercent}%->${window.maxUsedPercent}%`;
-                const isSelected = props.selectedRowKey === getLimitRowKey(window);
-                return (_jsxs(Text, { inverse: isSelected, color: isSelected ? "cyan" : undefined, children: [pad(window.planType, LIMIT_WINDOW_COLUMNS.plan), " ", pad(windowLabel, LIMIT_WINDOW_COLUMNS.window), " ", pad(usedLabel, LIMIT_WINDOW_COLUMNS.used), " ", pad(formatLocalDateTime(window.startTimeUtcIso), LIMIT_WINDOW_COLUMNS.date), " ", pad(formatLocalDateTime(window.endTimeUtcIso), LIMIT_WINDOW_COLUMNS.date), " ", pad(formatUsd(window.totals.estimatedCredits * CODEX_CREDIT_COST_USD), LIMIT_WINDOW_COLUMNS.value)] }, getLimitRowKey(window)));
-            })] }));
+    const bodyLines = [
+        { key: "primary-title", text: "Primary Limit Windows", bold: true },
+        ...buildLimitWindowSectionLines("primary", props.stats.primaryLimitWindows, props.selectedRowKey),
+        { key: "section-gap", text: "" },
+        { key: "secondary-title", text: "Secondary Limit Windows", bold: true },
+        ...buildLimitWindowSectionLines("secondary", props.stats.secondaryLimitWindows, props.selectedRowKey)
+    ];
+    return (_jsx(ScrollableLineViewport, { bodyLines: bodyLines, selectedBodyLineKey: props.selectedRowKey ? `limit-row:${props.selectedRowKey}` : undefined, availableHeight: props.availableHeight }));
 }
 function UsageByModelPanel(props) {
     if (props.stats.modelUsage.length === 0) {
         return _jsx(Text, { color: "gray", children: "No model usage found." });
     }
     const totals = props.stats.summary.totals;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: [pad("model", MODEL_USAGE_COLUMNS.model), " ", pad("input", MODEL_USAGE_COLUMNS.input), " ", pad("cached", MODEL_USAGE_COLUMNS.cached), " ", pad("non-cached", MODEL_USAGE_COLUMNS.nonCached), " ", pad("output", MODEL_USAGE_COLUMNS.output), " ", pad("credits", MODEL_USAGE_COLUMNS.credits), " value"] }), props.stats.modelUsage.map((row) => {
-                const isSelected = props.selectedModelId === row.modelId;
-                return (_jsxs(Text, { inverse: isSelected, color: isSelected ? "cyan" : undefined, children: [pad(row.modelId, MODEL_USAGE_COLUMNS.model), " ", pad(formatInteger(row.totals.inputTokens), MODEL_USAGE_COLUMNS.input), " ", pad(formatCacheTokens(row.totals, "cached"), MODEL_USAGE_COLUMNS.cached), " ", pad(formatCacheTokens(row.totals, "non-cached"), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(row.totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatUsageCredits(row.totals), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsageUsd(row.totals), MODEL_USAGE_COLUMNS.value)] }, row.modelId));
-            }), _jsxs(Text, { color: "cyan", children: [pad("TOTAL", MODEL_USAGE_COLUMNS.model), " ", pad(formatInteger(totals.inputTokens), MODEL_USAGE_COLUMNS.input), " ", pad(formatCacheTokens(totals, "cached"), MODEL_USAGE_COLUMNS.cached), " ", pad(formatCacheTokens(totals, "non-cached"), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatUsageCredits(totals), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsageUsd(totals), MODEL_USAGE_COLUMNS.value)] })] }));
+    if (totals.tokenBreakdown.schema === "anthropic") {
+        return (_jsx(ScrollableLineViewport, { headerLines: [
+                {
+                    key: "anthropic-model-header",
+                    text: `${pad("model", ANTHROPIC_MODEL_USAGE_COLUMNS.model)} ${pad("input", ANTHROPIC_MODEL_USAGE_COLUMNS.input)} ${pad("cacheW5m", ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite5m)} ${pad("cacheW1h", ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite1h)} ${pad("cacheRead", ANTHROPIC_MODEL_USAGE_COLUMNS.cacheRead)} ${pad("output", ANTHROPIC_MODEL_USAGE_COLUMNS.output)} ${pad("credits", ANTHROPIC_MODEL_USAGE_COLUMNS.credits)} value`,
+                    color: "gray"
+                }
+            ], bodyLines: props.stats.modelUsage.flatMap((row) => {
+                if (row.totals.tokenBreakdown.schema !== "anthropic") {
+                    return [];
+                }
+                return [
+                    {
+                        key: `model-row:${row.modelId}`,
+                        text: `${pad(row.modelId, ANTHROPIC_MODEL_USAGE_COLUMNS.model)} ${pad(formatInteger(row.totals.tokenBreakdown.inputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.input)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheWrite5mInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite5m)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheWrite1hInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite1h)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheReadInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheRead)} ${pad(formatInteger(row.totals.outputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.output)} ${pad(formatUsageCredits(row.totals, row.modelId), ANTHROPIC_MODEL_USAGE_COLUMNS.credits)} ${pad(formatUsageUsd(row.totals, row.modelId), ANTHROPIC_MODEL_USAGE_COLUMNS.value)}`,
+                        inverse: props.selectedModelId === row.modelId,
+                        color: props.selectedModelId === row.modelId ? "cyan" : undefined
+                    }
+                ];
+            }), footerLines: [
+                {
+                    key: "anthropic-model-total",
+                    text: `${pad("TOTAL", ANTHROPIC_MODEL_USAGE_COLUMNS.model)} ${pad(formatInteger(totals.tokenBreakdown.inputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.input)} ${pad(formatInteger(totals.tokenBreakdown.cacheWrite5mInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite5m)} ${pad(formatInteger(totals.tokenBreakdown.cacheWrite1hInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheWrite1h)} ${pad(formatInteger(totals.tokenBreakdown.cacheReadInputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.cacheRead)} ${pad(formatInteger(totals.outputTokens), ANTHROPIC_MODEL_USAGE_COLUMNS.output)} ${pad(formatUsageCredits(totals), ANTHROPIC_MODEL_USAGE_COLUMNS.credits)} ${pad(formatUsageUsd(totals), ANTHROPIC_MODEL_USAGE_COLUMNS.value)}`,
+                    color: "cyan"
+                }
+            ], selectedBodyLineKey: props.selectedModelId ? `model-row:${props.selectedModelId}` : undefined, availableHeight: props.availableHeight }));
+    }
+    return (_jsx(ScrollableLineViewport, { headerLines: [
+            {
+                key: "openai-model-header",
+                text: `${pad("model", OPENAI_MODEL_USAGE_COLUMNS.model)} ${pad("uncached", OPENAI_MODEL_USAGE_COLUMNS.input)} ${pad("cached", OPENAI_MODEL_USAGE_COLUMNS.cached)} ${pad("output", OPENAI_MODEL_USAGE_COLUMNS.output)} ${pad("credits", OPENAI_MODEL_USAGE_COLUMNS.credits)} value`,
+                color: "gray"
+            }
+        ], bodyLines: props.stats.modelUsage.flatMap((row) => {
+            if (row.totals.tokenBreakdown.schema !== "openai") {
+                return [];
+            }
+            return [
+                {
+                    key: `model-row:${row.modelId}`,
+                    text: `${pad(row.modelId, OPENAI_MODEL_USAGE_COLUMNS.model)} ${pad(formatOpenAiTokens(row.totals, "non-cached"), OPENAI_MODEL_USAGE_COLUMNS.input)} ${pad(formatOpenAiTokens(row.totals, "cached"), OPENAI_MODEL_USAGE_COLUMNS.cached)} ${pad(formatInteger(row.totals.outputTokens), OPENAI_MODEL_USAGE_COLUMNS.output)} ${pad(formatUsageCredits(row.totals, row.modelId), OPENAI_MODEL_USAGE_COLUMNS.credits)} ${pad(formatUsageUsd(row.totals, row.modelId), OPENAI_MODEL_USAGE_COLUMNS.value)}`,
+                    inverse: props.selectedModelId === row.modelId,
+                    color: props.selectedModelId === row.modelId ? "cyan" : undefined
+                }
+            ];
+        }), footerLines: [
+            {
+                key: "openai-model-total",
+                text: `${pad("TOTAL", OPENAI_MODEL_USAGE_COLUMNS.model)} ${pad(formatOpenAiTokens(totals, "non-cached"), OPENAI_MODEL_USAGE_COLUMNS.input)} ${pad(formatOpenAiTokens(totals, "cached"), OPENAI_MODEL_USAGE_COLUMNS.cached)} ${pad(formatInteger(totals.outputTokens), OPENAI_MODEL_USAGE_COLUMNS.output)} ${pad(formatUsageCredits(totals), OPENAI_MODEL_USAGE_COLUMNS.credits)} ${pad(formatUsageUsd(totals), OPENAI_MODEL_USAGE_COLUMNS.value)}`,
+                color: "cyan"
+            }
+        ], selectedBodyLineKey: props.selectedModelId ? `model-row:${props.selectedModelId}` : undefined, availableHeight: props.availableHeight }));
 }
 function DayToDayPanel(props) {
     if (props.stats.dayUsage.length === 0) {
         return _jsx(Text, { color: "gray", children: "No day-by-day usage found." });
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: [pad("day", DAY_USAGE_COLUMNS.day), " ", pad("events", DAY_USAGE_COLUMNS.events), " ", pad("input", DAY_USAGE_COLUMNS.input), " ", pad("output", DAY_USAGE_COLUMNS.output), " value"] }), props.stats.dayUsage.map((row) => {
-                const isSelected = props.selectedDayKey === row.dayKey;
-                return (_jsxs(Text, { inverse: isSelected, color: isSelected ? "cyan" : undefined, children: [pad(formatUtcDay(row.dayKey), DAY_USAGE_COLUMNS.day), " ", pad(formatInteger(row.totals.eventCount), DAY_USAGE_COLUMNS.events), " ", pad(formatInteger(row.totals.inputTokens), DAY_USAGE_COLUMNS.input), " ", pad(formatInteger(row.totals.outputTokens), DAY_USAGE_COLUMNS.output), " ", pad(formatUsageUsd(row.totals), DAY_USAGE_COLUMNS.value)] }, row.dayKey));
-            })] }));
+    const totals = props.stats.summary.totals;
+    if (totals.tokenBreakdown.schema === "anthropic") {
+        return (_jsx(ScrollableLineViewport, { headerLines: [
+                {
+                    key: "anthropic-day-header",
+                    text: `${pad("day", ANTHROPIC_DAY_USAGE_COLUMNS.day)} ${pad("events", ANTHROPIC_DAY_USAGE_COLUMNS.events)} ${pad("input", ANTHROPIC_DAY_USAGE_COLUMNS.input)} ${pad("cacheW5m", ANTHROPIC_DAY_USAGE_COLUMNS.cacheWrite5m)} ${pad("cacheW1h", ANTHROPIC_DAY_USAGE_COLUMNS.cacheWrite1h)} ${pad("cacheRead", ANTHROPIC_DAY_USAGE_COLUMNS.cacheRead)} ${pad("output", ANTHROPIC_DAY_USAGE_COLUMNS.output)} value`,
+                    color: "gray"
+                }
+            ], bodyLines: props.stats.dayUsage.flatMap((row) => {
+                if (row.totals.tokenBreakdown.schema !== "anthropic") {
+                    return [];
+                }
+                return [
+                    {
+                        key: `day-row:${row.dayKey}`,
+                        text: `${pad(formatUtcDay(row.dayKey), ANTHROPIC_DAY_USAGE_COLUMNS.day)} ${pad(formatInteger(row.totals.eventCount), ANTHROPIC_DAY_USAGE_COLUMNS.events)} ${pad(formatInteger(row.totals.tokenBreakdown.inputTokens), ANTHROPIC_DAY_USAGE_COLUMNS.input)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheWrite5mInputTokens), ANTHROPIC_DAY_USAGE_COLUMNS.cacheWrite5m)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheWrite1hInputTokens), ANTHROPIC_DAY_USAGE_COLUMNS.cacheWrite1h)} ${pad(formatInteger(row.totals.tokenBreakdown.cacheReadInputTokens), ANTHROPIC_DAY_USAGE_COLUMNS.cacheRead)} ${pad(formatInteger(row.totals.outputTokens), ANTHROPIC_DAY_USAGE_COLUMNS.output)} ${pad(formatUsageUsd(row.totals), ANTHROPIC_DAY_USAGE_COLUMNS.value)}`,
+                        inverse: props.selectedDayKey === row.dayKey,
+                        color: props.selectedDayKey === row.dayKey ? "cyan" : undefined
+                    }
+                ];
+            }), selectedBodyLineKey: props.selectedDayKey ? `day-row:${props.selectedDayKey}` : undefined, availableHeight: props.availableHeight }));
+    }
+    return (_jsx(ScrollableLineViewport, { headerLines: [
+            {
+                key: "openai-day-header",
+                text: `${pad("day", OPENAI_DAY_USAGE_COLUMNS.day)} ${pad("events", OPENAI_DAY_USAGE_COLUMNS.events)} ${pad("input", OPENAI_DAY_USAGE_COLUMNS.input)} ${pad("output", OPENAI_DAY_USAGE_COLUMNS.output)} value`,
+                color: "gray"
+            }
+        ], bodyLines: props.stats.dayUsage.flatMap((row) => {
+            if (row.totals.tokenBreakdown.schema !== "openai") {
+                return [];
+            }
+            return [
+                {
+                    key: `day-row:${row.dayKey}`,
+                    text: `${pad(formatUtcDay(row.dayKey), OPENAI_DAY_USAGE_COLUMNS.day)} ${pad(formatInteger(row.totals.eventCount), OPENAI_DAY_USAGE_COLUMNS.events)} ${pad(formatInteger(row.totals.inputTotalTokens), OPENAI_DAY_USAGE_COLUMNS.input)} ${pad(formatInteger(row.totals.outputTokens), OPENAI_DAY_USAGE_COLUMNS.output)} ${pad(formatUsageUsd(row.totals), OPENAI_DAY_USAGE_COLUMNS.value)}`,
+                    inverse: props.selectedDayKey === row.dayKey,
+                    color: props.selectedDayKey === row.dayKey ? "cyan" : undefined
+                }
+            ];
+        }), selectedBodyLineKey: props.selectedDayKey ? `day-row:${props.selectedDayKey}` : undefined, availableHeight: props.availableHeight }));
+}
+function ScrollableLineViewport(props) {
+    const headerLines = props.headerLines ?? [];
+    const footerLines = props.footerLines ?? [];
+    const layout = resolveScrollableViewportLayout(props.availableHeight, headerLines.length, props.bodyLines.length, footerLines.length);
+    const selectedBodyLineIndex = props.selectedBodyLineKey
+        ? props.bodyLines.findIndex((line) => line.key === props.selectedBodyLineKey)
+        : -1;
+    const scrollOffset = useAutoScrollOffset(selectedBodyLineIndex, props.bodyLines.length, layout.bodyVisibleCount);
+    const visibleHeaderLines = headerLines.slice(0, layout.headerVisibleCount);
+    const visibleBodyLines = props.bodyLines.slice(scrollOffset, scrollOffset + layout.bodyVisibleCount);
+    const visibleFooterLines = footerLines.slice(Math.max(0, footerLines.length - layout.footerVisibleCount));
+    const bodyScrollbarLines = buildScrollbarLines(layout.bodyVisibleCount, props.bodyLines.length, scrollOffset);
+    const showScrollbar = bodyScrollbarLines.length > 0;
+    return (_jsxs(Box, { flexDirection: "row", overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [visibleHeaderLines.map((line) => (_jsx(ScrollableViewportLine, { line: line }, line.key))), visibleBodyLines.map((line) => (_jsx(ScrollableViewportLine, { line: line }, line.key))), visibleFooterLines.map((line) => (_jsx(ScrollableViewportLine, { line: line }, line.key)))] }), showScrollbar ? (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [visibleHeaderLines.map((line) => (_jsx(Text, { color: "gray", children: " " }, `${line.key}-scrollbar`))), bodyScrollbarLines.map((line, index) => (_jsx(Text, { color: line === "#" ? "cyan" : "gray", children: line }, `scrollbar-${index}`))), visibleFooterLines.map((line) => (_jsx(Text, { color: "gray", children: " " }, `${line.key}-scrollbar`)))] })) : null] }));
+}
+function ScrollableViewportLine(props) {
+    return (_jsx(Text, { bold: props.line.bold, color: props.line.color, inverse: props.line.inverse, wrap: "truncate-end", children: props.line.text }));
+}
+function buildLimitWindowSectionLines(scope, windows, selectedRowKey) {
+    if (windows.length === 0) {
+        return [{ key: `${scope}-empty`, text: "No windows found.", color: "gray" }];
+    }
+    return [
+        {
+            key: `${scope}-header`,
+            text: `${pad("plan", LIMIT_WINDOW_COLUMNS.plan)} ${pad("window", LIMIT_WINDOW_COLUMNS.window)} ${pad("used", LIMIT_WINDOW_COLUMNS.used)} ${pad("start", LIMIT_WINDOW_COLUMNS.date)} ${pad("end", LIMIT_WINDOW_COLUMNS.date)} value`,
+            color: "gray"
+        },
+        ...windows.map((window) => {
+            const lineKey = getLimitRowKey(window);
+            const windowLabel = formatWindowMinutes(window.windowMinutes);
+            const usedLabel = `${window.minUsedPercent}%->${window.maxUsedPercent}%`;
+            const isSelected = selectedRowKey === lineKey;
+            return {
+                key: `limit-row:${lineKey}`,
+                text: `${pad(window.planType, LIMIT_WINDOW_COLUMNS.plan)} ${pad(windowLabel, LIMIT_WINDOW_COLUMNS.window)} ${pad(usedLabel, LIMIT_WINDOW_COLUMNS.used)} ${pad(formatLocalDateTime(window.startTimeUtcIso), LIMIT_WINDOW_COLUMNS.date)} ${pad(formatLocalDateTime(window.endTimeUtcIso), LIMIT_WINDOW_COLUMNS.date)} ${pad(formatUsd(window.totals.estimatedCredits * CODEX_CREDIT_COST_USD), LIMIT_WINDOW_COLUMNS.value)}`,
+                inverse: isSelected,
+                color: isSelected ? "cyan" : undefined
+            };
+        })
+    ];
 }
 function SelectionDetailsPanel(props) {
     if (props.providerState.status !== "ready") {
@@ -274,17 +421,16 @@ function SelectionDetailsPanel(props) {
     }
     if (props.tabId === "day-to-day-analyses" && props.selectedDayRow) {
         const row = props.selectedDayRow;
-        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Day details" }), _jsxs(Text, { children: ["day: ", formatUtcDay(row.dayKey), "  events: ", formatInteger(row.totals.eventCount), "  models: ", formatInteger(row.distinctModels.length), "  plans: ", formatInteger(row.distinctPlanTypes.length)] }), _jsxs(Text, { children: ["range: ", formatEventRange(row.firstEventUtcIso, row.lastEventUtcIso)] }), _jsxs(Text, { children: ["input: ", formatInteger(row.totals.inputTokens), "  cached: ", formatCacheTokens(row.totals, "cached")] }), _jsxs(Text, { children: ["non-cached: ", formatCacheTokens(row.totals, "non-cached"), "  output: ", formatInteger(row.totals.outputTokens)] }), _jsxs(Text, { children: ["models: ", row.distinctModels.join(", ") || "none"] }), _jsxs(Text, { children: ["plans: ", row.distinctPlanTypes.join(", ") || "none"] }), _jsx(UsageTotalsDetails, { totals: row.totals })] }));
+        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Day details" }), _jsxs(Text, { children: ["day: ", formatUtcDay(row.dayKey), "  events: ", formatInteger(row.totals.eventCount), "  models: ", formatInteger(row.distinctModels.length), "  plans: ", formatInteger(row.distinctPlanTypes.length)] }), _jsxs(Text, { children: ["range: ", formatEventRange(row.firstEventUtcIso, row.lastEventUtcIso)] }), _jsxs(Text, { children: ["models: ", row.distinctModels.join(", ") || "none"] }), _jsxs(Text, { children: ["plans: ", row.distinctPlanTypes.join(", ") || "none"] }), _jsx(UsageTotalsDetails, { totals: row.totals })] }));
     }
     if (props.tabId === "usage-by-model" && props.selectedModelRow) {
-        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Model details" }), _jsxs(Text, { children: ["model: ", props.selectedModelRow.modelId, "  events: ", formatInteger(props.selectedModelRow.totals.eventCount)] }), _jsx(UsageTotalsDetails, { totals: props.selectedModelRow.totals })] }));
+        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Model details" }), _jsxs(Text, { children: ["model: ", props.selectedModelRow.modelId, "  events: ", formatInteger(props.selectedModelRow.totals.eventCount)] }), _jsx(UsageTotalsDetails, { totals: props.selectedModelRow.totals, modelId: props.selectedModelRow.modelId })] }));
     }
     return null;
 }
 function UsageTotalsDetails(props) {
     const { totals } = props;
-    const inputPerOutput = formatInputPerOutput(totals);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Total credits burned: ", formatUsageCredits(totals)] }), _jsxs(Text, { children: ["Credits Value (@ $0.01/credit): ", formatUsageUsd(totals)] }), _jsxs(Text, { children: ["IpO: ", inputPerOutput.cached, ":", inputPerOutput.nonCached, ":", inputPerOutput.output] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(UsageBreakdownLines, { totals: totals }), _jsxs(Text, { children: ["Burned tokens for: ", formatUsageUsd(totals, props.modelId)] }), _jsxs(Text, { children: ["IpO: ", formatInputPerOutput(totals)] })] }));
 }
 function formatInteger(value) {
     return Math.round(value).toLocaleString("en-US");
@@ -298,19 +444,22 @@ function formatCredits(value) {
         maximumFractionDigits: 2
     });
 }
-function formatUsageCredits(totals) {
+function formatUsageCredits(totals, modelId) {
+    if (isInternalUsageModel(modelId)) {
+        return "N/A";
+    }
     return totals.estimatedCreditsStatus === "unavailable" ? "unknown" : formatCredits(totals.estimatedCredits);
 }
-function formatUsageUsd(totals) {
+function formatUsageUsd(totals, modelId) {
+    if (isInternalUsageModel(modelId)) {
+        return "N/A";
+    }
     return totals.estimatedCreditsStatus === "unavailable"
         ? "unknown"
         : formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD);
 }
-function formatCacheTokens(totals, kind) {
-    if (totals.cacheStatus === "unavailable") {
-        return "unknown";
-    }
-    return formatInteger(kind === "cached" ? totals.cachedInputTokens : totals.nonCachedInputTokens);
+function isInternalUsageModel(modelId) {
+    return modelId === "codex-auto-review" || modelId === "<synthetic>";
 }
 function formatUsd(value) {
     if (value > 0 && value < 0.0001) {
@@ -365,19 +514,107 @@ function formatEventRange(firstEventUtcIso, lastEventUtcIso) {
 function pad(value, length) {
     return value.length >= length ? value.slice(0, length) : value.padEnd(length);
 }
-function formatInputPerOutput(totals) {
-    if (totals.cacheStatus === "unavailable") {
-        return { cached: "unknown", nonCached: "unknown", output: "1" };
+function UsageBreakdownLines(props) {
+    const { totals } = props;
+    if (totals.tokenBreakdown.schema === "anthropic") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["input total: ", formatInteger(totals.inputTotalTokens), "  input: ", formatInteger(totals.tokenBreakdown.inputTokens), "  cacheW5m: ", formatInteger(totals.tokenBreakdown.cacheWrite5mInputTokens)] }), _jsxs(Text, { children: ["cacheW1h: ", formatInteger(totals.tokenBreakdown.cacheWrite1hInputTokens), "  cacheRead: ", formatInteger(totals.tokenBreakdown.cacheReadInputTokens), "  output: ", formatInteger(totals.outputTokens), "  reasoning: ", formatInteger(totals.reasoningOutputTokens), "  total: ", formatInteger(totals.totalTokens)] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["input total: ", formatInteger(totals.inputTotalTokens), "  uncached: ", formatOpenAiTokens(totals, "non-cached"), "  cached: ", formatOpenAiTokens(totals, "cached")] }), _jsxs(Text, { children: ["output: ", formatInteger(totals.outputTokens), "  reasoning: ", formatInteger(totals.reasoningOutputTokens), "  total: ", formatInteger(totals.totalTokens)] })] }));
+}
+function formatOpenAiTokens(totals, kind) {
+    if (totals.tokenBreakdown.schema !== "openai" || totals.cacheStatus === "unavailable") {
+        return "unknown";
     }
+    return formatInteger(kind === "non-cached" ? totals.tokenBreakdown.nonCachedInputTokens : totals.tokenBreakdown.cachedInputTokens);
+}
+function formatInputPerOutput(totals) {
     if (totals.outputTokens <= 0) {
-        return { cached: "0", nonCached: "0", output: "0" };
+        return totals.tokenBreakdown.schema === "anthropic" ? "input:cacheW5m:cacheW1h:cacheRead:output = 0:0:0:0:0" : "uncached:cached:output = 0:0:0";
+    }
+    if (totals.tokenBreakdown.schema === "anthropic") {
+        return `input:cacheW5m:cacheW1h:cacheRead:output = ${formatInteger(Math.round(totals.tokenBreakdown.inputTokens / totals.outputTokens))}:${formatInteger(Math.round(totals.tokenBreakdown.cacheWrite5mInputTokens / totals.outputTokens))}:${formatInteger(Math.round(totals.tokenBreakdown.cacheWrite1hInputTokens / totals.outputTokens))}:${formatInteger(Math.round(totals.tokenBreakdown.cacheReadInputTokens / totals.outputTokens))}:1`;
+    }
+    if (totals.cacheStatus === "unavailable") {
+        return "uncached:cached:output = unknown:unknown:1";
     }
+    return `uncached:cached:output = ${formatInteger(Math.round(totals.tokenBreakdown.nonCachedInputTokens / totals.outputTokens))}:${formatInteger(Math.round(totals.tokenBreakdown.cachedInputTokens / totals.outputTokens))}:1`;
+}
+function useMeasuredElementSize() {
+    const ref = useRef(null);
+    const [size, setSize] = useState({ width: 0, height: 0 });
+    useEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+        const nextSize = measureElement(ref.current);
+        setSize((current) => current.width === nextSize.width && current.height === nextSize.height ? current : nextSize);
+    });
     return {
-        cached: formatInteger(Math.round(totals.cachedInputTokens / totals.outputTokens)),
-        nonCached: formatInteger(Math.round(totals.nonCachedInputTokens / totals.outputTokens)),
-        output: "1"
+        ref,
+        width: size.width,
+        height: size.height
     };
 }
+function useAutoScrollOffset(selectedIndex, rowCount, viewportSize) {
+    const [scrollOffset, setScrollOffset] = useState(0);
+    useEffect(() => {
+        const maxOffset = Math.max(0, rowCount - Math.max(0, viewportSize));
+        setScrollOffset((current) => {
+            let next = Math.max(0, Math.min(current, maxOffset));
+            if (selectedIndex < 0 || viewportSize <= 0) {
+                return next;
+            }
+            if (selectedIndex < next) {
+                next = selectedIndex;
+            }
+            else if (selectedIndex >= next + viewportSize) {
+                next = selectedIndex - viewportSize + 1;
+            }
+            return Math.max(0, Math.min(next, maxOffset));
+        });
+    }, [rowCount, selectedIndex, viewportSize]);
+    return scrollOffset;
+}
+function resolveScrollableViewportLayout(availableHeight, headerCount, bodyCount, footerCount) {
+    const totalHeight = Math.max(1, availableHeight || 1);
+    if (bodyCount === 0) {
+        const headerVisibleCount = Math.min(headerCount, totalHeight);
+        return {
+            headerVisibleCount,
+            bodyVisibleCount: 0,
+            footerVisibleCount: Math.min(footerCount, Math.max(0, totalHeight - headerVisibleCount))
+        };
+    }
+    let headerVisibleCount = Math.min(headerCount, totalHeight);
+    let footerVisibleCount = Math.min(footerCount, Math.max(0, totalHeight - headerVisibleCount - 1));
+    let bodyVisibleCount = Math.min(bodyCount, Math.max(0, totalHeight - headerVisibleCount - footerVisibleCount));
+    if (bodyVisibleCount === 0 && footerVisibleCount > 0) {
+        footerVisibleCount -= 1;
+        bodyVisibleCount = Math.min(bodyCount, Math.max(0, totalHeight - headerVisibleCount - footerVisibleCount));
+    }
+    if (bodyVisibleCount === 0 && headerVisibleCount > 0) {
+        headerVisibleCount -= 1;
+        bodyVisibleCount = Math.min(bodyCount, Math.max(0, totalHeight - headerVisibleCount - footerVisibleCount));
+    }
+    if (bodyVisibleCount === 0) {
+        return {
+            headerVisibleCount: 0,
+            bodyVisibleCount: Math.min(bodyCount, totalHeight),
+            footerVisibleCount: 0
+        };
+    }
+    return { headerVisibleCount, bodyVisibleCount, footerVisibleCount };
+}
+function buildScrollbarLines(viewportSize, rowCount, scrollOffset) {
+    if (viewportSize <= 0 || rowCount <= viewportSize) {
+        return [];
+    }
+    const thumbSize = Math.max(1, Math.round((viewportSize * viewportSize) / rowCount));
+    const maxThumbOffset = Math.max(0, viewportSize - thumbSize);
+    const maxScrollOffset = Math.max(1, rowCount - viewportSize);
+    const thumbOffset = Math.round((Math.max(0, Math.min(scrollOffset, maxScrollOffset)) / maxScrollOffset) * maxThumbOffset);
+    return Array.from({ length: viewportSize }, (_, index) => index >= thumbOffset && index < thumbOffset + thumbSize ? SCROLLBAR_THUMB_GLYPH : SCROLLBAR_TRACK_GLYPH);
+}
 function clampSelectionIndex(value, rowCount) {
     if (rowCount === 0) {
         return -1;
@@ -396,7 +633,7 @@ function providerUsageScore(state) {
         return 0;
     }
     const totals = state.stats.summary.totals;
-    return totals.inputTokens + totals.cachedInputTokens + totals.outputTokens;
+    return totals.inputTotalTokens + totals.outputTokens;
 }
 function getLimitRows(providerState) {
     if (providerState.status !== "ready") {
@@ -424,7 +661,59 @@ function parseStatsOptions(argv) {
         verbose: argv.includes("-v") || argv.includes("--verbose")
     };
 }
+function useViewportHeight() {
+    const { stdout } = useStdout();
+    const [viewportHeight, setViewportHeight] = useState(() => resolveViewportHeight(stdout.rows));
+    useEffect(() => {
+        const updateViewportHeight = () => {
+            setViewportHeight(resolveViewportHeight(stdout.rows));
+        };
+        updateViewportHeight();
+        if (!stdout.isTTY) {
+            return;
+        }
+        stdout.on("resize", updateViewportHeight);
+        return () => {
+            stdout.off("resize", updateViewportHeight);
+        };
+    }, [stdout]);
+    return viewportHeight;
+}
+function resolveViewportHeight(rows) {
+    const terminalRows = typeof rows === "number" && rows > 0 ? rows : 24;
+    // Keep Ink below the terminal height so it stays on its incremental redraw path
+    // instead of the full-screen print path that can leave the viewport scrolled.
+    return Math.max(1, terminalRows - 1);
+}
 export function main(argv = process.argv.slice(2)) {
-    render(_jsx(App, { statsOptions: parseStatsOptions(argv) }));
+    const restoreFullscreen = enterFullscreenMode(process.stdout);
+    const exitHandler = () => {
+        restoreFullscreen();
+    };
+    process.once("exit", exitHandler);
+    const instance = render(_jsx(App, { statsOptions: parseStatsOptions(argv) }), {
+        stdout: process.stdout,
+        stdin: process.stdin,
+        stderr: process.stderr
+    });
+    void instance.waitUntilExit().finally(() => {
+        process.off("exit", exitHandler);
+        instance.cleanup();
+        restoreFullscreen();
+    });
+}
+function enterFullscreenMode(stdout) {
+    if (!stdout.isTTY) {
+        return () => { };
+    }
+    let restored = false;
+    stdout.write(ENTER_FULLSCREEN_MODE);
+    return () => {
+        if (restored) {
+            return;
+        }
+        restored = true;
+        stdout.write(EXIT_FULLSCREEN_MODE);
+    };
 }
 main();

package/ink-app/dist/providers/claude.js

@@ -73,7 +73,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
             .map((row) => row.modelId)
-            .filter((modelId) => !resolveRate(modelId));
+            .filter((modelId) => !resolveRate(modelId) && !isInternalClaudeModel(modelId));
         if (unknownPricedModels.length > 0) {
             warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
@@ -135,43 +135,61 @@ function resolveRate(modelId) {
     }
     return undefined;
 }
+function isInternalClaudeModel(modelId) {
+    return modelId === "<synthetic>";
+}
 function creditsFor(modelId, usage) {
     const rate = resolveRate(modelId);
     if (!rate) {
         return 0;
     }
-    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
-    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const inferenceMultiplier = usage.inferenceGeo === "us" ? 1.1 : 1;
     return (((usage.inputTokens / 1000000) * rate.input +
         (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
-        (usage.cacheCreation5mInputTokens / 1000000) * rate.cacheWrite5m +
-        (usage.cacheCreation1hInputTokens / 1000000) * rate.cacheWrite1h +
-        (cacheWriteFallbackTokens / 1000000) * rate.cacheWrite5m +
+        (cacheWriteBreakdown.cacheWrite5mInputTokens / 1000000) * rate.cacheWrite5m +
+        (cacheWriteBreakdown.cacheWrite1hInputTokens / 1000000) * rate.cacheWrite1h +
         (usage.outputTokens / 1000000) * rate.output) *
         inferenceMultiplier *
         USD_TO_CREDITS);
 }
 function usageToTotals(modelId, usage) {
-    const nonCachedInputTokens = usage.inputTokens + usage.cacheCreationInputTokens;
-    const cachedInputTokens = usage.cacheReadInputTokens;
+    const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
+    const inputTotalTokens = usage.inputTokens +
+        cacheWriteBreakdown.cacheWrite5mInputTokens +
+        cacheWriteBreakdown.cacheWrite1hInputTokens +
+        usage.cacheReadInputTokens;
     return {
-        inputTokens: nonCachedInputTokens + cachedInputTokens,
-        cachedInputTokens,
-        nonCachedInputTokens,
+        inputTotalTokens,
         outputTokens: usage.outputTokens,
         reasoningOutputTokens: 0,
-        totalTokens: nonCachedInputTokens + cachedInputTokens + usage.outputTokens,
+        totalTokens: inputTotalTokens + usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage),
-        eventCount: 1
+        eventCount: 1,
+        tokenBreakdown: {
+            schema: "anthropic",
+            inputTokens: usage.inputTokens,
+            cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
+            cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens,
+            cacheReadInputTokens: usage.cacheReadInputTokens,
+            outputTokens: usage.outputTokens
+        }
     };
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("anthropic");
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
+function resolveClaudeCacheWriteBreakdown(usage) {
+    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
+    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    return {
+        cacheWrite5mInputTokens: usage.cacheCreation5mInputTokens + cacheWriteFallbackTokens,
+        cacheWrite1hInputTokens: usage.cacheCreation1hInputTokens
+    };
+}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`);
 }

package/ink-app/dist/providers/codex.js

@@ -17,6 +17,7 @@ export class CodexUsageProvider extends UsageProviderBase {
     }
     async getStats(_options = {}) {
         const sessionsRoot = path.join(this.root, ".codex", "sessions");
+        const knownModels = await readCodexModelMetadata(this.root);
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
@@ -30,7 +31,7 @@ export class CodexUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes);
+            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
             parseTotals.linesRead += fileStats.linesRead;
             parseTotals.tokenEvents += fileStats.tokenEvents;
             parseTotals.malformedLines += fileStats.malformedLines;
@@ -43,7 +44,7 @@ export class CodexUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
             .map((row) => row.modelId)
-            .filter((modelId) => !RATE_CARD[modelId]);
+            .filter((modelId) => !RATE_CARD[modelId] && !isAssumedZeroRatedCodexModel(modelId, knownModels));
         if (unknownPricedModels.length > 0) {
             warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
@@ -74,6 +75,39 @@ export class CodexUsageProvider extends UsageProviderBase {
         };
     }
 }
+async function readCodexModelMetadata(root) {
+    const modelsCachePath = path.join(root, ".codex", "models_cache.json");
+    let fileText;
+    try {
+        fileText = await fs.promises.readFile(modelsCachePath, "utf8");
+    }
+    catch {
+        return new Map();
+    }
+    let payload;
+    try {
+        payload = JSON.parse(fileText);
+    }
+    catch {
+        return new Map();
+    }
+    const models = asRecord(payload)?.models;
+    if (!Array.isArray(models)) {
+        return new Map();
+    }
+    const metadata = new Map();
+    for (const model of models) {
+        const record = asRecord(model);
+        const slug = typeof record?.slug === "string" ? record.slug : "";
+        if (!slug) {
+            continue;
+        }
+        metadata.set(slug, {
+            visibility: typeof record?.visibility === "string" ? record.visibility : ""
+        });
+    }
+    return metadata;
+}
 function createEmptyRawUsage() {
     return {
         inputTokens: 0,
@@ -107,38 +141,51 @@ function creditsFor(modelId, usage) {
     if (!rate) {
         return 0;
     }
-    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
-    const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
-    return ((nonCachedInputTokens / 1000000) * rate.input +
-        (cachedInputTokens / 1000000) * rate.cachedInput +
+    return ((usage.inputTokens / 1000000) * rate.input +
+        (usage.cachedInputTokens / 1000000) * rate.cachedInput +
         (usage.outputTokens / 1000000) * rate.output);
 }
 function rawUsageToTotals(usage) {
-    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    const inputTotalTokens = usage.inputTokens + usage.cachedInputTokens;
     return {
-        inputTokens: usage.inputTokens,
-        cachedInputTokens,
-        nonCachedInputTokens: Math.max(0, usage.inputTokens - cachedInputTokens),
+        inputTotalTokens,
         outputTokens: usage.outputTokens,
         reasoningOutputTokens: usage.reasoningOutputTokens,
-        totalTokens: usage.totalTokens,
+        totalTokens: inputTotalTokens + usage.outputTokens,
         estimatedCredits: 0,
-        eventCount: 0
+        eventCount: 0,
+        tokenBreakdown: {
+            schema: "openai",
+            nonCachedInputTokens: usage.inputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            outputTokens: usage.outputTokens
+        }
     };
 }
-function createUsageTotalsForModel(modelId, usage) {
+function createUsageTotalsForModel(modelId, usage, knownModels) {
     const resolvedModelId = modelId || "unknown";
     const deltaTotals = rawUsageToTotals(usage);
     deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
     deltaTotals.eventCount = 1;
+    if (!RATE_CARD[resolvedModelId] && !isAssumedZeroRatedCodexModel(resolvedModelId, knownModels)) {
+        deltaTotals.estimatedCreditsStatus = "unavailable";
+    }
     return deltaTotals;
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
+function isHiddenCodexModel(modelId, knownModels) {
+    return knownModels.get(modelId)?.visibility === "hide";
+}
+function isAssumedZeroRatedCodexModel(modelId, knownModels) {
+    // Hidden internal Codex models do not have a public rate card entry. For dashboard
+    // rollups we treat them as zero-rated so they do not turn aggregate totals unknown.
+    return isHiddenCodexModel(modelId, knownModels);
+}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
 }
@@ -160,7 +207,7 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
+async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, knownModels) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
@@ -201,7 +248,7 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
         const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
         previousTotal = totalUsage;
         const resolvedModelId = currentModel || "unknown";
-        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage);
+        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels);
         tokenEvents += 1;
         addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));

package/ink-app/dist/providers/contract.js

@@ -4,27 +4,31 @@ export class UsageProviderBase {
         this.label = label;
     }
 }
-export function createEmptyUsageTotals() {
+export function createEmptyUsageTotals(schema = "openai") {
     return {
-        inputTokens: 0,
-        cachedInputTokens: 0,
-        nonCachedInputTokens: 0,
+        inputTotalTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
         totalTokens: 0,
         estimatedCredits: 0,
-        eventCount: 0
+        eventCount: 0,
+        tokenBreakdown: createEmptyUsageTokenBreakdown(schema)
+    };
+}
+export function cloneUsageTotals(totals) {
+    return {
+        ...totals,
+        tokenBreakdown: { ...totals.tokenBreakdown }
     };
 }
 export function addUsageTotals(target, source) {
-    target.inputTokens += source.inputTokens;
-    target.cachedInputTokens += source.cachedInputTokens;
-    target.nonCachedInputTokens += source.nonCachedInputTokens;
+    target.inputTotalTokens += source.inputTotalTokens;
     target.outputTokens += source.outputTokens;
     target.reasoningOutputTokens += source.reasoningOutputTokens;
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
+    addUsageTokenBreakdown(target.tokenBreakdown, source.tokenBreakdown);
     if (source.cacheStatus === "unavailable") {
         target.cacheStatus = "unavailable";
     }
@@ -33,9 +37,44 @@ export function addUsageTotals(target, source) {
     }
 }
 export function sumUsageTotals(rows) {
-    const totals = createEmptyUsageTotals();
+    const totals = createEmptyUsageTotals(rows[0]?.tokenBreakdown.schema ?? "openai");
     for (const row of rows) {
         addUsageTotals(totals, row);
     }
     return totals;
 }
+function createEmptyUsageTokenBreakdown(schema) {
+    if (schema === "anthropic") {
+        return {
+            schema,
+            inputTokens: 0,
+            cacheWrite5mInputTokens: 0,
+            cacheWrite1hInputTokens: 0,
+            cacheReadInputTokens: 0,
+            outputTokens: 0
+        };
+    }
+    return {
+        schema,
+        nonCachedInputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0
+    };
+}
+function addUsageTokenBreakdown(target, source) {
+    if (target.schema !== source.schema) {
+        throw new Error(`Cannot merge ${source.schema} usage totals into ${target.schema} totals.`);
+    }
+    target.outputTokens += source.outputTokens;
+    if (target.schema === "anthropic" && source.schema === "anthropic") {
+        target.inputTokens += source.inputTokens;
+        target.cacheWrite5mInputTokens += source.cacheWrite5mInputTokens;
+        target.cacheWrite1hInputTokens += source.cacheWrite1hInputTokens;
+        target.cacheReadInputTokens += source.cacheReadInputTokens;
+        return;
+    }
+    if (target.schema === "openai" && source.schema === "openai") {
+        target.nonCachedInputTokens += source.nonCachedInputTokens;
+        target.cachedInputTokens += source.cachedInputTokens;
+    }
+}

package/ink-app/dist/providers/copilot.js

@@ -222,16 +222,24 @@ function isCopilotChatSpan(attributes) {
 function createUsageTotals(modelId, usage) {
     const hasCacheInfo = usage.cachedInputTokens !== undefined || usage.cacheCreationInputTokens !== undefined;
     const hasKnownCreditPricing = isNonBillableModel(modelId) || (hasCacheInfo && rateForModel(modelId, usage.inputTokens) !== undefined);
-    const cachedInputTokens = hasCacheInfo ? Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens) : 0;
+    const cachedInputTokens = hasCacheInfo ? Math.max(0, usage.cachedInputTokens ?? 0) : 0;
+    const cacheWriteInputTokens = hasCacheInfo ? Math.max(0, usage.cacheCreationInputTokens ?? 0) : 0;
+    const uncachedInputTokens = hasCacheInfo
+        ? Math.max(0, usage.inputTokens - cachedInputTokens - cacheWriteInputTokens)
+        : 0;
     return {
-        inputTokens: usage.inputTokens,
-        cachedInputTokens,
-        nonCachedInputTokens: hasCacheInfo ? Math.max(0, usage.inputTokens - cachedInputTokens) : 0,
+        inputTotalTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
         reasoningOutputTokens: Math.min(usage.reasoningOutputTokens ?? 0, usage.outputTokens),
         totalTokens: usage.inputTokens + usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage),
         eventCount: 1,
+        tokenBreakdown: {
+            schema: "openai",
+            nonCachedInputTokens: uncachedInputTokens,
+            cachedInputTokens,
+            outputTokens: usage.outputTokens
+        },
         cacheStatus: hasCacheInfo ? "known" : "unavailable",
         estimatedCreditsStatus: hasKnownCreditPricing ? "known" : "unavailable"
     };
@@ -272,7 +280,7 @@ function isNonBillableModel(modelId) {
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }

package/ink-app/dist/providers/daily.js

@@ -1,4 +1,4 @@
-import { addUsageTotals } from "./contract.js";
+import { addUsageTotals, cloneUsageTotals } from "./contract.js";
 export function createDailyUsageAggregates() {
     return new Map();
 }
@@ -18,7 +18,7 @@ export function addDailyUsage(rows, eventTimeMs, modelId, planType, deltaTotals)
             sortTimeMs,
             firstEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
             lastEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
-            totals: { ...deltaTotals },
+            totals: cloneUsageTotals(deltaTotals),
             models,
             planTypes
         });
@@ -46,7 +46,7 @@ export function buildDailyUsageRows(rows) {
         lastEventUtcIso: row.lastEventMs === null ? null : formatIsoFromMilliseconds(row.lastEventMs),
         distinctModels: [...row.models].sort(),
         distinctPlanTypes: [...row.planTypes].sort(),
-        totals: { ...row.totals }
+        totals: cloneUsageTotals(row.totals)
     }));
 }
 function resolveDayBucket(eventTimeMs) {

package/ink-app/dist/providers/limits.js

@@ -1,4 +1,4 @@
-import { addUsageTotals, createEmptyUsageTotals } from "./contract.js";
+import { addUsageTotals, cloneUsageTotals, createEmptyUsageTotals } from "./contract.js";
 export function createLimitWindowAggregates() {
     return new Map();
 }
@@ -71,7 +71,7 @@ function collapseNearbyWindows(rows) {
         if (!existing) {
             collapsed.set(key, {
                 ...row,
-                totals: { ...row.totals }
+                totals: cloneUsageTotals(row.totals)
             });
             continue;
         }
@@ -93,7 +93,7 @@ function collapseNearbyWindows(rows) {
 function computeWindowTotals(events) {
     // Session files are not guaranteed to be parsed in timestamp order, so
     // saturation has to be applied after we sort the captured window events.
-    const totals = createEmptyUsageTotals();
+    const totals = createEmptyUsageTotals(events[0]?.totals.tokenBreakdown.schema ?? "openai");
     let sawBelowCap = false;
     let isExhausted = false;
     for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
@@ -132,7 +132,7 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
             lastSeenMs: eventTimeMs,
             minUsedPercent: usedPercent,
             maxUsedPercent: usedPercent,
-            events: [{ eventTimeMs, usedPercent, totals: { ...deltaTotals } }]
+            events: [{ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
         });
         return;
     }
@@ -142,5 +142,5 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
     existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
     existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
     existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.events.push({ eventTimeMs, usedPercent, totals: { ...deltaTotals } });
+    existing.events.push({ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) });
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "letmecode",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
+  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": "./bin/letmecode.js",
   "files": [
@@ -18,6 +19,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
+    "prepack": "npm run build",
+    "prestart": "npm run build",
+    "start": "node ./bin/letmecode.js",
+    "pretest": "npm run build",
+    "smoke": "node ./bin/letmecode.js",
+    "test": "node --test ink-app/test/*.test.mjs"
+  },
   "keywords": [
     "cli",
     "ink",
@@ -33,14 +44,5 @@
     "@types/node": "^24.0.7",
     "@types/react": "^18.3.24",
     "typescript": "^5.8.3"
-  },
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
-    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
-    "prestart": "npm run build",
-    "start": "node ./bin/letmecode.js",
-    "pretest": "npm run build",
-    "smoke": "node ./bin/letmecode.js",
-    "test": "node --test ink-app/test/*.test.mjs"
   }
-}
+}