letmecode 0.1.28 → 0.1.30

package/README.md

@@ -1,8 +1,10 @@
 # LetMeCode
 
-Terminal AI real-money value usage dashboard for Codex, Claude, Copilot, and Antigravity.
+Terminal AI token-usage and API-equivalent value dashboard for Codex, Claude, Copilot, and Antigravity.
 
-See your real $ usage data, inspect limits, see daily activity, and model-level token totals in a terminal UI.
+Inspect provider limits, locally recorded token usage, daily activity, and model-level API-equivalent cost estimates in a terminal UI. Subscription quota percentages come from the providers; dollar values are estimates at public API rates, not subscription invoices.
+
+Only complete current-format usage events are counted. Incomplete legacy Codex and Claude events are silently ignored instead of being priced with guessed defaults.
 
 ## Quick start
 

package/ink-app/dist/index.js

@@ -4,7 +4,7 @@ import { Box, Text, measureElement, useApp, useInput, useStdin, useStdout, rende
 import { buildHelpText, buildProviderStatsOptions, parseCliOptions } from "./cli-options.js";
 import { configureCopilotVsCodeLogging, createProviders } from "./providers/index.js";
 import { reportAnonymousUsage } from "./reporting.js";
-import { estimateLimitFullValue, selectLatestActiveLimitWindows } from "./providers/limits.js";
+import { estimateLimitFullValue, resolveMeasuredUsedPercent, selectLatestActiveLimitWindows } from "./providers/limits.js";
 const ESC = String.fromCharCode(0x1b);
 // Normal mouse tracking (button press/release only) + SGR extended coordinates.
 // This makes the controls clickable while leaving Shift+drag native text selection
@@ -327,7 +327,7 @@ function SummaryPanel(props) {
     return (_jsxs(Box, { borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Summary" }), _jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: 45, children: [_jsx(DetailRow, { label: "Plan", value: summary.distinctPlanTypes.join(", ") || "none" }), _jsx(DetailRow, { label: "Models", value: summary.distinctModels.join(", ") || "none" }), _jsx(DetailRow, { label: "Period", value: period }), _jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: "Usage" }), _jsx(DetailRow, { label: "Events", value: formatInteger(totals.eventCount) }), _jsx(DetailRow, { label: "Input", value: formatOverviewTokenCount(totals.inputTokens) }), _jsx(DetailRow, { label: "Output", value: formatOverviewTokenCount(totals.outputTokens) }), _jsx(DetailRow, { label: "Cache read", value: formatCacheOverviewTokenCount(totals.cacheReadStatus, totals.cacheReadInputTokens) }), _jsx(DetailRow, { label: "Reasoning", value: formatOverviewTokenCount(totals.reasoningOutputTokens) }), _jsx(DetailRow, { label: "Total", value: formatOverviewTokenCount(totals.totalTokens) }), _jsx(DetailRow, { label: "API equiv.", value: formatUsageUsd(totals) })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Efficiency" }), _jsx(DetailRow, { label: "Cache ratio", value: formatPercent(cacheRatio) }), (() => {
                                 const { label, value } = formatInputOutputRatio(totals, props.stats.providerId);
                                 return _jsx(DetailRow, { label: label, value: value, padLength: Math.max(14, label.length + 1), noSlice: true });
-                            })(), _jsx(DetailRow, { label: "Avg/event", value: `${formatOverviewTokenCount(averageTokensPerEvent)} tokens` }), _jsx(DetailRow, { label: "Cost/event", value: formatUnitUsd(costPerEvent) }), _jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: "Data source" }), _jsx(DetailRow, { label: "Files", value: formatInteger(summary.filesScanned) }), _jsx(DetailRow, { label: "Lines", value: formatInteger(summary.linesRead) }), _jsx(DetailRow, { label: "Path", value: summary.rootPath })] })] })] }));
+                            })(), _jsx(DetailRow, { label: "Avg/event", value: `${formatOverviewTokenCount(averageTokensPerEvent)} tokens` }), _jsx(DetailRow, { label: "API eq/event", value: formatUnitUsd(costPerEvent) }), _jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: "Data source" }), _jsx(DetailRow, { label: "Files", value: formatInteger(summary.filesScanned) }), _jsx(DetailRow, { label: "Lines", value: formatInteger(summary.linesRead) }), _jsx(DetailRow, { label: "Path", value: summary.rootPath })] })] })] }));
 }
 function ContentPanel(props) {
     if (props.providerState.status === "loading") {
@@ -499,7 +499,7 @@ function buildLimitWindowTableRow(window, isActive) {
             formatUsageUsd(window.totals),
             // Extrapolated full value of the limit, rounded to a single figure here;
             // the details panel shows the unrounded ±1% range.
-            formatLimitFullValueCompact(window.totals, window.maxUsedPercent)
+            formatLimitFullValueCompact(window.totals, resolveMeasuredUsedPercent(window))
         ]
     };
 }
