feat(menubar): show up to 3 quota rings again, with 5h/7d arc swap

Round 2 collapsed the menu bar to a single most-constrained ring per the
exposure experiment. Direct product feedback restores multi-provider
visibility: the menu bar now shows up to three visible providers ranked by
5-hour usage (most constrained first), each as a 21pt DualRing.

DualRing arcs are swapped from the old layout: OUTER now carries the 7-day
fraction (dimmer, 0.65 base opacity) and INNER carries the 5-hour fraction
(bright base, thickened when near-limit), so the urgent 5h signal sits at
the center of the glyph and stays the visually dominant one. 7-day is not
dropped — both windows remain visible per provider.

- AppDelegate.menuBarProviders: unconditional mostConstrained(count: 3)
- statusItemLength: restored pre-round-2 ring formula (26pt/ring, up to 3)
- QuotaStore.mostConstrained(in:count:) is now the production path
- QuotaStoreTests: keep the ranked-list tests for the production API
- Prototype widget-style toggle scaffolding removed entirely

Author: MisterBrookT

Sources/Kaji/AppDelegate.swift

@@ -261,14 +261,12 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         store.providers.filter { prefs.isVisible($0.id) }
     }
 
-    /// What the menubar actually draws: every visible ring on the legacy
-    /// rollback path, or exactly the single most-constrained provider in
-    /// treatment. Empty means no provider has data yet — StatusItemView then
-    /// falls back to its placeholder single ring.
+    /// What the menubar draws: up to three visible providers, most-constrained
+    /// first (5-hour used fraction). Restores multi-provider visibility that
+    /// round 2 collapsed to a single ring. Empty means no provider has data
+    /// yet — StatusItemView then falls back to its placeholder single ring.
     private var menuBarProviders: [ProviderView] {
-        guard !usesLegacyExposure else { return visibleProviders }
-        guard let leader = QuotaStore.mostConstrained(in: visibleProviders) else { return [] }
-        return [leader]
+        QuotaStore.mostConstrained(in: visibleProviders, count: 3)
     }
 
     func applicationWillTerminate(_ notification: Notification) {
@@ -385,8 +383,10 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     }
 
     private var statusItemLength: CGFloat {
-        let count = max(1, min(4, menuBarProviders.count))
-        var length = CGFloat(count) * 26 + 6
+        // 21pt ring + 5pt gap per visible ring (up to 3), + 6pt padding —
+        // the pre-round-2 multi-ring formula, restored.
+        let shown = max(1, min(3, menuBarProviders.count))
+        var length = CGFloat(shown) * 26 + 6
         // Compact monospaced `MM:SS` to the right of the rings (~40pt).
         if presentedWorkSlotLabel != nil {
             length += 40

Sources/Kaji/QuotaStore.swift

@@ -304,10 +304,20 @@ final class QuotaStore: ObservableObject {
     /// The provider closest to its limit among a given set.
     /// Providers without five-hour data are skipped; ties go to the earlier one.
     static func mostConstrained(in providers: [ProviderView]) -> ProviderView? {
-        providers.reduce(nil) { best, candidate in
-            guard let percent = candidate.fiveHourPercent else { return best }
-            guard let best, let bestPercent = best.fiveHourPercent else { return candidate }
-            return percent > bestPercent ? candidate : best
-        }
+        mostConstrained(in: providers, count: 1).first
+    }
+
+    /// This is what the menubar shows — up to three visible providers sorted
+    /// by 5-hour used percent descending (stable, so equal percents keep their
+    /// input order — "ties go to the earlier one"). Providers without five-hour
+    /// data are skipped; `count` merely caps the result, it never pads it.
+    static func mostConstrained(in providers: [ProviderView], count: Int) -> [ProviderView] {
+        let ranked = providers
+            .filter { $0.fiveHourPercent != nil }
+            .sorted {
+                guard let a = $0.fiveHourPercent, let b = $1.fiveHourPercent else { return false }
+                return a > b
+            }
+        return Array(ranked.prefix(max(0, count)))
     }
 }

Sources/Kaji/StatusItemView.swift

@@ -4,11 +4,12 @@ import KajiCore
 // MARK: - StatusItemView
 //
 // The compact menubar indicator: one concentric DOUBLE ring per visible
-// provider, side by side. Each glyph carries the provider's identity AND two
-// quota signals at once:
-//   - CENTER  = the provider mark.
-//   - OUTER arc = the 5-hour window.
-//   - INNER arc = the 7-day window.
+// provider, side by side — up to three, most-constrained first. Each glyph
+// carries the provider's identity AND two quota signals at once:
+//   - CENTER = the provider mark.
+//   - OUTER arc = the 7-day window (dimmer — supportive context).
+//   - INNER arc = the 5-hour window (bright, near-limit thickened — the
+//     actionable number).
 // The exact % lives in the popover (click the item); the arc length already
 // shows roughly how full each window is.
 //
@@ -169,8 +170,11 @@ private struct WorkStatusSlot: View {
 
 // MARK: - DualRing
 //
-// Two concentric trim arcs (outer 5h, inner 7d) around a center provider logo.
-// Sized for the menubar (~21pt).
+// Two concentric trim arcs around a center provider logo, sized for the
+// menubar (~21pt). OUTER = the 7-day window (dimmer — supportive context);
+// INNER = the 5-hour window (bright `base`, thickened when near-limit — the
+// actionable number). The 5-hour signal sits at the center of the glyph, so
+// the urgent number stays the visually dominant one.
 private struct DualRing: View {
     let provider: ProviderView?
     let showRemaining: Bool
@@ -183,7 +187,7 @@ private struct DualRing: View {
     private let gap: CGFloat = 1.3
 
     private var base: Color { scheme == .dark ? .white : .black }
-    private var innerColor: Color { base.opacity(0.65) }
+    private var weekColor: Color { base.opacity(0.65) }
     private var trackColor: Color { base.opacity(0.22) }
 
     private var fiveFraction: Double {
@@ -198,11 +202,13 @@ private struct DualRing: View {
 
     var body: some View {
         ZStack {
-            ring(inset: 0,
-                 lineWidth: nearLimit ? outerLW + 0.9 : outerLW,
+            // OUTER = 7-day arc: dimmer, normal width.
+            ring(inset: 0, lineWidth: outerLW,
+                 fraction: weekFraction, color: weekColor)
+            // INNER = 5-hour arc: bright, thickened when near-limit.
+            ring(inset: outerLW + gap,
+                 lineWidth: nearLimit ? innerLW + 0.9 : innerLW,
                  fraction: fiveFraction, color: base)
-            ring(inset: outerLW + gap, lineWidth: innerLW,
-                 fraction: weekFraction, color: innerColor)
             if let provider {
                 ProviderLogo(key: provider.id, color: base, size: 9)
             }

Tests/KajiTests/QuotaStoreTests.swift

@@ -41,13 +41,60 @@ final class QuotaStoreTests: XCTestCase {
         )
     }
 
-    func testMostConstrainedReturnsNilWithoutData() {
-        XCTAssertNil(QuotaStore.mostConstrained(in: []))
-        XCTAssertNil(
-            QuotaStore.mostConstrained(in: [
-                provider("codex", fiveHourPercent: nil),
-                provider("claude", fiveHourPercent: nil),
-            ])
+    // MARK: - mostConstrained(in:count:)
+
+    func testMostConstrainedCountReturnsRankedList() {
+        let providers = [
+            provider("claude", fiveHourPercent: 56),
+            provider("codex", fiveHourPercent: 82),
+            provider("ark", fiveHourPercent: nil),
+            provider("cursor", fiveHourPercent: 63),
+        ]
+        XCTAssertEqual(
+            QuotaStore.mostConstrained(in: providers, count: 2).map(\.id),
+            ["codex", "cursor"]
+        )
+        // `count` only caps the result — no-data providers are dropped, never padded.
+        XCTAssertEqual(
+            QuotaStore.mostConstrained(in: providers, count: 4).map(\.id),
+            ["codex", "cursor", "claude"]
+        )
+    }
+
+    func testMostConstrainedCountTieBreaksToEarlierProvider() {
+        let providers = [
+            provider("codex", fiveHourPercent: 70),
+            provider("claude", fiveHourPercent: 70),
+            provider("cursor", fiveHourPercent: 50),
+        ]
+        XCTAssertEqual(
+            QuotaStore.mostConstrained(in: providers, count: 2).map(\.id),
+            ["codex", "claude"]
+        )
+    }
+
+    func testMostConstrainedCountBoundsAndEmpty() {
+        let providers = [
+            provider("codex", fiveHourPercent: 82),
+            provider("claude", fiveHourPercent: 56),
+        ]
+        XCTAssertEqual(QuotaStore.mostConstrained(in: providers, count: 0), [])
+        XCTAssertEqual(QuotaStore.mostConstrained(in: [], count: 3), [])
+        XCTAssertEqual(
+            QuotaStore.mostConstrained(in: [provider("ark", fiveHourPercent: nil)], count: 3),
+            []
+        )
+    }
+
+    func testMostConstrainedCountOneMatchesLegacySingle() {
+        let providers = [
+            provider("claude", fiveHourPercent: 56),
+            provider("codex", fiveHourPercent: 82),
+            provider("ark", fiveHourPercent: nil),
+        ]
+        XCTAssertEqual(
+            QuotaStore.mostConstrained(in: providers, count: 1).first?.id,
+            QuotaStore.mostConstrained(in: providers)?.id
         )
     }
 }