feat: make OpenRouter color bar preview use standard resolver path

Previously the color-bar preview for OpenRouter read usedPercent directly
instead of going through IconRemainingResolver, which meant key-quota state
had no effect on the preview color. This change routes the preview through
the same resolvedPercents(_:style:showUsed:) call that the live icon uses.

- When no key limit is configured (noLimitConfigured) or key data is
  unavailable, resolvedPercents returns nil for primary, matching the live
  icon behavior and leaving the color bar unrendered
- When a key limit is set, the key-usage percent drives the preview as expected
- Adds tests covering the unavailable, no-limit, and key-quota cases, each
  verifying both the resolved percent and the menu-bar display text

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: willytop8

Sources/CodexBar/StatusItemController+Animation.swift

@@ -336,30 +336,6 @@ extension StatusItemController {
             return false
         }
 
-        if Self.shouldUseOpenRouterBrandFallback(provider: primaryProvider, snapshot: snapshot),
-           let brand = ProviderBrandIcon.image(for: primaryProvider)
-        {
-            let signature = [
-                "mode=openRouterFallback",
-                "provider=\(primaryProvider.rawValue)",
-                "style=\(String(describing: style))",
-                "primary=\(debugDouble(primary))",
-                "weekly=\(debugDouble(weekly))",
-                "credits=\(debugDouble(credits))",
-                "stale=\(stale ? "1" : "0")",
-                "status=\(statusIndicator.rawValue)",
-                "anim=\(needsAnimation ? "1" : "0")",
-            ].joined(separator: "|")
-            if self.shouldSkipMergedIconRender(signature) {
-                return true
-            }
-            self.setButtonTitle(nil, for: button)
-            self.setButtonImage(
-                Self.brandImageWithStatusOverlay(brand: brand, statusIndicator: statusIndicator),
-                for: button)
-            return false
-        }
-
         self.setButtonTitle(nil, for: button)
         if let morphProgress {
             let signature = [
@@ -440,17 +416,6 @@ extension StatusItemController {
             return
         }
 
-        if Self.shouldUseOpenRouterBrandFallback(provider: provider, snapshot: snapshot),
-           let brand = ProviderBrandIcon.image(for: provider)
-        {
-            self.setButtonTitle(nil, for: button)
-            self.setButtonImage(
-                Self.brandImageWithStatusOverlay(
-                    brand: brand,
-                    statusIndicator: self.store.statusIndicator(for: provider)),
-                for: button)
-            return
-        }
         let resolved = snapshot.map {
             IconRemainingResolver.resolvedPercents(
                 snapshot: $0,
@@ -775,18 +740,6 @@ extension StatusItemController {
         }
     }
 
-    nonisolated static func shouldUseOpenRouterBrandFallback(
-        provider: UsageProvider,
-        snapshot: UsageSnapshot?) -> Bool
-    {
-        guard provider == .openrouter,
-              let openRouterUsage = snapshot?.openRouterUsage
-        else {
-            return false
-        }
-        return openRouterUsage.keyQuotaStatus == .noLimitConfigured
-    }
-
     nonisolated static func brandImageWithStatusOverlay(
         brand: NSImage,
         statusIndicator: ProviderStatusIndicator) -> NSImage

Tests/CodexBarTests/ProvidersPaneCoverageTests.swift

@@ -171,6 +171,30 @@ struct ProvidersPaneCoverageTests {
         #expect(row?.value == "$4.61")
     }
 
+    @Test
+    func `open router provider pane shows balance and no quota metric when key limit is not configured`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-openrouter-no-key-limit")
+        let store = Self.makeUsageStore(settings: settings)
+        let snapshot = OpenRouterUsageSnapshot(
+            totalCredits: 50,
+            totalUsage: 45,
+            balance: 5, // balance = totalCredits - totalUsage
+            usedPercent: 90,
+            keyDataFetched: true,
+            keyLimit: nil,
+            keyUsage: nil,
+            rateLimit: nil,
+            updatedAt: Date()).toUsageSnapshot()
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let model = pane._test_menuCardModel(for: .openrouter)
+
+        #expect(model.planText == "Balance: $5.00")
+        #expect(model.metrics.isEmpty)
+        #expect(model.usageNotes == ["No limit set for the API key"])
+    }
+
     @Test
     func `provider detail plan row keeps plan label for non open router`() {
         let row = ProviderDetailView<EmptyView>.planRow(provider: .codex, planText: "Pro")

Tests/CodexBarTests/StatusItemControllerMenuTests.swift

@@ -97,44 +97,52 @@ struct StatusItemControllerMenuTests {
     }
 
     @Test
-    func `open router brand fallback enabled when no key limit configured`() {
+    func `open router key data unavailable uses color bar path with nil primary percent`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45,
             balance: 5,
             usedPercent: 90,
-            keyDataFetched: true,
+            keyDataFetched: false,
             keyLimit: nil,
             keyUsage: nil,
             rateLimit: nil,
             updatedAt: Date()).toUsageSnapshot()
 
-        #expect(StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
+        #expect(snapshot.openRouterUsage?.keyQuotaStatus == .unavailable)
+        let resolved = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .openrouter,
+            showUsed: false)
+        #expect(resolved.primary == nil)
+        #expect(resolved.secondary == nil)
         #expect(MenuBarDisplayText.percentText(window: snapshot.primary, showUsed: false) == nil)
     }
 
     @Test
-    func `open router brand fallback disabled when key quota fetch unavailable`() {
+    func `open router no key limit uses color bar path with nil primary percent`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45,
             balance: 5,
             usedPercent: 90,
-            keyDataFetched: false,
+            keyDataFetched: true,
             keyLimit: nil,
             keyUsage: nil,
             rateLimit: nil,
             updatedAt: Date()).toUsageSnapshot()
 
-        #expect(!StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
+        let resolved = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .openrouter,
+            showUsed: false)
+        #expect(resolved.primary == nil)
+        #expect(resolved.secondary == nil)
+        #expect(MenuBarDisplayText.percentText(window: snapshot.primary, showUsed: false) == nil)
     }
 
     @Test
-    func `open router brand fallback disabled when key quota available`() {
+    func `open router key quota uses color bar path with primary percent`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45,
@@ -145,10 +153,13 @@ struct StatusItemControllerMenuTests {
             rateLimit: nil,
             updatedAt: Date()).toUsageSnapshot()
 
-        #expect(!StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
         #expect(snapshot.primary?.usedPercent == 10)
+        let resolved = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .openrouter,
+            showUsed: false)
+        #expect(resolved.primary == 90)
+        #expect(resolved.secondary == nil)
     }
 
     @Test