letmecode 0.1.13 → 0.1.16

package/ink-app/dist/index.js

@@ -19,31 +19,9 @@ const DETAIL_TABS = [
     { id: "usage-by-model", label: "Models" }
 ];
 const CODEX_CREDIT_COST_USD = 0.01;
-const LIMIT_TABLE_COLUMNS = [
-    { header: "Plan", width: 5 },
-    { header: "Window", width: 6 },
-    { header: "Used", width: 8 },
-    { header: "Start", width: 14 },
-    { header: "End", width: 14 },
-    { header: "API eq.", width: 8 }
-];
-const DAILY_TABLE_COLUMNS = [
-    { header: "Day", width: 9 },
-    { header: "Ev", width: 5 },
-    { header: "Input", width: 8 },
-    { header: "Output", width: 7 },
-    { header: "C read", width: 8 },
-    { header: "C write", width: 7 },
-    { header: "API eq.", width: 7 }
-];
-const MODEL_TABLE_COLUMNS = [
-    { header: "Model", width: 16 },
-    { header: "Input", width: 7 },
-    { header: "Output", width: 7 },
-    { header: "C read", width: 7 },
-    { header: "C write", width: 7 },
-    { header: "API eq.", width: 7 }
-];
+const LIMIT_TABLE_HEADERS = ["Scope", "Plan", "Window", "Used", "Start", "End", "API eq."];
+const DAILY_TABLE_HEADERS = ["Day", "Ev", "Input", "Output", "C read", "C write", "API eq."];
+const MODEL_TABLE_HEADERS = ["Model", "Input", "Output", "C read", "C write", "API eq."];
 const COPILOT_ACTIONS = [
     { id: "vscode", label: "Start logging VS Code", enabled: true }
 ];
