@leo000001/opencode-quota-sidebar 1.2.0 → 1.4.0

package/README.md

@@ -180,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/format.js

@@ -187,7 +187,10 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
             return Math.max(max, stringCellWidth(label));
         }, 0);
         const quotaItems = visibleQuotas
-            .flatMap((item) => compactQuotaWide(item, labelWidth))
+            .flatMap((item) => compactQuotaWide(item, labelWidth, {
+            width,
+            wrapLines: config.sidebar.wrapQuotaLines,
+        }))
             .filter((s) => Boolean(s));
         if (quotaItems.length > 0) {
             lines.push('');
@@ -200,14 +203,31 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
 }
 /**
  * Multi-window quota format for sidebar.
- * Single window:  "OpenAI 5h 80% Rst 16:20"
- * Multi window:   "OpenAI 5h 80% Rst 16:20" + indented next line
- * Copilot:        "Copilot Monthly 70% Rst 03-01"
+ *
+ * When wrapLines=false (or content fits):
+ *   "OpenAI 5h 80% Rst 16:20"
+ *   "       Weekly 70% Rst 03-01"
+ *
+ * When wrapLines=true and label+content overflows width:
+ *   "RC-openai"
+ *   "  Daily $349.66/$180 Exp+ 02-27"
+ *   "  Balance $108.88"
  */
