@leo000001/opencode-quota-sidebar 1.0.3 → 1.3.0

package/README.md

@@ -17,6 +17,8 @@ Add the package name to `plugin` in your `opencode.json`. OpenCode uses Bun to i
 }
 ```
 
+Note for OpenCode `>=1.2.15`: TUI settings (`theme`/`keybinds`/`tui`) moved to `tui.json`, but plugin loading still stays in `opencode.json` (`plugin: []`).
+
 ## Development (build from source)
 
 ```bash
@@ -105,6 +107,7 @@ memory on startup. Chunk files remain on disk for historical range scans.
 
 - Node.js: >= 18 (for `fetch` + `AbortController`)
 - OpenCode: plugin SDK `@opencode-ai/plugin` ^1.2.10
+- OpenCode config split: if you are on `>=1.2.15`, keep this plugin in `opencode.json` and keep TUI-only keys in `tui.json`.
 
 ## Optional commands
 
@@ -177,8 +180,8 @@ Notes:
 - `sidebar.childrenMaxDepth` limits how many levels of nested subagents are traversed (default: `6`, clamped 1–32).
 - `sidebar.childrenMaxSessions` caps the total number of descendant sessions aggregated (default: `128`, clamped 0–2000).
 - `sidebar.childrenConcurrency` controls parallel fetches for descendant session messages (default: `5`, clamped 1–10).
-- `output` now includes reasoning tokens. Reasoning is no longer rendered as a separate line.
-- API cost excludes reasoning tokens from output billing (uses `tokens.output` only for output-price multiplication).
+- `output` includes reasoning tokens (`output = tokens.output + tokens.reasoning`). Reasoning is not rendered as a separate line.
+- API cost bills reasoning tokens at the output rate (same as completion tokens).
 - `quota.providers` is the extensible per-adapter switch map.
 - If API Cost is `$0.00`, it usually means the model/provider has no pricing mapping in OpenCode at the moment, so equivalent API cost cannot be estimated.
 

package/dist/cost.js

