@leo000001/opencode-quota-sidebar 1.13.10 → 2.0.1

package/dist/usage.d.ts

@@ -1,6 +1,12 @@
 import type { AssistantMessage, Message } from '@opencode-ai/sdk';
-import type { CachedSessionUsage, IncrementalCursor } from './types.js';
-export declare const USAGE_BILLING_CACHE_VERSION = 2;
+import type { CacheCoverageMetrics, CacheCoverageMode, CacheUsageBuckets, CachedSessionUsage, IncrementalCursor } from './types.js';
+/**
+ * Billing cache version — bump this whenever the persisted `CachedSessionUsage`
+ * shape changes in a way that requires recomputation (e.g. new aggregate
+ * fields).  This is distinct from the plugin *state* version managed by the
+ * persistence layer; billing version only governs usage-cache staleness.
+ */
+export declare const USAGE_BILLING_CACHE_VERSION = 4;
 export type ProviderUsage = {
     providerID: string;
     input: number;
@@ -26,16 +32,23 @@ export type UsageSummary = {
     apiCost: number;
     assistantMessages: number;
     sessionCount: number;
+    cacheBuckets?: CacheUsageBuckets;
     providers: Record<string, ProviderUsage>;
 };
 export type UsageOptions = {
     /** Equivalent API cost calculator for the message. */
     calcApiCost?: (message: AssistantMessage) => number;
+    /** Cache-behavior classifier for the message model/provider. */
+    classifyCacheMode?: (message: AssistantMessage) => CacheCoverageMode;
 };
+export declare function getCacheCoverageMetrics(usage: Pick<UsageSummary, 'input' | 'cacheRead' | 'cacheWrite' | 'assistantMessages' | 'cacheBuckets'>): CacheCoverageMetrics;
 export declare function emptyUsageSummary(): UsageSummary;
 export declare function summarizeMessages(entries: Array<{
     info: Message;
 }>, startAt?: number, sessionCount?: number, options?: UsageOptions): UsageSummary;
+export declare function summarizeMessagesInCompletedRange(entries: Array<{
+    info: Message;
+}>, startAt: number, endAt: number, sessionCount?: number, options?: UsageOptions): UsageSummary;
 /**
  * P1: Incremental usage aggregation.
  * Only processes messages newer than the cursor. Returns updated cursor.

package/dist/usage.js

@@ -1,4 +1,125 @@
-export const USAGE_BILLING_CACHE_VERSION = 2;
+/**
+ * Billing cache version — bump this whenever the persisted `CachedSessionUsage`
+ * shape changes in a way that requires recomputation (e.g. new aggregate
+ * fields).  This is distinct from the plugin *state* version managed by the
+ * persistence layer; billing version only governs usage-cache staleness.
+ */
+export const USAGE_BILLING_CACHE_VERSION = 4;
+function emptyCacheUsageBucket() {
+    return {
+        input: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        assistantMessages: 0,
+    };
+}
+function emptyCacheUsageBuckets() {
+    return {
+        readOnly: emptyCacheUsageBucket(),
+        readWrite: emptyCacheUsageBucket(),
+    };
+}
+function cloneCacheUsageBucket(bucket) {
+    return {
+        input: bucket?.input ?? 0,
+        cacheRead: bucket?.cacheRead ?? 0,
+        cacheWrite: bucket?.cacheWrite ?? 0,
+        assistantMessages: bucket?.assistantMessages ?? 0,
+    };
+}
+function cloneCacheUsageBuckets(buckets) {
+    if (!buckets)
+        return undefined;
+    return {
+        readOnly: cloneCacheUsageBucket(buckets.readOnly),
+        readWrite: cloneCacheUsageBucket(buckets.readWrite),
+    };
+}
+function mergeCacheUsageBucket(target, source) {
+    if (!source)
+        return target;
+    target.input += source.input;
+    target.cacheRead += source.cacheRead;
+    target.cacheWrite += source.cacheWrite;
+    target.assistantMessages += source.assistantMessages;
+    return target;
+}
+function addMessageCacheUsage(target, message) {
+    target.input += message.tokens.input;
+    target.cacheRead += message.tokens.cache.read;
+    target.cacheWrite += message.tokens.cache.write;
+    target.assistantMessages += 1;
+}
+/**
+ * Best-effort fallback for legacy cached data that lacks per-message cache
+ * buckets.  When `cacheWrite > 0` we assume all tokens came from a read-write
+ * model (Anthropic-like); when only `cacheRead > 0` we assume read-only
+ * (OpenAI-like).  Mixed-provider sessions that were cached before v3 will be
+ * attributed to a single bucket — this is a known limitation; new sessions
+ * classify per-message and are not affected.
+ */
+function fallbackCacheUsageBuckets(usage) {
+    if (usage.cacheWrite > 0) {
+        return {
+            readOnly: emptyCacheUsageBucket(),
+            readWrite: {
+                input: usage.input,
+                cacheRead: usage.cacheRead,
+                cacheWrite: usage.cacheWrite,
+                assistantMessages: usage.assistantMessages,
+            },
+        };
+    }
+    if (usage.cacheRead > 0) {
+        return {
+            readOnly: {
+                input: usage.input,
+                cacheRead: usage.cacheRead,
+                cacheWrite: 0,
+                assistantMessages: usage.assistantMessages,
+            },
+            readWrite: emptyCacheUsageBucket(),
+        };
+    }
+    return undefined;
+}
+function resolvedCacheUsageBuckets(usage) {
+    const explicit = cloneCacheUsageBuckets(usage.cacheBuckets);
+    if (!explicit) {
+        return cloneCacheUsageBuckets(fallbackCacheUsageBuckets(usage)) || emptyCacheUsageBuckets();
+    }
+    const accountedInput = explicit.readOnly.input + explicit.readWrite.input;
+    const accountedCacheRead = explicit.readOnly.cacheRead + explicit.readWrite.cacheRead;
+    const accountedCacheWrite = explicit.readOnly.cacheWrite + explicit.readWrite.cacheWrite;
+    const accountedAssistantMessages = explicit.readOnly.assistantMessages + explicit.readWrite.assistantMessages;
+    const residual = fallbackCacheUsageBuckets({
+        input: Math.max(0, usage.input - accountedInput),
+        cacheRead: Math.max(0, usage.cacheRead - accountedCacheRead),
+        cacheWrite: Math.max(0, usage.cacheWrite - accountedCacheWrite),
+        assistantMessages: Math.max(0, usage.assistantMessages - accountedAssistantMessages),
+    });
+    if (residual) {
+        mergeCacheUsageBucket(explicit.readOnly, residual.readOnly);
+        mergeCacheUsageBucket(explicit.readWrite, residual.readWrite);
+    }
+    return explicit;
+}
+export function getCacheCoverageMetrics(usage) {
+    const buckets = resolvedCacheUsageBuckets(usage);
+    const readWritePromptSurface = buckets.readWrite.input +
+        buckets.readWrite.cacheRead +
+        buckets.readWrite.cacheWrite;
+    const readOnlyPromptSurface = buckets.readOnly.input + buckets.readOnly.cacheRead;
+    return {
+        cacheCoverage: readWritePromptSurface > 0
+            ? (buckets.readWrite.cacheRead + buckets.readWrite.cacheWrite) /
+                readWritePromptSurface
+            : undefined,
+        cacheReadCoverage: readOnlyPromptSurface > 0
+            ? buckets.readOnly.cacheRead / readOnlyPromptSurface
+            : undefined,
+    };
+}
 export function emptyUsageSummary() {
     return {
         input: 0,
@@ -69,18 +190,47 @@ function addMessageUsage(target, message, options) {
     provider.apiCost += apiCost;
     provider.assistantMessages += 1;
     target.providers[message.providerID] = provider;
+    const cacheMode = options?.classifyCacheMode?.(message) || 'none';
+    if (cacheMode === 'read-only') {
+        const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(buckets.readOnly, message);
+    }
+    else if (cacheMode === 'read-write') {
+        const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(buckets.readWrite, message);
+    }
+}
+function completedTimeOf(message) {
+    const completed = message.time.completed;
+    if (typeof completed !== 'number')
+        return undefined;
+    if (!Number.isFinite(completed))
+        return undefined;
+    return completed;
+}
+function isCompletedAssistantInRange(message, startAt = 0, endAt = Number.POSITIVE_INFINITY) {
+    if (!isAssistant(message))
+        return false;
+    const completed = completedTimeOf(message);
+    if (completed === undefined)
+        return false;
+    return completed >= startAt && completed <= endAt;
 }
 export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
     const summary = emptyUsageSummary();
     summary.sessionCount = sessionCount;
     for (const entry of entries) {
-        if (!isAssistant(entry.info))
-            continue;
-        if (typeof entry.info.time.completed !== 'number')
+        if (!isCompletedAssistantInRange(entry.info, startAt))
             continue;
-        if (!Number.isFinite(entry.info.time.completed))
-            continue;
-        if (entry.info.time.created < startAt)
+        addMessageUsage(summary, entry.info, options);
+    }
+    return summary;
+}
+export function summarizeMessagesInCompletedRange(entries, startAt, endAt, sessionCount = 1, options) {
+    const summary = emptyUsageSummary();
+    summary.sessionCount = sessionCount;
+    for (const entry of entries) {
+        if (!isCompletedAssistantInRange(entry.info, startAt, endAt))
             continue;
         addMessageUsage(summary, entry.info, options);
     }
@@ -276,6 +426,12 @@ export function mergeUsage(target, source, options) {
     target.apiCost += source.apiCost;
     target.assistantMessages += source.assistantMessages;
     target.sessionCount += source.sessionCount;
+    const sourceBuckets = source.cacheBuckets;
+    if (sourceBuckets) {
+        const targetBuckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+        mergeCacheUsageBucket(targetBuckets.readOnly, sourceBuckets.readOnly);
+        mergeCacheUsageBucket(targetBuckets.readWrite, sourceBuckets.readWrite);
+    }
     for (const provider of Object.values(source.providers)) {
         const existing = target.providers[provider.providerID] ||
             emptyProviderUsage(provider.providerID);
@@ -321,12 +477,14 @@ export function toCachedSessionUsage(summary) {
         cost: summary.cost,
         apiCost: summary.apiCost,
         assistantMessages: summary.assistantMessages,
+        cacheBuckets: cloneCacheUsageBuckets(summary.cacheBuckets),
         providers,
     };
 }
 export function fromCachedSessionUsage(cached, sessionCount = 1) {
     // Merge cached reasoning into output for a single output metric.
     const mergedOutputValue = cached.output + cached.reasoning;
+    const cacheBuckets = cloneCacheUsageBuckets(cached.cacheBuckets);
     return {
         input: cached.input,
         output: mergedOutputValue,
@@ -338,6 +496,7 @@ export function fromCachedSessionUsage(cached, sessionCount = 1) {
         apiCost: cached.apiCost || 0,
         assistantMessages: cached.assistantMessages,
         sessionCount,
+        cacheBuckets,
         providers: Object.entries(cached.providers).reduce((acc, [providerID, provider]) => {
             acc[providerID] = {
                 providerID,

package/dist/usage_service.js

@@ -1,9 +1,15 @@
 import { TtlValueCache } from './cache.js';
-import { calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.js';
+import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
+import { dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
-import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesInCompletedRange, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+const READ_ONLY_CACHE_PROVIDERS = new Set([
+    'openai',
+    'github-copilot',
+    'venice',
+    'openrouter',
+]);
 export function createUsageService(deps) {
     const forceRescanSessions = new Set();
     const dirtyGeneration = new Map();
@@ -12,6 +18,8 @@ export function createUsageService(deps) {
         dirtyGeneration.set(sessionID, (dirtyGeneration.get(sessionID) || 0) + 1);
     };
     const isDirty = (sessionID) => {
+        if (deps.state.sessions[sessionID]?.dirty)
+            return true;
         return ((dirtyGeneration.get(sessionID) || 0) !==
             (cleanGeneration.get(sessionID) || 0));
     };
@@ -48,13 +56,10 @@ export function createUsageService(deps) {
         const map = all.reduce((acc, provider) => {
             if (!isRecord(provider))
                 return acc;
-            const providerID = typeof provider.id === 'string'
-                ? canonicalApiCostProviderID(provider.id)
-                : undefined;
-            if (!providerID)
-                return acc;
-            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
+            const rawProviderID = typeof provider.id === 'string' ? provider.id : undefined;
+            if (!rawProviderID)
                 return acc;
+            const canonicalProviderID = canonicalApiCostProviderID(rawProviderID);
             const models = provider.models;
             if (!isRecord(models))
                 return acc;
@@ -65,9 +70,15 @@ export function createUsageService(deps) {
                 if (!rates)
                     continue;
                 const modelID = typeof modelValue.id === 'string' ? modelValue.id : modelKey;
-                acc[modelCostKey(providerID, modelID)] = rates;
+                acc[modelCostKey(rawProviderID, modelID)] = rates;
                 if (modelKey !== modelID) {
-                    acc[modelCostKey(providerID, modelKey)] = rates;
+                    acc[modelCostKey(rawProviderID, modelKey)] = rates;
+                }
+                if (canonicalProviderID !== rawProviderID) {
+                    acc[modelCostKey(canonicalProviderID, modelID)] = rates;
+                    if (modelKey !== modelID) {
+                        acc[modelCostKey(canonicalProviderID, modelKey)] = rates;
+                    }
                 }
             }
             return acc;
@@ -78,7 +89,8 @@ export function createUsageService(deps) {
         const providerID = canonicalApiCostProviderID(message.providerID);
         if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
             return 0;
-        const rates = modelCostMap[modelCostKey(providerID, message.modelID)];
+        const rates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
+            modelCostMap[modelCostKey(providerID, message.modelID)];
         if (!rates) {
             const key = modelCostKey(providerID, message.modelID);
             if (!missingApiCostRateKeys.has(key)) {
@@ -89,6 +101,36 @@ export function createUsageService(deps) {
         }
         return calcEquivalentApiCostForMessage(message, rates);
     };
+    const classifyCacheMode = (message, modelCostMap) => {
+        const canonicalProviderID = canonicalApiCostProviderID(message.providerID);
+        const baseRates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
+            modelCostMap[modelCostKey(canonicalProviderID, message.modelID)];
+        const effectiveRates = baseRates &&
+            message.tokens.input + message.tokens.cache.read > 200_000 &&
+            baseRates.contextOver200k
+            ? baseRates.contextOver200k
+            : baseRates;
+        const fromRates = cacheCoverageModeFromRates(effectiveRates);
+        if (fromRates !== 'none')
+            return fromRates;
+        if (message.tokens.cache.write > 0)
+            return 'read-write';
+        if (message.tokens.cache.read <= 0)
+            return 'none';
+        const rawProviderID = message.providerID.toLowerCase();
+        if (READ_ONLY_CACHE_PROVIDERS.has(canonicalProviderID) ||
+            READ_ONLY_CACHE_PROVIDERS.has(rawProviderID)) {
+            return 'read-only';
+        }
+        // Heuristic fallback: classify by provider identity when pricing is missing.
+        if (canonicalProviderID === 'anthropic' ||
+            message.modelID.toLowerCase().includes('claude')) {
+            return 'read-write';
+        }
+        // Last resort: if the message has cache.read tokens from an unknown provider,
+        // treat it as read-only (the safer default — avoids inflating Cache Coverage).
+        return 'read-only';
+    };
     const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
     const decodeTokens = (value) => {
         if (!isRecord(value))
@@ -117,10 +159,6 @@ export function createUsageService(deps) {
             return undefined;
         if (typeof value.role !== 'string')
             return undefined;
-        if (typeof value.providerID !== 'string')
-            return undefined;
-        if (typeof value.modelID !== 'string')
-            return undefined;
         if (!isRecord(value.time))
             return undefined;
         if (!isFiniteNumber(value.time.created))
@@ -129,6 +167,19 @@ export function createUsageService(deps) {
             !isFiniteNumber(value.time.completed)) {
             return undefined;
         }
+        if (value.role !== 'assistant') {
+            return {
+                ...value,
+                time: {
+                    created: value.time.created,
+                    completed: value.time.completed,
+                },
+            };
+        }
+        if (typeof value.providerID !== 'string')
+            return undefined;
+        if (typeof value.modelID !== 'string')
+            return undefined;
         const tokens = decodeTokens(value.tokens);
         if (!tokens)
             return undefined;
@@ -194,6 +245,21 @@ export function createUsageService(deps) {
             return false;
         return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
     };
+    const hasStaleZeroApiCost = (cached, modelCostMap) => {
+        if (!cached)
+            return false;
+        if (cached.apiCost > 0)
+            return false;
+        return Object.entries(cached.providers).some(([providerID, provider]) => {
+            if (provider.apiCost > 0)
+                return false;
+            const canonicalProviderID = canonicalApiCostProviderID(providerID);
+            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(canonicalProviderID))
+                return false;
+            return Object.keys(modelCostMap).some((key) => key.startsWith(`${providerID}:`) ||
+                key.startsWith(`${canonicalProviderID}:`));
+        });
+    };
     const summarizeSessionUsage = async (sessionID, generationAtStart) => {
         const entries = await loadSessionEntries(sessionID);
         const sessionState = deps.state.sessions[sessionID];
@@ -212,7 +278,8 @@ export function createUsageService(deps) {
         }
         const modelCostMap = await getModelCostMap();
         const staleBillingCache = Boolean(sessionState?.usage) &&
-            !isUsageBillingCurrent(sessionState?.usage);
+            (!isUsageBillingCurrent(sessionState?.usage) ||
+                hasStaleZeroApiCost(sessionState?.usage, modelCostMap));
         const forceRescan = forceRescanSessions.has(sessionID) || staleBillingCache;
         if (forceRescan)
             forceRescanSessions.delete(sessionID);
@@ -221,11 +288,13 @@ export function createUsageService(deps) {
         }
         const { usage, cursor } = summarizeMessagesIncremental(entries, sessionState?.usage, sessionState?.cursor, forceRescan, {
             calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+            classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
         });
         usage.sessionCount = 1;
         // Update cursor in state
         if (sessionState) {
             sessionState.cursor = cursor;
+            sessionState.dirty = false;
         }
         if ((dirtyGeneration.get(sessionID) || 0) === generationAtStart) {
             cleanGeneration.set(sessionID, generationAtStart);
@@ -261,11 +330,16 @@ export function createUsageService(deps) {
     const summarizeSessionUsageForDisplay = async (sessionID, includeChildren) => {
         const root = await summarizeSessionUsageLocked(sessionID);
         const usage = root.usage;
+        let dirty = false;
         if (root.persist) {
             persistSessionUsage(sessionID, toCachedSessionUsage(usage));
+            dirty = true;
         }
-        if (!includeChildren)
+        if (!includeChildren) {
+            if (dirty)
+                deps.persistence.scheduleSave();
             return usage;
+        }
         const descendantIDs = await deps.descendantsResolver.listDescendantSessionIDs(sessionID, {
             maxDepth: deps.config.sidebar.childrenMaxDepth,
             maxSessions: deps.config.sidebar.childrenMaxSessions,
@@ -294,6 +368,7 @@ export function createUsageService(deps) {
                 const child = await summarizeSessionUsageLocked(childID);
                 if (child.persist) {
                     persistSessionUsage(childID, toCachedSessionUsage(child.usage));
+                    dirty = true;
                 }
                 return child.usage;
             });
@@ -301,15 +376,17 @@ export function createUsageService(deps) {
                 mergeUsage(merged, childUsage, { includeCost: false });
             }
         }
+        if (dirty)
+            deps.persistence.scheduleSave();
         return merged;
     };
     const RANGE_USAGE_CONCURRENCY = 5;
     const summarizeRangeUsage = async (period) => {
         const startAt = periodStart(period);
+        const endAt = Date.now();
         await deps.persistence.flushSave();
-        const sessions = await scanSessionsByCreatedRange(deps.statePath, startAt, Date.now(), deps.state);
+        const sessions = await scanAllSessions(deps.statePath, deps.state);
         const usage = emptyUsageSummary();
-        usage.sessionCount = sessions.length;
         const modelCostMap = await getModelCostMap();
         const hasPricing = Object.keys(modelCostMap).length > 0;
         const hasAnySubscriptionProvider = (cached) => {
@@ -338,61 +415,78 @@ export function createUsageService(deps) {
                 return false;
             return true;
         };
-        const needsFetch = [];
-        for (const session of sessions) {
-            if (session.state.usage) {
-                if (shouldRecomputeUsageCache(session.state.usage)) {
-                    needsFetch.push(session);
-                }
-                else {
-                    mergeUsage(usage, fromCachedSessionUsage(session.state.usage, 0));
-                }
-            }
-            else {
-                needsFetch.push(session);
-            }
-        }
-        if (needsFetch.length > 0) {
-            const fetched = await mapConcurrent(needsFetch, RANGE_USAGE_CONCURRENCY, async (session) => {
+        if (sessions.length > 0) {
+            const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
                 const entries = await loadSessionEntries(session.sessionID);
                 if (!entries) {
-                    if (session.state.usage) {
-                        return {
-                            sessionID: session.sessionID,
-                            dateKey: session.dateKey,
-                            computed: fromCachedSessionUsage(session.state.usage, 1),
-                            persist: false,
-                            cursor: session.state.cursor,
-                        };
-                    }
-                    const empty = emptyUsageSummary();
-                    empty.sessionCount = 1;
                     return {
                         sessionID: session.sessionID,
                         dateKey: session.dateKey,
-                        computed: empty,
+                        createdAt: session.state.createdAt,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        computed: emptyUsageSummary(),
+                        fullUsage: undefined,
+                        loadFailed: true,
                         persist: false,
                         cursor: undefined,
                     };
                 }
-                const { usage: computed, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
+                const computed = summarizeMessagesInCompletedRange(entries, startAt, endAt, 0, {
+                    calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
+                });
+                const shouldPersistFullUsage = !session.state.usage || shouldRecomputeUsageCache(session.state.usage);
+                if (!shouldPersistFullUsage) {
+                    return {
+                        sessionID: session.sessionID,
+                        dateKey: session.dateKey,
+                        createdAt: session.state.createdAt,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        computed,
+                        fullUsage: undefined,
+                        loadFailed: false,
+                        persist: false,
+                        cursor: session.state.cursor,
+                    };
+                }
+                const { usage: fullUsage, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
                 return {
                     sessionID: session.sessionID,
                     dateKey: session.dateKey,
+                    createdAt: session.state.createdAt,
+                    lastMessageTime: cursor.lastMessageTime,
                     computed,
+                    fullUsage,
+                    loadFailed: false,
                     persist: true,
                     cursor,
                 };
             });
+            const failedLoads = fetched.filter((item) => {
+                if (!item.loadFailed)
+                    return false;
+                const lastMessageTime = item.lastMessageTime;
+                if (typeof lastMessageTime === 'number' && lastMessageTime < startAt) {
+                    return false;
+                }
+                return true;
+            });
+            if (failedLoads.length > 0) {
+                throw new Error(`range usage unavailable: failed to load ${failedLoads.length} session(s)`);
+            }
             let dirty = false;
             const diskOnlyUpdates = [];
-            for (const { sessionID, dateKey, computed, persist, cursor } of fetched) {
-                mergeUsage(usage, { ...computed, sessionCount: 0 });
+            for (const { sessionID, dateKey, computed, fullUsage, persist, cursor } of fetched) {
+                if (computed.assistantMessages > 0) {
+                    computed.sessionCount = 1;
+                    mergeUsage(usage, computed);
+                }
                 const memoryState = deps.state.sessions[sessionID];
-                if (persist && memoryState) {
-                    memoryState.usage = toCachedSessionUsage(computed);
+                if (persist && fullUsage && memoryState) {
+                    memoryState.usage = toCachedSessionUsage(fullUsage);
                     memoryState.cursor = cursor;
                     const resolvedDateKey = deps.state.sessionDateMap[sessionID] ||
                         dateKeyFromTimestamp(memoryState.createdAt);
@@ -400,11 +494,11 @@ export function createUsageService(deps) {
                     deps.persistence.markDirty(resolvedDateKey);
                     dirty = true;
                 }
-                else if (persist) {
+                else if (persist && fullUsage) {
                     diskOnlyUpdates.push({
                         sessionID,
                         dateKey,
-                        usage: toCachedSessionUsage(computed),
+                        usage: toCachedSessionUsage(fullUsage),
                         cursor,
                     });
                 }
@@ -425,6 +519,15 @@ export function createUsageService(deps) {
     };
     const markSessionDirty = (sessionID) => {
         bumpDirty(sessionID);
+        const sessionState = deps.state.sessions[sessionID];
+        if (sessionState && !sessionState.dirty) {
+            sessionState.dirty = true;
+            const dateKey = deps.state.sessionDateMap[sessionID] ||
+                dateKeyFromTimestamp(sessionState.createdAt);
+            deps.state.sessionDateMap[sessionID] = dateKey;
+            deps.persistence.markDirty(dateKey);
+            deps.persistence.scheduleSave();
+        }
     };
     const markForceRescan = (sessionID) => {
         forceRescanSessions.add(sessionID);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "1.13.10",
+  "version": "2.0.1",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",