letmecode 0.1.1 → 0.1.2

package/README.md

@@ -1,18 +1,44 @@
-# letmecode
+# letmecode - Discover your detailed agent ussage Codex | Claude
 
-Minimal `npx`-first CLI package.
-
-## Local development
+Ussage:
 
 ```bash
-pnpm install
-pnpm start
+npx -y letmecode
 ```
 
-The Ink app source lives in `ink-app/`.
+<img width="2308" height="1491" alt="image" src="https://github.com/user-attachments/assets/f3f52d79-00e3-4ff5-bf2f-65f8be632aaa" />
+
+## Controls
+
+| Key | Action |
+| --- | --- |
+| `[` / `]` | Switch providers |
+| `Tab` / `Shift+Tab` | Switch providers when supported by the terminal |
+| `Up` / `Down` or `k` / `j` | Switch dashboard sections |
+| `Left` / `Right` | Select the previous or next table row |
+| `Enter` | Run the selected provider action |
+| `1` | Select the Copilot VS Code setup action |
+| `h` / `l` | Select a Copilot setup action |
+| `q` or `Esc` | Quit |
+
+## Copilot
 
-## Usage
+Copilot CLI usage is read from `~/.copilot/session-state`.
+
+VS Code extension usage needs file OTEL logging first. Select the `Copilot` provider, choose `Start logging VS Code` with `1` or `h` / `l`, then press `Enter`; letmecode will update the current user's VS Code settings with:
+
+```json
+{
+  "github.copilot.chat.otel.enabled": true,
+  "github.copilot.chat.otel.exporterType": "file",
+  "github.copilot.chat.otel.outfile": "~/.copilot/otel/vscode.jsonl",
+  "github.copilot.chat.otel.captureContent": false
+}
+```
+
+## Local development
 
 ```bash
-npx letmecode
+pnpm install
+pnpm start
 ```

package/ink-app/dist/index.js

@@ -1,13 +1,15 @@
 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 { createProviders } from "./providers/index.js";
+import { configureCopilotVsCodeLogging, createProviders } from "./providers/index.js";
 const VERTICAL_TABS = [
     { id: "limit-windows", label: "Limits" },
     { id: "summary", label: "Summary" },
+    { id: "day-to-day-analyses", label: "day to day" },
     { id: "usage-by-model", label: "by model" }
 ];
 const CODEX_CREDIT_COST_USD = 0.01;
