letmecode 0.1.20 → 0.1.22

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

@@ -10,12 +10,26 @@ import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregate
 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-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 },
@@ -46,12 +60,14 @@ const parsedClaudeSessionFilesCache = new Map();
 const claudeBinaryPathCache = new Map();
 const claudeUsageOutputCache = new Map();
 const claudeAuthStatusOutputCache = new Map();
+const claudeOauthCredentialsOutputCache = new Map();
 export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super(options.id ?? "claude", options.label ?? "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
         this.readUsageCommandOutput = options.readUsageCommandOutput;
         this.readAuthStatusOutput = options.readAuthStatusOutput;
+        this.readOauthCredentials = options.readOauthCredentials;
         this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
@@ -82,7 +98,6 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 `malformed=${file.malformedLines}`,
                 `assistantUsageEvents=${file.events.length}`,
                 `matchingEvents=${matchingEvents.length}`,
-                `source=${file.sourceKind}`,
                 `entrypoints=${summarizeEventCounts(file.events.map((event) => event.entrypoint || "<empty>"))}`,
                 `models=${summarizeDistinctValues(file.events.map((event) => event.modelId || "unknown"))}`
             ].join(" "));
@@ -125,7 +140,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             warnings.push(`Collapsed ${parsedEvents.duplicateUsageKeys} duplicate Claude usage event(s) by request/message key.`);
         }
         if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
-            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; merged same-key rows by per-field maxima to avoid double-counting cumulative snapshots.`);
+            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.`);
@@ -148,7 +163,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const liveLimitWindows = await buildLiveLimitWindows({
             root: this.root,
             readUsageCommandOutput: this.readUsageCommandOutput,
-            readAuthStatusOutput: this.readAuthStatusOutput,
+            readOauthCredentials: this.readOauthCredentials,
             traceLogger: options.traceLogger,
             now: this.now(),
             selectedEvents
@@ -213,14 +228,14 @@ function normalizeUsage(value) {
         inferenceGeo: String(usage.inference_geo ?? "")
     };
 }
-function resolveRate(modelId) {
-    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true });
+function resolveRate(modelId, timestampMs) {
+    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true, timestampMs });
 }
 function isInternalClaudeModel(modelId) {
     return modelId === "<synthetic>";
 }
-function creditsFor(modelId, usage) {
-    const rate = resolveRate(modelId);
+function creditsFor(modelId, usage, timestampMs) {
+    const rate = resolveRate(modelId, timestampMs);
     if (!rate) {
         return 0;
     }
@@ -234,7 +249,7 @@ function creditsFor(modelId, usage) {
         inferenceMultiplier *
         USD_TO_CREDITS);
 }
-function usageToTotals(modelId, usage) {
+function usageToTotals(modelId, usage, timestampMs) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
         cacheWriteBreakdown.cacheWrite1hInputTokens;
@@ -250,7 +265,7 @@ function usageToTotals(modelId, usage) {
             usage.cacheReadInputTokens +
             cacheWriteInputTokens +
             usage.outputTokens,
-        estimatedCredits: creditsFor(modelId, usage),
+        estimatedCredits: creditsFor(modelId, usage, timestampMs),
         eventCount: 1
     };
 }
@@ -387,26 +402,20 @@ async function loadParsedClaudeSessionFiles(sessionsRoot, traceLogger) {
         const files = [];
         traceClaude(traceLogger, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
-            files.push(await parseSessionFile(filePath, sessionsRoot));
+            files.push(await parseSessionFile(filePath));
         }
-        inferClaudeSessionFileSources(files);
         traceClaude(traceLogger, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
         return files;
     })();
     parsedClaudeSessionFilesCache.set(cacheKey, pending);
     return pending;
 }
