Integrate reviewed provider, history, and tray ports

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

@@ -661,6 +661,8 @@ pub struct SettingsSnapshot {
     predictive_pace_warning_enabled: bool,
     show_pace: bool,
     tray_icon_mode: &'static str,
+    stacked_tray_top_provider: Option<String>,
+    stacked_tray_bottom_provider: Option<String>,
     switcher_shows_icons: bool,
     menu_bar_shows_highest_usage: bool,
     menu_bar_shows_percent: bool,
@@ -719,24 +721,56 @@ pub struct SettingsSnapshot {
     provider_accent_colors: std::collections::HashMap<String, String>,
 }
 
-#[tauri::command]
-pub fn get_bootstrap_state() -> BootstrapState {
-    let settings = Settings::load();
+fn bootstrap_state_from_settings(settings: Settings) -> BootstrapState {
     BootstrapState {
         contract_version: "v1",
         providers: provider_catalog_for(&settings),
         settings: SettingsSnapshot::from(settings),
     }
 }
 
+#[cfg(not(test))]
 #[tauri::command]
-pub fn get_provider_catalog() -> Vec<ProviderCatalogEntry> {
+pub fn get_bootstrap_state(
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<BootstrapState, String> {
+    Ok(bootstrap_state_from_settings(settings_for_command(&state)?))
+}
+
+#[cfg(test)]
+#[tauri::command]
+pub fn get_bootstrap_state() -> BootstrapState {
+    bootstrap_state_from_settings(Settings::default())
+}
+
+#[tauri::command]
+pub fn get_provider_catalog(
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<ProviderCatalogEntry>, String> {
+    Ok(provider_catalog_for(&settings_for_command(&state)?))
+}
+
+pub fn get_provider_catalog_for_current_settings() -> Vec<ProviderCatalogEntry> {
     provider_catalog_for(&Settings::load())
 }
 
 #[tauri::command]
-pub fn get_settings_snapshot() -> SettingsSnapshot {
-    SettingsSnapshot::from(Settings::load())
+pub fn get_settings_snapshot(
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<SettingsSnapshot, String> {
+    Ok(SettingsSnapshot::from(settings_for_command(&state)?))
+}
+
+fn settings_for_command(state: &tauri::State<'_, Mutex<AppState>>) -> Result<Settings, String> {
+    let guard = state.lock().map_err(|error| error.to_string())?;
+    if guard.is_containment_proof() {
+        guard
+            .proof_settings()
+            .cloned()
+            .ok_or_else(|| "containment proof settings are unavailable".to_string())
+    } else {
+        Ok(Settings::load())
+    }
 }
 
 impl From<Settings> for SettingsSnapshot {
@@ -783,6 +817,8 @@ impl From<Settings> for SettingsSnapshot {
             predictive_pace_warning_enabled: settings.predictive_pace_warning_enabled,
             show_pace: settings.show_pace,
             tray_icon_mode: tray_icon_mode_label(settings.tray_icon_mode),
+            stacked_tray_top_provider: settings.stacked_tray_top_provider,
+            stacked_tray_bottom_provider: settings.stacked_tray_bottom_provider,
             switcher_shows_icons: settings.switcher_shows_icons,
             menu_bar_shows_highest_usage: settings.menu_bar_shows_highest_usage,
             menu_bar_shows_percent: settings.menu_bar_shows_percent,
@@ -876,6 +912,7 @@ fn tray_icon_mode_label(mode: TrayIconMode) -> &'static str {
     match mode {
         TrayIconMode::Single => "single",
         TrayIconMode::PerProvider => "perProvider",
+        TrayIconMode::Stacked => "stacked",
     }
 }
 

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

@@ -54,11 +54,22 @@ fn locale_strings_for(lang: Language) -> LocaleStrings {
 /// the persisted label (`"english"`, `"chinese"`), or the full name
 /// (`"English"`, `"Chinese"`, `"中文"`).
 #[tauri::command]
-pub fn get_locale_strings(language: Option<String>) -> Result<LocaleStrings, String> {
-    let lang = match language.as_deref() {
-        None => locale::current_language(),
-        Some(raw) => {
-            parse_locale_language(raw).ok_or_else(|| format!("unknown language code: {raw}"))?
+pub fn get_locale_strings(
+    state: tauri::State<'_, Mutex<AppState>>,
+    language: Option<String>,
+) -> Result<LocaleStrings, String> {
+    let proof_mode = state
+        .lock()
+        .map(|guard| guard.is_containment_proof())
+        .unwrap_or(true);
+    let lang = if proof_mode {
+        Language::English
+    } else {
+        match language.as_deref() {
+            None => locale::current_language(),
+            Some(raw) => {
+                parse_locale_language(raw).ok_or_else(|| format!("unknown language code: {raw}"))?
+            }
         }
     };
     Ok(locale_strings_for(lang))
@@ -71,7 +82,18 @@ fn parse_locale_language(raw: &str) -> Option<Language> {
 /// Persist the UI language and emit a `locale-changed` event so the
 /// frontend can refetch its locale table without a restart.
 #[tauri::command]
-pub fn set_ui_language(app: tauri::AppHandle, language: String) -> Result<(), String> {
+pub fn set_ui_language(
+    app: tauri::AppHandle,
+    state: tauri::State<'_, Mutex<AppState>>,
+    language: String,
+) -> Result<(), String> {
+    if state
+        .lock()
+        .map(|guard| guard.is_containment_proof())
+        .unwrap_or(true)
+    {
+        return Err("settings mutations disabled in containment proof mode".to_string());
+    }
     let lang =
         parse_locale_language(&language).ok_or_else(|| format!("unknown language: {language}"))?;
     let mut settings = Settings::load();

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

@@ -104,6 +104,39 @@ fn canonical_provider_arg(provider_id: &str) -> Result<String, String> {
     Ok(parse_provider_arg(provider_id)?.cli_name().to_string())
 }
 
+fn provider_dashboard_url(id: ProviderId, settings: &Settings) -> Option<String> {
+    match id {
+        ProviderId::MiniMax => Some(
+            codexbar::providers::MiniMaxProvider::dashboard_url_for_region(Some(
+                settings.api_region(id),
+            )),
+        ),
+        ProviderId::Kimi => Some(
+            codexbar::providers::KimiRegion::from_settings(Some(settings.api_region(id)))
+                .console_url()
+                .to_string(),
+        ),
+        ProviderId::OpenRouter => instantiate_provider(id)
+            .metadata()
+            .dashboard_url
+            .map(str::to_string),
+        _ => provider_dashboard_url_from_sources(
+            instantiate_provider(id).metadata().dashboard_url,
+            codexbar::settings::get_api_key_providers()
+                .into_iter()
+                .find(|provider| provider.id == id)
+                .and_then(|provider| provider.dashboard_url),
+        ),
+    }
+}
+
+fn provider_dashboard_url_from_sources(
+    metadata_url: Option<&'static str>,
+    api_key_catalog_url: Option<&'static str>,
+) -> Option<String> {
+    metadata_url.or(api_key_catalog_url).map(str::to_string)
+}
+
 fn validate_single_line_secret(value: &str, field: &str, max_len: usize) -> Result<(), String> {
     let trimmed = value.trim();
     if trimmed.is_empty() {

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

@@ -73,15 +73,7 @@ pub(crate) fn build_provider_detail(
     let provider = instantiate_provider(id);
     let metadata = provider.metadata();
     let resume_supported = auto_resume_supported(id);
-    let dashboard_url = if id == codexbar::core::ProviderId::MiniMax {
-        Some(
-            codexbar::providers::MiniMaxProvider::dashboard_url_for_region(Some(
-                settings.api_region(id),
-            )),
-        )
-    } else {
-        metadata.dashboard_url.map(|s| s.to_string())
-    };
+    let dashboard_url = provider_dashboard_url(id, &settings);
 
     let detail = ProviderDetail {
         id: id.cli_name().to_string(),

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

@@ -87,7 +87,7 @@ fn provider_cache_can_skip_refresh(
             .iter()
             .any(|snapshot| snapshot.provider_id == id.cli_name())
     });
-    if !force && crate::proof_harness::seed_usage_json_active() && cache_has_all {
+    if !force && state.provider_cache_seeded && cache_has_all {
         return true;
     }
     !force
@@ -125,6 +125,38 @@ pub(super) fn complete_provider_refresh(
 mod tests {
     use super::*;
 
+    #[test]
+    fn validated_seed_pins_only_complete_nonforced_cache() {
+        let mut state = AppState::new();
+        state.provider_cache.push(
+            crate::proof_harness::parse_seed_usage_snapshot(
+                r#"{"providerId":"codex","primary":{"usedPercent":25.0}}"#,
+            )
+            .unwrap(),
+        );
+        assert!(!provider_cache_can_skip_refresh(
+            &state,
+            false,
+            &[ProviderId::Codex]
+        ));
+        state.provider_cache_seeded = true;
+        assert!(provider_cache_can_skip_refresh(
+            &state,
+            false,
+            &[ProviderId::Codex]
+        ));
+        assert!(!provider_cache_can_skip_refresh(
+            &state,
+            true,
+            &[ProviderId::Codex]
+        ));
+        assert!(!provider_cache_can_skip_refresh(
+            &state,
+            false,
+            &[ProviderId::Codex, ProviderId::Claude]
+        ));
+    }
+
     #[test]
     fn stale_inputs_cannot_reserve_a_new_generation_after_invalidation() {
         let mut state = AppState::new();

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

@@ -272,6 +272,7 @@ fn region_provider(provider_id: &str) -> Option<codexbar::core::ProviderId> {
         "alibabatokenplan" => ProviderId::AlibabaTokenPlan,
         "zai" => ProviderId::Zai,
         "minimax" => ProviderId::MiniMax,
+        "kimi" => ProviderId::Kimi,
         _ => return None,
     })
 }
@@ -284,6 +285,10 @@ pub(crate) fn provider_region_lookup(settings: &Settings, provider_id: &str) ->
             ))
             .settings_value()
             .to_string()
+        } else if id == codexbar::core::ProviderId::Kimi {
+            codexbar::providers::KimiRegion::from_settings(Some(settings.api_region(id)))
+                .settings_value()
+                .to_string()
         } else {
             settings.api_region(id).to_string()
         }
@@ -820,6 +825,14 @@ pub fn region_options_for(provider_id: &str) -> Vec<RegionOption> {
                     .to_string(),
             },
         ],
+        "kimi" => codexbar::providers::KimiRegion::ALL
+            .iter()
+            .copied()
+            .map(|region| RegionOption {
+                value: region.settings_value().to_string(),
+                label: region.display_name().to_string(),
+            })
+            .collect(),
         "alibabatokenplan" => codexbar::providers::AlibabaTokenPlanRegion::ALL
             .iter()
             .copied()

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

@@ -10,6 +10,7 @@ use serde::Serialize;
 use std::sync::Arc;
 
 const MAX_CONCURRENT_PROVIDER_FETCHES: usize = 8;
+const PROOF_REFRESH_DISABLED: &str = "provider refresh disabled in containment proof mode";
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum RefreshScope {
@@ -379,10 +380,13 @@ async fn do_refresh_providers_with_policy(
     scope: RefreshScope,
 ) -> Result<ProviderRefreshOutcome, String> {
     let state = app.state::<Mutex<AppState>>();
-    let expected_generation = state
-        .lock()
-        .map_err(|e| e.to_string())?
-        .provider_refresh_generation;
+    let expected_generation = {
+        let guard = state.lock().map_err(|e| e.to_string())?;
+        if guard.is_containment_proof() {
+            return Err(PROOF_REFRESH_DISABLED.to_string());
+        }
+        guard.provider_refresh_generation
+    };
     let settings = Settings::load();
     let enabled_ids = settings.get_enabled_provider_ids();
     let refresh_ids = scope.provider_ids(&settings, &enabled_ids);
@@ -1159,6 +1163,13 @@ pub struct DeepSeekPricingStatus {
 pub fn get_deepseek_pricing_status(
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Option<DeepSeekPricingStatus> {
+    if state
+        .lock()
+        .map(|guard| guard.is_containment_proof())
+        .unwrap_or(true)
+    {
+        return None;
+    }
     let settings = Settings::load();
     if !settings.enabled_providers.contains("deepseek") {
         return None;
@@ -1203,11 +1214,21 @@ pub async fn refresh_providers_if_stale(app: tauri::AppHandle) -> Result<(), Str
 pub fn get_cached_providers(
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Vec<ProviderUsagePresentationSnapshot> {
-    let snapshots = state
+    let (snapshots, proof_mode, proof_settings) = state
         .lock()
-        .map(|guard| guard.provider_cache.clone())
-        .unwrap_or_default();
-    let settings = Settings::load();
+        .map(|guard| {
+            (
+                guard.provider_cache.clone(),
+                guard.is_containment_proof(),
+                guard.proof_settings().cloned(),
+            )
+        })
+        .unwrap_or((Vec::new(), true, None));
+    let settings = if proof_mode {
+        proof_settings.unwrap_or_default()
+    } else {
+        Settings::load()
+    };
 
     snapshots
         .into_iter()