+const VERTICAL_TAB_WIDTH = 12;
 const LIMIT_WINDOW_COLUMNS = {
     plan: 8,
     window: 8,
@@ -24,27 +26,46 @@ const MODEL_USAGE_COLUMNS = {
     credits: 12,
     value: 12
 };
-function App() {
+const DAY_USAGE_COLUMNS = {
+    day: 11,
+    events: 6,
+    input: 11,
+    output: 10,
+    value: 10
+};
+const COPILOT_ACTIONS = [
+    { id: "vscode", label: "Start logging VS Code", enabled: true }
+];
+function App(props) {
     const { exit } = useApp();
     const providers = React.useState(() => createProviders())[0];
     const [providerStates, setProviderStates] = useState(providers.map((provider) => ({ provider, status: "loading" })));
-    const [selectedProviderIndex, setSelectedProviderIndex] = useState(0);
+    const [selectedProviderId, setSelectedProviderId] = useState(providers[0]?.id ?? "");
+    const [hasUserSelectedProvider, setHasUserSelectedProvider] = useState(false);
     const [selectedVerticalTabIndex, setSelectedVerticalTabIndex] = useState(0);
     const [selectedLimitRowIndex, setSelectedLimitRowIndex] = useState(0);
+    const [selectedDayRowIndex, setSelectedDayRowIndex] = useState(0);
     const [selectedModelRowIndex, setSelectedModelRowIndex] = useState(0);
-    const selectedProvider = providerStates[selectedProviderIndex];
+    const [selectedCopilotActionIndex, setSelectedCopilotActionIndex] = useState(0);
+    const [copilotActionMessage, setCopilotActionMessage] = useState();
+    const sortedProviderStates = React.useMemo(() => sortProviderStatesByUsage(providerStates), [providerStates]);
+    const selectedProviderIndex = Math.max(0, sortedProviderStates.findIndex((state) => state.provider.id === selectedProviderId));
+    const selectedProvider = sortedProviderStates[selectedProviderIndex];
     const selectedVerticalTab = VERTICAL_TABS[selectedVerticalTabIndex];
     const limitRows = getLimitRows(selectedProvider);
+    const dayRows = getDayRows(selectedProvider);
     const modelRows = getModelRows(selectedProvider);
     const activeLimitRowIndex = clampSelectionIndex(selectedLimitRowIndex, limitRows.length);
+    const activeDayRowIndex = clampSelectionIndex(selectedDayRowIndex, dayRows.length);
     const activeModelRowIndex = clampSelectionIndex(selectedModelRowIndex, modelRows.length);
     const selectedLimitRow = activeLimitRowIndex >= 0 ? limitRows[activeLimitRowIndex] : undefined;
+    const selectedDayRow = activeDayRowIndex >= 0 ? dayRows[activeDayRowIndex] : undefined;
     const selectedModelRow = activeModelRowIndex >= 0 ? modelRows[activeModelRowIndex] : undefined;
     useEffect(() => {
         let cancelled = false;
         for (const provider of providers) {
             void provider
-                .getStats()
+                .getStats(props.statsOptions)
                 .then((stats) => {
                 if (cancelled) {
                     return;
@@ -66,13 +87,39 @@ function App() {
         return () => {
             cancelled = true;
         };
-    }, [providers]);
+    }, [props.statsOptions, providers]);
+    useEffect(() => {
+        if (hasUserSelectedProvider || providerStates.some((state) => state.status === "loading")) {
+            return;
+        }
+        const topProvider = sortedProviderStates[0];
+        if (providerUsageScore(topProvider) <= 0) {
+            return;
+        }
+        setSelectedProviderId(topProvider.provider.id);
+    }, [hasUserSelectedProvider, providerStates, sortedProviderStates]);
     useInput((input, key) => {
         if (input === "q" || key.escape) {
             exit();
             return;
         }
-        if ((key.ctrl || key.shift) && key.downArrow) {
+        if (selectedProvider.provider.id === "copilot" && input >= "1" && input <= String(COPILOT_ACTIONS.length)) {
+            setSelectedCopilotActionIndex(Number(input) - 1);
+            return;
+        }
+        if (selectedProvider.provider.id === "copilot" && key.return) {
+            runCopilotAction(COPILOT_ACTIONS[selectedCopilotActionIndex].id, setCopilotActionMessage);
+            return;
+        }
+        if (selectedProvider.provider.id === "copilot" && input === "l") {
+            setSelectedCopilotActionIndex((current) => (current + 1) % COPILOT_ACTIONS.length);
+            return;
+        }
+        if (selectedProvider.provider.id === "copilot" && input === "h") {
+            setSelectedCopilotActionIndex((current) => (current - 1 + COPILOT_ACTIONS.length) % COPILOT_ACTIONS.length);
+            return;
+        }
+        if (key.rightArrow) {
             if (selectedVerticalTab.id === "limit-windows") {
                 setSelectedLimitRowIndex(clampSelectionIndex(activeLimitRowIndex + 1, limitRows.length));
                 return;
@@ -81,8 +128,12 @@ function App() {
                 setSelectedModelRowIndex(clampSelectionIndex(activeModelRowIndex + 1, modelRows.length));
                 return;
             }
+            if (selectedVerticalTab.id === "day-to-day-analyses") {
+                setSelectedDayRowIndex(clampSelectionIndex(activeDayRowIndex + 1, dayRows.length));
+                return;
+            }
         }
-        if ((key.ctrl || key.shift) && key.upArrow) {
+        if (key.leftArrow) {
             if (selectedVerticalTab.id === "limit-windows") {
                 setSelectedLimitRowIndex(clampSelectionIndex(activeLimitRowIndex - 1, limitRows.length));
                 return;
@@ -91,13 +142,20 @@ function App() {
                 setSelectedModelRowIndex(clampSelectionIndex(activeModelRowIndex - 1, modelRows.length));
                 return;
             }
+            if (selectedVerticalTab.id === "day-to-day-analyses") {
+                setSelectedDayRowIndex(clampSelectionIndex(activeDayRowIndex - 1, dayRows.length));
+                return;
+            }
         }
-        if ((input === "\t" && !key.shift) || key.rightArrow) {
-            setSelectedProviderIndex((current) => (current + 1) % providerStates.length);
+        if ((key.tab && !key.shift) || input === "]") {
+            setSelectedProviderId(sortedProviderStates[(selectedProviderIndex + 1) % sortedProviderStates.length].provider.id);
+            setHasUserSelectedProvider(true);
             return;
         }
-        if ((input === "\t" && key.shift) || key.leftArrow) {
-            setSelectedProviderIndex((current) => (current - 1 + providerStates.length) % providerStates.length);
+        if ((key.tab && key.shift) || input === "[") {
+            setSelectedProviderId(sortedProviderStates[(selectedProviderIndex - 1 + sortedProviderStates.length) % sortedProviderStates.length]
+                .provider.id);
+            setHasUserSelectedProvider(true);
             return;
         }
         if (key.downArrow || input === "j") {
@@ -108,7 +166,39 @@ function App() {
             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/shift+tab or left/right to switch providers, j/k or up/down for details, ctrl+up/down or shift+up/down to select a row, q to quit" }), _jsx(Box, { marginTop: 1, children: providerStates.map((state, index) => (_jsx(ProviderTab, { label: state.provider.label, active: index === selectedProviderIndex, status: state.status }, state.provider.id))) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { flexDirection: "column", width: 12, 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, selectedModelId: selectedModelRow?.modelId }) })] }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRow: selectedLimitRow, selectedModelRow: selectedModelRow }), 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, 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] }));
+}
+function CopilotActionsPanel(props) {
+    if (props.providerState.provider.id !== "copilot") {
+        return null;
+    }
+    const hasNoUsage = props.providerState.status === "ready" && props.providerState.stats.summary.tokenEvents === 0;
+    const accentColor = hasNoUsage ? "red" : "cyan";
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: accentColor, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: accentColor, children: "Copilot setup" }), _jsx(Box, { children: COPILOT_ACTIONS.map((action, index) => (_jsx(Box, { marginRight: 1, children: _jsx(Text, { inverse: index === (props.selectedActionIndex ?? 0), bold: hasNoUsage && action.id === "vscode", color: action.enabled ? (hasNoUsage && action.id === "vscode" ? accentColor : undefined) : "gray", children: `${index + 1} ${action.label}` }) }, action.id))) }), _jsx(Text, { color: hasNoUsage ? accentColor : "gray", children: "Press 1 or h/l to select an action, enter to run selected." }), props.actionMessage ? _jsx(Text, { children: props.actionMessage }) : null] }));
+}
+function runCopilotAction(actionId, setCopilotActionMessage) {
+    setCopilotActionMessage("Updating VS Code settings...");
+    void configureCopilotVsCodeLogging()
+        .then((result) => {
+        setCopilotActionMessage(formatCopilotLoggingResult(result));
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        setCopilotActionMessage(`Failed to update VS Code settings: ${message}`);
+    });
+}
+function formatCopilotLoggingResult(result) {
+    const status = result.changed ? "VS Code logging enabled" : "VS Code logging already enabled";
+    return [
+        `${status}: ${result.outfile}`,
+        `Settings written to: ${result.settingsPath}`,
+        'Open "Preferences: Open User Settings (JSON)" in VS Code and verify that this is the active file.',
+        "Expected settings:",
+        '"github.copilot.chat.otel.enabled": true',
+        '"github.copilot.chat.otel.exporterType": "file"',
+        '"github.copilot.chat.otel.captureContent": false',
+        `"github.copilot.chat.otel.outfile": "${result.outfile}"`
+    ].join("\n");
 }
 function ProviderTab(props) {
     const statusColor = props.status === "error" ? "red" : props.status === "loading" ? "yellow" : "green";
@@ -116,12 +206,12 @@ function ProviderTab(props) {
     return (_jsx(Box, { marginRight: 1, children: _jsx(Text, { inverse: props.active, color: statusColor, children: tabLabel }) }));
 }
 function VerticalTab(props) {
-    return (_jsx(Text, { inverse: props.active, children: props.active ? ` ${props.label} ` : ` ${props.label}` }));
+    return (_jsx(Box, { width: VERTICAL_TAB_WIDTH, children: _jsx(Text, { wrap: "truncate-end", inverse: props.active, children: props.active ? ` ${props.label} ` : ` ${props.label}` }) }));
 }
 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: ", formatInteger(summary.totals.cachedInputTokens), "  non-cached: ", formatInteger(summary.totals.nonCachedInputTokens)] }), _jsxs(Text, { children: ["output: ", formatInteger(summary.totals.outputTokens), "  reasoning: ", formatInteger(summary.totals.reasoningOutputTokens), "  total: ", formatInteger(summary.totals.totalTokens)] }), _jsxs(Text, { children: ["estimated credits: ", formatCredits(summary.totals.estimatedCredits)] }), _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)] }), _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"] })] }));
 }
 function ContentPanel(props) {
     if (props.providerState.status === "loading") {
@@ -136,10 +226,13 @@ function ContentPanel(props) {
     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(UsageByModelPanel, { stats: props.providerState.stats, selectedModelId: props.selectedModelId });
 }
 function LimitWindowsPanel(props) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Primary" }), _jsx(LimitWindowSection, { windows: props.stats.primaryLimitWindows, selectedRowKey: props.selectedRowKey }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { bold: true, children: "Secondary" }), _jsx(LimitWindowSection, { windows: props.stats.secondaryLimitWindows, selectedRowKey: props.selectedRowKey })] }));
+    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) {
@@ -159,8 +252,17 @@ function UsageByModelPanel(props) {
     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(formatInteger(row.totals.cachedInputTokens), MODEL_USAGE_COLUMNS.cached), " ", pad(formatInteger(row.totals.nonCachedInputTokens), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(row.totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatCredits(row.totals.estimatedCredits), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsd(row.totals.estimatedCredits * CODEX_CREDIT_COST_USD), 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(formatInteger(totals.cachedInputTokens), MODEL_USAGE_COLUMNS.cached), " ", pad(formatInteger(totals.nonCachedInputTokens), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatCredits(totals.estimatedCredits), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD), MODEL_USAGE_COLUMNS.value)] })] }));
