feat(cursor): add token cost report with Cursor-metered total

Sources/CodexBar/InlineUsageDashboardContent.swift

@@ -238,7 +238,7 @@ extension UsageMenuCardView.Model {
         {
             return Self.poeInlineDashboard(usage, now: input.now)
         }
-        if [.codex, .claude, .vertexai, .bedrock].contains(input.provider),
+        if [.codex, .claude, .vertexai, .bedrock, .cursor].contains(input.provider),
            input.tokenCostInlineDashboardEnabled,
            let tokenSnapshot = input.tokenSnapshot,
            !tokenSnapshot.daily.isEmpty

Sources/CodexBar/MenuCardHeightFingerprint.swift

@@ -112,6 +112,7 @@ extension UsageMenuCardView.Model.TokenUsageSection {
         MenuCardHeightFingerprint.join([
             MenuCardHeightFingerprint.field("session", self.sessionLine),
             MenuCardHeightFingerprint.field("month", self.monthLine),
+            MenuCardHeightFingerprint.field("metered", self.meteredLine),
             MenuCardHeightFingerprint.field("comparisons", self.comparisonLines.joined(separator: "|")),
             MenuCardHeightFingerprint.field("hint", self.hintLine),
             MenuCardHeightFingerprint.field("error", self.errorLine),

Sources/CodexBar/MenuCardView+Costs.swift

@@ -141,10 +141,17 @@ extension UsageMenuCardView.Model {
             }
             return "\(windowLabel): \(monthCost)"
         }()
+        // Plan-metered spend over the same window (what the provider actually deducts);
+        // only providers that report it (currently Cursor) populate `meteredCostUSD`.
+        let meteredLine: String? = snapshot.meteredCostUSD.map {
+            let amount = UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode)
+            return String(format: L("Cursor-metered: %@ (%@)"), amount, windowLabel.lowercased())
+        }
         let err = (error?.isEmpty ?? true) ? nil : error
         return TokenUsageSection(
             sessionLine: sessionLine,
             monthLine: monthLine,
+            meteredLine: meteredLine,
             comparisonLines: comparisonPeriodsEnabled
                 ? snapshot.comparisonSummaries().map {
                     Self.costWindowLine(summary: $0, currencyCode: snapshot.currencyCode)
@@ -174,6 +181,8 @@ extension UsageMenuCardView.Model {
             L("Estimated from local Codex logs for the selected account.")
         case .claude:
             UsageFormatter.costEstimateHint(provider: provider)
+        case .cursor:
+            UsageFormatter.costEstimateHint(provider: provider)
         case .vertexai:
             L("cost_estimate_hint")
         case .bedrock:

Sources/CodexBar/MenuCardView+ModelHelpers.swift

@@ -202,6 +202,7 @@ extension UsageMenuCardView.Model {
         case let (current?, candidate?):
             current.hintLine == candidate.hintLine &&
                 current.errorLine == candidate.errorLine &&
+                (current.meteredLine == nil) == (candidate.meteredLine == nil) &&
                 current.comparisonLines.count == candidate.comparisonLines.count
         default:
             false

Sources/CodexBar/MenuCardView.swift

@@ -86,21 +86,26 @@ struct UsageMenuCardView: View {
         struct TokenUsageSection {
             let sessionLine: String
             let monthLine: String
+            let meteredLine: String?
             let comparisonLines: [String]
             let hintLine: String?
             let errorLine: String?
             let errorCopyText: String?
 
+            /// Explicit initializer so `meteredLine`/`comparisonLines` default to empty: callers
+            /// that predate them (and providers that never report them) keep their call sites.
             init(
                 sessionLine: String,
                 monthLine: String,
+                meteredLine: String? = nil,
                 comparisonLines: [String] = [],
                 hintLine: String?,
                 errorLine: String?,
                 errorCopyText: String?)
             {
                 self.sessionLine = sessionLine
                 self.monthLine = monthLine
+                self.meteredLine = meteredLine
                 self.comparisonLines = comparisonLines
                 self.hintLine = hintLine
                 self.errorLine = errorLine
@@ -212,39 +217,7 @@ struct UsageMenuCardView: View {
                         Divider()
                     }
                     if let tokenUsage = liveModel.tokenUsage {
-                        VStack(alignment: .leading, spacing: 6) {
-                            Text(L("cost_header_estimated"))
-                                .font(.body)
-                                .fontWeight(.medium)
-                            Text(tokenUsage.sessionLine)
-                                .font(.footnote)
-                                .lineLimit(1)
-                            Text(tokenUsage.monthLine)
-                                .font(.footnote)
-                                .lineLimit(1)
-                            ForEach(tokenUsage.comparisonLines, id: \.self) { line in
-                                Text(line)
-                                    .font(.footnote)
-                                    .lineLimit(1)
-                            }
-                            if let hint = tokenUsage.hintLine, !hint.isEmpty {
-                                Text(hint)
-                                    .font(.footnote)
-                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-                                    .lineLimit(4)
-                                    .fixedSize(horizontal: false, vertical: true)
-                            }
-                            if let error = tokenUsage.errorLine, !error.isEmpty {
-                                Text(error)
-                                    .font(.footnote)
-                                    .foregroundStyle(MenuHighlightStyle.error(self.isHighlighted))
-                                    .lineLimit(4)
-                                    .fixedSize(horizontal: false, vertical: true)
-                                    .overlay {
-                                        ClickToCopyOverlay(copyText: tokenUsage.errorCopyText ?? error)
-                                    }
-                            }
-                        }
+                        TokenUsageSectionContent(tokenUsage: tokenUsage, lineFont: .footnote)
                     }
                 }
             }
@@ -422,6 +395,55 @@ private struct CopyIconButton: View {
     }
 }
 
+/// Shared token-cost block (header, Today/window/metered/comparison lines, hint, error) used by
+/// both the inline card body and the standalone cost section; only the value-line font differs.
+private struct TokenUsageSectionContent: View {
+    let tokenUsage: UsageMenuCardView.Model.TokenUsageSection
+    let lineFont: Font
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            Text(L("cost_header_estimated"))
+                .font(.body)
+                .fontWeight(.medium)
+            Text(self.tokenUsage.sessionLine)
+                .font(self.lineFont)
+                .lineLimit(1)
+            Text(self.tokenUsage.monthLine)
+                .font(self.lineFont)
+                .lineLimit(1)
+            if let metered = self.tokenUsage.meteredLine, !metered.isEmpty {
+                Text(metered)
+                    .font(self.lineFont)
+                    .lineLimit(1)
+            }
+            ForEach(self.tokenUsage.comparisonLines, id: \.self) { line in
+                Text(line)
+                    .font(self.lineFont)
+                    .lineLimit(1)
+            }
+            if let hint = self.tokenUsage.hintLine, !hint.isEmpty {
+                Text(hint)
+                    .font(.footnote)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(4)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+            if let error = self.tokenUsage.errorLine, !error.isEmpty {
+                Text(error)
+                    .font(.footnote)
+                    .foregroundStyle(MenuHighlightStyle.error(self.isHighlighted))
+                    .lineLimit(4)
+                    .fixedSize(horizontal: false, vertical: true)
+                    .overlay {
+                        ClickToCopyOverlay(copyText: self.tokenUsage.errorCopyText ?? error)
+                    }
+            }
+        }
+    }
+}
+
 private struct ProviderCostContent: View {
     let section: UsageMenuCardView.Model.ProviderCostSection
     let progressColor: Color
@@ -747,39 +769,7 @@ struct UsageMenuCardCostSectionView: View {
             if hasTokenCost {
                 VStack(alignment: .leading, spacing: 10) {
                     if let tokenUsage = liveModel.tokenUsage {
-                        VStack(alignment: .leading, spacing: 6) {
-                            Text(L("cost_header_estimated"))
-                                .font(.body)
-                                .fontWeight(.medium)
-                            Text(tokenUsage.sessionLine)
-                                .font(.caption)
-                                .lineLimit(1)
-                            Text(tokenUsage.monthLine)
-                                .font(.caption)
-                                .lineLimit(1)
-                            ForEach(tokenUsage.comparisonLines, id: \.self) { line in
-                                Text(line)
-                                    .font(.caption)
-                                    .lineLimit(1)
-                            }
-                            if let hint = tokenUsage.hintLine, !hint.isEmpty {
-                                Text(hint)
-                                    .font(.footnote)
-                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-                                    .lineLimit(4)
-                                    .fixedSize(horizontal: false, vertical: true)
-                            }
-                            if let error = tokenUsage.errorLine, !error.isEmpty {
-                                Text(error)
-                                    .font(.footnote)
-                                    .foregroundStyle(MenuHighlightStyle.error(self.isHighlighted))
-                                    .lineLimit(4)
-                                    .fixedSize(horizontal: false, vertical: true)
-                                    .overlay {
-                                        ClickToCopyOverlay(copyText: tokenUsage.errorCopyText ?? error)
-                                    }
-                            }
-                        }
+                        TokenUsageSectionContent(tokenUsage: tokenUsage, lineFont: .caption)
                     }
                 }
                 .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)

Sources/CodexBar/PreferencesMenuPane.swift

@@ -125,6 +125,7 @@ struct CostSummarySettingsSection: View {
                     Text(L("cost_auto_refresh_info"))
                     self.costStatusLine(provider: .claude)
                     self.costStatusLine(provider: .codex)
+                    self.costStatusLine(provider: .cursor)
                 }
             }
         }
@@ -133,7 +134,7 @@ struct CostSummarySettingsSection: View {
     private func costStatusLine(provider: UsageProvider) -> Text {
         let name = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
 
-        guard provider == .claude || provider == .codex else {
+        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else {
             return Text(String(format: L("cost_status_unsupported"), name))
         }
 

Sources/CodexBar/StatusItemController+CostMenuCard.swift

@@ -91,6 +91,7 @@ extension StatusItemController {
         let lines = [
             tokenUsage?.sessionLine,
             tokenUsage?.monthLine,
+            tokenUsage?.meteredLine,
         ]
             .compactMap(\.self)
             + (tokenUsage?.comparisonLines ?? [])
@@ -106,6 +107,7 @@ extension StatusItemController {
         let primaryLines = ([
             tokenUsage?.sessionLine,
             tokenUsage?.monthLine,
+            tokenUsage?.meteredLine,
         ]
             .compactMap(\.self)
             + (tokenUsage?.comparisonLines ?? [])

Sources/CodexBar/UsageStore+TokenCost.swift

@@ -82,6 +82,18 @@ extension UsageStore {
         }
     }
 
+    /// Fingerprint of the Cursor account behind auto/cached cookie resolution, derived from the
+    /// latest status snapshot's identity (via an in-process hash, never the raw email). Used in the
+    /// cost cache scope so a silent account switch invalidates the TTL.
+    nonisolated static func cursorAutoIdentityFingerprint(_ snapshot: UsageSnapshot?) -> String {
+        guard let email = snapshot?.identity?.accountEmail?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !email.isEmpty
+        else {
+            return "none"
+        }
+        return "\(email.lowercased().hashValue)"
+    }
+
     nonisolated static func tokenCostRequiresProviderSnapshot(_ provider: UsageProvider) -> Bool {
         switch provider {
         case .mistral, .openai:

Sources/CodexBar/UsageStore.swift

@@ -1426,13 +1426,22 @@ extension UsageStore {
         }
     }
 
-    func refreshTokenUsage(_ provider: UsageProvider, force: Bool) async {
-        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else {
-            self.tokenSnapshots.removeValue(forKey: provider)
-            self.tokenErrors[provider] = nil
-            self.tokenFailureGates[provider]?.reset()
+    /// Clears cached cost/token state for a provider so an ineligible or disabled provider stops
+    /// surfacing stale data. Pass `resetFetchMarkers: false` to keep the TTL fetch markers (used
+    /// when a provider snapshot simply lacks token data for this cycle).
+    private func resetTokenState(for provider: UsageProvider, resetFetchMarkers: Bool = true) {
+        self.tokenSnapshots.removeValue(forKey: provider)
+        self.tokenErrors[provider] = nil
+        self.tokenFailureGates[provider]?.reset()
+        if resetFetchMarkers {
             self.lastTokenFetchAt.removeValue(forKey: provider)
             self.lastTokenFetchScope.removeValue(forKey: provider)
+        }
+    }
+
+    func refreshTokenUsage(_ provider: UsageProvider, force: Bool) async {
+        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else {
+            self.resetTokenState(for: provider)
             return
         }
 
@@ -1443,37 +1452,56 @@ extension UsageStore {
                 self.tokenFailureGates[provider]?.recordSuccess()
                 self.persistWidgetSnapshot(reason: "token-usage")
             } else {
-                self.tokenSnapshots.removeValue(forKey: provider)
-                self.tokenErrors[provider] = nil
-                self.tokenFailureGates[provider]?.reset()
+                self.resetTokenState(for: provider, resetFetchMarkers: false)
             }
             return
         }
 
         guard self.settings.costUsageEnabled else {
-            self.tokenSnapshots.removeValue(forKey: provider)
-            self.tokenErrors[provider] = nil
-            self.tokenFailureGates[provider]?.reset()
-            self.lastTokenFetchAt.removeValue(forKey: provider)
-            self.lastTokenFetchScope.removeValue(forKey: provider)
+            self.resetTokenState(for: provider)
             return
         }
 
         guard self.isEnabled(provider) else {
-            self.tokenSnapshots.removeValue(forKey: provider)
-            self.tokenErrors[provider] = nil
-            self.tokenFailureGates[provider]?.reset()
-            self.lastTokenFetchAt.removeValue(forKey: provider)
-            self.lastTokenFetchScope.removeValue(forKey: provider)
+            self.resetTokenState(for: provider)
+            return
+        }
+
+        // Cursor cost honors the same cookie policy as status: when the user set the cookie source
+        // to Off, skip the network fetch entirely (mirrors CursorProviderDescriptor.checkStatus).
+        if provider == .cursor, self.settings.cursorCookieSource == .off {
+            self.resetTokenState(for: provider)
             return
         }
 
         guard !self.tokenRefreshInFlight.contains(provider) else { return }
 
         let now = Date()
         let historyDays = self.settings.costUsageHistoryDays
+        // Cursor cost reuses the status cookie policy: a Manual source forwards the manual header so
+        // cost and status share the same session; other sources fall back to auto resolution.
+        let cursorCookieSource = self.settings.cursorCookieSource
+        let cursorCookieHeaderOverride: String? = provider == .cursor && cursorCookieSource == .manual
+            ? CookieHeaderNormalizer.normalize(self.settings.cursorCookieHeader)
+            : nil
         let costScope = self.tokenCostScope(for: provider)
-        let costScopeSignature = "\(costScope.signature)|historyDays=\(historyDays)"
+        // Fold the manual cookie into the cache key (via an in-process hash, never the raw header) so
+        // pasting a different Cursor cookie invalidates a snapshot fetched within the TTL instead of
+        // showing the previous account's data.
+        let cursorScopeSuffix = if provider != .cursor {
+            ""
+        } else if let override = cursorCookieHeaderOverride {
+            "|cursorCookie=manual:\(override.hashValue)"
+        } else {
+            // Auto/cached resolution can silently switch Cursor accounts (e.g. the old cookie is
+            // rejected and a status refresh imports a new browser session). Fold the resolved
+            // account identity into the scope so an account change invalidates the TTL instead of
+            // returning the previous account's cost snapshot.
+            "|cursorCookie=\(cursorCookieSource.rawValue):" +
+                Self.cursorAutoIdentityFingerprint(self.snapshots[.cursor])
+        }
+        let costScopeSignature =
+            "\(costScope.signature)|historyDays=\(historyDays)\(cursorScopeSuffix)"
         if !force,
            let last = self.lastTokenFetchAt[provider],
            self.lastTokenFetchScope[provider] == costScopeSignature,
@@ -1524,7 +1552,8 @@ extension UsageStore {
                         forceRefresh: force,
                         allowVertexClaudeFallback: !self.isEnabled(.claude),
                         codexHomePath: costScope.codexHomePath,
-                        historyDays: historyDays)
+                        historyDays: historyDays,
+                        cursorCookieHeaderOverride: cursorCookieHeaderOverride)
                 }
                 group.addTask {
                     try await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000))