letmecode 0.1.30 → 0.1.33

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, resolveMeasuredUsedPercent, selectLatestActiveLimitWindows } from "./providers/limits.js";
+import { estimateLimitFullValue, isPartialUsagePairing, 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
@@ -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, resolveMeasuredUsedPercent(window))
+            formatLimitFullValueCompact(window)
         ]
     };
 }
@@ -543,7 +543,9 @@ 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: "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" })] }));
+        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)}` }), isPartialUsagePairing(row) ? (_jsx(DetailRow, { label: "Paired from", value: formatCompactLocalDateTime(row.pairedUsageStartUtcIso ?? row.startTimeUtcIso), note: "percentage restarted mid-window" })) : null, _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), note: isPartialUsagePairing(row)
+                        ? `approximate: this percentage restarted mid-window, usage paired from ${formatCompactLocalDateTime(row.pairedUsageStartUtcIso ?? row.startTimeUtcIso)}`
+                        : "API equivalent cost extrapolated from the paired token/usage interval" })] }));
     }
     if (props.viewId === "day-to-day-analyses" && props.selectedDayRow) {
         const row = props.selectedDayRow;
@@ -650,17 +652,24 @@ function limitFullValueUsd(totals, usedPercent) {
     const usedUsd = totals.estimatedCredits * CODEX_CREDIT_COST_USD;
     return estimateLimitFullValue(usedUsd, usedPercent);
 }
-function formatLimitFullValueCompact(totals, usedPercent) {
-    const estimate = limitFullValueUsd(totals, usedPercent);
-    return estimate ? formatUsdWhole(estimate.point) : "-";
+// A window whose paired usage covers only part of its span is paired across an
+// only approximately known interval, so the figures it yields carry a "~".
+function formatLimitFullValueCompact(window) {
+    const estimate = limitFullValueUsd(window.totals, resolveMeasuredUsedPercent(window));
+    if (!estimate) {
+        return "-";
+    }
+    const value = formatUsdWhole(estimate.point);
+    return isPartialUsagePairing(window) ? `~${value}` : value;
 }
-function formatLimitFullValueRange(totals, usedPercent) {
-    const estimate = limitFullValueUsd(totals, usedPercent);
+function formatLimitFullValueRange(window) {
+    const estimate = limitFullValueUsd(window.totals, resolveMeasuredUsedPercent(window));
     if (!estimate) {
         return "-";
     }
     const low = formatUsd(estimate.low);
-    return Number.isFinite(estimate.high) ? `${low} – ${formatUsd(estimate.high)}` : `≥ ${low}`;
+    const range = Number.isFinite(estimate.high) ? `${low} – ${formatUsd(estimate.high)}` : `≥ ${low}`;
+    return isPartialUsagePairing(window) ? `~ ${range}` : range;
 }
 function formatUnitUsd(value) {
     if (!Number.isFinite(value)) {

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

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import path from "node:path";
+import { asRecord } from "./limits.js";
+const CLAUDE_PLAN_STATE_VERSION = 1;
+const MAX_TRACKED_PLANS = 20;
+// Refresh ticks re-resolve the same plan every few seconds; only persist the
+// heartbeat once it is stale enough to matter for a switch boundary.
+const LAST_SEEN_REFRESH_MS = 5 * 60000;
+export function getClaudePlanStatePath(root) {
+    return path.join(path.resolve(root), ".letmecode", "claude-plan-state.json");
+}
+/**
+ * Record that `planType` is the plan in effect now and return the moment the
+ * current plan first became visible, but only when letmecode had already seen a
+ * different plan before it. A first-ever observation returns null: without a
+ * previous plan on record there is no evidence that the provider's percentages
+ * restarted, so the caller must keep pairing the full window.
+ */
+export async function recordClaudePlanObservation(options) {
+    const statePath = getClaudePlanStatePath(options.root);
+    const nowMs = options.now.getTime();
+    const nowIso = new Date(nowMs).toISOString();
+    const state = await readClaudePlanState(statePath);
+    const observations = state.observations;
+    const previous = resolveLatestObservation(observations, options.planType);
+    const existing = observations.find((observation) => observation.planType === options.planType);
+    let entry;
+    let changed = false;
+    if (!existing) {
+        entry = {
+            planType: options.planType,
+            firstSeenUtcIso: nowIso,
+            lastSeenUtcIso: nowIso,
+            ...(previous ? { switchedFromPlanType: previous.planType } : {})
+        };
+        observations.push(entry);
+        changed = true;
+    }
+    else if (previous) {
+        // The account came back to a plan letmecode saw earlier: its percentages
+        // restarted again, so the stale first-seen no longer marks the boundary.
+        existing.firstSeenUtcIso = nowIso;
+        existing.lastSeenUtcIso = nowIso;
+        existing.switchedFromPlanType = previous.planType;
+        entry = existing;
+        changed = true;
+    }
+    else {
+        entry = existing;
+        changed = nowMs - Date.parse(existing.lastSeenUtcIso) >= LAST_SEEN_REFRESH_MS;
+        existing.lastSeenUtcIso = nowIso;
+    }
+    if (changed) {
+        await writeClaudePlanState(statePath, {
+            version: CLAUDE_PLAN_STATE_VERSION,
+            observations: observations.slice(-MAX_TRACKED_PLANS)
+        }, options.traceLogger);
+    }
+    if (!entry.switchedFromPlanType) {
+        return null;
+    }
+    const planStartMs = Date.parse(entry.firstSeenUtcIso);
+    return Number.isFinite(planStartMs) ? planStartMs : null;
+}
+/** Latest plan on record that is not `planType`, by the time it was last seen. */
+function resolveLatestObservation(observations, planType) {
+    let latest = null;
+    let latestMs = Number.NEGATIVE_INFINITY;
+    for (const observation of observations) {
+        if (observation.planType === planType) {
+            continue;
+        }
+        const lastSeenMs = Date.parse(observation.lastSeenUtcIso);
+        if (Number.isFinite(lastSeenMs) && lastSeenMs > latestMs) {
+            latest = observation;
+            latestMs = lastSeenMs;
+        }
+    }
+    return latest;
+}
+async function readClaudePlanState(statePath) {
+    let text;
+    try {
+        text = await fs.promises.readFile(statePath, { encoding: "utf8" });
+    }
+    catch {
+        return { version: CLAUDE_PLAN_STATE_VERSION, observations: [] };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        return { version: CLAUDE_PLAN_STATE_VERSION, observations: [] };
+    }
+    const record = asRecord(payload);
+    if (!record || record.version !== CLAUDE_PLAN_STATE_VERSION || !Array.isArray(record.observations)) {
+        return { version: CLAUDE_PLAN_STATE_VERSION, observations: [] };
+    }
+    return {
+        version: CLAUDE_PLAN_STATE_VERSION,
+        observations: record.observations
+            .map((value) => parseObservation(value))
+            .filter((observation) => observation !== null)
+    };
+}
+function parseObservation(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const planType = typeof record.planType === "string" ? record.planType.trim() : "";
+    const firstSeenUtcIso = typeof record.firstSeenUtcIso === "string" ? record.firstSeenUtcIso : "";
+    const lastSeenUtcIso = typeof record.lastSeenUtcIso === "string" ? record.lastSeenUtcIso : "";
+    if (!planType || !Number.isFinite(Date.parse(firstSeenUtcIso)) || !Number.isFinite(Date.parse(lastSeenUtcIso))) {
+        return null;
+    }
+    const switchedFromPlanType = typeof record.switchedFromPlanType === "string" && record.switchedFromPlanType.trim()
+        ? record.switchedFromPlanType.trim()
+        : undefined;
+    return {
+        planType,
+        firstSeenUtcIso,
+        lastSeenUtcIso,
+        ...(switchedFromPlanType ? { switchedFromPlanType } : {})
+    };
+}
+/** Never let a read-only or full disk break the dashboard. */
+async function writeClaudePlanState(statePath, state, traceLogger) {
+    const temporaryPath = `${statePath}.${process.pid}.tmp`;
+    try {
+        await fs.promises.mkdir(path.dirname(statePath), { recursive: true });
+        await fs.promises.writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+        await fs.promises.rename(temporaryPath, statePath);
+    }
+    catch (error) {
+        traceLogger?.log(`[Claude] Could not persist plan state to ${statePath}: ${String(error)}`);
+        await fs.promises.rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}

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

@@ -6,7 +6,8 @@ import path from "node:path";
 import readline from "node:readline";
 import { promisify } from "node:util";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
-import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, isPartialUsagePairing, numberOrZero } from "./limits.js";
+import { recordClaudePlanObservation } from "./claude-plan-state.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { fetchModelPricing, modelCostCredits } from "./pricing.js";
 /*
@@ -27,6 +28,14 @@ const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
 const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
 const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
 const ANSI_ESCAPE_SEQUENCE = /\u001B\[[0-9;]*[A-Za-z]/g;
+// Transcript `quotaLimits` entries name the quota cycle that rejected a request.
+// Their reset instant identifies the cycle, so a cycle that differs from the one
+// /usage reports now proves the account's quota accounting changed mid-window.
+const CLAUDE_QUOTA_WINDOW_MINUTES_BY_RATE_LIMIT_TYPE = {
+    five_hour: CLAUDE_SESSION_WINDOW_MINUTES,
+    seven_day: CLAUDE_WEEK_WINDOW_MINUTES
+};
+const CLAUDE_QUOTA_RESET_MATCH_TOLERANCE_MS = 60000;
 const MONTH_INDEX_BY_LABEL = {
     jan: 0,
     feb: 1,
@@ -96,6 +105,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 recordParsedUsageEvent(parsedEvents, event);
             }
         }
+        const quotaObservations = parsedSessionFiles.flatMap((file) => file.quotaObservations);
         const selectedEvents = [
             ...new Set(parsedEvents.keyedEvents.values())
         ];
@@ -156,7 +166,8 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             readOauthCredentials: this.readOauthCredentials,
             traceLogger: options.traceLogger,
             now: this.now(),
-            selectedEvents
+            selectedEvents,
+            quotaObservations
         });
         const primaryLimitWindows = liveLimitWindows.primaryLimitWindows.length > 0
             ? liveLimitWindows.primaryLimitWindows
@@ -164,6 +175,11 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const secondaryLimitWindows = liveLimitWindows.secondaryLimitWindows.length > 0
             ? liveLimitWindows.secondaryLimitWindows
             : fallbackSecondaryLimitWindows;
+        for (const window of [...primaryLimitWindows, ...secondaryLimitWindows]) {
+            if (isPartialUsagePairing(window) && window.pairedUsageStartUtcIso) {
+                warnings.push(`The ${formatWindowMinutesLabel(window.windowMinutes)} ${window.planType} limit restarted its percentage mid-window, so only usage from ${window.pairedUsageStartUtcIso} is paired with it and its full value is approximate.`);
+            }
+        }
         traceClaude(options.traceLogger, [
             `Finished stats collection:`,
             `filesScanned=${parseTotals.filesScanned}`,
@@ -414,6 +430,7 @@ async function parseSessionFile(filePath) {
     let linesRead = 0;
     let malformedLines = 0;
     const events = [];
+    const quotaObservations = [];
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -430,6 +447,12 @@ async function parseSessionFile(filePath) {
         if (payloadObject.type !== "assistant") {
             continue;
         }
+        // Rejected requests carry the quota cycle that turned them down but no usage,
+        // so this has to be read before the usage gate below drops the line.
+        const quotaObservation = extractQuotaObservation(payloadObject);
+        if (quotaObservation) {
+            quotaObservations.push(quotaObservation);
+        }
         const message = asRecord(payloadObject.message);
         const usage = asRecord(message?.usage);
         if (!usage || !isCurrentClaudeUsageEvent(payloadObject, message, usage)) {
@@ -459,7 +482,25 @@ async function parseSessionFile(filePath) {
         filePath,
         linesRead,
         malformedLines,
-        events
+        events,
+        quotaObservations
+    };
+}
+function extractQuotaObservation(payloadObject) {
+    const quotaLimits = asRecord(payloadObject.quotaLimits);
+    if (!quotaLimits) {
+        return null;
+    }
+    const rateLimitType = typeof quotaLimits.rateLimitType === "string" ? quotaLimits.rateLimitType : "";
+    const resetsAtSeconds = numberOrZero(quotaLimits.resetsAt);
+    const timestampMs = Date.parse(String(payloadObject.timestamp ?? ""));
+    if (!rateLimitType || !resetsAtSeconds || !Number.isFinite(timestampMs)) {
+        return null;
+    }
+    return {
+        timestampMs,
+        rateLimitType,
+        resetsAtMs: resetsAtSeconds * 1000
     };
 }
 function isCurrentClaudeUsageEvent(payloadObject, message, usage) {
@@ -600,6 +641,15 @@ function normalizeTimestamp(value) {
 function extractRateLimits(payloadObject, message) {
     return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
 }
+function formatWindowMinutesLabel(windowMinutes) {
+    if (windowMinutes % (24 * 60) === 0) {
+        return `${windowMinutes / (24 * 60)}d`;
+    }
+    if (windowMinutes % 60 === 0) {
+        return `${windowMinutes / 60}h`;
+    }
+    return `${windowMinutes}m`;
+}
 function traceClaude(traceLogger, message) {
     if (!traceLogger) {
         return;
@@ -671,12 +721,27 @@ async function buildLiveLimitWindows(options) {
     }
     const resolvedPlanType = resolveClaudeLivePlanType(credentials);
     traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
+    // A percentage reported for the current plan cannot describe usage produced
+    // under the plan the account had before it, so remember when the switch became
+    // visible and stop pairing anything older with that percentage.
+    const planStartMs = resolvedPlanType === "live"
+        ? null
+        : await recordClaudePlanObservation({
+            root: options.root,
+            planType: resolvedPlanType,
+            now: options.now,
+            traceLogger: options.traceLogger
+        });
+    if (planStartMs !== null) {
+        traceClaude(options.traceLogger, `Plan ${resolvedPlanType} first seen at ${toUtcIso(planStartMs)}; older usage is not paired with its percentages.`);
+    }
+    const buildRow = (snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now, resolvePairedUsageStartMs(snapshot, options.quotaObservations, planStartMs, options.traceLogger));
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
-        .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
+        .map(buildRow);
     const secondaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "secondary")
-        .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
+        .map(buildRow);
     for (let index = 0; index < snapshots.length; index += 1) {
         const snapshot = snapshots[index];
         const row = snapshot.scope === "primary"
@@ -690,6 +755,7 @@ async function buildLiveLimitWindows(options) {
             `used=${snapshot.usedPercent}%`,
             `limit=${snapshot.limitId}`,
             `range=${row.startTimeUtcIso}->${row.endTimeUtcIso}`,
+            `pairedFrom=${row.pairedUsageStartUtcIso ?? row.startTimeUtcIso}`,
             `matchedEvents=${row.eventCount}`,
             `input=${row.totals.inputTokens}`,
             `output=${row.totals.outputTokens}`,
@@ -1139,10 +1205,56 @@ function resolveHour24(hour12, meridiem) {
     }
     return meridiem === "pm" ? hour12 + 12 : hour12;
 }
-function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
+/**
+ * Start of the interval a snapshot's percentage can describe. Usage recorded
+ * before the account's current quota accounting began - a plan switch, or a
+ * rejection from a different quota cycle inside the same window - is no longer
+ * represented by the percentage /usage reports now, so pairing it would inflate
+ * everything extrapolated from the pair. Returns null when the whole window
+ * belongs to the current accounting.
+ *
+ * Both signals only bracket the switch: a foreign-cycle rejection happened at or
+ * before it, the first sighting of the current plan at or after it. The earliest
+ * candidate wins, so no usage that the current percentage does cover is dropped,
+ * and callers treat what they extrapolate as approximate rather than exact.
+ */
+function resolvePairedUsageStartMs(snapshot, quotaObservations, planStartMs, traceLogger) {
+    const windowStartMs = snapshot.resetsAtMs - snapshot.windowMinutes * 60000;
+    const candidates = [];
+    if (planStartMs !== null && planStartMs > windowStartMs) {
+        candidates.push(planStartMs);
+    }
+    const foreignCycleEndMs = resolveForeignQuotaCycleEndMs(snapshot, quotaObservations, windowStartMs);
+    if (foreignCycleEndMs !== null) {
+        traceClaude(traceLogger, `Window ${snapshot.limitId} contains a ${snapshot.windowMinutes}m quota rejection from another cycle at ${toUtcIso(foreignCycleEndMs)}.`);
+        // The rejection itself belongs to the previous cycle, so pairing resumes
+        // right after it.
+        candidates.push(foreignCycleEndMs + 1);
+    }
+    return candidates.length > 0 ? Math.min(...candidates) : null;
+}
+/**
+ * Latest moment inside the window at which a quota cycle other than the one the
+ * snapshot reports was still in force.
+ */
+function resolveForeignQuotaCycleEndMs(snapshot, quotaObservations, windowStartMs) {
+    let latestMs = null;
+    for (const observation of quotaObservations) {
+        if (CLAUDE_QUOTA_WINDOW_MINUTES_BY_RATE_LIMIT_TYPE[observation.rateLimitType] !== snapshot.windowMinutes ||
+            observation.timestampMs < windowStartMs ||
+            observation.timestampMs >= snapshot.resetsAtMs ||
+            Math.abs(observation.resetsAtMs - snapshot.resetsAtMs) <= CLAUDE_QUOTA_RESET_MATCH_TOLERANCE_MS) {
+            continue;
+        }
+        latestMs = latestMs === null ? observation.timestampMs : Math.max(latestMs, observation.timestampMs);
+    }
+    return latestMs;
+}
+function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now, pairedUsageStartMs = null) {
     const startTimeMs = snapshot.resetsAtMs - snapshot.windowMinutes * 60000;
+    const usageStartMs = Math.max(startTimeMs, pairedUsageStartMs ?? startTimeMs);
     const inWindowEvents = selectedEvents.filter((event) => Number.isFinite(event.timestampMs) &&
-        event.timestampMs >= startTimeMs &&
+        event.timestampMs >= usageStartMs &&
         event.timestampMs < snapshot.resetsAtMs &&
         matchesClaudeLiveSnapshotModelScope(snapshot, event.modelId));
     const totals = sumUsageTotals(inWindowEvents.map((event) => event.totals));
@@ -1150,6 +1262,7 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         totals.estimatedCreditsStatus = "unavailable";
     }
     const fallbackLastSeenMs = Math.min(now.getTime(), snapshot.resetsAtMs);
+    const hasPartialPairing = usageStartMs > startTimeMs;
     const firstSeenMs = inWindowEvents.reduce((minimum, event) => Math.min(minimum, event.timestampMs), Number.POSITIVE_INFINITY);
     const lastSeenMs = inWindowEvents.reduce((maximum, event) => Math.max(maximum, event.timestampMs), Number.NEGATIVE_INFINITY);
     return {
@@ -1160,7 +1273,8 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         windowMinutes: snapshot.windowMinutes,
         startTimeUtcIso: toUtcIso(startTimeMs),
         endTimeUtcIso: toUtcIso(snapshot.resetsAtMs),
-        firstSeenUtcIso: toUtcIso(Number.isFinite(firstSeenMs) ? firstSeenMs : startTimeMs),
+        ...(hasPartialPairing ? { pairedUsageStartUtcIso: toUtcIso(usageStartMs) } : {}),
+        firstSeenUtcIso: toUtcIso(Number.isFinite(firstSeenMs) ? firstSeenMs : usageStartMs),
         lastSeenUtcIso: toUtcIso(Number.isFinite(lastSeenMs) ? lastSeenMs : fallbackLastSeenMs),
         minUsedPercent: snapshot.usedPercent,
         maxUsedPercent: snapshot.usedPercent,

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

@@ -19,7 +19,12 @@ export function selectLatestActiveLimitWindows(windows, nowMs = Date.now()) {
             continue;
         }
         const startMs = Date.parse(window.startTimeUtcIso);
-        const groupKey = JSON.stringify([window.planType, window.windowMinutes]);
+        // `limitId` is part of the key because a plan can run several limits of the
+        // same duration side by side: Claude meters an all-models week and a
+        // model-family week that share a plan, a length and a reset instant. Keyed
+        // on plan and duration alone they collapse into one group and the family
+        // window loses the tie, so it never counts as active.
+        const groupKey = JSON.stringify([window.planType, window.limitId, window.windowMinutes]);
         const current = latestByPlanAndWindow.get(groupKey);
         if (!current || startMs > current.startMs) {
             latestByPlanAndWindow.set(groupKey, { window, startMs });
@@ -237,6 +242,18 @@ export function resolveMeasuredUsedPercent(window) {
     }
     return clampUsedPercent(window.maxUsedPercent - window.minUsedPercent);
 }
+/**
+ * True when a window's token totals cover only part of the window, so anything
+ * extrapolated from them (e.g. the limit's full value) is approximate.
+ */
+export function isPartialUsagePairing(window) {
+    if (!window.pairedUsageStartUtcIso) {
+        return false;
+    }
+    const pairedStartMs = Date.parse(window.pairedUsageStartUtcIso);
+    const startMs = Date.parse(window.startTimeUtcIso);
+    return Number.isFinite(pairedStartMs) && Number.isFinite(startMs) && pairedStartMs > startMs;
+}
 function clampUsedPercent(value) {
     if (!Number.isFinite(value)) {
         return 0;

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

@@ -44,7 +44,17 @@ export async function fetchModelPricing(modelIds, source) {
             output: model.output,
             inputCacheRead: model.input_cache_read,
             inputCacheWrite5m: model.input_cache_w5m,
-            inputCacheWrite1h: model.input_cache_w1h
+            inputCacheWrite1h: model.input_cache_w1h,
+            longContext: model.long_context
+                ? {
+                    inputTokensThreshold: model.long_context.input_tokens_threshold,
+                    input: model.long_context.input,
+                    output: model.long_context.output,
+                    inputCacheRead: model.long_context.input_cache_read,
+                    inputCacheWrite5m: model.long_context.input_cache_w5m,
+                    inputCacheWrite1h: model.long_context.input_cache_w1h
+                }
+                : null
         }
     ]));
     return new Map([...slugByModelId.entries()].flatMap(([modelId, slug]) => {
@@ -56,17 +66,24 @@ export function modelCostCredits(pricing, usage) {
     if (!pricing) {
         return undefined;
     }
-    if (usage.cacheWrite5mInputTokens > 0 && pricing.inputCacheWrite5m === null) {
+    const totalInputTokens = usage.inputTokens +
+        usage.cacheReadInputTokens +
+        usage.cacheWrite5mInputTokens +
+        usage.cacheWrite1hInputTokens;
+    const rates = pricing.longContext && totalInputTokens > pricing.longContext.inputTokensThreshold
+        ? pricing.longContext
+        : pricing;
+    if (usage.cacheWrite5mInputTokens > 0 && rates.inputCacheWrite5m === null) {
         return undefined;
     }
-    if (usage.cacheWrite1hInputTokens > 0 && pricing.inputCacheWrite1h === null) {
+    if (usage.cacheWrite1hInputTokens > 0 && rates.inputCacheWrite1h === null) {
         return undefined;
     }
-    return ((usage.inputTokens / 1000000) * pricing.input +
-        (usage.cacheReadInputTokens / 1000000) * pricing.inputCacheRead +
-        (usage.cacheWrite5mInputTokens / 1000000) * (pricing.inputCacheWrite5m ?? 0) +
-        (usage.cacheWrite1hInputTokens / 1000000) * (pricing.inputCacheWrite1h ?? 0) +
-        (usage.outputTokens / 1000000) * pricing.output) * USD_TO_CREDITS;
+    return ((usage.inputTokens / 1000000) * rates.input +
+        (usage.cacheReadInputTokens / 1000000) * rates.inputCacheRead +
+        (usage.cacheWrite5mInputTokens / 1000000) * (rates.inputCacheWrite5m ?? 0) +
+        (usage.cacheWrite1hInputTokens / 1000000) * (rates.inputCacheWrite1h ?? 0) +
+        (usage.outputTokens / 1000000) * rates.output) * USD_TO_CREDITS;
 }
 async function fetchCached(request) {
     const key = JSON.stringify(request);

package/ink-app/dist/reporting.js

@@ -2,12 +2,17 @@ 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";
+import { isPartialUsagePairing, 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
 // worth reporting, so they are dropped from the anonymous usage payload.
 const SKIP_REPORT_USED_PERCENTS = 3;
+// Name of the catch-all limit class: the window meters every model the plan
+// offers, rather than one carved-out family.
+const ALL_LIMIT_CLASS = "All";
+// Mirrors the reporting endpoint's schema, which caps `limit_class` at 64.
+const LIMIT_CLASS_MAX_LENGTH = 64;
 let versionCache = null;
 export async function reportAnonymousUsage(statsList) {
     const payload = await buildAnonymousUsagePayload(statsList);
@@ -36,6 +41,7 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
     return {
         agent: stats.analytics?.agentName ?? stats.providerLabel.replace(/\s+/g, ""),
         model_type: resolveReportModelType(stats, window),
+        limit_class: resolveReportLimitClass(stats, window),
         userid_hash: stats.analytics?.userIdHash ?? "",
         plan_id: window.planType,
         window_duration_seconds: window.windowMinutes * 60,
@@ -48,6 +54,52 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         letmecode_version: letmecodeVersion
     };
 }
+/**
+ * Canonical, display-ready name of the limit class a window belongs to.
+ * Every provider words the same idea differently - Antigravity separates Gemini
+ * from third-party models, Claude carves a model family out of the weekly
+ * window - so letmecode folds them onto one vocabulary and consumers never have
+ * to learn the provider-specific spellings in `model_type`.
+ *
+ * The vocabulary is open: a class nobody has seen before is reported under its
+ * own name rather than forced into an existing bucket.
+ */
+function resolveReportLimitClass(stats, window) {
+    if (stats.providerId === "claude") {
+        const modelFamily = window.modelType?.toLowerCase().replace(/\s+only$/, "").trim();
+        return modelFamily ? toLimitClassName(modelFamily) : ALL_LIMIT_CLASS;
+    }
+    if (stats.providerId === "antigravity") {
+        const limitId = window.limitId.toLowerCase();
+        if (limitId.includes("gemini")) {
+            return "Main";
+        }
+        if (limitId.startsWith("3p") || limitId.includes("third-party")) {
+            return "Other";
+        }
+        return toLimitClassName(window.limitId);
+    }
+    if (stats.providerId === "copilot") {
+        // Copilot quota labels ("AI Credits", "Premium requests") are already the
+        // name of the bucket they meter.
+        return window.modelType ? toLimitClassName(window.modelType) : ALL_LIMIT_CLASS;
+    }
+    // Codex, and anything else, meters every model against one shared allowance.
+    return ALL_LIMIT_CLASS;
+}
+/**
+ * Title-case a provider string into a class name, leaving words that already
+ * carry capitals alone so acronyms such as "AI Credits" survive intact.
+ */
+function toLimitClassName(value) {
+    const name = value
+        .trim()
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => (/[A-Z]/.test(word) ? word : word.charAt(0).toUpperCase() + word.slice(1)))
+        .join(" ");
+    return name ? truncateSchemaString(name, LIMIT_CLASS_MAX_LENGTH) : ALL_LIMIT_CLASS;
+}
 function resolveReportModelType(stats, window) {
     if (stats.providerId === "antigravity") {
         return resolveAntigravityReportModelType(stats, window);
@@ -104,6 +156,9 @@ function resolveReportedUsedPercents(window) {
 }
 function shouldReportUsageWindow(window) {
     return (window.totals.estimatedCreditsStatus !== "unavailable" &&
+        // A window whose percentage restarted mid-window pairs a full percentage
+        // with partial dollars, which would skew every aggregate built from it.
+        !isPartialUsagePairing(window) &&
         resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS);
 }
 function clampPercent(value) {

package/package.json

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