@@ -65,9 +65,12 @@ export function guessModelCostDivisor(rates) {
         : MODEL_COST_DIVISOR_PER_TOKEN;
 }
 export function calcEquivalentApiCostForMessage(message, rates) {
+    // For providers that expose reasoning tokens separately, they are still
+    // billed as output/completion tokens (same unit price). Our UI also merges
+    // reasoning into the single Output statistic, so API cost should match that.
+    const billedOutput = message.tokens.output + message.tokens.reasoning;
     const rawCost = message.tokens.input * rates.input +
-        // API cost intentionally excludes reasoning tokens.
-        message.tokens.output * rates.output +
+        billedOutput * rates.output +
         message.tokens.cache.read * rates.cacheRead +
         message.tokens.cache.write * rates.cacheWrite;
     const divisor = guessModelCostDivisor(rates);

package/dist/providers/third_party/rightcode.js

@@ -159,18 +159,19 @@ async function fetchRightCodeQuota(ctx) {
         const dailyTotal = matched.reduce((sum, subscription) => sum + subscription.dailyTotal, 0);
         const dailyRemaining = matched.reduce((sum, subscription) => sum + subscription.dailyRemaining, 0);
         const dailyPercent = dailyTotal > 0 ? (dailyRemaining / dailyTotal) * 100 : undefined;
-        const expiry = matched.reduce((acc, subscription) => {
-            if (!subscription.expiresAt)
-                return acc;
-            const current = Date.parse(subscription.expiresAt);
-            if (Number.isNaN(current))
-                return acc;
+        const parsedExpiries = matched
+            .map((subscription) => subscription.expiresAt)
+            .filter((iso) => typeof iso === 'string' && !!iso)
+            .map((iso) => ({ iso, ts: Date.parse(iso) }))
+            .filter((item) => !Number.isNaN(item.ts));
+        const uniqueExpiryTimestamps = new Set(parsedExpiries.map((e) => e.ts));
+        const hasMultipleExpiries = uniqueExpiryTimestamps.size > 1;
+        const expiry = parsedExpiries.reduce((acc, item) => {
             if (!acc)
-                return subscription.expiresAt;
+                return item.iso;
             const existing = Date.parse(acc);
-            if (Number.isNaN(existing) || current < existing) {
-                return subscription.expiresAt;
-            }
+            if (Number.isNaN(existing) || item.ts < existing)
+                return item.iso;
             return acc;
         }, undefined);
         const windows = [
@@ -179,7 +180,7 @@ async function fetchRightCodeQuota(ctx) {
                 showPercent: false,
                 remainingPercent: dailyPercent,
                 resetAt: expiry,
-                resetLabel: 'Exp',
+                resetLabel: hasMultipleExpiries ? 'Exp+' : 'Exp',
             },
         ];
         const names = matched.map((subscription) => subscription.name).join(', ');

package/dist/storage.d.ts

@@ -1,6 +1,6 @@
 import { dateKeyFromTimestamp, normalizeTimestampMs } from './storage_dates.js';
 import { authFilePath, resolveOpencodeDataDir, stateFilePath } from './storage_paths.js';
-import type { QuotaSidebarConfig, QuotaSidebarState, SessionState } from './types.js';
+import type { CachedSessionUsage, IncrementalCursor, QuotaSidebarConfig, QuotaSidebarState, SessionState } from './types.js';
 export { authFilePath, dateKeyFromTimestamp, normalizeTimestampMs, resolveOpencodeDataDir, stateFilePath, };
 export declare const defaultConfig: QuotaSidebarConfig;
 export declare function defaultState(): QuotaSidebarState;
@@ -32,3 +32,10 @@ export declare function scanSessionsByCreatedRange(statePath: string, startAt: n
 }[]>;
 /** Best-effort: remove a session entry from its day chunk (if present). */
 export declare function deleteSessionFromDayChunk(statePath: string, sessionID: string, dateKey: string): Promise<boolean>;
+/** Best-effort: persist recomputed usage/cursor for sessions loaded from disk-only chunks. */
+export declare function updateSessionsInDayChunks(statePath: string, updates: Array<{
+    sessionID: string;
+    dateKey: string;
+    usage: CachedSessionUsage;
+    cursor: IncrementalCursor | undefined;
+}>): Promise<number>;

package/dist/storage.js

@@ -161,6 +161,21 @@ export async function loadState(statePath) {
 }
 // ─── State saving ────────────────────────────────────────────────────────────
 const MAX_QUOTA_CACHE_AGE_MS = 24 * 60 * 60 * 1000;
+const dayChunkWriteLocks = new Map();
+async function withDayChunkWriteLock(dateKey, fn) {
+    const previous = dayChunkWriteLocks.get(dateKey) || Promise.resolve();
+    const run = previous.then(() => fn());
+    const release = run.then(() => undefined, () => undefined);
+    dayChunkWriteLocks.set(dateKey, release);
+    try {
+        return await run;
+    }
+    finally {
+        if (dayChunkWriteLocks.get(dateKey) === release) {
+            dayChunkWriteLocks.delete(dateKey);
+        }
+    }
+}
 function pruneState(state) {
     const now = Date.now();
     for (const [key, value] of Object.entries(state.quotaCache)) {
@@ -214,7 +229,7 @@ export async function saveState(statePath, state, options) {
             if (!Object.prototype.hasOwnProperty.call(sessionsByDate, dateKey)) {
                 return undefined;
             }
-            return (async () => {
+            return withDayChunkWriteLock(dateKey, async () => {
                 const memorySessions = sessionsByDate[dateKey] || {};
                 const next = writeAll
                     ? memorySessions
@@ -223,7 +238,7 @@ export async function saveState(statePath, state, options) {
                         ...memorySessions,
                     };
                 await writeDayChunk(rootPath, dateKey, next);
-            })();
+            });
         })
             .filter((promise) => Boolean(promise)));
     }
@@ -316,11 +331,50 @@ export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Dat
 /** Best-effort: remove a session entry from its day chunk (if present). */
 export async function deleteSessionFromDayChunk(statePath, sessionID, dateKey) {
     const rootPath = chunkRootPathFromStateFile(statePath);
-    const sessions = await readDayChunk(rootPath, dateKey);
-    if (!Object.prototype.hasOwnProperty.call(sessions, sessionID))
-        return false;
-    const next = { ...sessions };
-    delete next[sessionID];
-    await writeDayChunk(rootPath, dateKey, next);
-    return true;
+    return withDayChunkWriteLock(dateKey, async () => {
+        const sessions = await readDayChunk(rootPath, dateKey);
+        if (!Object.prototype.hasOwnProperty.call(sessions, sessionID))
+            return false;
+        const next = { ...sessions };
+        delete next[sessionID];
+        await writeDayChunk(rootPath, dateKey, next);
+        return true;
+    });
+}
+/** Best-effort: persist recomputed usage/cursor for sessions loaded from disk-only chunks. */
+export async function updateSessionsInDayChunks(statePath, updates) {
+    if (updates.length === 0)
+        return 0;
+    const rootPath = chunkRootPathFromStateFile(statePath);
+    const byDate = updates.reduce((acc, item) => {
+        const bucket = acc[item.dateKey] || [];
+        bucket.push(item);
+        acc[item.dateKey] = bucket;
+        return acc;
+    }, {});
+    let written = 0;
+    const WRITE_CONCURRENCY = 5;
+    await mapConcurrent(Object.entries(byDate), WRITE_CONCURRENCY, async ([dateKey, dateUpdates]) => {
+        await withDayChunkWriteLock(dateKey, async () => {
+            const sessions = await readDayChunk(rootPath, dateKey);
+            const next = { ...sessions };
+            let changed = false;
+            for (const item of dateUpdates) {
+                const existing = next[item.sessionID];
+                if (!existing)
+                    continue;
+                next[item.sessionID] = {
+                    ...existing,
+                    usage: item.usage,
+                    cursor: item.cursor,
+                };
+                changed = true;
+            }
+            if (!changed)
+                return;
+            await writeDayChunk(rootPath, dateKey, next);
+            written++;
+        });
+    });
+    return written;
 }

package/dist/storage_parse.js

@@ -40,6 +40,7 @@ function parseCachedUsage(value) {
         return acc;
     }, {});
     return {
+        billingVersion: asNumber(value.billingVersion),
         input: asNumber(value.input, 0),
         output: asNumber(value.output, 0),
         reasoning: asNumber(value.reasoning, 0),

package/dist/types.d.ts

@@ -49,6 +49,8 @@ export type CachedProviderUsage = {
     assistantMessages: number;
 };
 export type CachedSessionUsage = {
+    /** Billing aggregation cache version for cost/apiCost refresh migrations. */
+    billingVersion?: number;
     input: number;
     output: number;
     reasoning: number;

package/dist/usage.d.ts

@@ -1,5 +1,6 @@
 import type { AssistantMessage, Message } from '@opencode-ai/sdk';
 import type { CachedSessionUsage, IncrementalCursor } from './types.js';
+export declare const USAGE_BILLING_CACHE_VERSION = 1;
 export type ProviderUsage = {
     providerID: string;
     input: number;

package/dist/usage.js

@@ -1,3 +1,4 @@
+export const USAGE_BILLING_CACHE_VERSION = 1;
 export function emptyUsageSummary() {
     return {
         input: 0,
@@ -189,10 +190,16 @@ export function summarizeMessagesIncremental(entries, existingUsage, cursor, for
             time: nextCursor.lastMessageTime ?? cursorTime,
         };
         if (newerThan(candidate, current)) {
+            const idsAtCursorTime = new Set(nextCursor.lastMessageIdsAtTime ||
+                cursor.lastMessageIdsAtTime ||
+                (current.id ? [current.id] : []));
+            idsAtCursorTime.add(msg.id);
             nextCursor = {
                 lastMessageId: msg.id,
                 lastMessageTime: msg.time.completed,
-                lastMessageIdsAtTime: [msg.id],
+                lastMessageIdsAtTime: candidate.time > current.time
+                    ? [msg.id]
+                    : Array.from(idsAtCursorTime).sort(),
             };
         }
         else if (nextCursor.lastMessageTime === msg.time.completed) {
@@ -298,6 +305,7 @@ export function toCachedSessionUsage(summary) {
         return acc;
     }, {});
     return {
+        billingVersion: USAGE_BILLING_CACHE_VERSION,
         input: summary.input,
         output: summary.output,
         // Always 0 after merge into output; kept for serialization shape.

package/dist/usage_service.js

@@ -1,9 +1,9 @@
 import { TtlValueCache } from './cache.js';
 import { calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanSessionsByCreatedRange } from './storage.js';
+import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
-import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, } from './usage.js';
+import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
 export function createUsageService(deps) {
     const forceRescanSessions = new Set();
     const dirtyGeneration = new Map();
@@ -189,6 +189,11 @@ export function createUsageService(deps) {
         deps.state.sessionDateMap[sessionID] = dateKey;
         deps.persistence.markDirty(dateKey);
     };
+    const isUsageBillingCurrent = (cached) => {
+        if (!cached)
+            return false;
+        return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
+    };
     const summarizeSessionUsage = async (sessionID, generationAtStart) => {
         const entries = await loadSessionEntries(sessionID);
         const sessionState = deps.state.sessions[sessionID];
@@ -206,9 +211,14 @@ export function createUsageService(deps) {
             return { usage: empty, persist: false };
         }
         const modelCostMap = await getModelCostMap();
-        const forceRescan = forceRescanSessions.has(sessionID);
+        const staleBillingCache = Boolean(sessionState?.usage) &&
+            !isUsageBillingCurrent(sessionState?.usage);
+        const forceRescan = forceRescanSessions.has(sessionID) || staleBillingCache;
         if (forceRescan)
             forceRescanSessions.delete(sessionID);
+        if (staleBillingCache) {
+            debug(`usage cache billing refresh for session ${sessionID}`);
+        }
         const { usage, cursor } = summarizeMessagesIncremental(entries, sessionState?.usage, sessionState?.cursor, forceRescan, {
             calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
         });
@@ -268,7 +278,7 @@ export function createUsageService(deps) {
         const needsFetch = [];
         for (const childID of descendantIDs) {
             const cached = deps.state.sessions[childID]?.usage;
-            if (cached && !isDirty(childID)) {
+            if (cached && !isDirty(childID) && isUsageBillingCurrent(cached)) {
                 mergeUsage(merged, fromCachedSessionUsage(cached, 1));
             }
             else {
@@ -309,7 +319,9 @@ export function createUsageService(deps) {
                 return SUBSCRIPTION_API_COST_PROVIDERS.has(canonical);
             });
         };
-        const shouldRecomputeApiCost = (cached) => {
+        const shouldRecomputeUsageCache = (cached) => {
+            if (!isUsageBillingCurrent(cached))
+                return true;
             if (!hasPricing)
                 return false;
             if (cached.assistantMessages <= 0)
@@ -325,7 +337,7 @@ export function createUsageService(deps) {
         const needsFetch = [];
         for (const session of sessions) {
             if (session.state.usage) {
-                if (shouldRecomputeApiCost(session.state.usage)) {
+                if (shouldRecomputeUsageCache(session.state.usage)) {
                     needsFetch.push(session);
                 }
                 else {
@@ -343,35 +355,58 @@ export function createUsageService(deps) {
                     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,
                         persist: false,
+                        cursor: undefined,
                     };
                 }
-                const { usage: computed } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
+                const { usage: computed, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
                 });
-                return { sessionID: session.sessionID, computed, persist: true };
+                return {
+                    sessionID: session.sessionID,
+                    dateKey: session.dateKey,
+                    computed,
+                    persist: true,
+                    cursor,
+                };
             });
             let dirty = false;
-            for (const { sessionID, computed, persist } of fetched) {
+            const diskOnlyUpdates = [];
+            for (const { sessionID, dateKey, computed, persist, cursor } of fetched) {
                 mergeUsage(usage, { ...computed, sessionCount: 0 });
                 const memoryState = deps.state.sessions[sessionID];
                 if (persist && memoryState) {
                     memoryState.usage = toCachedSessionUsage(computed);
-                    const dateKey = deps.state.sessionDateMap[sessionID] ||
+                    memoryState.cursor = cursor;
+                    const resolvedDateKey = deps.state.sessionDateMap[sessionID] ||
                         dateKeyFromTimestamp(memoryState.createdAt);
-                    deps.state.sessionDateMap[sessionID] = dateKey;
-                    deps.persistence.markDirty(dateKey);
+                    deps.state.sessionDateMap[sessionID] = resolvedDateKey;
+                    deps.persistence.markDirty(resolvedDateKey);
                     dirty = true;
                 }
+                else if (persist) {
+                    diskOnlyUpdates.push({
+                        sessionID,
+                        dateKey,
+                        usage: toCachedSessionUsage(computed),
+                        cursor,
+                    });
+                }
+            }
+            if (diskOnlyUpdates.length > 0) {
+                await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch(swallow('updateSessionsInDayChunks'));
             }
             if (dirty)
                 deps.persistence.scheduleSave();

package/package.json

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