diff --git a/apps/desktop-tauri/src-tauri/src/auto_refresh.rs b/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
index 91d26dd773..4e40926ca2 100644
--- a/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
+++ b/apps/desktop-tauri/src-tauri/src/auto_refresh.rs
@@ -1,28 +1,73 @@
-use std::sync::{Arc, OnceLock};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, OnceLock};
 use std::time::{Duration, Instant};
 
+use codexbar::core::{
+    AdaptiveRefreshInput, AdaptiveRefreshReason, ThermalPressure, next_delay as adaptive_next_delay,
+};
 use codexbar::settings::Settings;
 
 const AUTO_REFRESH_POLL_INTERVAL: Duration = Duration::from_secs(15);
 
+static LAST_MENU_OPEN: OnceLock<Mutex<Option<Instant>>> = OnceLock::new();
+static LAST_CODING_ACTIVITY: OnceLock<Mutex<Option<Instant>>> = OnceLock::new();
+static ADAPTIVE_ACTIVE: AtomicBool = AtomicBool::new(false);
+
+/// Record that the tray/flyout panel just opened (recent-interaction signal).
+pub fn note_menu_open() {
+    *LAST_MENU_OPEN
+        .get_or_init(|| Mutex::new(None))
+        .lock()
+        .unwrap_or_else(|e| e.into_inner()) = Some(Instant::now());
+}
+
+/// Weak coding-activity signal (e.g. a refresh cycle that found live usage).
+#[allow(dead_code)]
+pub fn note_coding_activity() {
+    *LAST_CODING_ACTIVITY
+        .get_or_init(|| Mutex::new(None))
+        .lock()
+        .unwrap_or_else(|e| e.into_inner()) = Some(Instant::now());
+}
+
+fn age_since(slot: &OnceLock<Mutex<Option<Instant>>>) -> Option<Duration> {
+    let guard = slot
+        .get_or_init(|| Mutex::new(None))
+        .lock()
+        .unwrap_or_else(|e| e.into_inner());
+    guard.map(|at| at.elapsed())
+}
+
 pub fn install(app: tauri::AppHandle) {
     tauri::async_runtime::spawn(async move {
-        let mut schedule: Option<(Duration, Instant)> = None;
+        let mut schedule: Option<(Duration, Instant, bool)> = None;
         loop {
-            let interval = refresh_interval(Settings::load().refresh_interval_secs);
+            let settings = Settings::load();
+            ADAPTIVE_ACTIVE.store(settings.adaptive_refresh, Ordering::Relaxed);
+            let interval = resolve_refresh_interval(&settings);
             match interval {
                 None => schedule = None,
                 Some(interval) => {
                     let now = Instant::now();
+                    let adaptive = settings.adaptive_refresh;
                     let scheduled_at = schedule
-                        .filter(|(scheduled_interval, _)| *scheduled_interval == interval)
-                        .map(|(_, scheduled_at)| scheduled_at)
+                        .filter(|(scheduled_interval, _, was_adaptive)| {
+                            *scheduled_interval == interval && *was_adaptive == adaptive
+                        })
+                        .map(|(_, scheduled_at, _)| scheduled_at)
                         .unwrap_or(now);
                     if now >= scheduled_at {
                         let _ = crate::commands::do_refresh_providers_if_stale(&app).await;
+                        // Treat a completed refresh as a weak activity signal while adaptive.
+                        if adaptive {
+                            note_coding_activity();
+                        }
+                        let next_interval =
+                            resolve_refresh_interval(&Settings::load()).unwrap_or(interval);
                         schedule = Some((
-                            interval,
-                            next_fixed_tick(scheduled_at, Instant::now(), interval),
+                            next_interval,
+                            next_fixed_tick(scheduled_at, Instant::now(), next_interval),
+                            adaptive,
                         ));
                     }
                 }
@@ -32,6 +77,73 @@ pub fn install(app: tauri::AppHandle) {
     });
 }
 
+fn resolve_refresh_interval(settings: &Settings) -> Option<Duration> {
+    if settings.adaptive_refresh {
+        return Some(adaptive_delay_now());
+    }
+    refresh_interval(settings.refresh_interval_secs)
+}
+
+fn adaptive_delay_now() -> Duration {
+    let decision = adaptive_next_delay(AdaptiveRefreshInput {
+        last_menu_open_age: age_since(&LAST_MENU_OPEN),
+        last_coding_activity_age: age_since(&LAST_CODING_ACTIVITY),
+        low_power_mode_enabled: low_power_mode_enabled(),
+        thermal_pressure: ThermalPressure::Nominal,
+    });
+    tracing::debug!(
+        delay_secs = decision.delay.as_secs(),
+        reason = ?decision.reason,
+        "adaptive refresh delay"
+    );
+    let _ = AdaptiveRefreshReason::LongIdle;
+    decision.delay
+}
+
+/// Best-effort Windows battery/AC check. Returns false when unknown.
+fn low_power_mode_enabled() -> bool {
+    #[cfg(windows)]
+    {
+        // SYSTEM_POWER_STATUS via kernel32. ACLineStatus: 0 = offline (battery).
+        // BatteryFlag bit 0x08 = charging; BatteryLifePercent 0-100 or 255 unknown.
+        // Treat "on battery and < 20% remaining" as low-power; skip on failure.
+        #[repr(C)]
+        struct SystemPowerStatus {
+            ac_line_status: u8,
+            battery_flag: u8,
+            battery_life_percent: u8,
+            system_status_flag: u8,
+            battery_life_time: u32,
+            battery_full_life_time: u32,
+        }
+        #[link(name = "kernel32")]
+        unsafe extern "system" {
+            fn GetSystemPowerStatus(status: *mut SystemPowerStatus) -> i32;
+        }
+        let mut status = SystemPowerStatus {
+            ac_line_status: 255,
+            battery_flag: 255,
+            battery_life_percent: 255,
+            system_status_flag: 0,
+            battery_life_time: 0,
+            battery_full_life_time: 0,
+        };
+        let ok = unsafe { GetSystemPowerStatus(&mut status) } != 0;
+        if !ok {
+            return false;
+        }
+        let on_battery = status.ac_line_status == 0;
+        let low_pct = status.battery_life_percent <= 20;
+        // system_status_flag bit 0x01 = Battery Saver is on (Win10+)
+        let battery_saver = status.system_status_flag & 0x01 != 0;
+        return on_battery && (low_pct || battery_saver);
+    }
+    #[cfg(not(windows))]
+    {
+        false
+    }
+}
+
 fn next_fixed_tick(
     previous_scheduled_at: Instant,
     completed_at: Instant,
@@ -87,6 +199,26 @@ mod tests {
         assert_eq!(refresh_interval(0), None);
     }
 
+    #[test]
+    fn adaptive_enabled_uses_policy_delay() {
+        // Clear shared activity slots so parallel/prior tests cannot shrink the delay.
+        *LAST_MENU_OPEN
+            .get_or_init(|| Mutex::new(None))
+            .lock()
+            .unwrap_or_else(|e| e.into_inner()) = None;
+        *LAST_CODING_ACTIVITY
+            .get_or_init(|| Mutex::new(None))
+            .lock()
+            .unwrap_or_else(|e| e.into_inner()) = None;
+
+        let mut settings = Settings::default();
+        settings.adaptive_refresh = true;
+        settings.refresh_interval_secs = 0;
+        let delay = resolve_refresh_interval(&settings).expect("adaptive always schedules");
+        // No menu open → long idle 30m
+        assert_eq!(delay, Duration::from_secs(30 * 60));
+    }
+
     #[test]
     fn fixed_cadence_advances_from_the_scheduled_tick() {
         let start = Instant::now();
@@ -118,4 +250,11 @@ mod tests {
             vec!["codex".to_string()]
         );
     }
+
+    #[test]
+    fn note_menu_open_sets_recent_age() {
+        note_menu_open();
+        let age = age_since(&LAST_MENU_OPEN).expect("menu open recorded");
+        assert!(age < Duration::from_secs(5));
+    }
 }
diff --git a/apps/desktop-tauri/src-tauri/src/commands/bridge.rs b/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
index a92fe9f9ba..753edd23b3 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
@@ -408,6 +408,7 @@ pub struct SettingsSnapshot {
     enabled_providers: Vec<String>,
     provider_order: Vec<String>,
     refresh_interval_secs: u64,
+    adaptive_refresh: bool,
     refresh_all_providers_on_menu_open: bool,
     start_at_login: bool,
     start_minimized: bool,
@@ -504,6 +505,7 @@ impl From<Settings> for SettingsSnapshot {
             enabled_providers,
             provider_order,
             refresh_interval_secs: settings.refresh_interval_secs,
+            adaptive_refresh: settings.adaptive_refresh,
             refresh_all_providers_on_menu_open: settings.refresh_all_providers_on_menu_open,
             start_at_login: settings.start_at_login,
             start_minimized: settings.start_minimized,
diff --git a/apps/desktop-tauri/src-tauri/src/commands/providers.rs b/apps/desktop-tauri/src-tauri/src/commands/providers.rs
index 1d12ac816e..54008b5769 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/providers.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/providers.rs
@@ -110,6 +110,9 @@ pub(crate) fn build_fetch_context(
     let api_region = settings.api_region(id).trim().to_string();
     let gateway_url = (id == ProviderId::Wayfinder && !settings.gateway_url(id).is_empty())
         .then(|| settings.gateway_url(id).to_string());
+    // Local-first Auto providers (OpenCode Go) flip to web-first when a
+    // token account or manual cookie source scopes the session to web creds.
+    let auto_prefer_web = token_override.is_some() || cookie_source == "manual";
 
     FetchContext {
         source_mode,
@@ -118,6 +121,7 @@ pub(crate) fn build_fetch_context(
         workspace_id: (!workspace_id.is_empty()).then_some(workspace_id),
         api_region: (!api_region.is_empty()).then_some(api_region),
         gateway_url,
+        auto_prefer_web,
         ..FetchContext::default()
     }
 }
diff --git a/apps/desktop-tauri/src-tauri/src/commands/settings.rs b/apps/desktop-tauri/src-tauri/src/commands/settings.rs
index ccd8185532..94f87ad6d0 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/settings.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/settings.rs
@@ -9,6 +9,7 @@ use super::*;
 pub struct SettingsUpdate {
     pub enabled_providers: Option<Vec<String>>,
     pub refresh_interval_secs: Option<u64>,
+    pub adaptive_refresh: Option<bool>,
     pub refresh_all_providers_on_menu_open: Option<bool>,
     pub start_at_login: Option<bool>,
     pub start_minimized: Option<bool>,
@@ -126,6 +127,9 @@ impl SettingsUpdate {
         if let Some(v) = self.refresh_interval_secs {
             settings.refresh_interval_secs = v;
         }
+        if let Some(v) = self.adaptive_refresh {
+            settings.adaptive_refresh = v;
+        }
         if let Some(v) = self.refresh_all_providers_on_menu_open {
             settings.refresh_all_providers_on_menu_open = v;
         }
diff --git a/apps/desktop-tauri/src-tauri/src/tray_bridge.rs b/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
index 173b84a448..de9c78d1e0 100644
--- a/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
+++ b/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
@@ -318,6 +318,7 @@ pub fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
 fn handle_menu_event(app: &AppHandle, id: &str) {
     match resolve_menu_action(id) {
         Some(MenuAction::Transition(request)) => {
+            crate::auto_refresh::note_menu_open();
             match resolve_menu_transition_dispatch(id, request) {
                 // Pass None so default_surface_position can use remembered PopOut
                 // geometry first, then fall back to tray/current-monitor placement.
@@ -346,6 +347,7 @@ fn handle_menu_event(app: &AppHandle, id: &str) {
             // Pass None: open_or_focus falls back to the tray-anchored
             // default position (same placement chain the old TrayPanel
             // transition used) when no explicit position is given.
+            crate::auto_refresh::note_menu_open();
             let _ = shell::flyout_window::open_or_focus(app, None);
         }
         Some(MenuAction::Refresh) => {
diff --git a/apps/desktop-tauri/src/App.test.tsx b/apps/desktop-tauri/src/App.test.tsx
index 14230f1519..cd073ed89d 100644
--- a/apps/desktop-tauri/src/App.test.tsx
+++ b/apps/desktop-tauri/src/App.test.tsx
@@ -63,6 +63,7 @@ function settings(overrides: Partial<SettingsSnapshot> = {}): SettingsSnapshot {
   return {
     enabledProviders: ["codex", "claude"],
     refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
     refreshAllProvidersOnMenuOpen: false,
     startAtLogin: false,
     startMinimized: false,
diff --git a/apps/desktop-tauri/src/floatbar/FloatBar.test.tsx b/apps/desktop-tauri/src/floatbar/FloatBar.test.tsx
index 67dc7871c8..5722be9a19 100644
--- a/apps/desktop-tauri/src/floatbar/FloatBar.test.tsx
+++ b/apps/desktop-tauri/src/floatbar/FloatBar.test.tsx
@@ -92,6 +92,7 @@ function settings(overrides: Partial<SettingsSnapshot> = {}): SettingsSnapshot {
   return {
     enabledProviders: ["claude", "codex"],
     refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
     refreshAllProvidersOnMenuOpen: false,
     startAtLogin: false,
     startMinimized: false,
diff --git a/apps/desktop-tauri/src/i18n/keys.ts b/apps/desktop-tauri/src/i18n/keys.ts
index 5ffc32c235..baaea8eb37 100644
--- a/apps/desktop-tauri/src/i18n/keys.ts
+++ b/apps/desktop-tauri/src/i18n/keys.ts
@@ -674,6 +674,7 @@ export const ALL_LOCALE_KEYS = [
 
   // Tauri desktop shell — Refresh interval + provider display names
   "RefreshIntervalManual",
+  "RefreshIntervalAdaptive",
   "RefreshInterval15Min",
   "RefreshInterval30Min",
   "RefreshInterval1Hour",
diff --git a/apps/desktop-tauri/src/surfaces/PopOutPanel.test.tsx b/apps/desktop-tauri/src/surfaces/PopOutPanel.test.tsx
index d908988c85..dc96b99c34 100644
--- a/apps/desktop-tauri/src/surfaces/PopOutPanel.test.tsx
+++ b/apps/desktop-tauri/src/surfaces/PopOutPanel.test.tsx
@@ -118,6 +118,7 @@ function settings(): SettingsSnapshot {
   return {
     enabledProviders: ["codex", "claude"],
     refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
     refreshAllProvidersOnMenuOpen: false,
     startAtLogin: false,
     startMinimized: false,
diff --git a/apps/desktop-tauri/src/surfaces/TrayPanel.test.tsx b/apps/desktop-tauri/src/surfaces/TrayPanel.test.tsx
index 6df1796c8b..e1f9318d20 100644
--- a/apps/desktop-tauri/src/surfaces/TrayPanel.test.tsx
+++ b/apps/desktop-tauri/src/surfaces/TrayPanel.test.tsx
@@ -104,6 +104,7 @@ function settings(overrides: Partial<SettingsSnapshot> = {}): SettingsSnapshot {
   return {
     enabledProviders: ["codex", "claude"],
     refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
     refreshAllProvidersOnMenuOpen: false,
     startAtLogin: false,
     startMinimized: false,
diff --git a/apps/desktop-tauri/src/surfaces/settings/tabs/AboutTab.test.tsx b/apps/desktop-tauri/src/surfaces/settings/tabs/AboutTab.test.tsx
index 4e0102f0b7..592fc6cf08 100644
--- a/apps/desktop-tauri/src/surfaces/settings/tabs/AboutTab.test.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/tabs/AboutTab.test.tsx
@@ -40,6 +40,7 @@ import type { SettingsSnapshot } from "../../../types/bridge";
 const settings: SettingsSnapshot = {
   enabledProviders: [],
   refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
   refreshAllProvidersOnMenuOpen: false,
   startAtLogin: false,
   startMinimized: false,
diff --git a/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.test.tsx b/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.test.tsx
index 512322b446..fdd684fffa 100644
--- a/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.test.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.test.tsx
@@ -23,6 +23,7 @@ import type { SettingsSnapshot } from "../../../types/bridge";
 const settings: SettingsSnapshot = {
   enabledProviders: [],
   refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
   refreshAllProvidersOnMenuOpen: false,
   startAtLogin: false,
   startMinimized: false,
diff --git a/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.tsx b/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.tsx
index 771222ebd5..d821a469ac 100644
--- a/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.tsx
+++ b/apps/desktop-tauri/src/surfaces/settings/tabs/GeneralTab.tsx
@@ -18,6 +18,7 @@ const FALLBACK_LANGUAGE_OPTIONS: LanguageOption[] = [
 
 const REFRESH_CADENCE_OPTIONS: { value: string; labelKey: LocaleKey }[] = [
   { value: "0", labelKey: "RefreshIntervalManual" },
+  { value: "adaptive", labelKey: "RefreshIntervalAdaptive" },
   { value: "60", labelKey: "RefreshInterval1Min" },
   { value: "300", labelKey: "RefreshInterval5Min" },
   { value: "900", labelKey: "RefreshInterval15Min" },
@@ -310,13 +311,26 @@ export default function GeneralTab({
             description={t("RefreshIntervalHelper")}
           >
             <Select
-              value={String(settings.refreshIntervalSecs)}
+              value={
+                settings.adaptiveRefresh
+                  ? "adaptive"
+                  : String(settings.refreshIntervalSecs)
+              }
               disabled={saving}
               options={REFRESH_CADENCE_OPTIONS.map((o) => ({
                 value: o.value,
                 label: t(o.labelKey),
               }))}
-              onChange={(v) => set({ refreshIntervalSecs: Number(v) })}
+              onChange={(v) => {
+                if (v === "adaptive") {
+                  set({ adaptiveRefresh: true });
+                  return;
+                }
+                set({
+                  adaptiveRefresh: false,
+                  refreshIntervalSecs: Number(v),
+                });
+              }}
             />
           </Field>
           <Field
diff --git a/apps/desktop-tauri/src/types/bridge.test.ts b/apps/desktop-tauri/src/types/bridge.test.ts
index b869ffeaf2..549351dbc2 100644
--- a/apps/desktop-tauri/src/types/bridge.test.ts
+++ b/apps/desktop-tauri/src/types/bridge.test.ts
@@ -41,6 +41,7 @@ describe("Language type", () => {
     const snap: SettingsSnapshot = {
       enabledProviders: [],
       refreshIntervalSecs: 300,
+    adaptiveRefresh: false,
       refreshAllProvidersOnMenuOpen: false,
       startAtLogin: false,
       startMinimized: false,
diff --git a/apps/desktop-tauri/src/types/bridge.ts b/apps/desktop-tauri/src/types/bridge.ts
index 157b134aae..bb87f1fe05 100644
--- a/apps/desktop-tauri/src/types/bridge.ts
+++ b/apps/desktop-tauri/src/types/bridge.ts
@@ -224,6 +224,7 @@ export interface SettingsSnapshot {
   enabledProviders: string[];
   providerOrder?: string[];
   refreshIntervalSecs: number;
+  adaptiveRefresh: boolean;
   refreshAllProvidersOnMenuOpen: boolean;
   startAtLogin: boolean;
   startMinimized: boolean;
@@ -291,6 +292,7 @@ export interface SettingsSnapshot {
 export interface SettingsUpdate {
   enabledProviders?: string[];
   refreshIntervalSecs?: number;
+  adaptiveRefresh?: boolean;
   refreshAllProvidersOnMenuOpen?: boolean;
   startAtLogin?: boolean;
   startMinimized?: boolean;
diff --git a/rust/src/cli/diagnose.rs b/rust/src/cli/diagnose.rs
index f0e1f9cb1e..a126f68309 100644
--- a/rust/src/cli/diagnose.rs
+++ b/rust/src/cli/diagnose.rs
@@ -181,6 +181,7 @@ async fn collect_provider_diagnostic(
         gateway_url: settings
             .provider_config(provider_id)
             .and_then(|config| config.gateway_url.clone()),
+        auto_prefer_web: false,
     };
 
     let fetch_result = provider.fetch_usage(&ctx).await;
diff --git a/rust/src/cli/guard.rs b/rust/src/cli/guard.rs
index f37fc49582..ce29772d78 100644
--- a/rust/src/cli/guard.rs
+++ b/rust/src/cli/guard.rs
@@ -314,6 +314,7 @@ async fn fetch_guard_outcome(
         workspace_id: None,
         api_region: None,
         gateway_url: None,
+        auto_prefer_web: false,
     };
 
     match provider.fetch_usage(&ctx).await {
@@ -324,9 +325,7 @@ async fn fetch_guard_outcome(
             };
             match guard_remaining_headroom(rate_window) {
                 Some(remaining) => GuardFetchOutcome::Available(remaining),
-                None => {
-                    GuardFetchOutcome::Unavailable(GuardUnavailableReason::WindowUnavailable)
-                }
+                None => GuardFetchOutcome::Unavailable(GuardUnavailableReason::WindowUnavailable),
             }
         }
         Err(_) => GuardFetchOutcome::Unavailable(GuardUnavailableReason::FetchFailed),
@@ -514,7 +513,10 @@ mod tests {
 
     #[test]
     fn known_provider_accepted() {
-        assert_eq!(resolve_guard_provider("claude").unwrap(), ProviderId::Claude);
+        assert_eq!(
+            resolve_guard_provider("claude").unwrap(),
+            ProviderId::Claude
+        );
         assert_eq!(resolve_guard_provider("codex").unwrap(), ProviderId::Codex);
     }
 
diff --git a/rust/src/cli/serve.rs b/rust/src/cli/serve.rs
index 84cedbf4b9..588e3de0f5 100644
--- a/rust/src/cli/serve.rs
+++ b/rust/src/cli/serve.rs
@@ -276,6 +276,7 @@ async fn usage_response(provider: Option<&str>) -> String {
         workspace_id: None,
         api_region: None,
         gateway_url: None,
+        auto_prefer_web: false,
     };
 
     let mut results = Vec::new();
diff --git a/rust/src/cli/usage.rs b/rust/src/cli/usage.rs
index 1d787f61f6..845b0b15a1 100755
--- a/rust/src/cli/usage.rs
+++ b/rust/src/cli/usage.rs
@@ -216,6 +216,7 @@ fn build_usage_fetch_context(args: &UsageArgs, source_mode: SourceMode) -> Fetch
         workspace_id: None,
         api_region: None,
         gateway_url: None,
+        auto_prefer_web: false,
     }
 }
 
@@ -312,10 +313,7 @@ fn resolve_cli_api_key(
             find_token_account(&data, account_ref)?
         } else {
             data.active_account().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "No active token account for {}",
-                    provider_id.display_name()
-                )
+                anyhow::anyhow!("No active token account for {}", provider_id.display_name())
             })?
         };
         if let Some(env) = TokenAccountSupport::env_override(provider_id, &account.token)
diff --git a/rust/src/core/adaptive_refresh.rs b/rust/src/core/adaptive_refresh.rs
new file mode 100644
index 0000000000..85da81679b
--- /dev/null
+++ b/rust/src/core/adaptive_refresh.rs
@@ -0,0 +1,226 @@
+//! Adaptive refresh decision table (upstream AdaptiveRefreshPolicyCore).
+//!
+//! Pure policy — platform adapters supply thermal / low-power / activity inputs.
+
+use std::time::Duration;
+
+/// Thermal pressure signal after platform normalization.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ThermalPressure {
+    Nominal,
+    Constrained,
+}
+
+/// Why a given delay was chosen.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AdaptiveRefreshReason {
+    RecentInteraction,
+    CodingActivity,
+    Warm,
+    Idle,
+    LongIdle,
+    Constrained,
+}
+
+/// Inputs for one adaptive-refresh decision.
+#[derive(Debug, Clone, Copy)]
+pub struct AdaptiveRefreshInput {
+    /// Age of the last menu/panel open, if known.
+    pub last_menu_open_age: Option<Duration>,
+    /// Age of the last coding-activity signal, if known.
+    pub last_coding_activity_age: Option<Duration>,
+    pub low_power_mode_enabled: bool,
+    pub thermal_pressure: ThermalPressure,
+}
+
+/// Result of the decision table.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AdaptiveRefreshDecision {
+    pub delay: Duration,
+    pub reason: AdaptiveRefreshReason,
+}
+
+const RECENT_INTERACTION_THRESHOLD: Duration = Duration::from_secs(5 * 60);
+const WARM_THRESHOLD: Duration = Duration::from_secs(60 * 60);
+const IDLE_THRESHOLD: Duration = Duration::from_secs(4 * 60 * 60);
+const CODING_ACTIVITY_THRESHOLD: Duration = Duration::from_secs(5 * 60);
+
+const RECENT_INTERACTION_DELAY: Duration = Duration::from_secs(2 * 60);
+const WARM_DELAY: Duration = Duration::from_secs(5 * 60);
+const IDLE_DELAY: Duration = Duration::from_secs(15 * 60);
+const LONG_IDLE_DELAY: Duration = Duration::from_secs(30 * 60);
+const CONSTRAINED_DELAY: Duration = Duration::from_secs(30 * 60);
+const CODING_ACTIVITY_DELAY_CAP: Duration = Duration::from_secs(5 * 60);
+
+/// Representative cadence for consumers that need one interval but cannot access live state.
+pub const NOMINAL_INTERVAL_FOR_HEURISTICS: Duration = Duration::from_secs(5 * 60);
+
+/// Compute the next adaptive refresh delay from activity / power inputs.
+pub fn next_delay(input: AdaptiveRefreshInput) -> AdaptiveRefreshDecision {
+    if input.low_power_mode_enabled || input.thermal_pressure == ThermalPressure::Constrained {
+        return AdaptiveRefreshDecision {
+            delay: CONSTRAINED_DELAY,
+            reason: AdaptiveRefreshReason::Constrained,
+        };
+    }
+
+    let base = menu_activity_decision(input.last_menu_open_age);
+    if let Some(age) = input.last_coding_activity_age
+        && age < CODING_ACTIVITY_THRESHOLD
+        && base.delay > CODING_ACTIVITY_DELAY_CAP
+    {
+        return AdaptiveRefreshDecision {
+            delay: CODING_ACTIVITY_DELAY_CAP,
+            reason: AdaptiveRefreshReason::CodingActivity,
+        };
+    }
+    base
+}
+
+fn menu_activity_decision(last_menu_open_age: Option<Duration>) -> AdaptiveRefreshDecision {
+    let Some(age) = last_menu_open_age else {
+        return AdaptiveRefreshDecision {
+            delay: LONG_IDLE_DELAY,
+            reason: AdaptiveRefreshReason::LongIdle,
+        };
+    };
+
+    if age <= RECENT_INTERACTION_THRESHOLD {
+        return AdaptiveRefreshDecision {
+            delay: RECENT_INTERACTION_DELAY,
+            reason: AdaptiveRefreshReason::RecentInteraction,
+        };
+    }
+    if age <= WARM_THRESHOLD {
+        return AdaptiveRefreshDecision {
+            delay: WARM_DELAY,
+            reason: AdaptiveRefreshReason::Warm,
+        };
+    }
+    if age < IDLE_THRESHOLD {
+        return AdaptiveRefreshDecision {
+            delay: IDLE_DELAY,
+            reason: AdaptiveRefreshReason::Idle,
+        };
+    }
+    AdaptiveRefreshDecision {
+        delay: LONG_IDLE_DELAY,
+        reason: AdaptiveRefreshReason::LongIdle,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn input(
+        menu_age: Option<Duration>,
+        coding_age: Option<Duration>,
+        low_power: bool,
+        thermal: ThermalPressure,
+    ) -> AdaptiveRefreshInput {
+        AdaptiveRefreshInput {
+            last_menu_open_age: menu_age,
+            last_coding_activity_age: coding_age,
+            low_power_mode_enabled: low_power,
+            thermal_pressure: thermal,
+        }
+    }
+
+    #[test]
+    fn constrained_or_low_power_is_30m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(10)),
+            None,
+            true,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(30 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::Constrained);
+
+        let d = next_delay(input(
+            Some(Duration::from_secs(10)),
+            None,
+            false,
+            ThermalPressure::Constrained,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(30 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::Constrained);
+    }
+
+    #[test]
+    fn recent_menu_open_is_2m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(4 * 60)),
+            None,
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(2 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::RecentInteraction);
+    }
+
+    #[test]
+    fn warm_is_5m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(30 * 60)),
+            None,
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(5 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::Warm);
+    }
+
+    #[test]
+    fn idle_under_4h_is_15m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(2 * 60 * 60)),
+            None,
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(15 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::Idle);
+    }
+
+    #[test]
+    fn long_idle_is_30m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(5 * 60 * 60)),
+            None,
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(30 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::LongIdle);
+
+        let d = next_delay(input(None, None, false, ThermalPressure::Nominal));
+        assert_eq!(d.delay, Duration::from_secs(30 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::LongIdle);
+    }
+
+    #[test]
+    fn coding_activity_caps_long_idle_at_5m() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(5 * 60 * 60)),
+            Some(Duration::from_secs(60)),
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(5 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::CodingActivity);
+    }
+
+    #[test]
+    fn coding_activity_does_not_raise_recent_delay() {
+        let d = next_delay(input(
+            Some(Duration::from_secs(30)),
+            Some(Duration::from_secs(10)),
+            false,
+            ThermalPressure::Nominal,
+        ));
+        assert_eq!(d.delay, Duration::from_secs(2 * 60));
+        assert_eq!(d.reason, AdaptiveRefreshReason::RecentInteraction);
+    }
+}
diff --git a/rust/src/core/mod.rs b/rust/src/core/mod.rs
index eacd95d1db..d41aac2636 100755
--- a/rust/src/core/mod.rs
+++ b/rust/src/core/mod.rs
@@ -1,5 +1,6 @@
 //! Core data models and traits
 
+mod adaptive_refresh;
 mod cost_pricing;
 mod credential_migration;
 mod hooks;
@@ -17,6 +18,7 @@ mod usage_pace;
 mod usage_snapshot;
 mod widget_snapshot;
 
+pub use adaptive_refresh::*;
 pub use cost_pricing::*;
 pub use credential_migration::*;
 pub use hooks::*;
diff --git a/rust/src/core/provider.rs b/rust/src/core/provider.rs
index 1b62296fa8..c9ef43db64 100755
--- a/rust/src/core/provider.rs
+++ b/rust/src/core/provider.rs
@@ -563,6 +563,10 @@ pub struct FetchContext {
 
     /// Optional provider gateway URL, used by local gateway-backed providers.
     pub gateway_url: Option<String>,
+
+    /// When true, Auto mode prefers web before local (token-account scope,
+    /// manual cookie source, etc.). Workspace overrides are checked separately.
+    pub auto_prefer_web: bool,
 }
 
 impl Default for FetchContext {
@@ -577,6 +581,7 @@ impl Default for FetchContext {
             workspace_id: None,
             api_region: None,
             gateway_url: None,
+            auto_prefer_web: false,
         }
     }
 }
diff --git a/rust/src/cost_scanner.rs b/rust/src/cost_scanner.rs
index 881f8492d8..4cb616231b 100755
--- a/rust/src/cost_scanner.rs
+++ b/rust/src/cost_scanner.rs
@@ -445,21 +445,52 @@ where
     };
 
     let mut counted = 0;
-    for line in BufReader::new(file).lines().map_while(Result::ok) {
+    // Use read_until so a final incomplete line (no trailing newline) is still
+    // processed when it is valid UTF-8 JSON, and so a single bad line does not
+    // stop the walk the way `lines().map_while(Result::ok)` would.
+    for_each_jsonl_text_line(BufReader::new(file), |line| {
         if is_cancelled(cancel) {
-            break;
+            return false;
         }
-        if let Ok(event) = serde_json::from_str::<ClaudeEvent>(&line)
+        if let Ok(event) = serde_json::from_str::<ClaudeEvent>(line)
             && let Some(record) = claude_usage_record_from_event(&event)
             && should_count_claude_record(&record, cutoff, seen)
         {
             counted += 1;
             on_record(&record);
         }
-    }
+        true
+    });
     counted
 }
 
+/// Walk JSONL text lines from `reader`, including a final incomplete line at EOF.
+/// Continues past invalid UTF-8 segments. `on_line` returns `false` to stop early.
+fn for_each_jsonl_text_line<R, F>(mut reader: R, mut on_line: F)
+where
+    R: BufRead,
+    F: FnMut(&str) -> bool,
+{
+    let mut buf = Vec::new();
+    loop {
+        buf.clear();
+        match reader.read_until(b'\n', &mut buf) {
+            Ok(0) => break,
+            Ok(_) => {}
+            Err(_) => break,
+        }
+        while matches!(buf.last(), Some(b'\n' | b'\r')) {
+            buf.pop();
+        }
+        let Ok(line) = std::str::from_utf8(&buf) else {
+            continue;
+        };
+        if !on_line(line) {
+            break;
+        }
+    }
+}
+
 fn claude_usage_record_from_event(event: &ClaudeEvent) -> Option<ClaudeUsageRecord> {
     if event.event_type.as_deref() != Some("assistant") {
         return None;
@@ -957,4 +988,22 @@ mod tests {
         let _ = std::fs::remove_file(&file_a);
         let _ = std::fs::remove_file(&file_b);
     }
+
+    #[test]
+    fn claude_scan_counts_final_incomplete_jsonl_line() {
+        let path =
+            std::env::temp_dir().join(format!("codexbar-claude-tail-{}.jsonl", std::process::id()));
+        let ts = (Utc::now() - Duration::hours(1))
+            .format("%Y-%m-%dT%H:%M:%S%.3fZ")
+            .to_string();
+        // No trailing newline — the last (only) record must still be counted.
+        let body = claude_transcript_line(&ts, "requestId", "req_tail", "msg_tail");
+        std::fs::write(&path, body.as_bytes()).unwrap();
+
+        let cutoff = Utc::now() - Duration::days(1);
+        let mut seen = HashSet::new();
+        let counted = for_each_claude_usage_record(&path, &cutoff, &mut seen, None, |_| {});
+        assert_eq!(counted, 1, "incomplete final JSONL line must be processed");
+        let _ = std::fs::remove_file(&path);
+    }
 }
diff --git a/rust/src/locale.rs b/rust/src/locale.rs
index 14b6f7fa60..0f89d082a9 100644
--- a/rust/src/locale.rs
+++ b/rust/src/locale.rs
@@ -926,6 +926,7 @@ locale_keys! {
 
     // Tauri desktop shell — Refresh interval + provider display names
     RefreshIntervalManual,
+    RefreshIntervalAdaptive,
     RefreshInterval15Min,
     RefreshInterval30Min,
     RefreshInterval1Hour,
diff --git a/rust/src/locale/en-US.ftl b/rust/src/locale/en-US.ftl
index 5decb53f8f..775e8c552f 100644
--- a/rust/src/locale/en-US.ftl
+++ b/rust/src/locale/en-US.ftl
@@ -652,6 +652,7 @@ BootstrapFailed = Bootstrap failed
 LoadingShellContract = Loading shell contract…
 LoadingShellContractHint = Waiting for the Rust bridge to describe providers, surfaces, and settings.
 RefreshIntervalManual = Manual
+RefreshIntervalAdaptive = Adaptive
 RefreshInterval15Min = 15 minutes
 RefreshInterval30Min = 30 minutes
 RefreshInterval1Hour = 1 hour
diff --git a/rust/src/locale/es-MX.ftl b/rust/src/locale/es-MX.ftl
index 8f5cbbae2f..621ecf4559 100644
--- a/rust/src/locale/es-MX.ftl
+++ b/rust/src/locale/es-MX.ftl
@@ -365,6 +365,11 @@ SectionSavedAccounts = Cuentas guardadas
 SectionAddAccount = Agregar cuenta
 RefreshIntervalLabel = Intervalo de actualización
 RefreshIntervalHelper = Segundos entre actualizaciones automáticas de proveedores (0 = manual).
+RefreshIntervalAdaptive = Adaptativo
+RefreshIntervalManual = Manual
+RefreshInterval15Min = 15 minutos
+RefreshInterval30Min = 30 minutos
+RefreshInterval1Hour = 1 hora
 RefreshAllProvidersOnMenuOpen = Actualizar al abrir el menú
 RefreshAllProvidersOnMenuOpenHelper = Fuerza la actualización de proveedores habilitados cada vez que se abre el menú de bandeja.
 SoundVolumeHelper = Volumen para sonidos de alerta de umbral (0–100).
diff --git a/rust/src/locale/ja-JP.ftl b/rust/src/locale/ja-JP.ftl
index 8bb1efc103..768e9e48a6 100644
--- a/rust/src/locale/ja-JP.ftl
+++ b/rust/src/locale/ja-JP.ftl
@@ -674,6 +674,7 @@ RefreshInterval15Min = 15分
 RefreshInterval1Hour = 1時間
 RefreshInterval30Min = 30分
 RefreshIntervalManual = 手動
+RefreshIntervalAdaptive = アダプティブ
 SavedCookiesHint = ブラウザー認証を使用するプロバイダー向けの手動 Cookie 設定です。Cookie の自動抽出を利用できない場合に使用されます。
 SettingsWindowTitle = CodexBar 設定
 StackedBarChartAriaLabel = 積み上げ棒グラフ
diff --git a/rust/src/locale/ko-KR.ftl b/rust/src/locale/ko-KR.ftl
index b00a29efc9..1670faf3f1 100644
--- a/rust/src/locale/ko-KR.ftl
+++ b/rust/src/locale/ko-KR.ftl
@@ -365,6 +365,11 @@ SectionSavedAccounts = 저장된 계정
 SectionAddAccount = 계정 추가
 RefreshIntervalLabel = 새로고침 간격
 RefreshIntervalHelper = 제공업체 자동 새로고침 간격(초) (0으로 설정 시 수동 새로고침).
+RefreshIntervalAdaptive = 적응형
+RefreshIntervalManual = 수동
+RefreshInterval15Min = 15분
+RefreshInterval30Min = 30분
+RefreshInterval1Hour = 1시간
 RefreshAllProvidersOnMenuOpen = 메뉴를 열 때 새로고침
 RefreshAllProvidersOnMenuOpenHelper = 트레이 메뉴를 열 때마다 활성화된 제공업체를 강제로 새로고침합니다.
 SoundVolumeHelper = 임계값 경고 소리 볼륨 (0~100).
diff --git a/rust/src/locale/zh-CN.ftl b/rust/src/locale/zh-CN.ftl
index 3ed674d2e5..5572798ebb 100644
--- a/rust/src/locale/zh-CN.ftl
+++ b/rust/src/locale/zh-CN.ftl
@@ -652,6 +652,7 @@ BootstrapFailed = 引导失败
 LoadingShellContract = 正在加载外壳协议…
 LoadingShellContractHint = 正在等待 Rust 桥接描述服务商、界面和设置。
 RefreshIntervalManual = 手动
+RefreshIntervalAdaptive = 自适应
 RefreshInterval15Min = 15 分钟
 RefreshInterval30Min = 30 分钟
 RefreshInterval1Hour = 1 小时
diff --git a/rust/src/locale/zh-TW.ftl b/rust/src/locale/zh-TW.ftl
index c914265151..3f95e423a5 100644
--- a/rust/src/locale/zh-TW.ftl
+++ b/rust/src/locale/zh-TW.ftl
@@ -652,6 +652,7 @@ BootstrapFailed = 引導失敗
 LoadingShellContract = 正在載入外殼協定…
 LoadingShellContractHint = 正在等待 Rust 橋接描述提供者、介面和設定。
 RefreshIntervalManual = 手動
+RefreshIntervalAdaptive = 自適應
 RefreshInterval15Min = 15 分鐘
 RefreshInterval30Min = 30 分鐘
 RefreshInterval1Hour = 1 小時
diff --git a/rust/src/providers/opencodego/local.rs b/rust/src/providers/opencodego/local.rs
new file mode 100644
index 0000000000..01d99a3f35
--- /dev/null
+++ b/rust/src/providers/opencodego/local.rs
@@ -0,0 +1,538 @@
+//! OpenCode Go local usage reader (SQLite).
+//!
+//! Mirrors upstream `OpenCodeGoLocalUsageReader`: sums `opencode-go` assistant
+//! message / step-finish costs from the local OpenCode database and maps them
+//! onto session ($12 / 5h), weekly ($30), and monthly ($60) windows.
+
+use chrono::{DateTime, Datelike, Duration, NaiveDate, TimeZone, Timelike, Utc};
+use rusqlite::{Connection, OpenFlags};
+use std::path::{Path, PathBuf};
+
+use crate::core::{ProviderError, ProviderFetchResult, RateWindow, UsageSnapshot};
+
+const FIVE_HOURS_MS: i64 = 5 * 60 * 60 * 1000;
+const WEEK_MS: i64 = 7 * 24 * 60 * 60 * 1000;
+const SESSION_LIMIT_USD: f64 = 12.0;
+const WEEKLY_LIMIT_USD: f64 = 30.0;
+const MONTHLY_LIMIT_USD: f64 = 60.0;
+const PROVIDER_ID: &str = "opencode-go";
+
+const MESSAGE_USAGE_SQL: &str = r#"
+SELECT
+  CAST(COALESCE(json_extract(data, '$.time.created'), time_created) AS INTEGER) AS createdMs,
+  CAST(json_extract(data, '$.cost') AS REAL) AS cost
+FROM message
+WHERE json_valid(data)
+  AND json_extract(data, '$.providerID') = 'opencode-go'
+  AND json_extract(data, '$.role') = 'assistant'
+  AND json_type(data, '$.cost') IN ('integer', 'real')
+"#;
+
+const MESSAGE_AND_PART_USAGE_SQL: &str = r#"
+WITH provider_messages AS (
+  SELECT
+    id AS messageID,
+    CAST(COALESCE(json_extract(data, '$.time.created'), time_created) AS INTEGER) AS createdMs,
+    CAST(json_extract(data, '$.cost') AS REAL) AS cost,
+    json_type(data, '$.cost') IN ('integer', 'real') AS hasCost
+  FROM message
+  WHERE json_valid(data)
+    AND json_extract(data, '$.providerID') = 'opencode-go'
+    AND json_extract(data, '$.role') = 'assistant'
+)
+SELECT
+  CAST(COALESCE(json_extract(p.data, '$.time.created'), p.time_created, m.createdMs) AS INTEGER)
+    AS createdMs,
+  CAST(json_extract(p.data, '$.cost') AS REAL) AS cost
+FROM part p
+JOIN provider_messages m ON m.messageID = p.message_id
+WHERE json_valid(p.data)
+  AND json_extract(p.data, '$.type') = 'step-finish'
+  AND json_type(p.data, '$.cost') IN ('integer', 'real')
+UNION ALL
+SELECT createdMs, cost
+FROM provider_messages m
+WHERE hasCost
+  AND NOT EXISTS (
+    SELECT 1
+    FROM part p
+    WHERE p.message_id = m.messageID
+      AND json_valid(p.data)
+      AND json_extract(p.data, '$.type') = 'step-finish'
+      AND json_type(p.data, '$.cost') IN ('integer', 'real')
+  )
+"#;
+
+#[derive(Debug, Clone, Copy)]
+struct UsageRow {
+    created_ms: i64,
+    cost: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct LocalUsageSnapshot {
+    pub rolling_usage_percent: f64,
+    pub weekly_usage_percent: f64,
+    pub monthly_usage_percent: f64,
+    pub rolling_reset_in_sec: i64,
+    pub weekly_reset_in_sec: i64,
+    pub monthly_reset_in_sec: i64,
+}
+
+impl LocalUsageSnapshot {
+    pub fn to_fetch_result(&self) -> ProviderFetchResult {
+        let now = Utc::now();
+        let primary = RateWindow::with_details(
+            self.rolling_usage_percent,
+            Some(300),
+            Some(now + Duration::seconds(self.rolling_reset_in_sec)),
+            None,
+        );
+        let mut snap = UsageSnapshot::new(primary).with_login_method("OpenCode Go");
+        snap = snap.with_secondary(RateWindow::with_details(
+            self.weekly_usage_percent,
+            Some(10080),
+            Some(now + Duration::seconds(self.weekly_reset_in_sec)),
+            None,
+        ));
+        snap = snap.with_tertiary(RateWindow::with_details(
+            self.monthly_usage_percent,
+            Some(43200),
+            Some(now + Duration::seconds(self.monthly_reset_in_sec)),
+            None,
+        ));
+        ProviderFetchResult::new(snap, "local")
+    }
+}
+
+/// Candidate (auth.json, opencode.db) pairs for local OpenCode installs.
+pub fn candidate_paths() -> Vec<(PathBuf, PathBuf)> {
+    let mut out = Vec::new();
+
+    if let Ok(home) = std::env::var("USERPROFILE").or_else(|_| std::env::var("HOME")) {
+        let base = PathBuf::from(home)
+            .join(".local")
+            .join("share")
+            .join("opencode");
+        out.push((base.join("auth.json"), base.join("opencode.db")));
+    }
+
+    if let Ok(local) = std::env::var("LOCALAPPDATA") {
+        let base = PathBuf::from(local).join("opencode");
+        out.push((base.join("auth.json"), base.join("opencode.db")));
+    }
+
+    if let Some(home) = dirs::home_dir() {
+        let base = home.join(".local").join("share").join("opencode");
+        let pair = (base.join("auth.json"), base.join("opencode.db"));
+        if !out.iter().any(|existing| existing.1 == pair.1) {
+            out.push(pair);
+        }
+    }
+
+    out
+}
+
+pub fn fetch_local_usage(now: DateTime<Utc>) -> Result<LocalUsageSnapshot, ProviderError> {
+    let mut last_err: Option<ProviderError> = None;
+    for (auth, db) in candidate_paths() {
+        match fetch_from_paths(&auth, &db, now) {
+            Ok(snap) => return Ok(snap),
+            Err(e) => last_err = Some(e),
+        }
+    }
+    Err(last_err.unwrap_or_else(|| {
+        ProviderError::NotInstalled(
+            "OpenCode Go not detected. Log in with OpenCode Go or use it locally first.".into(),
+        )
+    }))
+}
+
+pub fn fetch_from_paths(
+    auth_path: &Path,
+    db_path: &Path,
+    now: DateTime<Utc>,
+) -> Result<LocalUsageSnapshot, ProviderError> {
+    let has_auth = has_auth_key(auth_path);
+    if !db_path.exists() {
+        return Err(if has_auth {
+            ProviderError::Other(
+                "OpenCode Go local usage history is unavailable: database not found".into(),
+            )
+        } else {
+            ProviderError::NotInstalled(
+                "OpenCode Go not detected. Log in with OpenCode Go or use it locally first.".into(),
+            )
+        });
+    }
+
+    let rows = read_rows(db_path)?;
+    if !has_auth && rows.is_empty() {
+        return Err(ProviderError::NotInstalled(
+            "OpenCode Go not detected. Log in with OpenCode Go or use it locally first.".into(),
+        ));
+    }
+    if rows.is_empty() {
+        return Err(ProviderError::Other(
+            "OpenCode Go local usage history is unavailable: no local usage rows".into(),
+        ));
+    }
+
+    Ok(snapshot_from_rows(&rows, now))
+}
+
+fn has_auth_key(path: &Path) -> bool {
+    let Ok(text) = std::fs::read_to_string(path) else {
+        return false;
+    };
+    let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) else {
+        return false;
+    };
+    value
+        .get(PROVIDER_ID)
+        .and_then(|entry| entry.get("key"))
+        .and_then(|key| key.as_str())
+        .is_some_and(|key| !key.trim().is_empty())
+}
+
+fn read_rows(db_path: &Path) -> Result<Vec<UsageRow>, ProviderError> {
+    let conn =
+        Connection::open_with_flags(db_path, OpenFlags::SQLITE_OPEN_READ_ONLY).map_err(|e| {
+            ProviderError::Other(format!("SQLite error reading OpenCode Go usage: {e}"))
+        })?;
+    conn.busy_timeout(std::time::Duration::from_millis(250))
+        .map_err(|e| {
+            ProviderError::Other(format!("SQLite error reading OpenCode Go usage: {e}"))
+        })?;
+
+    let sql = if has_table(&conn, "part") {
+        MESSAGE_AND_PART_USAGE_SQL
+    } else {
+        MESSAGE_USAGE_SQL
+    };
+
+    let mut stmt = conn.prepare(sql).map_err(|e| {
+        ProviderError::Other(format!("SQLite error reading OpenCode Go usage: {e}"))
+    })?;
+    let rows = stmt
+        .query_map([], |row| {
+            Ok(UsageRow {
+                created_ms: row.get::<_, i64>(0)?,
+                cost: row.get::<_, f64>(1)?,
+            })
+        })
+        .map_err(|e| {
+            ProviderError::Other(format!("SQLite error reading OpenCode Go usage: {e}"))
+        })?;
+
+    let mut out = Vec::new();
+    for row in rows {
+        let row = row.map_err(|e| {
+            ProviderError::Other(format!("SQLite error reading OpenCode Go usage: {e}"))
+        })?;
+        if row.created_ms > 0 && row.cost.is_finite() && row.cost >= 0.0 {
+            out.push(row);
+        }
+    }
+    Ok(out)
+}
+
+fn has_table(conn: &Connection, name: &str) -> bool {
+    conn.query_row(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?1 LIMIT 1",
+        [name],
+        |_| Ok(()),
+    )
+    .is_ok()
+}
+
+fn snapshot_from_rows(rows: &[UsageRow], now: DateTime<Utc>) -> LocalUsageSnapshot {
+    let now_ms = now.timestamp_millis();
+    let session_start = now_ms - FIVE_HOURS_MS;
+    let week_start_ms = start_of_utc_iso_week_ms(now);
+    let week_end_ms = week_start_ms + WEEK_MS;
+    let earliest_ms = rows.iter().map(|r| r.created_ms).min();
+    let (month_start_ms, month_end_ms) = month_bounds_ms(now, earliest_ms);
+
+    let mut session_cost = 0.0;
+    let mut weekly_cost = 0.0;
+    let mut monthly_cost = 0.0;
+    let mut oldest_session_ms: Option<i64> = None;
+
+    for row in rows {
+        if row.created_ms >= session_start && row.created_ms < now_ms {
+            session_cost += row.cost;
+            oldest_session_ms = Some(match oldest_session_ms {
+                Some(prev) => prev.min(row.created_ms),
+                None => row.created_ms,
+            });
+        }
+        if row.created_ms >= week_start_ms && row.created_ms < week_end_ms {
+            weekly_cost += row.cost;
+        }
+        if row.created_ms >= month_start_ms && row.created_ms < month_end_ms {
+            monthly_cost += row.cost;
+        }
+    }
+
+    let oldest = oldest_session_ms.unwrap_or(now_ms);
+    let rolling_reset_in_sec = ((oldest + FIVE_HOURS_MS - now_ms) / 1000).max(0);
+
+    LocalUsageSnapshot {
+        rolling_usage_percent: percent(session_cost, SESSION_LIMIT_USD),
+        weekly_usage_percent: percent(weekly_cost, WEEKLY_LIMIT_USD),
+        monthly_usage_percent: percent(monthly_cost, MONTHLY_LIMIT_USD),
+        rolling_reset_in_sec,
+        weekly_reset_in_sec: ((week_end_ms - now_ms) / 1000).max(0),
+        monthly_reset_in_sec: ((month_end_ms - now_ms) / 1000).max(0),
+    }
+}
+
+fn percent(used: f64, limit: f64) -> f64 {
+    if !used.is_finite() || limit <= 0.0 {
+        return 0.0;
+    }
+    let value = (used / limit * 100.0).clamp(0.0, 100.0);
+    (value * 10.0).round() / 10.0
+}
+
+/// ISO week start (Monday 00:00 UTC), matching upstream calendar settings.
+fn start_of_utc_iso_week_ms(now: DateTime<Utc>) -> i64 {
+    let date = now.date_naive();
+    let days_from_monday = date.weekday().num_days_from_monday() as i64;
+    let monday = date - Duration::days(days_from_monday);
+    Utc.from_utc_datetime(&monday.and_hms_opt(0, 0, 0).unwrap_or_default())
+        .timestamp_millis()
+}
+
+fn month_bounds_ms(now: DateTime<Utc>, anchor_ms: Option<i64>) -> (i64, i64) {
+    let Some(anchor_ms) = anchor_ms else {
+        let start = NaiveDate::from_ymd_opt(now.year(), now.month(), 1)
+            .unwrap_or_else(|| now.date_naive())
+            .and_hms_opt(0, 0, 0)
+            .unwrap_or_default();
+        let start_dt = Utc.from_utc_datetime(&start);
+        let end_dt = if now.month() == 12 {
+            Utc.with_ymd_and_hms(now.year() + 1, 1, 1, 0, 0, 0)
+                .single()
+                .unwrap_or(start_dt)
+        } else {
+            Utc.with_ymd_and_hms(now.year(), now.month() + 1, 1, 0, 0, 0)
+                .single()
+                .unwrap_or(start_dt)
+        };
+        return (start_dt.timestamp_millis(), end_dt.timestamp_millis());
+    };
+
+    let anchor = DateTime::<Utc>::from_timestamp_millis(anchor_ms).unwrap_or(now);
+    let mut year = now.year();
+    let mut month = now.month();
+    let mut start = anchored_month(year, month, &anchor);
+    if start > now {
+        if month == 1 {
+            year -= 1;
+            month = 12;
+        } else {
+            month -= 1;
+        }
+        start = anchored_month(year, month, &anchor);
+    }
+    let (end_year, end_month) = if month == 12 {
+        (year + 1, 1)
+    } else {
+        (year, month + 1)
+    };
+    let end = anchored_month(end_year, end_month, &anchor);
+    (start.timestamp_millis(), end.timestamp_millis())
+}
+
+fn anchored_month(year: i32, month: u32, anchor: &DateTime<Utc>) -> DateTime<Utc> {
+    let day = anchor.day();
+    let (hour, min, sec, nano) = (
+        anchor.hour(),
+        anchor.minute(),
+        anchor.second(),
+        anchor.nanosecond(),
+    );
+    if let Some(date) = NaiveDate::from_ymd_opt(year, month, day)
+        && let Some(ndt) = date.and_hms_nano_opt(hour, min, sec, nano)
+    {
+        return Utc.from_utc_datetime(&ndt);
+    }
+    // Clamp to last day of month when anchor day overflows (e.g. 31 → Feb).
+    let last_day = NaiveDate::from_ymd_opt(year, month, 1)
+        .map(|d| {
+            if month == 12 {
+                NaiveDate::from_ymd_opt(year + 1, 1, 1)
+            } else {
+                NaiveDate::from_ymd_opt(year, month + 1, 1)
+            }
+            .unwrap_or(d)
+                - Duration::days(1)
+        })
+        .map(|d| d.day())
+        .unwrap_or(28);
+    let date = NaiveDate::from_ymd_opt(year, month, last_day).unwrap_or_else(|| {
+        NaiveDate::from_ymd_opt(year, month, 1).unwrap_or_else(|| Utc::now().date_naive())
+    });
+    let ndt = date
+        .and_hms_nano_opt(hour, min, sec, nano)
+        .or_else(|| date.and_hms_opt(0, 0, 0))
+        .unwrap_or_default();
+    Utc.from_utc_datetime(&ndt)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Weekday;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_db_path(label: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_nanos())
+            .unwrap_or(0);
+        std::env::temp_dir().join(format!("opencodego-local-{label}-{nanos}.db"))
+    }
+
+    fn write_message_db(path: &Path, rows: &[(i64, f64)]) {
+        let conn = Connection::open(path).unwrap();
+        conn.execute_batch(
+            "CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                data TEXT,
+                time_created INTEGER
+            );",
+        )
+        .unwrap();
+        for (i, (created_ms, cost)) in rows.iter().enumerate() {
+            let data = format!(
+                r#"{{"providerID":"opencode-go","role":"assistant","cost":{cost},"time":{{"created":{created_ms}}}}}"#
+            );
+            conn.execute(
+                "INSERT INTO message (id, data, time_created) VALUES (?1, ?2, ?3)",
+                rusqlite::params![format!("m{i}"), data, created_ms],
+            )
+            .unwrap();
+        }
+    }
+
+    #[test]
+    fn not_detected_without_db_or_auth() {
+        let dir = std::env::temp_dir().join(format!(
+            "opencodego-missing-{}",
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .map(|d| d.as_nanos())
+                .unwrap_or(0)
+        ));
+        let _ = std::fs::create_dir_all(&dir);
+        let auth = dir.join("auth.json");
+        let db = dir.join("opencode.db");
+        let err = fetch_from_paths(&auth, &db, Utc::now()).unwrap_err();
+        assert!(matches!(err, ProviderError::NotInstalled(_)));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn sums_session_weekly_monthly_costs() {
+        let db = temp_db_path("sums");
+        let now = Utc.with_ymd_and_hms(2026, 3, 18, 12, 0, 0).unwrap(); // Wednesday
+        let now_ms = now.timestamp_millis();
+        // $6 in the rolling 5h window → 50% of $12
+        // $15 in ISO week → 50% of $30
+        // $30 in anchored month → 50% of $60
+        let session_ms = now_ms - 60_000;
+        let week_ms = start_of_utc_iso_week_ms(now) + 3_600_000;
+        let month_anchor_ms = now_ms - 10 * 24 * 60 * 60 * 1000;
+        write_message_db(
+            &db,
+            &[
+                (session_ms, 6.0),
+                (week_ms, 9.0), // plus session = 15 in week if session also in week
+                (month_anchor_ms, 15.0),
+            ],
+        );
+
+        // auth present so empty-rows path is not used; auth not required when rows exist
+        let auth = db.with_extension("auth.json");
+        let _ = std::fs::write(&auth, r#"{"opencode-go":{"key":"test-key"}}"#);
+
+        let snap = fetch_from_paths(&auth, &db, now).unwrap();
+        assert!((snap.rolling_usage_percent - 50.0).abs() < 0.05, "{snap:?}");
+        // session 6 + week-only 9 = 15 → 50%
+        assert!((snap.weekly_usage_percent - 50.0).abs() < 0.05, "{snap:?}");
+        // session 6 + week 9 + month 15 = 30 → 50%
+        assert!((snap.monthly_usage_percent - 50.0).abs() < 0.05, "{snap:?}");
+
+        let _ = std::fs::remove_file(&db);
+        let _ = std::fs::remove_file(&auth);
+    }
+
+    #[test]
+    fn prefers_step_finish_parts_when_present() {
+        let db = temp_db_path("parts");
+        let conn = Connection::open(&db).unwrap();
+        conn.execute_batch(
+            "CREATE TABLE message (id TEXT PRIMARY KEY, data TEXT, time_created INTEGER);
+             CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, data TEXT, time_created INTEGER);",
+        )
+        .unwrap();
+        let now = Utc.with_ymd_and_hms(2026, 3, 18, 12, 0, 0).unwrap();
+        let created = now.timestamp_millis() - 1_000;
+        // Message cost would be $12 (100%), but step-finish parts sum to $3 (25%).
+        conn.execute(
+            "INSERT INTO message (id, data, time_created) VALUES (?1, ?2, ?3)",
+            rusqlite::params![
+                "m1",
+                format!(
+                    r#"{{"providerID":"opencode-go","role":"assistant","cost":12,"time":{{"created":{created}}}}}"#
+                ),
+                created
+            ],
+        )
+        .unwrap();
+        conn.execute(
+            "INSERT INTO part (id, message_id, data, time_created) VALUES (?1, ?2, ?3, ?4)",
+            rusqlite::params![
+                "p1",
+                "m1",
+                format!(r#"{{"type":"step-finish","cost":3,"time":{{"created":{created}}}}}"#),
+                created
+            ],
+        )
+        .unwrap();
+        drop(conn);
+
+        let auth = db.with_extension("auth.json");
+        let _ = std::fs::write(&auth, r#"{"opencode-go":{"key":"k"}}"#);
+        let snap = fetch_from_paths(&auth, &db, now).unwrap();
+        assert!(
+            (snap.rolling_usage_percent - 25.0).abs() < 0.05,
+            "expected step-finish cost only, got {snap:?}"
+        );
+        let _ = std::fs::remove_file(&db);
+        let _ = std::fs::remove_file(&auth);
+    }
+
+    #[test]
+    fn percent_rounds_to_one_decimal() {
+        assert!((percent(1.0, 12.0) - 8.3).abs() < 0.05);
+        assert_eq!(percent(0.0, 12.0), 0.0);
+        assert_eq!(percent(f64::NAN, 12.0), 0.0);
+    }
+
+    #[test]
+    fn iso_week_starts_monday_utc() {
+        // 2026-03-18 is a Wednesday; week start should be 2026-03-16 00:00 UTC.
+        let wed = Utc.with_ymd_and_hms(2026, 3, 18, 15, 0, 0).unwrap();
+        let start = start_of_utc_iso_week_ms(wed);
+        let expected = Utc
+            .with_ymd_and_hms(2026, 3, 16, 0, 0, 0)
+            .unwrap()
+            .timestamp_millis();
+        assert_eq!(start, expected);
+        assert_eq!(wed.weekday(), Weekday::Wed);
+    }
+}
diff --git a/rust/src/providers/opencodego/mod.rs b/rust/src/providers/opencodego/mod.rs
index f8ee8b3cbe..a7358513d6 100644
--- a/rust/src/providers/opencodego/mod.rs
+++ b/rust/src/providers/opencodego/mod.rs
@@ -1,8 +1,11 @@
 //! OpenCode Go provider implementation
 //!
 //! Separate workspace surface that shares the `opencode.ai` cookie domain with
-//! the OpenCode provider. Resolves the workspace ID, then scrapes the `/go`
-//! usage page for rolling/weekly/monthly windows.
+//! the OpenCode provider. Auto prefers local SQLite usage (upstream #2316)
+//! unless a workspace override scopes the fetch to web first; Web is cookie
+//! scrape only; Cli is local-only.
+
+mod local;
 
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
@@ -31,9 +34,9 @@ impl OpenCodeGoProvider {
             metadata: ProviderMetadata {
                 id: ProviderId::OpenCodeGo,
                 display_name: "OpenCode Go",
-                session_label: "Rolling",
+                session_label: "5-hour",
                 weekly_label: "Weekly",
-                supports_opus: false,
+                supports_opus: true,
                 supports_credits: false,
                 default_enabled: false,
                 is_primary: false,
@@ -193,7 +196,11 @@ impl OpenCodeGoProvider {
                 // Regex path only matches direct percent field names — fraction
                 // heuristic is safe here (upstream #2331). used/limit computed
                 // percents must not use this path without a separate gate.
-                let p = if (0.0..=1.0).contains(&p) { p * 100.0 } else { p };
+                let p = if (0.0..=1.0).contains(&p) {
+                    p * 100.0
+                } else {
+                    p
+                };
                 return Some((p.clamp(0.0, 100.0), reset.max(0)));
             }
 
@@ -388,35 +395,38 @@ impl Provider for OpenCodeGoProvider {
         tracing::debug!("Fetching OpenCode Go usage");
 
         match ctx.source_mode {
-            SourceMode::Auto | SourceMode::Web => {
-                if let Some(ref cookie_header) = ctx.manual_cookie_header {
-                    return self
-                        .fetch_with_cookies(cookie_header, ctx.workspace_id.as_deref())
-                        .await;
-                }
-
-                match crate::providers::browser_cookie_header(&["opencode.ai"]) {
-                    Ok(cookie_header) => match self
-                        .fetch_with_cookies(&cookie_header, ctx.workspace_id.as_deref())
-                        .await
-                    {
+            SourceMode::Auto => {
+                // Local-first unless workspace/token scope asks for web first
+                // (manual cookie source is already mapped to Web by the shell).
+                if Self::auto_prefers_web_first(ctx) {
+                    match self.fetch_web(ctx).await {
                         Ok(result) => return Ok(result),
-                        Err(ProviderError::AuthRequired) => {}
+                        Err(e) if Self::web_error_allows_local_fallback(&e) => {
+                            tracing::debug!(
+                                "OpenCode Go web failed in scoped Auto; trying local: {e}"
+                            );
+                        }
                         Err(e) => return Err(e),
-                    },
-                    Err(ProviderError::NoCookies) => {}
-                    Err(e) => return Err(e),
+                    }
+                    return self.fetch_local();
                 }
 
-                Err(ProviderError::AuthRequired)
+                match self.fetch_local() {
+                    Ok(result) => return Ok(result),
+                    Err(e) => {
+                        tracing::debug!("OpenCode Go local failed in Auto; trying web: {e}");
+                    }
+                }
+                self.fetch_web(ctx).await
             }
-            SourceMode::Cli => Err(ProviderError::UnsupportedSource(SourceMode::Cli)),
+            SourceMode::Web => self.fetch_web(ctx).await,
+            SourceMode::Cli => self.fetch_local(),
             SourceMode::OAuth => Err(ProviderError::UnsupportedSource(SourceMode::OAuth)),
         }
     }
 
     fn available_sources(&self) -> Vec<SourceMode> {
-        vec![SourceMode::Auto, SourceMode::Web]
+        vec![SourceMode::Auto, SourceMode::Web, SourceMode::Cli]
     }
 
     fn supports_web(&self) -> bool {
@@ -424,7 +434,56 @@ impl Provider for OpenCodeGoProvider {
     }
 
     fn supports_cli(&self) -> bool {
-        false
+        true
+    }
+}
+
+impl OpenCodeGoProvider {
+    /// Auto prefers web when a workspace override or active token-account scope
+    /// is present (upstream `requiresScopedWebStrategy`).
+    fn auto_prefers_web_first(ctx: &FetchContext) -> bool {
+        if ctx
+            .workspace_id
+            .as_deref()
+            .is_some_and(|id| !id.trim().is_empty())
+        {
+            return true;
+        }
+        // Shell sets this when a token account is active for cookie/web scope.
+        ctx.auto_prefer_web
+    }
+
+    fn web_error_allows_local_fallback(err: &ProviderError) -> bool {
+        matches!(
+            err,
+            ProviderError::AuthRequired
+                | ProviderError::NoCookies
+                | ProviderError::Timeout
+                | ProviderError::Network(_)
+                | ProviderError::Parse(_)
+                | ProviderError::Other(_)
+        )
+    }
+
+    fn fetch_local(&self) -> Result<ProviderFetchResult, ProviderError> {
+        local::fetch_local_usage(Utc::now()).map(|snap| snap.to_fetch_result())
+    }
+
+    async fn fetch_web(&self, ctx: &FetchContext) -> Result<ProviderFetchResult, ProviderError> {
+        if let Some(ref cookie_header) = ctx.manual_cookie_header {
+            return self
+                .fetch_with_cookies(cookie_header, ctx.workspace_id.as_deref())
+                .await;
+        }
+
+        match crate::providers::browser_cookie_header(&["opencode.ai"]) {
+            Ok(cookie_header) => {
+                self.fetch_with_cookies(&cookie_header, ctx.workspace_id.as_deref())
+                    .await
+            }
+            Err(ProviderError::NoCookies) => Err(ProviderError::AuthRequired),
+            Err(e) => Err(e),
+        }
     }
 }
 
diff --git a/rust/src/settings.rs b/rust/src/settings.rs
index 5a33396291..ab3e0e280b 100755
--- a/rust/src/settings.rs
+++ b/rust/src/settings.rs
@@ -38,9 +38,14 @@ pub struct Settings {
     /// Enabled provider IDs (by CLI name)
     pub enabled_providers: HashSet<String>,
 
-    /// Refresh interval in seconds (0 = manual only)
+    /// Refresh interval in seconds (0 = manual only).
+    /// Ignored when [`Self::adaptive_refresh`] is true.
     pub refresh_interval_secs: u64,
 
+    /// When true, ignore the fixed interval and use adaptive refresh delays.
+    #[serde(default)]
+    pub adaptive_refresh: bool,
+
     /// Force-refresh enabled providers whenever the tray/menu surface opens.
     #[serde(default)]
     pub refresh_all_providers_on_menu_open: bool,
@@ -372,6 +377,7 @@ impl Default for Settings {
         Self {
             enabled_providers: enabled,
             refresh_interval_secs: 300, // 5 minutes
+            adaptive_refresh: false,
             refresh_all_providers_on_menu_open: false,
             start_minimized: false,
             start_at_login: false,
diff --git a/rust/src/settings/raw.rs b/rust/src/settings/raw.rs
index 3e2e7fa59e..2a14614a7f 100644
--- a/rust/src/settings/raw.rs
+++ b/rust/src/settings/raw.rs
@@ -16,6 +16,8 @@ use super::*;
 pub(super) struct RawSettings {
     enabled_providers: HashSet<String>,
     refresh_interval_secs: u64,
+    #[serde(default)]
+    adaptive_refresh: bool,
     refresh_all_providers_on_menu_open: bool,
     start_minimized: bool,
     start_at_login: bool,
@@ -153,6 +155,7 @@ impl Default for RawSettings {
         Self {
             enabled_providers: s.enabled_providers,
             refresh_interval_secs: s.refresh_interval_secs,
+            adaptive_refresh: s.adaptive_refresh,
             refresh_all_providers_on_menu_open: s.refresh_all_providers_on_menu_open,
             start_minimized: s.start_minimized,
             start_at_login: s.start_at_login,
@@ -444,6 +447,7 @@ impl From<RawSettings> for Settings {
         Settings {
             enabled_providers: raw.enabled_providers,
             refresh_interval_secs: raw.refresh_interval_secs,
+            adaptive_refresh: raw.adaptive_refresh,
             refresh_all_providers_on_menu_open: raw.refresh_all_providers_on_menu_open,
             start_minimized: raw.start_minimized,
             start_at_login: raw.start_at_login,