feat(failover): add auto-failover master switch with proxy integration (#427)

* feat(failover): add auto-failover master switch with proxy integration

- Add persistent auto_failover_enabled setting in database
- Add get/set_auto_failover_enabled commands
- Provider router respects master switch state
- Proxy shutdown automatically disables failover
- Enabling failover auto-starts proxy server
- Optimistic updates for failover queue toggle

* feat(proxy): persist proxy takeover state across app restarts

- Add proxy_takeover_{app_type} settings for per-app state tracking
- Restore proxy takeover state automatically on app startup
- Preserve state on normal exit, clear on manual stop
- Add stop_with_restore_keep_state method for graceful shutdown

* fix(proxy): set takeover state for all apps in start_with_takeover

src-tauri/src/database/dao/failover.rs

@@ -182,11 +182,25 @@ impl Database {
     ) -> Result<(), AppError> {
         let conn = lock_conn!(self.conn);
 
-        conn.execute(
-            "UPDATE failover_queue SET enabled = ?3 WHERE app_type = ?1 AND provider_id = ?2",
-            rusqlite::params![app_type, provider_id, enabled],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
+        let rows_affected = conn
+            .execute(
+                "UPDATE failover_queue SET enabled = ?3 WHERE app_type = ?1 AND provider_id = ?2",
+                rusqlite::params![app_type, provider_id, enabled],
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        if rows_affected == 0 {
+            log::warn!(
+                "set_failover_item_enabled: 未找到匹配记录 app_type={app_type}, provider_id={provider_id}"
+            );
+            return Err(AppError::Database(format!(
+                "未找到故障转移队列项: app_type={app_type}, provider_id={provider_id}"
+            )));
+        }
+
+        log::info!(
+            "set_failover_item_enabled: 已更新 app_type={app_type}, provider_id={provider_id}, enabled={enabled}"
+        );
 
         Ok(())
     }

src-tauri/src/database/dao/proxy.rs

@@ -71,21 +71,27 @@ impl Database {
         Ok(())
     }
 
-    /// 设置 Live 接管状态
+    /// 设置 Live 接管状态（仅更新 proxy_config 表，兼容旧逻辑）
+    ///
+    /// 注意：此方法不会清除 settings 表中的 proxy_takeover_* 状态。
+    /// settings 表的状态由 set_proxy_takeover_enabled 单独管理，用于跨重启保持状态。
     pub async fn set_live_takeover_active(&self, active: bool) -> Result<(), AppError> {
+        // 仅更新 proxy_config 表（兼容旧版本）
         let conn = lock_conn!(self.conn);
         conn.execute(
             "UPDATE proxy_config SET live_takeover_active = ?1, updated_at = datetime('now') WHERE id = 1",
             rusqlite::params![if active { 1 } else { 0 }],
         )
         .map_err(|e| AppError::Database(e.to_string()))?;
+
         Ok(())
     }
 
     /// 检查是否处于 Live 接管模式
+    ///
+    /// v3.8.0+：以 settings 表中的 `proxy_takeover_{app_type}` 为真实来源
     pub async fn is_live_takeover_active(&self) -> Result<bool, AppError> {
-        // v3.7.0+：以 proxy_live_backup 是否存在作为“接管状态”的真实来源（更贴近 per-app 接管）
-        self.has_any_live_backup().await
+        self.has_any_proxy_takeover()
     }
 
     // ==================== Provider Health ====================

src-tauri/src/database/dao/settings.rs

@@ -62,4 +62,56 @@ impl Database {
             Ok(())
         }
     }
+
+    // --- 代理接管状态管理 ---
+
+    /// 获取指定应用的代理接管状态
+    ///
+    /// 使用 settings 表存储各应用的接管状态，key 格式: `proxy_takeover_{app_type}`
+    pub fn get_proxy_takeover_enabled(&self, app_type: &str) -> Result<bool, AppError> {
+        let key = format!("proxy_takeover_{app_type}");
+        match self.get_setting(&key)? {
+            Some(value) => Ok(value == "true"),
+            None => Ok(false),
+        }
+    }
+
+    /// 设置指定应用的代理接管状态
+    ///
+    /// - `true` = 开启代理接管
+    /// - `false` = 关闭代理接管
+    pub fn set_proxy_takeover_enabled(
+        &self,
+        app_type: &str,
+        enabled: bool,
+    ) -> Result<(), AppError> {
+        let key = format!("proxy_takeover_{app_type}");
+        let value = if enabled { "true" } else { "false" };
+        self.set_setting(&key, value)
+    }
+
+    /// 检查是否有任一应用开启了代理接管
+    pub fn has_any_proxy_takeover(&self) -> Result<bool, AppError> {
+        let conn = lock_conn!(self.conn);
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM settings WHERE key LIKE 'proxy_takeover_%' AND value = 'true'",
+                [],
+                |row| row.get(0),
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(count > 0)
+    }
+
+    /// 清除所有代理接管状态（将所有 proxy_takeover_* 设置为 false）
+    pub fn clear_all_proxy_takeover(&self) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE settings SET value = 'false' WHERE key LIKE 'proxy_takeover_%'",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        log::info!("已清除所有代理接管状态");
+        Ok(())
+    }
 }