Discard stale refresh completions after account changes (#146)

* Discard stale refresh completions

* Address automated review feedback

* Make refresh synchronization rollback safe

* Invalidate credentials before refresh tasks

* Invalidate account changes before refresh tasks

* Refresh account scheduling after OpenCode edits

Author: HemSoft

CHANGELOG.md

@@ -43,6 +43,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Fixed
 
+- Refreshes that finish after an account is removed, disabled, or given new
+  credentials or routing settings no longer restore stale usage, errors,
+  history, or alerts.
 - Browser sign-in now ignores malformed, stale, and unrelated local callback
   requests until the expected ChatGPT, Claude, or GitHub Copilot redirect arrives.
 - ChatGPT, Claude, GitHub Copilot, and Cursor browser sign-in now stops safely
@@ -113,8 +116,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Developer Experience
 
+- Gated provider test doubles now suspend in-flight refreshes deterministically,
+  covering batch and single-account completions after account changes.
 - The Mac XCTest suite is split into domain-focused test classes with narrowly
-  scoped shared support, preserving the existing 344-test regression inventory.
+  scoped shared support, preserving the existing 347-test regression inventory.
 - Deterministic loopback OAuth tests now execute ChatGPT, Claude, and GitHub
   Copilot token exchanges through success, malformed, missing-token, and
   sanitized provider-error responses without opening a browser or using live credentials.

CodexBarMac/AppModel.swift

@@ -31,6 +31,9 @@ final class AppModel: ObservableObject {
         self.isAwaitingConfigurationRecoveryCompletion =
             configurationStore.isConfigurationRecoveryCompletionPending
         configurationStore.seedDefaultConfigurationsIfNeeded()
+        if !configurationStore.isConfigurationRecoveryRequired {
+            refreshService.updateCurrentConfigurations(configurationStore.configurations)
+        }
 
         refreshService.objectWillChange
             .sink { [weak self] _ in
@@ -175,15 +178,26 @@ final class AppModel: ObservableObject {
         await refresh()
     }
 
-    func discoverLocalCredentials() async {
+    @discardableResult
+    func discoverLocalCredentials() async -> Bool {
+        let previousConfigurations = configurationStore.enabledConfigurations
         let discovery = await Task.detached(priority: .utility) {
             LocalCredentialDiscovery.discover()
         }.value
 
         configurationStore.applyLocalCredentialDiscoveries(discovery)
+        let didChangeRefreshInputs = refreshInputsChanged(
+            from: previousConfigurations,
+            to: configurationStore.enabledConfigurations
+        )
+        if didChangeRefreshInputs {
+            invalidateAccounts()
+        }
+        return didChangeRefreshInputs
     }
 
     func refresh() async {
+        refreshService.updateCurrentConfigurations(configurationStore.configurations)
         if refreshService.isRefreshing {
             pendingRefresh = true
             return
@@ -238,11 +252,24 @@ final class AppModel: ObservableObject {
         )
     }
 
-    func handleAccountsChanged() async {
+    func invalidateAccounts() {
+        refreshService.updateCurrentConfigurations(configurationStore.configurations)
+    }
+
+    func refreshAfterAccountChange() async {
         updateAutoRefresh()
         await refresh()
     }
 
+    func refreshAfterCredentialChange() async {
+        await refresh()
+    }
+
+    func invalidateCredential(forAccountID accountID: String) {
+        refreshService.updateCurrentConfigurations(configurationStore.configurations)
+        refreshService.invalidateCredential(forAccountID: accountID)
+    }
+
     func completeConfigurationRecoveryIfPossible() {
         guard isAwaitingConfigurationRecoveryCompletion,
               configurationStore.completeConfigurationRecovery()
@@ -251,13 +278,32 @@ final class AppModel: ObservableObject {
         }
 
         isAwaitingConfigurationRecoveryCompletion = false
+        refreshService.updateCurrentConfigurations(configurationStore.configurations)
         historyStore.removeSnapshotsForMissingAccounts(
             validAccountIDs: Set(configurationStore.configurations.map(\.id))
         )
     }
 
     func refreshAccount(_ configuration: ProviderAccountConfiguration) async -> ProviderUsageResult? {
-        await refreshService.refresh(configuration: configuration)
+        refreshService.updateCurrentConfigurations(configurationStore.configurations)
+        guard
+            let currentConfiguration = configurationStore.configuration(accountID: configuration.id),
+            currentConfiguration.isEnabled,
+            refreshService.hasSameRefreshInputs(configuration, currentConfiguration)
+        else {
+            return nil
+        }
+        guard let result = await refreshService.refresh(configuration: currentConfiguration) else {
+            return nil
+        }
+
+        lastRefreshedAt = Date()
+        recordUsageHistory()
+        await processUsageAlerts(
+            results: alertEligibleResults(),
+            preserving: refreshService.incompleteRefreshAccountIDs
+        )
+        return result
     }
 
     func quit() {
@@ -277,6 +323,34 @@ final class AppModel: ObservableObject {
         historyStore.record(results: alertEligibleResults())
     }
 
+    private func refreshInputsChanged(
+        from previousConfigurations: [ProviderAccountConfiguration],
+        to currentConfigurations: [ProviderAccountConfiguration]
+    ) -> Bool {
+        let previousByID = previousConfigurations.reduce(
+            into: [String: ProviderAccountConfiguration]()
+        ) { configurationsByID, configuration in
+            configurationsByID[configuration.id] = configuration
+        }
+        let currentByID = currentConfigurations.reduce(
+            into: [String: ProviderAccountConfiguration]()
+        ) { configurationsByID, configuration in
+            configurationsByID[configuration.id] = configuration
+        }
+        guard previousByID.keys == currentByID.keys else {
+            return true
+        }
+        return previousByID.contains { accountID, previousConfiguration in
+            guard let currentConfiguration = currentByID[accountID] else {
+                return true
+            }
+            return !refreshService.hasSameRefreshInputs(
+                previousConfiguration,
+                currentConfiguration
+            )
+        }
+    }
+
     private func processUsageAlerts(
         results: [ProviderUsageResult],
         preserving preservedAccountIDs: Set<String>