-function compactQuotaWide(quota, labelWidth = 0) {
+function compactQuotaWide(quota, labelWidth = 0, options) {
     const label = sanitizeLine(quotaDisplayLabel(quota));
     const labelPadded = padEndCells(label, labelWidth);
+    const indent = ' '.repeat(labelWidth + 1);
+    const detailIndent = '  ';
     const withLabel = (content) => `${labelPadded} ${content}`;
+    const wrap = options?.wrapLines === true && (options?.width || 0) > 0;
+    const width = options?.width || 0;
+    /** If inline version overflows, break into label-line + indented detail lines. */
+    const maybeBreak = (inlineText, detailLines) => {
+        const inline = withLabel(inlineText);
+        if (!wrap || stringCellWidth(inline) <= width)
+            return [inline];
+        return [label, ...detailLines.map((d) => `${detailIndent}${d}`)];
+    };
     if (quota.status === 'error')
         return [withLabel('Remaining ?')];
     if (quota.status === 'unsupported')
@@ -229,7 +249,7 @@ function compactQuotaWide(quota, labelWidth = 0) {
                 ? [sanitizeLine(win.label), pct]
                 : [sanitizeLine(win.label)]
             : [pct];
-        const reset = compactReset(win.resetAt);
+        const reset = compactReset(win.resetAt, win.resetLabel);
         if (reset) {
             parts.push(`${sanitizeLine(win.resetLabel || 'Rst')} ${reset}`);
         }
@@ -238,42 +258,64 @@ function compactQuotaWide(quota, labelWidth = 0) {
     // Multi-window rendering
     if (quota.windows && quota.windows.length > 0) {
         const parts = quota.windows.map(renderWindow);
+        // Build the detail lines (window texts + optional balance)
+        const details = [...parts];
+        if (balanceText && !parts.some((p) => p.includes('Balance '))) {
+            details.push(balanceText);
+        }
+        // Try inline first (single window, fits in one line)
         if (parts.length === 1) {
-            const first = withLabel(parts[0]);
-            if (balanceText && !parts[0].includes('Balance ')) {
-                const indent = ' '.repeat(labelWidth + 1);
-                return [first, `${indent}${balanceText}`];
+            const firstInline = withLabel(parts[0]);
+            if (!wrap || stringCellWidth(firstInline) <= width) {
+                // Inline fits — use classic layout
+                const lines = [firstInline];
+                if (balanceText && !parts[0].includes('Balance ')) {
+                    lines.push(`${indent}${balanceText}`);
+                }
+                return lines;
             }
-            return [first];
+            // Overflow — break: label on its own line, details indented
+            return [label, ...details.map((d) => `${detailIndent}${d}`)];
         }
-        const indent = ' '.repeat(labelWidth + 1);
-        const lines = [
-            withLabel(parts[0]),
-            ...parts.slice(1).map((part) => `${indent}${part}`),
-        ];
-        const alreadyHasBalance = parts.some((part) => part.includes('Balance '));
-        if (balanceText && !alreadyHasBalance) {
-            lines.push(`${indent}${balanceText}`);
+        // Multiple windows: try classic inline layout first
+        const firstInline = withLabel(parts[0]);
+        if (!wrap || stringCellWidth(firstInline) <= width) {
+            const lines = [
+                firstInline,
+                ...parts.slice(1).map((part) => `${indent}${part}`),
+            ];
+            if (balanceText && !parts.some((p) => p.includes('Balance '))) {
+                lines.push(`${indent}${balanceText}`);
+            }
+            return lines;
         }
-        return lines;
+        // Overflow — break all
+        return [label, ...details.map((d) => `${detailIndent}${d}`)];
     }
     if (balanceText) {
-        return [withLabel(balanceText)];
+        return maybeBreak(balanceText, [balanceText]);
     }
     // Fallback: single value from top-level remainingPercent
     const percent = quota.remainingPercent === undefined
         ? '?'
         : `${Math.round(quota.remainingPercent)}%`;
-    const reset = compactReset(quota.resetAt);
-    return [withLabel(`Remaining ${percent}${reset ? ` Rst ${reset}` : ''}`)];
+    const reset = compactReset(quota.resetAt, 'Rst');
+    const fallbackText = `Remaining ${percent}${reset ? ` Rst ${reset}` : ''}`;
+    return maybeBreak(fallbackText, [fallbackText]);
 }
-function compactReset(iso) {
+function compactReset(iso, resetLabel) {
     if (!iso)
         return undefined;
     const timestamp = Date.parse(iso);
     if (Number.isNaN(timestamp))
         return undefined;
     const value = new Date(timestamp);
+    // RightCode subscriptions are displayed as an expiry date (MM-DD), not a time.
+    // Using UTC here makes the output stable across time zones for ISO `...Z` input.
+    if (typeof resetLabel === 'string' && resetLabel.startsWith('Exp')) {
+        const two = (num) => `${num}`.padStart(2, '0');
+        return `${two(value.getUTCMonth() + 1)}-${two(value.getUTCDate())}`;
+    }
     const now = new Date();
     const sameDay = value.getFullYear() === now.getFullYear() &&
         value.getMonth() === now.getMonth() &&
@@ -475,7 +517,7 @@ export function renderToastMessage(period, usage, quotas, options) {
                     const pct = win.remainingPercent === undefined
                         ? '-'
                         : `${win.remainingPercent.toFixed(1)}%`;
-                    const reset = compactReset(win.resetAt);
+                    const reset = compactReset(win.resetAt, win.resetLabel);
                     const parts = [win.label];
                     if (showPercent)
                         parts.push(pct);
@@ -505,7 +547,7 @@ export function renderToastMessage(period, usage, quotas, options) {
             const percent = item.remainingPercent === undefined
                 ? '-'
                 : `${item.remainingPercent.toFixed(1)}%`;
-            const reset = compactReset(item.resetAt);
+            const reset = compactReset(item.resetAt, 'Rst');
             return [
                 {
                     label: quotaDisplayLabel(item),

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

@@ -13,6 +13,7 @@ export const defaultConfig = {
         width: 36,
         showCost: true,
         showQuota: true,
+        wrapQuotaLines: true,
         includeChildren: true,
         childrenMaxDepth: 6,
         childrenMaxSessions: 128,
@@ -68,6 +69,7 @@ export async function loadConfig(paths) {
             width: Math.max(20, Math.min(60, asNumber(sidebar.width, defaultConfig.sidebar.width))),
             showCost: asBoolean(sidebar.showCost, defaultConfig.sidebar.showCost),
             showQuota: asBoolean(sidebar.showQuota, defaultConfig.sidebar.showQuota),
+            wrapQuotaLines: asBoolean(sidebar.wrapQuotaLines, defaultConfig.sidebar.wrapQuotaLines),
             includeChildren: asBoolean(sidebar.includeChildren, defaultConfig.sidebar.includeChildren),
             childrenMaxDepth: Math.max(1, Math.min(32, Math.floor(asNumber(sidebar.childrenMaxDepth, defaultConfig.sidebar.childrenMaxDepth)))),
             childrenMaxSessions: Math.max(0, Math.min(2000, Math.floor(asNumber(sidebar.childrenMaxSessions, defaultConfig.sidebar.childrenMaxSessions)))),
@@ -161,6 +163,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 +231,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 +240,7 @@ export async function saveState(statePath, state, options) {
                         ...memorySessions,
                     };
                 await writeDayChunk(rootPath, dateKey, next);
-            })();
+            });
         })
             .filter((promise) => Boolean(promise)));
     }
@@ -316,11 +333,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;
@@ -97,6 +99,8 @@ export type QuotaSidebarConfig = {
         width: number;
         showCost: boolean;
         showQuota: boolean;
+        /** When true, wrap long quota lines and indent continuations. */
+        wrapQuotaLines: boolean;
         /** Include descendant subagent sessions in session-scoped usage/quota. */
         includeChildren: boolean;
         /** Max descendant traversal depth when includeChildren is enabled. */

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.2.0",
+  "version": "1.4.0",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",