fix: scope provider refresh state (#1911)

* fix: scope refresh-row disabling to the provider being refreshed

Refreshing one provider greyed out — and single-flighted — the Refresh
row for every provider, so the menu implied the others were refreshing
when they were not.

Replace the single global `manualRefreshTask` with a per-scope map
(`.global` for the all-providers ⌘R/overview refresh, `.provider(p)`
for a single provider). The disable gate now reflects only the target
provider's own refresh (a global refresh still disables every row), and
`startManualRefresh` guards per scope so different providers can refresh
concurrently instead of one blocking the rest. `MenuCardRefreshMonitor`
tracks in-flight providers as a set plus a global flag.

Rewrites the refresh-row tests that encoded the old blanket behavior and
adds coverage for scoped greying and concurrent per-provider refreshes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: address review — preserve frozen cards and exclude global/provider overlap

- MenuCardRefreshMonitor: keep an already-refreshing provider's frozen card when a
  second provider's refresh re-supplies models (old-wins merge), so the first card
  no longer jumps mid-refresh — the artifact the freeze exists to prevent.
- startManualRefresh: make a .global refresh mutually exclusive with any per-provider
  one (and vice versa); two different providers still refresh concurrently.
- Merged-overview Refresh row now reflects any in-flight manual refresh, including a
  per-provider refresh's post-fetch status/token tail, instead of flickering.
- Make the test-only manualRefreshTask / manualRefreshProvider accessors return a value
  only when unambiguous (global, or exactly one task), else nil; move them to +Actions.
- Add tests: concurrent frozen-card retention, and overview-busy-through-tail + global
  refresh exclusion.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: apply frozen-card old-wins merge, global/provider exclusivity guard, scoped overview greying

* fix: isolate provider refresh snapshots

* test: use scoped refresh tasks

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: Peter Steinberger <steipete@gmail.com>

Author: 3 people

Sources/CodexBar/MenuCardRefreshMonitor.swift

@@ -13,10 +13,18 @@ final class MenuCardRefreshMonitor {
     typealias ModelResolver = @MainActor (UsageProvider) -> UsageMenuCardView.Model?
 
     private let resolveModel: ModelResolver
-    var isManualRefreshInFlight = false
-    private var manualRefreshProvider: UsageProvider?
+    /// Set while an all-providers refresh is running; it freezes every provider's card.
+    private var globalManualRefreshInFlight = false
+    /// Providers with an individual manual refresh in flight. Concurrent entries are allowed so
+    /// refreshing one provider does not stall or unfreeze another.
+    private var manualRefreshProviders: Set<UsageProvider> = []
     private var frozenManualRefreshModels: [UsageProvider: UsageMenuCardView.Model] = [:]
 
+    /// True while any manual refresh (global or per-provider) is running.
+    var isManualRefreshInFlight: Bool {
+        self.globalManualRefreshInFlight || !self.manualRefreshProviders.isEmpty
+    }
+
     init(resolveModel: @escaping ModelResolver) {
         self.resolveModel = resolveModel
     }
@@ -25,19 +33,34 @@ final class MenuCardRefreshMonitor {
         frozenModels: [UsageProvider: UsageMenuCardView.Model],
         provider: UsageProvider? = nil)
     {
-        self.frozenManualRefreshModels = frozenModels
-        self.manualRefreshProvider = provider
-        self.isManualRefreshInFlight = true
+        if let provider {
+            self.frozenManualRefreshModels[provider] = frozenModels[provider]
+            self.manualRefreshProviders.insert(provider)
+        } else {
+            self.frozenManualRefreshModels = frozenModels
+            self.globalManualRefreshInFlight = true
+        }
+    }
+
+    /// Balances a `beginManualRefresh` with the same `provider` argument (nil ends the global refresh).
+    func endManualRefresh(for provider: UsageProvider? = nil) {
+        if let provider {
+            self.manualRefreshProviders.remove(provider)
+            self.frozenManualRefreshModels[provider] = nil
+        } else {
+            self.globalManualRefreshInFlight = false
+            self.frozenManualRefreshModels.removeAll(keepingCapacity: true)
+        }
     }
 
-    func endManualRefresh() {
-        self.isManualRefreshInFlight = false
-        self.manualRefreshProvider = nil
+    func resetManualRefresh() {
+        self.globalManualRefreshInFlight = false
+        self.manualRefreshProviders.removeAll(keepingCapacity: true)
         self.frozenManualRefreshModels.removeAll(keepingCapacity: true)
     }
 
     func isManualRefreshInFlight(for provider: UsageProvider) -> Bool {
-        self.isManualRefreshInFlight && (self.manualRefreshProvider == nil || self.manualRefreshProvider == provider)
+        self.globalManualRefreshInFlight || self.manualRefreshProviders.contains(provider)
     }
 
     func model(

Sources/CodexBar/StatusItemController+Actions.swift

@@ -1,6 +1,15 @@
 import AppKit
 import CodexBarCore
 
+extension StatusItemController {
+    /// Identifies which manual refresh a task belongs to, so per-provider refreshes stay independent
+    /// of each other and of the all-providers refresh.
+    enum ManualRefreshScope: Hashable {
+        case global
+        case provider(UsageProvider)
+    }
+}
+
 enum LoginNotificationLogic {
     static func notificationCopy(providerName: String) -> (title: String, body: String) {
         (
@@ -114,10 +123,17 @@ extension StatusItemController: StatusItemMenuPersistentActionDelegate {
     }
 
     private func startManualRefresh(for provider: UsageProvider?) {
+        let scope: ManualRefreshScope = provider.map(ManualRefreshScope.provider) ?? .global
         let scopedRefreshInFlight = provider.map { self.store.refreshingProviders.contains($0) }
             ?? !self.store.refreshingProviders.isEmpty
+        // Two different providers may refresh concurrently, but an all-providers (.global) refresh must
+        // not overlap a per-provider one (or vice versa) — that would duplicate the shared fetch work.
+        let conflictsWithOtherScope = scope == .global
+            ? self.manualRefreshTasks.contains { $0.key != .global }
+            : self.manualRefreshTasks[.global] != nil
         guard !self.hasPreparedForAppShutdown,
-              self.manualRefreshTask == nil,
+              self.manualRefreshTasks[scope] == nil,
+              !conflictsWithOtherScope,
               !self.store.isRefreshing,
               !scopedRefreshInFlight
         else { return }
@@ -126,9 +142,8 @@ extension StatusItemController: StatusItemMenuPersistentActionDelegate {
         let task = Task { @MainActor [weak self] in
             guard let self else { return }
             defer {
-                self.manualRefreshTask = nil
-                self.manualRefreshProvider = nil
-                self.menuCardRefreshMonitor.endManualRefresh()
+                self.manualRefreshTasks[scope] = nil
+                self.menuCardRefreshMonitor.endManualRefresh(for: provider)
                 self.updatePersistentRefreshItemsEnabled()
                 self.prepareAttachedClosedMenusIfNeeded()
             }
@@ -152,8 +167,7 @@ extension StatusItemController: StatusItemMenuPersistentActionDelegate {
                     interaction: .userInitiated)
             }
         }
-        self.manualRefreshProvider = provider
-        self.manualRefreshTask = task
+        self.manualRefreshTasks[scope] = task
         self.menuCardRefreshMonitor.beginManualRefresh(frozenModels: frozenModels, provider: provider)
         self.updatePersistentRefreshItemsEnabled()
     }

Sources/CodexBar/StatusItemController+MenuTracking.swift

@@ -111,7 +111,7 @@ extension StatusItemController {
 
     var isMenuDataRefreshInFlight: Bool {
         self.store.isRefreshing ||
-            self.manualRefreshTask != nil ||
+            !self.manualRefreshTasks.isEmpty ||
             !self.store.refreshingProviders.isEmpty ||
             UsageProvider.allCases.contains { self.store.isTokenRefreshInFlight(for: $0) }
     }

Sources/CodexBar/StatusItemController+PersistentMenuActions.swift

@@ -16,18 +16,29 @@ extension StatusItemController {
     }
 
     func isRefreshActionInFlight(for menu: NSMenu) -> Bool {
-        if self.manualRefreshTask != nil {
+        // An all-providers manual refresh (⌘R / overview) legitimately busies every row.
+        if self.manualRefreshTasks[.global] != nil {
             return true
         }
 
         if self.isMergedOverviewSelected(in: menu) {
-            // Overview refresh is global, so its busy state must mirror the global manual-refresh gate.
-            return self.store.isRefreshing || !self.store.refreshingProviders.isEmpty
+            // Overview stands for every provider, so it is busy while ANY manual refresh runs —
+            // including the post-fetch tail of a per-provider refresh, after `refreshingProviders`
+            // has cleared but its `.provider` task is still finishing status/token/credits work.
+            return self.store.isRefreshing
+                || !self.manualRefreshTasks.isEmpty
+                || !self.store.refreshingProviders.isEmpty
         }
         if let provider = self.menuProvider(for: menu) {
-            return self.store.isRefreshing || self.store.refreshingProviders.contains(provider)
+            // A manual refresh of a different provider must not grey out this provider's row: only
+            // reflect the global refresh, this provider's own manual refresh, and its store refresh.
+            return self.store.isRefreshing
+                || self.manualRefreshTasks[.provider(provider)] != nil
+                || self.store.refreshingProviders.contains(provider)
         }
-        return self.store.isRefreshing || !self.store.refreshingProviders.isEmpty
+        return self.store.isRefreshing
+            || !self.manualRefreshTasks.isEmpty
+            || !self.store.refreshingProviders.isEmpty
     }
 
     func isMergedOverviewSelected(in menu: NSMenu) -> Bool {

Sources/CodexBar/StatusItemController+Shutdown.swift

@@ -28,10 +28,11 @@ extension StatusItemController {
         self.menuBarCountdownRefreshTask = nil
         self.loginTask?.cancel()
         self.loginTask = nil
-        self.manualRefreshTask?.cancel()
-        self.manualRefreshTask = nil
-        self.manualRefreshProvider = nil
-        self.menuCardRefreshMonitor.endManualRefresh()
+        for task in self.manualRefreshTasks.values {
+            task.cancel()
+        }
+        self.manualRefreshTasks.removeAll()
+        self.menuCardRefreshMonitor.resetManualRefresh()
         self.screenChangeVisibilityTask?.cancel()
         self.screenChangeVisibilityTask = nil
         self.pendingScreenChangePreviousCount = nil

Sources/CodexBar/StatusItemController.swift

@@ -138,8 +138,10 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     var fallbackMenu: NSMenu?
     var openMenus: [ObjectIdentifier: NSMenu] = [:]
     var menuRefreshTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
-    var manualRefreshTask: Task<Void, Never>?
-    var manualRefreshProvider: UsageProvider?
+    /// Manual refreshes tracked per scope so refreshing one provider neither greys out nor blocks
+    /// a manual refresh of another. `.global` covers the all-providers refresh (⌘R / merged overview).
+    var manualRefreshTasks: [ManualRefreshScope: Task<Void, Never>] = [:]
+
     var closedMenuRebuildTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
     var closedMenuRebuildRequests = MenuRebuildRequestRegistry<ObjectIdentifier>()
     var openMenuRebuildTasks: [ObjectIdentifier: Task<Void, Never>] = [:]

Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift

@@ -185,7 +185,7 @@ extension StatusMenuTests {
             controller._test_manualRefreshOperation = nil
         }
         controller.refreshNow()
-        let task = try #require(controller.manualRefreshTask)
+        let task = try #require(controller.manualRefreshTasks[.global])
 
         controller.invalidateMenus()
         for _ in 0..<40 {

Tests/CodexBarTests/StatusMenuMergedOverviewRefreshTests.swift

@@ -42,8 +42,7 @@ struct StatusMenuMergedOverviewRefreshTests {
         }
 
         #expect(requestCount == 0)
-        #expect(controller.manualRefreshTask == nil)
-        #expect(controller.manualRefreshProvider == nil)
+        #expect(controller.manualRefreshTasks.isEmpty)
     }
 
     private func makeSettings() -> SettingsStore {