refactor: model menu-open refresh policy

Author: steipete

Sources/CodexBar/MenuOpenRefreshPlan.swift

@@ -0,0 +1,34 @@
+import CodexBarCore
+
+struct MenuOpenRefreshPlan: Equatable {
+    struct Inputs {
+        let refreshAllOnOpen: Bool
+        let enabledProviders: [UsageProvider]
+        let visibleProviders: [UsageProvider]
+        let refreshingProviders: Set<UsageProvider>
+        let staleProviders: Set<UsageProvider>
+        let missingProviders: Set<UsageProvider>
+    }
+
+    enum Scheduling: Equatable {
+        case sequential
+        case concurrent
+    }
+
+    let providers: [UsageProvider]
+    let scheduling: Scheduling
+
+    static func resolve(_ inputs: Inputs) -> Self {
+        if inputs.refreshAllOnOpen {
+            return Self(providers: inputs.enabledProviders, scheduling: .concurrent)
+        }
+
+        let enabled = Set(inputs.enabledProviders)
+        let providers = inputs.visibleProviders.filter {
+            enabled.contains($0) &&
+                (inputs.refreshingProviders.contains($0) || inputs.staleProviders.contains($0) ||
+                    inputs.missingProviders.contains($0))
+        }
+        return Self(providers: providers, scheduling: .sequential)
+    }
+}

Sources/CodexBar/SettingsStore+Defaults.swift

@@ -13,8 +13,8 @@ extension SettingsStore {
         }
     }
 
-    /// When enabled, opening the menu refreshes usage for every enabled provider (on top of the
-    /// periodic refresh clock, which is left untouched). See `scheduleOpenMenuRefresh`.
+    /// When enabled, keeping the menu open through its short refresh delay fetches usage for every
+    /// enabled provider. The periodic refresh clock remains unchanged. See `scheduleOpenMenuRefresh`.
     var refreshAllProvidersOnMenuOpen: Bool {
         get { self.defaultsState.refreshAllProvidersOnMenuOpen }
         set {

Sources/CodexBar/StatusItemController+Menu.swift

@@ -1133,20 +1133,16 @@ extension StatusItemController {
             #endif
             guard self.openMenus[ObjectIdentifier(menu)] != nil else { return }
             let refreshAllOnOpen = self.settings.refreshAllProvidersOnMenuOpen
-            let availableProviders = Set(self.store.enabledProvidersForBackgroundWork())
-            // When "refresh all providers on open" is enabled, consider every enabled provider and refresh
-            // it regardless of freshness; otherwise keep the conservative stale/missing retry set scoped to
-            // the providers actually rendered in this menu.
-            let candidateProviders = refreshAllOnOpen
-                ? self.store.enabledProvidersForBackgroundWork()
-                : self.delayedRefreshRetryProviders(for: menu)
-            let retryProviders = candidateProviders.filter {
-                availableProviders.contains($0) &&
-                    (refreshAllOnOpen ||
-                        self.store.refreshingProviders.contains($0) ||
-                        self.store.isStale(provider: $0) ||
-                        self.store.snapshot(for: $0) == nil)
-            }
+            let enabledProviders = self.store.enabledProvidersForBackgroundWork()
+            let visibleProviders = self.delayedRefreshRetryProviders(for: menu)
+            let plan = MenuOpenRefreshPlan.resolve(.init(
+                refreshAllOnOpen: refreshAllOnOpen,
+                enabledProviders: enabledProviders,
+                visibleProviders: visibleProviders,
+                refreshingProviders: self.store.refreshingProviders,
+                staleProviders: Set(visibleProviders.filter { self.store.isStale(provider: $0) }),
+                missingProviders: Set(visibleProviders.filter { self.store.snapshot(for: $0) == nil })))
+            let retryProviders = plan.providers
             guard !retryProviders.isEmpty else {
                 self.clearSatisfiedDeferredMenuInteractionRefreshes(
                     for: self.delayedRefreshRetryProviders(for: menu))
@@ -1162,7 +1158,7 @@ extension StatusItemController {
             }
             self.deferMenuInteractionRefreshIfNeeded(providers: retryProviders)
             await ProviderInteractionContext.$current.withValue(.background) {
-                if refreshAllOnOpen {
+                if plan.scheduling == .concurrent {
                     // Refresh concurrently so one slow provider doesn't delay the rest, mirroring the
                     // periodic refresh in `UsageStore.runRefresh`. `coalesceIfRefreshing` makes each call
                     // wait for any in-flight refresh (e.g. a manual refresh) instead of overriding it.

Tests/CodexBarTests/MenuOpenRefreshPlanTests.swift

@@ -0,0 +1,46 @@
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+struct MenuOpenRefreshPlanTests {
+    @Test
+    func `refresh all selects every enabled provider concurrently`() {
+        let plan = MenuOpenRefreshPlan.resolve(.init(
+            refreshAllOnOpen: true,
+            enabledProviders: [.codex, .claude, .factory],
+            visibleProviders: [.codex],
+            refreshingProviders: [],
+            staleProviders: [],
+            missingProviders: []))
+
+        #expect(plan.providers == [.codex, .claude, .factory])
+        #expect(plan.scheduling == .concurrent)
+    }
+
+    @Test
+    func `ordinary refresh selects only visible enabled retries sequentially`() {
+        let plan = MenuOpenRefreshPlan.resolve(.init(
+            refreshAllOnOpen: false,
+            enabledProviders: [.codex, .claude, .factory],
+            visibleProviders: [.factory, .codex, .claude, .cursor],
+            refreshingProviders: [.factory],
+            staleProviders: [.codex],
+            missingProviders: [.claude, .cursor]))
+
+        #expect(plan.providers == [.factory, .codex, .claude])
+        #expect(plan.scheduling == .sequential)
+    }
+
+    @Test
+    func `ordinary refresh skips fresh providers`() {
+        let plan = MenuOpenRefreshPlan.resolve(.init(
+            refreshAllOnOpen: false,
+            enabledProviders: [.codex],
+            visibleProviders: [.codex],
+            refreshingProviders: [],
+            staleProviders: [],
+            missingProviders: []))
+
+        #expect(plan.providers.isEmpty)
+    }
+}

Tests/CodexBarTests/SettingsStoreTests.swift

@@ -86,6 +86,29 @@ struct SettingsStoreTests {
         #expect(storeB.refreshFrequency.seconds == 900)
     }
 
+    @Test
+    func `refresh on open defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-refresh-on-open"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.refreshAllProvidersOnMenuOpen == false)
+        store.refreshAllProvidersOnMenuOpen = true
+
+        let reloaded = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        #expect(reloaded.refreshAllProvidersOnMenuOpen == true)
+    }
+
     @Test
     func `weekly confetti setting defaults off and persists`() throws {
         let suite = "SettingsStoreTests-weekly-confetti"