-async function parseSessionFile(filePath, sessionsRoot) {
+async function parseSessionFile(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
     let malformedLines = 0;
     const events = [];
-    const assistantEntryPoints = new Set();
-    let hasIdeOpenedFileAttachment = false;
-    let hasIdeOpenedFileMarker = false;
-    let hasIdeTooling = false;
-    let hasQueueOperations = false;
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -420,19 +429,6 @@ async function parseSessionFile(filePath, sessionsRoot) {
             malformedLines += 1;
             continue;
         }
-        if (payloadObject.type === "queue-operation") {
-            hasQueueOperations = true;
-        }
-        if (messageContainsIdeOpenedFileMarker(asRecord(payloadObject.message))) {
-            hasIdeOpenedFileMarker = true;
-        }
-        const attachment = asRecord(payloadObject.attachment);
-        if (attachment?.type === "opened_file_in_ide") {
-            hasIdeOpenedFileAttachment = true;
-        }
-        if (attachmentHasIdeTooling(attachment)) {
-            hasIdeTooling = true;
-        }
         if (payloadObject.type !== "assistant") {
             continue;
         }
@@ -448,7 +444,6 @@ async function parseSessionFile(filePath, sessionsRoot) {
         const normalizedUsage = normalizeUsage(usage);
         const usageKeys = buildUsageEventKeys(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
-        assistantEntryPoints.add(entrypoint);
         events.push({
             entrypoint,
             filePath,
@@ -458,106 +453,17 @@ async function parseSessionFile(filePath, sessionsRoot) {
             timestampMs: eventTimeMs,
             modelId,
             usage: normalizedUsage,
-            totals: usageToTotals(modelId, normalizedUsage),
+            totals: usageToTotals(modelId, normalizedUsage, eventTimeMs),
             rateLimits
         });
     }
     return {
         filePath,
-        sessionGroupKey: buildClaudeSessionGroupKey(sessionsRoot, filePath),
         linesRead,
         malformedLines,
-        sourceKind: "unknown",
-        sourceReason: "unclassified",
-        signals: {
-            assistantEntryPoints: [...assistantEntryPoints].sort(),
-            hasIdeOpenedFileAttachment,
-            hasIdeOpenedFileMarker,
-            hasIdeTooling,
-            hasQueueOperations
-        },
         events
     };
 }
-function buildClaudeSessionGroupKey(sessionsRoot, filePath) {
-    const relativePath = path.relative(sessionsRoot, filePath);
-    if (!relativePath || relativePath.startsWith("..")) {
-        return filePath;
-    }
-    const normalizedRelativePath = relativePath.split(path.sep).join("/");
-    const subagentMatch = normalizedRelativePath.match(/^(.*\/[^/]+)\/subagents\/[^/]+\.jsonl$/);
-    if (subagentMatch?.[1]) {
-        return subagentMatch[1];
-    }
-    return normalizedRelativePath.replace(/\.jsonl$/i, "");
-}
-function inferClaudeSessionFileSources(files) {
-    const groups = new Map();
-    for (const file of files) {
-        const group = groups.get(file.sessionGroupKey) ?? {
-            assistantEntryPoints: new Set(),
-            hasIdeHints: false
-        };
-        for (const entrypoint of file.signals.assistantEntryPoints) {
-            group.assistantEntryPoints.add(entrypoint);
-        }
-        group.hasIdeHints =
-            group.hasIdeHints ||
-                file.signals.hasIdeOpenedFileAttachment ||
-                file.signals.hasIdeOpenedFileMarker ||
-                file.signals.hasIdeTooling ||
-                file.signals.hasQueueOperations;
-        groups.set(file.sessionGroupKey, group);
-    }
-    for (const file of files) {
-        const group = groups.get(file.sessionGroupKey);
-        const { kind, reason } = classifyClaudeSessionGroup(group);
-        file.sourceKind = kind;
-        file.sourceReason = reason;
-    }
-}
-function classifyClaudeSessionGroup(group) {
-    if (!group) {
-        return { kind: "unknown", reason: "missing session group signals" };
-    }
-    if (group.assistantEntryPoints.has("claude-vscode")) {
-        return { kind: "vscode", reason: "explicit claude-vscode entrypoint" };
-    }
-    if (group.assistantEntryPoints.has("sdk-cli") || group.assistantEntryPoints.has("claude")) {
-        return { kind: "cli", reason: "explicit sdk-cli/claude entrypoint" };
-    }
-    if (group.assistantEntryPoints.has("cli")) {
-        return group.hasIdeHints
-            ? { kind: "vscode", reason: "generic cli entrypoint with IDE session hints" }
-            : { kind: "cli", reason: "generic cli entrypoint without IDE session hints" };
-    }
-    return { kind: "unknown", reason: "no assistant entrypoints" };
-}
-function attachmentHasIdeTooling(attachment) {
-    if (attachment?.type !== "deferred_tools_delta") {
-        return false;
-    }
-    return extractStringArray(attachment.addedNames).some((name) => name.startsWith("mcp__ide__"));
-}
-function messageContainsIdeOpenedFileMarker(message) {
-    const content = message?.content;
-    if (typeof content === "string") {
-        return content.includes("<ide_opened_file>");
-    }
-    if (!Array.isArray(content)) {
-        return false;
-    }
-    return content.some((item) => {
-        const contentItem = asRecord(item);
-        return typeof contentItem?.text === "string" && contentItem.text.includes("<ide_opened_file>");
-    });
-}
-function extractStringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter((item) => typeof item === "string");
-}
 function buildUsageEventKeys(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
     const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
@@ -637,8 +543,14 @@ function recordParsedUsageEvent(parsedEvents, event) {
     }
 }
 function mergeParsedUsageEvents(previous, next) {
-    const mergedUsage = mergeClaudeUsage(previous.usage, next.usage);
-    const modelId = selectMergedEventModelId(previous, next);
+    // Same-key events are repeated/streamed snapshots of one logical request. Rather than
+    // synthesizing a field-wise maximum (which can fabricate token totals when a snapshot
+    // splits cache-write tokens across the 5m/1h buckets differently), keep the single most
+    // complete real snapshot and discard the rest.
+    const primaryEvent = selectMergedSnapshotEvent(previous, next);
+    const otherEvent = primaryEvent === previous ? next : previous;
+    const usage = primaryEvent.usage;
+    const modelId = selectMergedEventModelId(primaryEvent, otherEvent);
     const latestEvent = normalizeTimestamp(next.timestampMs) >= normalizeTimestamp(previous.timestampMs) ? next : previous;
     const sessionId = extractUsageKeySessionId(previous.usageKeys) || extractUsageKeySessionId(next.usageKeys);
     return {
@@ -646,38 +558,34 @@ function mergeParsedUsageEvents(previous, next) {
         filePath: latestEvent.filePath,
         lineNumber: latestEvent.lineNumber,
         usageKeys: [...new Set([...previous.usageKeys, ...next.usageKeys])],
-        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, mergedUsage),
+        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, usage),
         timestampMs: Math.max(normalizeTimestamp(previous.timestampMs), normalizeTimestamp(next.timestampMs)),
         modelId,
-        usage: mergedUsage,
-        totals: usageToTotals(modelId, mergedUsage),
+        usage,
+        totals: usageToTotals(modelId, usage, primaryEvent.timestampMs),
         rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
     };
 }
-function mergeClaudeUsage(previous, next) {
-    return {
-        inputTokens: Math.max(previous.inputTokens, next.inputTokens),
-        cacheReadInputTokens: Math.max(previous.cacheReadInputTokens, next.cacheReadInputTokens),
-        cacheCreationInputTokens: Math.max(previous.cacheCreationInputTokens, next.cacheCreationInputTokens),
-        cacheCreation5mInputTokens: Math.max(previous.cacheCreation5mInputTokens, next.cacheCreation5mInputTokens),
-        cacheCreation1hInputTokens: Math.max(previous.cacheCreation1hInputTokens, next.cacheCreation1hInputTokens),
-        outputTokens: Math.max(previous.outputTokens, next.outputTokens),
-        inferenceGeo: next.inferenceGeo || previous.inferenceGeo
-    };
-}
-function selectMergedEventModelId(previous, next) {
-    if (previous.modelId === next.modelId) {
-        return previous.modelId;
+// Pick the snapshot that carries the most usage. Cumulative snapshots are monotonic, so the
+// largest total is the final state; this also keeps a real synthetic-followup row (0 tokens)
+// from clobbering the real usage it follows. Ties fall back to the later, then the earlier-seen
+// event for deterministic output.
+function selectMergedSnapshotEvent(previous, next) {
+    if (next.totals.totalTokens !== previous.totals.totalTokens) {
+        return next.totals.totalTokens > previous.totals.totalTokens ? next : previous;
     }
-    if (isInternalClaudeModel(previous.modelId) && !isInternalClaudeModel(next.modelId)) {
-        return next.modelId;
+    return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs) ? next : previous;
+}
+function selectMergedEventModelId(primary, other) {
+    if (primary.modelId === other.modelId) {
+        return primary.modelId;
     }
-    if (isInternalClaudeModel(next.modelId) && !isInternalClaudeModel(previous.modelId)) {
-        return previous.modelId;
+    // The chosen snapshot's own model is authoritative, except when it is the internal
+    // <synthetic> placeholder and the other event names a real, priceable model.
+    if (isInternalClaudeModel(primary.modelId) && !isInternalClaudeModel(other.modelId)) {
+        return other.modelId;
     }
-    return next.totals.estimatedCredits >= previous.totals.estimatedCredits
-        ? next.modelId
-        : previous.modelId;
+    return primary.modelId;
 }
 function canCollapseAdjacentUnkeyedUsageEvents(previous, next) {
     return previous.filePath === next.filePath && next.lineNumber === previous.lineNumber + 1;
@@ -756,16 +664,16 @@ function buildClaudeCommandEnvironment() {
     };
 }
 async function buildLiveLimitWindows(options) {
-    const [usageOutput, subscriptionType] = await Promise.all([
+    const [usageOutput, credentials] = await Promise.all([
         readClaudeUsageCommandOutput(options.root, options.readUsageCommandOutput, options.traceLogger),
-        readClaudeSubscriptionType(options.root, options.readAuthStatusOutput, options.traceLogger)
+        readClaudeOauthCredentials(options.root, options.readOauthCredentials, options.traceLogger)
     ]);
     const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
     traceClaude(options.traceLogger, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
     if (snapshots.length === 0) {
         traceClaude(options.traceLogger, "No live usage snapshots matched the expected /usage format.");
     }
-    const resolvedPlanType = resolveClaudeLivePlanType(subscriptionType, snapshots);
+    const resolvedPlanType = resolveClaudeLivePlanType(credentials);
     traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
@@ -798,20 +706,82 @@ async function buildLiveLimitWindows(options) {
         secondaryLimitWindows
     };
 }
-function resolveClaudeLivePlanType(subscriptionType, snapshots) {
-    if (snapshots.some((snapshot) => snapshot.modelScope === "sonnet-only")) {
-        return "team_premium";
+// Reported as-is: the claude.ai OAuth `rateLimitTier` is not mapped to a friendly tier name
+// anymore, it is combined with `subscriptionType` verbatim (e.g. "team|default_claude_max_5x").
+function resolveClaudeLivePlanType(credentials) {
+    const subscriptionType = credentials?.subscriptionType;
+    if (!subscriptionType) {
+        return "live";
     }
-    return subscriptionType || "live";
+    return credentials?.rateLimitTier ? `${subscriptionType}|${credentials.rateLimitTier}` : subscriptionType;
 }
-async function readClaudeSubscriptionType(root, override, traceLogger) {
-    const output = await readClaudeAuthStatusOutput(root, override, traceLogger);
-    const subscriptionType = parseClaudeSubscriptionType(output);
-    if (output && !subscriptionType) {
-        traceClaude(traceLogger, "Could not parse subscription type from auth status output.");
-    }
-    traceClaude(traceLogger, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
-    return subscriptionType;
+async function readClaudeOauthCredentials(root, override, traceLogger) {
+    const output = await readClaudeOauthCredentialsOutput(root, override, traceLogger);
+    const credentials = parseClaudeOauthCredentials(output);
+    if (output && !credentials) {
+        traceClaude(traceLogger, "Could not parse claude.ai OAuth credentials from credentials file.");
+    }
+    traceClaude(traceLogger, `OAuth credentials result: subscriptionType=${credentials?.subscriptionType ?? "<none>"} rateLimitTier=${credentials?.rateLimitTier ?? "<none>"}.`);
+    return credentials;
+}
+async function readClaudeOauthCredentialsOutput(root, override, traceLogger) {
+    if (override) {
+        try {
+            const output = await override();
+            traceClaude(traceLogger, "Using injected OAuth credentials override.");
+            return output;
+        }
+        catch {
+            traceClaude(traceLogger, "Injected OAuth credentials override failed.");
+            return null;
+        }
+    }
+    const credentialsPath = path.join(path.resolve(root), ".claude", ".credentials.json");
+    const cacheKey = credentialsPath;
+    const cached = claudeOauthCredentialsOutputCache.get(cacheKey);
+    if (cached) {
+        traceClaude(traceLogger, "OAuth credentials cache hit.");
+        return cached;
+    }
+    const pending = (async () => {
+        try {
+            const output = await fs.promises.readFile(credentialsPath, { encoding: "utf8" });
+            traceClaude(traceLogger, `Read OAuth credentials from ${credentialsPath}.`);
+            return output;
+        }
+        catch {
+            traceClaude(traceLogger, `No readable OAuth credentials at ${credentialsPath}.`);
+            return null;
+        }
+    })();
+    claudeOauthCredentialsOutputCache.set(cacheKey, pending);
+    return pending;
+}
+function parseClaudeOauthCredentials(output) {
+    if (!output) {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+    const oauth = asRecord(asRecord(payload)?.claudeAiOauth);
+    if (!oauth) {
+        return null;
+    }
+    const subscriptionType = typeof oauth.subscriptionType === "string" && oauth.subscriptionType.trim()
+        ? oauth.subscriptionType.trim()
+        : null;
+    const rateLimitTier = typeof oauth.rateLimitTier === "string" && oauth.rateLimitTier.trim()
+        ? oauth.rateLimitTier.trim()
+        : null;
+    if (!subscriptionType && !rateLimitTier) {
+        return null;
+    }
+    return { subscriptionType, rateLimitTier };
 }
 async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     if (override) {
@@ -859,10 +829,6 @@ async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     claudeAuthStatusOutputCache.set(cacheKey, pending);
     return pending;
 }
-function parseClaudeSubscriptionType(output) {
-    const snapshot = parseClaudeAuthStatusSnapshot(output);
-    return snapshot?.subscriptionType ?? null;
-}
 function parseClaudeAuthStatusSnapshot(output) {
     if (!output) {
         return null;
@@ -1063,34 +1029,58 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
     if (!usageOutput) {
         return [];
     }
-    const snapshots = new Map();
     const normalizedOutput = usageOutput.replace(ANSI_ESCAPE_SEQUENCE, "");
+    const parsedLines = [];
     for (const line of normalizedOutput.split(/\r?\n/)) {
         const match = line
             .trim()
-            .match(/^Current\s+(session|week)(?:\s+\(([^)]+)\))?:\s+(\d+)%\s+used\b.*?\bresets\s+(.+)$/i);
+            .match(/^Current\s+(session|week)(?:\s+\(([^)]+)\))?:\s+(\d+)%\s+used\b(?:.*?\bresets\s+(.+))?$/i);
         if (!match) {
             continue;
         }
-        const label = match[1].toLowerCase() === "session" ? "session" : "week";
-        const windowQualifier = (match[2] ?? "").trim().toLowerCase();
         const usedPercent = Number(match[3]);
-        const windowMinutes = label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES;
-        const resetsAtMs = parseResetTimestampUtc(match[4], now.getTime(), windowMinutes);
-        if (!Number.isFinite(usedPercent) || !resetsAtMs) {
+        if (!Number.isFinite(usedPercent)) {
             continue;
         }
-        const isSonnetOnlyWeek = label === "week" && windowQualifier === "sonnet only";
-        const limitId = isSonnetOnlyWeek ? "current-week-sonnet-only" : `current-${label}`;
-        snapshots.set(limitId, {
-            scope: label === "session" ? "primary" : "secondary",
+        const label = match[1].toLowerCase() === "session" ? "session" : "week";
+        parsedLines.push({
             label,
-            limitId,
-            modelScope: isSonnetOnlyWeek ? "sonnet-only" : "all-models",
-            modelType: isSonnetOnlyWeek ? "sonnet only" : undefined,
+            windowQualifier: (match[2] ?? "").trim().toLowerCase(),
             usedPercent,
+            windowMinutes: label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES,
+            resetString: match[4]?.trim() || null
+        });
+    }
+    const resetMsByLabel = new Map();
+    for (const parsed of parsedLines) {
+        if (!parsed.resetString || resetMsByLabel.has(parsed.label)) {
+            continue;
+        }
+        const resetsAtMs = parseResetTimestampUtc(parsed.resetString, now.getTime(), parsed.windowMinutes);
+        if (resetsAtMs) {
+            resetMsByLabel.set(parsed.label, resetsAtMs);
+        }
+    }
+    const snapshots = new Map();
+    for (const parsed of parsedLines) {
+        const resetsAtMs = resetMsByLabel.get(parsed.label) ?? null;
+        if (!resetsAtMs) {
+            continue;
+        }
+        const isModelScopedWeek = parsed.label === "week" && parsed.windowQualifier !== "" && parsed.windowQualifier !== "all models";
+        const modelFamily = isModelScopedWeek ? parsed.windowQualifier.replace(/\s+only$/, "") : null;
+        const limitId = modelFamily
+            ? `current-week-${modelFamily.replace(/\s+/g, "-")}-only`
+            : `current-${parsed.label}`;
+        snapshots.set(limitId, {
+            scope: parsed.label === "session" ? "primary" : "secondary",
+            label: parsed.label,
+            limitId,
+            modelFamily,
+            modelType: modelFamily ? parsed.windowQualifier : undefined,
+            usedPercent: parsed.usedPercent,
             resetsAtMs,
-            windowMinutes
+            windowMinutes: parsed.windowMinutes
         });
     }
     return [...snapshots.values()].sort((left, right) => left.windowMinutes - right.windowMinutes || left.limitId.localeCompare(right.limitId));
@@ -1147,6 +1137,9 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         event.timestampMs < snapshot.resetsAtMs &&
         matchesClaudeLiveSnapshotModelScope(snapshot, event.modelId));
     const totals = sumUsageTotals(inWindowEvents.map((event) => event.totals));
+    if (snapshot.usedPercent > 0 && totals.eventCount === 0) {
+        totals.estimatedCreditsStatus = "unavailable";
+    }
     const fallbackLastSeenMs = Math.min(now.getTime(), snapshot.resetsAtMs);
     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);
@@ -1168,10 +1161,10 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
     };
 }
 function matchesClaudeLiveSnapshotModelScope(snapshot, modelId) {
-    if (snapshot.modelScope !== "sonnet-only") {
+    if (!snapshot.modelFamily) {
         return true;
     }
-    return modelId.toLowerCase().includes("sonnet");
+    return modelId.toLowerCase().includes(snapshot.modelFamily);
 }
 function buildModelUsageRowsForEvents(events) {
     const byModel = new Map();

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

@@ -32,8 +32,11 @@ export function addUsageTotals(target, source) {
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
-    if (source.cacheStatus === "unavailable") {
-        target.cacheStatus = "unavailable";
+    if (source.cacheReadStatus === "unavailable") {
+        target.cacheReadStatus = "unavailable";
+    }
+    if (source.cacheWriteStatus === "unavailable") {
+        target.cacheWriteStatus = "unavailable";
     }
     if (source.estimatedCreditsStatus === "unavailable") {
         target.estimatedCreditsStatus = "unavailable";

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

@@ -0,0 +1,55 @@
+import { resolveUsageRate } from "../pricing.js";
+/**
+ * Copilot-specific estimated API-equivalent rate card (micro-credits per
+ * million tokens). This is intentionally separate from the Codex and
+ * Antigravity rate cards — Copilot bills the same model families at different
+ * effective rates, so there is no single shared source of truth to reuse.
+ */
+export const RATE_CARD = {
+    "gpt-5-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 },
+    "gpt-5.3-codex": { input: 175, cacheRead: 17.5, cacheWrite: 175, cacheWrite5m: 175, cacheWrite1h: 175, output: 1400 },
+    "gpt-5.4": { input: 250, cacheRead: 25, cacheWrite: 250, cacheWrite5m: 250, cacheWrite1h: 250, output: 1500, longContext: { thresholdTokens: 272000, rate: { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 2250 } } },
+    "gpt-5.4-mini": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
+    "gpt-5.4-nano": { input: 20, cacheRead: 2, cacheWrite: 20, cacheWrite5m: 20, cacheWrite1h: 20, output: 125 },
+    "gpt-5.5": { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 3000, longContext: { thresholdTokens: 272000, rate: { input: 1000, cacheRead: 100, cacheWrite: 1000, cacheWrite5m: 1000, cacheWrite1h: 1000, output: 4500 } } },
+    "claude-haiku-4-5": { input: 100, cacheRead: 10, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 200, output: 500 },
+    "claude-sonnet-4-5": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
+    "claude-sonnet-4-6": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
+    "claude-opus-4-5": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-6": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-7": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-8": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-fable-5": { input: 1000, cacheRead: 100, cacheWrite: 1250, cacheWrite5m: 1250, cacheWrite1h: 2000, output: 5000 },
+    "gemini-2.5-pro": { input: 125, cacheRead: 12.5, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 125, output: 1000 },
+    "gemini-3-flash": { input: 50, cacheRead: 5, cacheWrite: 50, cacheWrite5m: 50, cacheWrite1h: 50, output: 300 },
+    "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.5-flash": { input: 150, cacheRead: 15, cacheWrite: 150, cacheWrite5m: 150, cacheWrite1h: 150, output: 900 },
+    "mai-code-1-flash": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
+    "raptor-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 }
+};
+/**
+ * Model id prefixes that Copilot does not bill (inline completions / next-edit
+ * suggestions). These are zero-rated rather than "unknown" so they never turn
+ * aggregate credit totals unknown.
+ */
+export const NON_BILLABLE_MODEL_PREFIXES = [
+    "copilot-nes",
+    "copilot-suggestion",
+    "copilot-suggestions"
+];
+/**
+ * Canonicalize a Copilot model id. The exporter already emits stable,
+ * human-readable ids (including dated suffixes like `gpt-5.4-2026-03-01`), and
+ * the dashboard surfaces those verbatim, so this only guards the empty case.
+ * Prefix-based rate resolution (see {@link rateForCopilotModel}) handles dated
+ * suffixes without collapsing the displayed id.
+ */
+export function normalizeCopilotModelId(modelId) {
+    return modelId || "unknown";
+}
+export function rateForCopilotModel(modelId, inputTokens) {
+    return resolveUsageRate(RATE_CARD, modelId, inputTokens, { prefixMatch: true });
+}
+export function isNonBillableCopilotModel(modelId) {
+    return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
+}