diff --git a/packages/desktop/src-tauri/src/commands/settings.rs b/packages/desktop/src-tauri/src/commands/settings.rs
index 62b7c031..75343ccb 100644
--- a/packages/desktop/src-tauri/src/commands/settings.rs
+++ b/packages/desktop/src-tauri/src/commands/settings.rs
@@ -300,6 +300,9 @@ fn sanitize_settings_update(payload: &Value) -> Value {
         if let Some(Value::Bool(b)) = obj.get("notifyOnSubtasks") {
             result_obj.insert("notifyOnSubtasks".to_string(), json!(b));
         }
+        if let Some(Value::Bool(b)) = obj.get("usageAutoRefresh") {
+            result_obj.insert("usageAutoRefresh".to_string(), json!(b));
+        }
         if let Some(Value::String(s)) = obj.get("notificationMode") {
             let trimmed = s.trim();
             if trimmed == "always" || trimmed == "hidden-only" {
@@ -377,6 +380,16 @@ fn sanitize_settings_update(payload: &Value) -> Value {
                 result_obj.insert("inputBarOffset".to_string(), json!(clamped));
             }
         }
+        if let Some(Value::Number(n)) = obj.get("usageRefreshIntervalMs") {
+            let parsed = n
+                .as_u64()
+                .or_else(|| n.as_i64().and_then(|v| if v >= 0 { Some(v as u64) } else { None }))
+                .or_else(|| n.as_f64().map(|v| v.round().max(0.0) as u64));
+            if let Some(value) = parsed {
+                let clamped = value.max(30000).min(300000);
+                result_obj.insert("usageRefreshIntervalMs".to_string(), json!(clamped));
+            }
+        }
 
         // Memory limit fields
         if let Some(Value::Number(n)) = obj.get("memoryLimitHistorical") {
diff --git a/packages/desktop/src-tauri/src/main.rs b/packages/desktop/src-tauri/src/main.rs
index 7d24d5f7..6dcf8a5c 100644
--- a/packages/desktop/src-tauri/src/main.rs
+++ b/packages/desktop/src-tauri/src/main.rs
@@ -7,6 +7,7 @@ mod opencode_auth;
 mod opencode_config;
 mod opencode_manager;
 mod path_utils;
+mod quota_providers;
 mod session_activity;
 mod skills_catalog;
 mod window_state;
@@ -22,7 +23,7 @@ use anyhow::{anyhow, Result};
 use assistant_notifications::spawn_assistant_notifications;
 use axum::{
     body::{to_bytes, Body},
-    extract::{Request, State},
+    extract::{Path, Request, State},
     http::{Method, StatusCode},
     response::{IntoResponse, Response},
     routing::{any, get, post},
@@ -275,6 +276,11 @@ struct ServerInfoPayload {
     has_last_directory: bool,
 }
 
+#[derive(Serialize)]
+struct QuotaProvidersResponse {
+    providers: Vec<String>,
+}
+
 #[tauri::command]
 async fn desktop_server_info(
     state: tauri::State<'_, DesktopRuntime>,
@@ -1098,6 +1104,8 @@ async fn run_http_server(
             "/api/openchamber/models-metadata",
             get(models_metadata_handler),
         )
+        .route("/api/quota/providers", get(quota_providers_handler))
+        .route("/api/quota/{providerId}", get(quota_provider_handler))
         .route("/api/opencode/directory", post(change_directory_handler))
         .route("/api", any(proxy_to_opencode))
         .route("/api/{*rest}", any(proxy_to_opencode))
@@ -1179,6 +1187,37 @@ async fn models_metadata_handler(
     Ok(Json(payload))
 }
 
+async fn quota_providers_handler(State(_state): State<ServerState>) -> Response {
+    match quota_providers::list_configured_quota_providers().await {
+        Ok(providers) => json_response(
+            StatusCode::OK,
+            QuotaProvidersResponse { providers },
+        ),
+        Err(err) => {
+            error!("[desktop:quota] Failed to list quota providers: {}", err);
+            config_error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string())
+        }
+    }
+}
+
+async fn quota_provider_handler(
+    State(state): State<ServerState>,
+    Path(provider_id): Path<String>,
+) -> Response {
+    let trimmed = provider_id.trim();
+    if trimmed.is_empty() {
+        return config_error_response(StatusCode::BAD_REQUEST, "Provider ID is required");
+    }
+
+    match quota_providers::fetch_quota_for_provider(&state.client, trimmed).await {
+        Ok(result) => json_response(StatusCode::OK, result),
+        Err(err) => {
+            error!("[desktop:quota] Failed to fetch quota: {}", err);
+            config_error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string())
+        }
+    }
+}
+
 #[derive(Deserialize)]
 struct DirectoryChangeRequest {
     path: String,
diff --git a/packages/desktop/src-tauri/src/quota_providers.rs b/packages/desktop/src-tauri/src/quota_providers.rs
new file mode 100644
index 00000000..025844eb
--- /dev/null
+++ b/packages/desktop/src-tauri/src/quota_providers.rs
@@ -0,0 +1,797 @@
+use anyhow::{anyhow, Result};
+use chrono::{DateTime, Local, TimeZone};
+use log::warn;
+use reqwest::Client;
+use serde::Serialize;
+use serde_json::Value;
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    time::Duration,
+};
+
+use crate::opencode_auth;
+
+const OPENCODE_CONFIG_DIR: &str = ".config/opencode";
+const OPENCODE_DATA_DIR: &str = ".local/share/opencode";
+
+const GOOGLE_CLIENT_ID: &str =
+    "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+const GOOGLE_CLIENT_SECRET: &str = "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";
+const DEFAULT_PROJECT_ID: &str = "rising-fact-p41fc";
+const GOOGLE_WINDOW_SECONDS: i64 = 5 * 60 * 60;
+
+const GOOGLE_ENDPOINTS: [&str; 3] = [
+    "https://daily-cloudcode-pa.sandbox.googleapis.com",
+    "https://autopush-cloudcode-pa.sandbox.googleapis.com",
+    "https://cloudcode-pa.googleapis.com",
+];
+
+const GOOGLE_USER_AGENT: &str = "antigravity/1.11.5 windows/amd64";
+const GOOGLE_API_CLIENT: &str = "google-cloud-sdk vscode_cloudshelleditor/0.1";
+const GOOGLE_CLIENT_METADATA: &str =
+    "{\"ideType\":\"IDE_UNSPECIFIED\",\"platform\":\"PLATFORM_UNSPECIFIED\",\"pluginType\":\"GEMINI\"}";
+
+#[derive(Clone, Debug, Default)]
+struct AuthEntry {
+    token: Option<String>,
+    access: Option<String>,
+    refresh: Option<String>,
+    expires: Option<i64>,
+    key: Option<String>,
+}
+
+#[derive(Clone, Debug, Default)]
+struct GoogleAuth {
+    access_token: Option<String>,
+    refresh_token: Option<String>,
+    expires: Option<i64>,
+    project_id: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProviderResult {
+    provider_id: String,
+    provider_name: String,
+    ok: bool,
+    configured: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<String>,
+    usage: Option<ProviderUsage>,
+    fetched_at: i64,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ProviderUsage {
+    windows: HashMap<String, UsageWindow>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    models: Option<HashMap<String, ProviderUsage>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UsageWindow {
+    used_percent: Option<f64>,
+    remaining_percent: Option<f64>,
+    window_seconds: Option<i64>,
+    reset_after_seconds: Option<i64>,
+    reset_at: Option<i64>,
+    reset_at_formatted: Option<String>,
+    reset_after_formatted: Option<String>,
+}
+
+fn get_home_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_else(|| PathBuf::from("/"))
+}
+
+fn opencode_config_dir() -> PathBuf {
+    get_home_dir().join(OPENCODE_CONFIG_DIR)
+}
+
+fn opencode_data_dir() -> PathBuf {
+    get_home_dir().join(OPENCODE_DATA_DIR)
+}
+
+fn antigravity_accounts_paths() -> [PathBuf; 2] {
+    [
+        opencode_config_dir().join("antigravity-accounts.json"),
+        opencode_data_dir().join("antigravity-accounts.json"),
+    ]
+}
+
+async fn read_json_file(path: &PathBuf) -> Option<Value> {
+    if !path.exists() {
+        return None;
+    }
+    let raw = tokio::fs::read_to_string(path).await.ok()?;
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    serde_json::from_str(trimmed).map_err(|err| {
+        warn!("Failed to read JSON file {}: {}", path.display(), err);
+        err
+    }).ok()
+}
+
+fn get_auth_entry<'a>(auth: &'a serde_json::Map<String, Value>, aliases: &[&str]) -> Option<&'a Value> {
+    for alias in aliases {
+        if let Some(value) = auth.get(*alias) {
+            return Some(value);
+        }
+    }
+    None
+}
+
+fn normalize_auth_entry(value: Option<&Value>) -> Option<AuthEntry> {
+    let value = value?;
+    match value {
+        Value::String(token) => Some(AuthEntry {
+            token: Some(token.clone()),
+            ..AuthEntry::default()
+        }),
+        Value::Object(map) => {
+            let token = map.get("token").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let access = map.get("access").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let refresh = map.get("refresh").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let key = map.get("key").and_then(|v| v.as_str()).map(|s| s.to_string());
+            let expires = map
+                .get("expires")
+                .and_then(|v| v.as_i64())
+                .or_else(|| map.get("expires").and_then(|v| v.as_f64()).map(|v| v.round() as i64));
+
+            Some(AuthEntry {
+                token,
+                access,
+                refresh,
+                expires,
+                key,
+            })
+        }
+        _ => None,
+    }
+}
+
+fn format_reset_at(timestamp_ms: i64) -> Option<String> {
+    let dt = Local.timestamp_millis_opt(timestamp_ms).single()?;
+    Some(dt.format("%-I:%M %p").to_string())
+}
+
+fn format_duration(seconds: i64) -> Option<String> {
+    if seconds < 0 {
+        return None;
+    }
+    let clamped = seconds.max(0) as i64;
+    let hours = clamped / 3600;
+    let minutes = (clamped % 3600) / 60;
+    if hours == 0 && minutes == 0 {
+        return Some("0m".to_string());
+    }
+    if hours == 0 {
+        return Some(format!("{}m", minutes));
+    }
+    if minutes == 0 {
+        return Some(format!("{}h", hours));
+    }
+    Some(format!("{}h {}m", hours, minutes))
+}
+
+fn calculate_reset_after_seconds(reset_at: Option<i64>) -> Option<i64> {
+    let reset_at = reset_at?;
+    let now_ms = chrono::Utc::now().timestamp_millis();
+    let delta = (reset_at - now_ms) / 1000;
+    Some(delta.max(0))
+}
+
+fn to_usage_window(used_percent: Option<f64>, window_seconds: Option<i64>, reset_at: Option<i64>) -> UsageWindow {
+    let remaining_percent = used_percent.map(|value| (100.0 - value).max(0.0));
+    let reset_after_seconds = calculate_reset_after_seconds(reset_at);
+    let reset_at_formatted = reset_at.and_then(format_reset_at);
+    let reset_after_formatted = reset_after_seconds.and_then(format_duration);
+
+    UsageWindow {
+        used_percent,
+        remaining_percent,
+        window_seconds,
+        reset_after_seconds,
+        reset_at,
+        reset_at_formatted,
+        reset_after_formatted,
+    }
+}
+
+fn build_result(
+    provider_id: &str,
+    provider_name: &str,
+    ok: bool,
+    configured: bool,
+    usage: Option<ProviderUsage>,
+    error: Option<String>,
+) -> ProviderResult {
+    ProviderResult {
+        provider_id: provider_id.to_string(),
+        provider_name: provider_name.to_string(),
+        ok,
+        configured,
+        error,
+        usage,
+        fetched_at: chrono::Utc::now().timestamp_millis(),
+    }
+}
+
+async fn load_auth_map() -> Result<serde_json::Map<String, Value>> {
+    let auth = opencode_auth::read_auth().await?;
+    auth.as_object()
+        .cloned()
+        .ok_or_else(|| anyhow!("Auth file is not a valid JSON object"))
+}
+
+async fn has_antigravity_accounts() -> bool {
+    for path in antigravity_accounts_paths() {
+        if let Some(data) = read_json_file(&path).await {
+            if data
+                .get("accounts")
+                .and_then(|value| value.as_array())
+                .is_some_and(|accounts| !accounts.is_empty())
+            {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+pub async fn list_configured_quota_providers() -> Result<Vec<String>> {
+    let auth = load_auth_map().await?;
+    let mut configured: HashSet<String> = HashSet::new();
+
+    let openai_auth = normalize_auth_entry(get_auth_entry(&auth, &["openai", "codex", "chatgpt"]));
+    if let Some(entry) = openai_auth {
+        if entry.access.is_some() || entry.token.is_some() {
+            configured.insert("openai".to_string());
+        }
+    }
+
+    let google_auth = normalize_auth_entry(get_auth_entry(&auth, &["google", "antigravity"]));
+    if let Some(entry) = google_auth {
+        if entry.access.is_some() || entry.token.is_some() || entry.refresh.is_some() {
+            configured.insert("google".to_string());
+        }
+    }
+
+    let zai_auth =
+        normalize_auth_entry(get_auth_entry(&auth, &["zai-coding-plan", "zai", "z.ai"]));
+    if let Some(entry) = zai_auth {
+        if entry.key.is_some() || entry.token.is_some() {
+            configured.insert("zai-coding-plan".to_string());
+        }
+    }
+
+    if has_antigravity_accounts().await {
+        configured.insert("google".to_string());
+    }
+
+    Ok(configured.into_iter().collect())
+}
+
+fn parse_number(value: Option<&Value>) -> Option<f64> {
+    let value = value?;
+    value.as_f64().or_else(|| value.as_i64().map(|v| v as f64))
+}
+
+async fn fetch_openai_quota(client: &Client) -> Result<ProviderResult> {
+    let auth = load_auth_map().await?;
+    let entry = normalize_auth_entry(get_auth_entry(&auth, &["openai", "codex", "chatgpt"]));
+    let access_token = entry
+        .as_ref()
+        .and_then(|entry| entry.access.clone().or(entry.token.clone()));
+
+    let Some(access_token) = access_token else {
+        return Ok(build_result(
+            "openai",
+            "OpenAI",
+            false,
+            false,
+            None,
+            Some("Not configured".to_string()),
+        ));
+    };
+
+    let response = client
+        .get("https://chatgpt.com/backend-api/wham/usage")
+        .bearer_auth(access_token)
+        .header("Content-Type", "application/json")
+        .send()
+        .await;
+
+    let response = match response {
+        Ok(resp) => resp,
+        Err(err) => {
+            return Ok(build_result(
+                "openai",
+                "OpenAI",
+                false,
+                true,
+                None,
+                Some(err.to_string()),
+            ))
+        }
+    };
+
+    if !response.status().is_success() {
+        return Ok(build_result(
+            "openai",
+            "OpenAI",
+            false,
+            true,
+            None,
+            Some(format!("API error: {}", response.status().as_u16())),
+        ));
+    }
+
+    let payload: Value = match response.json().await {
+        Ok(value) => value,
+        Err(err) => {
+            return Ok(build_result(
+                "openai",
+                "OpenAI",
+                false,
+                true,
+                None,
+                Some(err.to_string()),
+            ))
+        }
+    };
+
+    let primary = payload
+        .get("rate_limit")
+        .and_then(|value| value.get("primary_window"));
+    let secondary = payload
+        .get("rate_limit")
+        .and_then(|value| value.get("secondary_window"));
+
+    let mut windows: HashMap<String, UsageWindow> = HashMap::new();
+
+    if let Some(primary) = primary {
+        let used_percent = parse_number(primary.get("used_percent"));
+        let window_seconds = primary
+            .get("limit_window_seconds")
+            .and_then(|value| value.as_i64());
+        let reset_at = primary
+            .get("reset_at")
+            .and_then(|value| value.as_i64())
+            .map(|value| value * 1000);
+        windows.insert(
+            "5h".to_string(),
+            to_usage_window(used_percent, window_seconds, reset_at),
+        );
+    }
+
+    if let Some(secondary) = secondary {
+        let used_percent = parse_number(secondary.get("used_percent"));
+        let window_seconds = secondary
+            .get("limit_window_seconds")
+            .and_then(|value| value.as_i64());
+        let reset_at = secondary
+            .get("reset_at")
+            .and_then(|value| value.as_i64())
+            .map(|value| value * 1000);
+        windows.insert(
+            "weekly".to_string(),
+            to_usage_window(used_percent, window_seconds, reset_at),
+        );
+    }
+
+    Ok(build_result(
+        "openai",
+        "OpenAI",
+        true,
+        true,
+        Some(ProviderUsage {
+            windows,
+            models: None,
+        }),
+        None,
+    ))
+}
+
+async fn resolve_google_auth() -> Result<Option<GoogleAuth>> {
+    let auth = load_auth_map().await?;
+    let entry = normalize_auth_entry(get_auth_entry(&auth, &["google", "antigravity"]));
+
+    if let Some(entry) = entry {
+        let mut refresh = entry.refresh.clone();
+        let mut project_id = None;
+        if let Some(value) = entry.refresh.clone() {
+            if let Some((first, second)) = value.split_once('|') {
+                refresh = Some(first.to_string());
+                project_id = Some(second.to_string());
+            }
+        }
+        return Ok(Some(GoogleAuth {
+            access_token: entry.access.or(entry.token),
+            refresh_token: refresh,
+            expires: entry.expires,
+            project_id,
+        }));
+    }
+
+    for path in antigravity_accounts_paths() {
+        let data = match read_json_file(&path).await {
+            Some(data) => data,
+            None => continue,
+        };
+        let accounts = data.get("accounts").and_then(|value| value.as_array());
+        if let Some(accounts) = accounts {
+            if accounts.is_empty() {
+                continue;
+            }
+            let index = data
+                .get("activeIndex")
+                .and_then(|value| value.as_i64())
+                .unwrap_or(0)
+                .max(0) as usize;
+            let account = accounts.get(index).or_else(|| accounts.first());
+            if let Some(account) = account {
+                let refresh_token = account
+                    .get("refreshToken")
+                    .and_then(|value| value.as_str())
+                    .map(|value| value.to_string());
+                if refresh_token.is_none() {
+                    continue;
+                }
+                let project_id = account
+                    .get("projectId")
+                    .and_then(|value| value.as_str())
+                    .or_else(|| {
+                        account
+                            .get("managedProjectId")
+                            .and_then(|value| value.as_str())
+                    })
+                    .map(|value| value.to_string());
+
+                return Ok(Some(GoogleAuth {
+                    access_token: None,
+                    refresh_token,
+                    expires: None,
+                    project_id,
+                }));
+            }
+        }
+    }
+
+    Ok(None)
+}
+
+async fn refresh_google_access_token(client: &Client, refresh_token: &str) -> Result<Option<String>> {
+    let body = format!(
+        "client_id={}&client_secret={}&refresh_token={}&grant_type=refresh_token",
+        urlencoding::encode(GOOGLE_CLIENT_ID),
+        urlencoding::encode(GOOGLE_CLIENT_SECRET),
+        urlencoding::encode(refresh_token)
+    );
+
+    let response = client
+        .post("https://oauth2.googleapis.com/token")
+        .header("Content-Type", "application/x-www-form-urlencoded")
+        .body(body)
+        .send()
+        .await;
+
+    let response = match response {
+        Ok(resp) => resp,
+        Err(err) => {
+            warn!("Failed to refresh Google token: {}", err);
+            return Ok(None);
+        }
+    };
+
+    if !response.status().is_success() {
+        return Ok(None);
+    }
+
+    let payload: Value = response.json().await.unwrap_or(Value::Null);
+    Ok(payload
+        .get("access_token")
+        .and_then(|value| value.as_str())
+        .map(|value| value.to_string()))
+}
+
+async fn fetch_google_models(client: &Client, access_token: &str, project_id: Option<&str>) -> Option<Value> {
+    let body = if let Some(project_id) = project_id {
+        serde_json::json!({ "project": project_id })
+    } else {
+        serde_json::json!({})
+    };
+
+    for endpoint in GOOGLE_ENDPOINTS {
+        let response = client
+            .post(format!("{}/v1internal:fetchAvailableModels", endpoint))
+            .header("Authorization", format!("Bearer {}", access_token))
+            .header("Content-Type", "application/json")
+            .header("User-Agent", GOOGLE_USER_AGENT)
+            .header("X-Goog-Api-Client", GOOGLE_API_CLIENT)
+            .header("Client-Metadata", GOOGLE_CLIENT_METADATA)
+            .json(&body)
+            .timeout(Duration::from_secs(15))
+            .send()
+            .await;
+
+        let response = match response {
+            Ok(resp) => resp,
+            Err(_) => continue,
+        };
+
+        if response.status().is_success() {
+            if let Ok(payload) = response.json::<Value>().await {
+                return Some(payload);
+            }
+        }
+    }
+
+    None
+}
+
+fn parse_reset_time(value: Option<&Value>) -> Option<i64> {
+    let value = value?;
+    if let Some(num) = value.as_i64() {
+        if num > 0 {
+            return Some(num);
+        }
+    }
+    if let Some(text) = value.as_str() {
+        if let Ok(parsed) = DateTime::parse_from_rfc3339(text) {
+            return Some(parsed.timestamp_millis());
+        }
+    }
+    None
+}
+
+async fn fetch_google_quota(client: &Client) -> Result<ProviderResult> {
+    let auth = resolve_google_auth().await?;
+    let Some(auth) = auth else {
+        return Ok(build_result(
+            "google",
+            "Google",
+            false,
+            false,
+            None,
+            Some("Not configured".to_string()),
+        ));
+    };
+
+    let now = chrono::Utc::now().timestamp_millis();
+    let mut access_token = auth.access_token;
+    if access_token.is_none()
+        || auth
+            .expires
+            .is_some_and(|expires| expires <= now)
+    {
+        let Some(refresh_token) = auth.refresh_token.as_ref() else {
+            return Ok(build_result(
+                "google",
+                "Google",
+                false,
+                true,
+                None,
+                Some("Missing refresh token".to_string()),
+            ));
+        };
+        access_token = refresh_google_access_token(client, refresh_token).await?;
+    }
+
+    let Some(access_token) = access_token else {
+        return Ok(build_result(
+            "google",
+            "Google",
+            false,
+            true,
+            None,
+            Some("Failed to refresh OAuth token".to_string()),
+        ));
+    };
+
+    let project_id = auth.project_id.unwrap_or_else(|| DEFAULT_PROJECT_ID.to_string());
+    let payload = fetch_google_models(client, &access_token, Some(project_id.as_str())).await;
+    let Some(payload) = payload else {
+        return Ok(build_result(
+            "google",
+            "Google",
+            false,
+            true,
+            None,
+            Some("Failed to fetch models".to_string()),
+        ));
+    };
+
+    let mut models: HashMap<String, ProviderUsage> = HashMap::new();
+    if let Some(model_map) = payload.get("models").and_then(|value| value.as_object()) {
+        for (model_name, model_data) in model_map {
+            let remaining_fraction = parse_number(model_data.get("quotaInfo").and_then(|v| v.get("remainingFraction")));
+            let remaining_percent = remaining_fraction.map(|value| (value * 100.0).round());
+            let used_percent = remaining_percent.map(|value| (100.0 - value).max(0.0));
+            let reset_at = parse_reset_time(model_data.get("quotaInfo").and_then(|v| v.get("resetTime")));
+
+            let mut windows = HashMap::new();
+            windows.insert(
+                "5h".to_string(),
+                to_usage_window(used_percent, Some(GOOGLE_WINDOW_SECONDS), reset_at),
+            );
+            models.insert(
+                model_name.to_string(),
+                ProviderUsage {
+                    windows,
+                    models: None,
+                },
+            );
+        }
+    }
+
+    Ok(build_result(
+        "google",
+        "Google",
+        true,
+        true,
+        Some(ProviderUsage {
+            windows: HashMap::new(),
+            models: if models.is_empty() { None } else { Some(models) },
+        }),
+        None,
+    ))
+}
+
+fn normalize_timestamp(value: Option<&Value>) -> Option<i64> {
+    let value = value?;
+    if let Some(num) = value.as_i64() {
+        if num < 1_000_000_000_000 {
+            return Some(num * 1000);
+        }
+        return Some(num);
+    }
+    None
+}
+
+fn resolve_window_seconds(limit: &Value) -> Option<i64> {
+    let number = limit.get("number").and_then(|value| value.as_i64())?;
+    let unit = limit.get("unit").and_then(|value| value.as_i64())?;
+    let unit_seconds = match unit {
+        3 => Some(3600),
+        _ => None,
+    }?;
+    Some(unit_seconds * number)
+}
+
+fn resolve_window_label(window_seconds: Option<i64>) -> String {
+    let Some(window_seconds) = window_seconds else {
+        return "tokens".to_string();
+    };
+    if window_seconds % 86400 == 0 {
+        let days = window_seconds / 86400;
+        if days == 7 {
+            return "weekly".to_string();
+        }
+        return format!("{}d", days);
+    }
+    if window_seconds % 3600 == 0 {
+        return format!("{}h", window_seconds / 3600);
+    }
+    format!("{}s", window_seconds)
+}
+
+async fn fetch_zai_quota(client: &Client) -> Result<ProviderResult> {
+    let auth = load_auth_map().await?;
+    let entry = normalize_auth_entry(get_auth_entry(&auth, &["zai-coding-plan", "zai", "z.ai"]));
+    let api_key = entry
+        .as_ref()
+        .and_then(|entry| entry.key.clone().or(entry.token.clone()));
+
+    let Some(api_key) = api_key else {
+        return Ok(build_result(
+            "zai-coding-plan",
+            "z.ai",
+            false,
+            false,
+            None,
+            Some("Not configured".to_string()),
+        ));
+    };
+
+    let response = client
+        .get("https://api.z.ai/api/monitor/usage/quota/limit")
+        .bearer_auth(api_key)
+        .header("Content-Type", "application/json")
+        .send()
+        .await;
+
+    let response = match response {
+        Ok(resp) => resp,
+        Err(err) => {
+            return Ok(build_result(
+                "zai-coding-plan",
+                "z.ai",
+                false,
+                true,
+                None,
+                Some(err.to_string()),
+            ))
+        }
+    };
+
+    if !response.status().is_success() {
+        return Ok(build_result(
+            "zai-coding-plan",
+            "z.ai",
+            false,
+            true,
+            None,
+            Some(format!("API error: {}", response.status().as_u16())),
+        ));
+    }
+
+    let payload: Value = match response.json().await {
+        Ok(value) => value,
+        Err(err) => {
+            return Ok(build_result(
+                "zai-coding-plan",
+                "z.ai",
+                false,
+                true,
+                None,
+                Some(err.to_string()),
+            ))
+        }
+    };
+
+    let limits = payload
+        .get("data")
+        .and_then(|value| value.get("limits"))
+        .and_then(|value| value.as_array())
+        .cloned()
+        .unwrap_or_default();
+    let tokens_limit = limits
+        .iter()
+        .find(|limit| limit.get("type").and_then(|value| value.as_str()) == Some("TOKENS_LIMIT"));
+
+    let mut windows = HashMap::new();
+    if let Some(limit) = tokens_limit {
+        let window_seconds = resolve_window_seconds(limit);
+        let window_label = resolve_window_label(window_seconds);
+        let reset_at = normalize_timestamp(limit.get("nextResetTime"));
+        let used_percent = parse_number(limit.get("percentage"));
+
+        windows.insert(
+            window_label,
+            to_usage_window(used_percent, window_seconds, reset_at),
+        );
+    }
+
+    Ok(build_result(
+        "zai-coding-plan",
+        "z.ai",
+        true,
+        true,
+        Some(ProviderUsage {
+            windows,
+            models: None,
+        }),
+        None,
+    ))
+}
+
+pub async fn fetch_quota_for_provider(client: &Client, provider_id: &str) -> Result<ProviderResult> {
+    match provider_id {
+        "openai" => fetch_openai_quota(client).await,
+        "google" => fetch_google_quota(client).await,
+        "zai-coding-plan" => fetch_zai_quota(client).await,
+        _ => Ok(build_result(
+            provider_id,
+            provider_id,
+            false,
+            false,
+            None,
+            Some("Unsupported provider".to_string()),
+        )),
+    }
+}
diff --git a/packages/ui/src/components/sections/usage/UsageCard.tsx b/packages/ui/src/components/sections/usage/UsageCard.tsx
index f295c25b..0bd1d924 100644
--- a/packages/ui/src/components/sections/usage/UsageCard.tsx
+++ b/packages/ui/src/components/sections/usage/UsageCard.tsx
@@ -15,7 +15,7 @@ export const UsageCard: React.FC<UsageCardProps> = ({ title, window, subtitle })
   const windowLabel = formatWindowLabel(title);
 
   return (
-    <div className="rounded-xl border border-border/60 bg-card/40 p-4 shadow-sm">
+    <div className="rounded-xl border border-[var(--interactive-border)] bg-[var(--surface-elevated)]/60 p-4 shadow-sm">
       <div className="flex items-center justify-between gap-3">
         <div className="min-w-0">
           <div className="typography-ui-label text-foreground truncate">{windowLabel}</div>
diff --git a/packages/ui/src/components/sections/usage/UsagePage.tsx b/packages/ui/src/components/sections/usage/UsagePage.tsx
index de9f97a6..a4409051 100644
--- a/packages/ui/src/components/sections/usage/UsagePage.tsx
+++ b/packages/ui/src/components/sections/usage/UsagePage.tsx
@@ -69,20 +69,20 @@ export const UsagePage: React.FC = () => {
         </div>
 
         {!selectedResult && (
-          <div className="rounded-lg border border-border/60 bg-card/40 p-4 text-muted-foreground">
+          <div className="rounded-lg border border-[var(--interactive-border)] bg-[var(--surface-elevated)]/60 p-4 text-muted-foreground">
             <p className="typography-body">No usage data available yet.</p>
           </div>
         )}
 
         {error && (
-          <div className="rounded-lg border border-border/60 bg-card/40 p-4 text-muted-foreground">
+          <div className="rounded-lg border border-[var(--interactive-border)] bg-[var(--surface-elevated)]/60 p-4 text-muted-foreground">
             <p className="typography-body">Failed to refresh usage data.</p>
             <p className="typography-meta mt-1">{error}</p>
           </div>
         )}
 
         {selectedResult && !selectedResult.configured && (
-          <div className="rounded-lg border border-border/60 bg-card/40 p-4 text-muted-foreground">
+          <div className="rounded-lg border border-[var(--interactive-border)] bg-[var(--surface-elevated)]/60 p-4 text-muted-foreground">
             <p className="typography-body">Provider is not configured yet.</p>
             <p className="typography-meta mt-1">
               Add credentials in the Providers tab to enable usage tracking.
@@ -114,7 +114,7 @@ export const UsagePage: React.FC = () => {
 
         {selectedResult?.configured && usage && Object.keys(usage.windows ?? {}).length === 0 &&
           Object.keys(usage.models ?? {}).length === 0 && (
-          <div className="rounded-lg border border-border/60 bg-card/40 p-4 text-muted-foreground">
+          <div className="rounded-lg border border-[var(--interactive-border)] bg-[var(--surface-elevated)]/60 p-4 text-muted-foreground">
             <p className="typography-body">No quota windows reported for this provider.</p>
           </div>
         )}
diff --git a/packages/ui/src/components/sections/usage/UsageProgressBar.tsx b/packages/ui/src/components/sections/usage/UsageProgressBar.tsx
index e8d58840..b0d02228 100644
--- a/packages/ui/src/components/sections/usage/UsageProgressBar.tsx
+++ b/packages/ui/src/components/sections/usage/UsageProgressBar.tsx
@@ -11,17 +11,17 @@ export const UsageProgressBar: React.FC<UsageProgressBarProps> = ({ percent, cla
   const clamped = clampPercent(percent) ?? 0;
   const tone = resolveUsageTone(percent);
 
-  const fillClass = tone === 'critical'
-    ? 'from-rose-500 to-rose-400'
+  const fillStyle = tone === 'critical'
+    ? { backgroundColor: 'var(--status-error)' }
     : tone === 'warn'
-      ? 'from-amber-500 to-amber-400'
-      : 'from-emerald-500 to-emerald-400';
+      ? { backgroundColor: 'var(--status-warning)' }
+      : { backgroundColor: 'var(--status-success)' };
 
   return (
-    <div className={cn('h-2.5 rounded-full bg-muted/60 overflow-hidden', className)}>
+    <div className={cn('h-2.5 rounded-full bg-[var(--interactive-border)] overflow-hidden', className)}>
       <div
-        className={cn('h-full bg-gradient-to-r transition-all duration-300', fillClass)}
-        style={{ width: `${clamped}%` }}
+        className="h-full transition-all duration-300"
+        style={{ ...fillStyle, width: `${clamped}%` }}
         role="progressbar"
         aria-valuenow={clamped}
         aria-valuemin={0}
diff --git a/packages/ui/src/components/sections/usage/UsageSidebar.tsx b/packages/ui/src/components/sections/usage/UsageSidebar.tsx
index 1ef298ca..0f9c0fa7 100644
--- a/packages/ui/src/components/sections/usage/UsageSidebar.tsx
+++ b/packages/ui/src/components/sections/usage/UsageSidebar.tsx
@@ -3,6 +3,7 @@ import { ScrollableOverlay } from '@/components/ui/ScrollableOverlay';
 import { ProviderLogo } from '@/components/ui/ProviderLogo';
 import { Button } from '@/components/ui/button';
 import { Switch } from '@/components/ui/switch';
+import { Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
 import { useDeviceInfo } from '@/lib/device';
 import { isVSCodeRuntime } from '@/lib/desktop';
@@ -90,11 +91,21 @@ export const UsageSidebar: React.FC<UsageSidebarProps> = ({ onItemSelect }) => {
         <div className="flex items-center justify-between gap-2">
           <span className="typography-meta text-muted-foreground">Total {QUOTA_PROVIDERS.length}</span>
           <div className="flex items-center gap-2">
-            <Switch
-              checked={usageAutoRefresh}
-              onCheckedChange={handleUsageAutoRefreshChange}
-              aria-label="Toggle auto refresh"
-            />
+            <Tooltip delayDuration={700}>
+              <TooltipTrigger asChild>
+                <span className="inline-flex">
+                  <Switch
+                    checked={usageAutoRefresh}
+                    onCheckedChange={handleUsageAutoRefreshChange}
+                    aria-label="Toggle auto refresh"
+                    className="data-[state=checked]:bg-[var(--status-info)]"
+                  />
+                </span>
+              </TooltipTrigger>
+              <TooltipContent side="bottom">
+                Auto-refresh usage data at set interval
+              </TooltipContent>
+            </Tooltip>
             <Select
               value={String(usageRefreshIntervalMs)}
               onValueChange={handleUsageRefreshIntervalChange}
@@ -113,7 +124,7 @@ export const UsageSidebar: React.FC<UsageSidebarProps> = ({ onItemSelect }) => {
               type="button"
               variant="ghost"
               size="icon"
-              className="h-7 w-7 -my-1 text-muted-foreground"
+              className="h-7 w-7 -my-1 text-muted-foreground overflow-hidden"
               onClick={() => fetchAllQuotas()}
               aria-label="Refresh usage"
               title="Refresh usage"
@@ -133,20 +144,20 @@ export const UsageSidebar: React.FC<UsageSidebarProps> = ({ onItemSelect }) => {
           const isSelected = provider.id === selectedProviderId;
           const configured = result?.configured ?? false;
 
-          const statusClass = !configured
-            ? 'bg-muted-foreground/40'
+          const statusStyle = !configured
+            ? { backgroundColor: 'var(--surface-muted-foreground)', opacity: 0.4 }
             : tone === 'critical'
-              ? 'bg-rose-500'
+              ? { backgroundColor: 'var(--status-error)' }
               : tone === 'warn'
-                ? 'bg-amber-500'
-                : 'bg-emerald-500';
+                ? { backgroundColor: 'var(--status-warning)' }
+                : { backgroundColor: 'var(--status-success)' };
 
           return (
             <div
               key={provider.id}
               className={cn(
                 'group relative flex items-center rounded-md px-1.5 py-1 transition-all duration-200',
-                isSelected ? 'dark:bg-accent/80 bg-primary/12' : 'hover:dark:bg-accent/40 hover:bg-primary/6'
+                isSelected ? 'bg-interactive-selection' : 'hover:bg-interactive-hover'
               )}
             >
               <button
@@ -157,7 +168,7 @@ export const UsageSidebar: React.FC<UsageSidebarProps> = ({ onItemSelect }) => {
                 }}
                 className="flex min-w-0 flex-1 items-center gap-2 rounded-sm text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50"
               >
-                <span className={cn('h-2.5 w-2.5 rounded-full flex-shrink-0', statusClass)} />
+                <span className="h-2.5 w-2.5 rounded-full flex-shrink-0" style={statusStyle} />
                 <ProviderLogo providerId={provider.id} className="h-4 w-4 flex-shrink-0" />
                 <span className="typography-ui-label font-normal truncate flex-1 min-w-0 text-foreground">
                   {provider.name}
diff --git a/packages/vscode/src/bridge.ts b/packages/vscode/src/bridge.ts
index ca331e30..0dc0ab49 100644
--- a/packages/vscode/src/bridge.ts
+++ b/packages/vscode/src/bridge.ts
@@ -5,6 +5,7 @@ import { spawn } from 'child_process';
 import { type OpenCodeManager } from './opencode';
 import { createAgent, createCommand, deleteAgent, deleteCommand, getAgentSources, getCommandSources, updateAgent, updateCommand, type AgentScope, type CommandScope, AGENT_SCOPE, COMMAND_SCOPE, discoverSkills, getSkillSources, createSkill, updateSkill, deleteSkill, readSkillSupportingFile, writeSkillSupportingFile, deleteSkillSupportingFile, type SkillScope, SKILL_SCOPE, getProviderSources, removeProviderConfig } from './opencodeConfig';
 import { getProviderAuth, removeProviderAuth } from './opencodeAuth';
+import { fetchQuotaForProvider, listConfiguredQuotaProviders } from './quotaProviders';
 import * as gitService from './gitService';
 import {
   getSkillsCatalog,
@@ -180,6 +181,16 @@ const persistSettings = async (changes: Record<string, unknown>, ctx?: BridgeCon
     }
   }
 
+  if (typeof restChanges.usageAutoRefresh !== 'boolean') {
+    delete restChanges.usageAutoRefresh;
+  }
+
+  if (typeof restChanges.usageRefreshIntervalMs === 'number' && Number.isFinite(restChanges.usageRefreshIntervalMs)) {
+    restChanges.usageRefreshIntervalMs = Math.max(30000, Math.min(300000, Math.round(restChanges.usageRefreshIntervalMs)));
+  } else {
+    delete restChanges.usageRefreshIntervalMs;
+  }
+
   const merged = { ...current, ...restChanges, lastDirectory: current.lastDirectory };
   await ctx?.context?.globalState.update(SETTINGS_KEY, merged);
   return merged;
@@ -1914,6 +1925,30 @@ export async function handleBridgeMessage(message: BridgeRequest, ctx?: BridgeCo
         }
       }
 
+      case 'api:quota:providers': {
+        try {
+          const providers = listConfiguredQuotaProviders();
+          return { id, type, success: true, data: { providers } };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return { id, type, success: false, error: errorMessage };
+        }
+      }
+
+      case 'api:quota:get': {
+        const { providerId } = (payload || {}) as { providerId?: string };
+        if (!providerId) {
+          return { id, type, success: false, error: 'Provider ID is required' };
+        }
+        try {
+          const result = await fetchQuotaForProvider(providerId);
+          return { id, type, success: true, data: result };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return { id, type, success: false, error: errorMessage };
+        }
+      }
+
 
       case 'vscode:command': {
         const { command, args } = (payload || {}) as { command?: string; args?: unknown[] };
diff --git a/packages/vscode/src/quotaProviders.ts b/packages/vscode/src/quotaProviders.ts
new file mode 100644
index 00000000..4cbd01b7
--- /dev/null
+++ b/packages/vscode/src/quotaProviders.ts
@@ -0,0 +1,612 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+type AuthEntry = Record<string, unknown> | string;
+type AuthFile = Record<string, AuthEntry>;
+
+type UsageWindow = {
+  usedPercent: number | null;
+  remainingPercent: number | null;
+  windowSeconds: number | null;
+  resetAfterSeconds: number | null;
+  resetAt: number | null;
+  resetAtFormatted: string | null;
+  resetAfterFormatted: string | null;
+};
+
+type ProviderUsage = {
+  windows: Record<string, UsageWindow>;
+  models?: Record<string, ProviderUsage>;
+};
+
+type OpenAiUsagePayload = {
+  rate_limit?: {
+    primary_window?: {
+      used_percent?: number;
+      limit_window_seconds?: number;
+      reset_at?: number;
+    };
+    secondary_window?: {
+      used_percent?: number;
+      limit_window_seconds?: number;
+      reset_at?: number;
+    };
+  };
+};
+
+type GoogleModelsPayload = {
+  models?: Record<string, {
+    quotaInfo?: {
+      remainingFraction?: number;
+      resetTime?: string;
+    };
+  }>;
+};
+
+type ZaiLimit = {
+  type?: string;
+  number?: number;
+  unit?: number;
+  nextResetTime?: number;
+  percentage?: number;
+};
+
+type ZaiPayload = {
+  data?: {
+    limits?: ZaiLimit[];
+  };
+};
+
+export type ProviderResult = {
+  providerId: string;
+  providerName: string;
+  ok: boolean;
+  configured: boolean;
+  usage: ProviderUsage | null;
+  fetchedAt: number;
+  error?: string;
+};
+
+const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
+const OPENCODE_DATA_DIR = path.join(os.homedir(), '.local', 'share', 'opencode');
+const AUTH_FILE = path.join(OPENCODE_DATA_DIR, 'auth.json');
+
+const ANTIGRAVITY_ACCOUNTS_PATHS = [
+  path.join(OPENCODE_CONFIG_DIR, 'antigravity-accounts.json'),
+  path.join(OPENCODE_DATA_DIR, 'antigravity-accounts.json'),
+];
+
+const GOOGLE_CLIENT_ID =
+  '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
+const GOOGLE_CLIENT_SECRET = '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';
+const DEFAULT_PROJECT_ID = 'rising-fact-p41fc';
+const GOOGLE_WINDOW_SECONDS = 5 * 60 * 60;
+
+const GOOGLE_ENDPOINTS = [
+  'https://daily-cloudcode-pa.sandbox.googleapis.com',
+  'https://autopush-cloudcode-pa.sandbox.googleapis.com',
+  'https://cloudcode-pa.googleapis.com',
+];
+
+const GOOGLE_HEADERS = {
+  'User-Agent': 'antigravity/1.11.5 windows/amd64',
+  'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
+  'Client-Metadata':
+    '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}',
+};
+
+const ZAI_TOKEN_WINDOW_SECONDS: Record<number, number> = { 3: 3600 };
+
+const readAuthFile = (): AuthFile => {
+  if (!fs.existsSync(AUTH_FILE)) {
+    return {};
+  }
+  try {
+    const content = fs.readFileSync(AUTH_FILE, 'utf8');
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return {};
+    }
+    return JSON.parse(trimmed) as AuthFile;
+  } catch (error) {
+    console.error('Failed to read auth file:', error);
+    throw new Error('Failed to read OpenCode auth configuration');
+  }
+};
+
+const readJsonFile = (filePath: string): Record<string, unknown> | null => {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== 'object') return null;
+    return parsed as Record<string, unknown>;
+  } catch (error) {
+    console.warn(`Failed to read JSON file: ${filePath}`, error);
+    return null;
+  }
+};
+
+const getAuthEntry = (auth: AuthFile, aliases: string[]) => {
+  for (const alias of aliases) {
+    if (auth[alias]) {
+      return auth[alias];
+    }
+  }
+  return null;
+};
+
+const normalizeAuthEntry = (entry: AuthEntry | null) => {
+  if (!entry) return null;
+  if (typeof entry === 'string') {
+    return { token: entry } as Record<string, unknown>;
+  }
+  if (typeof entry === 'object') {
+    return entry;
+  }
+  return null;
+};
+
+const formatResetAt = (timestamp: number) => {
+  try {
+    return new Date(timestamp).toLocaleTimeString(undefined, {
+      hour: 'numeric',
+      minute: '2-digit',
+    });
+  } catch {
+    return null;
+  }
+};
+
+const formatDuration = (seconds: number | null) => {
+  if (typeof seconds !== 'number' || Number.isNaN(seconds)) {
+    return null;
+  }
+  const clamped = Math.max(0, Math.round(seconds));
+  const hours = Math.floor(clamped / 3600);
+  const minutes = Math.floor((clamped % 3600) / 60);
+  if (hours === 0 && minutes === 0) {
+    return '0m';
+  }
+  if (hours === 0) {
+    return `${minutes}m`;
+  }
+  if (minutes === 0) {
+    return `${hours}h`;
+  }
+  return `${hours}h ${minutes}m`;
+};
+
+const calculateResetAfterSeconds = (resetAt: number | null) => {
+  if (!resetAt) return null;
+  const delta = Math.floor((resetAt - Date.now()) / 1000);
+  return delta < 0 ? 0 : delta;
+};
+
+const toUsageWindow = (data: { usedPercent: number | null; windowSeconds: number | null; resetAt: number | null }) => {
+  const resetAfterSeconds = calculateResetAfterSeconds(data.resetAt);
+  return {
+    usedPercent: data.usedPercent,
+    remainingPercent: data.usedPercent !== null ? Math.max(0, 100 - data.usedPercent) : null,
+    windowSeconds: data.windowSeconds ?? null,
+    resetAfterSeconds,
+    resetAt: data.resetAt,
+    resetAtFormatted: data.resetAt ? formatResetAt(data.resetAt) : null,
+    resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null,
+  } satisfies UsageWindow;
+};
+
+const buildResult = (data: {
+  providerId: string;
+  providerName: string;
+  ok: boolean;
+  configured: boolean;
+  usage?: ProviderUsage | null;
+  error?: string;
+}): ProviderResult => ({
+  providerId: data.providerId,
+  providerName: data.providerName,
+  ok: data.ok,
+  configured: data.configured,
+  usage: data.usage ?? null,
+  ...(data.error ? { error: data.error } : {}),
+  fetchedAt: Date.now(),
+});
+
+export const listConfiguredQuotaProviders = () => {
+  const auth = readAuthFile();
+  const configured = new Set<string>();
+
+  const openaiAuth = normalizeAuthEntry(getAuthEntry(auth, ['openai', 'codex', 'chatgpt']));
+  if (openaiAuth && ((openaiAuth as Record<string, unknown>).access || (openaiAuth as Record<string, unknown>).token)) {
+    configured.add('openai');
+  }
+
+  const googleAuth = normalizeAuthEntry(getAuthEntry(auth, ['google', 'antigravity']));
+  if (googleAuth && ((googleAuth as Record<string, unknown>).access || (googleAuth as Record<string, unknown>).token || (googleAuth as Record<string, unknown>).refresh)) {
+    configured.add('google');
+  }
+
+  const zaiAuth = normalizeAuthEntry(getAuthEntry(auth, ['zai-coding-plan', 'zai', 'z.ai']));
+  if (zaiAuth && ((zaiAuth as Record<string, unknown>).key || (zaiAuth as Record<string, unknown>).token)) {
+    configured.add('zai-coding-plan');
+  }
+
+  for (const filePath of ANTIGRAVITY_ACCOUNTS_PATHS) {
+    const data = readJsonFile(filePath);
+    const accounts = data?.accounts;
+    if (Array.isArray(accounts) && accounts.length > 0) {
+      configured.add('google');
+      break;
+    }
+  }
+
+  return Array.from(configured);
+};
+
+export const fetchOpenaiQuota = async (): Promise<ProviderResult> => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, ['openai', 'codex', 'chatgpt'])) as Record<string, unknown> | null;
+  const accessToken = (entry?.access as string | undefined) ?? (entry?.token as string | undefined);
+
+  if (!accessToken) {
+    return buildResult({
+      providerId: 'openai',
+      providerName: 'OpenAI',
+      ok: false,
+      configured: false,
+      error: 'Not configured',
+    });
+  }
+
+  try {
+    const response = await fetch('https://chatgpt.com/backend-api/wham/usage', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId: 'openai',
+        providerName: 'OpenAI',
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`,
+      });
+    }
+
+    const payload = await response.json() as OpenAiUsagePayload;
+    const primary = payload?.rate_limit?.primary_window ?? null;
+    const secondary = payload?.rate_limit?.secondary_window ?? null;
+
+    const windows: Record<string, UsageWindow> = {};
+    if (primary) {
+      windows['5h'] = toUsageWindow({
+        usedPercent: typeof primary.used_percent === 'number' ? primary.used_percent : null,
+        windowSeconds: typeof primary.limit_window_seconds === 'number' ? primary.limit_window_seconds : null,
+        resetAt: primary.reset_at ? primary.reset_at * 1000 : null,
+      });
+    }
+    if (secondary) {
+      windows['weekly'] = toUsageWindow({
+        usedPercent: typeof secondary.used_percent === 'number' ? secondary.used_percent : null,
+        windowSeconds: typeof secondary.limit_window_seconds === 'number' ? secondary.limit_window_seconds : null,
+        resetAt: secondary.reset_at ? secondary.reset_at * 1000 : null,
+      });
+    }
+
+    return buildResult({
+      providerId: 'openai',
+      providerName: 'OpenAI',
+      ok: true,
+      configured: true,
+      usage: { windows },
+    });
+  } catch (error) {
+    return buildResult({
+      providerId: 'openai',
+      providerName: 'OpenAI',
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed',
+    });
+  }
+};
+
+const resolveGoogleAuth = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, ['google', 'antigravity'])) as Record<string, unknown> | null;
+  if (entry) {
+    const accessToken = (entry.access as string | undefined) ?? (entry.token as string | undefined);
+    let refreshToken = entry.refresh as string | undefined;
+    let projectId: string | undefined;
+    if (refreshToken && refreshToken.includes('|')) {
+      const [first, second] = refreshToken.split('|');
+      refreshToken = first;
+      projectId = second;
+    }
+    return {
+      accessToken,
+      refreshToken,
+      expires: entry.expires as number | undefined,
+      projectId,
+    };
+  }
+
+  for (const filePath of ANTIGRAVITY_ACCOUNTS_PATHS) {
+    const data = readJsonFile(filePath);
+    const accounts = data?.accounts;
+    if (Array.isArray(accounts) && accounts.length > 0) {
+      const index = typeof (data as Record<string, unknown>)?.activeIndex === 'number'
+        ? (data as Record<string, unknown>).activeIndex as number
+        : 0;
+      const account = (accounts[index] as Record<string, unknown> | undefined) ?? (accounts[0] as Record<string, unknown> | undefined);
+      if (account?.refreshToken) {
+        return {
+          refreshToken: account.refreshToken as string,
+          projectId: (account.projectId as string | undefined) ?? (account.managedProjectId as string | undefined),
+          email: account.email as string | undefined,
+        };
+      }
+    }
+  }
+
+  return null;
+};
+
+const refreshGoogleAccessToken = async (refreshToken: string) => {
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      client_id: GOOGLE_CLIENT_ID,
+      client_secret: GOOGLE_CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: 'refresh_token',
+    }),
+  });
+
+  if (!response.ok) {
+    return null;
+  }
+
+  const data = await response.json() as Record<string, unknown>;
+  return typeof data?.access_token === 'string' ? data.access_token : null;
+};
+
+const fetchGoogleModels = async (accessToken: string, projectId?: string) => {
+  const body = projectId ? { project: projectId } : {};
+
+  for (const endpoint of GOOGLE_ENDPOINTS) {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    const timeout = controller ? setTimeout(() => controller.abort(), 15000) : null;
+    try {
+      const response = await fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          'Content-Type': 'application/json',
+          ...GOOGLE_HEADERS,
+        },
+        body: JSON.stringify(body),
+        signal: controller?.signal,
+      });
+
+      if (response.ok) {
+        return await response.json() as Record<string, unknown>;
+      }
+    } catch {
+      // fall through
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+
+  return null;
+};
+
+export const fetchGoogleQuota = async (): Promise<ProviderResult> => {
+  const auth = resolveGoogleAuth();
+  if (!auth) {
+    return buildResult({
+      providerId: 'google',
+      providerName: 'Google',
+      ok: false,
+      configured: false,
+      error: 'Not configured',
+    });
+  }
+
+  const now = Date.now();
+  let accessToken: string | undefined = auth.accessToken;
+  if (!accessToken || (typeof auth.expires === 'number' && auth.expires <= now)) {
+    if (!auth.refreshToken) {
+      return buildResult({
+        providerId: 'google',
+        providerName: 'Google',
+        ok: false,
+        configured: true,
+        error: 'Missing refresh token',
+      });
+    }
+    accessToken = (await refreshGoogleAccessToken(auth.refreshToken)) ?? undefined;
+  }
+
+  if (!accessToken) {
+    return buildResult({
+      providerId: 'google',
+      providerName: 'Google',
+      ok: false,
+      configured: true,
+      error: 'Failed to refresh OAuth token',
+    });
+  }
+
+  const projectId = auth.projectId ?? DEFAULT_PROJECT_ID;
+  const payload = await fetchGoogleModels(accessToken, projectId);
+  if (!payload || typeof payload !== 'object') {
+    return buildResult({
+      providerId: 'google',
+      providerName: 'Google',
+      ok: false,
+      configured: true,
+      error: 'Failed to fetch models',
+    });
+  }
+
+  const models: Record<string, ProviderUsage> = {};
+  const payloadModels = (payload as GoogleModelsPayload).models ?? {};
+  for (const [modelName, modelData] of Object.entries(payloadModels)) {
+    const quotaInfo = modelData?.quotaInfo;
+    const remainingFraction = quotaInfo?.remainingFraction;
+    const remainingPercent = typeof remainingFraction === 'number'
+      ? Math.round(remainingFraction * 100)
+      : null;
+    const usedPercent = remainingPercent !== null ? Math.max(0, 100 - remainingPercent) : null;
+    const resetAt = quotaInfo?.resetTime
+      ? new Date(quotaInfo.resetTime).getTime()
+      : null;
+    models[modelName] = {
+      windows: {
+        '5h': toUsageWindow({
+          usedPercent,
+          windowSeconds: GOOGLE_WINDOW_SECONDS,
+          resetAt,
+        }),
+      },
+    };
+  }
+
+  return buildResult({
+    providerId: 'google',
+    providerName: 'Google',
+    ok: true,
+    configured: true,
+    usage: {
+      windows: {},
+      models: Object.keys(models).length ? models : undefined,
+    },
+  });
+};
+
+const normalizeTimestamp = (value: unknown) => {
+  if (typeof value !== 'number') return null;
+  return value < 1_000_000_000_000 ? value * 1000 : value;
+};
+
+const resolveWindowSeconds = (limit: Record<string, unknown> | undefined) => {
+  if (!limit || typeof limit.number !== 'number') return null;
+  const unitSeconds = ZAI_TOKEN_WINDOW_SECONDS[Number(limit.unit)];
+  if (!unitSeconds) return null;
+  return unitSeconds * limit.number;
+};
+
+const resolveWindowLabel = (windowSeconds: number | null) => {
+  if (!windowSeconds) return 'tokens';
+  if (windowSeconds % 86400 === 0) {
+    const days = windowSeconds / 86400;
+    return days === 7 ? 'weekly' : `${days}d`;
+  }
+  if (windowSeconds % 3600 === 0) {
+    return `${windowSeconds / 3600}h`;
+  }
+  return `${windowSeconds}s`;
+};
+
+export const fetchZaiQuota = async (): Promise<ProviderResult> => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, ['zai-coding-plan', 'zai', 'z.ai'])) as Record<string, unknown> | null;
+  const apiKey = (entry?.key as string | undefined) ?? (entry?.token as string | undefined);
+
+  if (!apiKey) {
+    return buildResult({
+      providerId: 'zai-coding-plan',
+      providerName: 'z.ai',
+      ok: false,
+      configured: false,
+      error: 'Not configured',
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.z.ai/api/monitor/usage/quota/limit', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId: 'zai-coding-plan',
+        providerName: 'z.ai',
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`,
+      });
+    }
+
+    const payload = await response.json() as ZaiPayload;
+    const limits = Array.isArray(payload?.data?.limits) ? payload.data.limits : [];
+    const tokensLimit = limits.find((limit: Record<string, unknown>) => limit?.type === 'TOKENS_LIMIT');
+    const windowSeconds = resolveWindowSeconds(tokensLimit as Record<string, unknown> | undefined);
+    const windowLabel = resolveWindowLabel(windowSeconds);
+    const resetAt = tokensLimit?.nextResetTime ? normalizeTimestamp(tokensLimit.nextResetTime) : null;
+    const usedPercent = typeof tokensLimit?.percentage === 'number' ? tokensLimit.percentage : null;
+
+    const windows: Record<string, UsageWindow> = {};
+    if (tokensLimit) {
+      windows[windowLabel] = toUsageWindow({
+        usedPercent,
+        windowSeconds,
+        resetAt,
+      });
+    }
+
+    return buildResult({
+      providerId: 'zai-coding-plan',
+      providerName: 'z.ai',
+      ok: true,
+      configured: true,
+      usage: { windows },
+    });
+  } catch (error) {
+    return buildResult({
+      providerId: 'zai-coding-plan',
+      providerName: 'z.ai',
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed',
+    });
+  }
+};
+
+export const fetchQuotaForProvider = async (providerId: string): Promise<ProviderResult> => {
+  switch (providerId) {
+    case 'openai':
+      return fetchOpenaiQuota();
+    case 'google':
+      return fetchGoogleQuota();
+    case 'zai-coding-plan':
+      return fetchZaiQuota();
+    default:
+      return buildResult({
+        providerId,
+        providerName: providerId,
+        ok: false,
+        configured: false,
+        error: 'Unsupported provider',
+      });
+  }
+};
diff --git a/packages/vscode/webview/main.tsx b/packages/vscode/webview/main.tsx
index ab2b5042..1812ba09 100644
--- a/packages/vscode/webview/main.tsx
+++ b/packages/vscode/webview/main.tsx
@@ -609,6 +609,28 @@ const handleLocalApiRequest = async (url: URL, init?: RequestInit) => {
     return new Response(JSON.stringify(result), { status: 200, headers: { 'Content-Type': 'application/json' } });
   }
 
+  if (pathname === '/api/quota/providers') {
+    try {
+      const data = await sendBridgeMessage('api:quota:providers');
+      return new Response(JSON.stringify(data), { status: 200, headers: { 'Content-Type': 'application/json' } });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return new Response(JSON.stringify({ error: message }), { status: 500, headers: { 'Content-Type': 'application/json' } });
+    }
+  }
+
+  const quotaMatch = pathname.match(/^\/api\/quota\/([^/]+)$/);
+  if (quotaMatch && (init?.method || 'GET').toUpperCase() === 'GET') {
+    const providerId = decodeURIComponent(quotaMatch[1]);
+    try {
+      const data = await sendBridgeMessage('api:quota:get', { providerId });
+      return new Response(JSON.stringify(data), { status: 200, headers: { 'Content-Type': 'application/json' } });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return new Response(JSON.stringify({ error: message }), { status: 500, headers: { 'Content-Type': 'application/json' } });
+    }
+  }
+
   // Handle provider auth deletion: DELETE /api/provider/:providerId/auth
   const providerAuthMatch = pathname.match(/^\/api\/provider\/([^/]+)\/auth$/);
   if (providerAuthMatch && (init?.method || 'GET').toUpperCase() === 'DELETE') {