Port Mac Usage & Spend settings pane

apps/desktop-tauri/src-tauri/src/auto_refresh.rs

@@ -214,6 +214,10 @@ fn auto_resume_scheduled_at(
 }
 
 fn local_usage_provider_ids(settings: &Settings) -> Vec<String> {
+    // "Track costs" off: no background local cost-log scan.
+    if !settings.cost_usage_enabled {
+        return Vec::new();
+    }
     settings
         .get_enabled_provider_ids()
         .into_iter()
@@ -459,6 +463,18 @@ mod tests {
         }
     }
 
+    #[test]
+    fn local_usage_refresh_skips_every_provider_when_cost_tracking_is_off() {
+        let settings = Settings {
+            cost_usage_enabled: false,
+            enabled_providers: ["codex".to_string(), "claude".to_string()]
+                .into_iter()
+                .collect(),
+            ..Default::default()
+        };
+        assert!(local_usage_provider_ids(&settings).is_empty());
+    }
+
     #[test]
     fn note_menu_open_sets_recent_age() {
         let _guard = ADAPTIVE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());

apps/desktop-tauri/src-tauri/src/commands/bridge.rs

@@ -907,6 +907,10 @@ pub struct SettingsSnapshot {
     /// History window as its persisted raw form (`rolling:N`,
     /// `month-to-date`, `all`).
     cost_reporting_period: String,
+    cost_usage_enabled: bool,
+    /// Usage & Spend time range, same raw form as `cost_reporting_period`.
+    spend_dashboard_period: String,
+    spend_dashboard_hidden_source_ids: Vec<String>,
     provider_accent_colors: std::collections::HashMap<String, String>,
 }
 
