sidekick-shared 0.21.4 → 0.21.6

package/README.md

@@ -9,6 +9,7 @@ Types, parsers, providers, readers, formatters, aggregation, search, reporting,
 
 ## Recent additions
 
+- **Codex reset credits** — `fetchCodexResetCreditsFromApi()` reads ChatGPT's reset-credit endpoint into a `CodexResetCreditsSnapshot`, and `fetchCodexQuotaFromApi()` attaches it to the returned quota state (preserved across session-sourced snapshot writes).
 - **Assistant-turn projection** — `segmentAssistantTurn()` / `assistantTurnEventsFromSessionEvents()` segment a provider-normalized turn into a browser-safe Timeline + Process + Answer shape (see [Assistant Turns](#api-overview)).
 - **Session-context snapshots** — `buildSessionContextSnapshot()` / `calculateSessionContextPressure()` expose layered evidence sources and low/medium/high context pressure.
 - **Zod boundary schemas** — runtime validation for data crossing process/IPC boundaries, importable fs-free from [`sidekick-shared/schemas`](#supported-import-paths).
@@ -25,34 +26,34 @@ npm install sidekick-shared
 
 ## API Overview
 
-| Module                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Types**                       | Session events, OpenCode/Codex format types, persistence schemas (tasks, decisions, notes, plans, historical data)                                                                                                                                                                                                                                                                                                                                                                                                            |
-| **Paths**                       | Config directory resolution, project data paths, workspace encoding                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| **Readers**                     | Read tasks, decisions, notes, history, handoff, and plans from `~/.config/sidekick/`                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| **Providers**                   | Session provider abstraction with Claude Code, OpenCode, and Codex implementations; auto-detection via filesystem                                                                                                                                                                                                                                                                                                                                                                                                             |
-| **Parsers**                     | JSONL event parsing, OpenCode/Codex format normalization, subagent scanning, session path resolution, debug log parsing                                                                                                                                                                                                                                                                                                                                                                                                       |
-| **Watchers**                    | Live session file watching with event bridging, plus `createJsonlTail()` for raw incremental JSONL consumers                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| **Formatters**                  | Display helpers (`formatTokenCount()`, `formatDurationMs()`), tool summary, noise classification, session dump (text/markdown/JSON), event highlighting                                                                                                                                                                                                                                                                                                                                                                       |
-| **Search**                      | Cross-session full-text search, advanced filtering (substring, fuzzy, regex, date)                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| **Aggregation**                 | Event aggregation, frequency tracking, activity heatmaps, pattern extraction                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| **Session Context**             | Provider-neutral context evidence snapshots (`buildSessionContextSnapshot()`, `calculateSessionContextPressure()`, `createSessionContextProjector()`, `readSessionContextSnapshot()`): layered evidence sources, low/medium/high context pressure, and observed capabilities (tools, MCP servers, permission mode, rate limits)                                                                                                                                                                                               |
-| **Assistant Turns**             | Browser-safe timeline/process/answer projection for provider-normalized assistant turns (`segmentAssistantTurn()`, `assistantTurnEventsFromSessionEvents()`), including interleaved reasoning, compact tool groups, and Claude `Task` subagent refs without prompt leakage                                                                                                                                                                                                                                                    |
-| **Report**                      | Self-contained HTML session report generation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| **Credentials**                 | Claude Max OAuth credential reading from `~/.claude/.credentials.json`                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| **Quota**                       | Claude Max subscription quota fetching (5-hour and 7-day windows), Codex rate-limit extraction from event streams, and authoritative z.ai Coding Plan quota fetching via `resolveZaiQuota()` / `fetchZaiQuotaFromApi()` (reads z.ai's `api/monitor/usage/quota/limit` endpoint with cached-snapshot fallback). The deprecated observed-traffic z.ai estimator helpers remain exported for backward compatibility only                                                                                                         |
-| **Provider Status**             | API health checking via status.claude.com and status.openai.com (indicator, components, incidents)                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| **Schemas**                     | Zod schemas for runtime validation of data crossing process/IPC boundaries — JSONL session events (`sessionEventSchema`, `messageUsageSchema`, `sessionMessageSchema`), assistant turns, quota, account status, and quota history — plus `extractSessionEvents()` to unwrap `progress`-wrapped events. Also published fs-free via the [`sidekick-shared/schemas`](#supported-import-paths) subpath                                                                                                                            |
-| **Extractors**                  | Pure functions for single-event processing: `extractTokenUsage()`, `extractToolCall()` (top-level `tool_use`), `extractToolCalls()` (assistant content blocks), plus Node-only session asset extraction (`gatherAssetsForCwd()`, `readClaudeAssets()`, `readCodexAssets()`) for URLs, file paths, commands, and plans                                                                                                                                                                                                         |
-| **Model Info & Pricing**        | Model family parsing (Anthropic / OpenAI / Google, including legacy `claude-3-opus-…` and `claude-3-5-sonnet-…` IDs), context-window lookup (including Fable 5 / Opus 4.8 / Opus 4.7 / Sonnet 4.7 1M and GPT-5.x variants), pricing tables with optional LiteLLM hydration, null-aware cost (`calculateCost()`), provenance-preserving cost (`calculateCostWithProvenance()`, `mergeCostSources()`), and display helpers (`shortModelName()`, `getModelDisplayInfo()`, `compareModelIds()`, `sortModelIds()`, `formatCost()`) |
-| **Quota Polling**               | `QuotaPoller` class with exponential backoff, active/idle intervals, and cached fallback                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| **Multi-Provider Quota**        | `MultiProviderQuotaService` orchestrates Claude polling + peak-hours + account labels + Codex/z.ai quota updates behind one typed event stream. `CodexQuotaWatcher` watches the active Codex rollout for live rate limits with snapshot fallback; z.ai quota uses the API resolver with snapshot fallback                                                                                                                                                                                                                     |
-| **Accounts**                    | Multi-provider account registry (v2) with per-provider active account, save/switch/remove, v1 migration, `ensureDefaultAccounts()` for first-run bootstrap of the active system Claude/Codex credentials as a "Default" saved account, `getActiveAccountStatus()` for a single-pass active-account read across providers, and live-first `resolveActiveClaudeAccount()` / `resolveActiveCodexAccount()` that report the currently logged-in account (self-healing the saved pointer) for display                              |
-| **Account Management 2.0**      | Provider-neutral acquisition + switching: `beginAccountLogin()` / `getAccountLoginStatus()` / `finalizeAccountLogin()` / `spawnAccountLogin()` drive a TTY-less, profile-isolated login that doesn't disturb the active account until finalization; `listAllAccounts()` and `switchAccount()` expose a shared switcher across Claude and Codex. Claude accounts get canonical profile homes with account-scoped macOS keychain suffixes and startup migration from legacy flat backups                                        |
-| **Terminal sync & auto-switch** | Opt-in terminal profile pointers, shell-hook/launcher helpers, and a default-off `AutoSwitchController` (`decideAutoSwitch()`) that moves to a healthier saved account when quota crosses a configured threshold                                                                                                                                                                                                                                                                                                              |
-| **Codex Profiles**              | Codex account lifecycle — prepare, finalize, switch, remove — switching atomically swaps the profile's backed-up credentials into the system `~/.codex/auth.json`, with rotated-token staleness protection, one-time dual-home migration, and legacy multi-home session monitoring                                                                                                                                                                                                                                            |
-| **Quota Snapshots**             | Persistent quota caching per provider/account for offline fallback                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| **Phrases**                     | Curated humorous phrases for loading/idle states, available as a flat `ALL_PHRASES` array or grouped via `PHRASE_CATEGORIES` for category-aware UI                                                                                                                                                                                                                                                                                                                                                                            |
+| Module                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Types**                       | Session events, OpenCode/Codex format types, persistence schemas (tasks, decisions, notes, plans, historical data)                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| **Paths**                       | Config directory resolution, project data paths, workspace encoding                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| **Readers**                     | Read tasks, decisions, notes, history, handoff, and plans from `~/.config/sidekick/`                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| **Providers**                   | Session provider abstraction with Claude Code, OpenCode, and Codex implementations; auto-detection via filesystem                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| **Parsers**                     | JSONL event parsing, OpenCode/Codex format normalization, subagent scanning, session path resolution, debug log parsing                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| **Watchers**                    | Live session file watching with event bridging, plus `createJsonlTail()` for raw incremental JSONL consumers                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **Formatters**                  | Display helpers (`formatTokenCount()`, `formatDurationMs()`), tool summary, noise classification, session dump (text/markdown/JSON), event highlighting                                                                                                                                                                                                                                                                                                                                                                                       |
+| **Search**                      | Cross-session full-text search, advanced filtering (substring, fuzzy, regex, date)                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| **Aggregation**                 | Event aggregation, frequency tracking, activity heatmaps, pattern extraction                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **Session Context**             | Provider-neutral context evidence snapshots (`buildSessionContextSnapshot()`, `calculateSessionContextPressure()`, `createSessionContextProjector()`, `readSessionContextSnapshot()`): layered evidence sources, low/medium/high context pressure, and observed capabilities (tools, MCP servers, permission mode, rate limits)                                                                                                                                                                                                               |
+| **Assistant Turns**             | Browser-safe timeline/process/answer projection for provider-normalized assistant turns (`segmentAssistantTurn()`, `assistantTurnEventsFromSessionEvents()`), including interleaved reasoning, compact tool groups, and Claude `Task` subagent refs without prompt leakage                                                                                                                                                                                                                                                                    |
+| **Report**                      | Self-contained HTML session report generation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| **Credentials**                 | Claude Max OAuth credential reading from `~/.claude/.credentials.json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| **Quota**                       | Claude Max subscription quota fetching (5-hour and 7-day windows), Codex rate-limit extraction from event streams (plus Codex reset credits via `fetchCodexResetCreditsFromApi()`, attached to quota state by `fetchCodexQuotaFromApi()`), and authoritative z.ai Coding Plan quota fetching via `resolveZaiQuota()` / `fetchZaiQuotaFromApi()` (reads z.ai's `api/monitor/usage/quota/limit` endpoint with cached-snapshot fallback). The deprecated observed-traffic z.ai estimator helpers remain exported for backward compatibility only |
+| **Provider Status**             | API health checking via status.claude.com and status.openai.com (indicator, components, incidents)                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| **Schemas**                     | Zod schemas for runtime validation of data crossing process/IPC boundaries — JSONL session events (`sessionEventSchema`, `messageUsageSchema`, `sessionMessageSchema`), assistant turns, quota, account status, and quota history — plus `extractSessionEvents()` to unwrap `progress`-wrapped events. Also published fs-free via the [`sidekick-shared/schemas`](#supported-import-paths) subpath                                                                                                                                            |
+| **Extractors**                  | Pure functions for single-event processing: `extractTokenUsage()`, `extractToolCall()` (top-level `tool_use`), `extractToolCalls()` (assistant content blocks), plus Node-only session asset extraction (`gatherAssetsForCwd()`, `readClaudeAssets()`, `readCodexAssets()`) for URLs, file paths, commands, and plans                                                                                                                                                                                                                         |
+| **Model Info & Pricing**        | Model family parsing (Anthropic / OpenAI / Google, including legacy `claude-3-opus-…` and `claude-3-5-sonnet-…` IDs), context-window lookup (including Fable 5 / Opus 4.8 / Opus 4.7 / Sonnet 4.7 1M and GPT-5.x variants), pricing tables with optional LiteLLM hydration, null-aware cost (`calculateCost()`), provenance-preserving cost (`calculateCostWithProvenance()`, `mergeCostSources()`), and display helpers (`shortModelName()`, `getModelDisplayInfo()`, `compareModelIds()`, `sortModelIds()`, `formatCost()`)                 |
+| **Quota Polling**               | `QuotaPoller` class with exponential backoff, active/idle intervals, and cached fallback                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| **Multi-Provider Quota**        | `MultiProviderQuotaService` orchestrates Claude polling + peak-hours + account labels + Codex/z.ai quota updates behind one typed event stream. `CodexQuotaWatcher` watches the active Codex rollout for live rate limits with snapshot fallback; z.ai quota uses the API resolver with snapshot fallback                                                                                                                                                                                                                                     |
+| **Accounts**                    | Multi-provider account registry (v2) with per-provider active account, save/switch/remove, v1 migration, `ensureDefaultAccounts()` for first-run bootstrap of the active system Claude/Codex credentials as a "Default" saved account, `getActiveAccountStatus()` for a single-pass active-account read across providers, and live-first `resolveActiveClaudeAccount()` / `resolveActiveCodexAccount()` that report the currently logged-in account (self-healing the saved pointer) for display                                              |
+| **Account Management 2.0**      | Provider-neutral acquisition + switching: `beginAccountLogin()` / `getAccountLoginStatus()` / `finalizeAccountLogin()` / `spawnAccountLogin()` drive a TTY-less, profile-isolated login that doesn't disturb the active account until finalization; `listAllAccounts()` and `switchAccount()` expose a shared switcher across Claude and Codex. Claude accounts get canonical profile homes with account-scoped macOS keychain suffixes and startup migration from legacy flat backups                                                        |
+| **Terminal sync & auto-switch** | Opt-in terminal profile pointers, shell-hook/launcher helpers, and a default-off `AutoSwitchController` (`decideAutoSwitch()`) that moves to a healthier saved account when quota crosses a configured threshold                                                                                                                                                                                                                                                                                                                              |
+| **Codex Profiles**              | Codex account lifecycle — prepare, finalize, switch, remove — switching atomically swaps the profile's backed-up credentials into the system `~/.codex/auth.json`, with rotated-token staleness protection, one-time dual-home migration, and legacy multi-home session monitoring                                                                                                                                                                                                                                                            |
+| **Quota Snapshots**             | Persistent quota caching per provider/account for offline fallback                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| **Phrases**                     | Curated humorous phrases for loading/idle states, available as a flat `ALL_PHRASES` array or grouped via `PHRASE_CATEGORIES` for category-aware UI                                                                                                                                                                                                                                                                                                                                                                                            |
 
 ## Supported import paths
 

package/dist/codexQuota.d.ts

@@ -1,4 +1,4 @@
-import type { QuotaState } from './quota';
+import type { CodexResetCreditsSnapshot, QuotaState } from './quota';
 import { CodexProvider } from './providers/codex';
 import type { ProviderQuotaState } from './providerQuota';
 import type { SavedAccountProfile } from './accountRegistry';
@@ -27,8 +27,10 @@ export interface CodexQuotaResolveOptions {
 export interface CodexQuotaApiOptions {
     codexHome?: string;
     accessToken?: string;
+    accountId?: string;
     fetchImpl?: typeof fetch;
     usageUrl?: string;
+    resetCreditsUrl?: string;
     capturedAt?: string;
 }
 export declare function quotaFromCodexRateLimits(rateLimits: CodexRateLimits | null | undefined, source?: 'api' | 'session' | 'cache', capturedAt?: string): QuotaState | null;
@@ -40,4 +42,5 @@ export declare function readLatestCodexQuotaFromRollouts(sessionPaths: string[],
 export declare function resolveCodexQuotaFromLocalSources(options?: CodexQuotaResolveOptions): ProviderQuotaState<'codex'> | null;
 export declare function resolveCodexQuota(options?: CodexQuotaResolveOptions): Promise<ProviderQuotaState<'codex'>>;
 export declare function fetchCodexQuotaFromApi(options?: CodexQuotaApiOptions): Promise<QuotaState>;
+export declare function fetchCodexResetCreditsFromApi(options?: CodexQuotaApiOptions): Promise<CodexResetCreditsSnapshot | undefined>;
 export {};

package/dist/codexQuota.js

@@ -38,15 +38,18 @@ exports.readLatestCodexQuotaFromRollouts = readLatestCodexQuotaFromRollouts;
 exports.resolveCodexQuotaFromLocalSources = resolveCodexQuotaFromLocalSources;
 exports.resolveCodexQuota = resolveCodexQuota;
 exports.fetchCodexQuotaFromApi = fetchCodexQuotaFromApi;
+exports.fetchCodexResetCreditsFromApi = fetchCodexResetCreditsFromApi;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const codexProfiles_1 = require("./codexProfiles");
 const quotaSnapshots_1 = require("./quotaSnapshots");
 const quota_1 = require("./quota");
 const codex_1 = require("./providers/codex");
+const codex_2 = require("./types/codex");
 const DEFAULT_TAIL_BYTES = 2 * 1024 * 1024;
 const DEFAULT_MAX_SESSION_FILES = 50;
 const CHATGPT_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
+const CHATGPT_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
 function timestampMs(value, fallbackMs = 0) {
     if (!value)
         return fallbackMs;
@@ -54,11 +57,19 @@ function timestampMs(value, fallbackMs = 0) {
     return Number.isFinite(ms) ? ms : fallbackMs;
 }
 // Codex can report slightly different percentages for the same reset window
-// across recent sessions. Prefer newer reset windows, then the highest observed
-// same-window utilization so local fallbacks do not under-report quota usage.
+// across recent sessions. Prefer the aggregate plan family ("codex") over
+// model/feature-specific families (which can read 0% while the plan is busy),
+// then newer reset windows, then the highest observed same-window utilization so
+// local fallbacks do not under-report quota usage.
 function isPreferredQuotaHit(candidate, current) {
     if (!current)
         return true;
+    // Family rank first: an aggregate hit always outranks a model-specific one, so a
+    // freshly-used per-model family (e.g. codex_bengalfox at 0%) can never mask the plan quota.
+    const candidateAggregate = (0, codex_2.isAggregateCodexLimit)(candidate.quota.limitId);
+    const currentAggregate = (0, codex_2.isAggregateCodexLimit)(current.quota.limitId);
+    if (candidateAggregate !== currentAggregate)
+        return candidateAggregate;
     const candidatePrimaryReset = timestampMs(candidate.quota.fiveHour.resetsAt);
     const currentPrimaryReset = timestampMs(current.quota.fiveHour.resetsAt);
     if (candidatePrimaryReset !== currentPrimaryReset)
@@ -140,6 +151,37 @@ function normalizeCredits(credits) {
         balance: credits.balance ?? undefined,
     };
 }
+function normalizeCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function normalizeResetCreditsPayload(payload, capturedAt) {
+    const credits = Array.isArray(payload.credits)
+        ? payload.credits.flatMap((credit) => {
+            const status = firstString(credit.status);
+            const expiresAt = firstString(credit.expires_at);
+            if (!status || !expiresAt)
+                return [];
+            return [
+                {
+                    title: firstString(credit.title),
+                    status,
+                    resetType: firstString(credit.reset_type),
+                    expiresAt,
+                    grantedAt: firstString(credit.granted_at),
+                },
+            ];
+        })
+        : [];
+    return {
+        availableCount: normalizeCount(payload.available_count),
+        totalEarnedCount: typeof payload.total_earned_count === 'number' && Number.isFinite(payload.total_earned_count)
+            ? payload.total_earned_count
+            : undefined,
+        credits,
+        source: 'api',
+        capturedAt,
+    };
+}
 function normalizeRateLimitReachedType(value) {
     if (typeof value === 'string')
         return value;
@@ -354,7 +396,10 @@ async function resolveCodexQuota(options = {}) {
 }
 async function fetchCodexQuotaFromApi(options = {}) {
     const capturedAt = options.capturedAt ?? new Date().toISOString();
-    const accessToken = options.accessToken ?? readCodexAccessToken(options.codexHome ?? (0, codexProfiles_1.resolveSidekickCodexHome)());
+    const auth = options.accessToken != null
+        ? { accessToken: options.accessToken, accountId: options.accountId }
+        : readCodexAuth(options.codexHome ?? (0, codexProfiles_1.resolveSidekickCodexHome)());
+    const accessToken = auth?.accessToken;
     if (!accessToken) {
         return {
             fiveHour: { utilization: 0, resetsAt: '' },
@@ -418,6 +463,15 @@ async function fetchCodexQuotaFromApi(options = {}) {
                 sevenDayLabel: 'Secondary',
             };
         }
+        const resetCredits = await fetchCodexResetCreditsFromApi({
+            ...options,
+            accessToken,
+            accountId: auth?.accountId,
+            capturedAt,
+        });
+        if (resetCredits) {
+            quota.resetCredits = resetCredits;
+        }
         return quota;
     }
     catch {
@@ -435,12 +489,49 @@ async function fetchCodexQuotaFromApi(options = {}) {
         };
     }
 }
-function readCodexAccessToken(codexHome) {
+async function fetchCodexResetCreditsFromApi(options = {}) {
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const auth = options.accessToken != null
+        ? { accessToken: options.accessToken, accountId: options.accountId }
+        : readCodexAuth(options.codexHome ?? (0, codexProfiles_1.resolveSidekickCodexHome)());
+    const accessToken = auth?.accessToken;
+    if (!accessToken)
+        return undefined;
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const headers = {
+            Authorization: `Bearer ${accessToken}`,
+            originator: 'Codex Desktop',
+            'OAI-Product-Sku': 'CODEX',
+            Accept: 'application/json',
+        };
+        if (auth?.accountId) {
+            headers['ChatGPT-Account-ID'] = auth.accountId;
+        }
+        const response = await fetchImpl(options.resetCreditsUrl ?? CHATGPT_RESET_CREDITS_URL, {
+            method: 'GET',
+            headers,
+        });
+        if (!response.ok)
+            return undefined;
+        return normalizeResetCreditsPayload((await response.json()), capturedAt);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCodexAuth(codexHome) {
     try {
         const parsed = JSON.parse(fs.readFileSync(path.join(codexHome, 'auth.json'), 'utf8'));
         if (parsed.OPENAI_API_KEY || parsed.auth_mode === 'api_key')
             return null;
-        return parsed.tokens?.access_token || null;
+        const accessToken = parsed.tokens?.access_token;
+        if (!accessToken)
+            return null;
+        return {
+            accessToken,
+            accountId: parsed.tokens?.account_id,
+        };
     }
     catch {
         return null;
@@ -464,7 +555,11 @@ function readLatestQuotaFromRollout(sessionPath, maxTailBytes, source) {
             const firstNewline = text.indexOf('\n');
             text = firstNewline >= 0 ? text.slice(firstNewline + 1) : '';
         }
+        // Scan from the end for the latest aggregate ("codex") rate-limit sample, which
+        // is what the plan quota represents. Keep the latest sample of any family as a
+        // fallback so a model-only session still surfaces something.
         const lines = text.split('\n');
+        let fallback = null;
         for (let i = lines.length - 1; i >= 0; i--) {
             const line = lines[i].trim();
             if (!line || !line.includes('rate_limits'))
@@ -474,13 +569,20 @@ function readLatestQuotaFromRollout(sessionPath, maxTailBytes, source) {
                 if (parsed.type !== 'event_msg' || parsed.payload?.type !== 'token_count')
                     continue;
                 const quota = quotaFromCodexRateLimits(parsed.payload.rate_limits, source, parsed.timestamp ?? new Date(stat.mtime).toISOString());
-                if (quota)
-                    return { quota, filePath: sessionPath, mtimeMs: stat.mtime.getTime() };
+                if (!quota)
+                    continue;
+                const hit = { quota, filePath: sessionPath, mtimeMs: stat.mtime.getTime() };
+                if ((0, codex_2.isAggregateCodexLimit)(quota.limitId))
+                    return hit;
+                if (!fallback)
+                    fallback = hit;
             }
             catch {
                 // Ignore malformed or partial lines.
             }
         }
+        if (fallback)
+            return fallback;
     }
     catch {
         return null;

package/dist/codexQuotaWatcher.js

@@ -208,26 +208,31 @@ class CodexQuotaWatcher {
             return;
         }
         const account = this.getActiveAccount();
+        const cached = account ? this.readSnapshot('codex', account.id) : null;
+        const liveQuotaWithResetCredits = {
+            ...liveQuota,
+            resetCredits: liveQuota.resetCredits ?? cached?.resetCredits,
+        };
         if (account) {
-            this.writeSnapshot('codex', account.id, liveQuota);
+            this.writeSnapshot('codex', account.id, liveQuotaWithResetCredits);
             if (this.workspaceId) {
                 const sample = {
-                    timestamp: liveQuota.capturedAt ?? new Date().toISOString(),
+                    timestamp: liveQuotaWithResetCredits.capturedAt ?? new Date().toISOString(),
                     runtimeProvider: 'codex',
                     providerId: account.id,
                     workspaceId: this.workspaceId,
                     fiveHour: {
-                        utilization: liveQuota.fiveHour.utilization,
-                        resetsAt: liveQuota.fiveHour.resetsAt,
+                        utilization: liveQuotaWithResetCredits.fiveHour.utilization,
+                        resetsAt: liveQuotaWithResetCredits.fiveHour.resetsAt,
                     },
                     sevenDay: {
-                        utilization: liveQuota.sevenDay.utilization,
-                        resetsAt: liveQuota.sevenDay.resetsAt,
+                        utilization: liveQuotaWithResetCredits.sevenDay.utilization,
+                        resetsAt: liveQuotaWithResetCredits.sevenDay.resetsAt,
                     },
-                    available: liveQuota.available,
-                    error: liveQuota.error,
-                    source: liveQuota.source,
-                    stale: liveQuota.stale,
+                    available: liveQuotaWithResetCredits.available,
+                    error: liveQuotaWithResetCredits.error,
+                    source: liveQuotaWithResetCredits.source,
+                    stale: liveQuotaWithResetCredits.stale,
                 };
                 try {
                     const result = this.appendHistorySample(sample);
@@ -243,7 +248,7 @@ class CodexQuotaWatcher {
             }
         }
         this.emitState(enrichQuotaState({
-            ...liveQuota,
+            ...liveQuotaWithResetCredits,
             runtimeProvider: 'codex',
             providerId: 'codex',
         }, account));

package/dist/index.d.ts

@@ -4,6 +4,7 @@
 export type { SessionEvent, ClaudeSessionEvent, MessageUsage, SessionMessage, TokenUsage, ToolCall, ToolAnalytics, TimelineEvent, PendingToolCall, TaskStatus as SessionTaskStatus, TrackedTask, TaskState, SubagentStats, PendingUserRequest, ResponseLatency, LatencyStats, PlanStep, PlanState, SessionStats, CompactionEvent, TruncationEvent, ContextAttribution, TurnAttribution, ContextSizePoint, PermissionMode, PermissionModeChange, } from './types/sessionEvent';
 export type { OpenCodeSession, OpenCodeMessage, OpenCodePart, OpenCodeTextPart, OpenCodeReasoningPart, OpenCodeToolInvocationPart, OpenCodeCompactionPart, OpenCodeDbToolPart, OpenCodeStepStartPart, OpenCodeStepFinishPart, OpenCodePatchPart, OpenCodeSubtaskPart, OpenCodeAgentPart, OpenCodeFilePart, OpenCodeRetryPart, OpenCodeSnapshotPart, OpenCodeProject, DbProject as OpenCodeDbProject, DbSession as OpenCodeDbSession, DbMessage as OpenCodeDbMessage, DbPart as OpenCodeDbPart, } from './types/opencode';
 export type { CodexRolloutLine, CodexSessionMeta, CodexResponseItem, CodexMessageItem, CodexContentPart, CodexReasoningItem, CodexFunctionCallItem, CodexFunctionCallOutputItem, CodexLocalShellCallItem, CodexWebSearchCallItem, CodexCustomToolCallItem, CodexCustomToolCallOutputItem, CodexCompacted, CodexTurnContext, CodexEventMsg, CodexEvent, CodexTurnStartedEvent, CodexTurnCompleteEvent, CodexTaskStartedEvent, CodexTaskCompleteEvent, CodexTurnAbortedEvent, CodexTokenCountEvent, CodexTokenUsage, CodexRateLimits, CodexAgentMessageEvent, CodexAgentReasoningEvent, CodexUserMessageEvent, CodexExecCommandBeginEvent, CodexExecCommandEndEvent, CodexMcpToolCallBeginEvent, CodexMcpToolCallEndEvent, CodexErrorEvent, CodexContextCompactedEvent, CodexPatchAppliedEvent, CodexBackgroundEvent, CodexGenericEvent, CodexDbThread, CodexReasoningSummary, } from './types/codex';
+export { isAggregateCodexLimit } from './types/codex';
 export type { PersistedTask, TaskPersistenceStore, TaskStatus } from './types/taskPersistence';
 export { TASK_PERSISTENCE_SCHEMA_VERSION, normalizeTaskStatus } from './types/taskPersistence';
 export type { DecisionEntry, DecisionLogStore, DecisionSource } from './types/decisionLog';
@@ -109,7 +110,7 @@ export { setTerminalActiveProfile, installShellHook, uninstallShellHook, isShell
 export { DEFAULT_AUTO_SWITCH_CONFIG, decideAutoSwitch, AutoSwitchController } from './autoSwitch';
 export type { AutoSwitchActiveAccount, AutoSwitchCandidate, AutoSwitchConfig, AutoSwitchControllerOptions, AutoSwitchDecision, AutoSwitchTransitionEvent, } from './autoSwitch';
 export { FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
-export type { QuotaProjectionInput, QuotaWindow, QuotaState } from './quota';
+export type { CodexResetCredit, CodexResetCreditsSnapshot, QuotaProjectionInput, QuotaWindow, QuotaState, } from './quota';
 export { describeQuotaFailure } from './quotaPresentation';
 export type { QuotaFailureDescriptor } from './quotaPresentation';
 export { QuotaPoller } from './quotaPoller';
@@ -117,7 +118,7 @@ export type { QuotaPollerOptions } from './quotaPoller';
 export { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
 export { appendQuotaHistorySample, readQuotaHistoryRange, readQuotaHistoryDailyBuckets, pruneQuotaHistory, getWorkspaceIdFromPath, } from './quotaHistory';
 export type { QuotaHistorySample, QuotaHistoryAppendOptions, QuotaHistoryRangeOptions, QuotaHistoryDailyBucket, QuotaHistoryRuntimeProvider, } from './quotaHistory';
-export { fetchCodexQuotaFromApi, quotaFromCodexRateLimits, readLatestCodexQuotaFromRollouts, resolveCodexQuota, resolveCodexQuotaFromLocalSources, } from './codexQuota';
+export { fetchCodexResetCreditsFromApi, fetchCodexQuotaFromApi, quotaFromCodexRateLimits, readLatestCodexQuotaFromRollouts, resolveCodexQuota, resolveCodexQuotaFromLocalSources, } from './codexQuota';
 export type { CodexQuotaApiOptions, CodexQuotaCreditsSnapshot, CodexQuotaResolveOptions, CodexQuotaResolveSource, } from './codexQuota';
 export { CodexQuotaWatcher } from './codexQuotaWatcher';
 export type { CodexQuotaWatcherOptions } from './codexQuotaWatcher';
@@ -145,7 +146,7 @@ export { readCodexAssets, codexSessions } from './extractors/sources/codexAssets
 export { gatherAssetsForCwd } from './extractors/gatherAssets';
 export type { GatherAssetsOptions, GatherAssetsResult } from './extractors/gatherAssets';
 export { messageUsageSchema, sessionMessageSchema, sessionEventSchema, permissionModeSchema, extractSessionEvents, } from './schemas/sessionEvent';
-export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './schemas/quota';
+export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './schemas/quota';
 export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHistoryDailyBucketSchema, } from './schemas/quotaHistory';
 export { activeProviderAccountStatusSchema, activeAccountStatusSchema, } from './schemas/accountStatus';
 export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, } from './schemas/accountManager';

package/dist/index.js

@@ -3,12 +3,14 @@
  * Public API for sidekick-shared.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverSessionDirectory = exports.getClaudeSessionDirectory = exports.encodeClaudeWorkspacePath = exports.detectSessionActivity = exports.extractTaskInfo = exports.scanSubagentDir = exports.normalizeCodexToolInput = exports.normalizeCodexToolName = exports.extractPatchFilePaths = exports.CodexRolloutParser = exports.parseDbPartData = exports.parseDbMessageData = exports.convertOpenCodeMessage = exports.detectPlanModeFromText = exports.normalizeToolInput = exports.normalizeToolName = exports.TRUNCATION_PATTERNS = exports.JsonlParser = exports.CodexProvider = exports.getOpenCodeDataDir = exports.OpenCodeProvider = exports.ClaudeCodeProvider = exports.getAllDetectedProviders = exports.detectProvider = exports.readClaudeCodePlanFiles = exports.getPlanAnalytics = exports.writePlans = exports.getLatestPlan = exports.readPlans = exports.readLatestHandoff = exports.readHistory = exports.readNotes = exports.readDecisions = exports.readTasks = exports.getProjectSlugRaw = exports.getProjectSlug = exports.encodeWorkspacePath = exports.getGlobalDataPath = exports.getProjectDataPath = exports.getConfigDir = exports.MAX_PLANS_PER_PROJECT = exports.PLAN_SCHEMA_VERSION = exports.createEmptyTokenTotals = exports.HISTORICAL_DATA_SCHEMA_VERSION = exports.STALENESS_THRESHOLDS = exports.IMPORTANCE_DECAY_FACTORS = exports.KNOWLEDGE_NOTE_SCHEMA_VERSION = exports.DECISION_LOG_SCHEMA_VERSION = exports.normalizeTaskStatus = exports.TASK_PERSISTENCE_SCHEMA_VERSION = void 0;
-exports.highlightEvent = exports.formatSessionJson = exports.formatSessionMarkdown = exports.formatSessionText = exports.classifyNoise = exports.shouldMergeWithPrevious = exports.classifyFollowEvent = exports.classifyMessage = exports.getSoftNoiseReason = exports.isHardNoiseFollowEvent = exports.isHardNoise = exports.formatToolSummary = exports.formatTokenCount = exports.formatDurationMs = exports.createJsonlTail = exports.toFollowEvents = exports.createWatcher = exports.parseChangelog = exports.extractProposedPlanShared = exports.parsePlanMarkdownShared = exports.PlanExtractor = exports.segmentAssistantTurn = exports.reasoningSummary = exports.isAssistantTurnSubagentTool = exports.extractTurnSubagents = exports.assistantTurnEventsFromSessionEvents = exports.readSessionContextSnapshot = exports.createSessionContextProjector = exports.calculateSessionContextPressure = exports.buildSessionContextSnapshot = exports.composeContext = exports.FilterEngine = exports.searchSessions = exports.CodexDatabase = exports.OpenCodeDatabase = exports.discoverDebugLogs = exports.collapseDuplicates = exports.filterByLevel = exports.parseDebugLog = exports.scanSubagentTraces = exports.findAllSessionsWithWorktrees = exports.discoverWorktreeSiblings = exports.resolveWorktreeMainRepo = exports.getAllClaudeProjectFolders = exports.decodeEncodedPath = exports.getMostRecentlyActiveSessionDir = exports.findSubdirectorySessionDirs = exports.findSessionsInDirectory = exports.findAllClaudeSessions = exports.findActiveClaudeSession = void 0;
-exports.upsertSavedAccountProfile = exports.getActiveSavedAccount = exports.listSavedAccountProfiles = exports.writeSavedAccountRegistry = exports.readSavedAccountRegistry = exports.getAccountsDir = exports.resolveClaudeLoginCommand = exports.listAllAccounts = exports.switchAccount = exports.spawnAccountLogin = exports.finalizeAccountLogin = exports.getAccountLoginStatus = exports.beginAccountLogin = exports.isMultiAccountEnabled = exports.resolveActiveClaudeAccount = exports.getActiveAccount = exports.listAccounts = exports.removeAccount = exports.reconcileClaudeAuthState = exports.applyActiveClaudeToLiveHome = exports.resolveActiveClaudeHome = exports.switchToAccount = exports.addCurrentAccount = exports.readActiveClaudeAccount = exports.writeAccountRegistry = exports.readAccountRegistry = exports.ensureDefaultAccounts = exports.readClaudeMaxAccessTokenSync = exports.readClaudeMaxCredentials = exports.writeActiveCredentials = exports.readActiveCredentials = exports.openInBrowser = exports.parseTranscriptFromEvents = exports.parseTranscript = exports.generateHtmlReport = exports.PatternExtractor = exports.HeatmapTracker = exports.FrequencyTracker = exports.getSnapshotPath = exports.isSnapshotValid = exports.deleteSnapshot = exports.loadSnapshot = exports.saveSnapshot = exports.parseTodoDependencies = exports.EventAggregator = exports.getRandomPhrase = exports.PHRASE_CATEGORIES = exports.ALL_PHRASES = exports.HIGHLIGHT_CSS = exports.clearHighlightCache = void 0;
-exports.resolveCodexQuota = exports.readLatestCodexQuotaFromRollouts = exports.quotaFromCodexRateLimits = exports.fetchCodexQuotaFromApi = exports.getWorkspaceIdFromPath = exports.pruneQuotaHistory = exports.readQuotaHistoryDailyBuckets = exports.readQuotaHistoryRange = exports.appendQuotaHistorySample = exports.writeQuotaSnapshot = exports.readQuotaSnapshot = exports.QuotaPoller = exports.describeQuotaFailure = exports.withQuotaProjections = exports.projectQuotaWindow = exports.fetchQuota = exports.SEVEN_DAY_WINDOW_MS = exports.FIVE_HOUR_WINDOW_MS = exports.AutoSwitchController = exports.decideAutoSwitch = exports.DEFAULT_AUTO_SWITCH_CONFIG = exports.removeLauncher = exports.writeLauncher = exports.isShellHookInstalled = exports.uninstallShellHook = exports.installShellHook = exports.setTerminalActiveProfile = exports.removeCodexAccount = exports.switchToCodexAccount = exports.finalizeCodexAccount = exports.prepareCodexAccount = exports.getCodexExecutionEnv = exports.resolveSidekickCodexHome = exports.resolveActiveCodexAccount = exports.getActiveCodexAccount = exports.listCodexAccounts = exports.getSystemCodexHome = exports.getCodexMonitoringHomes = exports.getCodexProfileHome = exports.getCodexProfilesDir = exports.readClaudeProfileIdentity = exports.isClaudeProfileAuthenticated = exports.claudeKeychainService = exports.claudeKeychainSuffix = exports.getClaudeProfileHome = exports.getClaudeProfilesDir = exports.getActiveAccountStatus = exports.removeSavedAccountProfile = exports.replaceSavedAccountProfiles = exports.setActiveSavedAccount = void 0;
-exports.sessionMessageSchema = exports.messageUsageSchema = exports.gatherAssetsForCwd = exports.codexSessions = exports.readCodexAssets = exports.claudeSessions = exports.readClaudeAssets = exports.extractCommands = exports.extractFilePaths = exports.extractUrls = exports.extractToolCalls = exports.extractToolCall = exports.extractTokenUsage = exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = exports.formatCost = exports.sortModelIds = exports.compareModelIds = exports.getModelDisplayInfo = exports.shortModelName = exports.mergeCostSources = exports.calculateCostWithProvenance = exports.calculateCostWithPricing = exports.calculateCost = exports.getModelInfo = exports.getModelPricing = exports.parseModelId = exports.DEFAULT_CONTEXT_WINDOW = exports.getModelContextWindowSize = exports.MultiProviderQuotaService = exports.resolveZaiQuota = exports.readZaiCredentials = exports.quotaStateFromZaiQuotaLimitPayload = exports.fetchZaiQuotaFromApi = exports.ZaiQuotaWatcher = exports.ZAI_TIER_BUDGETS = exports.ZAI_PROVIDER_IDS = exports.ZAI_PROMPT_INVOCATIONS = exports.turnTokenWeight = exports.rowsToZaiTurnsAndErrors = exports.resolveZaiTier = exports.parseZaiQuotaError = exports.makeUnavailableZaiQuotaState = exports.isZaiProviderId = exports.inferZaiQuotaState = exports.extractNextFlushTime = exports.accumulateZaiUsage = exports.CodexQuotaWatcher = exports.resolveCodexQuotaFromLocalSources = void 0;
-exports.scopePeakHoursToSessionProvider = exports.isClaudeCodeSessionProvider = exports.fetchPeakHoursStatus = exports.createPeakHoursNotApplicableState = exports.fetchOpenAIStatus = exports.fetchProviderStatus = exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = void 0;
+exports.getClaudeSessionDirectory = exports.encodeClaudeWorkspacePath = exports.detectSessionActivity = exports.extractTaskInfo = exports.scanSubagentDir = exports.normalizeCodexToolInput = exports.normalizeCodexToolName = exports.extractPatchFilePaths = exports.CodexRolloutParser = exports.parseDbPartData = exports.parseDbMessageData = exports.convertOpenCodeMessage = exports.detectPlanModeFromText = exports.normalizeToolInput = exports.normalizeToolName = exports.TRUNCATION_PATTERNS = exports.JsonlParser = exports.CodexProvider = exports.getOpenCodeDataDir = exports.OpenCodeProvider = exports.ClaudeCodeProvider = exports.getAllDetectedProviders = exports.detectProvider = exports.readClaudeCodePlanFiles = exports.getPlanAnalytics = exports.writePlans = exports.getLatestPlan = exports.readPlans = exports.readLatestHandoff = exports.readHistory = exports.readNotes = exports.readDecisions = exports.readTasks = exports.getProjectSlugRaw = exports.getProjectSlug = exports.encodeWorkspacePath = exports.getGlobalDataPath = exports.getProjectDataPath = exports.getConfigDir = exports.MAX_PLANS_PER_PROJECT = exports.PLAN_SCHEMA_VERSION = exports.createEmptyTokenTotals = exports.HISTORICAL_DATA_SCHEMA_VERSION = exports.STALENESS_THRESHOLDS = exports.IMPORTANCE_DECAY_FACTORS = exports.KNOWLEDGE_NOTE_SCHEMA_VERSION = exports.DECISION_LOG_SCHEMA_VERSION = exports.normalizeTaskStatus = exports.TASK_PERSISTENCE_SCHEMA_VERSION = exports.isAggregateCodexLimit = void 0;
+exports.formatSessionJson = exports.formatSessionMarkdown = exports.formatSessionText = exports.classifyNoise = exports.shouldMergeWithPrevious = exports.classifyFollowEvent = exports.classifyMessage = exports.getSoftNoiseReason = exports.isHardNoiseFollowEvent = exports.isHardNoise = exports.formatToolSummary = exports.formatTokenCount = exports.formatDurationMs = exports.createJsonlTail = exports.toFollowEvents = exports.createWatcher = exports.parseChangelog = exports.extractProposedPlanShared = exports.parsePlanMarkdownShared = exports.PlanExtractor = exports.segmentAssistantTurn = exports.reasoningSummary = exports.isAssistantTurnSubagentTool = exports.extractTurnSubagents = exports.assistantTurnEventsFromSessionEvents = exports.readSessionContextSnapshot = exports.createSessionContextProjector = exports.calculateSessionContextPressure = exports.buildSessionContextSnapshot = exports.composeContext = exports.FilterEngine = exports.searchSessions = exports.CodexDatabase = exports.OpenCodeDatabase = exports.discoverDebugLogs = exports.collapseDuplicates = exports.filterByLevel = exports.parseDebugLog = exports.scanSubagentTraces = exports.findAllSessionsWithWorktrees = exports.discoverWorktreeSiblings = exports.resolveWorktreeMainRepo = exports.getAllClaudeProjectFolders = exports.decodeEncodedPath = exports.getMostRecentlyActiveSessionDir = exports.findSubdirectorySessionDirs = exports.findSessionsInDirectory = exports.findAllClaudeSessions = exports.findActiveClaudeSession = exports.discoverSessionDirectory = void 0;
+exports.getActiveSavedAccount = exports.listSavedAccountProfiles = exports.writeSavedAccountRegistry = exports.readSavedAccountRegistry = exports.getAccountsDir = exports.resolveClaudeLoginCommand = exports.listAllAccounts = exports.switchAccount = exports.spawnAccountLogin = exports.finalizeAccountLogin = exports.getAccountLoginStatus = exports.beginAccountLogin = exports.isMultiAccountEnabled = exports.resolveActiveClaudeAccount = exports.getActiveAccount = exports.listAccounts = exports.removeAccount = exports.reconcileClaudeAuthState = exports.applyActiveClaudeToLiveHome = exports.resolveActiveClaudeHome = exports.switchToAccount = exports.addCurrentAccount = exports.readActiveClaudeAccount = exports.writeAccountRegistry = exports.readAccountRegistry = exports.ensureDefaultAccounts = exports.readClaudeMaxAccessTokenSync = exports.readClaudeMaxCredentials = exports.writeActiveCredentials = exports.readActiveCredentials = exports.openInBrowser = exports.parseTranscriptFromEvents = exports.parseTranscript = exports.generateHtmlReport = exports.PatternExtractor = exports.HeatmapTracker = exports.FrequencyTracker = exports.getSnapshotPath = exports.isSnapshotValid = exports.deleteSnapshot = exports.loadSnapshot = exports.saveSnapshot = exports.parseTodoDependencies = exports.EventAggregator = exports.getRandomPhrase = exports.PHRASE_CATEGORIES = exports.ALL_PHRASES = exports.HIGHLIGHT_CSS = exports.clearHighlightCache = exports.highlightEvent = void 0;
+exports.quotaFromCodexRateLimits = exports.fetchCodexQuotaFromApi = exports.fetchCodexResetCreditsFromApi = exports.getWorkspaceIdFromPath = exports.pruneQuotaHistory = exports.readQuotaHistoryDailyBuckets = exports.readQuotaHistoryRange = exports.appendQuotaHistorySample = exports.writeQuotaSnapshot = exports.readQuotaSnapshot = exports.QuotaPoller = exports.describeQuotaFailure = exports.withQuotaProjections = exports.projectQuotaWindow = exports.fetchQuota = exports.SEVEN_DAY_WINDOW_MS = exports.FIVE_HOUR_WINDOW_MS = exports.AutoSwitchController = exports.decideAutoSwitch = exports.DEFAULT_AUTO_SWITCH_CONFIG = exports.removeLauncher = exports.writeLauncher = exports.isShellHookInstalled = exports.uninstallShellHook = exports.installShellHook = exports.setTerminalActiveProfile = exports.removeCodexAccount = exports.switchToCodexAccount = exports.finalizeCodexAccount = exports.prepareCodexAccount = exports.getCodexExecutionEnv = exports.resolveSidekickCodexHome = exports.resolveActiveCodexAccount = exports.getActiveCodexAccount = exports.listCodexAccounts = exports.getSystemCodexHome = exports.getCodexMonitoringHomes = exports.getCodexProfileHome = exports.getCodexProfilesDir = exports.readClaudeProfileIdentity = exports.isClaudeProfileAuthenticated = exports.claudeKeychainService = exports.claudeKeychainSuffix = exports.getClaudeProfileHome = exports.getClaudeProfilesDir = exports.getActiveAccountStatus = exports.removeSavedAccountProfile = exports.replaceSavedAccountProfiles = exports.setActiveSavedAccount = exports.upsertSavedAccountProfile = void 0;
+exports.gatherAssetsForCwd = exports.codexSessions = exports.readCodexAssets = exports.claudeSessions = exports.readClaudeAssets = exports.extractCommands = exports.extractFilePaths = exports.extractUrls = exports.extractToolCalls = exports.extractToolCall = exports.extractTokenUsage = exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = exports.formatCost = exports.sortModelIds = exports.compareModelIds = exports.getModelDisplayInfo = exports.shortModelName = exports.mergeCostSources = exports.calculateCostWithProvenance = exports.calculateCostWithPricing = exports.calculateCost = exports.getModelInfo = exports.getModelPricing = exports.parseModelId = exports.DEFAULT_CONTEXT_WINDOW = exports.getModelContextWindowSize = exports.MultiProviderQuotaService = exports.resolveZaiQuota = exports.readZaiCredentials = exports.quotaStateFromZaiQuotaLimitPayload = exports.fetchZaiQuotaFromApi = exports.ZaiQuotaWatcher = exports.ZAI_TIER_BUDGETS = exports.ZAI_PROVIDER_IDS = exports.ZAI_PROMPT_INVOCATIONS = exports.turnTokenWeight = exports.rowsToZaiTurnsAndErrors = exports.resolveZaiTier = exports.parseZaiQuotaError = exports.makeUnavailableZaiQuotaState = exports.isZaiProviderId = exports.inferZaiQuotaState = exports.extractNextFlushTime = exports.accumulateZaiUsage = exports.CodexQuotaWatcher = exports.resolveCodexQuotaFromLocalSources = exports.resolveCodexQuota = exports.readLatestCodexQuotaFromRollouts = void 0;
+exports.scopePeakHoursToSessionProvider = exports.isClaudeCodeSessionProvider = exports.fetchPeakHoursStatus = exports.createPeakHoursNotApplicableState = exports.fetchOpenAIStatus = exports.fetchProviderStatus = exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = void 0;
+var codex_1 = require("./types/codex");
+Object.defineProperty(exports, "isAggregateCodexLimit", { enumerable: true, get: function () { return codex_1.isAggregateCodexLimit; } });
 var taskPersistence_1 = require("./types/taskPersistence");
 Object.defineProperty(exports, "TASK_PERSISTENCE_SCHEMA_VERSION", { enumerable: true, get: function () { return taskPersistence_1.TASK_PERSISTENCE_SCHEMA_VERSION; } });
 Object.defineProperty(exports, "normalizeTaskStatus", { enumerable: true, get: function () { return taskPersistence_1.normalizeTaskStatus; } });
@@ -57,8 +59,8 @@ Object.defineProperty(exports, "ClaudeCodeProvider", { enumerable: true, get: fu
 var openCode_1 = require("./providers/openCode");
 Object.defineProperty(exports, "OpenCodeProvider", { enumerable: true, get: function () { return openCode_1.OpenCodeProvider; } });
 Object.defineProperty(exports, "getOpenCodeDataDir", { enumerable: true, get: function () { return openCode_1.getOpenCodeDataDir; } });
-var codex_1 = require("./providers/codex");
-Object.defineProperty(exports, "CodexProvider", { enumerable: true, get: function () { return codex_1.CodexProvider; } });
+var codex_2 = require("./providers/codex");
+Object.defineProperty(exports, "CodexProvider", { enumerable: true, get: function () { return codex_2.CodexProvider; } });
 // Parsers — JSONL
 var jsonl_1 = require("./parsers/jsonl");
 Object.defineProperty(exports, "JsonlParser", { enumerable: true, get: function () { return jsonl_1.JsonlParser; } });
@@ -295,6 +297,7 @@ Object.defineProperty(exports, "readQuotaHistoryDailyBuckets", { enumerable: tru
 Object.defineProperty(exports, "pruneQuotaHistory", { enumerable: true, get: function () { return quotaHistory_1.pruneQuotaHistory; } });
 Object.defineProperty(exports, "getWorkspaceIdFromPath", { enumerable: true, get: function () { return quotaHistory_1.getWorkspaceIdFromPath; } });
 var codexQuota_1 = require("./codexQuota");
+Object.defineProperty(exports, "fetchCodexResetCreditsFromApi", { enumerable: true, get: function () { return codexQuota_1.fetchCodexResetCreditsFromApi; } });
 Object.defineProperty(exports, "fetchCodexQuotaFromApi", { enumerable: true, get: function () { return codexQuota_1.fetchCodexQuotaFromApi; } });
 Object.defineProperty(exports, "quotaFromCodexRateLimits", { enumerable: true, get: function () { return codexQuota_1.quotaFromCodexRateLimits; } });
 Object.defineProperty(exports, "readLatestCodexQuotaFromRollouts", { enumerable: true, get: function () { return codexQuota_1.readLatestCodexQuotaFromRollouts; } });
@@ -382,6 +385,8 @@ Object.defineProperty(exports, "quotaStateSchema", { enumerable: true, get: func
 Object.defineProperty(exports, "quotaFailureKindSchema", { enumerable: true, get: function () { return quota_2.quotaFailureKindSchema; } });
 Object.defineProperty(exports, "quotaProviderIdSchema", { enumerable: true, get: function () { return quota_2.quotaProviderIdSchema; } });
 Object.defineProperty(exports, "quotaSourceSchema", { enumerable: true, get: function () { return quota_2.quotaSourceSchema; } });
+Object.defineProperty(exports, "codexResetCreditSchema", { enumerable: true, get: function () { return quota_2.codexResetCreditSchema; } });
+Object.defineProperty(exports, "codexResetCreditsSnapshotSchema", { enumerable: true, get: function () { return quota_2.codexResetCreditsSnapshotSchema; } });
 Object.defineProperty(exports, "peakHoursStateSchema", { enumerable: true, get: function () { return quota_2.peakHoursStateSchema; } });
 Object.defineProperty(exports, "quotaFailureDescriptorSchema", { enumerable: true, get: function () { return quota_2.quotaFailureDescriptorSchema; } });
 Object.defineProperty(exports, "runtimeQuotaProviderSchema", { enumerable: true, get: function () { return quota_2.runtimeQuotaProviderSchema; } });

package/dist/parsers/codexParser.d.ts

@@ -43,6 +43,7 @@ export declare class CodexRolloutParser {
     private lastTokenUsage;
     private modelContextWindow;
     private lastRateLimits;
+    private hasAggregateRateLimits;
     private inPlanMode;
     private emittedToolUseIds;
     private patchExpandedToolUseIds;

package/dist/parsers/codexParser.js

@@ -16,6 +16,7 @@ exports.CodexRolloutParser = void 0;
 exports.normalizeCodexToolName = normalizeCodexToolName;
 exports.normalizeCodexToolInput = normalizeCodexToolInput;
 exports.extractPatchFilePaths = extractPatchFilePaths;
+const codex_1 = require("../types/codex");
 const openCodeParser_1 = require("./openCodeParser");
 function normalizeRateLimits(rateLimits) {
     if (!rateLimits?.primary && !rateLimits?.secondary)
@@ -126,6 +127,7 @@ class CodexRolloutParser {
     lastTokenUsage = null;
     modelContextWindow = null;
     lastRateLimits = null;
+    hasAggregateRateLimits = false;
     inPlanMode = false;
     emittedToolUseIds = new Set();
     patchExpandedToolUseIds = new Map();
@@ -177,6 +179,7 @@ class CodexRolloutParser {
         this.lastTokenUsage = null;
         this.modelContextWindow = null;
         this.lastRateLimits = null;
+        this.hasAggregateRateLimits = false;
         this.inPlanMode = false;
         this.emittedToolUseIds.clear();
         this.patchExpandedToolUseIds.clear();
@@ -493,9 +496,19 @@ class CodexRolloutParser {
                 if (e.info?.model_context_window) {
                     this.modelContextWindow = e.info.model_context_window;
                 }
-                // Store rate_limits if provided (subscription quota data)
+                // Store rate_limits if provided (subscription quota data). Codex interleaves
+                // multiple families (aggregate "codex" plus per-model ones like codex_bengalfox);
+                // keep the latest aggregate sample so a trailing model-specific event at 0% does
+                // not mask the plan quota. Fall back to a non-aggregate sample only until an
+                // aggregate one has been seen.
                 if (e.rate_limits) {
-                    this.lastRateLimits = e.rate_limits;
+                    if ((0, codex_1.isAggregateCodexLimit)(e.rate_limits.limit_id)) {
+                        this.lastRateLimits = e.rate_limits;
+                        this.hasAggregateRateLimits = true;
+                    }
+                    else if (!this.hasAggregateRateLimits) {
+                        this.lastRateLimits = e.rate_limits;
+                    }
                 }
                 // Usage data is nested under info.last_token_usage (info can be null)
                 const usage = e.info?.last_token_usage || e.info?.total_token_usage;

package/dist/quota.d.ts

@@ -10,6 +10,20 @@ export interface QuotaWindow {
     /** ISO timestamp when the window resets */
     resetsAt: string;
 }
+export interface CodexResetCredit {
+    title?: string;
+    status: string;
+    resetType?: string;
+    expiresAt: string;
+    grantedAt?: string;
+}
+export interface CodexResetCreditsSnapshot {
+    availableCount: number;
+    totalEarnedCount?: number;
+    credits: CodexResetCredit[];
+    source?: 'api' | 'cache';
+    capturedAt?: string;
+}
 export interface QuotaState {
     fiveHour: QuotaWindow;
     sevenDay: QuotaWindow;
@@ -45,6 +59,8 @@ export interface QuotaState {
     limitName?: string;
     /** Provider-specific credits snapshot */
     credits?: unknown;
+    /** Codex reset credits snapshot from the ChatGPT reset-credit endpoint */
+    resetCredits?: CodexResetCreditsSnapshot;
     /** Provider-specific plan type */
     planType?: string;
     /** Provider-specific rate-limit reached reason */

package/dist/quotaSnapshots.js

@@ -39,6 +39,7 @@ const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("./paths");
+const codex_1 = require("./types/codex");
 function getQuotaSnapshotPath() {
     return path.join((0, paths_1.getConfigDir)(), 'quota-snapshots.json');
 }
@@ -94,6 +95,15 @@ function windowResetMs(value) {
 // Preserve the best-known same-window snapshot while still allowing lower
 // utilization after Codex advances to a newer reset window.
 function shouldKeepExistingSnapshot(existing, next) {
+    // Family rank first (Codex): the aggregate plan-quota family ("codex") must never be
+    // replaced or blocked by a model/feature-specific family (e.g. codex_bengalfox), whose
+    // later-resetting 0% window would otherwise win the reset-window comparison below. This
+    // is a no-op for providers whose limitId is consistent across samples (Claude: absent;
+    // z.ai: zai-*), where both sides share the same aggregate-ness.
+    const existingAggregate = (0, codex_1.isAggregateCodexLimit)(existing.limitId);
+    const nextAggregate = (0, codex_1.isAggregateCodexLimit)(next.limitId);
+    if (existingAggregate !== nextAggregate)
+        return existingAggregate;
     const existingPrimaryReset = windowResetMs(existing.fiveHour.resetsAt);
     const nextPrimaryReset = windowResetMs(next.fiveHour.resetsAt);
     if (existingPrimaryReset !== nextPrimaryReset)
@@ -110,14 +120,16 @@ function shouldKeepExistingSnapshot(existing, next) {
 }
 function writeQuotaSnapshot(providerId, accountId, quota) {
     const store = readStore();
+    const index = store.snapshots.findIndex((item) => item.providerId === providerId && item.accountId === accountId);
+    const existingQuota = index >= 0 ? store.snapshots[index].quota : undefined;
     const snapshot = {
         ...quota,
         providerId,
         capturedAt: quota.capturedAt ?? new Date().toISOString(),
         source: quota.source ?? 'session',
         stale: false,
+        resetCredits: quota.resetCredits ?? (providerId === 'codex' ? existingQuota?.resetCredits : undefined),
     };
-    const index = store.snapshots.findIndex((item) => item.providerId === providerId && item.accountId === accountId);
     if (index >= 0 && shouldKeepExistingSnapshot(store.snapshots[index].quota, snapshot)) {
         return;
     }

package/dist/schemas/assistantTurn.d.ts

@@ -8,9 +8,9 @@ import { z } from 'zod';
 export declare const assistantTurnEventTypeSchema: z.ZodEnum<{
     status: "status";
     error: "error";
+    text: "text";
     tool_use: "tool_use";
     tool_result: "tool_result";
-    text: "text";
     progress: "progress";
     thinking: "thinking";
     delta: "delta";
@@ -19,9 +19,9 @@ export declare const assistantTurnEventSchema: z.ZodObject<{
     eventType: z.ZodEnum<{
         status: "status";
         error: "error";
+        text: "text";
         tool_use: "tool_use";
         tool_result: "tool_result";
-        text: "text";
         progress: "progress";
         thinking: "thinking";
         delta: "delta";

package/dist/schemas/index.d.ts

@@ -12,8 +12,8 @@
  */
 export { messageUsageSchema, sessionMessageSchema, sessionEventSchema, permissionModeSchema, extractSessionEvents, } from './sessionEvent';
 export type { MessageUsage, SessionMessage, SessionEvent, PermissionMode, } from '../types/sessionEvent';
-export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';
-export type { QuotaWindow, QuotaState } from '../quota';
+export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';
+export type { CodexResetCredit, CodexResetCreditsSnapshot, QuotaWindow, QuotaState, } from '../quota';
 export type { PeakHoursState } from '../peakHours';
 export type { QuotaFailureDescriptor } from '../quotaPresentation';
 export type { ProviderQuotaState, ProviderQuotaMap, RuntimeQuotaProvider } from '../providerQuota';

package/dist/schemas/index.js

@@ -12,7 +12,7 @@
  * subpath is self-sufficient for boundary-validation modules.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = void 0;
+exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = void 0;
 var sessionEvent_1 = require("./sessionEvent");
 Object.defineProperty(exports, "messageUsageSchema", { enumerable: true, get: function () { return sessionEvent_1.messageUsageSchema; } });
 Object.defineProperty(exports, "sessionMessageSchema", { enumerable: true, get: function () { return sessionEvent_1.sessionMessageSchema; } });
@@ -25,6 +25,8 @@ Object.defineProperty(exports, "quotaStateSchema", { enumerable: true, get: func
 Object.defineProperty(exports, "quotaFailureKindSchema", { enumerable: true, get: function () { return quota_1.quotaFailureKindSchema; } });
 Object.defineProperty(exports, "quotaProviderIdSchema", { enumerable: true, get: function () { return quota_1.quotaProviderIdSchema; } });
 Object.defineProperty(exports, "quotaSourceSchema", { enumerable: true, get: function () { return quota_1.quotaSourceSchema; } });
+Object.defineProperty(exports, "codexResetCreditSchema", { enumerable: true, get: function () { return quota_1.codexResetCreditSchema; } });
+Object.defineProperty(exports, "codexResetCreditsSnapshotSchema", { enumerable: true, get: function () { return quota_1.codexResetCreditsSnapshotSchema; } });
 Object.defineProperty(exports, "peakHoursStateSchema", { enumerable: true, get: function () { return quota_1.peakHoursStateSchema; } });
 Object.defineProperty(exports, "quotaFailureDescriptorSchema", { enumerable: true, get: function () { return quota_1.quotaFailureDescriptorSchema; } });
 Object.defineProperty(exports, "runtimeQuotaProviderSchema", { enumerable: true, get: function () { return quota_1.runtimeQuotaProviderSchema; } });

package/dist/schemas/quota.d.ts

@@ -27,9 +27,32 @@ export declare const quotaProviderIdSchema: z.ZodEnum<{
 }>;
 export declare const quotaSourceSchema: z.ZodEnum<{
     api: "api";
-    session: "session";
     cache: "cache";
+    session: "session";
 }>;
+export declare const codexResetCreditSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    resetType: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodString;
+    grantedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const codexResetCreditsSnapshotSchema: z.ZodObject<{
+    availableCount: z.ZodNumber;
+    totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+    credits: z.ZodArray<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        status: z.ZodString;
+        resetType: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodString;
+        grantedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        cache: "cache";
+    }>>;
+    capturedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const quotaStateSchema: z.ZodObject<{
     fiveHour: z.ZodObject<{
         utilization: z.ZodNumber;
@@ -59,8 +82,8 @@ export declare const quotaStateSchema: z.ZodObject<{
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     capturedAt: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -69,6 +92,22 @@ export declare const quotaStateSchema: z.ZodObject<{
     limitId: z.ZodOptional<z.ZodString>;
     limitName: z.ZodOptional<z.ZodString>;
     credits: z.ZodOptional<z.ZodUnknown>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+        totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+        credits: z.ZodArray<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            resetType: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodString;
+            grantedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            api: "api";
+            cache: "cache";
+        }>>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     planType: z.ZodOptional<z.ZodString>;
     rateLimitReachedType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -139,8 +178,8 @@ export declare const providerQuotaStateSchema: z.ZodObject<{
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     capturedAt: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -149,6 +188,22 @@ export declare const providerQuotaStateSchema: z.ZodObject<{
     limitId: z.ZodOptional<z.ZodString>;
     limitName: z.ZodOptional<z.ZodString>;
     credits: z.ZodOptional<z.ZodUnknown>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+        totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+        credits: z.ZodArray<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            resetType: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodString;
+            grantedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            api: "api";
+            cache: "cache";
+        }>>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     planType: z.ZodOptional<z.ZodString>;
     rateLimitReachedType: z.ZodOptional<z.ZodString>;
     accountLabel: z.ZodOptional<z.ZodString>;
@@ -221,8 +276,8 @@ export declare const claudeProviderQuotaStateSchema: z.ZodObject<{
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     capturedAt: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -231,6 +286,22 @@ export declare const claudeProviderQuotaStateSchema: z.ZodObject<{
     limitId: z.ZodOptional<z.ZodString>;
     limitName: z.ZodOptional<z.ZodString>;
     credits: z.ZodOptional<z.ZodUnknown>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+        totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+        credits: z.ZodArray<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            resetType: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodString;
+            grantedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            api: "api";
+            cache: "cache";
+        }>>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     planType: z.ZodOptional<z.ZodString>;
     rateLimitReachedType: z.ZodOptional<z.ZodString>;
     accountLabel: z.ZodOptional<z.ZodString>;
@@ -299,8 +370,8 @@ export declare const codexProviderQuotaStateSchema: z.ZodObject<{
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     capturedAt: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -309,6 +380,22 @@ export declare const codexProviderQuotaStateSchema: z.ZodObject<{
     limitId: z.ZodOptional<z.ZodString>;
     limitName: z.ZodOptional<z.ZodString>;
     credits: z.ZodOptional<z.ZodUnknown>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+        totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+        credits: z.ZodArray<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            resetType: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodString;
+            grantedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            api: "api";
+            cache: "cache";
+        }>>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     planType: z.ZodOptional<z.ZodString>;
     rateLimitReachedType: z.ZodOptional<z.ZodString>;
     accountLabel: z.ZodOptional<z.ZodString>;
@@ -377,8 +464,8 @@ export declare const zaiProviderQuotaStateSchema: z.ZodObject<{
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     capturedAt: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -387,6 +474,22 @@ export declare const zaiProviderQuotaStateSchema: z.ZodObject<{
     limitId: z.ZodOptional<z.ZodString>;
     limitName: z.ZodOptional<z.ZodString>;
     credits: z.ZodOptional<z.ZodUnknown>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+        totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+        credits: z.ZodArray<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            resetType: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodString;
+            grantedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            api: "api";
+            cache: "cache";
+        }>>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     planType: z.ZodOptional<z.ZodString>;
     rateLimitReachedType: z.ZodOptional<z.ZodString>;
     accountLabel: z.ZodOptional<z.ZodString>;
@@ -456,8 +559,8 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         }>>;
         source: z.ZodOptional<z.ZodEnum<{
             api: "api";
-            session: "session";
             cache: "cache";
+            session: "session";
         }>>;
         capturedAt: z.ZodOptional<z.ZodString>;
         stale: z.ZodOptional<z.ZodBoolean>;
@@ -466,6 +569,22 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         limitId: z.ZodOptional<z.ZodString>;
         limitName: z.ZodOptional<z.ZodString>;
         credits: z.ZodOptional<z.ZodUnknown>;
+        resetCredits: z.ZodOptional<z.ZodObject<{
+            availableCount: z.ZodNumber;
+            totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+            credits: z.ZodArray<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                status: z.ZodString;
+                resetType: z.ZodOptional<z.ZodString>;
+                expiresAt: z.ZodString;
+                grantedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            source: z.ZodOptional<z.ZodEnum<{
+                api: "api";
+                cache: "cache";
+            }>>;
+            capturedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         planType: z.ZodOptional<z.ZodString>;
         rateLimitReachedType: z.ZodOptional<z.ZodString>;
         accountLabel: z.ZodOptional<z.ZodString>;
@@ -534,8 +653,8 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         }>>;
         source: z.ZodOptional<z.ZodEnum<{
             api: "api";
-            session: "session";
             cache: "cache";
+            session: "session";
         }>>;
         capturedAt: z.ZodOptional<z.ZodString>;
         stale: z.ZodOptional<z.ZodBoolean>;
@@ -544,6 +663,22 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         limitId: z.ZodOptional<z.ZodString>;
         limitName: z.ZodOptional<z.ZodString>;
         credits: z.ZodOptional<z.ZodUnknown>;
+        resetCredits: z.ZodOptional<z.ZodObject<{
+            availableCount: z.ZodNumber;
+            totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+            credits: z.ZodArray<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                status: z.ZodString;
+                resetType: z.ZodOptional<z.ZodString>;
+                expiresAt: z.ZodString;
+                grantedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            source: z.ZodOptional<z.ZodEnum<{
+                api: "api";
+                cache: "cache";
+            }>>;
+            capturedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         planType: z.ZodOptional<z.ZodString>;
         rateLimitReachedType: z.ZodOptional<z.ZodString>;
         accountLabel: z.ZodOptional<z.ZodString>;
@@ -612,8 +747,8 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         }>>;
         source: z.ZodOptional<z.ZodEnum<{
             api: "api";
-            session: "session";
             cache: "cache";
+            session: "session";
         }>>;
         capturedAt: z.ZodOptional<z.ZodString>;
         stale: z.ZodOptional<z.ZodBoolean>;
@@ -622,6 +757,22 @@ export declare const providerQuotaMapSchema: z.ZodObject<{
         limitId: z.ZodOptional<z.ZodString>;
         limitName: z.ZodOptional<z.ZodString>;
         credits: z.ZodOptional<z.ZodUnknown>;
+        resetCredits: z.ZodOptional<z.ZodObject<{
+            availableCount: z.ZodNumber;
+            totalEarnedCount: z.ZodOptional<z.ZodNumber>;
+            credits: z.ZodArray<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                status: z.ZodString;
+                resetType: z.ZodOptional<z.ZodString>;
+                expiresAt: z.ZodString;
+                grantedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            source: z.ZodOptional<z.ZodEnum<{
+                api: "api";
+                cache: "cache";
+            }>>;
+            capturedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         planType: z.ZodOptional<z.ZodString>;
         rateLimitReachedType: z.ZodOptional<z.ZodString>;
         accountLabel: z.ZodOptional<z.ZodString>;

package/dist/schemas/quota.js

@@ -10,7 +10,7 @@
  * @module schemas/quota
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.quotaStateSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaWindowSchema = void 0;
+exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.quotaStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaWindowSchema = void 0;
 const zod_1 = require("zod");
 // ── QuotaWindow ──
 exports.quotaWindowSchema = zod_1.z.object({
@@ -27,6 +27,20 @@ exports.quotaFailureKindSchema = zod_1.z.enum([
 ]);
 exports.quotaProviderIdSchema = zod_1.z.enum(['claude-code', 'codex', 'zai']);
 exports.quotaSourceSchema = zod_1.z.enum(['api', 'session', 'cache']);
+exports.codexResetCreditSchema = zod_1.z.object({
+    title: zod_1.z.string().optional(),
+    status: zod_1.z.string(),
+    resetType: zod_1.z.string().optional(),
+    expiresAt: zod_1.z.string(),
+    grantedAt: zod_1.z.string().optional(),
+});
+exports.codexResetCreditsSnapshotSchema = zod_1.z.object({
+    availableCount: zod_1.z.number(),
+    totalEarnedCount: zod_1.z.number().optional(),
+    credits: zod_1.z.array(exports.codexResetCreditSchema),
+    source: zod_1.z.enum(['api', 'cache']).optional(),
+    capturedAt: zod_1.z.string().optional(),
+});
 exports.quotaStateSchema = zod_1.z.object({
     fiveHour: exports.quotaWindowSchema,
     sevenDay: exports.quotaWindowSchema,
@@ -46,6 +60,7 @@ exports.quotaStateSchema = zod_1.z.object({
     limitId: zod_1.z.string().optional(),
     limitName: zod_1.z.string().optional(),
     credits: zod_1.z.unknown().optional(),
+    resetCredits: exports.codexResetCreditsSnapshotSchema.optional(),
     planType: zod_1.z.string().optional(),
     rateLimitReachedType: zod_1.z.string().optional(),
 });

package/dist/schemas/quotaHistory.d.ts

@@ -35,8 +35,8 @@ export declare const quotaHistorySampleSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEnum<{
         api: "api";
-        session: "session";
         cache: "cache";
+        session: "session";
     }>>;
     stale: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;

package/dist/schemas/sessionEvent.d.ts

@@ -41,10 +41,10 @@ export declare const sessionEventSchema: z.ZodObject<{
     type: z.ZodEnum<{
         user: "user";
         assistant: "assistant";
+        system: "system";
         tool_use: "tool_use";
         tool_result: "tool_result";
         summary: "summary";
-        system: "system";
     }>;
     message: z.ZodObject<{
         role: z.ZodString;

package/dist/types/codex.d.ts

@@ -192,6 +192,15 @@ export interface CodexRateLimits {
     plan_type?: string;
     rate_limit_reached_type?: string;
 }
+/**
+ * Codex reports several rate-limit families per session, keyed by `limit_id`.
+ * The aggregate plan quota — what the usage API surfaces — is `limit_id: "codex"`
+ * (or absent on older payloads). Model/feature-specific families (e.g.
+ * `codex_bengalfox`, `premium`) report their own windows and can read 0% while the
+ * plan is heavily used, so they must never mask the aggregate in the standard
+ * quota view. Returns true only for the aggregate family.
+ */
+export declare function isAggregateCodexLimit(limitId?: string | null): boolean;
 export interface CodexTokenUsage {
     input_tokens: number;
     cached_input_tokens?: number;

package/dist/types/codex.js

@@ -12,3 +12,15 @@
  * @module types/codex
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAggregateCodexLimit = isAggregateCodexLimit;
+/**
+ * Codex reports several rate-limit families per session, keyed by `limit_id`.
+ * The aggregate plan quota — what the usage API surfaces — is `limit_id: "codex"`
+ * (or absent on older payloads). Model/feature-specific families (e.g.
+ * `codex_bengalfox`, `premium`) report their own windows and can read 0% while the
+ * plan is heavily used, so they must never mask the aggregate in the standard
+ * quota view. Returns true only for the aggregate family.
+ */
+function isAggregateCodexLimit(limitId) {
+    return !limitId || limitId === 'codex';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",