Reduce battery drain from OpenAI web extras

Sources/CodexBar/MenuDescriptor.swift

@@ -400,6 +400,7 @@ struct MenuDescriptor {
             entries.append(.action("Update ready, restart now?", .installUpdate))
         }
         entries.append(contentsOf: [
+            .action("Refresh", .refresh),
             .action("Settings...", .settings),
             .action("About CodexBar", .about),
             .action("Quit", .quit),

Sources/CodexBar/PreferencesProvidersPane.swift

@@ -66,15 +66,7 @@ struct ProvidersPane: View {
                     isErrorExpanded: self.expandedBinding(for: provider),
                     onCopyError: { text in self.copyToPasteboard(text) },
                     onRefresh: {
-                        Task { @MainActor in
-                            await ProviderInteractionContext.$current.withValue(.userInitiated) {
-                                if provider == .codex {
-                                    await self.store.refreshCodexAccountScopedState(allowDisabled: true)
-                                } else {
-                                    await self.store.refreshProvider(provider, allowDisabled: true)
-                                }
-                            }
-                        }
+                        self.triggerRefresh(for: provider)
                     },
                     showsSupplementarySettingsContent: self.codexAccountsSectionState(for: provider) != nil,
                     supplementarySettingsContent: {
@@ -156,6 +148,18 @@ struct ProvidersPane: View {
         self.selectedProvider = self.providers.first
     }
 
+    private func triggerRefresh(for provider: UsageProvider) {
+        Task { @MainActor in
+            await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                if provider == .codex {
+                    await self.store.refreshCodexAccountScopedState(allowDisabled: true)
+                } else {
+                    await self.store.refreshProvider(provider, allowDisabled: true)
+                }
+            }
+        }
+    }
+
     func binding(for provider: UsageProvider) -> Binding<Bool> {
         let meta = self.store.metadata(for: provider)
         return Binding(

Sources/CodexBar/Providers/Codex/CodexProviderImplementation.swift

@@ -69,6 +69,7 @@ struct CodexProviderImplementation: ProviderImplementation {
                         for: .codex)
                 }
             })
+        let batterySaverBinding = context.boolBinding(\.openAIWebBatterySaverEnabled)
 
         return [
             ProviderSettingsToggleDescriptor(
@@ -85,14 +86,32 @@ struct CodexProviderImplementation: ProviderImplementation {
             ProviderSettingsToggleDescriptor(
                 id: "codex-openai-web-extras",
                 title: "OpenAI web extras",
-                subtitle: "Show usage breakdown, credits history, and code review via chatgpt.com.",
+                subtitle: [
+                    "Optional.",
+                    "Turn this on to show code review, usage breakdown, and credits history via chatgpt.com.",
+                ].joined(separator: " "),
                 binding: extrasBinding,
                 statusText: nil,
                 actions: [],
                 isVisible: nil,
                 onChange: nil,
                 onAppDidBecomeActive: nil,
                 onAppearWhenEnabled: nil),
+            ProviderSettingsToggleDescriptor(
+                id: "codex-openai-web-battery-saver",
+                title: "Battery Saver",
+                subtitle: [
+                    "Recommended.",
+                    "Limits background chatgpt.com refreshes to reduce battery and network usage.",
+                    "Dashboard extras may stay stale until you refresh them manually.",
+                ].joined(separator: " "),
+                binding: batterySaverBinding,
+                statusText: nil,
+                actions: [],
+                isVisible: { context.settings.openAIWebAccessEnabled },
+                onChange: nil,
+                onAppDidBecomeActive: nil,
+                onAppearWhenEnabled: nil),
         ]
     }
 

Sources/CodexBar/SettingsStore+Defaults.swift

@@ -268,6 +268,17 @@ extension SettingsStore {
         }
     }
 
+    var openAIWebBatterySaverEnabled: Bool {
+        get { self.defaultsState.openAIWebBatterySaverEnabled }
+        set {
+            self.defaultsState.openAIWebBatterySaverEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "openAIWebBatterySaverEnabled")
+            CodexBarLog.logger(LogCategories.settings).info(
+                "OpenAI web battery saver updated",
+                metadata: ["enabled": newValue ? "1" : "0"])
+        }
+    }
+
     var jetbrainsIDEBasePath: String {
         get { self.defaultsState.jetbrainsIDEBasePath }
         set {

Sources/CodexBar/SettingsStore+MenuObservation.swift

@@ -27,6 +27,7 @@ extension SettingsStore {
         _ = self.claudeWebExtrasEnabled
         _ = self.showOptionalCreditsAndExtraUsage
         _ = self.openAIWebAccessEnabled
+        _ = self.openAIWebBatterySaverEnabled
         _ = self.codexUsageDataSource
         _ = self.codexActiveSource
         _ = self.claudeUsageDataSource

Sources/CodexBar/SettingsStore.swift

@@ -124,6 +124,8 @@ final class SettingsStore {
         copilotTokenStore: any CopilotTokenStoring = KeychainCopilotTokenStore(),
         tokenAccountStore: any ProviderTokenAccountStoring = FileTokenAccountStore())
     {
+        let hasStoredOpenAIWebAccessPreference = userDefaults.object(forKey: "openAIWebAccessEnabled") != nil
+        let hadExistingConfig = (try? configStore.load()) != nil
         let legacyStores = CodexBarConfigMigrator.LegacyStores(
             zaiTokenStore: zaiTokenStore,
             syntheticTokenStore: syntheticTokenStore,
@@ -159,7 +161,13 @@ final class SettingsStore {
         self.ensureAlibabaProviderAutoEnabledIfNeeded()
         self.applyTokenCostDefaultIfNeeded()
         if self.claudeUsageDataSource != .cli { self.claudeWebExtrasEnabled = false }
-        self.openAIWebAccessEnabled = self.codexCookieSource.isEnabled
+        if hasStoredOpenAIWebAccessPreference {
+            self.openAIWebAccessEnabled = self.defaultsState.openAIWebAccessEnabled
+        } else {
+            self.openAIWebAccessEnabled = Self.inferredInitialOpenAIWebAccessEnabled(
+                config: config,
+                hadExistingConfig: hadExistingConfig)
+        }
         if Self.shouldBridgeSharedDefaults(for: userDefaults) {
             Self.sharedDefaults?.set(self.debugDisableKeychainAccess, forKey: "debugDisableKeychainAccess")
         }
@@ -168,6 +176,16 @@ final class SettingsStore {
 }
 
 extension SettingsStore {
+    private static func inferredInitialOpenAIWebAccessEnabled(
+        config: CodexBarConfig,
+        hadExistingConfig: Bool) -> Bool
+    {
+        guard let codex = config.providerConfig(for: .codex) else { return false }
+        if let cookieSource = codex.cookieSource { return cookieSource.isEnabled }
+        if codex.sanitizedCookieHeader != nil { return true }
+        return hadExistingConfig
+    }
+
     private static func loadDefaultsState(userDefaults: UserDefaults) -> SettingsDefaultsState {
         let refreshDefault = userDefaults.string(forKey: "refreshFrequency")
             .flatMap(RefreshFrequency.init(rawValue:))
@@ -230,8 +248,11 @@ extension SettingsStore {
         let showOptionalCreditsAndExtraUsage = creditsExtrasDefault ?? true
         if creditsExtrasDefault == nil { userDefaults.set(true, forKey: "showOptionalCreditsAndExtraUsage") }
         let openAIWebAccessDefault = userDefaults.object(forKey: "openAIWebAccessEnabled") as? Bool
-        let openAIWebAccessEnabled = openAIWebAccessDefault ?? true
-        if openAIWebAccessDefault == nil { userDefaults.set(true, forKey: "openAIWebAccessEnabled") }
+        let openAIWebAccessEnabled = openAIWebAccessDefault ?? false
+        if openAIWebAccessDefault == nil { userDefaults.set(false, forKey: "openAIWebAccessEnabled") }
+        let openAIWebBatterySaverDefault = userDefaults.object(forKey: "openAIWebBatterySaverEnabled") as? Bool
+        let openAIWebBatterySaverEnabled = openAIWebBatterySaverDefault ?? false
+        if openAIWebBatterySaverDefault == nil { userDefaults.set(false, forKey: "openAIWebBatterySaverEnabled") }
         let jetbrainsIDEBasePath = userDefaults.string(forKey: "jetbrainsIDEBasePath") ?? ""
         let mergeIcons = userDefaults.object(forKey: "mergeIcons") as? Bool ?? true
         let switcherShowsIcons = userDefaults.object(forKey: "switcherShowsIcons") as? Bool ?? true
@@ -269,6 +290,7 @@ extension SettingsStore {
             claudeWebExtrasEnabledRaw: claudeWebExtrasEnabledRaw,
             showOptionalCreditsAndExtraUsage: showOptionalCreditsAndExtraUsage,
             openAIWebAccessEnabled: openAIWebAccessEnabled,
+            openAIWebBatterySaverEnabled: openAIWebBatterySaverEnabled,
             jetbrainsIDEBasePath: jetbrainsIDEBasePath,
             mergeIcons: mergeIcons,
             switcherShowsIcons: switcherShowsIcons,

Sources/CodexBar/SettingsStoreState.swift

@@ -27,6 +27,7 @@ struct SettingsDefaultsState {
     var claudeWebExtrasEnabledRaw: Bool
     var showOptionalCreditsAndExtraUsage: Bool
     var openAIWebAccessEnabled: Bool
+    var openAIWebBatterySaverEnabled: Bool
     var jetbrainsIDEBasePath: String
     var mergeIcons: Bool
     var switcherShowsIcons: Bool

Sources/CodexBar/UsageStore+BackgroundRefresh.swift

@@ -0,0 +1,24 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    func clearDisabledProviderState(enabledProviders: Set<UsageProvider>) {
+        for provider in UsageProvider.allCases where !enabledProviders.contains(provider) {
+            self.refreshingProviders.remove(provider)
+            self.snapshots.removeValue(forKey: provider)
+            self.errors[provider] = nil
+            self.lastSourceLabels.removeValue(forKey: provider)
+            self.lastFetchAttempts.removeValue(forKey: provider)
+            self.accountSnapshots.removeValue(forKey: provider)
+            self.tokenSnapshots.removeValue(forKey: provider)
+            self.tokenErrors[provider] = nil
+            self.failureGates[provider]?.reset()
+            self.tokenFailureGates[provider]?.reset()
+            self.statuses.removeValue(forKey: provider)
+            self.lastKnownSessionRemaining.removeValue(forKey: provider)
+            self.lastKnownSessionWindowSource.removeValue(forKey: provider)
+            self.lastTokenFetchAt.removeValue(forKey: provider)
+        }
+    }
+}

Sources/CodexBar/UsageStore+Logging.swift

@@ -18,6 +18,7 @@ extension UsageStore {
             "ampCookieSource": self.settings.ampCookieSource.rawValue,
             "ollamaCookieSource": self.settings.ollamaCookieSource.rawValue,
             "openAIWebAccess": self.settings.openAIWebAccessEnabled ? "1" : "0",
+            "openAIWebBatterySaver": self.settings.openAIWebBatterySaverEnabled ? "1" : "0",
             "claudeWebExtras": self.settings.claudeWebExtrasEnabled ? "1" : "0",
             "kiloExtras": self.settings.kiloExtrasEnabled ? "1" : "0",
         ]

Sources/CodexBar/UsageStore+OpenAIWeb.swift

@@ -1,6 +1,22 @@
 import CodexBarCore
 import Foundation
 
+struct OpenAIWebRefreshGateContext {
+    let force: Bool
+    let accountDidChange: Bool
+    let lastError: String?
+    let lastSnapshotAt: Date?
+    let lastAttemptAt: Date?
+    let now: Date
+    let refreshInterval: TimeInterval
+}
+
+struct OpenAIWebRefreshPolicyContext {
+    let accessEnabled: Bool
+    let batterySaverEnabled: Bool
+    let force: Bool
+}
+
 // MARK: - OpenAI web lifecycle
 
 extension UsageStore {
@@ -31,15 +47,28 @@ extension UsageStore {
     }
 
     func requestOpenAIDashboardRefreshIfStale(reason: String) {
-        guard self.isEnabled(.codex), self.settings.codexCookieSource.isEnabled else { return }
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else { return }
         let now = Date()
         let refreshInterval = self.openAIWebRefreshIntervalSeconds()
         let lastUpdatedAt = self.openAIDashboard?.updatedAt ?? self.lastOpenAIDashboardSnapshot?.updatedAt
         if let lastUpdatedAt, now.timeIntervalSince(lastUpdatedAt) < refreshInterval { return }
         let stamp = now.formatted(date: .abbreviated, time: .shortened)
         self.logOpenAIWeb("[\(stamp)] OpenAI web refresh request: \(reason)")
+        let forceRefresh = Self.forceOpenAIWebRefreshForStaleRequest(
+            batterySaverEnabled: self.settings.openAIWebBatterySaverEnabled)
+        self.openAIWebLogger.debug(
+            "OpenAI web stale refresh gate",
+            metadata: [
+                "reason": reason,
+                "force": forceRefresh ? "1" : "0",
+                "batterySaverEnabled": self.settings.openAIWebBatterySaverEnabled ? "1" : "0",
+                "interaction": ProviderInteractionContext.current == .userInitiated ? "user" : "background",
+            ])
         let expectedGuard = self.currentCodexOpenAIWebRefreshGuard()
-        Task { await self.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard) }
+        Task { await self.refreshOpenAIDashboardIfNeeded(force: forceRefresh, expectedGuard: expectedGuard) }
     }
 
     func applyOpenAIDashboard(
@@ -95,6 +124,7 @@ extension UsageStore {
             return
         }
 
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
         await MainActor.run {
             if let cached = self.lastOpenAIDashboardSnapshot {
                 self.openAIDashboard = cached
@@ -132,6 +162,7 @@ extension UsageStore {
             return
         }
 
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
         await MainActor.run {
             self.lastOpenAIDashboardError = [
                 "OpenAI web access requires a signed-in chatgpt.com session.",
@@ -311,10 +342,11 @@ extension UsageStore {
         bypassCoalescing: Bool = false,
         allowCodexUsageBackfill: Bool = true) async
     {
-        guard self.isEnabled(.codex), self.settings.codexCookieSource.isEnabled else {
-            self.resetOpenAIWebState()
-            return
-        }
+        self.syncOpenAIWebState()
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else { return }
         if self.openAIWebManagedTargetStoreIsUnreadable() {
             await self.failClosedRefreshForUnreadableManagedCodexStore()
             return
@@ -341,14 +373,18 @@ extension UsageStore {
 
         let now = Date()
         let minInterval = self.openAIWebRefreshIntervalSeconds()
-        if !force,
-           !self.openAIWebAccountDidChange,
-           self.lastOpenAIDashboardError == nil,
-           let snapshot = self.lastOpenAIDashboardSnapshot,
-           now.timeIntervalSince(snapshot.updatedAt) < minInterval
-        {
+        let refreshGate = OpenAIWebRefreshGateContext(
+            force: force,
+            accountDidChange: self.openAIWebAccountDidChange,
+            lastError: self.lastOpenAIDashboardError,
+            lastSnapshotAt: self.lastOpenAIDashboardSnapshot?.updatedAt,
+            lastAttemptAt: self.lastOpenAIDashboardAttemptAt,
+            now: now,
+            refreshInterval: minInterval)
+        if Self.shouldSkipOpenAIWebRefresh(refreshGate) {
             return
         }
+        self.lastOpenAIDashboardAttemptAt = now
 
         let taskToken = UUID()
         let context = OpenAIDashboardRefreshContext(
@@ -610,6 +646,7 @@ extension UsageStore {
             self.lastOpenAIDashboardSnapshot = nil
             self.lastOpenAIDashboardAttachmentAuthorized = false
             self.lastOpenAIDashboardError = nil
+            self.lastOpenAIDashboardAttemptAt = nil
             self.openAIDashboardRequiresLogin = true
             self.openAIDashboardCookieImportStatus = "Codex account changed; importing browser cookies…"
             self.lastOpenAIDashboardCookieImportAttemptAt = nil
@@ -994,12 +1031,14 @@ extension UsageStore {
 
     func resetOpenAIWebState() {
         self.invalidateOpenAIDashboardRefreshTask()
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
         self.openAIDashboard = nil
         self.openAIDashboardAttachmentAuthorized = false
         self.lastOpenAIDashboardError = nil
         self.lastOpenAIDashboardSnapshot = nil
         self.lastOpenAIDashboardAttachmentAuthorized = false
         self.lastOpenAIDashboardTargetEmail = nil
+        self.lastOpenAIDashboardAttemptAt = nil
         self.openAIDashboardRequiresLogin = false
         self.openAIDashboardCookieImportStatus = nil
         self.openAIDashboardCookieImportDebugLog = nil
@@ -1079,6 +1118,46 @@ extension UsageStore {
 // MARK: - OpenAI web error messaging
 
 extension UsageStore {
+    nonisolated static func shouldRunOpenAIWebRefresh(_ context: OpenAIWebRefreshPolicyContext) -> Bool {
+        guard context.accessEnabled else { return false }
+        return context.force || !context.batterySaverEnabled
+    }
+
+    nonisolated static func forceOpenAIWebRefreshForStaleRequest(batterySaverEnabled: Bool) -> Bool {
+        !batterySaverEnabled
+    }
+
+    nonisolated static func shouldSkipOpenAIWebRefresh(_ context: OpenAIWebRefreshGateContext) -> Bool {
+        if context.force || context.accountDidChange { return false }
+        if let lastAttemptAt = context.lastAttemptAt,
+           context.now.timeIntervalSince(lastAttemptAt) < context.refreshInterval
+        {
+            return true
+        }
+        if context.lastError == nil,
+           let lastSnapshotAt = context.lastSnapshotAt,
+           context.now.timeIntervalSince(lastSnapshotAt) < context.refreshInterval
+        {
+            return true
+        }
+        return false
+    }
+
+    func syncOpenAIWebState() {
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else {
+            self.resetOpenAIWebState()
+            return
+        }
+
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: true,
+            allowLastKnownLiveFallback: true)
+        self.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: targetEmail)
+    }
+
     func openAIDashboardFriendlyError(
         body: String,
         targetEmail: String?,