@@ -543,7 +543,7 @@ function SelectionDetailsPanel(props) {
     }
     if (props.viewId === "limit-windows" && props.selectedLimitRow) {
         const row = props.selectedLimitRow;
-        return (_jsxs(DetailsPanelFrame, { children: [_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: 25, children: [_jsx(DetailRow, { label: "Plan", value: row.planType }), _jsx(DetailRow, { label: "Models", value: formatLimitWindowModels(row) }), _jsx(DetailRow, { label: "Window", value: formatCompactWindowMinutes(row.windowMinutes) }), _jsx(DetailRow, { label: "Usage", value: formatUsedPercentRange(row.minUsedPercent, row.maxUsedPercent) }), _jsx(DetailRow, { label: "Events", value: formatInteger(row.eventCount) })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailRow, { label: "Period", value: `${formatCompactLocalDateTime(row.startTimeUtcIso)} → ${formatCompactLocalDateTime(row.endTimeUtcIso)}` }), _jsx(DetailRow, { label: "Input", value: formatInteger(row.totals.inputTokens) }), _jsx(DetailRow, { label: "Cache read", value: formatCacheTokens(row.totals.cacheReadStatus, row.totals.cacheReadInputTokens) }), _jsx(DetailRow, { label: "Cache write", value: formatCacheTokens(row.totals.cacheWriteStatus, row.totals.cacheWriteInputTokens) }), _jsx(DetailRow, { label: "Output", value: formatInteger(row.totals.outputTokens) }), _jsx(DetailRow, { label: "Total", value: formatInteger(row.totals.totalTokens) })] })] }), _jsx(DetailRow, { label: "API eq.", value: formatUsageUsd(row.totals), note: "API equivalent cost" }), _jsx(DetailRow, { label: "Full value", value: formatLimitFullValueRange(row.totals, row.maxUsedPercent), note: "API equivalent cost if 100% will be used" })] }));
+        return (_jsxs(DetailsPanelFrame, { children: [_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: 25, children: [_jsx(DetailRow, { label: "Plan", value: row.planType }), _jsx(DetailRow, { label: "Models", value: formatLimitWindowModels(row) }), _jsx(DetailRow, { label: "Window", value: formatCompactWindowMinutes(row.windowMinutes) }), _jsx(DetailRow, { label: "Usage", value: formatUsedPercentRange(row.minUsedPercent, row.maxUsedPercent) }), _jsx(DetailRow, { label: "Measured", value: formatMeasuredUsedPercent(row) }), _jsx(DetailRow, { label: "Events", value: formatInteger(row.eventCount) })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailRow, { label: "Period", value: `${formatCompactLocalDateTime(row.startTimeUtcIso)} → ${formatCompactLocalDateTime(row.endTimeUtcIso)}` }), _jsx(DetailRow, { label: "Input", value: formatInteger(row.totals.inputTokens) }), _jsx(DetailRow, { label: "Cache read", value: formatCacheTokens(row.totals.cacheReadStatus, row.totals.cacheReadInputTokens) }), _jsx(DetailRow, { label: "Cache write", value: formatCacheTokens(row.totals.cacheWriteStatus, row.totals.cacheWriteInputTokens) }), _jsx(DetailRow, { label: "Output", value: formatInteger(row.totals.outputTokens) }), _jsx(DetailRow, { label: "Total", value: formatInteger(row.totals.totalTokens) })] })] }), _jsx(DetailRow, { label: "API eq.", value: formatUsageUsd(row.totals), note: "API equivalent cost" }), _jsx(DetailRow, { label: "Full value", value: formatLimitFullValueRange(row.totals, resolveMeasuredUsedPercent(row)), note: "API equivalent cost extrapolated from the paired token/usage interval" })] }));
     }
     if (props.viewId === "day-to-day-analyses" && props.selectedDayRow) {
         const row = props.selectedDayRow;
@@ -621,7 +621,7 @@ function formatUsageUsd(totals, modelId) {
         : formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD);
 }
 function isInternalUsageModel(modelId) {
-    return modelId === "codex-auto-review" || modelId === "<synthetic>";
+    return modelId === "<synthetic>";
 }
 function formatUsd(value) {
     const roundedUpValue = value > 0 ? Math.ceil(value * 100) / 100 : value;
@@ -641,11 +641,10 @@ function formatUsdWhole(value) {
     });
 }
 // Extrapolate the limit's full USD value from the observed API-equivalent cost
