@leo000001/opencode-quota-sidebar 2.0.0 → 2.0.2

package/dist/quota_service.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { TtlValueCache } from './cache.js';
 import { isRecord, swallow } from './helpers.js';
 import { listDefaultQuotaProviderIDs, loadAuthMap, quotaSort } from './quota.js';
@@ -10,12 +11,43 @@ export function createQuotaService(deps) {
     const authCache = new TtlValueCache();
     const providerOptionsCache = new TtlValueCache();
     const inFlight = new Map();
+    let lastSuccessfulProviderOptionsMap = {};
+    const authFingerprint = (auth) => {
+        if (!auth || typeof auth !== 'object')
+            return undefined;
+        const stable = JSON.stringify(Object.keys(auth)
+            .sort()
+            .reduce((acc, key) => {
+            const value = auth[key];
+            if (value !== undefined)
+                acc[key] = value;
+            return acc;
+        }, {}));
+        return createHash('sha256').update(stable).digest('hex').slice(0, 12);
+    };
+    const providerOptionsFingerprint = (providerOptions) => {
+        if (!providerOptions)
+            return undefined;
+        const stable = JSON.stringify(Object.keys(providerOptions)
+            .sort()
+            .reduce((acc, key) => {
+            if (key === 'baseURL')
+                return acc;
+            const value = providerOptions[key];
+            if (value !== undefined)
+                acc[key] = value;
+            return acc;
+        }, {}));
+        if (stable === '{}')
+            return undefined;
+        return createHash('sha256').update(stable).digest('hex').slice(0, 12);
+    };
     const getAuthMap = async () => {
         const cached = authCache.get();
         if (cached)
             return cached;
         const value = await loadAuthMap(deps.authPath);
-        return authCache.set(value, 30_000);
+        return authCache.set(value, 5_000);
     };
     const getProviderOptionsMap = async () => {
         const cached = providerOptionsCache.get();
@@ -23,27 +55,131 @@ export function createQuotaService(deps) {
             return cached;
         const client = deps.client;
         if (!client.config?.providers && !client.provider?.list) {
-            return providerOptionsCache.set({}, 30_000);
+            return providerOptionsCache.set({}, 5_000);
         }
         // Newer runtimes expose config.providers; older clients may only expose
         // provider.list with a slightly different response shape.
-        const response = await (client.config?.providers
-            ? client.config.providers({
+        let response;
+        let fromConfigProviders = false;
+        if (client.config?.providers) {
+            fromConfigProviders = true;
+            response = await client.config
+                .providers({
                 query: { directory: deps.directory },
                 throwOnError: true,
             })
-            : client.provider.list({
+                .catch(swallow('getProviderOptionsMap:configProviders'));
+        }
+        if (!response && client.provider?.list) {
+            response = await client.provider
+                .list({
                 query: { directory: deps.directory },
                 throwOnError: true,
-            })).catch(swallow('getProviderOptionsMap'));
-        const data = isRecord(response) && isRecord(response.data) ? response.data : undefined;
-        const list = Array.isArray(data?.providers)
-            ? data.providers
-            : Array.isArray(data?.all)
-                ? data.all
+            })
+                .catch(swallow('getProviderOptionsMap:providerList'));
+        }
+        const data = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+            ? response.data
+            : undefined;
+        if (!response || data === undefined) {
+            if (client.provider?.list && fromConfigProviders) {
+                response = await client.provider
+                    .list({
+                    query: { directory: deps.directory },
+                    throwOnError: true,
+                })
+                    .catch(swallow('getProviderOptionsMap:providerListNoDataFallback'));
+                const fallbackData = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+                    ? response.data
+                    : undefined;
+                const fallbackRecord = isRecord(fallbackData) ? fallbackData : undefined;
+                const fallbackList = Array.isArray(fallbackRecord?.providers)
+                    ? fallbackRecord.providers
+                    : Array.isArray(fallbackRecord?.all)
+                        ? fallbackRecord.all
+                        : Array.isArray(fallbackData)
+                            ? fallbackData
+                            : undefined;
+                const map = Array.isArray(fallbackList)
+                    ? fallbackList.reduce((acc, item) => {
+                        if (!item || typeof item !== 'object')
+                            return acc;
+                        const record = item;
+                        const id = record.id;
+                        const options = record.options;
+                        if (typeof id !== 'string')
+                            return acc;
+                        if (!options || typeof options !== 'object' || Array.isArray(options)) {
+                            acc[id] = {};
+                            return acc;
+                        }
+                        acc[id] = options;
+                        return acc;
+                    }, {})
+                    : {};
+                if (Object.keys(map).length > 0) {
+                    lastSuccessfulProviderOptionsMap = map;
+                    return providerOptionsCache.set(map, 5_000);
+                }
+            }
+            return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                ? lastSuccessfulProviderOptionsMap
+                : {};
+        }
+        const dataRecord = isRecord(data) ? data : undefined;
+        const list = Array.isArray(dataRecord?.providers)
+            ? dataRecord.providers
+            : Array.isArray(dataRecord?.all)
+                ? dataRecord.all
                 : Array.isArray(data)
                     ? data
                     : undefined;
+        if (!list && fromConfigProviders && client.provider?.list) {
+            response = await client.provider
+                .list({
+                query: { directory: deps.directory },
+                throwOnError: true,
+            })
+                .catch(swallow('getProviderOptionsMap:providerListFallback'));
+            const fallbackData = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+                ? response.data
+                : undefined;
+            const fallbackRecord = isRecord(fallbackData) ? fallbackData : undefined;
+            const fallbackList = Array.isArray(fallbackRecord?.providers)
+                ? fallbackRecord.providers
+                : Array.isArray(fallbackRecord?.all)
+                    ? fallbackRecord.all
+                    : Array.isArray(fallbackData)
+                        ? fallbackData
+                        : undefined;
+            const map = Array.isArray(fallbackList)
+                ? fallbackList.reduce((acc, item) => {
+                    if (!item || typeof item !== 'object')
+                        return acc;
+                    const record = item;
+                    const id = record.id;
+                    const options = record.options;
+                    if (typeof id !== 'string')
+                        return acc;
+                    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+                        acc[id] = {};
+                        return acc;
+                    }
+                    acc[id] = options;
+                    return acc;
+                }, {})
+                : {};
+            if (Object.keys(map).length > 0) {
+                lastSuccessfulProviderOptionsMap = map;
+                return providerOptionsCache.set(map, 5_000);
+            }
+            if (!Array.isArray(fallbackList)) {
+                return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                    ? lastSuccessfulProviderOptionsMap
+                    : {};
+            }
+            return providerOptionsCache.set(map, 5_000);
+        }
         const map = Array.isArray(list)
             ? list.reduce((acc, item) => {
                 if (!item || typeof item !== 'object')
@@ -63,7 +199,16 @@ export function createQuotaService(deps) {
                 return acc;
             }, {})
             : {};
-        return providerOptionsCache.set(map, 30_000);
+        if (Object.keys(map).length > 0) {
+            lastSuccessfulProviderOptionsMap = map;
+            return providerOptionsCache.set(map, 5_000);
+        }
+        if (!Array.isArray(list)) {
+            return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                ? lastSuccessfulProviderOptionsMap
+                : providerOptionsCache.set(map, 5_000);
+        }
+        return providerOptionsCache.set(map, 5_000);
     };
     const isValidQuotaCache = (snapshot) => {
         // Guard against stale RightCode cache entries from pre-daily format.
@@ -166,14 +311,6 @@ export function createQuotaService(deps) {
             ? directCandidates
             : defaultCandidates;
         const matchedCandidates = rawCandidates.filter((candidate) => Boolean(deps.quotaRuntime.resolveQuotaAdapter(candidate.providerID, candidate.providerOptions)));
-        const dedupedCandidates = Array.from(matchedCandidates
-            .reduce((acc, candidate) => {
-            const key = deps.quotaRuntime.quotaCacheKey(candidate.providerID, candidate.providerOptions);
-            if (!acc.has(key))
-                acc.set(key, candidate);
-            return acc;
-        }, new Map())
-            .values());
         function authScopeFor(providerID, providerOptions) {
             const adapter = deps.quotaRuntime.resolveQuotaAdapter(providerID, providerOptions);
             const normalized = deps.quotaRuntime.normalizeProviderID(providerID);
@@ -186,24 +323,48 @@ export function createQuotaService(deps) {
                     candidates.push(value);
             };
             push(providerID);
-            push(normalized);
-            push(adapterID);
             if (adapterID === 'github-copilot')
                 push('github-copilot-enterprise');
+            push(normalized);
+            push(adapterID);
+            const optionsFingerprint = providerOptionsFingerprint(providerOptions);
             for (const key of candidates) {
                 const auth = authMap[key];
                 if (!auth)
                     continue;
-                if (key === 'openai' &&
-                    auth.type === 'oauth' &&
-                    typeof auth.accountId === 'string' &&
-                    auth.accountId) {
-                    return `${key}@${auth.accountId}`;
+                if (auth.type === 'oauth') {
+                    const authRecord = auth;
+                    const identity = (typeof auth.accountId === 'string' && auth.accountId) ||
+                        (typeof authRecord.login === 'string' && authRecord.login) ||
+                        (typeof authRecord.userId === 'string' && authRecord.userId);
+                    if (identity) {
+                        return optionsFingerprint
+                            ? `${key}@${identity}|options@${optionsFingerprint}`
+                            : `${key}@${identity}`;
+                    }
+                }
+                const fingerprint = authFingerprint(auth);
+                if (fingerprint) {
+                    return optionsFingerprint
+                        ? `${key}@${fingerprint}|options@${optionsFingerprint}`
+                        : `${key}@${fingerprint}`;
                 }
-                return key;
+                return optionsFingerprint ? `${key}|options@${optionsFingerprint}` : key;
+            }
+            if (optionsFingerprint) {
+                return `options@${optionsFingerprint}`;
             }
             return 'none';
         }
+        const dedupedCandidates = Array.from(matchedCandidates
+            .reduce((acc, candidate) => {
+            const baseKey = deps.quotaRuntime.quotaCacheKey(candidate.providerID, candidate.providerOptions);
+            const key = `${baseKey}#${authScopeFor(candidate.providerID, candidate.providerOptions)}`;
+            if (!acc.has(key))
+                acc.set(key, candidate);
+            return acc;
+        }, new Map())
+            .values());
         let cacheChanged = false;
         const fetchSnapshot = (providerID, providerOptions) => {
             const baseKey = deps.quotaRuntime.quotaCacheKey(providerID, providerOptions);
@@ -229,7 +390,11 @@ export function createQuotaService(deps) {
                     body: next,
                     throwOnError: true,
                 })
-                    .catch(swallow('getQuotaSnapshots:authSet'));
+                    .catch((error) => {
+                    swallow('getQuotaSnapshots:authSet')(error);
+                    throw error;
+                });
+                authCache.clear();
             }, providerOptions)
                 .then((latest) => {
                 if (!latest)

package/dist/storage.d.ts

@@ -30,6 +30,11 @@ export declare function scanSessionsByCreatedRange(statePath: string, startAt: n
     dateKey: string;
     state: SessionState;
 }[]>;
+export declare function scanAllSessions(statePath: string, memoryState?: QuotaSidebarState): Promise<{
+    sessionID: string;
+    dateKey: string;
+    state: SessionState;
+}[]>;
 /** 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. */

package/dist/storage.js

@@ -40,6 +40,7 @@ export function defaultState() {
         titleEnabled: true,
         sessionDateMap: {},
         sessions: {},
+        deletedSessionDateMap: {},
         quotaCache: {},
     };
 }
@@ -128,6 +129,17 @@ async function loadVersion2State(raw, statePath) {
         acc[sessionID] = value;
         return acc;
     }, {});
+    const deletedSessionDateMapRaw = isRecord(raw.deletedSessionDateMap)
+        ? raw.deletedSessionDateMap
+        : {};
+    const deletedSessionDateMap = Object.entries(deletedSessionDateMapRaw).reduce((acc, [sessionID, value]) => {
+        if (typeof value !== 'string')
+            return acc;
+        if (!isDateKey(value))
+            return acc;
+        acc[sessionID] = value;
+        return acc;
+    }, {});
     const hadRawSessionDateMapEntries = isRecord(raw.sessionDateMap) && Object.keys(raw.sessionDateMap).length > 0;
     const explicitDateKeys = Array.from(new Set(Object.values(sessionDateMap)));
     // Only discover chunks when sessionDateMap is missing from state.
@@ -150,6 +162,8 @@ async function loadVersion2State(raw, statePath) {
     const sessions = {};
     for (const [dateKey, chunkSessions] of chunks) {
         for (const [sessionID, session] of Object.entries(chunkSessions)) {
+            if (deletedSessionDateMap[sessionID])
+                continue;
             sessions[sessionID] = session;
             if (!sessionDateMap[sessionID])
                 sessionDateMap[sessionID] = dateKey;
@@ -160,6 +174,7 @@ async function loadVersion2State(raw, statePath) {
         titleEnabled,
         sessionDateMap,
         sessions,
+        deletedSessionDateMap,
         quotaCache,
     };
 }
@@ -237,22 +252,31 @@ export async function saveState(statePath, state, options) {
     await fs.mkdir(path.dirname(statePath), { recursive: true });
     if (!skipChunks) {
         const keysToWrite = writeAll
-            ? Object.keys(sessionsByDate)
+            ? Array.from(new Set([
+                ...Object.keys(sessionsByDate),
+                ...Object.values(state.deletedSessionDateMap),
+            ]))
             : Array.from(dirtySet ?? []);
         await Promise.all(keysToWrite
             .map((dateKey) => {
-            if (!Object.prototype.hasOwnProperty.call(sessionsByDate, dateKey)) {
-                return undefined;
-            }
             return withDayChunkWriteLock(dateKey, async () => {
                 const memorySessions = sessionsByDate[dateKey] || {};
+                const tombstonedIDs = Object.entries(state.deletedSessionDateMap)
+                    .filter(([, tombstoneDateKey]) => tombstoneDateKey === dateKey)
+                    .map(([sessionID]) => sessionID);
                 const next = writeAll
                     ? memorySessions
                     : {
                         ...(await readDayChunk(rootPath, dateKey)),
                         ...memorySessions,
                     };
+                for (const sessionID of tombstonedIDs) {
+                    delete next[sessionID];
+                }
                 await writeDayChunk(rootPath, dateKey, next);
+                for (const sessionID of tombstonedIDs) {
+                    delete state.deletedSessionDateMap[sessionID];
+                }
             });
         })
             .filter((promise) => Boolean(promise)));
@@ -262,6 +286,7 @@ export async function saveState(statePath, state, options) {
         version: 2,
         titleEnabled: state.titleEnabled,
         sessionDateMap: state.sessionDateMap,
+        deletedSessionDateMap: state.deletedSessionDateMap,
         quotaCache: state.quotaCache,
     }, null, 2)}\n`);
 }
@@ -292,6 +317,7 @@ export function evictOldSessions(state, retentionDays) {
  */
 export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Date.now(), memoryState) {
     const rootPath = chunkRootPathFromStateFile(statePath);
+    const deletedSessionIDs = new Set(Object.keys(memoryState?.deletedSessionDateMap || {}));
     const dateKeys = dateKeysInRange(startAt, endAt);
     if (!dateKeys.length) {
         return [];
@@ -302,6 +328,8 @@ export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Dat
     if (memoryState) {
         const dateKeySet = new Set(dateKeys);
         for (const [sessionID, session] of Object.entries(memoryState.sessions)) {
+            if (deletedSessionIDs.has(sessionID))
+                continue;
             const dk = memoryState.sessionDateMap[sessionID];
             if (!dk || !dateKeySet.has(dk))
                 continue;
@@ -314,11 +342,9 @@ export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Dat
             }
         }
     }
-    // Second pass: read disk chunks for date keys that may have sessions not in memory
-    const memoryDateKeys = memoryState
-        ? new Set(Object.values(memoryState.sessionDateMap))
-        : new Set();
-    const diskDateKeys = dateKeys.filter((dk) => !memoryDateKeys.has(dk));
+    // Second pass: read disk chunks for all date keys in range, then de-dupe by sessionID.
+    // A date can have a mix of in-memory and disk-only sessions.
+    const diskDateKeys = [...dateKeys];
     if (diskDateKeys.length > 0) {
         const RANGE_SCAN_CONCURRENCY = 5;
         const chunkEntries = await mapConcurrent(diskDateKeys, RANGE_SCAN_CONCURRENCY, async (dateKey) => {
@@ -332,6 +358,8 @@ export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Dat
         for (const entry of chunkEntries.flat()) {
             if (seenSessionIDs.has(entry.sessionID))
                 continue;
+            if (deletedSessionIDs.has(entry.sessionID))
+                continue;
             const createdAt = Number.isFinite(entry.state.createdAt) && entry.state.createdAt > 0
                 ? entry.state.createdAt
                 : dateStartFromKey(entry.dateKey);
@@ -343,6 +371,43 @@ export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Dat
     }
     return results;
 }
+export async function scanAllSessions(statePath, memoryState) {
+    const rootPath = chunkRootPathFromStateFile(statePath);
+    const deletedSessionIDs = new Set(Object.keys(memoryState?.deletedSessionDateMap || {}));
+    const results = [];
+    const seenSessionIDs = new Set();
+    if (memoryState) {
+        for (const [sessionID, sessionState] of Object.entries(memoryState.sessions)) {
+            if (deletedSessionIDs.has(sessionID))
+                continue;
+            const dateKey = memoryState.sessionDateMap[sessionID] ||
+                dateKeyFromTimestamp(sessionState.createdAt);
+            results.push({ sessionID, dateKey, state: sessionState });
+            seenSessionIDs.add(sessionID);
+        }
+    }
+    const dateKeys = await discoverChunks(rootPath);
+    if (dateKeys.length === 0)
+        return results;
+    const RANGE_SCAN_CONCURRENCY = 5;
+    const chunkEntries = await mapConcurrent(dateKeys, RANGE_SCAN_CONCURRENCY, async (dateKey) => {
+        const sessions = await readDayChunk(rootPath, dateKey);
+        return Object.entries(sessions).map(([sessionID, state]) => ({
+            sessionID,
+            dateKey,
+            state,
+        }));
+    });
+    for (const entry of chunkEntries.flat()) {
+        if (seenSessionIDs.has(entry.sessionID))
+            continue;
+        if (deletedSessionIDs.has(entry.sessionID))
+            continue;
+        results.push(entry);
+        seenSessionIDs.add(entry.sessionID);
+    }
+    return results;
+}
 /** Best-effort: remove a session entry from its day chunk (if present). */
 export async function deleteSessionFromDayChunk(statePath, sessionID, dateKey) {
     const rootPath = chunkRootPathFromStateFile(statePath);

package/dist/storage_chunks.js

@@ -45,14 +45,17 @@ class ChunkCache {
     constructor(maxSize = 64) {
         this.maxSize = maxSize;
     }
-    get(dateKey) {
-        const entry = this.cache.get(dateKey);
+    key(rootPath, dateKey) {
+        return `${path.resolve(rootPath)}::${dateKey}`;
+    }
+    get(rootPath, dateKey) {
+        const entry = this.cache.get(this.key(rootPath, dateKey));
         if (!entry)
             return undefined;
         entry.accessedAt = Date.now();
         return entry.sessions;
     }
-    set(dateKey, sessions) {
+    set(rootPath, dateKey, sessions) {
         if (this.cache.size >= this.maxSize) {
             // Evict least recently accessed
             let oldestKey;
@@ -66,17 +69,20 @@ class ChunkCache {
             if (oldestKey)
                 this.cache.delete(oldestKey);
         }
-        this.cache.set(dateKey, { sessions, accessedAt: Date.now() });
+        this.cache.set(this.key(rootPath, dateKey), {
+            sessions,
+            accessedAt: Date.now(),
+        });
     }
-    invalidate(dateKey) {
-        this.cache.delete(dateKey);
+    invalidate(rootPath, dateKey) {
+        this.cache.delete(this.key(rootPath, dateKey));
     }
 }
 const chunkCache = new ChunkCache();
 export async function readDayChunk(rootPath, dateKey) {
     if (!isDateKey(dateKey))
         return {};
-    const cached = chunkCache.get(dateKey);
+    const cached = chunkCache.get(rootPath, dateKey);
     if (cached)
         return cached;
     const filePath = chunkFilePath(rootPath, dateKey);
@@ -101,7 +107,7 @@ export async function readDayChunk(rootPath, dateKey) {
         acc[sessionID] = parsedSession;
         return acc;
     }, {});
-    chunkCache.set(dateKey, sessions);
+    chunkCache.set(rootPath, dateKey, sessions);
     return sessions;
 }
 /**
@@ -174,13 +180,18 @@ export async function writeDayChunk(rootPath, dateKey, sessions) {
         throw new Error(`unsafe chunk root at ${rootPath}`);
     }
     await mkdirpNoSymlink(rootPath, path.dirname(filePath));
+    if (Object.keys(sessions).length === 0) {
+        await fs.rm(filePath, { force: true }).catch(() => undefined);
+        chunkCache.invalidate(rootPath, dateKey);
+        return;
+    }
     const chunk = {
         version: 1,
         dateKey,
         sessions,
     };
     await safeWriteFile(filePath, `${JSON.stringify(chunk, null, 2)}\n`);
-    chunkCache.invalidate(dateKey);
+    chunkCache.invalidate(rootPath, dateKey);
 }
 export async function discoverChunks(rootPath) {
     const years = await fs.readdir(rootPath).catch(() => []);

package/dist/storage_parse.js

@@ -1,4 +1,5 @@
 import { asNumber, isRecord } from './helpers.js';
+import { normalizeTimestampMs } from './storage_dates.js';
 function parseSessionTitleState(value) {
     if (!isRecord(value))
         return undefined;
@@ -26,6 +27,7 @@ function parseProviderUsage(value) {
         cost: asNumber(value.cost, 0),
         apiCost: asNumber(value.apiCost, 0),
         assistantMessages: asNumber(value.assistantMessages, 0),
+        cacheBuckets: parseCacheUsageBuckets(value.cacheBuckets),
     };
 }
 function parseCacheUsageBucket(value) {
@@ -107,7 +109,7 @@ export function parseSessionState(value) {
     const title = parseSessionTitleState(value);
     if (!title)
         return undefined;
-    const createdAt = asNumber(value.createdAt, 0);
+    const createdAt = normalizeTimestampMs(value.createdAt, 0);
     if (!createdAt)
         return undefined;
     return {
@@ -115,6 +117,7 @@ export function parseSessionState(value) {
         createdAt,
         parentID: typeof value.parentID === 'string' ? value.parentID : undefined,
         usage: parseCachedUsage(value.usage),
+        dirty: value.dirty === true,
         cursor: parseCursor(value.cursor),
     };
 }

package/dist/title.js

@@ -3,16 +3,15 @@ function sanitizeTitleFragment(value) {
         .replace(/[\x00-\x1F\x7F-\x9F]/g, ' ')
         .trimEnd();
 }
-function isStrongDecoratedDetail(line) {
+function isCoreDecoratedDetail(line) {
     if (!line)
         return false;
-    if (/^Input\s+\S+\s+Output(?:\s+\S+)?/.test(line))
+    if (/^Input\s+\$?[\d.,]+[kKmM]?(?:\s+Output(?:\s+\$?[\d.,]+[kKmM]?)?)?~?$/.test(line)) {
         return true;
-    if (/^Cache\s+(Read|Write)\s+\S+/.test(line))
-        return true;
-    if (/^Cache(?:\s+Read)?\s+Coverage\s+\S+/.test(line))
+    }
+    if (/^Cache\s+(Read|Write)\s+\$?\d[\d.,]*[kKmM]?$/.test(line))
         return true;
-    if (/^\$\S+\s+as API cost\b/.test(line))
+    if (/^\$\S+\s+as API cost$/.test(line))
         return true;
     // Single-line compact mode compatibility.
     if (/^I(?:nput)?\s+\$?\d[\d.,]*[kKmM]?\s+O(?:utput)?\s+\$?\d[\d.,]*[kKmM]?$/.test(line))
@@ -23,12 +22,26 @@ function isStrongDecoratedDetail(line) {
         return true;
     return false;
 }
-function isQuotaLikeProviderDetail(line) {
+function isSingleLineDecoratedPrefix(line) {
     if (!line)
         return false;
-    if (!/^(OpenAI|Copilot|Anthropic|RightCode|RC)\b/.test(line))
-        return false;
-    return /\b(Rst|Exp\+?|Balance|Remaining)\b|\d{1,3}%/.test(line);
+    if (/^Input\s+\$?[\d.,]+[kKmM]?~?$/.test(line))
+        return true;
+    if (/^Input\s+\$?[\d.,]+[kKmM]?\s+Output(?:\s+\$?[\d.,]+[kKmM]?~?)?$/.test(line)) {
+        return true;
+    }
+    if (/^Cache\s+(Read|Write)\s+\$?\d[\d.,]*[kKmM]?(?:~|$)/.test(line)) {
+        return true;
+    }
+    if (/^Cache(?:\s+Read)?\s+Coverage\s+\d[\d.,]*(?:%|~)$/.test(line)) {
+        return true;
+    }
+    if (/^\$\S+\s+as API cost(?:~|$)/.test(line))
+        return true;
+    return false;
+}
+function isSingleLineDetailPrefix(line) {
+    return isCoreDecoratedDetail(line) || isSingleLineDecoratedPrefix(line);
 }
 function decoratedSingleLineBase(line) {
     const parts = sanitizeTitleFragment(line)
@@ -36,18 +49,28 @@ function decoratedSingleLineBase(line) {
         .map((part) => part.trim());
     if (parts.length < 2)
         return undefined;
+    if (isSingleLineDetailPrefix(parts[0] || ''))
+        return undefined;
     const details = parts.slice(1);
-    if (!details.some((detail) => isStrongDecoratedDetail(detail))) {
+    if (!details.some((detail) => isSingleLineDetailPrefix(detail))) {
         return undefined;
     }
     return parts[0] || 'Session';
 }
 export function normalizeBaseTitle(title) {
-    const firstLine = stripAnsi(title).split(/\r?\n/, 1)[0] || 'Session';
+    const safeTitle = canonicalizeTitle(title) || 'Session';
+    const firstLine = stripAnsi(safeTitle).split(/\r?\n/, 1)[0] || 'Session';
     const decoratedBase = decoratedSingleLineBase(firstLine);
     if (decoratedBase)
         return decoratedBase;
-    return sanitizeTitleFragment(firstLine) || 'Session';
+    const lines = stripAnsi(safeTitle).split(/\r?\n/);
+    if (lines.length > 1) {
+        const detail = lines.slice(1).map((line) => sanitizeTitleFragment(line).trim());
+        if (detail.some((line) => isCoreDecoratedDetail(line))) {
+            return sanitizeTitleFragment(firstLine) || 'Session';
+        }
+    }
+    return safeTitle;
 }
 export function stripAnsi(value) {
     // Remove terminal escape sequences. Sidebar titles must be plain text.
@@ -93,6 +116,5 @@ export function looksDecorated(title) {
     const detail = lines
         .slice(1)
         .map((line) => sanitizeTitleFragment(line).trim());
-    return (detail.some((line) => isStrongDecoratedDetail(line)) ||
-        detail.some((line) => isQuotaLikeProviderDetail(line)));
+    return detail.some((line) => isCoreDecoratedDetail(line));
 }