@leo000001/opencode-quota-sidebar 1.13.10 → 2.0.0

package/README.md

@@ -53,16 +53,18 @@ Want to add support for another provider (Google Antigravity, Zhipu AI, Firmware
 
 ## Features
 
-- Session title becomes multiline in sidebar:
-  - line 1: original session title
-  - line 2: Input/Output tokens
-  - line 3: Cache Read tokens (only if non-zero)
-  - line 4: Cache Write tokens (only if non-zero)
-  - line 5: `$X.XX as API cost` (equivalent API billing for subscription-auth providers)
-  - quota lines: quota text like `OpenAI 5h 80% Rst 16:20`; short windows (`5h`, `1d`, `Daily`) show `HH:MM` on same-day resets and `MM-DD HH:MM` when crossing days, while longer windows continue to show `MM-DD`
+- Session title becomes multiline in sidebar:
+  - line 1: original session title
+  - line 2: Input/Output tokens
+  - line 3: Cache Read tokens (only if non-zero)
+  - line 4: Cache Write tokens (only if non-zero)
+  - next lines: `Cache Coverage` (read/write cache models) and `Cache Read Coverage` (read-only cache models) when enough cache telemetry is available; mixed sessions can show both
+  - next line: `$X.XX as API cost` (equivalent API billing for subscription-auth providers)
+  - quota lines: quota text like `OpenAI 5h 80% Rst 16:20`; short windows (`5h`, `1d`, `Daily`) show `HH:MM` on same-day resets and `MM-DD HH:MM` when crossing days, while longer windows continue to show `MM-DD`
   - RightCode daily quota shows `$remaining/$dailyTotal` + expiry (e.g. `RC Daily $105/$60 Exp 02-27`, without trailing percent) and also shows balance on the next indented line when available; `Exp` remains date-only
 - Session-scoped usage/quota can include descendant subagent sessions (enabled by default via `sidebar.includeChildren=true`). Traversal is bounded by `childrenMaxDepth` (default 6), `childrenMaxSessions` (default 128), and `childrenConcurrency` (default 5); truncation is logged when `OPENCODE_QUOTA_DEBUG=1`. Day/week/month ranges never merge children — only session scope does.
-- Toast message includes three sections: `Token Usage`, `Cost as API` (per provider), and `Quota`
+- Toast message includes three sections: `Token Usage`, `Cost as API` (per provider), and `Quota`
+- `quota_summary` markdown / toast also include `Cache Coverage` and `Cache Read Coverage` summary lines when available
 - Quota snapshots are de-duplicated before rendering to avoid repeated provider lines
 - Custom tools:
   - `quota_summary` — generate usage report for session/day/week/month (markdown + toast)

package/dist/cost.d.ts

@@ -1,4 +1,5 @@
 import type { AssistantMessage } from '@opencode-ai/sdk';
+import type { CacheCoverageMode } from './types.js';
 export declare const SUBSCRIPTION_API_COST_PROVIDERS: Set<string>;
 export declare function canonicalApiCostProviderID(providerID: string): string;
 export type ModelCostRates = {
@@ -16,4 +17,5 @@ export type ModelCostRates = {
 export declare function modelCostKey(providerID: string, modelID: string): string;
 export declare function parseModelCostRates(value: unknown): ModelCostRates | undefined;
 export declare function guessModelCostDivisor(rates: ModelCostRates): 1 | 1000000;
+export declare function cacheCoverageModeFromRates(rates: ModelCostRates | undefined): CacheCoverageMode;
 export declare function calcEquivalentApiCostForMessage(message: AssistantMessage, rates: ModelCostRates): number;

package/dist/cost.js

@@ -78,6 +78,15 @@ export function guessModelCostDivisor(rates) {
         ? MODEL_COST_DIVISOR_PER_MILLION
         : MODEL_COST_DIVISOR_PER_TOKEN;
 }
+export function cacheCoverageModeFromRates(rates) {
+    if (!rates)
+        return 'none';
+    if (rates.cacheWrite > 0)
+        return 'read-write';
+    if (rates.cacheRead > 0)
+        return 'read-only';
+    return 'none';
+}
 export function calcEquivalentApiCostForMessage(message, rates) {
     const effectiveRates = message.tokens.input > 200_000 && rates.contextOver200k
         ? rates.contextOver200k

package/dist/format.d.ts

@@ -1,5 +1,5 @@
 import type { QuotaSidebarConfig, QuotaSnapshot } from './types.js';
-import type { UsageSummary } from './usage.js';
+import { type UsageSummary } from './usage.js';
 /**
  * Render sidebar title with multi-line token breakdown.
  *

package/dist/format.js

@@ -1,3 +1,4 @@
+import { getCacheCoverageMetrics } from './usage.js';
 import { canonicalProviderID, collapseQuotaSnapshots, displayShortLabel, quotaDisplayLabel, } from './quota_render.js';
 import { stripAnsi } from './title.js';
 /** M6 fix: handle negative, NaN, Infinity gracefully. */
@@ -147,6 +148,11 @@ function formatApiCostValue(value) {
 function formatApiCostLine(value) {
     return `${formatApiCostValue(value)} as API cost`;
 }
+function formatPercent(value, decimals = 1) {
+    const safe = Number.isFinite(value) && value >= 0 ? value : 0;
+    const pct = (safe * 100).toFixed(decimals);
+    return `${pct.replace(/\.0+$/, '').replace(/(\.\d*[1-9])0+$/, '$1')}%`;
+}
 function alignPairs(pairs, indent = '  ') {
     if (pairs.length === 0)
         return [];
@@ -191,6 +197,7 @@ function compactQuotaInline(quota) {
 function renderSingleLineTitle(baseTitle, usage, quotas, config, width) {
     const baseBudget = Math.min(16, Math.max(8, Math.floor(width * 0.35)));
     const base = fitLine(baseTitle, baseBudget);
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const segments = [
         `Input ${sidebarNumber(usage.input)}  Output ${sidebarNumber(usage.output)}`,
     ];
@@ -200,6 +207,12 @@ function renderSingleLineTitle(baseTitle, usage, quotas, config, width) {
     if (usage.cacheWrite > 0) {
         segments.push(`Cache Write ${sidebarNumber(usage.cacheWrite)}`);
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        segments.push(`Cache Coverage ${formatPercent(cacheMetrics.cacheCoverage, 0)}`);
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        segments.push(`Cache Read Coverage ${formatPercent(cacheMetrics.cacheReadCoverage, 0)}`);
+    }
     if (config.sidebar.showCost && usage.apiCost > 0) {
         segments.push(formatApiCostLine(usage.apiCost));
     }
@@ -229,6 +242,7 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
     if (config.sidebar.multilineTitle !== true) {
         return renderSingleLineTitle(safeBaseTitle, usage, quotas, config, width);
     }
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const lines = [];
     lines.push(fitLine(safeBaseTitle, width));
     lines.push('');
@@ -242,6 +256,12 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
     if (usage.cacheWrite > 0) {
         lines.push(fitLine(`Cache Write ${sidebarNumber(usage.cacheWrite)}`, width));
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        lines.push(fitLine(`Cache Coverage ${formatPercent(cacheMetrics.cacheCoverage, 0)}`, width));
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        lines.push(fitLine(`Cache Read Coverage ${formatPercent(cacheMetrics.cacheReadCoverage, 0)}`, width));
+    }
     if (config.sidebar.showCost && usage.apiCost > 0) {
         lines.push(fitLine(formatApiCostLine(usage.apiCost), width));
     }
@@ -419,6 +439,7 @@ function periodLabel(period) {
 }
 export function renderMarkdownReport(period, usage, quotas, options) {
     const showCost = options?.showCost !== false;
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const mdCell = (value) => sanitizeLine(value).replace(/\|/g, '\\|');
     const rightCodeSubscriptionProviderIDs = new Set(collapseQuotaSnapshots(quotas)
         .filter((quota) => quota.adapterID === 'rightcode')
@@ -506,6 +527,14 @@ export function renderMarkdownReport(period, usage, quotas, options) {
         `- Sessions: ${usage.sessionCount}`,
         `- Assistant messages: ${usage.assistantMessages}`,
         `- Tokens: input ${usage.input}, output ${usage.output}, cache_read ${usage.cacheRead}, cache_write ${usage.cacheWrite}, total ${usage.total}`,
+        ...(cacheMetrics.cacheCoverage !== undefined
+            ? [`- Cache Coverage: ${formatPercent(cacheMetrics.cacheCoverage, 1)}`]
+            : []),
+        ...(cacheMetrics.cacheReadCoverage !== undefined
+            ? [
+                `- Cache Read Coverage: ${formatPercent(cacheMetrics.cacheReadCoverage, 1)}`,
+            ]
+            : []),
         ...(showCost
             ? [
                 `- Measured cost: ${measuredCostSummaryValue()}`,
@@ -533,6 +562,7 @@ export function renderMarkdownReport(period, usage, quotas, options) {
 export function renderToastMessage(period, usage, quotas, options) {
     const width = Math.max(24, Math.floor(options?.width || 56));
     const showCost = options?.showCost !== false;
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const lines = [];
     lines.push(fitLine(`${periodLabel(period)} - Total ${shortNumber(usage.total)}`, width));
     lines.push('');
@@ -553,6 +583,18 @@ export function renderToastMessage(period, usage, quotas, options) {
             value: shortNumber(usage.cacheWrite),
         });
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        tokenPairs.push({
+            label: 'Cache Coverage',
+            value: formatPercent(cacheMetrics.cacheCoverage, 1),
+        });
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        tokenPairs.push({
+            label: 'Cache Read Coverage',
+            value: formatPercent(cacheMetrics.cacheReadCoverage, 1),
+        });
+    }
     if (showCost) {
         if (usage.apiCost > 0) {
             tokenPairs.push({

package/dist/storage_parse.js

@@ -28,6 +28,38 @@ function parseProviderUsage(value) {
         assistantMessages: asNumber(value.assistantMessages, 0),
     };
 }
+function parseCacheUsageBucket(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        input: asNumber(value.input, 0),
+        cacheRead: asNumber(value.cacheRead, 0),
+        cacheWrite: asNumber(value.cacheWrite, 0),
+        assistantMessages: asNumber(value.assistantMessages, 0),
+    };
+}
+function parseCacheUsageBuckets(value) {
+    if (!isRecord(value))
+        return undefined;
+    const readOnly = parseCacheUsageBucket(value.readOnly);
+    const readWrite = parseCacheUsageBucket(value.readWrite);
+    if (!readOnly && !readWrite)
+        return undefined;
+    return {
+        readOnly: readOnly || {
+            input: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            assistantMessages: 0,
+        },
+        readWrite: readWrite || {
+            input: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            assistantMessages: 0,
+        },
+    };
+}
 function parseCachedUsage(value) {
     if (!isRecord(value))
         return undefined;
@@ -50,6 +82,7 @@ function parseCachedUsage(value) {
         cost: asNumber(value.cost, 0),
         apiCost: asNumber(value.apiCost, 0),
         assistantMessages: asNumber(value.assistantMessages, 0),
+        cacheBuckets: parseCacheUsageBuckets(value.cacheBuckets),
         providers,
     };
 }

package/dist/title.js

@@ -10,6 +10,8 @@ function isStrongDecoratedDetail(line) {
         return true;
     if (/^Cache\s+(Read|Write)\s+\S+/.test(line))
         return true;
+    if (/^Cache(?:\s+Read)?\s+Coverage\s+\S+/.test(line))
+        return true;
     if (/^\$\S+\s+as API cost\b/.test(line))
         return true;
     // Single-line compact mode compatibility.

package/dist/types.d.ts

@@ -36,6 +36,17 @@ export type SessionTitleState = {
     baseTitle: string;
     lastAppliedTitle?: string;
 };
+export type CacheCoverageMode = 'none' | 'read-only' | 'read-write';
+export type CacheUsageBucket = {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    assistantMessages: number;
+};
+export type CacheUsageBuckets = {
+    readOnly: CacheUsageBucket;
+    readWrite: CacheUsageBucket;
+};
 export type CachedProviderUsage = {
     input: number;
     output: number;
@@ -61,6 +72,8 @@ export type CachedSessionUsage = {
     /** Equivalent API billing cost (USD) computed from model pricing. */
     apiCost: number;
     assistantMessages: number;
+    /** Cache coverage buckets grouped by model cache behavior. */
+    cacheBuckets?: CacheUsageBuckets;
     providers: Record<string, CachedProviderUsage>;
 };
 /** Tracks incremental aggregation cursor for a session (P1). */

package/dist/usage.d.ts

@@ -1,6 +1,6 @@
 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 { CacheCoverageMode, CacheUsageBuckets, CachedSessionUsage, IncrementalCursor } from './types.js';
+export declare const USAGE_BILLING_CACHE_VERSION = 3;
 export type ProviderUsage = {
     providerID: string;
     input: number;
@@ -26,11 +26,18 @@ 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'>): {
+    cacheCoverage: number | undefined;
+    cacheReadCoverage: number | undefined;
 };
 export declare function emptyUsageSummary(): UsageSummary;
 export declare function summarizeMessages(entries: Array<{

package/dist/usage.js

@@ -1,4 +1,94 @@
-export const USAGE_BILLING_CACHE_VERSION = 2;
+export const USAGE_BILLING_CACHE_VERSION = 3;
+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;
+}
+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) {
+    return (cloneCacheUsageBuckets(usage.cacheBuckets || fallbackCacheUsageBuckets(usage)) ||
+        emptyCacheUsageBuckets());
+}
+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,
@@ -11,6 +101,7 @@ export function emptyUsageSummary() {
         apiCost: 0,
         assistantMessages: 0,
         sessionCount: 0,
+        cacheBuckets: emptyCacheUsageBuckets(),
         providers: {},
     };
 }
@@ -69,6 +160,15 @@ 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);
+    }
 }
 export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
     const summary = emptyUsageSummary();
@@ -276,6 +376,12 @@ 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) {
+        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 +427,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 +446,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,5 +1,5 @@
 import { TtlValueCache } from './cache.js';
-import { calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
+import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
 import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
@@ -48,13 +48,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 +62,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 +81,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 +93,30 @@ 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';
+        if (canonicalProviderID === 'anthropic' ||
+            message.modelID.toLowerCase().includes('claude')) {
+            return 'read-write';
+        }
+        if (canonicalProviderID === 'openai')
+            return 'read-only';
+        return 'none';
+    };
     const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
     const decodeTokens = (value) => {
         if (!isRecord(value))
@@ -221,6 +249,7 @@ 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
@@ -377,6 +406,7 @@ export function createUsageService(deps) {
                 }
                 const { usage: computed, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
                 return {
                     sessionID: session.sessionID,

package/package.json

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