letmecode 0.1.28 → 0.1.29

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/claude.js

@@ -9,28 +9,19 @@ import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTota
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { resolveUsageRate } from "./pricing.js";
+// Source: https://platform.claude.com/docs/en/about-claude/pricing
+// (checked 2026-09-05).
 const RATE_CARD = {
+    "claude-fable-5-1": { input: 10, cacheRead: 0.25, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
     "claude-fable-5": { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
+    "claude-opus-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
     "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-5": { 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 },
@@ -113,15 +104,13 @@ 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.");
@@ -143,9 +132,6 @@ 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);
@@ -153,7 +139,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             .map((row) => row.modelId)
             .filter((modelId) => !resolveRate(modelId) && !isInternalClaudeModel(modelId));
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
         if (parsedSessionFiles.length === 0) {
             warnings.push(`No Claude session files found under ${sessionsRoot}.`);
@@ -216,17 +202,18 @@ 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) {
@@ -244,18 +231,25 @@ function creditsFor(modelId, usage, timestampMs) {
     // 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 +
+    const speedMultiplier = usage.speed.trim().toLowerCase() === "fast" && isClaudeFastPricedModel(modelId)
+        ? 2
+        : 1;
+    const tokenCostUsd = (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);
+        (usage.outputTokens / 1000000) * rate.output;
+    const webSearchCostUsd = usage.webSearchRequests * 0.01;
+    return (tokenCostUsd * speedMultiplier * inferenceMultiplier + webSearchCostUsd) * USD_TO_CREDITS;
+}
+function isClaudeFastPricedModel(modelId) {
+    return ["claude-opus-5", "claude-opus-4-8"].some((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
 }
 function usageToTotals(modelId, usage, timestampMs) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
         cacheWriteBreakdown.cacheWrite1hInputTokens;
+    const rateKnown = Boolean(resolveRate(modelId, timestampMs)) || isInternalClaudeModel(modelId);
     return {
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
@@ -269,7 +263,8 @@ function usageToTotals(modelId, usage, timestampMs) {
             cacheWriteInputTokens +
             usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage, timestampMs),
-        eventCount: 1
+        eventCount: 1,
+        estimatedCreditsStatus: rateKnown ? "known" : "unavailable"
     };
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
@@ -279,10 +274,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 +430,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 +460,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 +492,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 +533,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 +584,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 +1055,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 +1162,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

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

@@ -10,50 +10,90 @@ import { resolveUsageRate } from "./pricing.js";
 // One credit equals $0.01 (see CODEX_CREDIT_COST_USD in index.tsx), so credits
 // equal USD * 100. Rate cards are expressed in the model's actual API price in
 // USD per 1M tokens and scaled to credits in creditsFor, matching the Claude
-// provider. These are the real gpt-5.* API prices, not the (4x cheaper) Codex
+// provider. These are the real OpenAI API prices, not the (4x cheaper) Codex
 // subscription credit prices.
+// Source: https://developers.openai.com/api/docs/pricing (checked 2026-09-05).
+// GPT-5.6 Sol's current promotional rate is guaranteed only through at least
+// 2026-11-21, so it must be rechecked after that date.
 const USD_TO_CREDITS = 100;
+const GPT_6_ASTRA_RATE = {
+    input: 10,
+    cacheRead: 1,
+    cacheWrite: 12.5,
+    cacheWrite5m: 12.5,
+    cacheWrite1h: 12.5,
+    output: 50,
+    longContext: {
+        thresholdTokens: 272000,
+        rate: { input: 20, cacheRead: 2, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 75 }
+    }
+};
 const GPT_5_6_SOL_RATE = {
-    input: 5,
-    cacheRead: 0.5,
-    cacheWrite: 6.25,
-    cacheWrite5m: 6.25,
-    cacheWrite1h: 6.25,
-    output: 30,
+    input: 4,
+    cacheRead: 0.4,
+    cacheWrite: 5,
+    cacheWrite5m: 5,
+    cacheWrite1h: 5,
+    output: 20,
     longContext: {
         thresholdTokens: 272000,
-        rate: { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 12.5, output: 45 }
+        rate: { input: 8, cacheRead: 0.8, cacheWrite: 10, cacheWrite5m: 10, cacheWrite1h: 10, output: 30 }
     }
 };
 const RATE_CARD = {
+    "gpt-6-astra": GPT_6_ASTRA_RATE,
     "gpt-5.6-sol": GPT_5_6_SOL_RATE,
     "gpt-5.6-terra": {
-        input: 2.5,
-        cacheRead: 0.25,
-        cacheWrite: 3.125,
-        cacheWrite5m: 3.125,
-        cacheWrite1h: 3.125,
-        output: 15,
+        input: 2,
+        cacheRead: 0.2,
+        cacheWrite: 2.5,
+        cacheWrite5m: 2.5,
+        cacheWrite1h: 2.5,
+        output: 12,
         longContext: {
             thresholdTokens: 272000,
-            rate: { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 6.25, output: 22.5 }
+            rate: { input: 4, cacheRead: 0.4, cacheWrite: 5, cacheWrite5m: 5, cacheWrite1h: 5, output: 18 }
         }
     },
     "gpt-5.6-luna": {
-        input: 1,
-        cacheRead: 0.1,
-        cacheWrite: 1.25,
-        cacheWrite5m: 1.25,
-        cacheWrite1h: 1.25,
-        output: 6,
+        input: 0.2,
+        cacheRead: 0.02,
+        cacheWrite: 0.25,
+        cacheWrite5m: 0.25,
+        cacheWrite1h: 0.25,
+        output: 1.2,
+        longContext: {
+            thresholdTokens: 272000,
+            rate: { input: 0.4, cacheRead: 0.04, cacheWrite: 0.5, cacheWrite5m: 0.5, cacheWrite1h: 0.5, output: 1.8 }
+        }
+    },
+    "gpt-5.5": {
+        input: 5,
+        cacheRead: 0.5,
+        cacheWrite: 0,
+        cacheWrite5m: 0,
+        cacheWrite1h: 0,
+        output: 30,
+        longContext: {
+            thresholdTokens: 272000,
+            rate: { input: 10, cacheRead: 1, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 45 }
+        }
+    },
+    "gpt-5.4": {
+        input: 2.5,
+        cacheRead: 0.25,
+        cacheWrite: 0,
+        cacheWrite5m: 0,
+        cacheWrite1h: 0,
+        output: 15,
         longContext: {
             thresholdTokens: 272000,
-            rate: { input: 2, cacheRead: 0.2, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 2.5, output: 9 }
+            rate: { input: 5, cacheRead: 0.5, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 22.5 }
         }
     },
-    "gpt-5.5": { input: 5, cacheRead: 0.5, cacheWrite: 5, cacheWrite5m: 5, cacheWrite1h: 5, output: 30 },
-    "gpt-5.4": { input: 2.5, cacheRead: 0.25, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 2.5, output: 15 },
-    "gpt-5.4-mini": { input: 0.75, cacheRead: 0.075, cacheWrite: 0.75, cacheWrite5m: 0.75, cacheWrite1h: 0.75, output: 4.5 }
+    "gpt-5.4-mini": { input: 0.75, cacheRead: 0.075, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 4.5 },
+    "gpt-5.3-codex": { input: 1.75, cacheRead: 0.175, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 14 },
+    "gpt-5.2": { input: 1.75, cacheRead: 0.175, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 14 }
 };
 export class CodexUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
@@ -61,7 +101,11 @@ export class CodexUsageProvider extends UsageProviderBase {
         this.root = path.resolve(options.root ?? os.homedir());
     }
     async getStats(_options = {}) {
-        const sessionsRoot = path.join(this.root, ".codex", "sessions");
+        const codexRoot = path.join(this.root, ".codex");
+        const sessionRoots = [
+            path.join(codexRoot, "sessions"),
+            path.join(codexRoot, "archived_sessions")
+        ];
         const knownModels = await readCodexModelMetadata(this.root);
         const userIdHash = await readCodexUserIdHash(this.root, this.label);
         const byModel = new Map();
@@ -75,12 +119,22 @@ export class CodexUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        for await (const file of walkSessionFiles(sessionsRoot)) {
-            parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
-            parseTotals.linesRead += fileStats.linesRead;
-            parseTotals.tokenEvents += fileStats.tokenEvents;
-            parseTotals.malformedLines += fileStats.malformedLines;
+        const seenSessionFiles = new Set();
+        for (const sessionRoot of sessionRoots) {
+            for await (const file of walkSessionFiles(sessionRoot)) {
+                // Archiving normally moves a rollout, but guard against a transient copy
+                // existing in both locations while Codex updates its session index.
+                const sessionFileId = path.basename(file);
+                if (seenSessionFiles.has(sessionFileId)) {
+                    continue;
+                }
+                seenSessionFiles.add(sessionFileId);
+                parseTotals.filesScanned += 1;
+                const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
+                parseTotals.linesRead += fileStats.linesRead;
+                parseTotals.tokenEvents += fileStats.tokenEvents;
+                parseTotals.malformedLines += fileStats.malformedLines;
+            }
         }
         if (parseTotals.malformedLines > 0) {
             warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
@@ -89,13 +143,14 @@ export class CodexUsageProvider extends UsageProviderBase {
             .map(([modelId, totals]) => ({ modelId, totals }))
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
+            .filter((row) => row.totals.totalTokens > 0)
             .map((row) => row.modelId)
             .filter((modelId) => !rateForCodexModel(modelId) && !isAssumedZeroRatedCodexModel(modelId, knownModels));
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
         if (parseTotals.filesScanned === 0) {
-            warnings.push(`No Codex session files found under ${sessionsRoot}.`);
+            warnings.push(`No Codex session files found under ${codexRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
         const dayUsage = buildDailyUsageRows(byDay);
@@ -110,8 +165,8 @@ export class CodexUsageProvider extends UsageProviderBase {
                 totals: summaryTotals,
                 distinctModels: modelUsage.map((row) => row.modelId),
                 distinctPlanTypes: [...planTypes].sort(),
-                rootLabel: "~/.codex/sessions",
-                rootPath: sessionsRoot
+                rootLabel: "~/.codex",
+                rootPath: codexRoot
             },
             modelUsage,
             dayUsage,
@@ -247,6 +302,7 @@ function createEmptyRawUsage() {
     return {
         inputTokens: 0,
         cachedInputTokens: 0,
+        cacheWriteInputTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
         totalTokens: 0
@@ -257,58 +313,78 @@ function normalizeRawUsage(value) {
     return {
         inputTokens: numberOrZero(usage.input_tokens),
         cachedInputTokens: numberOrZero(usage.cached_input_tokens),
+        cacheWriteInputTokens: numberOrZero(usage.cache_write_input_tokens),
         outputTokens: numberOrZero(usage.output_tokens),
         reasoningOutputTokens: numberOrZero(usage.reasoning_output_tokens),
         totalTokens: numberOrZero(usage.total_tokens)
     };
 }
-function subtractRawUsage(current, previous) {
-    return {
-        inputTokens: Math.max(0, current.inputTokens - previous.inputTokens),
-        cachedInputTokens: Math.max(0, current.cachedInputTokens - previous.cachedInputTokens),
-        outputTokens: Math.max(0, current.outputTokens - previous.outputTokens),
-        reasoningOutputTokens: Math.max(0, current.reasoningOutputTokens - previous.reasoningOutputTokens),
-        totalTokens: Math.max(0, current.totalTokens - previous.totalTokens)
-    };
-}
-function creditsFor(modelId, usage) {
+function creditsFor(modelId, usage, serviceTier) {
     const rate = rateForCodexModel(modelId, usage.inputTokens);
     if (!rate) {
         return 0;
     }
-    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
-    const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
-    return (((nonCachedInputTokens / 1000000) * rate.input +
-        (cachedInputTokens / 1000000) * rate.cacheRead +
+    const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
+    return (((inputTokens / 1000000) * rate.input +
+        (cacheReadInputTokens / 1000000) * rate.cacheRead +
+        (cacheWriteInputTokens / 1000000) * rate.cacheWrite +
         (usage.outputTokens / 1000000) * rate.output) *
+        serviceTierPriceMultiplier(serviceTier) *
         USD_TO_CREDITS);
 }
+function serviceTierPriceMultiplier(serviceTier) {
+    switch (serviceTier?.trim().toLowerCase()) {
+        case "fast":
+        case "priority":
+            return 2;
+        case "flex":
+            return 0.5;
+        default:
+            return 1;
+    }
+}
+function isSupportedServiceTier(serviceTier) {
+    return ["default", "priority", "fast", "flex"].includes(serviceTier?.trim().toLowerCase() ?? "");
+}
 function rateForCodexModel(modelId, inputTokens = 0) {
     // The unsuffixed API alias routes to Sol. Normalize only the exact alias so
     // an unknown future gpt-5.6-* tier is not accidentally charged at Sol rates.
-    const pricedModelId = modelId === "gpt-5.6" ? "gpt-5.6-sol" : modelId;
+    const pricedModelId = modelId === "gpt-5.6"
+        ? "gpt-5.6-sol"
+        : modelId === "codex-auto-review"
+            ? "gpt-5.4"
+            : modelId;
     return resolveUsageRate(RATE_CARD, pricedModelId, inputTokens, { prefixMatch: true });
 }
 function rawUsageToTotals(usage) {
-    const cacheReadInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
-    const inputTokens = Math.max(0, usage.inputTokens - cacheReadInputTokens);
+    const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
     return {
         inputTokens,
         outputTokens: usage.outputTokens,
         cacheReadInputTokens,
-        cacheWriteInputTokens: 0,
-        cacheWrite5mInputTokens: 0,
+        cacheWriteInputTokens,
+        cacheWrite5mInputTokens: cacheWriteInputTokens,
         cacheWrite1hInputTokens: 0,
         reasoningOutputTokens: usage.reasoningOutputTokens,
-        totalTokens: inputTokens + cacheReadInputTokens + usage.outputTokens,
+        totalTokens: inputTokens + cacheReadInputTokens + cacheWriteInputTokens + usage.outputTokens,
         estimatedCredits: 0,
         eventCount: 0
     };
 }
-function createUsageTotalsForModel(modelId, usage, knownModels) {
+function resolveCodexInputBreakdown(usage) {
+    const cacheReadInputTokens = Math.min(Math.max(0, usage.cachedInputTokens), usage.inputTokens);
+    const inputAfterCacheRead = Math.max(0, usage.inputTokens - cacheReadInputTokens);
+    const cacheWriteInputTokens = Math.min(Math.max(0, usage.cacheWriteInputTokens), inputAfterCacheRead);
+    return {
+        inputTokens: Math.max(0, inputAfterCacheRead - cacheWriteInputTokens),
+        cacheReadInputTokens,
+        cacheWriteInputTokens
+    };
+}
+function createUsageTotalsForModel(modelId, usage, knownModels, serviceTier) {
     const resolvedModelId = modelId || "unknown";
     const deltaTotals = rawUsageToTotals(usage);
-    deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
+    deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage, serviceTier);
     deltaTotals.eventCount = 1;
     if (!rateForCodexModel(resolvedModelId, usage.inputTokens) && !isAssumedZeroRatedCodexModel(resolvedModelId, knownModels)) {
         deltaTotals.estimatedCreditsStatus = "unavailable";
@@ -325,12 +401,13 @@ function isHiddenCodexModel(modelId, knownModels) {
     return knownModels.get(modelId)?.visibility === "hide";
 }
 function isAssumedZeroRatedCodexModel(modelId, knownModels) {
-    // Hidden internal Codex models do not have a public rate card entry. For dashboard
-    // rollups we treat them as zero-rated so they do not turn aggregate totals unknown.
-    return isHiddenCodexModel(modelId, knownModels);
+    // Synthetic bookkeeping rows carry no billable model call. Other hidden
+    // models are not assumed free: Codex auto-review is mapped to GPT-5.4 above,
+    // and an unknown hidden model must make the estimate explicitly unavailable.
+    return modelId === "<synthetic>" && isHiddenCodexModel(modelId, knownModels);
 }
 function isSessionFile(filePath) {
-    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
+    return filePath.endsWith(".jsonl");
 }
 async function* walkSessionFiles(directory) {
     let entries;
@@ -354,10 +431,51 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
-    let previousTotal;
+    let currentServiceTier;
+    let pendingUsageRecord;
+    let firstSessionMetadataSeen = false;
+    let forkStartedAtMs = null;
+    let isOwnForkHistory = true;
     let linesRead = 0;
     let tokenEvents = 0;
     let malformedLines = 0;
+    let pendingWebSearchCalls = 0;
+    let lastSeenTimestampMs = 0;
+    const recordUsage = (modelId, usage, eventTimeMs, rateLimits = null, serviceTier = currentServiceTier) => {
+        const webSearchCostCredits = pendingWebSearchCalls;
+        pendingWebSearchCalls = 0;
+        // Current-format-only policy: without the applied tier the exact cost is
+        // unknowable. Silently ignore the event instead of guessing Standard or
+        // carrying compatibility warnings for legacy rollout formats.
+        if (!isSupportedServiceTier(serviceTier)) {
+            return;
+        }
+        if (!hasCountedRawUsage(usage) && webSearchCostCredits === 0) {
+            return;
+        }
+        const resolvedModelId = modelId || "unknown";
+        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels, serviceTier);
+        // OpenAI API web search is $10 / 1k calls: $0.01, or one dashboard
+        // credit, per completed call. Search-content tokens are already present in
+        // the model usage record and are priced normally above.
+        deltaTotals.estimatedCredits += webSearchCostCredits;
+        if (!hasCountedRawUsage(usage) && webSearchCostCredits > 0) {
+            deltaTotals.estimatedCreditsStatus = "known";
+        }
+        const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
+        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
+        tokenEvents += 1;
+        addModelUsage(byModel, resolvedModelId, deltaTotals);
+        addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
+        applyRateLimits(windows, rateLimits, safeEventTimeMs, resolvedModelId, deltaTotals, planTypes);
+    };
+    const flushPendingUsageRecord = () => {
+        if (!pendingUsageRecord) {
+            return;
+        }
+        recordUsage(pendingUsageRecord.modelId, pendingUsageRecord.usage, pendingUsageRecord.eventTimeMs, null, pendingUsageRecord.serviceTier);
+        pendingUsageRecord = undefined;
+    };
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -371,35 +489,111 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
             malformedLines += 1;
             continue;
         }
+        const parsedTimestampMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        if (Number.isFinite(parsedTimestampMs)) {
+            lastSeenTimestampMs = parsedTimestampMs;
+        }
+        if (payloadObject.type === "session_meta" && !firstSessionMetadataSeen) {
+            firstSessionMetadataSeen = true;
+            const payload = asRecord(payloadObject.payload);
+            const sessionStartedAtMs = parseSortableCodexIdTimestamp(payload?.id);
+            if (typeof payload?.forked_from_id === "string" && sessionStartedAtMs !== null) {
+                forkStartedAtMs = sessionStartedAtMs;
+                isOwnForkHistory = false;
+            }
+            continue;
+        }
         if (payloadObject.type === "turn_context") {
-            const payload = payloadObject.payload;
-            const collaborationMode = payload?.collaboration_mode;
-            const settings = collaborationMode?.settings;
+            const payload = asRecord(payloadObject.payload);
+            const turnStartedAtMs = parseSortableCodexIdTimestamp(payload?.turn_id);
+            if (forkStartedAtMs !== null && turnStartedAtMs !== null && turnStartedAtMs < forkStartedAtMs) {
+                continue;
+            }
+            if (!isOwnForkHistory) {
+                if (forkStartedAtMs !== null && turnStartedAtMs === null) {
+                    continue;
+                }
+                isOwnForkHistory = true;
+            }
+            flushPendingUsageRecord();
+            const collaborationMode = asRecord(payload?.collaboration_mode);
+            const settings = asRecord(collaborationMode?.settings);
             currentModel = String(payload?.model ?? settings?.model ?? currentModel);
             continue;
         }
+        // A fork inherits the latest thread settings from its parent history. Keep
+        // tracking those settings while skipping the inherited usage itself, so a
+        // child request is priced with the tier that was actually in force.
+        if (payloadObject.type === "event_msg") {
+            const payload = asRecord(payloadObject.payload);
+            if (payload?.type === "thread_settings_applied") {
+                const threadSettings = asRecord(payload.thread_settings);
+                if (typeof threadSettings?.model === "string" && threadSettings.model.trim()) {
+                    currentModel = threadSettings.model;
+                }
+                if (typeof threadSettings?.service_tier === "string" && threadSettings.service_tier.trim()) {
+                    currentServiceTier = threadSettings.service_tier;
+                }
+                continue;
+            }
+        }
+        if (!isOwnForkHistory) {
+            continue;
+        }
+        if (payloadObject.type === "token_usage_record") {
+            flushPendingUsageRecord();
+            const payload = asRecord(payloadObject.payload);
+            const usage = normalizeRawUsage(payload?.usage);
+            if (hasCountedRawUsage(usage)) {
+                pendingUsageRecord = {
+                    modelId: currentModel || "unknown",
+                    usage,
+                    eventTimeMs: Date.parse(String(payloadObject.timestamp ?? "")),
+                    serviceTier: currentServiceTier
+                };
+            }
+            continue;
+        }
         if (payloadObject.type !== "event_msg") {
             continue;
         }
-        const payload = payloadObject.payload;
+        const payload = asRecord(payloadObject.payload);
+        if (payload?.type === "web_search_end") {
+            pendingWebSearchCalls += 1;
+            continue;
+        }
         if (payload?.type !== "token_count") {
             continue;
         }
-        const info = payload.info;
-        const totalUsage = normalizeRawUsage(info?.total_token_usage);
-        const lastUsage = info?.last_token_usage;
-        const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
-        previousTotal = totalUsage;
-        const resolvedModelId = currentModel || "unknown";
-        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels);
-        tokenEvents += 1;
-        addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
-        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
         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, resolvedModelId, deltaTotals, planTypes);
+        if (pendingUsageRecord) {
+            const pending = pendingUsageRecord;
+            pendingUsageRecord = undefined;
+            recordUsage(pending.modelId, pending.usage, pending.eventTimeMs, rateLimits, pending.serviceTier);
+        }
+    }
+    flushPendingUsageRecord();
+    if (pendingWebSearchCalls > 0) {
+        recordUsage(currentModel, createEmptyRawUsage(), lastSeenTimestampMs);
     }
     return { linesRead, tokenEvents, malformedLines };
 }
+function hasCountedRawUsage(usage) {
+    return (usage.inputTokens > 0 ||
+        usage.cachedInputTokens > 0 ||
+        usage.cacheWriteInputTokens > 0 ||
+        usage.outputTokens > 0 ||
+        usage.reasoningOutputTokens > 0);
+}
+function parseSortableCodexIdTimestamp(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const timestampHex = value.replace(/-/g, "").slice(0, 12);
+    if (!/^[0-9a-f]{12}$/i.test(timestampHex)) {
+        return null;
+    }
+    const timestamp = Number.parseInt(timestampHex, 16);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}

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

@@ -88,6 +88,7 @@ export function buildWindowLists(windows) {
             lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
             minUsedPercent: window.minUsedPercent,
             maxUsedPercent: window.maxUsedPercent,
+            measuredUsedPercent: usage.measuredUsedPercent,
             totals: usage.totals,
             modelUsage: usage.modelUsage,
             eventCount: 0
@@ -178,6 +179,10 @@ function collapseNearbyWindows(rows) {
             existing.lastSeenUtcIso > row.lastSeenUtcIso ? existing.lastSeenUtcIso : row.lastSeenUtcIso;
         existing.minUsedPercent = Math.min(existing.minUsedPercent, row.minUsedPercent);
         existing.maxUsedPercent = Math.max(existing.maxUsedPercent, row.maxUsedPercent);
+        existing.measuredUsedPercent =
+            existing.minUsedPercent === existing.maxUsedPercent
+                ? 0
+                : clampUsedPercent(existing.maxUsedPercent - existing.minUsedPercent);
         addUsageTotals(existing.totals, row.totals);
         existing.modelUsage = mergeModelUsageRows(existing.modelUsage, row.modelUsage);
         existing.eventCount = existing.totals.eventCount;
@@ -189,13 +194,22 @@ function computeWindowUsage(events) {
     // saturation has to be applied after we sort the captured window events.
     const totals = createEmptyUsageTotals();
     const byModel = new Map();
-    let sawBelowCap = false;
-    let isExhausted = false;
-    for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
+    const sortedEvents = [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs);
+    const baselinePercent = clampUsedPercent(sortedEvents[0]?.usedPercent ?? 0);
+    // Each rate-limit snapshot is recorded after the usage event on the same
+    // line. The first event therefore has no matching "before" percentage, even
+    // when its post-event value rounds to zero. Keep its percentage only as the
+    // baseline and aggregate requests from the next snapshot onward.
+    const firstIncludedIndex = sortedEvents.length > 0 ? 1 : 0;
+    let highestIncludedPercent = baselinePercent;
+    let sawBelowCap = baselinePercent < 100;
+    let isExhausted = baselinePercent >= 100;
+    for (const [index, event] of sortedEvents.entries()) {
         sawBelowCap || (sawBelowCap = event.usedPercent < 100);
-        if (!isExhausted) {
+        if (index >= firstIncludedIndex && !isExhausted) {
             addUsageTotals(totals, event.totals);
             addWindowModelUsage(byModel, event.modelId, event.totals);
+            highestIncludedPercent = Math.max(highestIncludedPercent, clampUsedPercent(event.usedPercent));
             if (sawBelowCap && event.usedPercent >= 100) {
                 isExhausted = true;
             }
@@ -203,9 +217,32 @@ function computeWindowUsage(events) {
     }
     return {
         totals,
-        modelUsage: buildModelUsageRows(byModel)
+        modelUsage: buildModelUsageRows(byModel),
+        measuredUsedPercent: clampUsedPercent(highestIncludedPercent - baselinePercent)
     };
 }
+/**
+ * Return the provider percentage represented by a window's token totals.
+ * Older/injected rows without the explicit field retain the legacy derivation.
+ */
+export function resolveMeasuredUsedPercent(window) {
+    if (window.measuredUsedPercent === null) {
+        return null;
+    }
+    if (typeof window.measuredUsedPercent === "number" && Number.isFinite(window.measuredUsedPercent)) {
+        return clampUsedPercent(window.measuredUsedPercent);
+    }
+    if (window.minUsedPercent === window.maxUsedPercent) {
+        return clampUsedPercent(window.maxUsedPercent);
+    }
+    return clampUsedPercent(window.maxUsedPercent - window.minUsedPercent);
+}
+function clampUsedPercent(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, value));
+}
 function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, modelId, deltaTotals) {
     if (!window) {
         return;

package/ink-app/dist/reporting.js

@@ -2,6 +2,7 @@ import { request } from "node:https";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveMeasuredUsedPercent } from "./providers/limits.js";
 const REPORTING_ENDPOINT = "https://devforth.io/admin/api/report_ussage_anonymous";
 const CREDIT_TO_DOLLARS = 0.01;
 // Limit windows at or below this used-percent carry too little signal to be
@@ -99,13 +100,11 @@ function buildUsageRaw(modelUsage) {
     return usageRaw;
 }
 function resolveReportedUsedPercents(window) {
-    if (window.minUsedPercent === window.maxUsedPercent) {
-        return clampPercent(window.maxUsedPercent);
-    }
-    return clampPercent(window.maxUsedPercent - window.minUsedPercent);
+    return clampPercent(resolveMeasuredUsedPercent(window) ?? 0);
 }
 function shouldReportUsageWindow(window) {
-    return resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS;
+    return (window.totals.estimatedCreditsStatus !== "unavailable" &&
+        resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS);
 }
 function clampPercent(value) {
     if (!Number.isFinite(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Terminal AI usage dashboard for Codex, Claude, Copilot, and Antigravity.",
   "author": "Devforth (https://devforth.io)",
   "license": "MIT",