fix: remove stale split status items

Author: steipete

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 - Menu: keep the status menu open when manually refreshing usage from the menu (#845). Thanks @OlimjonovOtabek!
+- Menu bar: remove stale split provider status items instead of hiding them, avoiding leftover second-icon slots on macOS 26.4.
 - Augment: report the real 1-minute keepalive check/min-refresh intervals in startup logs and docs (#434). Thanks @guglielmofonda!
 
 ## 0.24 — 2026-05-06

Sources/CodexBar/IconRemainingResolver.swift

@@ -0,0 +1,91 @@
+import CodexBarCore
+
+enum IconRemainingResolver {
+    private static func codexProjection(snapshot: UsageSnapshot) -> CodexConsumerProjection {
+        CodexConsumerProjection.make(
+            surface: .menuBar,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: snapshot.updatedAt))
+    }
+
+    private static func codexVisibleWindows(snapshot: UsageSnapshot) -> [RateWindow] {
+        let projection = self.codexProjection(snapshot: snapshot)
+        return projection.visibleRateLanes.compactMap { projection.rateWindow(for: $0) }
+    }
+
+    static func resolvedWindows(
+        snapshot: UsageSnapshot,
+        style: IconStyle)
+        -> (primary: RateWindow?, secondary: RateWindow?)
+    {
+        if style == .perplexity {
+            let windows = snapshot.orderedPerplexityDisplayWindows()
+            return (
+                primary: windows.first,
+                secondary: windows.dropFirst().first)
+        }
+        if style == .antigravity {
+            let windows = [snapshot.primary, snapshot.secondary, snapshot.tertiary].compactMap(\.self)
+            return (
+                primary: windows.first,
+                secondary: windows.dropFirst().first)
+        }
+        if style == .codex {
+            let windows = self.codexVisibleWindows(snapshot: snapshot)
+            return (
+                primary: windows.first,
+                secondary: windows.dropFirst().first)
+        }
+        return (
+            primary: snapshot.primary,
+            secondary: snapshot.secondary)
+    }
+
+    static func resolvedRemaining(
+        snapshot: UsageSnapshot,
+        style: IconStyle)
+        -> (primary: Double?, secondary: Double?)
+    {
+        if style == .perplexity {
+            let windows = snapshot.orderedPerplexityDisplayWindows()
+            return (
+                primary: windows.first?.remainingPercent,
+                secondary: windows.dropFirst().first?.remainingPercent)
+        }
+        if style == .antigravity {
+            let windows = [snapshot.primary, snapshot.secondary, snapshot.tertiary].compactMap(\.self)
+            return (
+                primary: windows.first?.remainingPercent,
+                secondary: windows.dropFirst().first?.remainingPercent)
+        }
+        if style == .codex {
+            let windows = self.codexVisibleWindows(snapshot: snapshot)
+            return (
+                primary: windows.first?.remainingPercent,
+                secondary: windows.dropFirst().first?.remainingPercent)
+        }
+        return (
+            primary: snapshot.primary?.remainingPercent,
+            secondary: snapshot.secondary?.remainingPercent)
+    }
+
+    static func resolvedPercents(
+        snapshot: UsageSnapshot,
+        style: IconStyle,
+        showUsed: Bool)
+        -> (primary: Double?, secondary: Double?)
+    {
+        let windows = Self.resolvedWindows(snapshot: snapshot, style: style)
+        return (
+            primary: showUsed ? windows.primary?.usedPercent : windows.primary?.remainingPercent,
+            secondary: showUsed ? windows.secondary?.usedPercent : windows.secondary?.remainingPercent)
+    }
+}

Sources/CodexBar/IconView.swift

@@ -2,7 +2,6 @@ import AppKit
 import CodexBarCore
 import Observation
 import QuartzCore
-import SwiftUI
 
 // MARK: - Status item controller (AppKit-hosted icons, SwiftUI popovers)
 
@@ -531,8 +530,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         let mergeIcons = self.shouldMergeIcons
         if mergeIcons {
             self.statusItem.isVisible = anyEnabled || force
-            for item in self.statusItems.values {
-                item.isVisible = false
+            for provider in Array(self.statusItems.keys) {
+                self.removeProviderStatusItem(for: provider)
             }
             self.attachMenus()
         } else {
@@ -544,8 +543,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
                 if shouldBeVisible {
                     let item = self.lazyStatusItem(for: provider)
                     item.isVisible = true
-                } else if let item = self.statusItems[provider] {
-                    item.isVisible = false
+                } else {
+                    self.removeProviderStatusItem(for: provider)
                 }
             }
             self.attachMenus(fallback: fallback)
@@ -610,10 +609,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
                     }
                 }
             } else if let item = self.statusItems[provider] {
-                // Item exists but is no longer needed - clear its menu
-                if item.menu != nil {
-                    item.menu = nil
-                }
+                item.menu = nil
             }
         }
     }
@@ -625,16 +621,31 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         let ordered = self.settings.orderedProviders()
         let desired = Set(ordered)
         for provider in Array(self.statusItems.keys) where !desired.contains(provider) {
-            if let item = self.statusItems.removeValue(forKey: provider) {
-                self.statusBar.removeStatusItem(item)
-            }
+            self.removeProviderStatusItem(for: provider)
         }
 
-        for provider in ordered {
+        guard !self.shouldMergeIcons else { return }
+        let fallback = self.fallbackProvider
+        let force = self.store.debugForceAnimation
+        for provider in ordered where self.isEnabled(provider) || fallback == provider || force {
             _ = self.lazyStatusItem(for: provider)
         }
     }
 
+    private func removeProviderStatusItem(for provider: UsageProvider) {
+        if let menu = self.providerMenus.removeValue(forKey: provider) {
+            let menuID = ObjectIdentifier(menu)
+            self.menuProviders.removeValue(forKey: menuID)
+            self.menuVersions.removeValue(forKey: menuID)
+            self.openMenus.removeValue(forKey: menuID)
+            self.menuRefreshTasks.removeValue(forKey: menuID)?.cancel()
+        }
+
+        guard let item = self.statusItems.removeValue(forKey: provider) else { return }
+        item.menu = nil
+        self.statusBar.removeStatusItem(item)
+    }
+
     func isVisible(_ provider: UsageProvider) -> Bool {
         self.store.debugForceAnimation || self.isEnabled(provider) || self.fallbackProvider == provider
     }