@@ -217,7 +195,7 @@ function App(props) {
             moveSelectedTableRow(-1);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: viewportHeight, overflow: "hidden", children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "gray", children: "Provider  " }), sortedProviderStates.map((state) => (_jsx(ProviderTab, { label: state.provider.label, active: state.provider.id === selectedProvider.provider.id, status: state.status, regionRef: getRegionRef(`provider:${state.provider.id}`) }, state.provider.id)))] }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "View      " }), DETAIL_TABS.map((tab, index) => (_jsx(DetailTab, { label: tab.label, active: index === selectedDetailTabIndex, regionRef: getRegionRef(`vtab:${index}`) }, tab.id)))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [_jsx(Box, { flexGrow: 1, overflow: "hidden", children: _jsx(Box, { ref: contentPanelRef, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedDetailTab.id, selectedLimitRowKey: selectedLimitRow ? getLimitRowKey(selectedLimitRow) : undefined, selectedDayKey: selectedDayRow?.dayKey, selectedModelId: selectedModelRow?.modelId, availableHeight: contentPanelHeight }) }) }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedDetailTab.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] }), _jsx(Text, { color: "gray", children: "Tab provider \u00B7 \u2190/\u2192 view \u00B7 \u2191/\u2193 row \u00B7 q quit" })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: viewportHeight, overflow: "hidden", children: [_jsx(Text, { bold: true, color: "cyan", children: "LetMeCode Usage Dashboard" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "gray", children: "Provider  " }), sortedProviderStates.map((state) => (_jsx(ProviderTab, { label: state.provider.label, active: state.provider.id === selectedProvider.provider.id, status: state.status, regionRef: getRegionRef(`provider:${state.provider.id}`) }, state.provider.id)))] }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "View      " }), DETAIL_TABS.map((tab, index) => (_jsx(DetailTab, { label: tab.label, active: index === selectedDetailTabIndex, regionRef: getRegionRef(`vtab:${index}`) }, tab.id)))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [_jsx(Box, { flexGrow: 1, overflow: "hidden", children: _jsx(Box, { ref: contentPanelRef, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedDetailTab.id, selectedLimitRowKey: selectedLimitRow ? getLimitRowKey(selectedLimitRow) : undefined, selectedDayKey: selectedDayRow?.dayKey, selectedModelId: selectedModelRow?.modelId, availableHeight: contentPanelHeight }) }) }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedDetailTab.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] }), _jsx(Text, { color: "gray", children: "Tab provider \u00B7 \u2190/\u2192 view \u00B7 \u2191/\u2193 row \u00B7 q quit" })] }));
 }
 function CopilotActionsPanel(props) {
     if (props.providerState.provider.id !== "copilot") {
@@ -290,27 +268,23 @@ function ContentPanel(props) {
     return (_jsx(UsageByModelPanel, { stats: props.providerState.stats, selectedModelId: props.selectedModelId, availableHeight: props.availableHeight }));
 }
 function LimitWindowsPanel(props) {
-    const bodyLines = [
-        ...buildLimitWindowTableLines("primary", "Primary limits", props.stats.primaryLimitWindows, props.selectedRowKey),
-        { key: "section-gap", text: "" },
-        ...buildLimitWindowTableLines("secondary", "Secondary limits", props.stats.secondaryLimitWindows, props.selectedRowKey)
-    ];
-    return (_jsx(ScrollableLineViewport, { bodyLines: bodyLines, availableHeight: props.availableHeight }));
+    const tableLines = buildLimitWindowTableLines(props.stats, props.selectedRowKey);
+    return (_jsx(ScrollableLineViewport, { ...tableLines, 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;
-    const bodyLines = buildModelUsageTableLines(props.stats.modelUsage, totals, props.selectedModelId);
-    return (_jsx(ScrollableLineViewport, { bodyLines: bodyLines, selectedBodyLineKey: props.selectedModelId ? `model-row:${props.selectedModelId}` : undefined, availableHeight: props.availableHeight }));
+    const tableLines = buildModelUsageTableLines(props.stats.modelUsage, totals, props.selectedModelId);
+    return (_jsx(ScrollableLineViewport, { ...tableLines, 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." });
     }
-    const bodyLines = buildDailyUsageTableLines(props.stats.dayUsage, props.selectedDayKey);
-    return (_jsx(ScrollableLineViewport, { bodyLines: bodyLines, selectedBodyLineKey: props.selectedDayKey ? `day-row:${props.selectedDayKey}` : undefined, availableHeight: props.availableHeight }));
+    const tableLines = buildDailyUsageTableLines(props.stats.dayUsage, props.selectedDayKey);
+    return (_jsx(ScrollableLineViewport, { ...tableLines, selectedBodyLineKey: props.selectedDayKey ? `day-row:${props.selectedDayKey}` : undefined, availableHeight: props.availableHeight }));
 }
 function ScrollableLineViewport(props) {
     const headerLines = props.headerLines ?? [];
@@ -330,147 +304,153 @@ function ScrollableLineViewport(props) {
 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 buildTableBorder(columns, left, middle, right) {
-    return `${left}${columns.map((column) => "─".repeat(column.width + 2)).join(middle)}${right}`;
+function createTextTable(headers, rows) {
+    return {
+        headers: [...headers],
+        widths: headers.map((header, index) => Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length)))
+    };
+}
+function buildTableBorder(table, left, middle, right) {
+    return `${left}${table.widths.map((width) => "─".repeat(width + 2)).join(middle)}${right}`;
 }
-function buildTableRow(columns, cells) {
-    return `│${columns.map((column, index) => ` ${pad(cells[index] ?? "", column.width)} `).join("│")}│`;
+function buildTableRow(table, cells) {
+    return `│${table.widths.map((width, index) => ` ${pad(cells[index] ?? "", width)} `).join("│")}│`;
 }
-function buildLimitWindowTableLines(scope, title, windows, selectedRowKey) {
-    if (windows.length === 0) {
-        return [
-            { key: `${scope}-title`, text: title, bold: true },
-            { key: `${scope}-empty`, text: "No windows found.", color: "gray" }
-        ];
+function buildTextTableLines(options) {
+    if (options.rows.length === 0 && !options.totalRow) {
+        return {
+            bodyLines: [
+                { key: `${options.lineKeyPrefix}-title`, text: options.title, bold: true },
+                { key: `${options.lineKeyPrefix}-empty`, text: "No rows found.", color: "gray" }
+            ]
+        };
     }
-    return [
-        { key: `${scope}-title`, text: title, bold: true },
+    const tableRows = options.totalRow
+        ? [...options.rows, options.totalRow]
+        : options.rows;
+    const table = createTextTable(options.headers, tableRows.map((row) => row.cells));
+    const headerLines = [
+        { key: `${options.lineKeyPrefix}-title`, text: options.title, bold: true },
         {
-            key: `${scope}-top-border`,
-            text: buildTableBorder(LIMIT_TABLE_COLUMNS, "┌", "┬", "┐"),
+            key: `${options.lineKeyPrefix}-top-border`,
+            text: buildTableBorder(table, "┌", "┬", "┐"),
             color: "gray"
         },
         {
-            key: `${scope}-header`,
-            text: buildTableRow(LIMIT_TABLE_COLUMNS, LIMIT_TABLE_COLUMNS.map((column) => column.header)),
+            key: `${options.lineKeyPrefix}-header`,
+            text: buildTableRow(table, table.headers),
             color: "gray"
         },
         {
-            key: `${scope}-header-border`,
-            text: buildTableBorder(LIMIT_TABLE_COLUMNS, "├", "┼", "┤"),
-            color: "gray"
-        },
-        ...windows.map((window) => {
-            const lineKey = getLimitRowKey(window);
-            const windowLabel = formatCompactWindowMinutes(window.windowMinutes);
-            const usedLabel = formatUsedPercentRange(window.minUsedPercent, window.maxUsedPercent);
-            const isSelected = selectedRowKey === lineKey;
-            return {
-                key: `limit-row:${lineKey}`,
-                text: buildTableRow(LIMIT_TABLE_COLUMNS, [
-                    window.planType,
-                    windowLabel,
-                    usedLabel,
-                    formatCompactLocalDateTime(window.startTimeUtcIso),
-                    formatCompactLocalDateTime(window.endTimeUtcIso),
-                    formatUsd(window.totals.estimatedCredits * CODEX_CREDIT_COST_USD)
-                ]),
-                inverse: isSelected,
-                color: isSelected ? "cyan" : undefined
-            };
-        }),
-        {
-            key: `${scope}-bottom-border`,
-            text: buildTableBorder(LIMIT_TABLE_COLUMNS, "└", "┴", "┘"),
+            key: `${options.lineKeyPrefix}-header-border`,
+            text: buildTableBorder(table, "├", "┼", "┤"),
             color: "gray"
         }
     ];
-}
-function buildDailyUsageTableLines(rows, selectedDayKey) {
-    return [
-        { key: "daily-title", text: "Daily usage", bold: true },
-        {
-            key: "daily-top-border",
-            text: buildTableBorder(DAILY_TABLE_COLUMNS, "┌", "┬", "┐"),
-            color: "gray"
-        },
-        {
-            key: "daily-header",
-            text: buildTableRow(DAILY_TABLE_COLUMNS, DAILY_TABLE_COLUMNS.map((column) => column.header)),
-            color: "gray"
-        },
-        {
-            key: "daily-header-border",
-            text: buildTableBorder(DAILY_TABLE_COLUMNS, "├", "┼", "┤"),
-            color: "gray"
-        },
-        ...rows.map((row) => {
-            const isSelected = selectedDayKey === row.dayKey;
-            return {
-                key: `day-row:${row.dayKey}`,
-                text: buildTableRow(DAILY_TABLE_COLUMNS, [
-                    formatUtcDay(row.dayKey),
-                    formatCompactTokenCount(row.totals.eventCount),
-                    formatCompactTokenCount(row.totals.inputTokens),
-                    formatCompactTokenCount(row.totals.outputTokens),
-                    formatCompactCacheTokens(row.totals, row.totals.cacheReadInputTokens),
-                    formatCompactCacheTokens(row.totals, row.totals.cacheWriteInputTokens),
-                    formatUsageUsd(row.totals)
-                ]),
+    const bodyLines = options.rows.flatMap((row) => {
+        const isSelected = options.selectedRowKey === row.key;
+        const lines = [{
+                key: row.key,
+                text: buildTableRow(table, row.cells),
                 inverse: isSelected,
                 color: isSelected ? "cyan" : undefined
-            };
-        }),
-        {
-            key: "daily-bottom-border",
-            text: buildTableBorder(DAILY_TABLE_COLUMNS, "└", "┴", "┘"),
-            color: "gray"
+            }];
+        if (options.separatorAfterRowKeys?.has(row.key)) {
+            lines.push({
+                key: `${row.key}-separator`,
+                text: buildTableBorder(table, "├", "┼", "┤"),
+                color: "gray"
+            });
         }
-    ];
+        return lines;
+    });
+    const footerLines = [];
+    if (options.totalRow) {
+        footerLines.push({
+            key: `${options.lineKeyPrefix}-total-border`,
+            text: buildTableBorder(table, "├", "┼", "┤"),
+            color: "gray"
+        }, {
+            key: options.totalRow.key,
+            text: buildTableRow(table, options.totalRow.cells),
+            color: "cyan"
+        });
+    }
+    footerLines.push({
+        key: `${options.lineKeyPrefix}-bottom-border`,
+        text: buildTableBorder(table, "└", "┴", "┘"),
+        color: "gray"
+    });
+    return {
+        headerLines,
+        bodyLines,
+        footerLines
+    };
+}
+function buildLimitWindowTableLines(stats, selectedRowKey) {
+    const primaryRows = stats.primaryLimitWindows.map((window) => buildLimitWindowTableRow(window));
+    const secondaryRows = stats.secondaryLimitWindows.map((window) => buildLimitWindowTableRow(window));
+    const separatorAfterRowKeys = primaryRows.length > 0 && secondaryRows.length > 0
+        ? new Set([primaryRows[primaryRows.length - 1].key])
+        : undefined;
+    return buildTextTableLines({
+        title: "Limits",
+        lineKeyPrefix: "limits",
+        headers: LIMIT_TABLE_HEADERS,
+        rows: [...primaryRows, ...secondaryRows],
+        selectedRowKey: selectedRowKey ? `limit-row:${selectedRowKey}` : undefined,
+        separatorAfterRowKeys
+    });
+}
+function buildLimitWindowTableRow(window) {
+    return {
+        key: `limit-row:${getLimitRowKey(window)}`,
+        cells: [
+            window.scope,
+            window.planType,
+            formatCompactWindowMinutes(window.windowMinutes),
+            formatUsedPercentRange(window.minUsedPercent, window.maxUsedPercent),
+            formatCompactLocalDateTime(window.startTimeUtcIso),
+            formatCompactLocalDateTime(window.endTimeUtcIso),
+            formatUsd(window.totals.estimatedCredits * CODEX_CREDIT_COST_USD)
+        ]
+    };
+}
+function buildDailyUsageTableLines(rows, selectedDayKey) {
+    return buildTextTableLines({
+        title: "Daily usage",
+        lineKeyPrefix: "daily",
+        headers: DAILY_TABLE_HEADERS,
+        rows: rows.map((row) => ({
+            key: `day-row:${row.dayKey}`,
+            cells: [
+                formatUtcDay(row.dayKey),
+                formatCompactTokenCount(row.totals.eventCount),
+                formatCompactTokenCount(row.totals.inputTokens),
+                formatCompactTokenCount(row.totals.outputTokens),
+                formatCompactCacheTokens(row.totals, row.totals.cacheReadInputTokens),
+                formatCompactCacheTokens(row.totals, row.totals.cacheWriteInputTokens),
+                formatUsageUsd(row.totals)
+            ]
+        })),
+        selectedRowKey: selectedDayKey ? `day-row:${selectedDayKey}` : undefined
+    });
 }
 function buildModelUsageTableLines(rows, totals, selectedModelId) {
-    return [
-        { key: "model-title", text: "Model usage", bold: true },
-        {
-            key: "model-top-border",
-            text: buildTableBorder(MODEL_TABLE_COLUMNS, "┌", "┬", "┐"),
-            color: "gray"
-        },
-        {
-            key: "model-header",
-            text: buildTableRow(MODEL_TABLE_COLUMNS, MODEL_TABLE_COLUMNS.map((column) => column.header)),
-            color: "gray"
-        },
-        {
-            key: "model-header-border",
-            text: buildTableBorder(MODEL_TABLE_COLUMNS, "├", "┼", "┤"),
-            color: "gray"
-        },
-        ...rows.map((row) => {
-            const isSelected = selectedModelId === row.modelId;
-            return {
-                key: `model-row:${row.modelId}`,
-                text: formatModelUsageTableRow(row.modelId, row.totals),
-                inverse: isSelected,
-                color: isSelected ? "cyan" : undefined
-            };
-        }),
-        {
-            key: "model-total-border",
-            text: buildTableBorder(MODEL_TABLE_COLUMNS, "├", "┼", "┤"),
-            color: "gray"
-        },
-        {
+    return buildTextTableLines({
+        title: "Model usage",
+        lineKeyPrefix: "model",
+        headers: MODEL_TABLE_HEADERS,
+        rows: rows.map((row) => ({
+            key: `model-row:${row.modelId}`,
+            cells: formatModelUsageTableCells(row.modelId, row.totals)
+        })),
+        selectedRowKey: selectedModelId ? `model-row:${selectedModelId}` : undefined,
+        totalRow: {
             key: "model-total",
-            text: formatModelUsageTableRow("TOTAL", totals),
-            color: "cyan"
-        },
-        {
-            key: "model-bottom-border",
-            text: buildTableBorder(MODEL_TABLE_COLUMNS, "└", "┴", "┘"),
-            color: "gray"
+            cells: formatModelUsageTableCells("TOTAL", totals)
         }
-    ];
+    });
 }
 function SelectionDetailsPanel(props) {
     if (props.providerState.status !== "ready") {
@@ -697,16 +677,16 @@ function formatEventRange(firstEventUtcIso, lastEventUtcIso) {
 function pad(value, length) {
     return value.length >= length ? value.slice(0, length) : value.padEnd(length);
 }
-function formatModelUsageTableRow(modelId, totals) {
+function formatModelUsageTableCells(modelId, totals) {
     const displayModelId = modelId === "unknown" ? "-" : modelId;
-    return buildTableRow(MODEL_TABLE_COLUMNS, [
+    return [
         displayModelId,
         formatCompactTokenCount(totals.inputTokens),
         formatCompactTokenCount(totals.outputTokens),
         formatCompactCacheTokens(totals, totals.cacheReadInputTokens),
         formatCompactCacheTokens(totals, totals.cacheWriteInputTokens),
         formatUsageUsd(totals, modelId)
-    ]);
+    ];
 }
 function UsageBreakdownLines(props) {
     const { totals } = props;

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

@@ -210,8 +210,8 @@ async function collectAntigravityQuotaFromLocalRpc() {
     return {
         entries: parseAntigravityQuotaEntries(quota),
         fetchedAt: Date.now(),
-        planType: status.userStatus.planStatus.planInfo.planName ?? "unknown",
-        userIdHash: createHash("md5").update(status.userStatus.email).digest("hex")
+        planType: parseAntigravityPlanType(status),
+        userIdHash: parseAntigravityUserIdHash(status)
     };
 }
 function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
@@ -384,6 +384,16 @@ export function parseAntigravityQuotaEntries(payload) {
         });
     });
 }
+export function parseAntigravityPlanType(payload) {
+    const planName = payload.response?.userStatus?.planStatus?.planInfo?.planName;
+    return typeof planName === "string" && planName ? planName : "unknown";
+}
+export function parseAntigravityUserIdHash(payload) {
+    const email = payload.response?.userStatus?.email;
+    return typeof email === "string" && email
+        ? createHash("md5").update(email).digest("hex")
+        : null;
+}
 function resolveQuotaGroupModelIds(text) {
     return (QUOTA_MODEL_GROUPS.find(({ pattern }) => pattern.test(text.toLowerCase()))?.models ?? []);
 }

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

@@ -125,7 +125,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             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.`);
+            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; merged same-key rows by per-field maxima to avoid double-counting cumulative snapshots.`);
         }
         if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
             warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} duplicate unkeyed Claude usage event(s) by usage signature.`);
@@ -455,6 +455,7 @@ async function parseSessionFile(filePath, sessionsRoot) {
             usageSignature,
             timestampMs: eventTimeMs,
             modelId,
+            usage: normalizedUsage,
             totals: usageToTotals(modelId, normalizedUsage),
             rateLimits
         });
@@ -565,8 +566,11 @@ function buildUsageEventKey(payloadObject, message) {
     return `${sessionId}|${requestId || messageId}`;
 }
 function buildUsageSignature(payloadObject, modelId, usage) {
+    return buildUsageSignatureFromParts(String(payloadObject.sessionId ?? ""), modelId, usage);
+}
+function buildUsageSignatureFromParts(sessionId, modelId, usage) {
     return [
-        String(payloadObject.sessionId ?? ""),
+        sessionId,
         modelId,
         usage.inputTokens,
         usage.cacheCreationInputTokens,
@@ -597,9 +601,7 @@ function recordParsedUsageEvent(parsedEvents, event) {
         if (previous.usageSignature !== event.usageSignature) {
             parsedEvents.duplicateUsageKeyCollisions += 1;
         }
-        if (shouldReplaceUsageEvent(previous, event)) {
-            parsedEvents.keyedEvents.set(event.usageKey, event);
-        }
+        parsedEvents.keyedEvents.set(event.usageKey, mergeParsedUsageEvents(previous, event));
         return;
     }
     const previous = parsedEvents.unkeyedEvents.get(event.usageSignature);
@@ -608,18 +610,57 @@ function recordParsedUsageEvent(parsedEvents, event) {
         return;
     }
     parsedEvents.duplicateUnkeyedEvents += 1;
-    if (shouldReplaceUsageEvent(previous, event)) {
+    if (normalizeTimestamp(event.timestampMs) > normalizeTimestamp(previous.timestampMs)) {
         parsedEvents.unkeyedEvents.set(event.usageSignature, event);
     }
 }
-function shouldReplaceUsageEvent(previous, next) {
-    if (next.totals.estimatedCredits > previous.totals.estimatedCredits) {
-        return true;
+function mergeParsedUsageEvents(previous, next) {
+    const mergedUsage = mergeClaudeUsage(previous.usage, next.usage);
+    const modelId = selectMergedEventModelId(previous, next);
+    const latestEvent = normalizeTimestamp(next.timestampMs) >= normalizeTimestamp(previous.timestampMs) ? next : previous;
+    const sessionId = extractUsageKeySessionId(previous.usageKey) || extractUsageKeySessionId(next.usageKey);
+    return {
+        entrypoint: latestEvent.entrypoint || previous.entrypoint || next.entrypoint,
+        usageKey: previous.usageKey ?? next.usageKey,
+        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, mergedUsage),
+        timestampMs: Math.max(normalizeTimestamp(previous.timestampMs), normalizeTimestamp(next.timestampMs)),
+        modelId,
+        usage: mergedUsage,
+        totals: usageToTotals(modelId, mergedUsage),
+        rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
+    };
+}
+function mergeClaudeUsage(previous, next) {
+    return {
+        inputTokens: Math.max(previous.inputTokens, next.inputTokens),
+        cacheReadInputTokens: Math.max(previous.cacheReadInputTokens, next.cacheReadInputTokens),
+        cacheCreationInputTokens: Math.max(previous.cacheCreationInputTokens, next.cacheCreationInputTokens),
+        cacheCreation5mInputTokens: Math.max(previous.cacheCreation5mInputTokens, next.cacheCreation5mInputTokens),
+        cacheCreation1hInputTokens: Math.max(previous.cacheCreation1hInputTokens, next.cacheCreation1hInputTokens),
+        outputTokens: Math.max(previous.outputTokens, next.outputTokens),
+        inferenceGeo: next.inferenceGeo || previous.inferenceGeo
+    };
+}
+function selectMergedEventModelId(previous, next) {
+    if (previous.modelId === next.modelId) {
+        return previous.modelId;
+    }
+    if (isInternalClaudeModel(previous.modelId) && !isInternalClaudeModel(next.modelId)) {
+        return next.modelId;
+    }
+    if (isInternalClaudeModel(next.modelId) && !isInternalClaudeModel(previous.modelId)) {
+        return previous.modelId;
     }
-    if (next.totals.estimatedCredits === previous.totals.estimatedCredits) {
-        return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs);
+    return next.totals.estimatedCredits >= previous.totals.estimatedCredits
+        ? next.modelId
+        : previous.modelId;
+}
+function extractUsageKeySessionId(usageKey) {
+    if (!usageKey) {
+        return "";
     }
-    return false;
+    const separatorIndex = usageKey.indexOf("|");
+    return separatorIndex >= 0 ? usageKey.slice(0, separatorIndex) : usageKey;
 }
 function normalizeTimestamp(value) {
     return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
@@ -696,7 +737,7 @@ async function buildLiveLimitWindows(options) {
     if (snapshots.length === 0) {
         traceClaude(options.traceLogger, "No live usage snapshots matched the expected /usage format.");
     }
-    const resolvedPlanType = subscriptionType || "live";
+    const resolvedPlanType = resolveClaudeLivePlanType(subscriptionType, snapshots);
     traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
@@ -707,14 +748,15 @@ async function buildLiveLimitWindows(options) {
     for (let index = 0; index < snapshots.length; index += 1) {
         const snapshot = snapshots[index];
         const row = snapshot.scope === "primary"
-            ? primaryLimitWindows.filter((window) => window.limitId === `current-${snapshot.label}`)[0]
-            : secondaryLimitWindows.filter((window) => window.limitId === `current-${snapshot.label}`)[0];
+            ? primaryLimitWindows.find((window) => window.limitId === snapshot.limitId)
+            : secondaryLimitWindows.find((window) => window.limitId === snapshot.limitId);
         if (!row) {
             continue;
         }
         traceClaude(options.traceLogger, [
             `Live window ${snapshot.scope}/${snapshot.label}:`,
             `used=${snapshot.usedPercent}%`,
+            `limit=${snapshot.limitId}`,
             `range=${row.startTimeUtcIso}->${row.endTimeUtcIso}`,
             `matchedEvents=${row.eventCount}`,
             `input=${row.totals.inputTokens}`,
@@ -728,6 +770,12 @@ async function buildLiveLimitWindows(options) {
         secondaryLimitWindows
     };
 }
+function resolveClaudeLivePlanType(subscriptionType, snapshots) {
+    if (snapshots.some((snapshot) => snapshot.modelScope === "sonnet-only")) {
+        return "team_premium";
+    }
+    return subscriptionType || "live";
+}
 async function readClaudeSubscriptionType(root, override, traceLogger) {
     const output = await readClaudeAuthStatusOutput(root, override, traceLogger);
     const subscriptionType = parseClaudeSubscriptionType(output);
@@ -992,26 +1040,32 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
     for (const line of normalizedOutput.split(/\r?\n/)) {
         const match = line
             .trim()
-            .match(/^Current\s+(session|week)(?:\s+\([^)]+\))?:\s+(\d+)%\s+used\b.*?\bresets\s+(.+)$/i);
+            .match(/^Current\s+(session|week)(?:\s+\(([^)]+)\))?:\s+(\d+)%\s+used\b.*?\bresets\s+(.+)$/i);
         if (!match) {
             continue;
         }
         const label = match[1].toLowerCase() === "session" ? "session" : "week";
-        const usedPercent = Number(match[2]);
+        const windowQualifier = (match[2] ?? "").trim().toLowerCase();
+        const usedPercent = Number(match[3]);
         const windowMinutes = label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES;
-        const resetsAtMs = parseResetTimestampUtc(match[3], now.getTime(), windowMinutes);
+        const resetsAtMs = parseResetTimestampUtc(match[4], now.getTime(), windowMinutes);
         if (!Number.isFinite(usedPercent) || !resetsAtMs) {
             continue;
         }
-        snapshots.set(label, {
+        const isSonnetOnlyWeek = label === "week" && windowQualifier === "sonnet only";
+        const limitId = isSonnetOnlyWeek ? "current-week-sonnet-only" : `current-${label}`;
+        snapshots.set(limitId, {
             scope: label === "session" ? "primary" : "secondary",
             label,
+            limitId,
+            modelScope: isSonnetOnlyWeek ? "sonnet-only" : "all-models",
+            modelType: isSonnetOnlyWeek ? "sonnet only" : undefined,
             usedPercent,
             resetsAtMs,
             windowMinutes
         });
     }
-    return [...snapshots.values()].sort((left, right) => left.windowMinutes - right.windowMinutes);
+    return [...snapshots.values()].sort((left, right) => left.windowMinutes - right.windowMinutes || left.limitId.localeCompare(right.limitId));
 }
 function parseResetTimestampUtc(value, nowMs, windowMinutes) {
     const match = value
@@ -1062,7 +1116,8 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
     const startTimeMs = snapshot.resetsAtMs - snapshot.windowMinutes * 60000;
     const inWindowEvents = selectedEvents.filter((event) => Number.isFinite(event.timestampMs) &&
         event.timestampMs >= startTimeMs &&
-        event.timestampMs < snapshot.resetsAtMs);
+        event.timestampMs < snapshot.resetsAtMs &&
+        matchesClaudeLiveSnapshotModelScope(snapshot, event.modelId));
     const totals = sumUsageTotals(inWindowEvents.map((event) => event.totals));
     const fallbackLastSeenMs = Math.min(now.getTime(), snapshot.resetsAtMs);
     const firstSeenMs = inWindowEvents.reduce((minimum, event) => Math.min(minimum, event.timestampMs), Number.POSITIVE_INFINITY);
@@ -1070,7 +1125,8 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
     return {
         scope: snapshot.scope,
         planType,
-        limitId: `current-${snapshot.label}`,
+        limitId: snapshot.limitId,
+        modelType: snapshot.modelType,
         windowMinutes: snapshot.windowMinutes,
         startTimeUtcIso: toUtcIso(startTimeMs),
         endTimeUtcIso: toUtcIso(snapshot.resetsAtMs),
@@ -1083,6 +1139,12 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         eventCount: totals.eventCount
     };
 }
+function matchesClaudeLiveSnapshotModelScope(snapshot, modelId) {
+    if (snapshot.modelScope !== "sonnet-only") {
+        return true;
+    }
+    return modelId.toLowerCase().includes("sonnet");
+}
 function buildModelUsageRowsForEvents(events) {
     const byModel = new Map();
     for (const event of events) {

package/ink-app/dist/reporting.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 const REPORTING_ENDPOINT = "https://devforth.io/admin/api/report_ussage_anonymous";
 const CREDIT_TO_DOLLARS = 0.01;
+const MIN_REPORTED_USED_PERCENTS = 1;
 let versionCache = null;
 export async function reportAnonymousUsage(statsList) {
     const payload = await buildAnonymousUsagePayload(statsList);
@@ -15,10 +16,12 @@ export async function reportAnonymousUsage(statsList) {
 export async function buildAnonymousUsageReports(statsList) {
     const letmecodeVersion = await readLetmecodeVersion();
     return statsList.flatMap((stats) => {
-        if (!stats.analytics?.userIdHash) {
+        if (!stats.analytics?.userIdHash || stats.providerId === "antigravity") {
             return [];
         }
-        return [...stats.primaryLimitWindows, ...stats.secondaryLimitWindows].map((window) => buildAnonymousUsageReport(stats, window, letmecodeVersion));
+        return [...stats.primaryLimitWindows, ...stats.secondaryLimitWindows]
+            .filter((window) => shouldReportUsageWindow(window))
+            .map((window) => buildAnonymousUsageReport(stats, window, letmecodeVersion));
     });
 }
 export async function buildAnonymousUsagePayload(statsList) {
@@ -46,6 +49,9 @@ function resolveReportModelType(stats, window) {
     if (stats.providerId === "antigravity") {
         return resolveAntigravityReportModelType(stats, window);
     }
+    if (window.modelType) {
+        return truncateSchemaString(window.modelType, 128);
+    }
     if (window.limitId && window.limitId !== "unknown") {
         return truncateSchemaString(window.limitId, 128);
     }
@@ -86,6 +92,9 @@ function resolveReportedUsedPercents(window) {
     }
     return clampPercent(window.maxUsedPercent - window.minUsedPercent);
 }
+function shouldReportUsageWindow(window) {
+    return resolveReportedUsedPercents(window) >= MIN_REPORTED_USED_PERCENTS;
+}
 function clampPercent(value) {
     if (!Number.isFinite(value)) {
         return 0;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "letmecode",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
+  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": {
     "letmecode": "./bin/letmecode.js"
@@ -20,6 +21,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",
@@ -35,14 +46,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"
   }
-}
+}