Address review: filter persisted scoped rows on fallback, default setting off

Author: Alfred

Sources/CodexBar/SettingsStore.swift

@@ -507,12 +507,9 @@ extension SettingsStore {
         if Self.isRunningTests, claudeDailyRoutinesUsageVisibleDefault == nil {
             userDefaults.set(true, forKey: "claudeDailyRoutinesUsageVisible")
         }
-        let claudeModelScopedWeeklyUsageVisibleDefault = userDefaults.object(
-            forKey: "claudeModelScopedWeeklyUsageVisible") as? Bool
-        let claudeModelScopedWeeklyUsageVisible = claudeModelScopedWeeklyUsageVisibleDefault ?? true
-        if Self.isRunningTests, claudeModelScopedWeeklyUsageVisibleDefault == nil {
-            userDefaults.set(true, forKey: "claudeModelScopedWeeklyUsageVisible")
-        }
+        // Model-scoped weekly rows are opt-in: a fresh install keeps widgets on the standard quota lanes.
+        let claudeModelScopedWeeklyUsageVisible = userDefaults.object(
+            forKey: "claudeModelScopedWeeklyUsageVisible") as? Bool ?? false
         let codexSparkUsageVisibleDefault = userDefaults.object(forKey: "codexSparkUsageVisible") as? Bool
         let codexSparkUsageVisible = codexSparkUsageVisibleDefault ?? true
         if Self.isRunningTests, codexSparkUsageVisibleDefault == nil {

Sources/CodexBar/UsageStore+WidgetSnapshot.swift

@@ -206,7 +206,8 @@ extension UsageStore {
         {
             Self.preservedClaudeWidgetUsage(
                 from: previousEntry,
-                expectedQuotaOwnerKey: claudeQuotaOwnerKey)
+                expectedQuotaOwnerKey: claudeQuotaOwnerKey,
+                includesModelScopedWeeklyRows: self.settings.claudeModelScopedWeeklyUsageVisible)
         } else {
             nil
         }
@@ -294,7 +295,8 @@ extension UsageStore {
 
     private nonisolated static func preservedClaudeWidgetUsage(
         from entry: WidgetSnapshot.ProviderEntry?,
-        expectedQuotaOwnerKey: String?) -> PreservedClaudeWidgetUsage?
+        expectedQuotaOwnerKey: String?,
+        includesModelScopedWeeklyRows: Bool) -> PreservedClaudeWidgetUsage?
     {
         guard let entry, entry.provider == .claude else { return nil }
         guard let expectedQuotaOwnerKey,
@@ -309,6 +311,13 @@ extension UsageStore {
         let tertiary = entry.tertiary?.isSyntheticPlaceholder == true ? nil : entry.tertiary
         let usageRows = entry.usageRows?.filter { row in
             guard row.window?.isSyntheticPlaceholder != true else { return false }
+            // Rows persisted while the setting was on must not outlive it: without a live snapshot
+            // this preserved list is what widgets render, so re-apply the visibility filter here.
+            guard includesModelScopedWeeklyRows ||
+                !row.id.hasPrefix(Self.claudeModelScopedWeeklyWindowIDPrefix)
+            else {
+                return false
+            }
             return switch row.id {
             case "primary": primary != nil
             case "secondary": secondary != nil
@@ -471,7 +480,9 @@ extension UsageStore {
             // Claude fetchers place model-scoped weekly quotas (for example, Fable) in extraRateWindows.
             // Keep the widget projection generic so newly surfaced Claude model quotas appear without UI changes.
             rows.append(contentsOf: (snapshot.extraRateWindows ?? []).compactMap { namedWindow in
-                guard namedWindow.id.hasPrefix("claude-weekly-scoped-"), namedWindow.usageKnown else { return nil }
+                guard namedWindow.id.hasPrefix(Self.claudeModelScopedWeeklyWindowIDPrefix),
+                      namedWindow.usageKnown
+                else { return nil }
                 return WidgetSnapshot.WidgetUsageRowSnapshot(
                     id: namedWindow.id,
                     title: namedWindow.title,
@@ -494,6 +505,9 @@ extension UsageStore {
         return rows.filter { $0.percentLeft != nil }
     }
 
+    /// Identifier prefix Claude fetchers use for model-scoped weekly carve-outs (for example, Fable).
+    private nonisolated static let claudeModelScopedWeeklyWindowIDPrefix = "claude-weekly-scoped-"
+
     private nonisolated static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
     private nonisolated static let antigravityCompactFallbackWindowIDPrefix = "antigravity-compact-fallback-"
 

Tests/CodexBarTests/ClaudeScopedWeeklySettingsTests.swift

@@ -0,0 +1,59 @@
+import CodexBarCore
+import Foundation
+import Observation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct ClaudeScopedWeeklySettingsTests {
+    private final class ObservationFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = false
+
+        func set() {
+            self.lock.lock()
+            self.value = true
+            self.lock.unlock()
+        }
+
+        func get() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
+    @Test
+    func `Claude model scoped widget usage defaults off persists and refreshes only menus`() async throws {
+        let suite = "ClaudeScopedWeeklySettingsTests-claude-model-scoped-widget-usage-visible"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.claudeModelScopedWeeklyUsageVisible == false)
+        let backgroundRevision = store.backgroundWorkSettingsRevision
+        let menuDidChange = ObservationFlag()
+        withObservationTracking {
+            _ = store.menuObservationToken
+        } onChange: {
+            menuDidChange.set()
+        }
+        store.claudeModelScopedWeeklyUsageVisible = true
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(store.backgroundWorkSettingsRevision == backgroundRevision)
+        #expect(menuDidChange.get())
+
+        let reloaded = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        #expect(reloaded.claudeModelScopedWeeklyUsageVisible)
+    }
+}

Tests/CodexBarTests/ClaudeScopedWeeklyWidgetRowTests.swift

@@ -0,0 +1,35 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+@testable import CodexBarWidget
+
+struct ClaudeScopedWeeklyWidgetRowTests {
+    @Test
+    func `Claude widget renders projected model scoped weekly rows`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .claude,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "primary", title: "Session", percentLeft: 75),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "secondary", title: "Weekly", percentLeft: 50),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "claude-weekly-scoped-fable",
+                    title: "Fable only",
+                    percentLeft: 70),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        #expect(WidgetUsageRow.smallWidgetRowLimit(for: entry) == nil)
+        #expect(WidgetUsageRow.rows(for: entry).map(\.id) == [
+            "primary",
+            "secondary",
+            "claude-weekly-scoped-fable",
+        ])
+    }
+}

Tests/CodexBarTests/CodexBarWidgetProviderTests.swift

@@ -567,35 +567,6 @@ struct CodexBarWidgetProviderTests {
         #expect(rows == [WidgetUsageRow(id: "weekly", title: "Weekly", percentLeft: 75)])
     }
 
-    @Test
-    func `Claude widget renders projected model scoped weekly rows`() {
-        let entry = WidgetSnapshot.ProviderEntry(
-            provider: .claude,
-            updatedAt: Date(),
-            primary: nil,
-            secondary: nil,
-            tertiary: nil,
-            usageRows: [
-                WidgetSnapshot.WidgetUsageRowSnapshot(id: "primary", title: "Session", percentLeft: 75),
-                WidgetSnapshot.WidgetUsageRowSnapshot(id: "secondary", title: "Weekly", percentLeft: 50),
-                WidgetSnapshot.WidgetUsageRowSnapshot(
-                    id: "claude-weekly-scoped-fable",
-                    title: "Fable only",
-                    percentLeft: 70),
-            ],
-            creditsRemaining: nil,
-            codeReviewRemainingPercent: nil,
-            tokenUsage: nil,
-            dailyUsage: [])
-
-        #expect(WidgetUsageRow.smallWidgetRowLimit(for: entry) == nil)
-        #expect(WidgetUsageRow.rows(for: entry).map(\.id) == [
-            "primary",
-            "secondary",
-            "claude-weekly-scoped-fable",
-        ])
-    }
-
     @Test
     func `codex widget session cap lifts at weekly reset without a new snapshot`() {
         let now = Date(timeIntervalSince1970: 1_800_000_000)

Tests/CodexBarTests/ProviderSettingsDescriptorTests.swift

@@ -345,20 +345,20 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func `claude model scoped widget usage toggle is default on and independent`() throws {
+    func `claude model scoped widget usage toggle is default off and independent`() throws {
         let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-claude-model-scoped-widget")
         let context = fixture.settingsContext(provider: .claude)
         let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
         let widgetToggle = try #require(toggles.first {
             $0.id == "claude-model-scoped-weekly-usage-visible"
         })
 
-        #expect(widgetToggle.binding.wrappedValue)
+        #expect(widgetToggle.binding.wrappedValue == false)
         #expect(widgetToggle.isEnabled == nil)
         #expect(widgetToggle.subtitle.contains("Fable"))
 
-        widgetToggle.binding.wrappedValue = false
-        #expect(fixture.settings.claudeModelScopedWeeklyUsageVisible == false)
+        widgetToggle.binding.wrappedValue = true
+        #expect(fixture.settings.claudeModelScopedWeeklyUsageVisible)
 
         fixture.settings.showOptionalCreditsAndExtraUsage = false
         #expect(widgetToggle.isEnabled == nil)

Tests/CodexBarTests/SettingsStoreTests.swift

@@ -1363,39 +1363,6 @@ struct SettingsStoreTests {
         #expect(reloaded.codexSparkUsageVisible == false)
     }
 
-    @Test
-    func `Claude model scoped widget usage defaults on persists and refreshes only menus`() async throws {
-        let suite = "SettingsStoreTests-claude-model-scoped-widget-usage-visible"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let store = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-
-        #expect(store.claudeModelScopedWeeklyUsageVisible)
-        let backgroundRevision = store.backgroundWorkSettingsRevision
-        let menuDidChange = ObservationFlag()
-        withObservationTracking {
-            _ = store.menuObservationToken
-        } onChange: {
-            menuDidChange.set()
-        }
-        store.claudeModelScopedWeeklyUsageVisible = false
-        try? await Task.sleep(nanoseconds: 50_000_000)
-        #expect(store.backgroundWorkSettingsRevision == backgroundRevision)
-        #expect(menuDidChange.get())
-
-        let reloaded = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        #expect(reloaded.claudeModelScopedWeeklyUsageVisible == false)
-    }
-
     @Test
     func `menu observation token updates on defaults change`() async throws {
         let suite = "SettingsStoreTests-observation-defaults"

Tests/CodexBarTests/UsageStoreWidgetSnapshotTests.swift

@@ -122,7 +122,7 @@ struct UsageStoreWidgetSnapshotTests {
     }
 
     @Test
-    func `widget snapshot includes known Claude model scoped weekly quotas by default`() async throws {
+    func `widget snapshot includes known Claude model scoped weekly quotas only when enabled`() async throws {
         let suite = "UsageStoreWidgetSnapshotTests-claude-model-scoped-weekly-rows"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -164,6 +164,15 @@ struct UsageStoreWidgetSnapshotTests {
         store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
         defer { store._test_widgetSnapshotSaveOverride = nil }
 
+        // The setting is opt-in, so untouched defaults must project the standard quota lanes only.
+        #expect(settings.claudeModelScopedWeeklyUsageVisible == false)
+        store.persistWidgetSnapshot(reason: "claude-model-scoped-weekly-rows-default-test")
+        await store.widgetSnapshotPersistTask?.value
+
+        let defaultEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .claude })
+        #expect(defaultEntry.usageRows?.map(\.id) == ["primary", "secondary"])
+
+        settings.claudeModelScopedWeeklyUsageVisible = true
         store.persistWidgetSnapshot(reason: "claude-model-scoped-weekly-rows-test")
         await store.widgetSnapshotPersistTask?.value
 
@@ -180,6 +189,94 @@ struct UsageStoreWidgetSnapshotTests {
         #expect(hiddenEntry.usageRows?.map(\.id) == ["primary", "secondary"])
     }
 
+    @Test
+    func `widget snapshot drops persisted Claude model scoped weekly rows once the setting is off`() async throws {
+        let suite = "UsageStoreWidgetSnapshotTests-claude-model-scoped-weekly-fallback"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.claudeModelScopedWeeklyUsageVisible = true
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 25, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 50, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                tertiary: nil,
+                extraRateWindows: [
+                    NamedRateWindow(
+                        id: "claude-weekly-scoped-fable",
+                        title: "Fable only",
+                        window: RateWindow(
+                            usedPercent: 30,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                ],
+                updatedAt: updatedAt),
+            provider: .claude)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "claude-model-scoped-weekly-fallback-seed")
+        await store.widgetSnapshotPersistTask?.value
+
+        let seededEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .claude })
+        #expect(seededEntry.usageRows?.map(\.id) == ["primary", "secondary", "claude-weekly-scoped-fable"])
+        let quotaOwnerKey = try #require(seededEntry.quotaOwnerKey)
+
+        // No live Claude snapshot: the projection now falls back to the persisted rows above.
+        store.snapshots.removeValue(forKey: .claude)
+        settings.claudeModelScopedWeeklyUsageVisible = false
+        store.persistWidgetSnapshot(reason: "claude-model-scoped-weekly-fallback-disabled")
+        await store.widgetSnapshotPersistTask?.value
+
+        let fallbackEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .claude })
+        #expect(fallbackEntry.usageRows?.map(\.id) == ["primary", "secondary"])
+        #expect(fallbackEntry.usageRows?.contains { $0.id.hasPrefix("claude-weekly-scoped-") } == false)
+
+        // A persisted entry whose only rows are scoped carve-outs drops out of the projection entirely.
+        store.lastQueuedWidgetSnapshot = WidgetSnapshot(
+            entries: [
+                WidgetSnapshot.ProviderEntry(
+                    provider: .claude,
+                    updatedAt: updatedAt,
+                    primary: nil,
+                    secondary: nil,
+                    tertiary: nil,
+                    usageRows: [
+                        WidgetSnapshot.WidgetUsageRowSnapshot(
+                            id: "claude-weekly-scoped-fable",
+                            title: "Fable only",
+                            percentLeft: 70),
+                    ],
+                    creditsRemaining: nil,
+                    codeReviewRemainingPercent: nil,
+                    tokenUsage: nil,
+                    dailyUsage: [],
+                    quotaOwnerKey: quotaOwnerKey),
+            ],
+            enabledProviders: [.claude],
+            generatedAt: updatedAt)
+
+        store.persistWidgetSnapshot(reason: "claude-model-scoped-weekly-fallback-scoped-only")
+        await store.widgetSnapshotPersistTask?.value
+
+        #expect(widgetSnapshots.last?.entries.contains { $0.provider == .claude } == false)
+    }
+
     @Test
     func `widget snapshot includes antigravity grouped usage rows`() async throws {
         let suite = "UsageStoreWidgetSnapshotTests-antigravity-grouped"