diff --git a/apps/desktop-tauri/src-tauri/src/commands/bridge.rs b/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
index 1a85da249b..d24d087870 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/bridge.rs
@@ -103,6 +103,10 @@ pub struct CostSnapshotBridge {
     #[serde(default)]
     pub balance: Option<f64>,
     #[serde(default)]
+    pub balance_updated_at: Option<String>,
+    #[serde(default)]
+    pub account_id: Option<String>,
+    #[serde(default)]
     pub formatted_balance: Option<String>,
     #[serde(default)]
     pub daily: Vec<CostDailyPointBridge>,
@@ -195,6 +199,8 @@ pub struct ProviderUsageSnapshot {
     pub account_email: Option<String>,
     #[serde(default = "default_source_label")]
     pub source_label: String,
+    #[serde(default)]
+    pub has_successful_claude_cli_quota: bool,
     /// Defaults to launch time when absent so the card renders as fresh.
     #[serde(default)]
     pub updated_at: String,
@@ -378,6 +384,8 @@ impl ProviderUsageSnapshot {
                 formatted_used: c.format_used(),
                 formatted_limit: c.format_limit(),
                 balance: c.balance,
+                balance_updated_at: c.balance_updated_at.map(|dt| dt.to_rfc3339()),
+                account_id: c.account_id.clone(),
                 formatted_balance: c.format_balance(),
                 daily: c
                     .daily
@@ -392,6 +400,7 @@ impl ProviderUsageSnapshot {
             plan_name: usage.login_method.clone(),
             account_email: usage.account_email.clone(),
             source_label: result.source_label.clone(),
+            has_successful_claude_cli_quota: result.has_successful_claude_cli_quota,
             updated_at: usage.updated_at.to_rfc3339(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
@@ -438,6 +447,7 @@ impl ProviderUsageSnapshot {
             plan_name: None,
             account_email: None,
             source_label: String::new(),
+            has_successful_claude_cli_quota: false,
             updated_at: chrono::Utc::now().to_rfc3339(),
             error: Some(error),
             error_state: state_kind,
diff --git a/apps/desktop-tauri/src-tauri/src/commands/providers.rs b/apps/desktop-tauri/src-tauri/src/commands/providers.rs
index 237e03f88e..6d39d6ca24 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/providers.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/providers.rs
@@ -447,11 +447,13 @@ async fn refresh_provider(
 
 /// F6 (upstream 0.48.0 UsageStore+CodexResetBackfill): backfill missing
 /// `resets_at` / `reset_description` on fresh Codex windows from the cached
-/// lane data when the cached reset is still future. Fresh `used_percent` is
-/// untouched; only the reset timestamp/description are backfilled.
+/// lane data when the cached reset is still future. z.ai five-hour cached
+/// resets use the same plausibility bound as the provider parser, so an
+/// impossible rejected reset cannot be restored from the cache. Fresh
+/// `used_percent` is untouched; only reset metadata is backfilled.
 ///
-/// This is Codex-scoped by design (upstream: "Provider-specific by design"):
-/// other providers do not carry bounded resume state.
+/// This remains provider-scoped by design (upstream: "Provider-specific by
+/// design"): only Codex and z.ai carry the relevant bounded reset semantics.
 ///
 /// Applies to the bridge snapshot before publishing so every surface (tray,
 /// CLI, frontend) sees the backfilled reset instead of a missing one.
@@ -460,19 +462,23 @@ pub(super) fn codex_reset_backfill(
     cached: Option<&ProviderUsageSnapshot>,
 ) {
     let Some(cached) = cached else { return };
-    if snapshot.provider_id != "codex" {
+    if !matches!(snapshot.provider_id.as_str(), "codex" | "zai") {
         return;
     }
 
     // Backfill each slot from the corresponding cached slot.
-    backfill_slot_window(&mut snapshot.primary, &cached.primary);
+    backfill_slot_window(
+        &snapshot.provider_id,
+        &mut snapshot.primary,
+        &cached.primary,
+    );
     if let (Some(fresh), Some(cached_sec)) = (&mut snapshot.secondary, &cached.secondary) {
-        backfill_slot_window(fresh, cached_sec);
+        backfill_slot_window(&snapshot.provider_id, fresh, cached_sec);
     }
     // Tertiary (monthly/other): the Codex bridge doesn't normally populate this,
     // but the slot exists for forward-compat. Backfill when available.
     if let (Some(fresh), Some(cached_ter)) = (&mut snapshot.tertiary, &cached.tertiary) {
-        backfill_slot_window(fresh, cached_ter);
+        backfill_slot_window(&snapshot.provider_id, fresh, cached_ter);
     }
 }
 
@@ -480,6 +486,7 @@ pub(super) fn codex_reset_backfill(
 /// cached window whose reset is still in the future. `used_percent` is never
 /// overwritten (upstream: "fresh used_percent untouched").
 fn backfill_slot_window(
+    provider_id: &str,
     fresh: &mut bridge::RateWindowSnapshot,
     cached: &bridge::RateWindowSnapshot,
 ) {
@@ -491,11 +498,20 @@ fn backfill_slot_window(
     };
     // Only backfill when the cached reset is still future — a stale reset is
     // worse than a missing one.
-    if let Ok(cached_dt) = chrono::DateTime::parse_from_rfc3339(cached_reset) {
-        if cached_dt <= chrono::Utc::now() {
-            return;
-        }
-    } else {
+    let Ok(cached_dt) = chrono::DateTime::parse_from_rfc3339(cached_reset) else {
+        return;
+    };
+    let now = chrono::Utc::now();
+    if cached_dt <= now {
+        return;
+    }
+    // A missing z.ai five-hour reset can mean the provider rejected an
+    // impossible future timestamp. Do not let equally impossible cached
+    // evidence undo that rejection, but preserve a plausible cached reset.
+    if provider_id == "zai"
+        && fresh.window_minutes == Some(300)
+        && cached_dt > now + chrono::Duration::minutes(5 * 60 + 1)
+    {
         return;
     }
     fresh.resets_at = Some(cached_reset.clone());
@@ -521,7 +537,7 @@ pub(super) fn preserve_last_good_transient_failure(
         return snapshot;
     }
 
-    let Some(previous) = guard
+    let Some(mut previous) = guard
         .provider_cache
         .iter()
         .find(|cached| cached.provider_id == id.cli_name() && cached.error.is_none())
@@ -529,6 +545,9 @@ pub(super) fn preserve_last_good_transient_failure(
     else {
         return snapshot;
     };
+    // Preserved quota remains useful for display, but the failed current
+    // attempt cannot prove that Claude CLI is available for account actions.
+    previous.has_successful_claude_cli_quota = false;
 
     let count = guard
         .transient_provider_failure_counts
@@ -1133,6 +1152,7 @@ mod reset_backfill_tests {
             plan_name: None,
             account_email: None,
             source_label: String::new(),
+            has_successful_claude_cli_quota: false,
             updated_at: "2026-01-01T00:00:00Z".into(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
@@ -1192,6 +1212,24 @@ mod reset_backfill_tests {
         assert!(fresh.primary.resets_at.is_none(), "non-codex skip");
     }
 
+    #[test]
+    fn zai_five_hour_backfill_rejects_impossible_cached_reset() {
+        for (offset, should_backfill) in [
+            (chrono::Duration::hours(1), true),
+            (chrono::Duration::hours(10), false),
+        ] {
+            let future = (chrono::Utc::now() + offset).to_rfc3339();
+            let mut cached = codex_snapshot(win(50.0, Some(&future)));
+            cached.provider_id = "zai".into();
+            let mut fresh = codex_snapshot(win(30.0, None));
+            fresh.provider_id = "zai".into();
+            fresh.primary.reset_description = Some("5-hour".into());
+            codex_reset_backfill(&mut fresh, Some(&cached));
+            assert_eq!(fresh.primary.resets_at.is_some(), should_backfill);
+            assert!((fresh.primary.used_percent - 30.0).abs() < f64::EPSILON);
+        }
+    }
+
     #[test]
     fn f6_skips_when_no_cached_snapshot() {
         let mut fresh = codex_snapshot(win(30.0, None));
diff --git a/apps/desktop-tauri/src-tauri/src/commands/tests.rs b/apps/desktop-tauri/src-tauri/src/commands/tests.rs
index bab3dc1731..8b38489ac5 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/tests.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/tests.rs
@@ -939,6 +939,7 @@ fn provider_cache_upsert_replaces_existing_provider() {
         cost: None,
         wayfinder_usage: None,
         source_label: "CLI".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let mut first =
@@ -963,6 +964,7 @@ fn provider_cache_prunes_disabled_providers() {
         cost: None,
         wayfinder_usage: None,
         source_label: "CLI".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let codex =
@@ -994,6 +996,7 @@ fn hiding_codex_spark_rows_preserves_other_extra_usage() {
         cost: None,
         wayfinder_usage: None,
         source_label: "CLI".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let mut snapshot =
@@ -1025,6 +1028,7 @@ fn claude_transient_auth_failure_preserves_first_last_good_snapshot() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let good =
@@ -1056,6 +1060,7 @@ fn claude_repeated_auth_failure_surfaces_error() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let good =
@@ -1092,6 +1097,7 @@ fn claude_cloudflare_challenge_retains_prior_usage_while_surfaceing_guidance() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let good =
@@ -1139,6 +1145,7 @@ fn claude_cloudflare_challenge_keeps_prior_usage_when_guidance_surfaces() {
         cost: None,
         wayfinder_usage: None,
         source_label: "Web".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let mut good =
@@ -1182,6 +1189,7 @@ fn claude_cli_parse_failure_keeps_last_good_every_time() {
         cost: None,
         wayfinder_usage: None,
         source_label: "CLI".to_string(),
+        has_successful_claude_cli_quota: true,
         pace_authoritative: true,
     };
     let good =
@@ -1205,6 +1213,7 @@ fn claude_cli_parse_failure_keeps_last_good_every_time() {
 
     assert_eq!(first.error, None);
     assert_eq!(first.primary.used_percent, 17.0);
+    assert!(!first.has_successful_claude_cli_quota);
     // Parse failures keep last-good on every refresh (upstream #2247), unlike one-shot auth.
     assert_eq!(second.error, None);
     assert_eq!(second.primary.used_percent, 17.0);
@@ -1218,6 +1227,7 @@ fn claude_hard_credentials_missing_does_not_preserve_stale() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
     let good =
@@ -1379,6 +1389,7 @@ fn japanese_provider_snapshot_localizes_weekly_label() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
 
@@ -1409,6 +1420,7 @@ fn japanese_provider_snapshot_localizes_pace_reserve_description() {
         cost: None,
         wayfinder_usage: None,
         source_label: "OAuth".to_string(),
+        has_successful_claude_cli_quota: false,
         pace_authoritative: true,
     };
 
diff --git a/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs b/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
index 04c0b620ef..c1012551c0 100644
--- a/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
+++ b/apps/desktop-tauri/src-tauri/src/commands/usage_spend.rs
@@ -62,17 +62,118 @@ pub struct UsageSpendSummary {
     pub contract: SpendContract,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 struct CachedUsageSpendSummary {
     key: String,
     summary: UsageSpendSummary,
+    refresh_owner: Option<UsageSpendRefreshOwner>,
 }
 
-static USAGE_SPEND_SUMMARY_CACHE: OnceLock<Mutex<Option<CachedUsageSpendSummary>>> =
-    OnceLock::new();
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum UsageSpendRefreshPhase {
+    Indexing,
+    Paused,
+}
 
-fn usage_spend_summary_cache() -> &'static Mutex<Option<CachedUsageSpendSummary>> {
-    USAGE_SPEND_SUMMARY_CACHE.get_or_init(|| Mutex::new(None))
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct UsageSpendRefreshOwner {
+    generation: u64,
+    scope: String,
+}
+
+#[derive(Default)]
+struct UsageSpendCoordinator {
+    next_generation: u64,
+    current: Option<(UsageSpendRefreshOwner, UsageSpendRefreshPhase)>,
+    cache: Option<CachedUsageSpendSummary>,
+}
+
+impl UsageSpendCoordinator {
+    fn begin(&mut self, scope: String) -> UsageSpendRefreshOwner {
+        self.next_generation = self.next_generation.wrapping_add(1).max(1);
+        let owner = UsageSpendRefreshOwner {
+            generation: self.next_generation,
+            scope,
+        };
+        self.current = Some((owner.clone(), UsageSpendRefreshPhase::Indexing));
+        owner
+    }
+
+    fn pause(&mut self, owner: &UsageSpendRefreshOwner) {
+        if let Some((current, phase)) = self.current.as_mut()
+            && current == owner
+            && *phase == UsageSpendRefreshPhase::Indexing
+        {
+            *phase = UsageSpendRefreshPhase::Paused;
+        }
+    }
+
+    fn is_current(&self, owner: &UsageSpendRefreshOwner) -> bool {
+        self.current
+            .as_ref()
+            .is_some_and(|(current, _)| current == owner)
+    }
+
+    fn clear_if_indexing(&mut self, owner: &UsageSpendRefreshOwner) -> bool {
+        let Some((current, phase)) = self.current.as_ref() else {
+            return false;
+        };
+        if current != owner || *phase != UsageSpendRefreshPhase::Indexing {
+            return false;
+        }
+        self.current = None;
+        true
+    }
+}
+
+static USAGE_SPEND_COORDINATOR: OnceLock<Mutex<UsageSpendCoordinator>> = OnceLock::new();
+
+fn usage_spend_coordinator() -> &'static Mutex<UsageSpendCoordinator> {
+    USAGE_SPEND_COORDINATOR.get_or_init(|| Mutex::new(UsageSpendCoordinator::default()))
+}
+
+fn clear_summary_refreshing(summary: &mut UsageSpendSummary) {
+    for row in &mut summary.rows {
+        row.refreshing = false;
+        row.stale_updated_at = None;
+    }
+}
+
+fn summary_is_refreshing(summary: &UsageSpendSummary) -> bool {
+    summary.rows.iter().any(|row| row.refreshing)
+}
+
+fn mark_refresh_paused_if_codex_scan_paused(
+    coordinator: &mut UsageSpendCoordinator,
+    owner: &UsageSpendRefreshOwner,
+    refreshing: bool,
+    codex_scan_pause_reason: Option<&codexbar::core::CodexScanPauseReason>,
+) {
+    if refreshing && codex_scan_pause_reason.is_some() {
+        coordinator.pause(owner);
+    }
+}
+
+/// Retire an invalidated owner without allowing it to clear a replacement.
+fn clear_usage_spend_refresh_if_owned(owner: &UsageSpendRefreshOwner) {
+    let Ok(mut coordinator) = usage_spend_coordinator().lock() else {
+        return;
+    };
+    if !coordinator.clear_if_indexing(owner) {
+        return;
+    }
+    if let Some(existing) = coordinator.cache.as_mut()
+        && existing.refresh_owner.as_ref() == Some(owner)
+    {
+        clear_summary_refreshing(&mut existing.summary);
+        existing.refresh_owner = None;
+    }
+}
+
+struct BuiltUsageSpendSummary {
+    key: String,
+    summary: UsageSpendSummary,
+    refresh_owner: Option<UsageSpendRefreshOwner>,
 }
 
 #[tauri::command]
@@ -88,11 +189,29 @@ pub async fn get_usage_spend_summary(
 
     let selected_days = history_days.unwrap_or(30);
     let force_refresh = force_refresh.unwrap_or(false);
-    tauri::async_runtime::spawn_blocking(move || {
+    let built = tauri::async_runtime::spawn_blocking(move || {
         build_usage_spend_summary_cached(&cached, selected_days, force_refresh)
     })
     .await
-    .map_err(|e| format!("usage spend worker failed: {e}"))?
+    .map_err(|e| format!("usage spend worker failed: {e}"))??;
+    let current_cached = state
+        .lock()
+        .map_err(|e| e.to_string())
+        .map(|guard| guard.provider_cache.clone())?;
+    let current_key = usage_spend_cache_key(
+        &current_cached,
+        selected_days,
+        &codexbar::settings::Settings::load(),
+    );
+    if current_key != built.key {
+        if let Some(owner) = built.refresh_owner.as_ref() {
+            clear_usage_spend_refresh_if_owned(owner);
+        }
+        let mut summary = built.summary;
+        clear_summary_refreshing(&mut summary);
+        return Ok(summary);
+    }
+    Ok(built.summary)
 }
 
 #[tauri::command]
@@ -112,26 +231,68 @@ fn build_usage_spend_summary_cached(
     cached: &[ProviderUsageSnapshot],
     selected_days: u32,
     force_refresh: bool,
-) -> Result<UsageSpendSummary, String> {
+) -> Result<BuiltUsageSpendSummary, String> {
     let settings = codexbar::settings::Settings::load();
     let key = usage_spend_cache_key(cached, selected_days, &settings);
-    let mut guard = usage_spend_summary_cache()
-        .lock()
-        .map_err(|error| error.to_string())?;
-    if !force_refresh
-        && let Some(existing) = guard.as_ref()
-        && existing.key == key
     {
-        return Ok(existing.summary.clone());
+        let guard = usage_spend_coordinator()
+            .lock()
+            .map_err(|error| error.to_string())?;
+        if !force_refresh
+            && let Some(existing) = guard.cache.as_ref()
+            && existing.key == key
+        {
+            return Ok(BuiltUsageSpendSummary {
+                key: existing.key.clone(),
+                summary: existing.summary.clone(),
+                refresh_owner: existing.refresh_owner.clone(),
+            });
+        }
     }
-    // Hold the cache mutex while building: callers for the same app revision
-    // coalesce behind this single scan instead of starting parallel rescans.
+    let owner = {
+        let mut coordinator = usage_spend_coordinator()
+            .lock()
+            .map_err(|error| error.to_string())?;
+        coordinator.begin(key.clone())
+    };
     let summary = build_usage_spend_summary(cached, selected_days, &settings, force_refresh);
-    *guard = Some(CachedUsageSpendSummary {
-        key,
+    let refreshing = summary_is_refreshing(&summary);
+    let codex_scan_pause_reason =
+        codexbar::core::JsonlScanner::load_cache_status(codexbar::core::ProviderId::Codex, None)
+            .codex_scan_pause_reason;
+
+    let mut coordinator = usage_spend_coordinator()
+        .lock()
+        .map_err(|error| error.to_string())?;
+    mark_refresh_paused_if_codex_scan_paused(
+        &mut coordinator,
+        &owner,
+        refreshing,
+        codex_scan_pause_reason.as_ref(),
+    );
+    if !coordinator.is_current(&owner) {
+        let mut summary = summary;
+        clear_summary_refreshing(&mut summary);
+        return Ok(BuiltUsageSpendSummary {
+            key,
+            summary,
+            refresh_owner: Some(owner),
+        });
+    }
+    if !refreshing {
+        coordinator.clear_if_indexing(&owner);
+    }
+    let refresh_owner = refreshing.then(|| owner.clone());
+    coordinator.cache = Some(CachedUsageSpendSummary {
+        key: key.clone(),
         summary: summary.clone(),
+        refresh_owner: refresh_owner.clone(),
     });
-    Ok(summary)
+    Ok(BuiltUsageSpendSummary {
+        key,
+        summary,
+        refresh_owner,
+    })
 }
 
 fn usage_spend_cache_key(
@@ -545,6 +706,48 @@ fn cached_spend(snapshot: Option<&ProviderUsageSnapshot>) -> SpendValues {
 mod cache_key_tests {
     use super::*;
 
+    #[test]
+    fn invalidated_owner_clears_orphaned_indexing_activity() {
+        let mut coordinator = UsageSpendCoordinator::default();
+        let owner = coordinator.begin("account:old".to_string());
+
+        assert!(coordinator.clear_if_indexing(&owner));
+        assert!(!coordinator.is_current(&owner));
+    }
+
+    #[test]
+    fn old_owner_cleanup_cannot_clear_a_replacement() {
+        let mut coordinator = UsageSpendCoordinator::default();
+        let old = coordinator.begin("account:old".to_string());
+        let replacement = coordinator.begin("account:new".to_string());
+
+        assert!(!coordinator.clear_if_indexing(&old));
+        assert!(coordinator.is_current(&replacement));
+    }
+
+    #[test]
+    fn settings_replacement_preserves_an_intentional_pause() {
+        let mut coordinator = UsageSpendCoordinator::default();
+        let old = coordinator.begin("settings:old".to_string());
+        let replacement = coordinator.begin("settings:new".to_string());
+        let status = codexbar::core::CachedCostReadStatus {
+            codex_scan_pause_reason: Some(codexbar::core::CodexScanPauseReason::NoProgress),
+            ..Default::default()
+        };
+        mark_refresh_paused_if_codex_scan_paused(
+            &mut coordinator,
+            &replacement,
+            true,
+            status.codex_scan_pause_reason.as_ref(),
+        );
+
+        assert!(!coordinator.clear_if_indexing(&old));
+        assert_eq!(
+            coordinator.current.as_ref().map(|(_, phase)| *phase),
+            Some(UsageSpendRefreshPhase::Paused)
+        );
+    }
+
     #[test]
     fn privacy_mode_is_part_of_usage_spend_cache_identity() {
         let public = usage_spend_cache_key_with_privacy(&[], 30, false, false, false);
diff --git a/apps/desktop-tauri/src-tauri/src/powertoys.rs b/apps/desktop-tauri/src-tauri/src/powertoys.rs
index 492385c336..5c6352157e 100644
--- a/apps/desktop-tauri/src-tauri/src/powertoys.rs
+++ b/apps/desktop-tauri/src-tauri/src/powertoys.rs
@@ -199,6 +199,7 @@ mod tests {
             plan_name: Some("Team".to_string()),
             account_email: Some("dev@example.com".to_string()),
             source_label: "web".to_string(),
+            has_successful_claude_cli_quota: false,
             updated_at: "2026-07-09T00:00:00Z".to_string(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
@@ -245,6 +246,7 @@ mod tests {
             plan_name: None,
             account_email: None,
             source_label: "web".to_string(),
+            has_successful_claude_cli_quota: false,
             updated_at: "2026-07-09T00:00:00Z".to_string(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
diff --git a/apps/desktop-tauri/src-tauri/src/tray_bridge.rs b/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
index e0b38d55cf..5c83e2cac1 100644
--- a/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
+++ b/apps/desktop-tauri/src-tauri/src/tray_bridge.rs
@@ -1078,12 +1078,15 @@ mod tests {
                 formatted_limit: Some(format!("${limit:.2}")),
                 balance: None,
                 formatted_balance: None,
+                balance_updated_at: None,
+                account_id: None,
                 daily: Vec::new(),
                 always_visible: false,
             }),
             plan_name: None,
             account_email: None,
             source_label: String::new(),
+            has_successful_claude_cli_quota: false,
             updated_at: "2025-01-01T00:00:00Z".into(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
diff --git a/apps/desktop-tauri/src-tauri/src/usage_metric.rs b/apps/desktop-tauri/src-tauri/src/usage_metric.rs
index 48a84426de..9d762c392f 100644
--- a/apps/desktop-tauri/src-tauri/src/usage_metric.rs
+++ b/apps/desktop-tauri/src-tauri/src/usage_metric.rs
@@ -211,6 +211,7 @@ mod tests {
             plan_name: None,
             account_email: None,
             source_label: "test".to_string(),
+            has_successful_claude_cli_quota: false,
             updated_at: "2026-08-16T00:00:00Z".to_string(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
diff --git a/apps/desktop-tauri/src/lib/claudeAccountActions.test.ts b/apps/desktop-tauri/src/lib/claudeAccountActions.test.ts
new file mode 100644
index 0000000000..dc54c1b1bd
--- /dev/null
+++ b/apps/desktop-tauri/src/lib/claudeAccountActions.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import type { ProviderUsageSnapshot } from "../types/bridge";
+import { hasSuccessfulClaudeCliQuota } from "./claudeAccountActions";
+
+function provider(
+  overrides: Partial<ProviderUsageSnapshot> = {},
+): Pick<
+  ProviderUsageSnapshot,
+  | "providerId"
+  | "sourceLabel"
+  | "hasSuccessfulClaudeCliQuota"
+  | "error"
+  | "primary"
+  | "secondary"
+> {
+  return {
+    providerId: "claude",
+    sourceLabel: "Claude CLI",
+    hasSuccessfulClaudeCliQuota: true,
+    error: null,
+    primary: {
+      usedPercent: 25,
+      remainingPercent: 75,
+      windowMinutes: null,
+      isExhausted: false,
+      resetsAt: null,
+      resetDescription: null,
+      reservePercent: null,
+      reserveDescription: null,
+      isInformational: false,
+    },
+    secondary: null,
+    ...overrides,
+  };
+}
+
+describe("hasSuccessfulClaudeCliQuota", () => {
+  it("allows account actions without an identity field", () => {
+    expect(hasSuccessfulClaudeCliQuota(provider())).toBe(true);
+  });
+
+  it("does not treat retained, failed, or non-CLI data as account proof", () => {
+    expect(hasSuccessfulClaudeCliQuota(provider({ hasSuccessfulClaudeCliQuota: false }))).toBe(
+      false,
+    );
+    expect(hasSuccessfulClaudeCliQuota(provider({ error: "timed out" }))).toBe(false);
+    expect(
+      hasSuccessfulClaudeCliQuota(
+        provider({
+          primary: {
+            usedPercent: 25,
+            remainingPercent: 75,
+            windowMinutes: null,
+            isExhausted: false,
+            resetsAt: null,
+            resetDescription: "Status",
+            reservePercent: null,
+            reserveDescription: null,
+            isInformational: true,
+          },
+        }),
+      ),
+    ).toBe(false);
+  });
+});
diff --git a/apps/desktop-tauri/src/lib/claudeAccountActions.ts b/apps/desktop-tauri/src/lib/claudeAccountActions.ts
new file mode 100644
index 0000000000..f5e68d1ab3
--- /dev/null
+++ b/apps/desktop-tauri/src/lib/claudeAccountActions.ts
@@ -0,0 +1,33 @@
+import type { ProviderUsageSnapshot, RateWindowSnapshot } from "../types/bridge";
+
+/**
+ * A Claude CLI quota response proves that account actions are useful even
+ * when Claude does not expose an email or other account identity.
+ *
+ * Keep this deliberately narrower than "has Claude data": retained data,
+ * web/OAuth data, and failed refreshes must not authenticate an account.
+ */
+export function hasSuccessfulClaudeCliQuota(
+  provider: Pick<
+    ProviderUsageSnapshot,
+    | "providerId"
+    | "hasSuccessfulClaudeCliQuota"
+    | "error"
+    | "primary"
+    | "secondary"
+  >,
+): boolean {
+  if (
+    provider.providerId !== "claude" ||
+    provider.error !== null ||
+    !provider.hasSuccessfulClaudeCliQuota
+  ) {
+    return false;
+  }
+
+  return hasQuotaWindow(provider.primary) || hasQuotaWindow(provider.secondary);
+}
+
+function hasQuotaWindow(window: RateWindowSnapshot | null): boolean {
+  return window !== null && !window.isInformational && Number.isFinite(window.usedPercent);
+}
diff --git a/apps/desktop-tauri/src/surfaces/TrayPanel.tsx b/apps/desktop-tauri/src/surfaces/TrayPanel.tsx
index 19317626b9..68b1e758c8 100644
--- a/apps/desktop-tauri/src/surfaces/TrayPanel.tsx
+++ b/apps/desktop-tauri/src/surfaces/TrayPanel.tsx
@@ -2,7 +2,13 @@ import { Fragment, useEffect, useState, type CSSProperties } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import type { BootstrapState, ProviderUsageSnapshot, UsageSpendSummary } from "../types/bridge";
 import type { LocaleKey } from "../i18n/keys";
-import { beginFlyoutGesture, getUsageSpendSummary, openProviderDashboard, openProviderStatusPage } from "../lib/tauri";
+import {
+  beginFlyoutGesture,
+  getUsageSpendSummary,
+  openProviderDashboard,
+  openProviderStatusPage,
+  openSettingsWindow,
+} from "../lib/tauri";
 import {
   TRAY_SCALE_MAX,
   TRAY_SCALE_MIN,
@@ -14,6 +20,7 @@ import MenuSurface, { MenuEmpty } from "../components/MenuSurface";
 import UpdateBanner from "../components/UpdateBanner";
 import ProviderGrid from "../components/ProviderGrid";
 import AgentSessions from "../components/AgentSessions";
+import { hasSuccessfulClaudeCliQuota } from "../lib/claudeAccountActions";
 
 /** Provider IDs that have a dashboard URL in the backend */
 const HAS_DASHBOARD = new Set([
@@ -137,6 +144,12 @@ export default function TrayPanel({ state }: { state: BootstrapState }) {
     );
   };
 
+  const selectedProvider = selectedProviderId
+    ? sorted.find((provider) => provider.providerId === selectedProviderId) ?? null
+    : null;
+  const canSwitchClaudeAccount =
+    selectedProvider !== null && hasSuccessfulClaudeCliQuota(selectedProvider);
+
   if (sorted.length === 0) {
     return (
       <div className={revealClassName}>
@@ -208,9 +221,24 @@ export default function TrayPanel({ state }: { state: BootstrapState }) {
               ))}
         </div>
         {/* Context actions — detail mode only, matches macOS actionsSection */}
-        {selectedProviderId && (HAS_DASHBOARD.has(selectedProviderId) || HAS_STATUS_PAGE.has(selectedProviderId)) && (
+        {selectedProviderId &&
+          (HAS_DASHBOARD.has(selectedProviderId) ||
+            HAS_STATUS_PAGE.has(selectedProviderId) ||
+            canSwitchClaudeAccount) && (
           <div className="context-actions">
             <div className="context-actions__divider" />
+            {canSwitchClaudeAccount && (
+              <button
+                type="button"
+                className="context-actions__btn"
+                onClick={() => openSettingsWindow("providers")}
+              >
+                <span className="context-actions__icon" aria-hidden>
+                  ⇄
+                </span>
+                {t("ActionSwitchAccount")}
+              </button>
+            )}
             {HAS_DASHBOARD.has(selectedProviderId) && (
               <button
                 type="button"
diff --git a/apps/desktop-tauri/src/types/bridge.ts b/apps/desktop-tauri/src/types/bridge.ts
index ef80370a89..952db5537a 100644
--- a/apps/desktop-tauri/src/types/bridge.ts
+++ b/apps/desktop-tauri/src/types/bridge.ts
@@ -549,6 +549,10 @@ export interface CostSnapshotBridge {
   formattedUsed: string;
   formattedLimit: string | null;
   balance?: number | null;
+  /** Successful balance observation time; independent from the usage-cap age. */
+  balanceUpdatedAt?: string | null;
+  /** Stable provider account scope for reconciling paired observations. */
+  accountId?: string | null;
   formattedBalance?: string | null;
   daily?: CostDailyPoint[];
   /** Provider-metered spend that is itself a primary usage signal. */
@@ -603,6 +607,8 @@ export interface ProviderUsageSnapshot {
   planName: string | null;
   accountEmail: string | null;
   sourceLabel: string;
+  /** Backend proof of a live successful Claude CLI quota fetch; only true is proof. */
+  hasSuccessfulClaudeCliQuota?: boolean;
   updatedAt: string;
   error: string | null;
   errorState: ProviderStateKind;
@@ -940,6 +946,8 @@ export interface CodexAccountUsageSnapshot {
   primaryWindow: CodexUsageWindow | null;
   secondaryWindow: CodexUsageWindow | null;
   credits: CodexCreditsBalance | null;
+  /** Persisted account-scoped extra-usage cost, when available. */
+  cost?: CostSnapshotBridge | null;
   updatedAt: string;
 }
 
diff --git a/rust/src/codex_accounts/api.rs b/rust/src/codex_accounts/api.rs
index b67eff2d7b..ac3c368ea1 100644
--- a/rust/src/codex_accounts/api.rs
+++ b/rust/src/codex_accounts/api.rs
@@ -11,7 +11,8 @@ use chrono::{DateTime, Utc};
 use thiserror::Error;
 
 use super::models::{
-    AccountUsageSnapshot, CreditsBalanceSnapshot, UsageWindowSnapshot, WindowRole,
+    AccountUsageSnapshot, CodexExtraUsageCost, CreditsBalanceSnapshot, UsageWindowSnapshot,
+    WindowRole,
 };
 use crate::core::credentialed_http_client_builder;
 
@@ -437,6 +438,7 @@ impl CodexAccountApi {
             .and_then(|v| v.as_object())
             .map(make_credits);
 
+        let cost_account_id = remote_account_id.clone();
         Ok(AccountUsageSnapshot {
             email: identity.email.or_else(|| normalize_string(fallback_email)),
             provider_account_id: remote_account_id,
@@ -450,7 +452,13 @@ impl CodexAccountApi {
                 .and_then(|v| v.as_bool()),
             primary_window,
             secondary_window,
-            credits,
+            credits: credits.clone(),
+            cost: CodexExtraUsageCost::from_credits(
+                credits.as_ref(),
+                Utc::now(),
+                cost_account_id.as_deref(),
+                None,
+            ),
             updated_at: Utc::now(),
         })
     }
@@ -893,6 +901,7 @@ mod tests {
             primary_window: Some(UsageWindowSnapshot::new(12.0, Some(Utc::now()), 18_000)),
             secondary_window: None,
             credits: None,
+            cost: None,
             updated_at: Utc::now(),
         };
         assert!(is_equivalent(&mk(), &mk()));
diff --git a/rust/src/codex_accounts/extra_usage.rs b/rust/src/codex_accounts/extra_usage.rs
new file mode 100644
index 0000000000..961b3a4213
--- /dev/null
+++ b/rust/src/codex_accounts/extra_usage.rs
@@ -0,0 +1,118 @@
+use chrono::{DateTime, Utc};
+
+use super::models::{AccountUsageSnapshot, CreditsBalanceSnapshot};
+
+/// Reconciles Codex's purchased-credit observation with a separately fetched
+/// monthly extra-usage cap.
+pub struct CodexExtraUsageCost;
+
+impl CodexExtraUsageCost {
+    pub const CURRENCY_CODE: &'static str = "Credits";
+
+    pub fn from_credits(
+        credits: Option<&CreditsBalanceSnapshot>,
+        observed_at: DateTime<Utc>,
+        account_id: Option<&str>,
+        attached: Option<&crate::core::CostSnapshot>,
+    ) -> Option<crate::core::CostSnapshot> {
+        let Some(credits) = credits else {
+            return attached.cloned();
+        };
+        let balance = Self::purchased_extra_credits_balance(credits, attached);
+        // `Some(credits)` is itself the successful credits observation; this
+        // preserves a confirmed zero while keeping legacy persisted rows valid.
+        let balance_updated_at = Some(observed_at);
+        let mut live = crate::core::CostSnapshot::new(0.0, Self::CURRENCY_CODE, "Extra usage")
+            .replacing_balance(balance, balance_updated_at);
+        if let Some(account_id) = account_id.filter(|id| !id.trim().is_empty()) {
+            live = live.with_account_id(account_id);
+        }
+        crate::core::CostSnapshot::reconcile(Some(&live), attached)
+    }
+
+    /// Purchased credits are reported as the provider's remaining balance. A
+    /// matching monthly remainder means no purchased credits, but a successful
+    /// zero observation is still retained by `balance_updated_at`.
+    pub fn purchased_extra_credits_balance(
+        credits: &CreditsBalanceSnapshot,
+        attached: Option<&crate::core::CostSnapshot>,
+    ) -> Option<f64> {
+        let balance = credits.balance?;
+        if balance <= 0.0 {
+            return Some(0.0);
+        }
+        if let Some(monthly_remaining) = attached
+            .filter(|cost| cost.currency_code.eq_ignore_ascii_case(Self::CURRENCY_CODE))
+            .and_then(crate::core::CostSnapshot::remaining)
+            && (balance - monthly_remaining).abs() <= 0.000_1
+        {
+            return Some(0.0);
+        }
+        Some(balance)
+    }
+}
+
+impl AccountUsageSnapshot {
+    /// Build the account-scoped credit cost while preserving a separately
+    /// fetched monthly cap, if one is available.
+    pub fn extra_usage_cost(
+        &self,
+        attached: Option<&crate::core::CostSnapshot>,
+    ) -> Option<crate::core::CostSnapshot> {
+        let attached = attached.or(self.cost.as_ref());
+        CodexExtraUsageCost::from_credits(
+            self.credits.as_ref(),
+            self.updated_at,
+            self.provider_account_id
+                .as_deref()
+                .or(self.email.as_deref()),
+            attached,
+        )
+    }
+}
+
+#[cfg(test)]
+mod extra_usage_tests {
+    use super::*;
+
+    fn at(seconds: i64) -> DateTime<Utc> {
+        DateTime::<Utc>::from_timestamp(seconds, 0).unwrap()
+    }
+
+    #[test]
+    fn purchased_balance_keeps_confirmed_zero() {
+        let credits = CreditsBalanceSnapshot {
+            has_credits: true,
+            unlimited: false,
+            balance: Some(0.0),
+        };
+        let result =
+            CodexExtraUsageCost::from_credits(Some(&credits), at(200), Some("acct"), None).unwrap();
+
+        assert_eq!(result.balance, Some(0.0));
+        assert_eq!(result.balance_updated_at, Some(at(200)));
+        assert_eq!(result.account_id.as_deref(), Some("acct"));
+    }
+
+    #[test]
+    fn purchased_balance_reconciles_with_attached_monthly_cap() {
+        let credits = CreditsBalanceSnapshot {
+            has_credits: true,
+            unlimited: false,
+            balance: Some(15.0),
+        };
+        let mut cap = crate::core::CostSnapshot::new(10.0, "Credits", "Monthly").with_limit(25.0);
+        cap.updated_at = at(100);
+        cap.account_id = Some("acct".to_string());
+
+        let result =
+            CodexExtraUsageCost::from_credits(Some(&credits), at(200), Some("acct"), Some(&cap))
+                .unwrap();
+
+        assert_eq!(result.used, 10.0);
+        assert_eq!(result.limit, Some(25.0));
+        assert_eq!(result.balance, Some(0.0));
+        assert_eq!(result.updated_at, at(100));
+        assert_eq!(result.balance_updated_at, Some(at(200)));
+    }
+}
diff --git a/rust/src/codex_accounts/mod.rs b/rust/src/codex_accounts/mod.rs
index ef84bb97b6..a0a29eb29c 100644
--- a/rust/src/codex_accounts/mod.rs
+++ b/rust/src/codex_accounts/mod.rs
@@ -14,6 +14,7 @@
 pub mod account_manager;
 pub mod api;
 pub mod codex_desktop;
+mod extra_usage;
 pub mod file_locations;
 pub mod login_runner;
 pub mod models;
diff --git a/rust/src/codex_accounts/models.rs b/rust/src/codex_accounts/models.rs
index edbc0e9e1e..4586901654 100644
--- a/rust/src/codex_accounts/models.rs
+++ b/rust/src/codex_accounts/models.rs
@@ -10,6 +10,8 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
+pub use super::extra_usage::CodexExtraUsageCost;
+
 /// `parse_from_rfc3339` requires an offset; append `Z` only when none is present.
 pub fn parse_datetime(value: &str) -> Option<DateTime<Utc>> {
     let text = value.trim();
@@ -535,6 +537,9 @@ pub struct AccountUsageSnapshot {
     pub primary_window: Option<UsageWindowSnapshot>,
     pub secondary_window: Option<UsageWindowSnapshot>,
     pub credits: Option<CreditsBalanceSnapshot>,
+    /// Account-scoped extra-usage cost persisted with the account lane.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cost: Option<crate::core::CostSnapshot>,
     pub updated_at: DateTime<Utc>,
 }
 
@@ -825,6 +830,7 @@ mod tests {
             primary_window: Some(UsageWindowSnapshot::new(10.0, None, 18_000)),
             secondary_window: None,
             credits: None,
+            cost: None,
             updated_at: utc_now(),
         };
         assert!(snapshot.is_quota_blocked());
diff --git a/rust/src/codex_accounts/stores.rs b/rust/src/codex_accounts/stores.rs
index 4eace86dd5..9ca2fbf117 100644
--- a/rust/src/codex_accounts/stores.rs
+++ b/rust/src/codex_accounts/stores.rs
@@ -243,6 +243,11 @@ mod tests {
             )),
             secondary_window: None,
             credits: None,
+            cost: Some(
+                crate::core::CostSnapshot::new(0.0, "Credits", "Extra usage")
+                    .with_balance_observation(Some(0.0), utc_now())
+                    .with_account_id("acct-1"),
+            ),
             updated_at: utc_now(),
         };
         let mut map = HashMap::new();
@@ -251,6 +256,11 @@ mod tests {
         let loaded = store.load().unwrap();
         assert_eq!(loaded.len(), 1);
         assert_eq!(loaded[&id].plan.as_deref().unwrap(), "pro");
+        assert_eq!(loaded[&id].cost.as_ref().unwrap().balance, Some(0.0));
+        assert_eq!(
+            loaded[&id].cost.as_ref().unwrap().account_id.as_deref(),
+            Some("acct-1")
+        );
         crate::codex_accounts::file_locations::clear_app_support_directory_override();
     }
 
diff --git a/rust/src/core/jsonl_scanner.rs b/rust/src/core/jsonl_scanner.rs
index 7689ea0236..4d2c504c3e 100755
--- a/rust/src/core/jsonl_scanner.rs
+++ b/rust/src/core/jsonl_scanner.rs
@@ -26,6 +26,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 pub struct CachedCostReadStatus {
     pub has_days: bool,
     pub previous_report: Option<CachedCostReport>,
+    pub codex_scan_pause_reason: Option<CodexScanPauseReason>,
 }
 
 #[derive(Deserialize, Default)]
@@ -38,6 +39,8 @@ struct CachedCostReadStatusProjection {
     has_days: bool,
     #[serde(default)]
     previous_report: Option<CachedCostReport>,
+    #[serde(default)]
+    codex_scan_pause_reason: Option<CodexScanPauseReason>,
 }
 
 fn deserialize_nonempty_object<'de, D>(deserializer: D) -> Result<bool, D::Error>
@@ -202,6 +205,22 @@ pub struct CostUsageCache {
     /// True while bounded Codex catch-up has not completed for this window.
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub codex_scan_incomplete: bool,
+    /// Earliest scan start retained for the active Codex catch-up cycle.
+    ///
+    /// This is deliberately separate from `scan_since_key`: that field is the
+    /// last successfully completed scan and must not change merely because a
+    /// narrower report was requested while catch-up is pending.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codex_pending_scan_since_key: Option<String>,
+    /// Scan end and source identity for the active Codex catch-up cycle.
+    /// Requests may retain the pending start only when all of these remain
+    /// compatible with the persisted work.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codex_pending_scan_until_key: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub codex_pending_scan_root_paths: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codex_pending_scan_timezone: Option<String>,
     /// Terminal catch-up pause attached to the existing incomplete state. A
     /// background scan must not clear or retry this state; an app-driven
     /// refresh clears it before starting the next pass.
@@ -460,6 +479,7 @@ impl JsonlScanner {
         CachedCostReadStatus {
             has_days: projection.has_days,
             previous_report: projection.previous_report,
+            codex_scan_pause_reason: projection.codex_scan_pause_reason,
         }
     }
     pub(crate) fn cached_cost_report_from_days(cache: &CostUsageCache) -> CachedCostReport {
diff --git a/rust/src/core/usage_snapshot.rs b/rust/src/core/usage_snapshot.rs
index 43f85874af..422c887597 100755
--- a/rust/src/core/usage_snapshot.rs
+++ b/rust/src/core/usage_snapshot.rs
@@ -282,6 +282,16 @@ pub struct CostSnapshot {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub balance: Option<f64>,
 
+    /// When the prepaid balance was successfully observed. This is independent
+    /// from `updated_at`, which belongs to the usage/limit observation.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub balance_updated_at: Option<DateTime<Utc>>,
+
+    /// Provider account that owns this cost observation, when the provider
+    /// exposes a stable account identifier.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub account_id: Option<String>,
+
     /// Exact daily spend points when the provider supplies them.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub daily: Vec<CostDailyPoint>,
@@ -304,6 +314,8 @@ impl CostSnapshot {
             resets_at: None,
             updated_at: Utc::now(),
             balance: None,
+            balance_updated_at: None,
+            account_id: None,
             daily: Vec::new(),
             always_visible: false,
         }
@@ -318,9 +330,92 @@ impl CostSnapshot {
     /// Builder pattern: set remaining prepaid balance (finite, ≥ 0 only)
     pub fn with_balance(mut self, balance: f64) -> Self {
         self.balance = finite_amount(balance);
+        self.balance_updated_at = self.balance.map(|_| self.updated_at);
+        self
+    }
+
+    /// Record a balance observation, including a confirmed zero or absence.
+    pub fn with_balance_observation(
+        mut self,
+        balance: Option<f64>,
+        observed_at: DateTime<Utc>,
+    ) -> Self {
+        self.balance = balance.and_then(finite_amount);
+        self.balance_updated_at = Some(observed_at);
         self
     }
 
+    /// Builder pattern: scope this observation to a provider account.
+    pub fn with_account_id(mut self, account_id: impl Into<String>) -> Self {
+        let account_id = account_id.into();
+        self.account_id = (!account_id.trim().is_empty()).then_some(account_id);
+        self
+    }
+
+    /// Replace only the balance observation while preserving the usage/limit
+    /// age and all provider presentation metadata.
+    pub fn replacing_balance(
+        &self,
+        balance: Option<f64>,
+        balance_updated_at: Option<DateTime<Utc>>,
+    ) -> Self {
+        let mut replacement = self.clone();
+        replacement.balance = balance.and_then(finite_amount);
+        replacement.balance_updated_at = balance_updated_at;
+        replacement
+    }
+
+    /// Reconcile two same-account observations whose usage cap and purchased
+    /// balance may have been fetched at different times.
+    pub fn reconcile(live: Option<&Self>, attached: Option<&Self>) -> Option<Self> {
+        let Some(live) = live else {
+            return attached.cloned();
+        };
+        let Some(attached) = attached else {
+            return Some(live.clone());
+        };
+        if !live
+            .currency_code
+            .eq_ignore_ascii_case(&attached.currency_code)
+            || (live.account_id.is_some()
+                && attached.account_id.is_some()
+                && live.account_id != attached.account_id)
+        {
+            return Some(live.clone());
+        }
+
+        let balance_date = |cost: &Self| {
+            cost.balance_updated_at
+                .or_else(|| cost.balance.map(|_| cost.updated_at))
+        };
+        let live_balance_date = balance_date(live);
+        let attached_balance_date = balance_date(attached);
+        let balance_source = match live_balance_date {
+            Some(live_date)
+                if attached_balance_date.is_none_or(|attached_date| live_date >= attached_date) =>
+            {
+                live
+            }
+            _ => attached,
+        };
+        let cap_source = if attached.limit.is_some_and(|limit| limit > 0.0)
+            && (live.limit.unwrap_or(0.0) <= 0.0 || attached.updated_at > live.updated_at)
+        {
+            attached
+        } else {
+            live
+        };
+        let mut result =
+            cap_source.replacing_balance(balance_source.balance, balance_date(balance_source));
+        if result.account_id.is_none() {
+            result.account_id = live
+                .account_id
+                .clone()
+                .or_else(|| attached.account_id.clone());
+        }
+        Some(result)
+    }
+
     pub fn with_daily(mut self, daily: Vec<CostDailyPoint>) -> Self {
         self.daily = daily;
         self
@@ -409,6 +504,10 @@ pub struct ProviderFetchResult {
     /// Label describing the data source (e.g., "oauth", "web", "cli")
     pub source_label: String,
 
+    /// True only for a live Claude CLI fetch with usable quota windows.
+    #[serde(default)]
+    pub has_successful_claude_cli_quota: bool,
+
     /// Whether quota data is authoritative enough for pace/run-out advice.
     #[serde(default = "default_pace_authoritative")]
     pub pace_authoritative: bool,
@@ -426,6 +525,7 @@ impl ProviderFetchResult {
             cost: None,
             wayfinder_usage: None,
             source_label: source_label.into(),
+            has_successful_claude_cli_quota: false,
             pace_authoritative: true,
         }
     }
@@ -473,4 +573,53 @@ mod tests {
         assert_eq!(cost.used_percent(), None);
         assert_eq!(cost.format_used(), "$0.00");
     }
+
+    #[test]
+    fn cost_reconcile_keeps_newer_cap_and_balance_observations_separate() {
+        let at = |seconds| DateTime::<Utc>::from_timestamp(seconds, 0).unwrap();
+        let mut attached = CostSnapshot::new(40.0, "Credits", "Monthly").with_limit(100.0);
+        attached.updated_at = at(100);
+        attached = attached.with_account_id("account-1");
+
+        let live = CostSnapshot::new(0.0, "Credits", "Extra usage")
+            .with_balance_observation(Some(0.0), at(200))
+            .with_account_id("account-1");
+        let resolved = CostSnapshot::reconcile(Some(&live), Some(&attached)).unwrap();
+
+        assert_eq!(resolved.used, 40.0);
+        assert_eq!(resolved.limit, Some(100.0));
+        assert_eq!(resolved.balance, Some(0.0));
+        assert_eq!(resolved.balance_updated_at, Some(at(200)));
+        assert_eq!(resolved.updated_at, at(100));
+        assert_eq!(resolved.account_id.as_deref(), Some("account-1"));
+    }
+
+    #[test]
+    fn cost_reconcile_does_not_mix_account_scopes() {
+        let mut attached = CostSnapshot::new(40.0, "Credits", "Monthly").with_limit(100.0);
+        attached.account_id = Some("account-a".to_string());
+        let live = CostSnapshot::new(0.0, "Credits", "Extra usage")
+            .with_balance_observation(Some(7.0), Utc::now())
+            .with_account_id("account-b");
+
+        let resolved = CostSnapshot::reconcile(Some(&live), Some(&attached)).unwrap();
+        assert_eq!(resolved.account_id.as_deref(), Some("account-b"));
+        assert_eq!(resolved.used, 0.0);
+        assert_eq!(resolved.limit, None);
+        assert_eq!(resolved.balance, Some(7.0));
+    }
+
+    #[test]
+    fn cost_provenance_survives_persistence_roundtrip() {
+        let observed_at = DateTime::<Utc>::from_timestamp(123, 0).unwrap();
+        let cost = CostSnapshot::new(2.0, "Credits", "Extra usage")
+            .with_balance_observation(Some(0.0), observed_at)
+            .with_account_id("account-1");
+        let encoded = serde_json::to_value(&cost).unwrap();
+        let decoded: CostSnapshot = serde_json::from_value(encoded).unwrap();
+
+        assert_eq!(decoded.balance, Some(0.0));
+        assert_eq!(decoded.balance_updated_at, Some(observed_at));
+        assert_eq!(decoded.account_id.as_deref(), Some("account-1"));
+    }
 }
diff --git a/rust/src/cost_scanner/codex.rs b/rust/src/cost_scanner/codex.rs
index 360024c44b..dd4bc64928 100644
--- a/rust/src/cost_scanner/codex.rs
+++ b/rust/src/cost_scanner/codex.rs
@@ -1,8 +1,10 @@
 use super::*;
 
 mod logical_target;
+mod pending_range;
 mod reconciliation;
 use logical_target::*;
+use pending_range::{CodexPendingScanContext, codex_cache_has_validated_state};
 use reconciliation::*;
 
 fn rebuild_cache_days(cache: &mut CostUsageCache) {
@@ -213,24 +215,30 @@ impl CostScanner {
 
         let cache_root = self.cache_root.as_deref();
         let mut cache = JsonlScanner::load_cache(ProviderId::Codex, cache_root);
+        let sessions_dirs = self.get_codex_sessions_dirs();
+        let pending_scan = CodexPendingScanContext::new(
+            &cache,
+            &range,
+            &sessions_dirs,
+            self.options.is_app_driven(),
+        );
 
         // A no-progress or source-error catch-up is terminal for background
         // synchronization. Keep the resumable queue and last validated report
         // intact until the user explicitly requests an app-driven refresh.
-        if cache.codex_scan_incomplete
-            && cache.codex_scan_pause_reason.is_some()
-            && !self.options.is_app_driven()
-        {
+        if pending_scan.should_preserve_pause(&cache, self.options.is_app_driven()) {
             return (
                 paused_codex_summary(&cache, start_date, today),
                 stats,
                 cache,
             );
         }
-        if self.options.is_app_driven() {
+        if self.options.is_app_driven() || pending_scan.is_incompatible {
             cache.codex_scan_pause_reason = None;
         }
 
+        let scan_range = &pending_scan.scan_range;
+
         // Debounce: rebuild from disk cache without re-walking session files.
         if JsonlScanner::should_skip_cached_scan(&cache, self.options, now_ms)
             && !cache.codex_scan_incomplete
@@ -280,7 +288,6 @@ impl CostScanner {
             return (summary, stats, cache);
         }
 
-        let sessions_dirs = self.get_codex_sessions_dirs();
         let established_report_before_scan = (!cache.codex_scan_incomplete
             && cache.previous_report.is_none()
             && (cache.scan_since_key.is_some()
@@ -288,8 +295,14 @@ impl CostScanner {
                 || !cache.files.is_empty()))
         .then(|| JsonlScanner::cached_cost_report_from_days(&cache));
 
+        // Persist the source-bound work range before doing bounded work.
+        cache.codex_pending_scan_since_key = Some(scan_range.scan_since_key.clone());
+        cache.codex_pending_scan_until_key = Some(scan_range.scan_until_key.clone());
+        cache.codex_pending_scan_root_paths = pending_scan.root_paths.clone();
+        cache.codex_pending_scan_timezone = Some(pending_scan.timezone.clone());
+
         let (mut candidates, discovery_complete) =
-            self.collect_codex_candidates(&sessions_dirs, &range, &cache, cancel, &mut stats);
+            self.collect_codex_candidates(&sessions_dirs, scan_range, &cache, cancel, &mut stats);
         let candidate_limit = if self.options.codex_candidate_limit == 0 {
             usize::MAX
         } else {
@@ -311,7 +324,7 @@ impl CostScanner {
         prioritize_codex_pending_candidates(&mut candidates, &pending_paths_before_pass);
         if discovery_complete && !is_cancelled(cancel) {
             pending_next
-                .retain(|path| !cached_codex_file_is_complete_for_range(&cache, path, &range));
+                .retain(|path| !cached_codex_file_is_complete_for_range(&cache, path, scan_range));
         }
 
         let mut incomplete_processed = Vec::new();
@@ -351,7 +364,7 @@ impl CostScanner {
 
             let outcome = self.parse_codex_file_bounded(
                 &candidate.path,
-                &range,
+                scan_range,
                 &mut summary,
                 &mut cache,
                 cancel,
@@ -388,9 +401,9 @@ impl CostScanner {
 
         let mut pruned_paths_pending = Vec::new();
         if discovery_complete && !is_cancelled(cancel) {
-            pruned_paths_pending = missing_codex_cache_paths(&cache, &sessions_dirs, &range);
+            pruned_paths_pending = missing_codex_cache_paths(&cache, &sessions_dirs, scan_range);
             if self.options.is_app_driven() {
-                reconcile_missing_codex_cache_files(&mut cache, &sessions_dirs, &range);
+                reconcile_missing_codex_cache_files(&mut cache, &sessions_dirs, scan_range);
                 for path in &pending_paths_before_pass {
                     if !Path::new(path).exists() {
                         cache.files.remove(path);
@@ -416,7 +429,7 @@ impl CostScanner {
                 return true;
             }
             Path::new(path).exists()
-                && is_codex_path_in_scan_window(Path::new(path), &sessions_dirs, &range)
+                && is_codex_path_in_scan_window(Path::new(path), &sessions_dirs, scan_range)
         });
         if discovery_complete
             && !is_cancelled(cancel)
@@ -453,8 +466,12 @@ impl CostScanner {
                 };
             }
         } else {
-            cache.scan_since_key = Some(range.since_key.clone());
-            cache.scan_until_key = Some(range.until_key.clone());
+            cache.scan_since_key = Some(scan_range.scan_since_key.clone());
+            cache.scan_until_key = Some(scan_range.scan_until_key.clone());
+            cache.codex_pending_scan_since_key = None;
+            cache.codex_pending_scan_until_key = None;
+            cache.codex_pending_scan_root_paths.clear();
+            cache.codex_pending_scan_timezone = None;
             cache.previous_report = None;
             cache.codex_scan_pause_reason = None;
         }
@@ -564,12 +581,7 @@ impl CostScanner {
         let mut candidates = Vec::new();
         let mut seen = HashSet::new();
         let mut discovery_complete = true;
-        let cache_has_validated_state = cache.scan_since_key.is_some()
-            || cache.scan_until_key.is_some()
-            || cache.previous_report.is_some()
-            || !cache.files.is_empty()
-            || !cache.days.is_empty()
-            || !cache.codex_pending_paths.is_empty();
+        let cache_has_validated_state = codex_cache_has_validated_state(cache);
         let mut dates = codex_scan_dates(range);
         if self.options.prefer_newest_codex_sessions_first {
             dates.reverse();
@@ -826,6 +838,7 @@ impl CostScanner {
             let parser_state_safe = entry.codex_token_timestamps_monotonic.is_some();
             if cache_covers_range
                 && (same_partial || growing)
+                && !codex_cached_entry_is_complete_empty_fragment(entry)
                 && start_offset > 0
                 && start_offset <= size
                 && parser_state_safe
diff --git a/rust/src/cost_scanner/codex/logical_target.rs b/rust/src/cost_scanner/codex/logical_target.rs
index 90200d4b8c..20f27abd14 100644
--- a/rust/src/cost_scanner/codex/logical_target.rs
+++ b/rust/src/cost_scanner/codex/logical_target.rs
@@ -78,3 +78,14 @@ pub(super) fn codex_logical_target_has_unconsumed_tail(
     let target_size = codex_scan_target_size(usage);
     parsed_bytes < metadata_size || target_size < metadata_size
 }
+
+/// Whether a completed empty fragment has no parser state worth resuming.
+pub(super) fn codex_cached_entry_is_complete_empty_fragment(usage: &CostUsageFileUsage) -> bool {
+    usage.days.is_empty()
+        && usage.parsed_bytes == Some(usage.size)
+        && usage.codex_scan_target_size == Some(usage.size)
+        && usage.last_model.is_none()
+        && usage.last_totals.is_none()
+        && usage.codex_last_token_timestamp.is_none()
+        && usage.codex_token_timestamps_monotonic != Some(false)
+}
diff --git a/rust/src/cost_scanner/codex/pending_range.rs b/rust/src/cost_scanner/codex/pending_range.rs
new file mode 100644
index 0000000000..36710a956c
--- /dev/null
+++ b/rust/src/cost_scanner/codex/pending_range.rs
@@ -0,0 +1,113 @@
+use super::*;
+
+pub(super) struct CodexPendingScanContext {
+    pub(super) scan_range: CostUsageDayRange,
+    pub(super) is_incompatible: bool,
+    pub(super) root_paths: Vec<String>,
+    pub(super) timezone: String,
+}
+
+impl CodexPendingScanContext {
+    pub(super) fn new(
+        cache: &CostUsageCache,
+        range: &CostUsageDayRange,
+        sessions_dirs: &[PathBuf],
+        is_app_driven: bool,
+    ) -> Self {
+        let root_paths = codex_scan_root_keys(sessions_dirs);
+        let timezone = crate::core::local_timezone_name();
+        let is_compatible = !is_app_driven
+            && cache.codex_scan_incomplete
+            && codex_pending_scan_context_is_compatible(
+                cache,
+                &range.scan_until_key,
+                &root_paths,
+                &timezone,
+            );
+        let is_incompatible = cache.codex_scan_incomplete
+            && codex_pending_scan_context_is_known(cache)
+            && !is_compatible;
+        let scan_since_key = if is_compatible {
+            std::cmp::min(
+                cache
+                    .codex_pending_scan_since_key
+                    .as_deref()
+                    .unwrap_or(range.scan_since_key.as_str()),
+                range.scan_since_key.as_str(),
+            )
+            .to_string()
+        } else {
+            range.scan_since_key.clone()
+        };
+
+        Self {
+            scan_range: CostUsageDayRange {
+                since_key: range.since_key.clone(),
+                until_key: range.until_key.clone(),
+                scan_since_key,
+                scan_until_key: range.scan_until_key.clone(),
+            },
+            is_incompatible,
+            root_paths,
+            timezone,
+        }
+    }
+
+    pub(super) fn should_preserve_pause(
+        &self,
+        cache: &CostUsageCache,
+        is_app_driven: bool,
+    ) -> bool {
+        cache.codex_scan_incomplete && cache.codex_scan_pause_reason.is_some() && !is_app_driven
+    }
+}
+
+pub(super) fn codex_cache_has_validated_state(cache: &CostUsageCache) -> bool {
+    cache.scan_since_key.is_some()
+        || cache.scan_until_key.is_some()
+        || cache.previous_report.is_some()
+        || !cache.files.is_empty()
+        || !cache.days.is_empty()
+        || !cache.codex_pending_paths.is_empty()
+        || cache.codex_pending_scan_since_key.is_some()
+}
+
+fn codex_scan_root_keys(sessions_dirs: &[PathBuf]) -> Vec<String> {
+    let mut roots = sessions_dirs
+        .iter()
+        .map(|root| {
+            let resolved = fs::canonicalize(root).unwrap_or_else(|_| root.clone());
+            let key = resolved.to_string_lossy().to_string();
+            if cfg!(windows) {
+                key.to_ascii_lowercase()
+            } else {
+                key
+            }
+        })
+        .collect::<Vec<_>>();
+    roots.sort();
+    roots.dedup();
+    roots
+}
+
+fn codex_pending_scan_context_is_compatible(
+    cache: &CostUsageCache,
+    scan_until_key: &str,
+    root_paths: &[String],
+    timezone: &str,
+) -> bool {
+    cache
+        .codex_pending_scan_since_key
+        .as_deref()
+        .is_some_and(|since| CostUsageDayRange::parse_day_key(since).is_some())
+        && cache.codex_pending_scan_until_key.as_deref() == Some(scan_until_key)
+        && cache.codex_pending_scan_root_paths == root_paths
+        && cache.codex_pending_scan_timezone.as_deref() == Some(timezone)
+}
+
+fn codex_pending_scan_context_is_known(cache: &CostUsageCache) -> bool {
+    cache.codex_pending_scan_since_key.is_some()
+        || cache.codex_pending_scan_until_key.is_some()
+        || !cache.codex_pending_scan_root_paths.is_empty()
+        || cache.codex_pending_scan_timezone.is_some()
+}
diff --git a/rust/src/cost_scanner/tests.rs b/rust/src/cost_scanner/tests.rs
index 65da4bcdf8..6f238c21f7 100644
--- a/rust/src/cost_scanner/tests.rs
+++ b/rust/src/cost_scanner/tests.rs
@@ -2017,6 +2017,228 @@ fn trace_pruning_preserves_cursor_and_validated_history_until_refresh() {
     assert!(resumed_cache.previous_report.is_none());
 }
 
+fn expected_codex_scan_start(days: u32) -> String {
+    let today = Local::now().date_naive();
+    let report_start = today - Duration::days(i64::from(days.saturating_sub(1)));
+    CostUsageDayRange::new(report_start, today).scan_since_key
+}
+
+fn pending_codex_options(force: bool) -> CostScanOptions {
+    let mut options = if force {
+        CostScanOptions::app_driven()
+    } else {
+        CostScanOptions::default()
+    };
+    options.codex_candidate_limit = 1;
+    options
+}
+
+#[test]
+fn pending_codex_scan_30_to_7_keeps_wide_start_and_narrow_report() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    for index in 0..3 {
+        write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+    }
+
+    let first = CostScanner::new(30)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+    assert!(first_cache.codex_scan_incomplete);
+
+    let second = CostScanner::new(7)
+        .with_options(pending_codex_options(false))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (summary, _, second_cache) = second.scan_codex_detailed_with_cache(None);
+    let today = Local::now().date_naive();
+    assert!(second_cache.codex_scan_incomplete);
+    assert_eq!(
+        second_cache.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(30).as_str())
+    );
+    assert_eq!(summary.period_start, Some(today - Duration::days(6)));
+    assert_eq!(summary.period_end, Some(today));
+}
+
+#[test]
+fn pending_codex_scan_7_to_30_expands_to_earliest_start() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    for index in 0..3 {
+        write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+    }
+
+    let first = CostScanner::new(7)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+    assert!(first_cache.codex_scan_incomplete);
+
+    let second = CostScanner::new(30)
+        .with_options(pending_codex_options(false))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (_, _, second_cache) = second.scan_codex_detailed_with_cache(None);
+    assert!(second_cache.codex_scan_incomplete);
+    assert_eq!(
+        second_cache.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(30).as_str())
+    );
+}
+
+#[test]
+fn pending_codex_scan_repeated_narrow_wide_alternation_is_monotonic() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    for index in 0..8 {
+        write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+    }
+
+    let first = CostScanner::new(30)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+    assert!(first_cache.codex_scan_incomplete);
+
+    for days in [7, 30, 7, 30, 7] {
+        let scanner = CostScanner::new(days)
+            .with_options(pending_codex_options(false))
+            .with_cache_root(&cache_root)
+            .with_sessions_dirs(vec![sessions.clone()]);
+        let (_, _, cache) = scanner.scan_codex_detailed_with_cache(None);
+        assert!(cache.codex_scan_incomplete);
+        assert_eq!(
+            cache.codex_pending_scan_since_key.as_deref(),
+            Some(expected_codex_scan_start(30).as_str())
+        );
+    }
+}
+
+#[test]
+fn pending_codex_scan_incompatible_root_timezone_or_end_resets_start() {
+    for incompatibility in ["root", "timezone", "end"] {
+        let root = tempfile::tempdir().unwrap();
+        let sessions = root.path().join("sessions");
+        let alternate_sessions = root.path().join("alternate-sessions");
+        let cache_root = root.path().join("cache");
+        for index in 0..3 {
+            write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+            write_codex_session_fixture(
+                &alternate_sessions,
+                &format!("alternate-{index}.jsonl"),
+                200 + index,
+            );
+        }
+
+        let first = CostScanner::new(30)
+            .with_options(pending_codex_options(true))
+            .with_cache_root(&cache_root)
+            .with_sessions_dirs(vec![sessions.clone()]);
+        let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+        assert!(first_cache.codex_scan_incomplete);
+
+        let mut persisted = JsonlScanner::load_cache(ProviderId::Codex, Some(&cache_root));
+        match incompatibility {
+            "root" => {}
+            "timezone" => {
+                persisted.codex_pending_scan_timezone = Some("not-the-local-zone".to_string())
+            }
+            "end" => persisted.codex_pending_scan_until_key = Some("2099-01-01".to_string()),
+            _ => unreachable!(),
+        }
+        JsonlScanner::save_cache(ProviderId::Codex, &mut persisted, Some(&cache_root));
+
+        let roots = if incompatibility == "root" {
+            vec![alternate_sessions]
+        } else {
+            vec![sessions]
+        };
+        let second = CostScanner::new(7)
+            .with_options(pending_codex_options(false))
+            .with_cache_root(&cache_root)
+            .with_sessions_dirs(roots);
+        let (_, _, second_cache) = second.scan_codex_detailed_with_cache(None);
+        assert!(second_cache.codex_scan_incomplete);
+        assert_eq!(
+            second_cache.codex_pending_scan_since_key.as_deref(),
+            Some(expected_codex_scan_start(7).as_str()),
+            "{incompatibility} context must reset the pending start"
+        );
+    }
+}
+
+#[test]
+fn pending_codex_scan_force_rescan_resets_start() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    for index in 0..3 {
+        write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+    }
+
+    let first = CostScanner::new(30)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+    assert!(first_cache.codex_scan_incomplete);
+
+    let forced = CostScanner::new(7)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (_, _, forced_cache) = forced.scan_codex_detailed_with_cache(None);
+    assert!(forced_cache.codex_scan_incomplete);
+    assert_eq!(
+        forced_cache.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(7).as_str())
+    );
+}
+
+#[test]
+fn pending_codex_scan_start_survives_restart() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    for index in 0..3 {
+        write_codex_session_fixture(&sessions, &format!("pending-{index}.jsonl"), 100 + index);
+    }
+
+    let first = CostScanner::new(30)
+        .with_options(pending_codex_options(true))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = first.scan_codex_detailed_with_cache(None);
+    assert_eq!(
+        first_cache.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(30).as_str())
+    );
+
+    let persisted = JsonlScanner::load_cache(ProviderId::Codex, Some(&cache_root));
+    assert_eq!(
+        persisted.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(30).as_str())
+    );
+
+    let restarted = CostScanner::new(7)
+        .with_options(pending_codex_options(false))
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (_, _, restarted_cache) = restarted.scan_codex_detailed_with_cache(None);
+    assert_eq!(
+        restarted_cache.codex_pending_scan_since_key.as_deref(),
+        Some(expected_codex_scan_start(30).as_str())
+    );
+}
+
 #[test]
 fn disappeared_trace_path_waits_for_explicit_validation() {
     let root = tempfile::tempdir().unwrap();
@@ -2173,3 +2395,103 @@ fn legacy_cache_json_defaults_bounded_scan_state() {
     assert!(cache.codex_pending_paths.is_empty());
     assert!(!cache.codex_scan_incomplete);
 }
+
+#[test]
+fn complete_empty_codex_fragment_persists_in_cache() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    let path = write_codex_session_fixture(&sessions, "empty.jsonl", 100);
+    std::fs::write(&path, b"\n").unwrap();
+    let key = path.to_string_lossy().to_string();
+
+    let scanner = CostScanner::new(7)
+        .with_options(CostScanOptions::app_driven())
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (summary, _, cache) = scanner.scan_codex_detailed_with_cache(None);
+
+    assert_eq!(summary.input_tokens, 0);
+    let entry = cache.files.get(&key).expect("empty fragment is cached");
+    assert!(entry.days.is_empty());
+    assert_eq!(entry.parsed_bytes, Some(1));
+    assert_eq!(entry.codex_scan_target_size, Some(1));
+
+    let persisted = JsonlScanner::load_cache(ProviderId::Codex, Some(&cache_root));
+    assert!(persisted.files.contains_key(&key));
+}
+
+#[test]
+fn complete_empty_codex_fragment_reparses_from_start_after_growth() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    let path = write_codex_session_fixture(&sessions, "empty.jsonl", 100);
+    std::fs::write(&path, b"\n").unwrap();
+    let key = path.to_string_lossy().to_string();
+
+    let scanner = CostScanner::new(7)
+        .with_options(CostScanOptions::app_driven())
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions.clone()]);
+    let (_, _, first_cache) = scanner.scan_codex_detailed_with_cache(None);
+    let first = first_cache.files.get(&key).expect("initial empty fragment");
+    assert_eq!(first.parsed_bytes, Some(1));
+    assert_eq!(first.codex_scan_target_size, Some(1));
+
+    write_codex_session_fixture(&sessions, "empty.jsonl", 100);
+    let (grown_summary, stats, grown_cache) = scanner.scan_codex_detailed_with_cache(None);
+
+    assert_eq!(grown_summary.input_tokens, 100);
+    assert_eq!(stats.files_resumed, 0);
+    assert!(!grown_cache.files[&key].days.is_empty());
+}
+
+#[test]
+fn incomplete_or_buffered_empty_codex_fragment_is_not_marked_complete() {
+    let root = tempfile::tempdir().unwrap();
+    let sessions = root.path().join("sessions");
+    let cache_root = root.path().join("cache");
+    let path = write_codex_session_fixture(&sessions, "incomplete.jsonl", 100);
+    std::fs::write(&path, br#"{"timestamp":"2026-09-07T00:00:00Z""#).unwrap();
+    let key = path.to_string_lossy().to_string();
+
+    let scanner = CostScanner::new(7)
+        .with_options(CostScanOptions::app_driven())
+        .with_cache_root(&cache_root)
+        .with_sessions_dirs(vec![sessions]);
+    let (_, _, cache) = scanner.scan_codex_detailed_with_cache(None);
+
+    let entry = cache
+        .files
+        .get(&key)
+        .expect("incomplete fragment is tracked");
+    assert!(entry.days.is_empty());
+    assert_ne!(entry.parsed_bytes, Some(entry.size));
+    assert!(cache.codex_scan_incomplete);
+    assert!(cache.codex_pending_paths.contains(&key));
+
+    let buffered_root = tempfile::tempdir().unwrap();
+    let buffered_sessions = buffered_root.path().join("sessions");
+    let buffered_cache_root = buffered_root.path().join("cache");
+    let buffered_path = write_codex_session_fixture(&buffered_sessions, "buffered.jsonl", 100);
+    std::fs::write(&buffered_path, b"\nnot-yet-read").unwrap();
+    let buffered_key = buffered_path.to_string_lossy().to_string();
+    let mut options = CostScanOptions::app_driven();
+    options.codex_max_session_file_bytes = 1;
+    options.codex_max_scan_bytes_per_refresh = 1;
+    let buffered_scanner = CostScanner::new(7)
+        .with_options(options)
+        .with_cache_root(&buffered_cache_root)
+        .with_sessions_dirs(vec![buffered_sessions]);
+    let (_, _, buffered_cache) = buffered_scanner.scan_codex_detailed_with_cache(None);
+
+    let buffered_entry = buffered_cache
+        .files
+        .get(&buffered_key)
+        .expect("buffered fragment is tracked");
+    assert!(buffered_entry.days.is_empty());
+    assert_ne!(buffered_entry.parsed_bytes, Some(buffered_entry.size));
+    assert!(buffered_cache.codex_scan_incomplete);
+    assert!(buffered_cache.codex_pending_paths.contains(&buffered_key));
+}
diff --git a/rust/src/providers/antigravity/local_bot_id.rs b/rust/src/providers/antigravity/local_bot_id.rs
new file mode 100644
index 0000000000..d51825dd68
--- /dev/null
+++ b/rust/src/providers/antigravity/local_bot_id.rs
@@ -0,0 +1,151 @@
+use std::collections::{HashMap, HashSet};
+
+use super::super::local_step_resolver::StepOccurrence;
+use super::{Event, PendingTimestampRow, StepTimestampScan};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) struct ExactStepTimestamp {
+    pub(super) step_uuid: String,
+    pub(super) timestamp_ms: i64,
+}
+
+pub(super) fn record_exact_bot_id(
+    bot_id: &str,
+    step_uuid: &str,
+    timestamp_ms: i64,
+    by_bot_id: &mut HashMap<String, ExactStepTimestamp>,
+    ambiguous_bot_ids: &mut HashSet<String>,
+) {
+    if ambiguous_bot_ids.contains(bot_id) {
+        return;
+    }
+
+    let candidate = ExactStepTimestamp {
+        step_uuid: step_uuid.to_string(),
+        timestamp_ms,
+    };
+    match by_bot_id.get(bot_id) {
+        None => {
+            by_bot_id.insert(bot_id.to_string(), candidate);
+        }
+        Some(existing) if existing == &candidate => {}
+        Some(_) => {
+            by_bot_id.remove(bot_id);
+            ambiguous_bot_ids.insert(bot_id.to_string());
+        }
+    }
+}
+
+pub(super) fn embedded_timestamps_agree(
+    occurrences: &HashMap<String, Vec<StepOccurrence>>,
+    step_scan: &StepTimestampScan,
+    bot_id_uses: &HashMap<String, usize>,
+) -> bool {
+    for (step_uuid, occurrences) in occurrences {
+        for occurrence in occurrences {
+            let Some(bot_id) = occurrence.bot_id.as_deref() else {
+                continue;
+            };
+            if bot_id_uses.get(bot_id).copied() != Some(1) {
+                continue;
+            }
+            let Some(exact) = step_scan.by_bot_id.get(bot_id) else {
+                continue;
+            };
+            if step_scan.ambiguous_bot_ids.contains(bot_id)
+                || exact.step_uuid != *step_uuid
+                || occurrence
+                    .timestamp_ms
+                    .is_some_and(|ts| ts != exact.timestamp_ms)
+            {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+pub(super) fn append_recovered_events(
+    events: &mut Vec<Event>,
+    session: &str,
+    pending: &[PendingTimestampRow],
+    resolved: &HashMap<String, Vec<i64>>,
+    occurrences: &HashMap<String, Vec<StepOccurrence>>,
+    step_scan: &StepTimestampScan,
+    bot_id_uses: &HashMap<String, usize>,
+) -> usize {
+    let mut occurrence_offsets = HashMap::<String, HashMap<i64, usize>>::new();
+    for (step_uuid, occurrences) in occurrences {
+        let mut rows = occurrences
+            .iter()
+            .map(|occurrence| occurrence.row)
+            .collect::<Vec<_>>();
+        rows.sort_unstable();
+        if rows.windows(2).any(|pair| pair[0] == pair[1]) {
+            continue;
+        }
+        occurrence_offsets.insert(
+            step_uuid.clone(),
+            rows.into_iter()
+                .enumerate()
+                .map(|(offset, row)| (row, offset))
+                .collect(),
+        );
+    }
+
+    let mut recovered = 0;
+    let mut pending_rows = pending.iter().collect::<Vec<_>>();
+    pending_rows.sort_by_key(|pending| pending.row);
+    for pending in pending_rows {
+        if let Some(bot_id) = pending
+            .turn
+            .usage
+            .as_ref()
+            .and_then(|usage| usage.bot_id.as_deref())
+        {
+            if step_scan.ambiguous_bot_ids.contains(bot_id) {
+                continue;
+            }
+            if let Some(exact) = step_scan.by_bot_id.get(bot_id) {
+                if exact.step_uuid != pending.step_uuid {
+                    continue;
+                }
+                if bot_id_uses.get(bot_id) == Some(&1) {
+                    let mut turn = pending.turn.clone();
+                    turn.timestamp_ms = Some(exact.timestamp_ms);
+                    events.push(Event {
+                        session: session.to_string(),
+                        row: pending.row,
+                        turn,
+                        total: pending.total,
+                    });
+                    recovered += 1;
+                    continue;
+                }
+            }
+        }
+        let Some(timestamps) = resolved.get(&pending.step_uuid) else {
+            continue;
+        };
+        let Some(offset) = occurrence_offsets
+            .get(&pending.step_uuid)
+            .and_then(|rows| rows.get(&pending.row))
+        else {
+            continue;
+        };
+        let Some(timestamp_ms) = timestamps.get(*offset) else {
+            continue;
+        };
+        let mut turn = pending.turn.clone();
+        turn.timestamp_ms = Some(*timestamp_ms);
+        events.push(Event {
+            session: session.to_string(),
+            row: pending.row,
+            turn,
+            total: pending.total,
+        });
+        recovered += 1;
+    }
+    events.sort_by_key(|event| event.row);
+    recovered
+}
diff --git a/rust/src/providers/antigravity/local_proto.rs b/rust/src/providers/antigravity/local_proto.rs
index 099f25e07b..851b80a2fa 100644
--- a/rust/src/providers/antigravity/local_proto.rs
+++ b/rust/src/providers/antigravity/local_proto.rs
@@ -6,6 +6,7 @@ pub(super) struct ParsedUsage {
     pub output: u64,
     pub reasoning: u64,
     pub response_id: Option<String>,
+    pub bot_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
@@ -17,6 +18,13 @@ pub(super) struct ParsedTurn {
     pub step_uuid: Option<String>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) struct StepMetadata {
+    pub step_uuid: Option<String>,
+    pub bot_id: Option<String>,
+    pub timestamp_ms: Option<i64>,
+}
+
 #[derive(Clone, Copy)]
 enum FieldValue<'a> {
     Varint(u64),
@@ -119,6 +127,44 @@ fn identity_text(field: Field<'_>) -> Option<Option<String>> {
     Some((!value.trim().is_empty()).then(|| value.to_string()))
 }
 
+fn auxiliary_text(field: Field<'_>) -> Result<Option<String>, ()> {
+    let value = std::str::from_utf8(message(field).ok_or(())?).map_err(|_| ())?;
+    Ok((!value.trim().is_empty()).then(|| value.to_string()))
+}
+
+#[derive(Debug, Default)]
+struct AuxiliaryIdentifier {
+    value: Option<String>,
+    valid: bool,
+}
+
+impl AuxiliaryIdentifier {
+    fn new() -> Self {
+        Self {
+            value: None,
+            valid: true,
+        }
+    }
+
+    fn read(&mut self, field: Field<'_>) {
+        if !self.valid {
+            return;
+        }
+        match auxiliary_text(field) {
+            Ok(value) => self.value = value,
+            Err(()) => {
+                self.value = None;
+                self.valid = false;
+            }
+        }
+    }
+
+    fn invalidate(&mut self) {
+        self.value = None;
+        self.valid = false;
+    }
+}
+
 fn timestamp_millis(seconds: Option<u64>, nanos: u64) -> Option<Option<i64>> {
     let Some(seconds) = seconds else {
         return Some(None);
@@ -155,8 +201,9 @@ pub(super) fn parse_turn(root: &[u8]) -> Option<ParsedTurn> {
     Some(turn)
 }
 
-pub(super) fn parse_step_metadata(root: &[u8]) -> Option<(Option<String>, Option<i64>)> {
+pub(super) fn parse_step_metadata(root: &[u8]) -> Option<StepMetadata> {
     let mut step_uuid = None;
+    let mut bot_identifier = AuxiliaryIdentifier::new();
     let mut seconds = None;
     let mut nanos = 0_u64;
     let mut timestamp_is_valid = true;
@@ -171,6 +218,22 @@ pub(super) fn parse_step_metadata(root: &[u8]) -> Option<(Option<String>, Option
                     timestamp_is_valid = false;
                 }
             }
+            9 => {
+                let Some(envelope) = message(field) else {
+                    bot_identifier.invalidate();
+                    return Some(());
+                };
+                if fields(envelope, |subfield| {
+                    if subfield.number == 7 {
+                        bot_identifier.read(subfield);
+                    }
+                    Some(())
+                })
+                .is_none()
+                {
+                    bot_identifier.invalidate();
+                }
+            }
             12 => step_uuid = identity_text(field)?,
             _ => {}
         }
@@ -181,7 +244,11 @@ pub(super) fn parse_step_metadata(root: &[u8]) -> Option<(Option<String>, Option
     } else {
         None
     };
-    Some((step_uuid, timestamp_ms))
+    Some(StepMetadata {
+        step_uuid,
+        bot_id: bot_identifier.value,
+        timestamp_ms,
+    })
 }
 
 fn parse_chat(
@@ -206,18 +273,22 @@ fn parse_chat(
     })
 }
 fn parse_usage(bytes: &[u8], usage: &mut ParsedUsage) -> Option<()> {
+    let mut bot_identifier = AuxiliaryIdentifier::new();
     fields(bytes, |field| {
         match field.number {
             1 => usage.system_prompt = integer(field)?,
             2 => usage.new_input = integer(field)?,
             5 => usage.cache_read = integer(field)?,
+            7 => bot_identifier.read(field),
             9 => usage.output = integer(field)?,
             10 => usage.reasoning = integer(field)?,
             11 => usage.response_id = text(field)?,
             _ => {}
         }
         Some(())
-    })
+    })?;
+    usage.bot_id = bot_identifier.value;
+    Some(())
 }
 fn parse_generation(bytes: &[u8], seconds: &mut Option<u64>, nanos: &mut u64) -> Option<()> {
     fields(bytes, |field| {
@@ -306,6 +377,7 @@ mod tests {
         assert_eq!(usage.output, 40);
         assert_eq!(usage.reasoning, 50);
         assert_eq!(usage.response_id.as_deref(), Some("response-1"));
+        assert_eq!(usage.bot_id, None);
         assert_eq!(turn.timestamp_ms, Some(1_787_572_800_123));
     }
     #[test]
@@ -341,7 +413,11 @@ mod tests {
         metadata.extend(field_bytes(12, step_uuid.as_bytes()));
         assert_eq!(
             parse_step_metadata(&metadata),
-            Some((Some(step_uuid.to_string()), Some(1_787_572_800_123)))
+            Some(StepMetadata {
+                step_uuid: Some(step_uuid.to_string()),
+                bot_id: None,
+                timestamp_ms: Some(1_787_572_800_123),
+            })
         );
     }
 
@@ -352,7 +428,39 @@ mod tests {
 
         assert_eq!(
             parse_step_metadata(&metadata),
-            Some((Some("step-uuid-1".to_string()), None))
+            Some(StepMetadata {
+                step_uuid: Some("step-uuid-1".to_string()),
+                bot_id: None,
+                timestamp_ms: None,
+            })
+        );
+    }
+
+    #[test]
+    fn malformed_optional_bot_id_does_not_discard_usage() {
+        let mut usage = field_varint(2, 20);
+        usage.extend(field_bytes(7, &[0xff]));
+        usage.extend(field_varint(9, 40));
+        let root = field_bytes(1, &field_bytes(4, &usage));
+
+        let turn = parse_turn(&root).expect("malformed optional ID must not discard turn");
+        assert_eq!(turn.usage.unwrap().bot_id, None);
+    }
+
+    #[test]
+    fn malformed_step_bot_id_disables_exact_identity_but_keeps_metadata() {
+        let mut envelope = field_bytes(7, &[0xff]);
+        envelope.extend(field_bytes(7, b"later-valid-id"));
+        let mut metadata = field_bytes(9, &envelope);
+        metadata.extend(field_bytes(12, b"step-uuid-1"));
+
+        assert_eq!(
+            parse_step_metadata(&metadata),
+            Some(StepMetadata {
+                step_uuid: Some("step-uuid-1".to_string()),
+                bot_id: None,
+                timestamp_ms: None,
+            })
         );
     }
 }
diff --git a/rust/src/providers/antigravity/local_sqlite.rs b/rust/src/providers/antigravity/local_sqlite.rs
index 1149988b99..f0d9cb2ff4 100644
--- a/rust/src/providers/antigravity/local_sqlite.rs
+++ b/rust/src/providers/antigravity/local_sqlite.rs
@@ -1,3 +1,6 @@
+#[path = "local_bot_id.rs"]
+mod local_bot_id;
+
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -6,6 +9,7 @@ use std::time::{Duration as StdDuration, Instant};
 use chrono::{DateTime, Duration, Local, TimeZone, Utc};
 use rusqlite::{Connection, OpenFlags, TransactionBehavior, types::ValueRef};
 
+use self::local_bot_id::{ExactStepTimestamp, embedded_timestamps_agree, record_exact_bot_id};
 use super::local_proto::{ParsedTurn, parse_step_metadata, parse_turn};
 use super::local_sessions::{LocalHistoryCoverage, LocalSessionSummary};
 use super::local_step_resolver::{StepOccurrence, StepTimestamp, resolve_step_timestamps};
@@ -87,6 +91,7 @@ struct ParsedRows {
     events: Vec<Event>,
     pending: Vec<PendingTimestampRow>,
     occurrences: HashMap<String, Vec<StepOccurrence>>,
+    bot_id_uses: HashMap<String, usize>,
     database_bytes: usize,
     complete: bool,
 }
@@ -94,6 +99,8 @@ struct ParsedRows {
 #[derive(Debug)]
 struct StepTimestampScan {
     timestamps: HashMap<String, Vec<StepTimestamp>>,
+    by_bot_id: HashMap<String, ExactStepTimestamp>,
+    ambiguous_bot_ids: HashSet<String>,
     complete: bool,
 }
 
@@ -344,13 +351,19 @@ fn read_database(path: &Path, budget: &mut Budget) -> rusqlite::Result<(Vec<Even
         return Ok((rows.events, false));
     }
 
+    if !embedded_timestamps_agree(&rows.occurrences, &step_scan, &rows.bot_id_uses) {
+        return Ok((rows.events, false));
+    }
+
     let resolved = resolve_step_timestamps(&step_scan.timestamps, &needed_occurrences);
-    let recovered = append_recovered_events(
+    let recovered = local_bot_id::append_recovered_events(
         &mut rows.events,
         &session,
         &rows.pending,
         &resolved,
         &rows.occurrences,
+        &step_scan,
+        &rows.bot_id_uses,
     );
     if recovered < rows.pending.len() {
         rows.complete = false;
@@ -375,6 +388,7 @@ fn read_generation_rows(
     let mut events = Vec::new();
     let mut pending = Vec::new();
     let mut occurrences: HashMap<String, Vec<StepOccurrence>> = HashMap::new();
+    let mut bot_id_uses = HashMap::new();
 
     while let Some(row) = query.next()? {
         if !budget.check() {
@@ -439,6 +453,9 @@ fn read_generation_rows(
             continue;
         };
         let step_uuid = turn.step_uuid.clone();
+        if let Some(bot_id) = turn.usage.as_ref().and_then(|usage| usage.bot_id.as_ref()) {
+            *bot_id_uses.entry(bot_id.clone()).or_insert(0) += 1;
+        }
         if let Some(step_uuid) = step_uuid.as_deref() {
             occurrences
                 .entry(step_uuid.to_string())
@@ -446,6 +463,7 @@ fn read_generation_rows(
                 .push(StepOccurrence {
                     row: idx,
                     timestamp_ms: turn.timestamp_ms,
+                    bot_id: turn.usage.as_ref().and_then(|usage| usage.bot_id.clone()),
                 });
         }
         match (turn.timestamp_ms, step_uuid) {
@@ -469,6 +487,7 @@ fn read_generation_rows(
         events,
         pending,
         occurrences,
+        bot_id_uses,
         database_bytes,
         complete,
     })
@@ -495,6 +514,8 @@ fn read_step_timestamps(
     let blob_limit = i64::try_from(MAX_BLOB_BYTES).unwrap_or(i64::MAX);
     let mut query = statement.query([blob_limit])?;
     let mut timestamps = HashMap::<String, Vec<StepTimestamp>>::new();
+    let mut by_bot_id = HashMap::<String, ExactStepTimestamp>::new();
+    let mut ambiguous_bot_ids = HashSet::new();
     let mut complete = true;
     let mut rows_are_valid = true;
 
@@ -547,87 +568,68 @@ fn read_step_timestamps(
                 continue;
             }
         };
-        let Some((step_uuid, timestamp_ms)) = parse_step_metadata(blob) else {
+        let Some(metadata) = parse_step_metadata(blob) else {
             rows_are_valid = false;
             continue;
         };
-        let Some(step_uuid) = step_uuid.filter(|value| !value.is_empty()) else {
+        let Some(step_uuid) = metadata.step_uuid.filter(|value| !value.is_empty()) else {
             rows_are_valid = false;
             continue;
         };
+        if let Some(bot_id) = metadata.bot_id.as_deref()
+            && let Some(timestamp_ms) = metadata.timestamp_ms
+        {
+            record_exact_bot_id(
+                bot_id,
+                &step_uuid,
+                timestamp_ms,
+                &mut by_bot_id,
+                &mut ambiguous_bot_ids,
+            );
+        }
         if needed_occurrences.contains_key(&step_uuid) {
             timestamps
                 .entry(step_uuid)
                 .or_default()
                 .push(StepTimestamp {
                     row: idx,
-                    timestamp_ms,
+                    timestamp_ms: metadata.timestamp_ms,
+                    bot_id: metadata.bot_id,
                 });
         }
     }
 
+    let positional_timestamps = timestamps
+        .into_iter()
+        .map(|(step_uuid, values)| {
+            let values = values
+                .into_iter()
+                .map(|timestamp| StepTimestamp {
+                    row: timestamp.row,
+                    timestamp_ms: if timestamp
+                        .bot_id
+                        .as_deref()
+                        .is_some_and(|bot_id| ambiguous_bot_ids.contains(bot_id))
+                    {
+                        None
+                    } else {
+                        timestamp.timestamp_ms
+                    },
+                    bot_id: timestamp.bot_id,
+                })
+                .collect();
+            (step_uuid, values)
+        })
+        .collect();
+
     Ok(StepTimestampScan {
-        timestamps,
+        timestamps: positional_timestamps,
+        by_bot_id,
+        ambiguous_bot_ids,
         complete: complete && rows_are_valid,
     })
 }
 
-fn append_recovered_events(
-    events: &mut Vec<Event>,
-    session: &str,
-    pending: &[PendingTimestampRow],
-    resolved: &HashMap<String, Vec<i64>>,
-    occurrences: &HashMap<String, Vec<StepOccurrence>>,
-) -> usize {
-    let mut occurrence_offsets = HashMap::<String, HashMap<i64, usize>>::new();
-    for (step_uuid, occurrences) in occurrences {
-        let mut rows = occurrences
-            .iter()
-            .map(|occurrence| occurrence.row)
-            .collect::<Vec<_>>();
-        rows.sort_unstable();
-        if rows.windows(2).any(|pair| pair[0] == pair[1]) {
-            continue;
-        }
-        occurrence_offsets.insert(
-            step_uuid.clone(),
-            rows.into_iter()
-                .enumerate()
-                .map(|(offset, row)| (row, offset))
-                .collect(),
-        );
-    }
-
-    let mut recovered = 0;
-    let mut pending_rows = pending.iter().collect::<Vec<_>>();
-    pending_rows.sort_by_key(|pending| pending.row);
-    for pending in pending_rows {
-        let Some(timestamps) = resolved.get(&pending.step_uuid) else {
-            continue;
-        };
-        let Some(offset) = occurrence_offsets
-            .get(&pending.step_uuid)
-            .and_then(|rows| rows.get(&pending.row))
-        else {
-            continue;
-        };
-        let Some(timestamp_ms) = timestamps.get(*offset) else {
-            continue;
-        };
-        let mut turn = pending.turn.clone();
-        turn.timestamp_ms = Some(*timestamp_ms);
-        events.push(Event {
-            session: session.to_string(),
-            row: pending.row,
-            turn,
-            total: pending.total,
-        });
-        recovered += 1;
-    }
-    events.sort_by_key(|event| event.row);
-    recovered
-}
-
 fn supported_schema(conn: &Connection, budget: &mut Budget) -> rusqlite::Result<bool> {
     let mut statement =
         conn.prepare("SELECT name, type, rootpage FROM main.sqlite_master LIMIT ?1")?;
diff --git a/rust/src/providers/antigravity/local_sqlite_synthetic_tests.rs b/rust/src/providers/antigravity/local_sqlite_synthetic_tests.rs
index 6b8d3a361a..0e9f38de2f 100644
--- a/rust/src/providers/antigravity/local_sqlite_synthetic_tests.rs
+++ b/rust/src/providers/antigravity/local_sqlite_synthetic_tests.rs
@@ -44,11 +44,23 @@ fn field_bytes(number: u64, value: &[u8]) -> Vec<u8> {
 }
 
 fn turn_blob(step_uuid: Option<&str>, input: u64, timestamp: Option<u64>) -> Vec<u8> {
+    turn_blob_with_bot_id(step_uuid, input, timestamp, None)
+}
+
+fn turn_blob_with_bot_id(
+    step_uuid: Option<&str>,
+    input: u64,
+    timestamp: Option<u64>,
+    bot_id: Option<&str>,
+) -> Vec<u8> {
     let mut usage = field_varint(1, 11);
     usage.extend(field_varint(2, input));
     usage.extend(field_varint(5, 50));
     usage.extend(field_varint(9, 30));
     usage.extend(field_varint(10, 7));
+    if let Some(bot_id) = bot_id {
+        usage.extend(field_bytes(7, bot_id.as_bytes()));
+    }
 
     let mut chat = field_bytes(4, &usage);
     if let Some(seconds) = timestamp {
@@ -68,6 +80,14 @@ fn turn_blob(step_uuid: Option<&str>, input: u64, timestamp: Option<u64>) -> Vec
 }
 
 fn step_metadata(step_uuid: Option<&str>, timestamp: Option<u64>) -> Vec<u8> {
+    step_metadata_with_bot_id(step_uuid, timestamp, None)
+}
+
+fn step_metadata_with_bot_id(
+    step_uuid: Option<&str>,
+    timestamp: Option<u64>,
+    bot_id: Option<&str>,
+) -> Vec<u8> {
     let mut metadata = Vec::new();
     if let Some(seconds) = timestamp {
         let mut stamp = field_varint(1, seconds);
@@ -77,6 +97,9 @@ fn step_metadata(step_uuid: Option<&str>, timestamp: Option<u64>) -> Vec<u8> {
     if let Some(step_uuid) = step_uuid {
         metadata.extend(field_bytes(12, step_uuid.as_bytes()));
     }
+    if let Some(bot_id) = bot_id {
+        metadata.extend(field_bytes(9, &field_bytes(7, bot_id.as_bytes())));
+    }
     metadata
 }
 
@@ -295,3 +318,127 @@ fn embedded_and_step_timestamps_must_agree() {
     assert_eq!(summary.coverage, LocalHistoryCoverage::Partial);
     assert_eq!(summary.total_tokens, 198);
 }
+
+#[test]
+fn unique_bot_ids_recover_each_turn_despite_auxiliary_step_rows() {
+    let dir = tempfile::tempdir().unwrap();
+    let uuid = "per-turn";
+    database(
+        &dir,
+        "bot-correlation",
+        &[
+            (
+                10,
+                turn_blob_with_bot_id(Some(uuid), 100, None, Some("bot-a")),
+            ),
+            (
+                20,
+                turn_blob_with_bot_id(Some(uuid), 200, None, Some("bot-b")),
+            ),
+        ],
+        Some(&[
+            (
+                1,
+                Some(step_metadata_with_bot_id(
+                    Some(uuid),
+                    Some(NOW_SECONDS - 300),
+                    Some("auxiliary"),
+                )),
+            ),
+            (
+                2,
+                Some(step_metadata_with_bot_id(
+                    Some(uuid),
+                    Some(NOW_SECONDS - 120),
+                    Some("bot-a"),
+                )),
+            ),
+            (
+                3,
+                Some(step_metadata_with_bot_id(
+                    Some(uuid),
+                    Some(NOW_SECONDS - 60),
+                    Some("bot-b"),
+                )),
+            ),
+        ]),
+    );
+
+    let summary = summary(&dir);
+
+    assert_eq!(summary.coverage, LocalHistoryCoverage::Complete);
+    assert_eq!(summary.total_tokens, 496);
+}
+
+#[test]
+fn conflicting_bot_id_evidence_is_withheld() {
+    let dir = tempfile::tempdir().unwrap();
+    let uuid = "ambiguous-bot";
+    database(
+        &dir,
+        "ambiguous-bot",
+        &[(
+            (0),
+            turn_blob_with_bot_id(Some(uuid), 100, None, Some("bot-x")),
+        )],
+        Some(&[
+            (
+                10,
+                Some(step_metadata_with_bot_id(
+                    Some(uuid),
+                    Some(NOW_SECONDS - 120),
+                    Some("bot-x"),
+                )),
+            ),
+            (
+                20,
+                Some(step_metadata_with_bot_id(
+                    Some(uuid),
+                    Some(NOW_SECONDS - 60),
+                    Some("bot-x"),
+                )),
+            ),
+        ]),
+    );
+
+    let summary = summary(&dir);
+
+    assert_eq!(summary.coverage, LocalHistoryCoverage::Partial);
+    assert_eq!(summary.total_tokens, 0);
+}
+
+#[test]
+fn cross_step_bot_id_evidence_is_withheld() {
+    let dir = tempfile::tempdir().unwrap();
+    database(
+        &dir,
+        "cross-step-bot",
+        &[(
+            (0),
+            turn_blob_with_bot_id(Some("needed-step"), 100, None, Some("bot-x")),
+        )],
+        Some(&[
+            (
+                10,
+                Some(step_metadata_with_bot_id(
+                    Some("other-step"),
+                    Some(NOW_SECONDS - 120),
+                    Some("bot-x"),
+                )),
+            ),
+            (
+                20,
+                Some(step_metadata_with_bot_id(
+                    Some("needed-step"),
+                    Some(NOW_SECONDS - 60),
+                    Some("other-bot"),
+                )),
+            ),
+        ]),
+    );
+
+    let summary = summary(&dir);
+
+    assert_eq!(summary.coverage, LocalHistoryCoverage::Partial);
+    assert_eq!(summary.total_tokens, 0);
+}
diff --git a/rust/src/providers/antigravity/local_step_resolver.rs b/rust/src/providers/antigravity/local_step_resolver.rs
index 12bfb2e42c..5a68e4cc01 100644
--- a/rust/src/providers/antigravity/local_step_resolver.rs
+++ b/rust/src/providers/antigravity/local_step_resolver.rs
@@ -1,15 +1,17 @@
 use std::collections::HashMap;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) struct StepOccurrence {
     pub row: i64,
     pub timestamp_ms: Option<i64>,
+    pub bot_id: Option<String>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) struct StepTimestamp {
     pub row: i64,
     pub timestamp_ms: Option<i64>,
+    pub bot_id: Option<String>,
 }
 
 pub(super) fn resolve_step_timestamps(
@@ -88,13 +90,21 @@ mod tests {
 
     fn occurrences(rows: &[(i64, Option<i64>)]) -> Vec<StepOccurrence> {
         rows.iter()
-            .map(|&(row, timestamp_ms)| StepOccurrence { row, timestamp_ms })
+            .map(|&(row, timestamp_ms)| StepOccurrence {
+                row,
+                timestamp_ms,
+                bot_id: None,
+            })
             .collect()
     }
 
     fn timestamps(rows: &[(i64, Option<i64>)]) -> Vec<StepTimestamp> {
         rows.iter()
-            .map(|&(row, timestamp_ms)| StepTimestamp { row, timestamp_ms })
+            .map(|&(row, timestamp_ms)| StepTimestamp {
+                row,
+                timestamp_ms,
+                bot_id: None,
+            })
             .collect()
     }
 
diff --git a/rust/src/providers/claude/mod.rs b/rust/src/providers/claude/mod.rs
index 700f21fbcd..7677c80ee6 100755
--- a/rust/src/providers/claude/mod.rs
+++ b/rust/src/providers/claude/mod.rs
@@ -67,7 +67,13 @@ fn cached_cli_result() -> Option<ProviderFetchResult> {
     guard
         .as_ref()
         .filter(|entry| entry.cached_at.elapsed() <= CLI_RESULT_CACHE_TTL)
-        .map(|entry| entry.result.clone())
+        .map(|entry| {
+            let mut result = entry.result.clone();
+            // A retained payload is useful for display, but cannot prove that
+            // the current fetch reached Claude CLI successfully.
+            result.has_successful_claude_cli_quota = false;
+            result
+        })
 }
 
 /// Whether the OAuth source failed with a revocation (not just expiry).
@@ -630,7 +636,9 @@ impl ClaudeProvider {
             return Err(error);
         }
 
-        self.parse_cli_output(&combined)
+        Ok(mark_live_claude_cli_result(
+            self.parse_cli_output(&combined)?,
+        ))
     }
 
     /// Parse Claude CLI /usage output
@@ -756,6 +764,18 @@ impl ClaudeProvider {
     }
 }
 
+fn has_real_claude_quota_window(usage: &UsageSnapshot) -> bool {
+    let is_real = |window: &RateWindow| !window.is_informational && window.used_percent.is_finite();
+    is_real(&usage.primary) || usage.secondary.as_ref().is_some_and(is_real)
+}
+
+fn mark_live_claude_cli_result(mut result: ProviderFetchResult) -> ProviderFetchResult {
+    if has_real_claude_quota_window(&result.usage) {
+        result.has_successful_claude_cli_quota = true;
+    }
+    result
+}
+
 fn record_auto_source(
     failures: &mut Vec<(&'static str, ProviderError)>,
     source: &'static str,
@@ -1579,11 +1599,32 @@ Active days: 2/10              Longest streak: 1 day
 
     #[test]
     fn cli_result_cache_round_trips() {
-        let result = ProviderFetchResult::new(UsageSnapshot::new(RateWindow::new(42.0)), "cli");
+        let mut result = ProviderFetchResult::new(UsageSnapshot::new(RateWindow::new(42.0)), "cli");
+        result.has_successful_claude_cli_quota = true;
         cache_cli_result(result.clone());
         let cached = cached_cli_result().expect("cached result within TTL");
         assert!((cached.usage.primary.used_percent - 42.0).abs() < 0.01);
         assert_eq!(cached.source_label, "cli");
+        assert!(!cached.has_successful_claude_cli_quota);
+    }
+
+    #[test]
+    fn live_identity_less_cli_quota_proves_account_action() {
+        let provider = ClaudeProvider::new();
+        let result = provider
+            .parse_cli_output("Current session\n25% used\nCurrent week (all models)\n40% used")
+            .expect("CLI quota should parse");
+        let result = mark_live_claude_cli_result(result);
+
+        assert!(result.usage.account_email.is_none());
+        assert!(result.has_successful_claude_cli_quota);
+    }
+
+    #[test]
+    fn non_cli_fetch_result_does_not_prove_account_action() {
+        let result = ProviderFetchResult::new(UsageSnapshot::new(RateWindow::new(42.0)), "oauth");
+
+        assert!(!result.has_successful_claude_cli_quota);
     }
     #[test]
     fn cli_presence_maps_to_local_runtime_offline() {
diff --git a/rust/src/providers/codex/mod.rs b/rust/src/providers/codex/mod.rs
index 11652cf452..399bc51577 100755
--- a/rust/src/providers/codex/mod.rs
+++ b/rust/src/providers/codex/mod.rs
@@ -49,8 +49,17 @@ fn fetch_result(
     cost: Option<crate::core::CostSnapshot>,
     source: &str,
 ) -> ProviderFetchResult {
+    let account_email = usage.account_email.clone();
     let mut result = ProviderFetchResult::new(usage, source);
-    if let Some(cost) = cost {
+    if let Some(cost) = cost.map(|cost| {
+        if cost.account_id.is_none()
+            && let Some(account) = account_email.as_deref()
+        {
+            cost.with_account_id(account)
+        } else {
+            cost
+        }
+    }) {
         result = result.with_cost(cost);
     }
     result
diff --git a/rust/src/providers/kilo/mod.rs b/rust/src/providers/kilo/mod.rs
index 0ed77bcc2c..db39158569 100644
--- a/rust/src/providers/kilo/mod.rs
+++ b/rust/src/providers/kilo/mod.rs
@@ -71,7 +71,7 @@ impl KiloProvider {
         }
 
         Err(ProviderError::NotInstalled(
-            "Kilo API key not found. Set KILO_API_KEY, store in keychain, or sign in with Kilo CLI."
+            "Kilo API key not found. Set KILO_API_KEY, store in keychain, or run `kilo auth login`."
                 .to_string(),
         ))
     }
diff --git a/rust/src/providers/zai/mcp_details.rs b/rust/src/providers/zai/mcp_details.rs
index e0ce09cb99..d5e9e88f60 100755
--- a/rust/src/providers/zai/mcp_details.rs
+++ b/rust/src/providers/zai/mcp_details.rs
@@ -78,7 +78,9 @@ impl ZaiUsageDetail {
 
     /// Format usage as human-readable string
     pub fn format_usage(&self) -> String {
-        if self.usage >= 1_000_000 {
+        if self.usage >= 1_000_000_000 {
+            format!("{:.1}B tokens", self.usage as f64 / 1_000_000_000.0)
+        } else if self.usage >= 1_000_000 {
             format!("{:.1}M tokens", self.usage as f64 / 1_000_000.0)
         } else if self.usage >= 1_000 {
             format!("{:.1}K tokens", self.usage as f64 / 1_000.0)
@@ -394,6 +396,10 @@ mod tests {
 
     #[test]
     fn test_usage_detail_format() {
+        let detail = ZaiUsageDetail::new("glm-5", 1_500_000_000);
+        assert_eq!(detail.usage, 1_500_000_000);
+        assert_eq!(detail.format_usage(), "1.5B tokens");
+
         let detail = ZaiUsageDetail::new("claude-3-opus", 1_500_000);
         assert_eq!(detail.format_usage(), "1.5M tokens");
 
diff --git a/rust/src/providers/zai/mod.rs b/rust/src/providers/zai/mod.rs
index 945bf0e23a..7e5a11cd8b 100755
--- a/rust/src/providers/zai/mod.rs
+++ b/rust/src/providers/zai/mod.rs
@@ -6,6 +6,7 @@
 mod balance;
 pub mod mcp_details;
 pub mod region;
+mod reset_plausibility;
 pub mod settings;
 
 // Re-exports for MCP details menu
@@ -29,6 +30,7 @@ use crate::core::{
     RateWindow, SourceMode, UsageSnapshot,
 };
 
+use reset_plausibility::is_plausible_five_hour_reset;
 use settings::ZaiSettingsReader;
 
 const ZAI_USAGE_SCOPE_ENV: &str = "Z_AI_USAGE_SCOPE";
@@ -397,16 +399,8 @@ impl ZaiProvider {
         // windows keep duration minutes; TIME_LIMIT (MCP) carries the "MCP"
         // label and no window duration; 5-hour token windows are labeled
         // "5-hour"; otherwise the explicit window label is used.
-        fn make_window(l: &ZaiLimit) -> RateWindow {
-            let resets_at = l
-                .next_reset_time
-                .and_then(DateTime::<Utc>::from_timestamp_millis)
-                .or_else(|| {
-                    l.reset_at
-                        .as_deref()
-                        .and_then(|value| DateTime::parse_from_rfc3339(value).ok())
-                        .map(|timestamp| timestamp.with_timezone(&Utc))
-                });
+        let now = Utc::now();
+        let make_window = |l: &ZaiLimit| -> RateWindow {
             let is_tokens = matches!(
                 l.limit_type.as_deref(),
                 Some("TOKENS_LIMIT") | Some("CREDIT_LIMIT") | Some("tokens")
@@ -416,13 +410,24 @@ impl ZaiProvider {
             } else {
                 None
             };
+            let resets_at = l
+                .next_reset_time
+                .and_then(DateTime::<Utc>::from_timestamp_millis)
+                .or_else(|| {
+                    l.reset_at
+                        .as_deref()
+                        .and_then(|value| DateTime::parse_from_rfc3339(value).ok())
+                        .map(|timestamp| timestamp.with_timezone(&Utc))
+                });
+            let resets_at =
+                resets_at.filter(|reset| is_plausible_five_hour_reset(window_mins, *reset, now));
             RateWindow::with_details(
                 compute_percent(l),
                 window_mins,
                 resets_at,
                 rate_window_reset_description(l, window_mins),
             )
-        }
+        };
 
         // Upstream 0.48.0 bucket split: with 2+ token limits, the shortest
         // window → session (5-hour GLM Coding Plan window) and the longest →
@@ -608,379 +613,4 @@ impl Provider for ZaiProvider {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use settings::EnvMap;
-    use std::collections::HashMap;
-
-    fn env_map(pairs: &[(&str, &str)]) -> EnvMap {
-        pairs
-            .iter()
-            .map(|(key, value)| (key.to_string(), value.to_string()))
-            .collect::<HashMap<_, _>>()
-    }
-
-    #[test]
-    fn request_url_adds_team_type_query_for_team_context() {
-        let env = env_map(&[]);
-        let team = ZaiTeamContext {
-            organization_id: "org".to_string(),
-            project_id: "project".to_string(),
-        };
-
-        let url = ZaiProvider::request_url(&env, ZaiRegion::Global, Some(&team)).expect("url");
-
-        assert_eq!(
-            url.as_str(),
-            "https://api.z.ai/api/monitor/usage/quota/limit?type=2"
-        );
-    }
-
-    #[test]
-    fn quota_url_uses_bigmodel_cn_region_aliases() {
-        let ctx = FetchContext {
-            api_region: Some("bigmodel-cn".to_string()),
-            ..FetchContext::default()
-        };
-        let env = env_map(&[]);
-        let region = ZaiProvider::effective_region(&ctx, &env);
-        assert_eq!(region, ZaiRegion::BigModelCn);
-
-        let url = ZaiProvider::quota_url(&env, region).expect("url");
-
-        assert_eq!(
-            url.as_str(),
-            "https://open.bigmodel.cn/api/monitor/usage/quota/limit"
-        );
-    }
-
-    #[test]
-    fn global_region_defaults_to_api_z_ai() {
-        let env = env_map(&[]);
-
-        let url = ZaiProvider::quota_url(&env, ZaiRegion::Global).expect("url");
-
-        assert_eq!(
-            url.as_str(),
-            "https://api.z.ai/api/monitor/usage/quota/limit"
-        );
-    }
-
-    #[test]
-    fn parses_workspace_pair_as_team_context() {
-        let parsed = parse_team_context_pair(" org-team | project-team ").expect("team context");
-
-        assert_eq!(parsed.organization_id, "org-team");
-        assert_eq!(parsed.project_id, "project-team");
-    }
-
-    #[test]
-    fn parses_successful_response_without_message() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "planName": "BigModel CN",
-                "limits": [{
-                    "type": "TOKENS_LIMIT",
-                    "used": 10,
-                    "limit": 100,
-                    "unit": 3,
-                    "number": 5
-                }]
-            }
-        }))
-        .unwrap();
-
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        assert_eq!(usage.login_method.as_deref(), Some("BigModel CN"));
-        assert_eq!(usage.primary.used_percent, 10.0);
-    }
-
-    #[test]
-    fn parses_current_api_percentage_and_reset_time() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [{
-                    "type": "TOKENS_LIMIT",
-                    "unit": 3,
-                    "number": 5,
-                    "usage": 800000000,
-                    "currentValue": 600000000,
-                    "remaining": 200000000,
-                    "percentage": 75,
-                    "nextResetTime": 1770648402389_i64
-                }]
-            }
-        }))
-        .unwrap();
-
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        assert_eq!(usage.primary.used_percent, 75.0);
-        assert_eq!(usage.primary.window_minutes, Some(300));
-        assert!(usage.primary.resets_at.is_some());
-    }
-
-    #[test]
-    fn credit_limit_plan_drives_primary_and_weekly_windows() {
-        // Upstream 0.49.0 #2724/#2712: credit-based Coding Plans report
-        // CREDIT_LIMIT rows shaped like TOKENS_LIMIT. Without this, usage
-        // sticks at 0% used / 100% remaining.
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "planName": "GLM Coding Lite",
-                "limits": [
-                    {
-                        "type": "CREDIT_LIMIT",
-                        "unit": 3,
-                        "number": 5,
-                        "usage": 500,
-                        "currentValue": 475,
-                        "remaining": 25,
-                        "percentage": 95,
-                        "nextResetTime": 1770648402389_i64
-                    },
-                    {
-                        "type": "CREDIT_LIMIT",
-                        "unit": 6,
-                        "number": 1,
-                        "usage": 3000,
-                        "currentValue": 1200,
-                        "remaining": 1800,
-                        "percentage": 40
-                    }
-                ]
-            }
-        }))
-        .unwrap();
-
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        // Shortest window (5h credits) is the primary; longest (weekly) secondary.
-        assert!((usage.primary.used_percent - 95.0).abs() < f64::EPSILON);
-        assert_eq!(usage.primary.window_minutes, Some(300));
-        assert_eq!(usage.primary.reset_description.as_deref(), Some("5-hour"));
-        assert!(usage.primary.resets_at.is_some());
-        let secondary = usage.secondary.expect("weekly credit window");
-        assert!((secondary.used_percent - 40.0).abs() < f64::EPSILON);
-        assert_eq!(secondary.window_minutes, Some(10080));
-    }
-
-    #[test]
-    fn usage_signal_overrides_stale_percentage() {
-        // Upstream 0.49.0 `parseLimit`: a positive `usage` total makes the
-        // absolute used signal authoritative; the API's `percentage` is only
-        // trusted without it.
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [{
-                    "type": "CREDIT_LIMIT",
-                    "unit": 3,
-                    "number": 5,
-                    "usage": 500,
-                    "currentValue": 25,
-                    "remaining": 475,
-                    "percentage": 95
-                }]
-            }
-        }))
-        .unwrap();
-
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        assert!((usage.primary.used_percent - 5.0).abs() < f64::EPSILON);
-    }
-
-    #[test]
-    fn time_limit_primary_carries_mcp_label_without_duration() {
-        // Upstream 0.48.0: TIME_LIMIT (MCP) windows no longer keep explicit
-        // duration minutes and label as "MCP", not the old monthly sentinel.
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [{
-                    "type": "TIME_LIMIT",
-                    "unit": 3,
-                    "number": 5,
-                    "usage": 100,
-                    "currentValue": 20,
-                    "remaining": 80,
-                    "percentage": 25,
-                    "nextResetTime": 123000_i64
-                }]
-            }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-        assert_eq!(usage.primary.window_minutes, None);
-        assert_eq!(usage.primary.reset_description.as_deref(), Some("MCP"));
-        assert!(usage.primary.resets_at.is_some());
-    }
-
-    #[test]
-    fn bare_time_limit_primary_has_no_window_duration() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [{
-                    "type": "TIME_LIMIT",
-                    "unit": 1,
-                    "number": 0,
-                    "usage": 100,
-                    "currentValue": 20,
-                    "remaining": 80,
-                    "percentage": 25,
-                    "nextResetTime": 123000_i64
-                }]
-            }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-        assert_eq!(usage.primary.window_minutes, None);
-        assert_eq!(usage.primary.reset_description.as_deref(), Some("MCP"));
-    }
-
-    #[test]
-    fn mcp_limit_renders_separate_named_window() {
-        // Upstream 0.48.0 GLM Coding Plan layout: coding-limit primary +
-        // MCP as a named extra window; MCP 1-minute marker no longer maps
-        // to a monthly sentinel secondary.
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [
-                    {
-                        "type": "TOKENS_LIMIT",
-                        "unit": 6,
-                        "number": 1,
-                        "percentage": 34
-                    },
-                    {
-                        "type": "TIME_LIMIT",
-                        "unit": 5,
-                        "number": 1,
-                        "percentage": 10
-                    }
-                ]
-            }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        assert_eq!(usage.primary.window_minutes, Some(10080));
-        assert_eq!(
-            usage.primary.reset_description.as_deref(),
-            Some("1 week window")
-        );
-        assert!(usage.secondary.is_none());
-        let mcp = usage
-            .extra_rate_windows
-            .iter()
-            .find(|window| window.id == "zai-mcp")
-            .expect("MCP extra window");
-        assert_eq!(mcp.title, "MCP");
-        assert_eq!(mcp.window.window_minutes, None);
-        assert_eq!(mcp.window.reset_description.as_deref(), Some("MCP"));
-        assert_eq!(mcp.window.used_percent, 10.0);
-    }
-
-    #[test]
-    fn session_five_hour_window_becomes_primary_over_weekly() {
-        // Upstream 0.48.0 GLM Coding Plan: 2+ TOKENS_LIMIT entries →
-        // shortest (5-hour) window primary, longest (weekly) secondary.
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "limits": [
-                    {
-                        "type": "TOKENS_LIMIT",
-                        "unit": 3,
-                        "number": 5,
-                        "percentage": 55,
-                        "nextResetTime": 1770648402389_i64
-                    },
-                    {
-                        "type": "TOKENS_LIMIT",
-                        "unit": 6,
-                        "number": 1,
-                        "percentage": 34
-                    }
-                ]
-            }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-
-        assert_eq!(usage.primary.used_percent, 55.0);
-        assert_eq!(usage.primary.window_minutes, Some(300));
-        assert_eq!(usage.primary.reset_description.as_deref(), Some("5-hour"));
-        assert!(usage.primary.resets_at.is_some());
-        let secondary = usage.secondary.expect("weekly secondary");
-        assert_eq!(secondary.used_percent, 34.0);
-        assert_eq!(secondary.window_minutes, Some(10080));
-        assert!(usage.model_specific.is_none());
-    }
-
-    #[test]
-    fn plan_name_falls_back_to_level_key() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": {
-                "level": "GLM Coding Plan",
-                "limits": []
-            }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-        assert_eq!(usage.login_method.as_deref(), Some("GLM Coding Plan"));
-
-        for key in ["plan", "plan_type", "packageName"] {
-            let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-                "code": 200,
-                "data": { key: "Coding Plan", "limits": [] }
-            }))
-            .unwrap();
-            let usage = provider.parse_quota_response(&quota).unwrap();
-            assert_eq!(usage.login_method.as_deref(), Some("Coding Plan"), "{key}");
-        }
-    }
-
-    #[test]
-    fn empty_plan_fields_fall_back_to_default() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 200,
-            "data": { "planName": "  ", "level": "", "limits": [] }
-        }))
-        .unwrap();
-        let usage = provider.parse_quota_response(&quota).unwrap();
-        assert_eq!(usage.login_method.as_deref(), Some("z.ai"));
-    }
-
-    #[test]
-    fn preserves_api_code_error_message() {
-        let provider = ZaiProvider::new();
-        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
-            "code": 401,
-            "message": "invalid token"
-        }))
-        .unwrap();
-
-        let error = provider.parse_quota_response(&quota).unwrap_err();
-
-        assert!(error.to_string().contains("invalid token"));
-    }
-}
+mod tests;
diff --git a/rust/src/providers/zai/reset_plausibility.rs b/rust/src/providers/zai/reset_plausibility.rs
new file mode 100644
index 0000000000..ac380b4bd9
--- /dev/null
+++ b/rust/src/providers/zai/reset_plausibility.rs
@@ -0,0 +1,15 @@
+use chrono::{DateTime, Utc};
+
+const ZAI_FIVE_HOUR_WINDOW_MINUTES: u32 = 300;
+
+/// Five-hour Coding Plan resets cannot be more than five hours away, plus one
+/// minute for clock skew. Past resets remain valid because the API may report
+/// a boundary that has just elapsed.
+pub(super) fn is_plausible_five_hour_reset(
+    window_minutes: Option<u32>,
+    reset: DateTime<Utc>,
+    now: DateTime<Utc>,
+) -> bool {
+    window_minutes != Some(ZAI_FIVE_HOUR_WINDOW_MINUTES)
+        || reset <= now + chrono::Duration::minutes(5 * 60 + 1)
+}
diff --git a/rust/src/providers/zai/tests.rs b/rust/src/providers/zai/tests.rs
new file mode 100644
index 0000000000..12689811a3
--- /dev/null
+++ b/rust/src/providers/zai/tests.rs
@@ -0,0 +1,435 @@
+use super::*;
+use settings::EnvMap;
+use std::collections::HashMap;
+
+fn env_map(pairs: &[(&str, &str)]) -> EnvMap {
+    pairs
+        .iter()
+        .map(|(key, value)| (key.to_string(), value.to_string()))
+        .collect::<HashMap<_, _>>()
+}
+
+#[test]
+fn request_url_adds_team_type_query_for_team_context() {
+    let env = env_map(&[]);
+    let team = ZaiTeamContext {
+        organization_id: "org".to_string(),
+        project_id: "project".to_string(),
+    };
+
+    let url = ZaiProvider::request_url(&env, ZaiRegion::Global, Some(&team)).expect("url");
+
+    assert_eq!(
+        url.as_str(),
+        "https://api.z.ai/api/monitor/usage/quota/limit?type=2"
+    );
+}
+
+#[test]
+fn quota_url_uses_bigmodel_cn_region_aliases() {
+    let ctx = FetchContext {
+        api_region: Some("bigmodel-cn".to_string()),
+        ..FetchContext::default()
+    };
+    let env = env_map(&[]);
+    let region = ZaiProvider::effective_region(&ctx, &env);
+    assert_eq!(region, ZaiRegion::BigModelCn);
+
+    let url = ZaiProvider::quota_url(&env, region).expect("url");
+
+    assert_eq!(
+        url.as_str(),
+        "https://open.bigmodel.cn/api/monitor/usage/quota/limit"
+    );
+}
+
+#[test]
+fn global_region_defaults_to_api_z_ai() {
+    let env = env_map(&[]);
+
+    let url = ZaiProvider::quota_url(&env, ZaiRegion::Global).expect("url");
+
+    assert_eq!(
+        url.as_str(),
+        "https://api.z.ai/api/monitor/usage/quota/limit"
+    );
+}
+
+#[test]
+fn parses_workspace_pair_as_team_context() {
+    let parsed = parse_team_context_pair(" org-team | project-team ").expect("team context");
+
+    assert_eq!(parsed.organization_id, "org-team");
+    assert_eq!(parsed.project_id, "project-team");
+}
+
+#[test]
+fn parses_successful_response_without_message() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "planName": "BigModel CN",
+            "limits": [{
+                "type": "TOKENS_LIMIT",
+                "used": 10,
+                "limit": 100,
+                "unit": 3,
+                "number": 5
+            }]
+        }
+    }))
+    .unwrap();
+
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    assert_eq!(usage.login_method.as_deref(), Some("BigModel CN"));
+    assert_eq!(usage.primary.used_percent, 10.0);
+}
+
+#[test]
+fn parses_current_api_percentage_and_reset_time() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [{
+                "type": "TOKENS_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "usage": 800000000,
+                "currentValue": 600000000,
+                "remaining": 200000000,
+                "percentage": 75,
+                "nextResetTime": 1770648402389_i64
+            }]
+        }
+    }))
+    .unwrap();
+
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    assert_eq!(usage.primary.used_percent, 75.0);
+    assert_eq!(usage.primary.window_minutes, Some(300));
+    assert!(usage.primary.resets_at.is_some());
+}
+
+#[test]
+fn five_hour_reset_plausibility_drops_impossible_timestamp() {
+    let now = Utc::now();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {"limits": [
+            {
+                "type": "TOKENS_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "percentage": 25,
+                "nextResetTime": (now + chrono::Duration::hours(10)).timestamp_millis()
+            },
+            {
+                "type": "TOKENS_LIMIT",
+                "unit": 6,
+                "number": 1,
+                "percentage": 9,
+                "nextResetTime": (now + chrono::Duration::days(6)).timestamp_millis()
+            },
+            {
+                "type": "TIME_LIMIT",
+                "unit": 5,
+                "number": 1,
+                "percentage": 22,
+                "nextResetTime": (now + chrono::Duration::days(20)).timestamp_millis()
+            }
+        ]}
+    }))
+    .unwrap();
+
+    let usage = ZaiProvider::new().parse_quota_response(&quota).unwrap();
+    assert_eq!(usage.primary.used_percent, 25.0);
+    assert_eq!(usage.primary.window_minutes, Some(300));
+    assert_eq!(usage.primary.reset_description.as_deref(), Some("5-hour"));
+    assert!(usage.primary.resets_at.is_none());
+    assert!(usage.secondary.as_ref().is_some_and(|window| {
+        window.window_minutes == Some(10080) && window.resets_at.is_some()
+    }));
+    let mcp = usage
+        .extra_rate_windows
+        .iter()
+        .find(|window| window.id == "zai-mcp")
+        .expect("MCP extra window");
+    assert!(mcp.window.resets_at.is_some());
+}
+
+#[test]
+fn five_hour_reset_horizon_allows_one_minute_clock_skew() {
+    let now = Utc::now();
+    let edge = now + chrono::Duration::minutes(5 * 60 + 1);
+    assert!(is_plausible_five_hour_reset(Some(300), edge, now));
+    assert!(!is_plausible_five_hour_reset(
+        Some(300),
+        edge + chrono::Duration::milliseconds(1),
+        now
+    ));
+    assert!(is_plausible_five_hour_reset(Some(10080), edge, now));
+    assert!(is_plausible_five_hour_reset(None, edge, now));
+}
+
+#[test]
+fn credit_limit_plan_drives_primary_and_weekly_windows() {
+    // Upstream 0.49.0 #2724/#2712: credit-based Coding Plans report
+    // CREDIT_LIMIT rows shaped like TOKENS_LIMIT. Without this, usage
+    // sticks at 0% used / 100% remaining.
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "planName": "GLM Coding Lite",
+            "limits": [
+                {
+                    "type": "CREDIT_LIMIT",
+                    "unit": 3,
+                    "number": 5,
+                    "usage": 500,
+                    "currentValue": 475,
+                    "remaining": 25,
+                    "percentage": 95,
+                    "nextResetTime": 1770648402389_i64
+                },
+                {
+                    "type": "CREDIT_LIMIT",
+                    "unit": 6,
+                    "number": 1,
+                    "usage": 3000,
+                    "currentValue": 1200,
+                    "remaining": 1800,
+                    "percentage": 40
+                }
+            ]
+        }
+    }))
+    .unwrap();
+
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    // Shortest window (5h credits) is the primary; longest (weekly) secondary.
+    assert!((usage.primary.used_percent - 95.0).abs() < f64::EPSILON);
+    assert_eq!(usage.primary.window_minutes, Some(300));
+    assert_eq!(usage.primary.reset_description.as_deref(), Some("5-hour"));
+    assert!(usage.primary.resets_at.is_some());
+    let secondary = usage.secondary.expect("weekly credit window");
+    assert!((secondary.used_percent - 40.0).abs() < f64::EPSILON);
+    assert_eq!(secondary.window_minutes, Some(10080));
+}
+
+#[test]
+fn usage_signal_overrides_stale_percentage() {
+    // Upstream 0.49.0 `parseLimit`: a positive `usage` total makes the
+    // absolute used signal authoritative; the API's `percentage` is only
+    // trusted without it.
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [{
+                "type": "CREDIT_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "usage": 500,
+                "currentValue": 25,
+                "remaining": 475,
+                "percentage": 95
+            }]
+        }
+    }))
+    .unwrap();
+
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    assert!((usage.primary.used_percent - 5.0).abs() < f64::EPSILON);
+}
+
+#[test]
+fn time_limit_primary_carries_mcp_label_without_duration() {
+    // Upstream 0.48.0: TIME_LIMIT (MCP) windows no longer keep explicit
+    // duration minutes and label as "MCP", not the old monthly sentinel.
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [{
+                "type": "TIME_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "usage": 100,
+                "currentValue": 20,
+                "remaining": 80,
+                "percentage": 25,
+                "nextResetTime": 123000_i64
+            }]
+        }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+    assert_eq!(usage.primary.window_minutes, None);
+    assert_eq!(usage.primary.reset_description.as_deref(), Some("MCP"));
+    assert!(usage.primary.resets_at.is_some());
+}
+
+#[test]
+fn bare_time_limit_primary_has_no_window_duration() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [{
+                "type": "TIME_LIMIT",
+                "unit": 1,
+                "number": 0,
+                "usage": 100,
+                "currentValue": 20,
+                "remaining": 80,
+                "percentage": 25,
+                "nextResetTime": 123000_i64
+            }]
+        }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+    assert_eq!(usage.primary.window_minutes, None);
+    assert_eq!(usage.primary.reset_description.as_deref(), Some("MCP"));
+}
+
+#[test]
+fn mcp_limit_renders_separate_named_window() {
+    // Upstream 0.48.0 GLM Coding Plan layout: coding-limit primary +
+    // MCP as a named extra window; MCP 1-minute marker no longer maps
+    // to a monthly sentinel secondary.
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [
+                {
+                    "type": "TOKENS_LIMIT",
+                    "unit": 6,
+                    "number": 1,
+                    "percentage": 34
+                },
+                {
+                    "type": "TIME_LIMIT",
+                    "unit": 5,
+                    "number": 1,
+                    "percentage": 10
+                }
+            ]
+        }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    assert_eq!(usage.primary.window_minutes, Some(10080));
+    assert_eq!(
+        usage.primary.reset_description.as_deref(),
+        Some("1 week window")
+    );
+    assert!(usage.secondary.is_none());
+    let mcp = usage
+        .extra_rate_windows
+        .iter()
+        .find(|window| window.id == "zai-mcp")
+        .expect("MCP extra window");
+    assert_eq!(mcp.title, "MCP");
+    assert_eq!(mcp.window.window_minutes, None);
+    assert_eq!(mcp.window.reset_description.as_deref(), Some("MCP"));
+    assert_eq!(mcp.window.used_percent, 10.0);
+}
+
+#[test]
+fn session_five_hour_window_becomes_primary_over_weekly() {
+    // Upstream 0.48.0 GLM Coding Plan: 2+ TOKENS_LIMIT entries →
+    // shortest (5-hour) window primary, longest (weekly) secondary.
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "limits": [
+                {
+                    "type": "TOKENS_LIMIT",
+                    "unit": 3,
+                    "number": 5,
+                    "percentage": 55,
+                    "nextResetTime": 1770648402389_i64
+                },
+                {
+                    "type": "TOKENS_LIMIT",
+                    "unit": 6,
+                    "number": 1,
+                    "percentage": 34
+                }
+            ]
+        }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+
+    assert_eq!(usage.primary.used_percent, 55.0);
+    assert_eq!(usage.primary.window_minutes, Some(300));
+    assert_eq!(usage.primary.reset_description.as_deref(), Some("5-hour"));
+    assert!(usage.primary.resets_at.is_some());
+    let secondary = usage.secondary.expect("weekly secondary");
+    assert_eq!(secondary.used_percent, 34.0);
+    assert_eq!(secondary.window_minutes, Some(10080));
+    assert!(usage.model_specific.is_none());
+}
+
+#[test]
+fn plan_name_falls_back_to_level_key() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": {
+            "level": "GLM Coding Plan",
+            "limits": []
+        }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+    assert_eq!(usage.login_method.as_deref(), Some("GLM Coding Plan"));
+
+    for key in ["plan", "plan_type", "packageName"] {
+        let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+            "code": 200,
+            "data": { key: "Coding Plan", "limits": [] }
+        }))
+        .unwrap();
+        let usage = provider.parse_quota_response(&quota).unwrap();
+        assert_eq!(usage.login_method.as_deref(), Some("Coding Plan"), "{key}");
+    }
+}
+
+#[test]
+fn empty_plan_fields_fall_back_to_default() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 200,
+        "data": { "planName": "  ", "level": "", "limits": [] }
+    }))
+    .unwrap();
+    let usage = provider.parse_quota_response(&quota).unwrap();
+    assert_eq!(usage.login_method.as_deref(), Some("z.ai"));
+}
+
+#[test]
+fn preserves_api_code_error_message() {
+    let provider = ZaiProvider::new();
+    let quota: ZaiQuotaResponse = serde_json::from_value(serde_json::json!({
+        "code": 401,
+        "message": "invalid token"
+    }))
+    .unwrap();
+
+    let error = provider.parse_quota_response(&quota).unwrap_err();
+
+    assert!(error.to_string().contains("invalid token"));
+}
diff --git a/rust/src/settings/api_keys.rs b/rust/src/settings/api_keys.rs
index c396e8207b..ac71ba0dbc 100644
--- a/rust/src/settings/api_keys.rs
+++ b/rust/src/settings/api_keys.rs
@@ -275,7 +275,7 @@ pub fn get_api_key_providers() -> Vec<ProviderConfigInfo> {
             name: "Kilo",
             requires_api_key: true,
             api_key_env_var: Some("KILO_API_KEY"),
-            api_key_help: Some("Get your API key from Kilo, or sign in with Kilo CLI."),
+            api_key_help: Some("Get your API key from Kilo, or run `kilo auth login`."),
             config_file_path: Some("~/.local/share/kilo/auth.json"),
             dashboard_url: Some("https://app.kilo.ai/usage"),
         },