@@ -1053,6 +1057,9 @@ impl From<Settings> for SettingsSnapshot {
             hide_native_codex_cost_when_open_codex_present: settings
                 .hide_native_codex_cost_when_open_codex_present,
             cost_reporting_period: settings.cost_reporting_period.raw(),
+            cost_usage_enabled: settings.cost_usage_enabled,
+            spend_dashboard_period: settings.spend_dashboard_period.raw(),
+            spend_dashboard_hidden_source_ids: settings.spend_dashboard_hidden_source_ids,
             provider_accent_colors: settings
                 .provider_configs
                 .iter()

apps/desktop-tauri/src-tauri/src/commands/chart.rs

@@ -209,6 +209,18 @@ fn build_provider_chart_data_with_cancel(
     cancel: Option<Arc<AtomicBool>>,
     weekly_window: Option<RateWindowSnapshot>,
 ) -> ProviderChartData {
+    if !cost_tracking_enabled() {
+        // Track costs off: no local log scan, so no cost, token, local-usage or
+        // quota-window history (all read local logs). OpenAI dashboard data is
+        // fetched from the web and stays.
+        let (credits_history, usage_breakdown) =
+            load_openai_dashboard_chart_data(&provider_id, account_email.as_deref());
+        return ProviderChartData {
+            credits_history,
+            usage_breakdown,
+            ..ProviderChartData::empty(provider_id)
+        };
+    }
     let live_window = weekly_window.as_ref().map(rate_window_from_snapshot);
     let build_snapshot = || {
         codexbar::providers::chart::build_chart_snapshot(
@@ -401,6 +413,11 @@ fn map_quota_window_history(
     }
 }
 
+/// "Track costs" (Usage & Spend). Off means no local cost-log scan at all.
+fn cost_tracking_enabled() -> bool {
+    codexbar::settings::Settings::load().cost_usage_enabled
+}
+
 /// The History window the desktop is configured to report.
 fn current_reporting_period() -> CostReportingPeriod {
     codexbar::settings::Settings::load().cost_reporting_period
@@ -489,6 +506,9 @@ fn load_local_usage_summary_with_unknown_models(
     provider_id: &str,
     cancel: Option<&AtomicBool>,
 ) -> (Option<ProviderLocalUsageSummary>, HashSet<String>) {
+    if !cost_tracking_enabled() {
+        return (None, HashSet::new());
+    }
     let period = current_reporting_period();
     if provider_id == "muse" {
         let summary = if cancel.is_some_and(|flag| flag.load(Ordering::Relaxed)) {
@@ -688,7 +708,7 @@ pub(crate) async fn refresh_provider_local_usage_cache(provider_ids: Vec<String>
             .await
             .unwrap_or(summary);
         }
-        store_local_usage_summary(&provider_id, summary);
+        store_local_usage_summary_if_tracking(&provider_id, summary);
     }
 }
 
@@ -704,6 +724,11 @@ fn load_local_usage_summary_cached(
     provider_id: &str,
     cancel: Option<&AtomicBool>,
 ) -> Option<ProviderLocalUsageSummary> {
+    // Checked before the cache so an entry from before "Track costs" was
+    // turned off is never served.
+    if !cost_tracking_enabled() {
+        return None;
+    }
     let cache = local_usage_cache();
     let period_identity = local_usage_period_identity();
     if let Ok(guard) = cache.lock()
@@ -723,10 +748,31 @@ fn load_local_usage_summary_cached(
         return None;
     }
 
-    store_local_usage_summary(provider_id, summary.clone());
+    store_local_usage_summary_if_tracking(provider_id, summary.clone());
     summary
 }
 
+/// A scan can outlive a "Track costs" off switch, which clears the cache; drop
+/// its result rather than refill the cache that the PowerToys pipe reads.
+fn store_local_usage_summary_if_tracking(
+    provider_id: &str,
+    summary: Option<ProviderLocalUsageSummary>,
+) {
+    let tracking = summary.is_none() || cost_tracking_enabled();
+    store_scanned_local_usage_summary(provider_id, summary, tracking);
+}
+
+fn store_scanned_local_usage_summary(
+    provider_id: &str,
+    summary: Option<ProviderLocalUsageSummary>,
+    cost_tracking_enabled: bool,
+) {
+    if summary.is_some() && !cost_tracking_enabled {
+        return;
+    }
+    store_local_usage_summary(provider_id, summary);
+}
+
 fn store_local_usage_summary(provider_id: &str, summary: Option<ProviderLocalUsageSummary>) {
     let period_identity = match summary.as_ref() {
         Some(summary) => {

apps/desktop-tauri/src-tauri/src/commands/chart/tests.rs

@@ -227,3 +227,30 @@ fn local_usage_today_hides_known_zero_and_unknown_cost_but_keeps_tokens() {
     let absent = summary_for(None);
     assert_eq!((absent.today_cost, absent.latest_tokens), (None, None));
 }
+
+#[test]
+fn a_scan_that_finishes_after_track_costs_went_off_is_not_cached() {
+    use super::{cached_provider_local_usage_summary, store_scanned_local_usage_summary};
+    let summary = || ProviderLocalUsageSummary {
+        today_cost: Some(1.25),
+        thirty_day_cost: Some(12.5),
+        thirty_day_tokens: Some(42_000),
+        period_cost: Some(12.5),
+        period_tokens: Some(42_000),
+        reporting_period: "month-to-date".to_string(),
+        latest_tokens: None,
+        top_model: None,
+        estimate_note: "estimated".to_string(),
+        token_cost_updated_at_ms: 1234,
+        incomplete_request_count: None,
+    };
+
+    store_scanned_local_usage_summary("track-off-race", Some(summary()), false);
+    assert!(cached_provider_local_usage_summary("track-off-race").is_none());
+
+    store_scanned_local_usage_summary("track-on-scan", Some(summary()), true);
+    assert_eq!(
+        cached_provider_local_usage_summary("track-on-scan").and_then(|s| s.today_cost),
+        Some(1.25)
+    );
+}

apps/desktop-tauri/src-tauri/src/commands/preferences_transfer.rs

@@ -57,13 +57,20 @@ pub async fn import_preferences(
     let mut settings = Settings::load();
     let previous_language = settings.ui_language;
     let previous_period = settings.cost_reporting_period;
+    let previous_cost_tracking = settings.cost_usage_enabled;
     let previous_enabled = settings.get_enabled_provider_ids();
     let applied = document
         .apply_to(&mut settings)
         .map_err(|error| error.to_string())?;
+    if settings.cost_usage_enabled && !previous_cost_tracking {
+        // Turning "Track costs" on pins the bucket zone, as in Settings.
+        settings.pin_cost_usage_bucket_time_zone();
+    }
     settings.save().map_err(|error| error.to_string())?;
     tracing::info!(applied, "imported portable preferences");
-    if settings.cost_reporting_period != previous_period {
+    if settings.cost_reporting_period != previous_period
+        || settings.cost_usage_enabled != previous_cost_tracking
+    {
         // Cached local cost summaries cover the old period's window.
         super::clear_provider_local_usage_cache();
     }

apps/desktop-tauri/src-tauri/src/commands/settings.rs

@@ -103,6 +103,12 @@ pub struct SettingsUpdate {
     pub hide_native_codex_cost_when_open_codex_present: Option<bool>,
     /// History window: `rolling:N` (1..=365), `month-to-date`, or `all`.
     pub cost_reporting_period: Option<String>,
+    /// "Track costs" in Usage & Spend.
+    pub cost_usage_enabled: Option<bool>,
+    /// Usage & Spend time range, same format as `cost_reporting_period`.
+    pub spend_dashboard_period: Option<String>,
+    /// Usage & Spend sources left out of the dashboard; stored sorted and unique.
+    pub spend_dashboard_hidden_source_ids: Option<Vec<String>>,
 }
 
 impl SettingsUpdate {
@@ -122,6 +128,7 @@ impl SettingsUpdate {
             || self.adaptive_refresh.is_some()
             || self.codex_custom_sessions_dirs.is_some()
             || self.cost_reporting_period.is_some()
+            || self.cost_usage_enabled.is_some()
             || self.high_usage_threshold.is_some()
             || self.critical_usage_threshold.is_some()
             || self.provider_usage_thresholds.is_some()
@@ -199,6 +206,24 @@ impl SettingsUpdate {
         {
             settings.cost_reporting_period = v;
         }
+        if let Some(v) = self
+            .spend_dashboard_period
+            .as_deref()
+            .and_then(codexbar::cost_reporting_period::CostReportingPeriod::parse)
+        {
+            settings.spend_dashboard_period = v;
+        }
+        if let Some(ids) = self.spend_dashboard_hidden_source_ids.clone() {
+            settings.spend_dashboard_hidden_source_ids =
+                codexbar::settings::normalize_spend_dashboard_hidden_source_ids(ids);
+        }
+        if let Some(v) = self.cost_usage_enabled {
+            if v && !settings.cost_usage_enabled {
+                // Mac pins the bucket zone when cost tracking is turned on.
+                settings.pin_cost_usage_bucket_time_zone();
+            }
+            settings.cost_usage_enabled = v;
+        }
         if let Some(v) = self.open_codex_usage_logs_enabled {
             settings.open_codex_usage_logs_enabled = v;
         }
@@ -505,6 +530,11 @@ impl SettingsUpdate {
         {
             return Err(format!("Invalid cost reporting period: {value}"));
         }
+        if let Some(value) = self.spend_dashboard_period.as_deref()
+            && codexbar::cost_reporting_period::CostReportingPeriod::parse(value).is_none()
+        {
+            return Err(format!("Invalid spend dashboard period: {value}"));
+        }
         if let Some(overrides) = &self.switcher_shortcuts {
             settings.switcher_shortcuts =
                 codexbar::switcher_shortcuts::normalize_overrides(overrides)
@@ -616,8 +646,9 @@ pub async fn update_settings(
     let mut settings = Settings::load();
     let notify_float_bar = patch.notifies_float_bar();
     let refresh_provider_data = patch.refreshes_provider_data();
-    let clear_local_usage_cache =
-        patch.codex_custom_sessions_dirs.is_some() || patch.cost_reporting_period.is_some();
+    let clear_local_usage_cache = patch.codex_custom_sessions_dirs.is_some()
+        || patch.cost_reporting_period.is_some()
+        || patch.cost_usage_enabled.is_some();
     let rebuild_tray_menu = patch.rebuilds_tray_menu();
     let refresh_tray_presentation = patch.refreshes_tray_presentation();
     let stay_awake_changed = patch.stay_awake_enabled.is_some();
@@ -840,6 +871,66 @@ mod tests {
         );
     }
 
+    #[test]
+    fn spend_dashboard_updates_are_validated_and_applied() {
+        use codexbar::cost_reporting_period::CostReportingPeriod;
+
+        let mut settings = Settings::default();
+        let bad: SettingsUpdate =
+            serde_json::from_str(r#"{"spendDashboardPeriod":"fortnight"}"#).unwrap();
+        let error = bad
+            .apply_to(&mut settings)
+            .expect_err("unknown dashboard period must be rejected");
+        assert_eq!(error, "Invalid spend dashboard period: fortnight");
+
+        let good: SettingsUpdate = serde_json::from_str(
+            r#"{"spendDashboardPeriod":"rolling:90","spendDashboardHiddenSourceIds":["pi"," Codex","pi"]}"#,
+        )
+        .unwrap();
+        good.apply_to(&mut settings)
+            .expect("valid dashboard patch applies");
+        assert_eq!(
+            settings.spend_dashboard_period,
+            CostReportingPeriod::Rolling(90)
+        );
+        // The menu / float-bar period is a separate key.
+        assert_eq!(
+            settings.cost_reporting_period,
+            CostReportingPeriod::Rolling(30)
+        );
+        assert_eq!(settings.spend_dashboard_hidden_source_ids, ["codex", "pi"]);
+    }
+
+    #[test]
+    fn turning_cost_tracking_on_pins_the_bucket_zone_and_off_keeps_it() {
+        let mut settings = Settings {
+            cost_usage_enabled: false,
+            cost_usage_bucket_time_zone: String::new(),
+            ..Settings::default()
+        };
+        let on: SettingsUpdate = serde_json::from_str(r#"{"costUsageEnabled":true}"#).unwrap();
+        assert!(on.notifies_float_bar());
+        on.apply_to(&mut settings).expect("enable applies");
+        assert!(settings.cost_usage_enabled);
+        let mut expected = Settings {
+            cost_usage_bucket_time_zone: String::new(),
+            ..Settings::default()
+        };
+        expected.pin_cost_usage_bucket_time_zone();
+        assert_eq!(
+            settings.cost_usage_bucket_time_zone,
+            expected.cost_usage_bucket_time_zone
+        );
+
+        let off: SettingsUpdate = serde_json::from_str(r#"{"costUsageEnabled":false}"#).unwrap();
+        off.apply_to(&mut settings).expect("disable applies");
+        assert!(!settings.cost_usage_enabled);
+        assert_eq!(
+            settings.cost_usage_bucket_time_zone,
+            expected.cost_usage_bucket_time_zone
+        );
+    }
+
     #[test]
     fn display_settings_that_affect_tray_trigger_presentation_refresh() {
         assert!(

apps/desktop-tauri/src-tauri/src/commands/spend_contract.rs

@@ -28,6 +28,9 @@ pub async fn get_spend_contract(
         let settings = Settings::load();
         let period =
             CostReportingPeriod::resolve_request(period.as_deref(), settings.cost_reporting_period);
+        if !settings.cost_usage_enabled {
+            return SpendContract::empty(&provider, period);
+        }
         let scanner = CostScanner::for_period(period);
         let summary = match provider.as_str() {
             "codex" => scanner.scan_codex(),