+                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)] })] }));
+}
+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));
+            })] }));
 }
 function SelectionDetailsPanel(props) {
     if (props.providerState.status !== "ready") {
@@ -170,6 +272,10 @@ function SelectionDetailsPanel(props) {
         const row = props.selectedLimitRow;
         return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Limit details" }), _jsxs(Text, { children: [row.scope, "  plan: ", row.planType, "  window: ", formatWindowMinutes(row.windowMinutes), "  used: ", row.minUsedPercent, "%", "->", row.maxUsedPercent, "%  limit: ", row.limitId] }), _jsxs(Text, { children: ["range: ", formatLocalDateTime(row.startTimeUtcIso), " ", "->", " ", formatLocalDateTime(row.endTimeUtcIso), "  events: ", formatInteger(row.eventCount)] }), _jsx(UsageTotalsDetails, { totals: row.totals })] }));
     }
+    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 })] }));
+    }
     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 })] }));
     }
@@ -178,18 +284,38 @@ function SelectionDetailsPanel(props) {
 function UsageTotalsDetails(props) {
     const { totals } = props;
     const inputPerOutput = formatInputPerOutput(totals);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Total credits burned: ", formatCredits(totals.estimatedCredits)] }), _jsxs(Text, { children: ["Credits Value (@ $0.01/credit): ", formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD)] }), _jsxs(Text, { children: ["IpO: ", inputPerOutput.cached, ":", inputPerOutput.nonCached, ":", inputPerOutput.output] })] }));
+    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] })] }));
 }
 function formatInteger(value) {
     return Math.round(value).toLocaleString("en-US");
 }
 function formatCredits(value) {
+    if (value > 0 && value < 0.01) {
+        return "<0.01";
+    }
     return value.toLocaleString("en-US", {
         minimumFractionDigits: 2,
         maximumFractionDigits: 2
     });
 }