-// and how much of the limit it represents. Uses the highest reported percent
-// (the latest cumulative usage) and returns "-" when the cost is unknown or the
-// percent is missing.
+// and how much of the limit it represents. The percentage must cover the same
+// paired interval as the token totals; returns "-" when either value is unknown.
 function limitFullValueUsd(totals, usedPercent) {
-    if (totals.estimatedCreditsStatus === "unavailable") {
+    if (totals.estimatedCreditsStatus === "unavailable" || usedPercent === null) {
         return null;
     }
     const usedUsd = totals.estimatedCredits * CODEX_CREDIT_COST_USD;
@@ -727,6 +726,10 @@ function formatUsedPercentRange(minUsedPercent, maxUsedPercent) {
         ? fmt(minUsedPercent)
         : `${fmt(minUsedPercent)}–${fmt(maxUsedPercent)}`;
 }
+function formatMeasuredUsedPercent(window) {
+    const measuredUsedPercent = resolveMeasuredUsedPercent(window);
+    return measuredUsedPercent === null ? "-" : formatPercent(measuredUsedPercent);
+}
 function formatCompactWindowMinutes(value) {
     const hours = value / 60;
     if (hours >= 24) {

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

@@ -20,7 +20,19 @@ const MODEL_IDS = {
     "claude-opus-4-6-20251201": "claude-opus-4-6"
 };
 export function normalizeAntigravityModelId(modelId) {
-    return MODEL_IDS[modelId] ?? (modelId || "unknown");
+    const exactModelId = MODEL_IDS[modelId];
+    if (exactModelId) {
+        return exactModelId;
+    }
+    const currentGeminiModel = [
+        "gemini-3.8-flash",
+        "gemini-3.7-flash",
+        "gemini-3.6-flash",
+        "gemini-3.1-pro"
+    ].find((candidate) => modelId === candidate ||
+        modelId === `${candidate}-preview` ||
+        ["low", "medium", "high"].some((level) => modelId === `${candidate}-${level}`));
+    return currentGeminiModel ?? (modelId || "unknown");
 }
 export function antigravityModelScope(rawModelId) {
     const modelId = normalizeAntigravityModelId(rawModelId);

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

@@ -1,68 +1,12 @@
 import { createHash } from "node:crypto";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "../contract.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "../daily.js";
-import { resolveUsageRate } from "../pricing.js";
+import { fetchModelPricing, modelCostCredits } from "../pricing.js";
 import { modelScopeLabel, modelScopeMatches, normalizeAntigravityModelId } from "./models.js";
 import { parseAntigravityQuotaEntries } from "./quota-parser.js";
 import { findAntigravityLocalServer } from "./rpc/discovery.js";
 import { extractQuotaGroups, fetchAntigravityUserStatus } from "./rpc/quota.js";
 import { collectUsageFromLocalRpc } from "./usage-parse.js";
-const RATE_CARD = {
-    "gemini-3.5-flash": {
-        input: 150,
-        cacheRead: 15,
-        cacheWrite: 150,
-        cacheWrite5m: 150,
-        cacheWrite1h: 150,
-        output: 900
-    },
-    "gemini-3.1-pro": {
-        input: 200,
-        cacheRead: 20,
-        cacheWrite: 200,
-        cacheWrite5m: 200,
-        cacheWrite1h: 200,
-        output: 1200,
-        longContext: {
-            thresholdTokens: 200000,
-            rate: {
-                input: 400,
-                cacheRead: 40,
-                cacheWrite: 400,
-                cacheWrite5m: 400,
-                cacheWrite1h: 400,
-                output: 1800
-            }
-        }
-    },
-    "gemini-3-flash": {
-        input: 50,
-        cacheRead: 5,
-        cacheWrite: 50,
-        cacheWrite5m: 50,
-        cacheWrite1h: 50,
-        output: 300
-    },
-    "claude-sonnet-4-6": {
-        input: 300,
-        cacheRead: 30,
-        cacheWrite: 375,
-        cacheWrite5m: 375,
-        cacheWrite1h: 600,
-        output: 1500
-    },
-    "claude-opus-4-6": {
-        input: 500,
-        cacheRead: 50,
-        cacheWrite: 625,
-        cacheWrite5m: 625,
-        cacheWrite1h: 1000,
-        output: 2500
-    }
-};
-const UNPRICED_MODELS = new Set([
-    "gpt-oss-120b"
-]);
 export class AntigravityUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("antigravity", "Antigravity");
@@ -104,11 +48,18 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         if (duplicateEvents > 0) {
             warnings.push(`Collapsed ${duplicateEvents} duplicate Antigravity usage response(s).`);
         }
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(selectedRecords.map((record) => normalizeAntigravityModelId(record.modelId)), "antigravity");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         for (const record of selectedRecords) {
             const modelId = normalizeAntigravityModelId(record.modelId);
-            const totals = usageRecordToTotals(modelId, record);
+            const totals = usageRecordToTotals(modelId, record, pricing);
             addModelUsage(byModel, modelId, totals);
             addDailyUsage(byDay, record.timestamp, modelId, undefined, totals);
         }
@@ -120,12 +71,12 @@ export class AntigravityUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits -
             left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
-            .filter((row) => !rateForModel(row.modelId, rowInputTokens(row)) && !UNPRICED_MODELS.has(row.modelId))
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
             .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No Antigravity estimated API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No complete Antigravity API-equivalent pricing returned for: ${unknownPricedModels.join(", ")}.`);
         }
-        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, quotaSnapshot.planType, selectedRecords, quotaSnapshot.fetchedAt)) ?? [];
+        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, quotaSnapshot.planType, selectedRecords, quotaSnapshot.fetchedAt, pricing)) ?? [];
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -177,7 +128,7 @@ async function collectQuotaFromConnection(connect) {
             : null
     };
 }
-function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
+function buildAntigravityLimitWindow(quota, planType, records, fetchedAt, pricing) {
     const startAt = quota.resetAt - quota.windowMinutes * 60000;
     const byModel = new Map();
     const matchingTimestamps = [];
@@ -189,7 +140,7 @@ function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
             continue;
         }
         matchingTimestamps.push(record.timestamp);
-        addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record));
+        addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record, pricing));
     }
     const modelUsage = [...byModel.entries()]
         .map(([modelId, totals]) => ({
@@ -250,7 +201,8 @@ function deduplicateRecords(records) {
 function recordTokenTotal(record) {
     return record.input + record.cacheRead + record.cacheWrite + record.output;
 }
-function usageRecordToTotals(modelId, record) {
+function usageRecordToTotals(modelId, record, pricing) {
+    const estimatedCredits = creditsFor(modelId, record, pricing);
     return {
         inputTokens: record.input,
         outputTokens: record.output,
@@ -263,7 +215,7 @@ function usageRecordToTotals(modelId, record) {
             record.cacheRead +
             record.cacheWrite +
             record.output,
-        estimatedCredits: creditsFor(modelId, record),
+        estimatedCredits: estimatedCredits ?? 0,
         eventCount: 1,
         // The local RPC reports cache reads but never cache writes, so a zero cache
         // write is genuinely unknown (not a confirmed zero) and is surfaced as "-".
@@ -271,26 +223,17 @@ function usageRecordToTotals(modelId, record) {
         // which case it is both billed (see creditsFor) and shown as known.
         cacheReadStatus: "known",
         cacheWriteStatus: record.cacheWrite > 0 ? "known" : "unavailable",
-        estimatedCreditsStatus: rateForModel(modelId, record.input)
-            ? "known"
-            : "unavailable"
+        estimatedCreditsStatus: estimatedCredits === undefined ? "unavailable" : "known"
     };
 }
-function creditsFor(modelId, record) {
-    const rate = rateForModel(modelId, record.input);
-    if (!rate) {
-        return 0;
-    }
-    return ((record.input / 1000000) * rate.input +
-        (record.cacheRead / 1000000) * rate.cacheRead +
-        (record.cacheWrite / 1000000) * rate.cacheWrite +
-        (record.output / 1000000) * rate.output);
-}
-function rateForModel(modelId, inputTokens) {
-    return resolveUsageRate(RATE_CARD, modelId, inputTokens);
-}
-function rowInputTokens(row) {
-    return row.totals.inputTokens + row.totals.cacheReadInputTokens + row.totals.cacheWriteInputTokens;
+function creditsFor(modelId, record, pricing) {
+    return modelCostCredits(pricing.get(modelId), {
+        inputTokens: record.input,
+        outputTokens: record.output,
+        cacheReadInputTokens: record.cacheRead,
+        cacheWrite5mInputTokens: record.cacheWrite,
+        cacheWrite1hInputTokens: 0
+    });
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const totals = byModel.get(modelId) ?? createEmptyUsageTotals();

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

@@ -8,37 +8,21 @@ import { promisify } from "node:util";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
-import { resolveUsageRate } from "./pricing.js";
-const RATE_CARD = {
-    "claude-fable-5": { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
-    "claude-opus-4-8": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-7": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-6": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-1": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
-    "claude-opus-4": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
-    "claude-opus-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-sonnet-5": {
-        input: 3,
-        cacheRead: 0.3,
-        cacheWrite: 3.75,
-        cacheWrite5m: 3.75,
-        cacheWrite1h: 6,
-        output: 15,
-        // Intro pricing (~0.66x) through 2026-08-31; reverts to the standard rate above on 2026-09-01.
-        introOffer: {
-            effectiveUntilMs: Date.UTC(2026, 8, 1),
-            rate: { input: 2, cacheRead: 0.2, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 4, output: 10 }
-        }
-    },
-    "claude-sonnet-4-6": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-sonnet-4-5": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-sonnet-4": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-haiku-4-5": { input: 1, cacheRead: 0.1, cacheWrite: 1.25, cacheWrite5m: 1.25, cacheWrite1h: 2, output: 5 },
-    "claude-haiku-3-5": { input: 0.8, cacheRead: 0.08, cacheWrite: 1, cacheWrite5m: 1, cacheWrite1h: 1.6, output: 4 }
-};
+import { fetchModelPricing, modelCostCredits } from "./pricing.js";
+/*
+Previous local prices in USD per 1M tokens, kept temporarily as requested:
+claude-fable-5-1 and claude-mythos-5-1 10 / 0.25 / 12.5 / 20 / 50
+claude-fable-5 and claude-mythos-5 10 / 1 / 12.5 / 20 / 50
+claude-opus-5, 4-8, 4-7, 4-6, 4-5 5 / 0.5 / 6.25 / 10 / 25
+claude-opus-4-1 and 4 15 / 1.5 / 18.75 / 30 / 75
+claude-sonnet-5 2 / 0.2 / 2.5 / 4 / 10
+claude-sonnet-4-6, 4-5, 4 3 / 0.3 / 3.75 / 6 / 15
+claude-haiku-4-5 1 / 0.1 / 1.25 / 2 / 5
+claude-haiku-3-5 0.8 / 0.08 / 1 / 1.6 / 4
+Columns: input / cache read / cache write 5m / cache write 1h / output.
+*/
 const execFileAsync = promisify(execFile);
-const USD_TO_CREDITS = 100;
+const EMPTY_MODEL_PRICING = new Map();
 const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
 const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
 const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
@@ -113,20 +97,28 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             }
         }
         const selectedEvents = [
-            ...new Set(parsedEvents.keyedEvents.values()),
-            ...parsedEvents.unkeyedEvents
+            ...new Set(parsedEvents.keyedEvents.values())
         ];
         traceClaude(options.traceLogger, [
             `Transcript selection summary: filesWithMatches=${parseTotals.filesScanned}/${parsedSessionFiles.length}`,
             `selectedEvents=${selectedEvents.length}`,
             `duplicateUsageKeys=${parsedEvents.duplicateUsageKeys}`,
-            `duplicateUsageKeyCollisions=${parsedEvents.duplicateUsageKeyCollisions}`,
-            `duplicateUnkeyedEvents=${parsedEvents.duplicateUnkeyedEvents}`
+            `duplicateUsageKeyCollisions=${parsedEvents.duplicateUsageKeyCollisions}`
         ].join(" "));
         if (selectedEvents.length === 0 && parsedSessionFiles.length > 0) {
             traceClaude(options.traceLogger, "No assistant usage events were found in the parsed Claude session files.");
         }
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(selectedEvents
+                .map((event) => event.modelId)
+                .filter((modelId) => !isInternalClaudeModel(modelId)), "claude_code");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
         for (const event of selectedEvents) {
+            event.totals = usageToTotals(event.modelId, event.usage, event.timestampMs, pricing);
             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;
@@ -143,17 +135,14 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
             warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; kept the most complete same-key snapshot to avoid double-counting cumulative snapshots.`);
         }
-        if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
-            warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} adjacent 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);
         const unknownPricedModels = modelUsage
-            .map((row) => row.modelId)
-            .filter((modelId) => !resolveRate(modelId) && !isInternalClaudeModel(modelId));
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
+            .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No complete API-equivalent pricing returned for: ${unknownPricedModels.join(", ")}.`);
         }
         if (parsedSessionFiles.length === 0) {
             warnings.push(`No Claude session files found under ${sessionsRoot}.`);
@@ -216,46 +205,53 @@ export class ClaudeUsageProvider extends UsageProviderBase {
 function normalizeUsage(value) {
     const usage = asRecord(value) ?? {};
     const cacheCreation = asRecord(usage.cache_creation);
+    const serverToolUse = asRecord(usage.server_tool_use);
     const cacheCreation5mInputTokens = numberOrZero(cacheCreation?.ephemeral_5m_input_tokens);
     const cacheCreation1hInputTokens = numberOrZero(cacheCreation?.ephemeral_1h_input_tokens);
-    const cacheCreationInputTokens = Math.max(numberOrZero(usage.cache_creation_input_tokens), cacheCreation5mInputTokens + cacheCreation1hInputTokens);
     return {
         inputTokens: numberOrZero(usage.input_tokens),
         cacheReadInputTokens: numberOrZero(usage.cache_read_input_tokens),
-        cacheCreationInputTokens,
         cacheCreation5mInputTokens,
         cacheCreation1hInputTokens,
         outputTokens: numberOrZero(usage.output_tokens),
-        inferenceGeo: String(usage.inference_geo ?? "")
+        inferenceGeo: String(usage.inference_geo ?? ""),
+        speed: String(usage.speed ?? ""),
+        webSearchRequests: numberOrZero(serverToolUse?.web_search_requests)
     };
 }
-function resolveRate(modelId, timestampMs) {
-    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true, timestampMs });
-}
 function isInternalClaudeModel(modelId) {
     return modelId === "<synthetic>";
 }
-function creditsFor(modelId, usage, timestampMs) {
-    const rate = resolveRate(modelId, timestampMs);
-    if (!rate) {
-        return 0;
-    }
+function creditsFor(modelId, usage, pricing) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     // The US inference surcharge must match regardless of the casing the source
     // reports (e.g. "us", "US"), so compare case-insensitively.
     const inferenceMultiplier = usage.inferenceGeo.trim().toLowerCase() === "us" ? 1.1 : 1;
-    return (((usage.inputTokens / 1000000) * rate.input +
-        (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
-        (cacheWriteBreakdown.cacheWrite5mInputTokens / 1000000) * rate.cacheWrite5m +
-        (cacheWriteBreakdown.cacheWrite1hInputTokens / 1000000) * rate.cacheWrite1h +
-        (usage.outputTokens / 1000000) * rate.output) *
-        inferenceMultiplier *
-        USD_TO_CREDITS);
+    const speedMultiplier = usage.speed.trim().toLowerCase() === "fast" && isClaudeFastPricedModel(modelId)
+        ? 2
+        : 1;
+    const tokenCostCredits = modelCostCredits(pricing.get(modelId), {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens,
+        cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
+        cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens
+    });
+    if (tokenCostCredits === undefined) {
+        return undefined;
+    }
+    return (tokenCostCredits * speedMultiplier * inferenceMultiplier +
+        usage.webSearchRequests);
+}
+function isClaudeFastPricedModel(modelId) {
+    return ["claude-opus-5", "claude-opus-4-8"].some((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
 }
-function usageToTotals(modelId, usage, timestampMs) {
+function usageToTotals(modelId, usage, _timestampMs, pricing = EMPTY_MODEL_PRICING) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
         cacheWriteBreakdown.cacheWrite1hInputTokens;
+    const estimatedCredits = creditsFor(modelId, usage, pricing);
+    const rateKnown = estimatedCredits !== undefined || isInternalClaudeModel(modelId);
     return {
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
@@ -268,8 +264,9 @@ function usageToTotals(modelId, usage, timestampMs) {
             usage.cacheReadInputTokens +
             cacheWriteInputTokens +
             usage.outputTokens,
-        estimatedCredits: creditsFor(modelId, usage, timestampMs),
-        eventCount: 1
+        estimatedCredits: estimatedCredits ?? 0,
+        eventCount: 1,
+        estimatedCreditsStatus: rateKnown ? "known" : "unavailable"
     };
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
@@ -279,10 +276,8 @@ function addModelUsage(byModel, modelId, deltaTotals) {
     byModel.set(resolvedModelId, totals);
 }
 function resolveClaudeCacheWriteBreakdown(usage) {
-    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
-    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
     return {
-        cacheWrite5mInputTokens: usage.cacheCreation5mInputTokens + cacheWriteFallbackTokens,
+        cacheWrite5mInputTokens: usage.cacheCreation5mInputTokens,
         cacheWrite1hInputTokens: usage.cacheCreation1hInputTokens
     };
 }
@@ -437,7 +432,7 @@ async function parseSessionFile(filePath) {
         }
         const message = asRecord(payloadObject.message);
         const usage = asRecord(message?.usage);
-        if (!usage) {
+        if (!usage || !isCurrentClaudeUsageEvent(payloadObject, message, usage)) {
             continue;
         }
         const modelId = String(message?.model ?? "unknown");
@@ -467,6 +462,21 @@ async function parseSessionFile(filePath) {
         events
     };
 }
+function isCurrentClaudeUsageEvent(payloadObject, message, usage) {
+    return (typeof payloadObject.version === "string" &&
+        payloadObject.version.length > 0 &&
+        typeof payloadObject.sessionId === "string" &&
+        payloadObject.sessionId.length > 0 &&
+        typeof payloadObject.requestId === "string" &&
+        payloadObject.requestId.length > 0 &&
+        typeof message?.id === "string" &&
+        message.id.length > 0 &&
+        typeof usage.service_tier === "string" &&
+        typeof usage.speed === "string" &&
+        typeof usage.inference_geo === "string" &&
+        asRecord(usage.cache_creation) !== null &&
+        asRecord(usage.server_tool_use) !== null);
+}
 function buildUsageEventKeys(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
     const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
@@ -484,22 +494,20 @@ function buildUsageSignatureFromParts(sessionId, modelId, usage) {
         sessionId,
         modelId,
         usage.inputTokens,
-        usage.cacheCreationInputTokens,
         usage.cacheCreation5mInputTokens,
         usage.cacheCreation1hInputTokens,
         usage.cacheReadInputTokens,
         usage.outputTokens,
-        usage.inferenceGeo
+        usage.inferenceGeo,
+        usage.speed,
+        usage.webSearchRequests
     ].join("|");
 }
 function createParsedUsageEventAccumulator() {
     return {
         keyedEvents: new Map(),
-        unkeyedEvents: [],
-        lastUnkeyedEventsBySignature: new Map(),
         duplicateUsageKeys: 0,
-        duplicateUsageKeyCollisions: 0,
-        duplicateUnkeyedEvents: 0
+        duplicateUsageKeyCollisions: 0
     };
 }
 function recordParsedUsageEvent(parsedEvents, event) {
@@ -527,23 +535,6 @@ function recordParsedUsageEvent(parsedEvents, event) {
         }
         return;
     }
-    const previousRecord = parsedEvents.lastUnkeyedEventsBySignature.get(event.usageSignature);
-    if (!previousRecord || !canCollapseAdjacentUnkeyedUsageEvents(previousRecord.event, event)) {
-        parsedEvents.unkeyedEvents.push(event);
-        parsedEvents.lastUnkeyedEventsBySignature.set(event.usageSignature, {
-            event,
-            index: parsedEvents.unkeyedEvents.length - 1
-        });
-        return;
-    }
-    parsedEvents.duplicateUnkeyedEvents += 1;
-    if (normalizeTimestamp(event.timestampMs) > normalizeTimestamp(previousRecord.event.timestampMs)) {
-        parsedEvents.unkeyedEvents[previousRecord.index] = event;
-        parsedEvents.lastUnkeyedEventsBySignature.set(event.usageSignature, {
-            event,
-            index: previousRecord.index
-        });
-    }
 }
 function mergeParsedUsageEvents(previous, next) {
     // Same-key events are repeated/streamed snapshots of one logical request. Rather than
@@ -595,9 +586,6 @@ function selectMergedEventModelId(primary, other) {
     }
     return primary.modelId;
 }
-function canCollapseAdjacentUnkeyedUsageEvents(previous, next) {
-    return previous.filePath === next.filePath && next.lineNumber === previous.lineNumber + 1;
-}
 function extractUsageKeySessionId(usageKeys) {
     const usageKey = usageKeys[0];
     if (!usageKey) {
@@ -1069,6 +1057,19 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
             resetMsByLabel.set(parsed.label, resetsAtMs);
         }
     }
+    // Claude omits reset timestamps while an entire bucket is displayed as 0%.
+    // Keep that authoritative zero instead of silently dropping the window. The
+    // provisional range starts at the sample time, so no earlier transcript
+    // events are falsely paired with the zero-percent measurement.
+    for (const label of ["session", "week"]) {
+        const sameLabelLines = parsedLines.filter((parsed) => parsed.label === label);
+        if (!resetMsByLabel.has(label) &&
+            sameLabelLines.length > 0 &&
+            sameLabelLines.every((parsed) => parsed.usedPercent === 0)) {
+            const windowMinutes = label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES;
+            resetMsByLabel.set(label, now.getTime() + windowMinutes * 60000);
+        }
+    }
     const snapshots = new Map();
     for (const parsed of parsedLines) {
         const resetsAtMs = resetMsByLabel.get(parsed.label) ?? null;
@@ -1163,6 +1164,9 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         lastSeenUtcIso: toUtcIso(Number.isFinite(lastSeenMs) ? lastSeenMs : fallbackLastSeenMs),
         minUsedPercent: snapshot.usedPercent,
         maxUsedPercent: snapshot.usedPercent,
+        measuredUsedPercent: snapshot.usedPercent > 0 && totals.eventCount === 0
+            ? null
+            : snapshot.usedPercent,
         totals,
         modelUsage: buildModelUsageRowsForEvents(inWindowEvents),
         eventCount: totals.eventCount