perf(spend): parallelize loads and memoize model build

Scripts/lint.sh

@@ -139,7 +139,7 @@ run_swiftformat_lint() {
 
 run_swiftlint() {
   ensure_swiftlint
-  "${BIN_DIR}/swiftlint" --strict
+  "${BIN_DIR}/swiftlint" --strict --no-cache
 }
 
 collect_javascript_files() {

Sources/CodexBar/SpendDashboardModel.swift

@@ -305,20 +305,30 @@ struct SpendDashboardModel: Equatable, Sendable {
             inputs,
             hiddenSourceIDs: hiddenSourceIDs,
             hideNativeCodexWhenOpenCodexPresent: hideNativeCodexWhenOpenCodexPresent)
+        var conversionCache: [String: Double?] = [:]
         let classifiedInputs = visibleInputs.compactMap { input -> ClassifiedInput? in
             guard let sourceCurrencyCode = Self.currencyCode(input.snapshot.currencyCode) else { return nil }
             let targetCurrencyCode = UsageFormatter.effectiveCurrencyCode(
                 preferred: preferredCurrencyCode,
                 providerCurrency: sourceCurrencyCode)
-            let conversion = CurrencyExchange.shared.convert(
-                amount: 1,
-                from: sourceCurrencyCode,
-                to: targetCurrencyCode)
+            let cacheKey = "\(sourceCurrencyCode)->\(targetCurrencyCode)"
+            let conversion: Double?
+            if let cached = conversionCache[cacheKey] {
+                conversion = cached
+            } else {
+                let value = CurrencyExchange.shared.convert(
+                    amount: 1,
+                    from: sourceCurrencyCode,
+                    to: targetCurrencyCode)
+                conversionCache[cacheKey] = value
+                conversion = value
+            }
             return ClassifiedInput(
                 currencyCode: conversion == nil ? sourceCurrencyCode : targetCurrencyCode,
                 input: input,
                 costMultiplier: conversion ?? 1)
         }
+        let bounds = Self.bounds(days: days, now: now, calendar: calculationCalendar)
         let groups = Dictionary(grouping: classifiedInputs, by: { $0.currencyCode })
             .map { currencyCode, inputs in
                 Self.buildCurrencyGroup(
@@ -327,6 +337,7 @@ struct SpendDashboardModel: Equatable, Sendable {
                     days: days,
                     now: now,
                     calendar: calculationCalendar,
+                    bounds: bounds,
                     selectedDay: selectedDay.map { calculationCalendar.startOfDay(for: $0) })
             }
             .sorted { $0.currencyCode < $1.currencyCode }
@@ -426,9 +437,10 @@ struct SpendDashboardModel: Equatable, Sendable {
         days: Int,
         now: Date,
         calendar: Calendar,
+        bounds: ClosedRange<Date>? = nil,
         selectedDay: Date?) -> CurrencyGroup
     {
-        let bounds = Self.bounds(days: days, now: now, calendar: calendar)
+        let bounds = bounds ?? Self.bounds(days: days, now: now, calendar: calendar)
         let summaries = inputs.map { classified in
             Self.inputSummary(
                 input: classified.input,
@@ -983,6 +995,12 @@ struct SpendDashboardModel: Equatable, Sendable {
         return start...end
     }
 
+    private static let utcCalendar: Calendar = {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .gmt
+        return calendar
+    }()
+
     private static func gregorianCalendar(timeZone: TimeZone) -> Calendar {
         var calendar = Calendar(identifier: .gregorian)
         calendar.timeZone = timeZone
@@ -1067,10 +1085,11 @@ struct SpendDashboardModel: Equatable, Sendable {
     }
 
     private static func bucketCalendar(for provider: UsageProvider, displayCalendar: Calendar) -> Calendar {
+        // Provider-specific by design: mistral openrouter xai display calendar
         guard provider == .mistral || provider == .openrouter || provider == .xai else { return displayCalendar }
         // Mistral, OpenRouter, and xAI label daily buckets and snapshot coverage by UTC day. Map each UTC boundary into
         // the containing local dashboard day instead of reinterpreting the label as a local date.
-        return self.gregorianCalendar(timeZone: TimeZone(secondsFromGMT: 0) ?? .gmt)
+        return self.utcCalendar
     }
 
     private static func currencyCode(_ rawValue: String) -> String? {

Sources/CodexBar/UsageStore+SpendDashboardPublication.swift

@@ -45,6 +45,10 @@ extension UsageStore {
 
     func stopSharedSpendDashboardPublication() {
         self.sharedSpendDashboardObservationStarted = false
+        self.sharedSpendDashboardObservationDebounceTask?.cancel()
+        self.sharedSpendDashboardObservationDebounceTask = nil
+        self.sharedSpendDashboardTokenPublicationDebounceTask?.cancel()
+        self.sharedSpendDashboardTokenPublicationDebounceTask = nil
         self.sharedSpendDashboardControllerStorage?.stop()
         self.cancelSpendDashboardCodexCostCatchUp()
     }
@@ -55,17 +59,45 @@ extension UsageStore {
             SpendDashboardSource.configuration(settings: self.settings, store: self)
         } onChange: { [weak self] in
             Task { @MainActor [weak self] in
-                self?.observeSharedSpendDashboardConfiguration()
+                self?.scheduleDebouncedSharedSpendDashboardObservation()
             }
         }
         self.applySharedSpendDashboardConfiguration(configuration)
     }
 
+    private func scheduleDebouncedSharedSpendDashboardObservation() {
+        self.sharedSpendDashboardObservationDebounceTask?.cancel()
+        let delay: Duration = self.startupBehavior.automaticallyStartsBackgroundWork
+            ? .milliseconds(250) : .milliseconds(0)
+        self.sharedSpendDashboardObservationDebounceTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: delay)
+            guard !Task.isCancelled else { return }
+            self?.sharedSpendDashboardObservationDebounceTask = nil
+            self?.observeSharedSpendDashboardConfiguration()
+        }
+    }
+
     func synchronizeSharedSpendDashboardAfterTokenPublication(for provider: UsageProvider) {
-        // Provider-specific by design: regular Codex publication triggers the account-scoped spend producer.
-        guard provider == .codex, self.sharedSpendDashboardObservationStarted else { return }
-        self.applySharedSpendDashboardConfiguration(
-            SpendDashboardSource.configuration(settings: self.settings, store: self))
+        guard self.sharedSpendDashboardObservationStarted else { return }
+        let isIndependent = Self.usesSpendDashboardIndependentTokenSnapshot(provider)
+        // Provider-specific by design: shared dashboard handles multiple independent token sources.
+        // Token publications both drive the shared dashboard.
+        guard provider == .codex || isIndependent else { return }
+        self.scheduleDebouncedTokenPublicationSync()
+    }
+
+    private func scheduleDebouncedTokenPublicationSync() {
+        self.sharedSpendDashboardTokenPublicationDebounceTask?.cancel()
+        let delay: Duration = self.startupBehavior.automaticallyStartsBackgroundWork
+            ? .milliseconds(250) : .milliseconds(0)
+        self.sharedSpendDashboardTokenPublicationDebounceTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: delay)
+            guard !Task.isCancelled else { return }
+            self?.sharedSpendDashboardTokenPublicationDebounceTask = nil
+            guard let self, self.sharedSpendDashboardObservationStarted else { return }
+            self.applySharedSpendDashboardConfiguration(
+                SpendDashboardSource.configuration(settings: self.settings, store: self))
+        }
     }
 
     private func applySharedSpendDashboardConfiguration(_ configuration: SpendDashboardConfiguration) {

Sources/CodexBar/UsageStore.swift

@@ -191,6 +191,8 @@ final class UsageStore {
     var spendDashboardPublication = SpendDashboardPublication.empty
     @ObservationIgnored var sharedSpendDashboardControllerStorage: SpendDashboardController?
     @ObservationIgnored var sharedSpendDashboardObservationStarted = false
+    @ObservationIgnored var sharedSpendDashboardObservationDebounceTask: Task<Void, Never>?
+    @ObservationIgnored var sharedSpendDashboardTokenPublicationDebounceTask: Task<Void, Never>?
     var tokenErrors: [ProviderInstanceID: String] = [:]
     var tokenRefreshInFlight: Set<ProviderInstanceID> = []
     var codexCostCatchUpActivity: CodexCostCatchUpActivity?

Sources/CodexBarCore/Providers/Antigravity/AntigravityOfflineStore.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+/// Offline Antigravity CLI store (tokscale lesson): counts local SQLite conversations
+/// at `~/.gemini/antigravity-cli/conversations/*.db` without requiring a running
+/// language server or OAuth. Used as a last-resort fallback when live quota
+/// probes and OAuth both fail.
+public enum AntigravityOfflineStore {
+    /// Resolve the base Gemini home directory. Mirrors tokscale's `GEMINI_CLI_HOME`
+    /// override: if the env var is set and non-empty, use it; otherwise `~/.gemini`.
+    public static func geminiHomeDirectory(home: URL, env: [String: String]) -> URL {
+        if let override = env["GEMINI_CLI_HOME"]?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !override.isEmpty
+        {
+            return URL(fileURLWithPath: override, isDirectory: true)
+        }
+        // Provider-specific by design: CLI home path is a fixed external contract.
+        return home.appendingPathComponent(".gemini", isDirectory: true)
+    }
+
+    public static func conversationsDirectory(home: URL, env: [String: String] = [:]) -> URL {
+        self.geminiHomeDirectory(home: home, env: env)
+            .appendingPathComponent("antigravity-cli", isDirectory: true)
+            .appendingPathComponent("conversations", isDirectory: true)
+    }
+
+    /// Tokscale cache alternative: `~/.config/tokscale/antigravity-cache/sessions`
+    public static func tokscaleCacheDirectory(home: URL) -> URL {
+        home.appendingPathComponent(".config", isDirectory: true)
+            .appendingPathComponent("tokscale", isDirectory: true)
+            .appendingPathComponent("antigravity-cache", isDirectory: true)
+            .appendingPathComponent("sessions", isDirectory: true)
+    }
+
+    /// Count offline conversations (`.db` files). Cheap, no SQLite open.
+    public static func countConversations(
+        home: URL,
+        env: [String: String] = [:],
+        fileManager: FileManager = .default) -> Int
+    {
+        let primary = self.conversationsDirectory(home: home, env: env)
+        let primaryCount = self.countDBFiles(in: primary, fileManager: fileManager)
+        if primaryCount > 0 { return primaryCount }
+        // Fallback to tokscale JSONL cache (also counts as offline availability)
+        let cache = self.tokscaleCacheDirectory(home: home)
+        return self.countJSONLFiles(in: cache, fileManager: fileManager)
+    }
+
+    public static func hasOfflineData(
+        home: URL,
+        env: [String: String] = [:],
+        fileManager: FileManager = .default) -> Bool
+    {
+        self.countConversations(home: home, env: env, fileManager: fileManager) > 0
+    }
+
+    private static func countDBFiles(in directory: URL, fileManager: FileManager) -> Int {
+        guard let contents = try? fileManager.contentsOfDirectory(
+            at: directory,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]) else { return 0 }
+        return contents.count(where: { $0.pathExtension.lowercased() == "db" })
+    }
+
+    private static func countJSONLFiles(in directory: URL, fileManager: FileManager) -> Int {
+        guard let contents = try? fileManager.contentsOfDirectory(
+            at: directory,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]) else { return 0 }
+        return contents.count(where: { $0.pathExtension.lowercased() == "jsonl" })
+    }
+}

Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift

@@ -178,19 +178,20 @@ public enum AntigravityProviderDescriptor {
         let cli = AntigravityCLIHTTPSFetchStrategy()
         let ide = AntigravityStatusFetchStrategy(source: .ide)
         let oauth = AntigravityOAuthFetchStrategy()
+        let offline = AntigravityOfflineFetchStrategy()
         switch context.sourceMode {
         case .cli:
-            return [app, cli, ide]
+            return [app, cli, ide, offline]
         case .oauth:
             return [oauth]
         case .auto:
             if context.selectedTokenAccountID != nil ||
                 context.env[AntigravityOAuthCredentialsStore.environmentCredentialsKey] != nil ||
                 self.hasSharedOAuthCredentials(context: context)
             {
-                return [app, cli, ide, oauth]
+                return [app, cli, ide, oauth, offline]
             }
-            return [app, cli, ide]
+            return [app, cli, ide, offline]
         case .web, .api:
             return []
         }
@@ -786,6 +787,61 @@ struct AntigravityOAuthFetchStrategy: ProviderFetchStrategy {
     }
 }
 
+/// Offline fallback (tokscale lesson): when live probes and OAuth have no data,
+/// surface the local Antigravity CLI conversation count from
+/// `~/.gemini/antigravity-cli/conversations/*.db` as a non-quota snapshot.
+/// This keeps the menu bar from going blank on a fresh install without a running
+/// server and mirrors tokscale's direct SQLite read (no RPC, no `antigravity sync`).
+struct AntigravityOfflineFetchStrategy: ProviderFetchStrategy {
+    let id: String = "antigravity.offline"
+    let kind: ProviderFetchKind = .localProbe
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        // Cheap file existence check; no SQLite open.
+        let homeURL = context.env["HOME"]
+            .flatMap { $0.isEmpty ? nil : URL(fileURLWithPath: $0, isDirectory: true) }
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        return AntigravityOfflineStore.hasOfflineData(home: homeURL, env: context.env)
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let homeURL = context.env["HOME"]
+            .flatMap { $0.isEmpty ? nil : URL(fileURLWithPath: $0, isDirectory: true) }
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        let count = AntigravityOfflineStore.countConversations(home: homeURL, env: context.env)
+        guard count > 0 else {
+            throw AntigravityStatusProbeError.notRunning
+        }
+        let window = RateWindow(
+            usedPercent: 0,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: nil)
+        let offlineWindow = NamedRateWindow(
+            id: "antigravity-offline-conversations",
+            title: "Offline · \(count) conversation" + (count == 1 ? "" : "s"),
+            window: window,
+            usageKnown: false)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [offlineWindow],
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: AntigravitySelectedAccountGuard.selectedAccountEmail(context: context),
+                accountOrganization: nil,
+                loginMethod: "offline"))
+        return self.makeResult(usage: snapshot, sourceLabel: "offline")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        // Offline is terminal; no further fallback.
+        false
+    }
+}
+
 /// Guards ambient Antigravity snapshots against the explicitly selected account.
 ///
 /// The local desktop probe and the ``agy`` CLI HTTPS server report whichever