+function formatUsageCredits(totals) {
+    return totals.estimatedCreditsStatus === "unavailable" ? "unknown" : formatCredits(totals.estimatedCredits);
+}
+function formatUsageUsd(totals) {
+    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 formatUsd(value) {
+    if (value > 0 && value < 0.0001) {
+        return "<$0.0001";
+    }
     return value.toLocaleString("en-US", {
         currency: "USD",
         style: "currency",
@@ -217,10 +343,32 @@ function formatLocalDateTime(value) {
     const lookup = Object.fromEntries(parts.map((part) => [part.type, part.value]));
     return `${lookup.day} ${lookup.month} ${lookup.year} ${lookup.hour}:${lookup.minute}`;
 }
+function formatUtcDay(value) {
+    if (value === "unknown") {
+        return "unknown";
+    }
+    const parts = new Intl.DateTimeFormat("en-US", {
+        month: "short",
+        day: "2-digit",
+        year: "2-digit",
+        timeZone: "UTC"
+    }).formatToParts(new Date(`${value}T00:00:00.000Z`));
+    const lookup = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${lookup.day} ${lookup.month} ${lookup.year}`;
+}
+function formatEventRange(firstEventUtcIso, lastEventUtcIso) {
+    if (!firstEventUtcIso || !lastEventUtcIso) {
+        return "unknown";
+    }
+    return `${formatLocalDateTime(firstEventUtcIso)} -> ${formatLocalDateTime(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" };
+    }
     if (totals.outputTokens <= 0) {
         return { cached: "0", nonCached: "0", output: "0" };
     }
@@ -236,6 +384,20 @@ function clampSelectionIndex(value, rowCount) {
     }
     return Math.max(0, Math.min(value, rowCount - 1));
 }
+function sortProviderStatesByUsage(states) {
+    return states
+        .map((state, index) => ({ state, index }))
+        .sort((left, right) => providerUsageScore(right.state) - providerUsageScore(left.state) ||
+        left.index - right.index)
+        .map((entry) => entry.state);
+}
+function providerUsageScore(state) {
+    if (state.status !== "ready") {
+        return 0;
+    }
+    const totals = state.stats.summary.totals;
+    return totals.inputTokens + totals.cachedInputTokens + totals.outputTokens;
+}
 function getLimitRows(providerState) {
     if (providerState.status !== "ready") {
         return [];
@@ -248,10 +410,21 @@ function getModelRows(providerState) {
     }
     return providerState.stats.modelUsage;
 }
+function getDayRows(providerState) {
+    if (providerState.status !== "ready") {
+        return [];
+    }
+    return providerState.stats.dayUsage;
+}
 function getLimitRowKey(row) {
     return `${row.scope}-${row.planType}-${row.limitId}-${row.startTimeUtcIso}-${row.endTimeUtcIso}`;
 }
-export function main() {
-    render(_jsx(App, {}));
+function parseStatsOptions(argv) {
+    return {
+        verbose: argv.includes("-v") || argv.includes("--verbose")
+    };
+}
+export function main(argv = process.argv.slice(2)) {
+    render(_jsx(App, { statsOptions: parseStatsOptions(argv) }));
 }
 main();

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

@@ -4,31 +4,34 @@ import path from "node:path";
 import readline from "node:readline";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 const RATE_CARD = {
-    "claude-opus-4-8": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-7": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-6": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-5": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-1": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
-    "claude-opus-4": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
-    "claude-sonnet-4-6": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-sonnet-4-5": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-sonnet-4": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-haiku-4-5": { input: 100, cacheWrite5m: 125, cacheWrite1h: 200, cacheRead: 10, output: 500 },
-    "claude-haiku-3-5": { input: 80, cacheWrite5m: 100, cacheWrite1h: 160, cacheRead: 8, output: 400 }
+    "claude-opus-4-8": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-7": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-6": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-5": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-1": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
+    "claude-opus-4": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
+    "claude-sonnet-4-6": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-sonnet-4": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-haiku-4-5": { input: 1, cacheWrite5m: 1.25, cacheWrite1h: 2, cacheRead: 0.1, output: 5 },
+    "claude-haiku-3-5": { input: 0.8, cacheWrite5m: 1, cacheWrite1h: 1.6, cacheRead: 0.08, output: 4 }
 };
+const USD_TO_CREDITS = 100;
 export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("claude", "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
     }
-    async getStats() {
+    async getStats(options = {}) {
         const sessionsRoot = path.join(this.root, ".claude", "projects");
         const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
         const planTypes = new Set();
         const warnings = [];
-        const seenUsageEvents = new Set();
+        const parsedEvents = createParsedUsageEventAccumulator();
         const parseTotals = {
             filesScanned: 0,
             linesRead: 0,
@@ -37,14 +40,34 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, windows, planTypes, seenUsageEvents);
+            const fileStats = await parseSessionFile(file, parsedEvents);
             parseTotals.linesRead += fileStats.linesRead;
-            parseTotals.tokenEvents += fileStats.tokenEvents;
             parseTotals.malformedLines += fileStats.malformedLines;
         }
+        const selectedEvents = [
+            ...parsedEvents.keyedEvents.values(),
+            ...parsedEvents.unkeyedEvents.values()
+        ];
+        for (const event of selectedEvents) {
+            addModelUsage(byModel, event.modelId, event.totals);
+            const planType = typeof event.rateLimits?.plan_type === "string" ? event.rateLimits.plan_type : undefined;
+            const safeEventTimeMs = Number.isFinite(event.timestampMs) ? event.timestampMs : 0;
+            addDailyUsage(byDay, event.timestampMs, event.modelId, planType, event.totals);
+            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.totals, planTypes);
+        }
+        parseTotals.tokenEvents = selectedEvents.length;
         if (parseTotals.malformedLines > 0) {
             warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
         }
+        if (options.verbose && parsedEvents.duplicateUsageKeys > 0) {
+            warnings.push(`Collapsed ${parsedEvents.duplicateUsageKeys} duplicate Claude usage event(s) by request/message key.`);
+        }
+        if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
+            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; keeping the highest-cost/latest event per key.`);
+        }
+        if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
+            warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} duplicate unkeyed Claude usage event(s) by usage signature.`);
+        }
         const modelUsage = [...byModel.entries()]
             .map(([modelId, totals]) => ({ modelId, totals }))
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
@@ -58,6 +81,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             warnings.push(`No Claude session files found under ${sessionsRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const dayUsage = buildDailyUsageRows(byDay);
         const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
         if (parseTotals.filesScanned > 0 &&
             parseTotals.tokenEvents > 0 &&
@@ -79,6 +103,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 rootPath: sessionsRoot
             },
             modelUsage,
+            dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
             warnings
@@ -124,7 +149,8 @@ function creditsFor(modelId, usage) {
         (usage.cacheCreation1hInputTokens / 1000000) * rate.cacheWrite1h +
         (cacheWriteFallbackTokens / 1000000) * rate.cacheWrite5m +
         (usage.outputTokens / 1000000) * rate.output) *
-        inferenceMultiplier);
+        inferenceMultiplier *
+        USD_TO_CREDITS);
 }
 function usageToTotals(modelId, usage) {
     const nonCachedInputTokens = usage.inputTokens + usage.cacheCreationInputTokens;
@@ -167,11 +193,10 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, windows, planTypes, seenUsageEvents) {
+async function parseSessionFile(filePath, parsedEvents) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
-    let tokenEvents = 0;
     let malformedLines = 0;
     for await (const line of lineReader) {
         linesRead += 1;
@@ -194,22 +219,23 @@ async function parseSessionFile(filePath, byModel, windows, planTypes, seenUsage
         if (!usage) {
             continue;
         }
-        const usageKey = buildUsageEventKey(payloadObject, message);
-        if (usageKey && seenUsageEvents.has(usageKey)) {
-            continue;
-        }
-        if (usageKey) {
-            seenUsageEvents.add(usageKey);
-        }
         const modelId = String(message?.model ?? "unknown");
-        const deltaTotals = usageToTotals(modelId, normalizeUsage(usage));
-        addModelUsage(byModel, modelId, deltaTotals);
-        tokenEvents += 1;
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
-        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        applyRateLimits(windows, extractRateLimits(payloadObject, message), safeEventTimeMs, deltaTotals, planTypes);
+        const rateLimits = extractRateLimits(payloadObject, message);
+        const normalizedUsage = normalizeUsage(usage);
+        const usageKey = buildUsageEventKey(payloadObject, message);
+        const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
+        const parsedEvent = {
+            usageKey,
+            usageSignature,
+            timestampMs: eventTimeMs,
+            modelId,
+            totals: usageToTotals(modelId, normalizedUsage),
+            rateLimits
+        };
+        recordParsedUsageEvent(parsedEvents, parsedEvent);
     }
-    return { linesRead, tokenEvents, malformedLines };
+    return { linesRead, malformedLines };
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -220,6 +246,66 @@ function buildUsageEventKey(payloadObject, message) {
     }
     return `${sessionId}|${requestId || messageId}`;
 }
+function buildUsageSignature(payloadObject, modelId, usage) {
+    return [
+        String(payloadObject.sessionId ?? ""),
+        modelId,
+        usage.inputTokens,
+        usage.cacheCreationInputTokens,
+        usage.cacheCreation5mInputTokens,
+        usage.cacheCreation1hInputTokens,
+        usage.cacheReadInputTokens,
+        usage.outputTokens,
+        usage.inferenceGeo
+    ].join("|");
+}
+function createParsedUsageEventAccumulator() {
+    return {
+        keyedEvents: new Map(),
+        unkeyedEvents: new Map(),
+        duplicateUsageKeys: 0,
+        duplicateUsageKeyCollisions: 0,
+        duplicateUnkeyedEvents: 0
+    };
+}
+function recordParsedUsageEvent(parsedEvents, event) {
+    if (event.usageKey) {
+        const previous = parsedEvents.keyedEvents.get(event.usageKey);
+        if (!previous) {
+            parsedEvents.keyedEvents.set(event.usageKey, event);
+            return;
+        }
+        parsedEvents.duplicateUsageKeys += 1;
+        if (previous.usageSignature !== event.usageSignature) {
+            parsedEvents.duplicateUsageKeyCollisions += 1;
+        }
+        if (shouldReplaceUsageEvent(previous, event)) {
+            parsedEvents.keyedEvents.set(event.usageKey, event);
+        }
+        return;
+    }
+    const previous = parsedEvents.unkeyedEvents.get(event.usageSignature);
+    if (!previous) {
+        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+        return;
+    }
+    parsedEvents.duplicateUnkeyedEvents += 1;
+    if (shouldReplaceUsageEvent(previous, event)) {
+        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+    }
+}
+function shouldReplaceUsageEvent(previous, next) {
+    if (next.totals.estimatedCredits > previous.totals.estimatedCredits) {
+        return true;
+    }
+    if (next.totals.estimatedCredits === previous.totals.estimatedCredits) {
+        return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs);
+    }
+    return false;
+}
+function normalizeTimestamp(value) {
+    return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
 function extractRateLimits(payloadObject, message) {
     return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
 }

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import readline from "node:readline";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 const RATE_CARD = {
     "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
     "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
@@ -14,9 +15,10 @@ export class CodexUsageProvider extends UsageProviderBase {
         super("codex", "Codex");
         this.root = path.resolve(options.root ?? os.homedir());
     }
-    async getStats() {
+    async getStats(_options = {}) {
         const sessionsRoot = path.join(this.root, ".codex", "sessions");
         const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
         const planTypes = new Set();
         const warnings = [];
@@ -28,7 +30,7 @@ export class CodexUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, windows, planTypes);
+            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes);
             parseTotals.linesRead += fileStats.linesRead;
             parseTotals.tokenEvents += fileStats.tokenEvents;
             parseTotals.malformedLines += fileStats.malformedLines;
@@ -49,6 +51,7 @@ export class CodexUsageProvider extends UsageProviderBase {
             warnings.push(`No Codex session files found under ${sessionsRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const dayUsage = buildDailyUsageRows(byDay);
         const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
         return {
             providerId: this.id,
@@ -64,6 +67,7 @@ export class CodexUsageProvider extends UsageProviderBase {
                 rootPath: sessionsRoot
             },
             modelUsage,
+            dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
             warnings
@@ -156,7 +160,7 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, windows, planTypes) {
+async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
@@ -202,7 +206,10 @@ async function parseSessionFile(filePath, byModel, windows, planTypes) {
         addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
         const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        applyRateLimits(windows, asRecord(payload.rate_limits), safeEventTimeMs, deltaTotals, planTypes);
+        const rateLimits = asRecord(payload.rate_limits);
+        const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
+        addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
+        applyRateLimits(windows, rateLimits, safeEventTimeMs, deltaTotals, planTypes);
     }
     return { linesRead, tokenEvents, malformedLines };
 }

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

@@ -25,6 +25,12 @@ export function addUsageTotals(target, source) {
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
+    if (source.cacheStatus === "unavailable") {
+        target.cacheStatus = "unavailable";
+    }
+    if (source.estimatedCreditsStatus === "unavailable") {
+        target.estimatedCreditsStatus = "unavailable";
+    }
 }
 export function sumUsageTotals(rows) {
     const totals = createEmptyUsageTotals();

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

@@ -0,0 +1,380 @@
+import fs from "node:fs";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
+import { asRecord } from "./limits.js";
+const VSCODE_OTEL_SETTINGS = {
+    "github.copilot.chat.otel.enabled": true,
+    "github.copilot.chat.otel.exporterType": "file",
+    "github.copilot.chat.otel.captureContent": false
+};
+const RATE_CARD = {
+    "gpt-5-mini": { input: 25, cachedInput: 2.5, output: 200 },
+    "gpt-5.3-codex": { input: 175, cachedInput: 17.5, output: 1400 },
+    "gpt-5.4": { input: 250, cachedInput: 25, output: 1500 },
+    "gpt-5.4-mini": { input: 75, cachedInput: 7.5, output: 450 },
+    "gpt-5.4-nano": { input: 20, cachedInput: 2, output: 125 },
+    "gpt-5.5": { input: 500, cachedInput: 50, output: 3000 },
+    "claude-haiku-4-5": { input: 100, cachedInput: 10, cacheWrite: 125, output: 500 },
+    "claude-sonnet-4-5": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-sonnet-4-6": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-opus-4-5": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-6": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-7": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-8": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-fable-5": { input: 1000, cachedInput: 100, cacheWrite: 1250, output: 5000 },
+    "gemini-2.5-pro": { input: 125, cachedInput: 12.5, output: 1000 },
+    "gemini-3-flash": { input: 50, cachedInput: 5, output: 300 },
+    "gemini-3.1-pro": { input: 200, cachedInput: 20, output: 1200 },
+    "gemini-3.5-flash": { input: 150, cachedInput: 15, output: 900 },
+    "mai-code-1-flash": { input: 75, cachedInput: 7.5, output: 450 },
+    "raptor-mini": { input: 25, cachedInput: 2.5, output: 200 }
+};
+const LONG_CONTEXT_RATE_CARD = {
+    "gpt-5.4": { thresholdInputTokens: 272000, input: 500, cachedInput: 50, output: 2250 },
+    "gpt-5.5": { thresholdInputTokens: 272000, input: 1000, cachedInput: 100, output: 4500 },
+    "gemini-3.1-pro": { thresholdInputTokens: 200000, input: 400, cachedInput: 40, output: 1800 }
+};
+const NON_BILLABLE_MODEL_PREFIXES = ["copilot-nes", "copilot-suggestion"];
+export class CopilotUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("copilot", "Copilot");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats() {
+        const vscodeOtelFile = getCopilotOtelPath(this.root);
+        const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
+        const warnings = [];
+        const parseTotals = {
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        const vscodeOtelFileExists = await isReadableFile(vscodeOtelFile);
+        if (vscodeOtelFileExists) {
+            const fileStats = await parseCopilotJsonlFile(vscodeOtelFile, byModel, byDay);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.tokenEvents += fileStats.tokenEvents;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        else if (await isCopilotVsCodeLoggingEnabled(this.root, vscodeOtelFile)) {
+            warnings.push(`VS Code Copilot logging is enabled, but ${vscodeOtelFile} has not been created yet. Reload VS Code and send a Copilot Chat request.`);
+        }
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed Copilot JSONL line(s).`);
+        }
+        const filesScanned = vscodeOtelFileExists ? 1 : 0;
+        if (filesScanned === 0) {
+            warnings.push(`No Copilot VS Code OTEL usage file found at ${vscodeOtelFile}.`);
+        }
+        else if (parseTotals.tokenEvents === 0) {
+            warnings.push("No Copilot token usage events found. For VS Code, run Start logging VS Code and reload VS Code.");
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        if (summaryTotals.cacheStatus === "unavailable") {
+            warnings.push("Copilot cache token attributes are unavailable for some events; cached/non-cached tokens and estimated credits are shown as unknown.");
+        }
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [],
+                rootLabel: "~/.copilot/otel/vscode.jsonl",
+                rootPath: vscodeOtelFile
+            },
+            modelUsage,
+            dayUsage: buildDailyUsageRows(byDay),
+            primaryLimitWindows: [],
+            secondaryLimitWindows: [],
+            warnings
+        };
+    }
+}
+export async function configureCopilotVsCodeLogging(options = {}) {
+    const root = path.resolve(options.root ?? os.homedir());
+    const outfile = getCopilotOtelPath(root);
+    const settingsPath = options.settingsPath ?? (await getVsCodeSettingsPath(root));
+    const settingsText = await readTextFileOrEmpty(settingsPath);
+    const { text, changed } = updateJsoncSettings(settingsText, {
+        ...VSCODE_OTEL_SETTINGS,
+        "github.copilot.chat.otel.outfile": toVsCodeOutfilePath(outfile)
+    });
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outfile), { recursive: true });
+    if (changed) {
+        await fs.promises.writeFile(settingsPath, text, "utf8");
+    }
+    return { settingsPath, outfile, changed };
+}
+function getCopilotOtelPath(root) {
+    return path.join(root, ".copilot", "otel", "vscode.jsonl");
+}
+function toVsCodeOutfilePath(filePath) {
+    return process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+}
+async function getVsCodeSettingsPath(root) {
+    const userRoots = getVsCodeUserRoots(root);
+    for (const userRoot of userRoots) {
+        if (await isDirectory(userRoot)) {
+            return path.join(userRoot, "settings.json");
+        }
+    }
+    return path.join(userRoots[0], "settings.json");
+}
+function getVsCodeUserRoots(root) {
+    if (process.platform === "darwin") {
+        const applicationSupport = path.join(root, "Library", "Application Support");
+        return [
+            path.join(applicationSupport, "Code", "User"),
+            path.join(applicationSupport, "Code - Insiders", "User")
+        ];
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(root, "AppData", "Roaming");
+        return [path.join(appData, "Code", "User"), path.join(appData, "Code - Insiders", "User")];
+    }
+    const configRoot = path.join(root, ".config");
+    return [path.join(configRoot, "Code", "User"), path.join(configRoot, "Code - Insiders", "User")];
+}
+async function parseCopilotJsonlFile(filePath, byModel, byDay) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const parseTotals = {
+        linesRead: 0,
+        tokenEvents: 0,
+        malformedLines: 0
+    };
+    for await (const line of lineReader) {
+        parseTotals.linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(line);
+        }
+        catch {
+            parseTotals.malformedLines += 1;
+            continue;
+        }
+        const event = extractCopilotUsageEvent(payload);
+        if (event) {
+            parseTotals.tokenEvents += 1;
+            addModelUsage(byModel, event.modelId, event.totals);
+            addDailyUsage(byDay, event.timestampMs, event.modelId, undefined, event.totals);
+        }
+    }
+    return parseTotals;
+}
+function extractCopilotUsageEvent(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return null;
+    }
+    const attributes = asRecord(record.attributes);
+    if (!attributes || !isCopilotChatSpan(attributes)) {
+        return null;
+    }
+    const usage = usageFromAttributes(attributes);
+    if (!usage) {
+        return null;
+    }
+    const modelId = stringAttribute(attributes, "gen_ai.response.model") ?? "unknown";
+    const timestampMs = hrTimeToMs(record.hrTime) ?? Number.NaN;
+    return {
+        timestampMs,
+        modelId,
+        totals: createUsageTotals(modelId, usage)
+    };
+}
+function usageFromAttributes(attributes) {
+    const inputTokens = numberAttribute(attributes, "gen_ai.usage.input_tokens") ?? 0;
+    const outputTokens = numberAttribute(attributes, "gen_ai.usage.output_tokens") ?? 0;
+    const reasoningOutputTokens = numberAttribute(attributes, "gen_ai.usage.reasoning.output_tokens");
+    const cachedInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_read.input_tokens");
+    const cacheCreationInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_creation.input_tokens");
+    if (inputTokens <= 0 && outputTokens <= 0 && (reasoningOutputTokens ?? 0) <= 0) {
+        return null;
+    }
+    return {
+        inputTokens,
+        cachedInputTokens,
+        cacheCreationInputTokens,
+        outputTokens,
+        reasoningOutputTokens
+    };
+}
+function isCopilotChatSpan(attributes) {
+    return stringAttribute(attributes, "gen_ai.operation.name") === "chat";
+}
+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;
+    return {
+        inputTokens: usage.inputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens: hasCacheInfo ? Math.max(0, usage.inputTokens - cachedInputTokens) : 0,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: Math.min(usage.reasoningOutputTokens ?? 0, usage.outputTokens),
+        totalTokens: usage.inputTokens + usage.outputTokens,
+        estimatedCredits: creditsFor(modelId, usage),
+        eventCount: 1,
+        cacheStatus: hasCacheInfo ? "known" : "unavailable",
+        estimatedCreditsStatus: hasKnownCreditPricing ? "known" : "unavailable"
+    };
+}
+function creditsFor(modelId, usage) {
+    if (isNonBillableModel(modelId)) {
+        return 0;
+    }
+    const rate = rateForModel(modelId, usage.inputTokens);
+    if (!rate) {
+        return 0;
+    }
+    if (usage.cachedInputTokens === undefined && usage.cacheCreationInputTokens === undefined) {
+        return 0;
+    }
+    const cacheRead = Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens);
+    const cacheWrite = Math.min(usage.cacheCreationInputTokens ?? 0, Math.max(0, usage.inputTokens - cacheRead));
+    const regularInput = Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    return ((regularInput / 1000000) * rate.input +
+        (cacheRead / 1000000) * rate.cachedInput +
+        (cacheWrite / 1000000) * (rate.cacheWrite ?? rate.input) +
+        (usage.outputTokens / 1000000) * rate.output);
+}
+function rateForModel(modelId, inputTokens) {
+    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
+    const model = candidates.find((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
+    if (!model) {
+        return undefined;
+    }
+    const longContextRate = LONG_CONTEXT_RATE_CARD[model];
+    if (longContextRate && inputTokens > longContextRate.thresholdInputTokens) {
+        return longContextRate;
+    }
+    return RATE_CARD[model];
+}
+function isNonBillableModel(modelId) {
+    return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function numberAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    return undefined;
+}
+function stringAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "string" && value) {
+        return value;
+    }
+    return undefined;
+}
+function hrTimeToMs(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const [seconds, nanoseconds] = value;
+    if (typeof seconds !== "number" ||
+        !Number.isFinite(seconds) ||
+        typeof nanoseconds !== "number" ||
+        !Number.isFinite(nanoseconds)) {
+        return undefined;
+    }
+    return seconds * 1000 + nanoseconds / 1000000;
+}
+async function isReadableFile(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isCopilotVsCodeLoggingEnabled(root, outfile) {
+    const settings = await readJsonSettings(await getVsCodeSettingsPath(root));
+    const configuredOutfile = settings["github.copilot.chat.otel.outfile"];
+    return (settings["github.copilot.chat.otel.enabled"] === true &&
+        settings["github.copilot.chat.otel.exporterType"] === "file" &&
+        typeof configuredOutfile === "string" &&
+        normalizeComparablePath(configuredOutfile) === normalizeComparablePath(toVsCodeOutfilePath(outfile)));
+}
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath).replace(/\\/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+async function readJsonSettings(filePath) {
+    return parseJsoncSettings(await readTextFileOrEmpty(filePath));
+}
+async function readTextFileOrEmpty(filePath) {
+    try {
+        return await fs.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function parseJsoncSettings(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = parse(raw);
+    return asRecord(parsed) ?? {};
+}
+function updateJsoncSettings(raw, values) {
+    let text = raw.trim() ? raw : "{\n}";
+    let changed = false;
+    for (const [key, value] of Object.entries(values)) {
+        if (parseJsoncSettings(text)[key] === value) {
+            continue;
+        }
+        const edits = modify(text, [key], value, {
+            formattingOptions: {
+                eol: "\n",
+                insertSpaces: true,
+                tabSize: 4
+            }
+        });
+        if (edits.length > 0) {
+            text = applyEdits(text, edits);
+            changed = true;
+        }
+    }
+    if (changed && !text.endsWith("\n")) {
+        text += "\n";
+    }
+    return { text, changed };
+}

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

@@ -0,0 +1,64 @@
+import { addUsageTotals } from "./contract.js";
+export function createDailyUsageAggregates() {
+    return new Map();
+}
+export function addDailyUsage(rows, eventTimeMs, modelId, planType, deltaTotals) {
+    const { dayKey, sortTimeMs } = resolveDayBucket(eventTimeMs);
+    const resolvedModelId = modelId || "unknown";
+    const existing = rows.get(dayKey);
+    if (!existing) {
+        const models = new Set();
+        models.add(resolvedModelId);
+        const planTypes = new Set();
+        if (planType) {
+            planTypes.add(planType);
+        }
+        rows.set(dayKey, {
+            dayKey,
+            sortTimeMs,
+            firstEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            lastEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            totals: { ...deltaTotals },
+            models,
+            planTypes
+        });
+        return;
+    }
+    addUsageTotals(existing.totals, deltaTotals);
+    existing.models.add(resolvedModelId);
+    if (planType) {
+        existing.planTypes.add(planType);
+    }
+    if (Number.isFinite(eventTimeMs)) {
+        existing.sortTimeMs = Math.max(existing.sortTimeMs, sortTimeMs);
+        existing.firstEventMs =
+            existing.firstEventMs === null ? eventTimeMs : Math.min(existing.firstEventMs, eventTimeMs);
+        existing.lastEventMs =
+            existing.lastEventMs === null ? eventTimeMs : Math.max(existing.lastEventMs, eventTimeMs);
+    }
+}
+export function buildDailyUsageRows(rows) {
+    return [...rows.values()]
+        .sort((left, right) => right.sortTimeMs - left.sortTimeMs || right.dayKey.localeCompare(left.dayKey))
+        .map((row) => ({
+        dayKey: row.dayKey,
+        firstEventUtcIso: row.firstEventMs === null ? null : formatIsoFromMilliseconds(row.firstEventMs),
+        lastEventUtcIso: row.lastEventMs === null ? null : formatIsoFromMilliseconds(row.lastEventMs),
+        distinctModels: [...row.models].sort(),
+        distinctPlanTypes: [...row.planTypes].sort(),
+        totals: { ...row.totals }
+    }));
+}
+function resolveDayBucket(eventTimeMs) {
+    if (!Number.isFinite(eventTimeMs)) {
+        return { dayKey: "unknown", sortTimeMs: Number.NEGATIVE_INFINITY };
+    }
+    const dayKey = new Date(eventTimeMs).toISOString().slice(0, 10);
+    return {
+        dayKey,
+        sortTimeMs: Date.parse(`${dayKey}T00:00:00.000Z`)
+    };
+}
+function formatIsoFromMilliseconds(milliseconds) {
+    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
+}

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

@@ -1,8 +1,10 @@
 import { ClaudeUsageProvider } from "./claude.js";
 import { CodexUsageProvider } from "./codex.js";
+import { CopilotUsageProvider } from "./copilot.js";
 export function createProviders() {
-    return [new CodexUsageProvider(), new ClaudeUsageProvider()];
+    return [new CodexUsageProvider(), new ClaudeUsageProvider(), new CopilotUsageProvider()];
 }
 export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
+export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.js";
 export { UsageProviderBase } from "./contract.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
@@ -26,6 +26,7 @@
   ],
   "dependencies": {
     "ink": "4.4.1",
+    "jsonc-parser": "^3.3.1",
     "react": "18.3.1"
   },
   "devDependencies": {