@leo000001/opencode-quota-sidebar 2.0.0 → 2.0.2

package/dist/usage.js

@@ -1,4 +1,10 @@
-export const USAGE_BILLING_CACHE_VERSION = 3;
+/**
+ * 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,
@@ -25,8 +31,8 @@ function cloneCacheUsageBuckets(buckets) {
     if (!buckets)
         return undefined;
     return {
-        readOnly: cloneCacheUsageBucket(buckets?.readOnly),
-        readWrite: cloneCacheUsageBucket(buckets?.readWrite),
+        readOnly: cloneCacheUsageBucket(buckets.readOnly),
+        readWrite: cloneCacheUsageBucket(buckets.readWrite),
     };
 }
 function mergeCacheUsageBucket(target, source) {
@@ -44,6 +50,14 @@ function addMessageCacheUsage(target, message) {
     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 {
@@ -70,8 +84,25 @@ function fallbackCacheUsageBuckets(usage) {
     return undefined;
 }
 function resolvedCacheUsageBuckets(usage) {
-    return (cloneCacheUsageBuckets(usage.cacheBuckets || fallbackCacheUsageBuckets(usage)) ||
-        emptyCacheUsageBuckets());
+    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);
@@ -89,6 +120,9 @@ export function getCacheCoverageMetrics(usage) {
             : undefined,
     };
 }
+export function getProviderCacheCoverageMetrics(usage) {
+    return getCacheCoverageMetrics(usage);
+}
 export function emptyUsageSummary() {
     return {
         input: 0,
@@ -101,7 +135,6 @@ export function emptyUsageSummary() {
         apiCost: 0,
         assistantMessages: 0,
         sessionCount: 0,
-        cacheBuckets: emptyCacheUsageBuckets(),
         providers: {},
     };
 }
@@ -117,6 +150,7 @@ function emptyProviderUsage(providerID) {
         cost: 0,
         apiCost: 0,
         assistantMessages: 0,
+        cacheBuckets: undefined,
     };
 }
 function isAssistant(message) {
@@ -164,23 +198,47 @@ function addMessageUsage(target, message, options) {
     if (cacheMode === 'read-only') {
         const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
         addMessageCacheUsage(buckets.readOnly, message);
+        const providerBuckets = (provider.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(providerBuckets.readOnly, message);
     }
     else if (cacheMode === 'read-write') {
         const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
         addMessageCacheUsage(buckets.readWrite, message);
+        const providerBuckets = (provider.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(providerBuckets.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))
+        if (!isCompletedAssistantInRange(entry.info, startAt))
             continue;
-        if (typeof entry.info.time.completed !== 'number')
-            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);
     }
@@ -376,9 +434,9 @@ export function mergeUsage(target, source, options) {
     target.apiCost += source.apiCost;
     target.assistantMessages += source.assistantMessages;
     target.sessionCount += source.sessionCount;
-    const targetBuckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
     const sourceBuckets = source.cacheBuckets;
     if (sourceBuckets) {
+        const targetBuckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
         mergeCacheUsageBucket(targetBuckets.readOnly, sourceBuckets.readOnly);
         mergeCacheUsageBucket(targetBuckets.readWrite, sourceBuckets.readWrite);
     }
@@ -395,6 +453,11 @@ export function mergeUsage(target, source, options) {
         }
         existing.apiCost += provider.apiCost;
         existing.assistantMessages += provider.assistantMessages;
+        if (provider.cacheBuckets) {
+            const providerBuckets = (existing.cacheBuckets ||= emptyCacheUsageBuckets());
+            mergeCacheUsageBucket(providerBuckets.readOnly, provider.cacheBuckets.readOnly);
+            mergeCacheUsageBucket(providerBuckets.readWrite, provider.cacheBuckets.readWrite);
+        }
         target.providers[provider.providerID] = existing;
     }
     return target;
@@ -412,6 +475,7 @@ export function toCachedSessionUsage(summary) {
             cost: provider.cost,
             apiCost: provider.apiCost,
             assistantMessages: provider.assistantMessages,
+            cacheBuckets: cloneCacheUsageBuckets(provider.cacheBuckets),
         };
         return acc;
     }, {});
@@ -459,6 +523,7 @@ export function fromCachedSessionUsage(cached, sessionCount = 1) {
                 cost: provider.cost,
                 apiCost: provider.apiCost || 0,
                 assistantMessages: provider.assistantMessages,
+                cacheBuckets: cloneCacheUsageBuckets(provider.cacheBuckets),
             };
             return acc;
         }, {}),

package/dist/usage_service.js

@@ -1,9 +1,15 @@
 import { TtlValueCache } from './cache.js';
 import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.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));
     };
@@ -109,13 +117,19 @@ export function createUsageService(deps) {
             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';
         }
-        if (canonicalProviderID === 'openai')
-            return 'read-only';
-        return 'none';
+        // 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) => {
@@ -145,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))
@@ -157,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;
@@ -187,6 +210,7 @@ export function createUsageService(deps) {
             .filter((item) => Boolean(item));
         if (decoded.length > 0 && decoded.length < value.length) {
             debug(`message entries partially decoded: kept ${decoded.length}/${value.length}`);
+            return undefined;
         }
         // If the API returned entries but none match the expected shape,
         // treat it as a load failure so we don't silently undercount.
@@ -222,7 +246,22 @@ export function createUsageService(deps) {
             return false;
         return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
     };
-    const summarizeSessionUsage = async (sessionID, generationAtStart) => {
+    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, options) => {
         const entries = await loadSessionEntries(sessionID);
         const sessionState = deps.state.sessions[sessionID];
         // If we can't load messages (transient API failure), fall back to cached
@@ -234,13 +273,17 @@ export function createUsageService(deps) {
                     persist: false,
                 };
             }
+            if (options?.requireEntries) {
+                throw new Error(`session usage unavailable: failed to load messages for ${sessionID}`);
+            }
             const empty = emptyUsageSummary();
             empty.sessionCount = 1;
             return { usage: empty, persist: false };
         }
         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);
@@ -255,13 +298,14 @@ export function createUsageService(deps) {
         // Update cursor in state
         if (sessionState) {
             sessionState.cursor = cursor;
+            sessionState.dirty = false;
         }
         if ((dirtyGeneration.get(sessionID) || 0) === generationAtStart) {
             cleanGeneration.set(sessionID, generationAtStart);
         }
         return { usage, persist: true };
     };
-    const summarizeSessionUsageLocked = async (sessionID) => {
+    const summarizeSessionUsageLocked = async (sessionID, options) => {
         for (let attempt = 0; attempt < 2; attempt++) {
             const generationAtStart = dirtyGeneration.get(sessionID) || 0;
             const existing = usageInFlight.get(sessionID);
@@ -271,13 +315,15 @@ export function createUsageService(deps) {
                     continue;
                 return result;
             }
-            const promise = summarizeSessionUsage(sessionID, generationAtStart);
+            const promise = summarizeSessionUsage(sessionID, generationAtStart, options);
             const entry = { generation: generationAtStart, promise };
-            promise.finally(() => {
+            void promise
+                .finally(() => {
                 const current = usageInFlight.get(sessionID);
                 if (current?.promise === promise)
                     usageInFlight.delete(sessionID);
-            });
+            })
+                .catch(() => undefined);
             usageInFlight.set(sessionID, entry);
             const result = await promise;
             if ((dirtyGeneration.get(sessionID) || 0) !== generationAtStart)
@@ -290,18 +336,26 @@ 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,
             concurrency: deps.config.sidebar.childrenConcurrency,
         });
-        if (descendantIDs.length === 0)
+        if (descendantIDs.length === 0) {
+            if (dirty)
+                deps.persistence.scheduleSave();
             return usage;
+        }
         const merged = emptyUsageSummary();
         mergeUsage(merged, usage);
         const needsFetch = [];
@@ -323,6 +377,7 @@ export function createUsageService(deps) {
                 const child = await summarizeSessionUsageLocked(childID);
                 if (child.persist) {
                     persistSessionUsage(childID, toCachedSessionUsage(child.usage));
+                    dirty = true;
                 }
                 return child.usage;
             });
@@ -330,15 +385,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) => {
@@ -367,80 +424,108 @@ 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,
+                        dirty: session.state.dirty === true,
+                        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,
+                        dirty: session.state.dirty === true,
+                        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,
+                    dirty: false,
                     computed,
+                    fullUsage,
+                    loadFailed: false,
                     persist: true,
                     cursor,
                 };
             });
+            const failedLoads = fetched.filter((item) => {
+                if (!item.loadFailed)
+                    return false;
+                if (item.dirty)
+                    return true;
+                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);
                     deps.state.sessionDateMap[sessionID] = resolvedDateKey;
                     deps.persistence.markDirty(resolvedDateKey);
+                    memoryState.dirty = false;
                     dirty = true;
                 }
-                else if (persist) {
+                else if (persist && fullUsage) {
                     diskOnlyUpdates.push({
                         sessionID,
                         dateKey,
-                        usage: toCachedSessionUsage(computed),
+                        usage: toCachedSessionUsage(fullUsage),
                         cursor,
                     });
                 }
             }
             if (diskOnlyUpdates.length > 0) {
-                await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch(swallow('updateSessionsInDayChunks'));
+                const persisted = await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch((error) => {
+                    swallow('updateSessionsInDayChunks')(error);
+                    return false;
+                });
+                if (!persisted) {
+                    throw new Error(`range usage unavailable: failed to persist ${diskOnlyUpdates.length} disk-only session(s)`);
+                }
             }
             if (dirty)
                 deps.persistence.scheduleSave();
@@ -449,12 +534,31 @@ export function createUsageService(deps) {
     };
     const summarizeForTool = async (period, sessionID, includeChildren) => {
         if (period === 'session') {
+            if (!includeChildren) {
+                const session = await summarizeSessionUsageLocked(sessionID, {
+                    requireEntries: true,
+                });
+                if (session.persist) {
+                    persistSessionUsage(sessionID, toCachedSessionUsage(session.usage));
+                    deps.persistence.scheduleSave();
+                }
+                return session.usage;
+            }
             return summarizeSessionUsageForDisplay(sessionID, includeChildren);
         }
         return summarizeRangeUsage(period);
     };
     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": "2.0.0",
+  "version": "2.0.2",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",