sidekick-shared 0.24.4 → 0.25.0

package/dist/codexQuotaWatcher.js

@@ -40,6 +40,7 @@ const codexQuota_1 = require("./codexQuota");
 const quotaSnapshots_1 = require("./quotaSnapshots");
 const quotaHistory_1 = require("./quotaHistory");
 const codex_1 = require("./providers/codex");
+const accountChanges_1 = require("./accountChanges");
 const DEFAULT_DISCOVERY_POLL_INTERVAL_MS = 30_000;
 const DEFAULT_LOCAL_SCAN_CACHE_MS = 5 * 60_000;
 function accountEmail(account) {
@@ -86,6 +87,7 @@ class CodexQuotaWatcher {
     now;
     workspaceId;
     appendHistorySample;
+    subscribeAccountsChanged;
     listeners = [];
     discoveryTimer;
     provider = null;
@@ -96,6 +98,7 @@ class CodexQuotaWatcher {
     lastLocalScanAt = Number.NEGATIVE_INFINITY;
     lastLocalScanState = null;
     running = false;
+    accountSubscription = null;
     constructor(workspacePath, options = {}) {
         this.workspacePath = workspacePath;
         this.discoveryPollIntervalMs =
@@ -119,15 +122,14 @@ class CodexQuotaWatcher {
         this.now = options.now ?? Date.now;
         this.workspaceId = options.workspaceId;
         this.appendHistorySample = options.appendHistorySample ?? quotaHistory_1.appendQuotaHistorySample;
+        this.subscribeAccountsChanged = options.subscribeAccountsChanged ?? accountChanges_1.onAccountsChanged;
     }
     start() {
         if (this.running)
             return;
         this.running = true;
-        this.refreshActiveSession();
-        this.discoveryTimer = setInterval(() => {
-            this.refreshActiveSession();
-        }, this.discoveryPollIntervalMs);
+        this.accountSubscription ??= this.subscribeAccountsChanged(() => this.handleAccountsChanged());
+        this.handleAccountsChanged();
     }
     stop() {
         if (!this.running)
@@ -137,6 +139,8 @@ class CodexQuotaWatcher {
             clearInterval(this.discoveryTimer);
             this.discoveryTimer = undefined;
         }
+        this.accountSubscription?.dispose();
+        this.accountSubscription = null;
         this.teardownActiveSession();
     }
     dispose() {
@@ -157,21 +161,46 @@ class CodexQuotaWatcher {
         return this.onUpdate(cb);
     }
     refresh() {
-        this.refreshActiveSession();
+        this.handleAccountsChanged();
     }
-    refreshActiveSession() {
+    handleAccountsChanged() {
+        if (!this.running)
+            return;
+        const account = this.safeGetActiveAccount();
+        if (!account) {
+            if (this.discoveryTimer) {
+                clearInterval(this.discoveryTimer);
+                this.discoveryTimer = undefined;
+            }
+            this.teardownActiveSession();
+            this.emitState(makeUnavailableState(null, 'No Codex account configured'));
+            return;
+        }
+        if (!this.discoveryTimer) {
+            this.discoveryTimer = setInterval(() => {
+                this.refreshActiveSession();
+            }, this.discoveryPollIntervalMs);
+            this.discoveryTimer.unref?.();
+        }
+        this.refreshActiveSession(account);
+    }
+    refreshActiveSession(account = this.safeGetActiveAccount()) {
+        if (!account) {
+            this.handleAccountsChanged();
+            return;
+        }
         const provider = this.getProvider();
         const nextSessionPath = provider.findActiveSession(this.workspacePath);
         if (!nextSessionPath) {
             this.teardownActiveSession();
-            this.emitCachedOrUnavailable();
+            this.emitCachedOrUnavailable(account);
             return;
         }
         if (nextSessionPath !== this.sessionPath || this.reader == null) {
             this.attachToSession(nextSessionPath);
             return;
         }
-        this.ingestSessionUpdate('readNew');
+        this.ingestSessionUpdate('readNew', account);
     }
     attachToSession(nextSessionPath) {
         this.teardownActiveSession();
@@ -189,14 +218,30 @@ class CodexQuotaWatcher {
                 }
                 this.refreshActiveSession();
             });
+            if (typeof this.fileWatcher.on === 'function') {
+                this.fileWatcher.on('error', () => {
+                    try {
+                        this.fileWatcher?.close();
+                    }
+                    catch {
+                        // Discovery polling remains active.
+                    }
+                    this.fileWatcher = null;
+                });
+            }
         }
         catch {
             this.emitCachedOrUnavailable();
         }
     }
-    ingestSessionUpdate(mode) {
+    ingestSessionUpdate(mode, knownAccount) {
+        const account = knownAccount ?? this.safeGetActiveAccount();
+        if (!account) {
+            this.handleAccountsChanged();
+            return;
+        }
         if (!this.provider || !this.reader) {
-            this.emitCachedOrUnavailable();
+            this.emitCachedOrUnavailable(account);
             return;
         }
         if (!this.reader.exists()) {
@@ -211,48 +256,45 @@ class CodexQuotaWatcher {
         }
         const liveQuota = (0, codexQuota_1.quotaFromCodexRateLimits)(this.provider.getLastRateLimits(), 'session');
         if (!liveQuota) {
-            this.emitCachedOrUnavailable();
+            this.emitCachedOrUnavailable(account);
             return;
         }
-        const account = this.getActiveAccount();
-        const cached = account ? this.readSnapshot('codex', account.id) : null;
+        const cached = this.readSnapshot('codex', account.id);
         const liveQuotaWithResetCredits = {
             ...liveQuota,
             resetCredits: liveQuota.resetCredits ?? cached?.resetCredits,
         };
-        if (account) {
-            this.writeSnapshot('codex', account.id, liveQuotaWithResetCredits);
-            if (this.workspaceId) {
-                const sample = {
-                    timestamp: liveQuotaWithResetCredits.capturedAt ?? new Date().toISOString(),
-                    runtimeProvider: 'codex',
-                    providerId: account.id,
-                    workspaceId: this.workspaceId,
-                    fiveHour: {
-                        utilization: liveQuotaWithResetCredits.fiveHour.utilization,
-                        resetsAt: liveQuotaWithResetCredits.fiveHour.resetsAt,
-                    },
-                    sevenDay: {
-                        utilization: liveQuotaWithResetCredits.sevenDay.utilization,
-                        resetsAt: liveQuotaWithResetCredits.sevenDay.resetsAt,
-                    },
-                    available: liveQuotaWithResetCredits.available,
-                    error: liveQuotaWithResetCredits.error,
-                    source: liveQuotaWithResetCredits.source,
-                    stale: liveQuotaWithResetCredits.stale,
-                };
-                try {
-                    const result = this.appendHistorySample(sample);
-                    if (result && typeof result.catch === 'function') {
-                        result.catch(() => {
-                            // History append must never break the live emission path.
-                        });
-                    }
-                }
-                catch {
-                    // Synchronous errors swallowed for the same reason.
+        this.writeSnapshot('codex', account.id, liveQuotaWithResetCredits);
+        if (this.workspaceId) {
+            const sample = {
+                timestamp: liveQuotaWithResetCredits.capturedAt ?? new Date().toISOString(),
+                runtimeProvider: 'codex',
+                providerId: account.id,
+                workspaceId: this.workspaceId,
+                fiveHour: {
+                    utilization: liveQuotaWithResetCredits.fiveHour.utilization,
+                    resetsAt: liveQuotaWithResetCredits.fiveHour.resetsAt,
+                },
+                sevenDay: {
+                    utilization: liveQuotaWithResetCredits.sevenDay.utilization,
+                    resetsAt: liveQuotaWithResetCredits.sevenDay.resetsAt,
+                },
+                available: liveQuotaWithResetCredits.available,
+                error: liveQuotaWithResetCredits.error,
+                source: liveQuotaWithResetCredits.source,
+                stale: liveQuotaWithResetCredits.stale,
+            };
+            try {
+                const result = this.appendHistorySample(sample);
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => {
+                        // History append must never break the live emission path.
+                    });
                 }
             }
+            catch {
+                // Synchronous errors swallowed for the same reason.
+            }
         }
         this.emitState(enrichQuotaState({
             ...liveQuotaWithResetCredits,
@@ -260,8 +302,12 @@ class CodexQuotaWatcher {
             providerId: 'codex',
         }, account));
     }
-    emitCachedOrUnavailable() {
-        const account = this.getActiveAccount();
+    emitCachedOrUnavailable(knownAccount) {
+        const account = knownAccount ?? this.safeGetActiveAccount();
+        if (!account) {
+            this.emitState(makeUnavailableState(null, 'No Codex account configured'));
+            return;
+        }
         const scanNow = this.now();
         if (scanNow - this.lastLocalScanAt < this.localScanCacheMs) {
             if (this.lastLocalScanState) {
@@ -296,7 +342,7 @@ class CodexQuotaWatcher {
                 localProvider?.dispose();
             }
         }
-        const cached = account ? this.readSnapshot('codex', account.id) : null;
+        const cached = this.readSnapshot('codex', account.id);
         if (cached) {
             this.emitState(enrichQuotaState({
                 ...cached,
@@ -331,6 +377,14 @@ class CodexQuotaWatcher {
         }
         return this.provider;
     }
+    safeGetActiveAccount() {
+        try {
+            return this.getActiveAccount();
+        }
+        catch {
+            return null;
+        }
+    }
     teardownActiveSession() {
         if (this.fileWatcher) {
             this.fileWatcher.close();

package/dist/context/sessionContext.js

@@ -12,6 +12,7 @@ exports.createSessionContextProjector = createSessionContextProjector;
 exports.readSessionContextSnapshot = readSessionContextSnapshot;
 const EventAggregator_1 = require("../aggregation/EventAggregator");
 const modelContext_1 = require("../modelContext");
+const mcpToolName_1 = require("../parsers/mcpToolName");
 const tokenEstimation_1 = require("../tokenEstimation");
 const DEFAULT_CONTEXT_SOURCE_LIMIT = 200;
 const DEFAULT_SNIPPET_MAX_CHARS = 240;
@@ -490,10 +491,7 @@ function inferMcpServer(toolName, input) {
     const explicit = input._sidekickMcpServerName ?? input.server_name ?? input.serverName;
     if (typeof explicit === 'string' && explicit.trim())
         return explicit.trim();
-    const match = /^mcp__([^_]+(?:_[^_]+)*)__/.exec(toolName);
-    if (match)
-        return match[1];
-    return undefined;
+    return (0, mcpToolName_1.parseMcpToolName)(toolName)?.serverName;
 }
 function extractText(content) {
     if (typeof content === 'string')

package/dist/ensureDefaultAccounts.js

@@ -72,14 +72,14 @@ async function ensureDefaultClaudeAccount(options) {
 function cleanupPendingCodexProfile(profileId) {
     fs.rmSync(path.join((0, codexProfiles_1.getCodexProfilesDir)(), profileId), { recursive: true, force: true });
 }
-function ensureDefaultCodexAccount(options) {
+async function ensureDefaultCodexAccount(options) {
     try {
         if ((0, codexProfiles_1.getActiveCodexAccount)())
             return 'skipped';
         const systemAuthPath = path.join((0, codexProfiles_1.getSystemCodexHome)(), 'auth.json');
         if (!fs.existsSync(systemAuthPath))
             return 'skipped';
-        const result = (0, codexProfiles_1.prepareCodexAccount)('Default');
+        const result = await (0, codexProfiles_1.prepareCodexAccountAsync)('Default');
         if (result.success && !result.needsLogin)
             return 'registered';
         if (result.profileId) {
@@ -95,7 +95,7 @@ function ensureDefaultCodexAccount(options) {
 }
 async function ensureDefaultAccounts(options) {
     const claude = await ensureDefaultClaudeAccount(options);
-    const codex = ensureDefaultCodexAccount(options);
+    const codex = await ensureDefaultCodexAccount(options);
     try {
         (0, accounts_1.reconcileClaudeAuthState)();
     }
@@ -103,7 +103,7 @@ async function ensureDefaultAccounts(options) {
         logFailure(options, 'Claude auth reconciliation failed.', error);
     }
     try {
-        (0, codexProfiles_1.reconcileCodexAuthState)();
+        await (0, codexProfiles_1.reconcileCodexAuthStateAsync)();
     }
     catch (error) {
         logFailure(options, 'Codex auth reconciliation failed.', error);

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export { projectSessionTranscript } from './transcript';
 export type { TranscriptFidelity, TranscriptSourceProvenance, CanonicalTranscriptBlock, CanonicalTranscriptMessage, CanonicalToolCall, CanonicalTranscriptUsageTotals, CanonicalSessionTranscript, ProjectSessionTranscriptOptions, } from './transcript';
 export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
 export type { ProviderSessionIndex, ListRecentSessionsOptions } from './sessionTranscripts';
-export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, } from './observedSessionCollector';
-export type { ObservedSessionReference, ObservedSessionCollectionSource, ProviderObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';
+export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
+export type { KnownObservedSessionFingerprint, ObservedSessionChange, ObservedSessionChangeBatch, ObservedSessionChangeType, ObservedSessionReference, ObservedSessionFingerprintParts, ObservedSessionSourceSubscribeOptions, ObservedSessionSubscribeOptions, ObservedSessionCollectionSource, ProviderObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnosticPhase, ObservedSessionDiagnosticSeverity, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';
 export type { SessionEvent, ClaudeSessionEvent, MessageUsage, SessionMessage, SessionEventBase, MessageSessionEvent, UserSessionEvent, AssistantSessionEvent, SummarySessionEvent, SystemSessionEvent, ToolUseSessionEvent, ToolResultSessionEvent, 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';
@@ -38,29 +38,39 @@ export { readHistory } from './readers/history';
 export { readLatestHandoff } from './readers/handoff';
 export { readPlans, getLatestPlan, writePlans, getPlanAnalytics, readClaudeCodePlanFiles, } from './readers/plans';
 export type { ReadPlansOptions, PlanAnalytics } from './readers/plans';
-export { atomicWriteJson, atomicWriteJsonSync, updateJsonStoreAtomic } from './writers/atomic';
+export { atomicWriteJson, atomicWriteJsonSync, atomicWriteFileSync, updateJsonStoreAtomic, updateJsonStoreAtomicSync, withFileLockSync, } from './writers/atomic';
 export { addTask, completeTask } from './writers/tasks';
 export { addDecision, decisionFingerprint } from './writers/decisions';
 export { addNote } from './writers/notes';
 export { renderHandoffUrlTemplate } from './handoffUrl';
 export type { HandoffUrlIdentifiers } from './handoffUrl';
-export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader, ProviderRuntimeStatus, } from './providers/types';
+export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader, SessionProviderOptions, ProviderOperationStatus, SessionProviderDiagnostic, SessionProviderDiagnosticKind, SessionProviderDiagnosticPhase, SessionProviderDiagnosticSeverity, ProviderRuntimeStatus, } from './providers/types';
+export { SESSION_PROVIDER_IDS } from './providers/types';
+export { createSessionProviders } from './providers/factory';
+export type { CreateSessionProvidersOptions, CreateSessionProvidersResult, } from './providers/factory';
 export { createProviderSessionAdapterV1, derivePendingUserRequestV1, } from './types/observedSessionV1';
-export type { ObservationProvenanceV1, ObservedAgentSessionV1, ObservedValueV1, PendingUserRequestV1, ProviderCapabilitiesV1, ProviderSessionAdapterV1, SessionEvidenceRefV1, } from './types/observedSessionV1';
+export type { ObservationProvenanceV1, ObservedAgentSessionV1, ObservedValueV1, PendingUserRequestV1, ProviderCapabilitiesV1, ProviderSessionAdapterV1, ProviderSessionAdapterV1Options, SessionEvidenceRefV1, } from './types/observedSessionV1';
 export { detectProvider, getAllDetectedProviders } from './providers/detect';
 export { ClaudeCodeProvider } from './providers/claudeCode';
 export { OpenCodeProvider, getOpenCodeDataDir } from './providers/openCode';
-export { CodexProvider } from './providers/codex';
+export { CodexProvider, findCodexRolloutFile } from './providers/codex';
+export type { FindCodexRolloutFileOptions } from './providers/codex';
 export { JsonlParser, TRUNCATION_PATTERNS } from './parsers/jsonl';
 export type { RawSessionEvent, JsonlParserCallbacks, JsonlParserOptions } from './parsers/jsonl';
 export { normalizeToolName, normalizeToolInput, detectPlanModeFromText, convertOpenCodeMessage, parseDbMessageData, parseDbPartData, } from './parsers/openCodeParser';
 export { CodexRolloutParser, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, } from './parsers/codexParser';
 export { scanSubagentDir, extractTaskInfo } from './parsers/subagentScanner';
-export { detectSessionActivity } from './parsers/sessionActivityDetector';
+export { detectSessionActivity, refreshSessionActivityState, } from './parsers/sessionActivityDetector';
 export type { SessionActivityState, SessionActivityResult, } from './parsers/sessionActivityDetector';
 export { encodeWorkspacePath as encodeClaudeWorkspacePath, getSessionDirectory as getClaudeSessionDirectory, discoverSessionDirectory, findActiveSession as findActiveClaudeSession, findAllSessions as findAllClaudeSessions, findSessionsInDirectory, findSubdirectorySessionDirs, getMostRecentlyActiveSessionDir, decodeEncodedPath, getAllProjectFolders as getAllClaudeProjectFolders, resolveWorktreeMainRepo, discoverWorktreeSiblings, findAllSessionsWithWorktrees, } from './parsers/sessionPathResolver';
 export { scanSubagentTraces } from './parsers/subagentTraceParser';
 export type { SubagentTrace, SubagentTraceEvent } from './parsers/subagentTraceParser';
+export { parseMcpToolName } from './parsers/mcpToolName';
+export type { McpToolNameParts } from './parsers/mcpToolName';
+export { readCodexHistory } from './parsers/codexHistory';
+export type { CodexHistoryEntry, ReadCodexHistoryOptions } from './parsers/codexHistory';
+export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, readSessionPreviewAsync, } from './sessionPreviews';
+export type { AsyncSessionPreviewOptions, ListSessionPreviewsAsyncOptions, ListSessionPreviewsOptions, ReadSessionPreviewAsyncOptions, ReadSessionPreviewOptions, SessionPreview, SessionPreviewListResult, SessionPreviewReadResult, } from './sessionPreviews';
 export { parseDebugLog, filterByLevel, collapseDuplicates, discoverDebugLogs, } from './parsers/debugLogParser';
 export type { DebugLogEntry, DebugLogFile, DebugLogLevel } from './parsers/debugLogParser';
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
@@ -98,7 +108,7 @@ export { ALL_PHRASES, PHRASE_CATEGORIES, getRandomPhrase } from './phrases';
 export type { PhraseCategory } from './phrases';
 export { EventAggregator, parseTodoDependencies } from './aggregation/EventAggregator';
 export { SessionMonitor } from './sessionMonitor';
-export type { SessionMonitorOptions } from './sessionMonitor';
+export type { SessionMonitorOptions, SessionMonitorSubscribeOptions } from './sessionMonitor';
 export type { SerializedAggregatorState } from './aggregation/EventAggregator';
 export { saveSnapshot, loadSnapshot, deleteSnapshot, isSnapshotValid, getSnapshotPath, } from './aggregation/snapshot';
 export type { SessionSnapshot } from './aggregation/snapshot';
@@ -126,21 +136,24 @@ export { ensureDefaultAccounts } from './ensureDefaultAccounts';
 export type { EnsureDefaultAccountStatus, EnsureDefaultAccountsOptions, EnsureDefaultAccountsResult, } from './ensureDefaultAccounts';
 export { readAccountRegistry, writeAccountRegistry, readActiveClaudeAccount, addCurrentAccount, switchToAccount, resolveActiveClaudeHome, applyActiveClaudeToLiveHome, reconcileClaudeAuthState, removeAccount, listAccounts, getActiveAccount, resolveActiveClaudeAccount, isMultiAccountEnabled, } from './accounts';
 export type { AccountEntry, AccountRegistry, ActiveAccountInfo, AccountManagerResult, } from './accounts';
-export { beginAccountLogin, getAccountLoginStatus, finalizeAccountLogin, spawnAccountLogin, switchAccount, listAllAccounts, resolveClaudeLoginCommand, } from './accountManager';
+export { beginAccountLogin, getAccountLoginStatus, getAccountLoginStatusAsync, finalizeAccountLogin, finalizeAccountLoginAsync, spawnAccountLogin, switchAccount, switchAccountAsync, listAllAccounts, resolveClaudeLoginCommand, } from './accountManager';
 export type { AccountLoginCommand, AccountLoginState, AccountLoginStatus, BeginAccountLoginResult, FinalizeAccountLoginOptions, ListAllAccountsResult, SpawnAccountLoginOptions, } from './accountManager';
 export { getAccountsDir, readSavedAccountRegistry, writeSavedAccountRegistry, listSavedAccountProfiles, getActiveSavedAccount, upsertSavedAccountProfile, setActiveSavedAccount, replaceSavedAccountProfiles, removeSavedAccountProfile, } from './accountRegistry';
 export type { AccountProviderId, AccountIdentityMetadata, ResolvedActiveAccount, SavedAccountProfile, SavedAccountRegistry, } from './accountRegistry';
+export { ACCOUNT_PROVIDER_IDS } from './accountRegistry';
 export { getActiveAccountStatus } from './accountStatus';
 export type { ActiveAccountStatus, ActiveProviderAccountStatus } from './accountStatus';
+export { onAccountsChanged } from './accountChanges';
+export type { AccountsChangedEvent, OnAccountsChangedOptions } from './accountChanges';
 export { getClaudeProfilesDir, getClaudeProfileHome, claudeKeychainSuffix, claudeKeychainService, isClaudeProfileAuthenticated, readClaudeProfileIdentity, } from './claudeProfiles';
 export type { ClaudeProfileIdentity } from './claudeProfiles';
-export { getCodexProfilesDir, getCodexProfileHome, getCodexMonitoringHomes, getSystemCodexHome, listCodexAccounts, getActiveCodexAccount, resolveActiveCodexAccount, resolveSidekickCodexHome, getCodexExecutionEnv, prepareCodexAccount, finalizeCodexAccount, switchToCodexAccount, removeCodexAccount, } from './codexProfiles';
+export { getCodexProfilesDir, getCodexProfileHome, getCodexMonitoringHomes, getSystemCodexHome, listCodexAccounts, getActiveCodexAccount, resolveActiveCodexAccount, resolveSidekickCodexHome, getCodexExecutionEnv, prepareCodexAccount, prepareCodexAccountAsync, finalizeCodexAccount, finalizeCodexAccountAsync, switchToCodexAccount, switchToCodexAccountAsync, removeCodexAccount, } from './codexProfiles';
 export type { CodexAccountManagerResult } from './codexProfiles';
 export { setTerminalActiveProfile, installShellHook, uninstallShellHook, isShellHookInstalled, writeLauncher, removeLauncher, } from './terminalSync';
 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 { CodexResetCredit, CodexResetCreditsSnapshot, QuotaProjectionInput, QuotaWindow, QuotaState, } from './quota';
+export { FIVE_HOUR_WINDOW_MS, QUOTA_PROVIDER_IDS, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
+export type { CodexResetCredit, CodexResetCreditsSnapshot, QuotaProjectionInput, QuotaProviderId, QuotaWindow, QuotaState, } from './quota';
 export { describeQuotaFailure } from './quotaPresentation';
 export type { QuotaFailureDescriptor } from './quotaPresentation';
 export { QuotaPoller } from './quotaPoller';
@@ -156,14 +169,18 @@ export { fetchZaiQuotaFromApi, quotaStateFromZaiQuotaLimitPayload, readZaiCreden
 export type { ReadZaiCredentialsOptions, ZaiCredentialSource, ZaiCredentials, ZaiPlatform, ZaiQuotaApiOptions, ZaiQuotaResolveOptions, } from './zaiQuotaApi';
 export { MultiProviderQuotaService } from './multiProviderQuotaService';
 export type { MultiProviderQuotaServiceOptions } from './multiProviderQuotaService';
+export { RUNTIME_QUOTA_PROVIDER_IDS } from './providerQuota';
 export type { ProviderQuotaMap, ProviderQuotaState, RuntimeQuotaProvider } from './providerQuota';
 export type { QuotaSnapshotProviderId } from './quotaSnapshots';
 export { BurnRateCalculator, estimateTimeToQuota } from './statusline/BurnRateCalculator';
 export { formatStatusline, selectStatuslineAccount } from './statusline/formatter';
 export type { StatuslineInput, StatuslineSelection } from './statusline/formatter';
-export { getModelContextWindowSize, DEFAULT_CONTEXT_WINDOW } from './modelContext';
-export { parseModelId, getModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, } from './modelInfo';
-export type { ModelPricing, CostTokenUsage, CostSource, CostProvenanceInput, CostWithProvenance, ModelInfo, ModelProvider, ParsedModelId, ModelDisplayInfo, } from './modelInfo';
+export { getModelContextWindowSize, resolveModelContextWindow, DEFAULT_CONTEXT_WINDOW, } from './modelContext';
+export type { ModelCatalogMatch, ModelContextWindowProvenance, ModelContextWindowSource, ResolvedModelContextWindow, } from './modelContext';
+export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, MODEL_PROVIDER_IDS, } from './modelInfo';
+export type { ModelPricing, CostTokenUsage, CostSource, CostProvenanceInput, CostWithProvenance, ModelInfo, ModelProvider, ParsedModelId, ModelDisplayInfo, ModelPricingMatch, ModelPricingProvenance, ModelPricingSource, ResolvedModelPricing, } from './modelInfo';
+export { exportResolvedModelCatalog, importResolvedModelCatalog, registerModelAlias, resolveModelAlias, RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, } from './modelCatalog';
+export type { ImportResolvedModelCatalogResult, ResolvedModelCatalogEntry, ResolvedModelCatalogSnapshot, } from './modelCatalog';
 export { hydratePricingCatalog, normalizeLiteLlmCatalog, normalizeLiteLlmContextWindows, LITELLM_CATALOG_URL, } from './pricingCatalog';
 export type { HydrateOptions, HydrateResult } from './pricingCatalog';
 export { loadObservedContextWindows, recordObservedContextWindow, getObservedContextWindowPath, } from './observedContextWindows';