fix(tests): correct error type assertions in proxy DAO tests

The tests expected AppError::InvalidInput but the DAO functions use
AppError::localized() which returns AppError::Localized variant.
Updated assertions to match the correct error type with key validation.

src-tauri/Cargo.lock

@@ -701,7 +701,7 @@ dependencies = [
 
 [[package]]
 name = "cc-switch"
-version = "3.10.1"
+version = "3.10.2"
 dependencies = [
  "anyhow",
  "async-stream",

src-tauri/build.rs

@@ -1,3 +1,28 @@
 fn main() {
-    tauri_build::build()
+    tauri_build::build();
+
+    // Windows: Embed Common Controls v6 manifest for test binaries
+    //
+    // When running `cargo test`, the generated test executables don't include
+    // the standard Tauri application manifest. Without Common Controls v6,
+    // `tauri::test` calls fail with STATUS_ENTRYPOINT_NOT_FOUND.
+    //
+    // This workaround:
+    // 1. Embeds the manifest into test binaries via /MANIFEST:EMBED
+    // 2. Uses /MANIFEST:NO for the main binary to avoid duplicate resources
+    //    (Tauri already handles manifest embedding for the app binary)
+    #[cfg(target_os = "windows")]
+    {
+        let manifest_path = std::path::PathBuf::from(
+            std::env::var("CARGO_MANIFEST_DIR").expect("missing CARGO_MANIFEST_DIR"),
+        )
+        .join("common-controls.manifest");
+        let manifest_arg = format!("/MANIFESTINPUT:{}", manifest_path.display());
+
+        println!("cargo:rustc-link-arg=/MANIFEST:EMBED");
+        println!("cargo:rustc-link-arg={}", manifest_arg);
+        // Avoid duplicate manifest resources in binary builds.
+        println!("cargo:rustc-link-arg-bins=/MANIFEST:NO");
+        println!("cargo:rerun-if-changed={}", manifest_path.display());
+    }
 }

src-tauri/common-controls.manifest

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity type="win32"
+        name="Microsoft.Windows.Common-Controls"
+        version="6.0.0.0"
+        processorArchitecture="*"
+        publicKeyToken="6595b64144ccf1df"
+        language="*"/>
+    </dependentAssembly>
+  </dependency>
+</assembly>

src-tauri/src/app_config.rs

@@ -282,6 +282,25 @@ impl AppType {
             AppType::OpenCode => "opencode",
         }
     }
+
+    /// Check if this app uses additive mode
+    ///
+    /// - Switch mode (false): Only the current provider is written to live config (Claude, Codex, Gemini)
+    /// - Additive mode (true): All providers are written to live config (OpenCode)
+    pub fn is_additive_mode(&self) -> bool {
+        matches!(self, AppType::OpenCode)
+    }
+
+    /// Return an iterator over all app types
+    pub fn all() -> impl Iterator<Item = AppType> {
+        [
+            AppType::Claude,
+            AppType::Codex,
+            AppType::Gemini,
+            AppType::OpenCode,
+        ]
+        .into_iter()
+    }
 }
 
 impl FromStr for AppType {

src-tauri/src/codex_config.rs

@@ -2,21 +2,14 @@
 use std::path::PathBuf;
 
 use crate::config::{
-    atomic_write, delete_file, sanitize_provider_name, write_json_file, write_text_file,
+    atomic_write, delete_file, get_home_dir, sanitize_provider_name, write_json_file,
+    write_text_file,
 };
 use crate::error::AppError;
 use serde_json::Value;
 use std::fs;
 use std::path::Path;
 
-/// 获取用户主目录，带回退和日志
-fn get_home_dir() -> PathBuf {
-    dirs::home_dir().unwrap_or_else(|| {
-        log::warn!("无法获取用户主目录，回退到当前目录");
-        PathBuf::from(".")
-    })
-}
-
 /// 获取 Codex 配置目录路径
 pub fn get_codex_config_dir() -> PathBuf {
     if let Some(custom) = crate::settings::get_codex_override_dir() {

src-tauri/src/commands/misc.rs

@@ -581,18 +581,19 @@ fn write_claude_config(
     std::fs::write(config_file, config_json).map_err(|e| format!("写入配置文件失败: {e}"))
 }
 
-/// macOS: 使用 Terminal.app 启动
+/// macOS: 根据用户首选终端启动
 #[cfg(target_os = "macos")]
 fn launch_macos_terminal(config_file: &std::path::Path) -> Result<(), String> {
     use std::os::unix::fs::PermissionsExt;
-    use std::process::Command;
+
+    let preferred = crate::settings::get_preferred_terminal();
+    let terminal = preferred.as_deref().unwrap_or("terminal");
 
     let temp_dir = std::env::temp_dir();
     let script_file = temp_dir.join(format!("cc_switch_launcher_{}.sh", std::process::id()));
-
     let config_path = config_file.to_string_lossy();
 
-    // Write the shell script to a temp file (no escaping needed!)
+    // Write the shell script to a temp file
     let script_content = format!(
         r#"#!/bin/bash
 trap 'rm -f "{config_path}" "{script_file}"' EXIT
@@ -611,7 +612,34 @@ exec bash --norc --noprofile
     std::fs::set_permissions(&script_file, std::fs::Permissions::from_mode(0o755))
         .map_err(|e| format!("设置脚本权限失败: {e}"))?;
 
-    // Simple AppleScript - just execute the script file
+    // Try the preferred terminal first, fall back to Terminal.app if it fails
+    // Note: Kitty doesn't need the -e flag, others do
+    let result = match terminal {
+        "iterm2" => launch_macos_iterm2(&script_file),
+        "alacritty" => launch_macos_open_app("Alacritty", &script_file, true),
+        "kitty" => launch_macos_open_app("kitty", &script_file, false),
+        "ghostty" => launch_macos_open_app("Ghostty", &script_file, true),
+        _ => launch_macos_terminal_app(&script_file), // "terminal" or default
+    };
+
+    // If preferred terminal fails and it's not the default, try Terminal.app as fallback
+    if result.is_err() && terminal != "terminal" {
+        log::warn!(
+            "首选终端 {} 启动失败，回退到 Terminal.app: {:?}",
+            terminal,
+            result.as_ref().err()
+        );
+        return launch_macos_terminal_app(&script_file);
+    }
+
+    result
+}
+
+/// macOS: Terminal.app
+#[cfg(target_os = "macos")]
+fn launch_macos_terminal_app(script_file: &std::path::Path) -> Result<(), String> {
+    use std::process::Command;
+
     let applescript = format!(
         r#"tell application "Terminal"
     activate
@@ -627,12 +655,9 @@ end tell"#,
         .map_err(|e| format!("执行 osascript 失败: {e}"))?;
 
     if !output.status.success() {
-        // Clean up on failure
-        let _ = std::fs::remove_file(&script_file);
-        let _ = std::fs::remove_file(config_file);
         let stderr = String::from_utf8_lossy(&output.stderr);
         return Err(format!(
-            "AppleScript 执行失败 (exit code: {:?}): {}",
+            "Terminal.app 执行失败 (exit code: {:?}): {}",
             output.status.code(),
             stderr
         ));
@@ -641,13 +666,86 @@ end tell"#,
     Ok(())
 }
 
-/// Linux: 尝试使用常见终端启动
+/// macOS: iTerm2
+#[cfg(target_os = "macos")]
+fn launch_macos_iterm2(script_file: &std::path::Path) -> Result<(), String> {
+    use std::process::Command;
+
+    let applescript = format!(
+        r#"tell application "iTerm"
+    activate
+    tell current window
+        create tab with default profile
+        tell current session
+            write text "bash '{}'"
+        end tell
+    end tell
+end tell"#,
+        script_file.display()
+    );
+
+    let output = Command::new("osascript")
+        .arg("-e")
+        .arg(&applescript)
+        .output()
+        .map_err(|e| format!("执行 osascript 失败: {e}"))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!(
+            "iTerm2 执行失败 (exit code: {:?}): {}",
+            output.status.code(),
+            stderr
+        ));
+    }
+
+    Ok(())
+}
+
+/// macOS: 使用 open -a 启动支持 --args 参数的终端（Alacritty/Kitty/Ghostty）
+#[cfg(target_os = "macos")]
+fn launch_macos_open_app(
+    app_name: &str,
+    script_file: &std::path::Path,
+    use_e_flag: bool,
+) -> Result<(), String> {
+    use std::process::Command;
+
+    let mut cmd = Command::new("open");
+    cmd.arg("-a").arg(app_name).arg("--args");
+
+    if use_e_flag {
+        cmd.arg("-e");
+    }
+    cmd.arg("bash").arg(script_file);
+
+    let output = cmd
+        .output()
+        .map_err(|e| format!("启动 {} 失败: {e}", app_name))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!(
+            "{} 启动失败 (exit code: {:?}): {}",
+            app_name,
+            output.status.code(),
+            stderr
+        ));
+    }
+
+    Ok(())
+}
+
+/// Linux: 根据用户首选终端启动
 #[cfg(target_os = "linux")]
 fn launch_linux_terminal(config_file: &std::path::Path) -> Result<(), String> {
     use std::os::unix::fs::PermissionsExt;
     use std::process::Command;
 
-    let terminals = [
+    let preferred = crate::settings::get_preferred_terminal();
+
+    // Default terminal list with their arguments
+    let default_terminals = [
         ("gnome-terminal", vec!["--"]),
         ("konsole", vec!["-e"]),
         ("xfce4-terminal", vec!["-e"]),
@@ -655,9 +753,10 @@ fn launch_linux_terminal(config_file: &std::path::Path) -> Result<(), String> {
         ("lxterminal", vec!["-e"]),
         ("alacritty", vec!["-e"]),
         ("kitty", vec!["-e"]),
+        ("ghostty", vec!["-e"]),
     ];
 
-    // Create temp script file (same approach as macOS)
+    // Create temp script file
     let temp_dir = std::env::temp_dir();
     let script_file = temp_dir.join(format!("cc_switch_launcher_{}.sh", std::process::id()));
     let config_path = config_file.to_string_lossy();
@@ -679,25 +778,48 @@ exec bash --norc --noprofile
     std::fs::set_permissions(&script_file, std::fs::Permissions::from_mode(0o755))
         .map_err(|e| format!("设置脚本权限失败: {e}"))?;
 
+    // Build terminal list: preferred terminal first (if specified), then defaults
+    let terminals_to_try: Vec<(&str, Vec<&str>)> = if let Some(ref pref) = preferred {
+        // Find the preferred terminal's args from default list
+        let pref_args = default_terminals
+            .iter()
+            .find(|(name, _)| *name == pref.as_str())
+            .map(|(_, args)| args.iter().map(|s| *s).collect::<Vec<&str>>())
+            .unwrap_or_else(|| vec!["-e"]); // Default args for unknown terminals
+
+        let mut list = vec![(pref.as_str(), pref_args)];
+        // Add remaining terminals as fallbacks
+        for (name, args) in &default_terminals {
+            if *name != pref.as_str() {
+                list.push((*name, args.iter().map(|s| *s).collect()));
+            }
+        }
+        list
+    } else {
+        default_terminals
+            .iter()
+            .map(|(name, args)| (*name, args.iter().map(|s| *s).collect()))
+            .collect()
+    };
+
     let mut last_error = String::from("未找到可用的终端");
 
-    for (terminal, args) in terminals {
-        // Check if terminal exists
-        if std::path::Path::new(&format!("/usr/bin/{}", terminal)).exists()
+    for (terminal, args) in terminals_to_try {
+        // Check if terminal exists in common paths
+        let terminal_exists = std::path::Path::new(&format!("/usr/bin/{}", terminal)).exists()
             || std::path::Path::new(&format!("/bin/{}", terminal)).exists()
-        {
+            || std::path::Path::new(&format!("/usr/local/bin/{}", terminal)).exists()
+            || which_command(terminal);
+
+        if terminal_exists {
             let result = Command::new(terminal)
                 .args(&args)
                 .arg("bash")
                 .arg(script_file.to_string_lossy().as_ref())
-                .output();
+                .spawn();
 
             match result {
-                Ok(output) if output.status.success() => return Ok(()),
-                Ok(output) => {
-                    let stderr = String::from_utf8_lossy(&output.stderr);
-                    last_error = format!("启动 {} 失败: {}", terminal, stderr);
-                }
+                Ok(_) => return Ok(()),
                 Err(e) => {
                     last_error = format!("执行 {} 失败: {}", terminal, e);
                 }
@@ -711,13 +833,25 @@ exec bash --norc --noprofile
     Err(last_error)
 }
 
-/// Windows: 创建临时批处理文件启动
+/// Check if a command exists using `which`
+#[cfg(target_os = "linux")]
+fn which_command(cmd: &str) -> bool {
+    use std::process::Command;
+    Command::new("which")
+        .arg(cmd)
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Windows: 根据用户首选终端启动
 #[cfg(target_os = "windows")]
 fn launch_windows_terminal(
     temp_dir: &std::path::Path,
     config_file: &std::path::Path,
 ) -> Result<(), String> {
-    use std::process::Command;
+    let preferred = crate::settings::get_preferred_terminal();
+    let terminal = preferred.as_deref().unwrap_or("cmd");
 
     let bat_file = temp_dir.join(format!("cc_switch_claude_{}.bat", std::process::id()));
     let config_path_for_batch = config_file.to_string_lossy().replace('&', "^&");
@@ -733,23 +867,53 @@ del \"%~f0\" >nul 2>&1
         config_path_for_batch, config_path_for_batch, config_path_for_batch
     );
 
-    std::fs::write(&bat_file, content).map_err(|e| format!("写入批处理文件失败: {e}"))?;
+    std::fs::write(&bat_file, &content).map_err(|e| format!("写入批处理文件失败: {e}"))?;
+
+    let bat_path = bat_file.to_string_lossy();
+    let ps_cmd = format!("& '{}'", bat_path);
+
+    // Try the preferred terminal first
+    let result = match terminal {
+        "powershell" => run_windows_start_command(
+            &["powershell", "-NoExit", "-Command", &ps_cmd],
+            "PowerShell",
+        ),
+        "wt" => run_windows_start_command(&["wt", "cmd", "/K", &bat_path], "Windows Terminal"),
+        _ => run_windows_start_command(&["cmd", "/K", &bat_path], "cmd"), // "cmd" or default
+    };
+
+    // If preferred terminal fails and it's not the default, try cmd as fallback
+    if result.is_err() && terminal != "cmd" {
+        log::warn!(
+            "首选终端 {} 启动失败，回退到 cmd: {:?}",
+            terminal,
+            result.as_ref().err()
+        );
+        return run_windows_start_command(&["cmd", "/K", &bat_path], "cmd");
+    }
+
+    result
+}
+
+/// Windows: Run a start command with common error handling
+#[cfg(target_os = "windows")]
+fn run_windows_start_command(args: &[&str], terminal_name: &str) -> Result<(), String> {
+    use std::process::Command;
+
+    let mut full_args = vec!["/C", "start"];
+    full_args.extend(args);
 
-    // Use output() to capture errors from the start command
-    // Use /K instead of /C to keep the window open after execution
     let output = Command::new("cmd")
-        .args(["/C", "start", "cmd", "/K", &bat_file.to_string_lossy()])
+        .args(&full_args)
         .creation_flags(CREATE_NO_WINDOW)
         .output()
-        .map_err(|e| format!("执行 cmd 失败: {e}"))?;
+        .map_err(|e| format!("启动 {} 失败: {e}", terminal_name))?;
 
     if !output.status.success() {
-        // Clean up on failure
-        let _ = std::fs::remove_file(&bat_file);
-        let _ = std::fs::remove_file(config_file);
         let stderr = String::from_utf8_lossy(&output.stderr);
         return Err(format!(
-            "启动 Windows 终端失败 (exit code: {:?}): {}",
+            "{} 启动失败 (exit code: {:?}): {}",
+            terminal_name,
             output.status.code(),
             stderr
         ));

src-tauri/src/commands/proxy.rs

@@ -2,6 +2,7 @@
 //!
 //! 提供前端调用的 API 接口
 
+use crate::error::AppError;
 use crate::proxy::types::*;
 use crate::proxy::{CircuitBreakerConfig, CircuitBreakerStats};
 use crate::store::AppState;
@@ -119,6 +120,120 @@ pub async fn update_proxy_config_for_app(
         .map_err(|e| e.to_string())
 }
 
+async fn get_default_cost_multiplier_internal(
+    state: &AppState,
+    app_type: &str,
+) -> Result<String, AppError> {
+    let db = &state.db;
+    db.get_default_cost_multiplier(app_type).await
+}
+
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
+pub async fn get_default_cost_multiplier_test_hook(
+    state: &AppState,
+    app_type: &str,
+) -> Result<String, AppError> {
+    get_default_cost_multiplier_internal(state, app_type).await
+}
+
+/// 获取默认成本倍率
+#[tauri::command]
+pub async fn get_default_cost_multiplier(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+) -> Result<String, String> {
+    get_default_cost_multiplier_internal(&state, &app_type)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+async fn set_default_cost_multiplier_internal(
+    state: &AppState,
+    app_type: &str,
+    value: &str,
+) -> Result<(), AppError> {
+    let db = &state.db;
+    db.set_default_cost_multiplier(app_type, value).await
+}
+
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
+pub async fn set_default_cost_multiplier_test_hook(
+    state: &AppState,
+    app_type: &str,
+    value: &str,
+) -> Result<(), AppError> {
+    set_default_cost_multiplier_internal(state, app_type, value).await
+}
+
+/// 设置默认成本倍率
+#[tauri::command]
+pub async fn set_default_cost_multiplier(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    value: String,
+) -> Result<(), String> {
+    set_default_cost_multiplier_internal(&state, &app_type, &value)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+async fn get_pricing_model_source_internal(
+    state: &AppState,
+    app_type: &str,
+) -> Result<String, AppError> {
+    let db = &state.db;
+    db.get_pricing_model_source(app_type).await
+}
+
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
+pub async fn get_pricing_model_source_test_hook(
+    state: &AppState,
+    app_type: &str,
+) -> Result<String, AppError> {
+    get_pricing_model_source_internal(state, app_type).await
+}
+
+/// 获取计费模式来源
+#[tauri::command]
+pub async fn get_pricing_model_source(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+) -> Result<String, String> {
+    get_pricing_model_source_internal(&state, &app_type)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+async fn set_pricing_model_source_internal(
+    state: &AppState,
+    app_type: &str,
+    value: &str,
+) -> Result<(), AppError> {
+    let db = &state.db;
+    db.set_pricing_model_source(app_type, value).await
+}
+
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
+pub async fn set_pricing_model_source_test_hook(
+    state: &AppState,
+    app_type: &str,
+    value: &str,
+) -> Result<(), AppError> {
+    set_pricing_model_source_internal(state, app_type, value).await
+}
+
+/// 设置计费模式来源
+#[tauri::command]
+pub async fn set_pricing_model_source(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    value: String,
+) -> Result<(), String> {
+    set_pricing_model_source_internal(&state, &app_type, &value)
+        .await
+        .map_err(|e| e.to_string())
+}
+
 /// 检查代理服务器是否正在运行
 #[tauri::command]
 pub async fn is_proxy_running(state: tauri::State<'_, AppState>) -> Result<bool, String> {

src-tauri/src/config.rs

@@ -6,7 +6,17 @@ use std::path::{Path, PathBuf};
 use crate::error::AppError;
 
 /// 获取用户主目录，带回退和日志
-fn get_home_dir() -> PathBuf {
+///
+/// On Windows, respects the `HOME` environment variable (if set) to support
+/// test isolation. Falls back to `dirs::home_dir()` otherwise.
+pub fn get_home_dir() -> PathBuf {
+    #[cfg(windows)]
+    if let Ok(home) = std::env::var("HOME") {
+        let trimmed = home.trim();
+        if !trimmed.is_empty() {
+            return PathBuf::from(trimmed);
+        }
+    }
     dirs::home_dir().unwrap_or_else(|| {
         log::warn!("无法获取用户主目录，回退到当前目录");
         PathBuf::from(".")
@@ -71,10 +81,7 @@ pub fn get_app_config_dir() -> PathBuf {
     if let Some(custom) = crate::app_store::get_app_config_dir_override() {
         return custom;
     }
-
-    dirs::home_dir()
-        .expect("无法获取用户主目录")
-        .join(".cc-switch")
+    get_home_dir().join(".cc-switch")
 }
 
 /// 获取应用配置文件路径

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

@@ -4,6 +4,7 @@
 
 use crate::error::AppError;
 use crate::proxy::types::*;
+use rust_decimal::Decimal;
 
 use super::super::{lock_conn, Database};
 
@@ -75,6 +76,117 @@ impl Database {
         Ok(())
     }
 
+    /// 获取默认成本倍率
+    pub async fn get_default_cost_multiplier(&self, app_type: &str) -> Result<String, AppError> {
+        let result = {
+            let conn = lock_conn!(self.conn);
+            conn.query_row(
+                "SELECT default_cost_multiplier FROM proxy_config WHERE app_type = ?1",
+                [app_type],
+                |row| row.get(0),
+            )
+        };
+
+        match result {
+            Ok(value) => Ok(value),
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                self.init_proxy_config_rows().await?;
+                Ok("1".to_string())
+            }
+            Err(e) => Err(AppError::Database(e.to_string())),
+        }
+    }
+
+    /// 设置默认成本倍率
+    pub async fn set_default_cost_multiplier(
+        &self,
+        app_type: &str,
+        value: &str,
+    ) -> Result<(), AppError> {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            return Err(AppError::localized(
+                "error.multiplierEmpty",
+                "倍率不能为空",
+                "Multiplier cannot be empty",
+            ));
+        }
+        trimmed.parse::<Decimal>().map_err(|e| {
+            AppError::localized(
+                "error.invalidMultiplier",
+                format!("无效倍率: {value} - {e}"),
+                format!("Invalid multiplier: {value} - {e}"),
+            )
+        })?;
+
+        // 确保行存在
+        self.ensure_proxy_config_row_exists(app_type)?;
+
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE proxy_config SET
+                default_cost_multiplier = ?2,
+                updated_at = datetime('now')
+             WHERE app_type = ?1",
+            rusqlite::params![app_type, trimmed],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// 获取计费模式来源
+    pub async fn get_pricing_model_source(&self, app_type: &str) -> Result<String, AppError> {
+        let result = {
+            let conn = lock_conn!(self.conn);
+            conn.query_row(
+                "SELECT pricing_model_source FROM proxy_config WHERE app_type = ?1",
+                [app_type],
+                |row| row.get(0),
+            )
+        };
+
+        match result {
+            Ok(value) => Ok(value),
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                self.init_proxy_config_rows().await?;
+                Ok("response".to_string())
+            }
+            Err(e) => Err(AppError::Database(e.to_string())),
+        }
+    }
+
+    /// 设置计费模式来源
+    pub async fn set_pricing_model_source(
+        &self,
+        app_type: &str,
+        value: &str,
+    ) -> Result<(), AppError> {
+        let trimmed = value.trim();
+        if !matches!(trimmed, "response" | "request") {
+            return Err(AppError::localized(
+                "error.invalidPricingMode",
+                format!("无效计费模式: {value}"),
+                format!("Invalid pricing mode: {value}"),
+            ));
+        }
+
+        // 确保行存在
+        self.ensure_proxy_config_row_exists(app_type)?;
+
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE proxy_config SET
+                pricing_model_source = ?2,
+                updated_at = datetime('now')
+             WHERE app_type = ?1",
+            rusqlite::params![app_type, trimmed],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
     /// 获取应用级代理配置
     pub async fn get_proxy_config_for_app(
         &self,
@@ -177,17 +289,90 @@ impl Database {
         Ok(())
     }
 
+    /// 确保指定 app_type 的 proxy_config 行存在（同步版本，用于 set_* 函数）
+    ///
+    /// 使用与 schema.rs seed 相同的 per-app 默认值
+    fn ensure_proxy_config_row_exists(&self, app_type: &str) -> Result<(), AppError> {
+        let conn = self
+            .conn
+            .lock()
+            .map_err(|e| AppError::Lock(e.to_string()))?;
+
+        // 根据 app_type 使用不同的默认值（与 schema.rs seed 保持一致）
+        let (retries, fb_timeout, idle_timeout, cb_fail, cb_succ, cb_timeout, cb_rate, cb_min) =
+            match app_type {
+                "claude" => (6, 90, 180, 8, 3, 90, 0.7, 15),
+                "codex" => (3, 60, 120, 4, 2, 60, 0.6, 10),
+                "gemini" => (5, 60, 120, 4, 2, 60, 0.6, 10),
+                _ => (3, 60, 120, 4, 2, 60, 0.6, 10), // 默认值
+            };
+
+        conn.execute(
+            "INSERT OR IGNORE INTO proxy_config (
+                app_type, max_retries,
+                streaming_first_byte_timeout, streaming_idle_timeout, non_streaming_timeout,
+                circuit_failure_threshold, circuit_success_threshold, circuit_timeout_seconds,
+                circuit_error_rate_threshold, circuit_min_requests
+            ) VALUES (?1, ?2, ?3, ?4, 600, ?5, ?6, ?7, ?8, ?9)",
+            rusqlite::params![
+                app_type,
+                retries,
+                fb_timeout,
+                idle_timeout,
+                cb_fail,
+                cb_succ,
+                cb_timeout,
+                cb_rate,
+                cb_min
+            ],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
     /// 初始化 proxy_config 表的三行数据
+    ///
+    /// 使用与 schema.rs seed 相同的 per-app 默认值
     async fn init_proxy_config_rows(&self) -> Result<(), AppError> {
         let conn = lock_conn!(self.conn);
 
-        for app_type in &["claude", "codex", "gemini"] {
-            conn.execute(
-                "INSERT OR IGNORE INTO proxy_config (app_type) VALUES (?1)",
-                [app_type],
-            )
-            .map_err(|e| AppError::Database(e.to_string()))?;
-        }
+        // 使用与 schema.rs seed 相同的 per-app 默认值
+        // claude: 更激进的重试和超时配置
+        conn.execute(
+            "INSERT OR IGNORE INTO proxy_config (
+                app_type, max_retries,
+                streaming_first_byte_timeout, streaming_idle_timeout, non_streaming_timeout,
+                circuit_failure_threshold, circuit_success_threshold, circuit_timeout_seconds,
+                circuit_error_rate_threshold, circuit_min_requests
+            ) VALUES ('claude', 6, 90, 180, 600, 8, 3, 90, 0.7, 15)",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // codex: 默认配置
+        conn.execute(
+            "INSERT OR IGNORE INTO proxy_config (
+                app_type, max_retries,
+                streaming_first_byte_timeout, streaming_idle_timeout, non_streaming_timeout,
+                circuit_failure_threshold, circuit_success_threshold, circuit_timeout_seconds,
+                circuit_error_rate_threshold, circuit_min_requests
+            ) VALUES ('codex', 3, 60, 120, 600, 4, 2, 60, 0.6, 10)",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // gemini: 稍高的重试次数
+        conn.execute(
+            "INSERT OR IGNORE INTO proxy_config (
+                app_type, max_retries,
+                streaming_first_byte_timeout, streaming_idle_timeout, non_streaming_timeout,
+                circuit_failure_threshold, circuit_success_threshold, circuit_timeout_seconds,
+                circuit_error_rate_threshold, circuit_min_requests
+            ) VALUES ('gemini', 5, 60, 120, 600, 4, 2, 60, 0.6, 10)",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
 
         Ok(())
     }
@@ -662,3 +847,58 @@ impl Database {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::database::Database;
+    use crate::error::AppError;
+
+    #[tokio::test]
+    async fn test_default_cost_multiplier_round_trip() -> Result<(), AppError> {
+        let db = Database::memory()?;
+
+        let default = db.get_default_cost_multiplier("claude").await?;
+        assert_eq!(default, "1");
+
+        db.set_default_cost_multiplier("claude", "1.5").await?;
+        let updated = db.get_default_cost_multiplier("claude").await?;
+        assert_eq!(updated, "1.5");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_default_cost_multiplier_validation() -> Result<(), AppError> {
+        let db = Database::memory()?;
+
+        let err = db
+            .set_default_cost_multiplier("claude", "not-a-number")
+            .await
+            .unwrap_err();
+        // AppError::localized returns AppError::Localized variant
+        assert!(matches!(err, AppError::Localized { key: "error.invalidMultiplier", .. }));
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_pricing_model_source_round_trip_and_validation() -> Result<(), AppError> {
+        let db = Database::memory()?;
+
+        let default = db.get_pricing_model_source("claude").await?;
+        assert_eq!(default, "response");
+
+        db.set_pricing_model_source("claude", "request").await?;
+        let updated = db.get_pricing_model_source("claude").await?;
+        assert_eq!(updated, "request");
+
+        let err = db
+            .set_pricing_model_source("claude", "invalid")
+            .await
+            .unwrap_err();
+        // AppError::localized returns AppError::Localized variant
+        assert!(matches!(err, AppError::Localized { key: "error.invalidPricingMode", .. }));
+
+        Ok(())
+    }
+}

src-tauri/src/database/mod.rs

@@ -47,7 +47,7 @@ const DB_BACKUP_RETAIN: usize = 10;
 
 /// 当前 Schema 版本号
 /// 每次修改表结构时递增，并在 schema.rs 中添加相应的迁移逻辑
-pub(crate) const SCHEMA_VERSION: i32 = 4;
+pub(crate) const SCHEMA_VERSION: i32 = 5;
 
 /// 安全地序列化 JSON，避免 unwrap panic
 pub(crate) fn to_json_string<T: Serialize>(value: &T) -> Result<String, AppError> {

src-tauri/src/database/schema.rs

@@ -120,6 +120,8 @@ impl Database {
             circuit_failure_threshold INTEGER NOT NULL DEFAULT 4, circuit_success_threshold INTEGER NOT NULL DEFAULT 2,
             circuit_timeout_seconds INTEGER NOT NULL DEFAULT 60, circuit_error_rate_threshold REAL NOT NULL DEFAULT 0.6,
             circuit_min_requests INTEGER NOT NULL DEFAULT 10,
+            default_cost_multiplier TEXT NOT NULL DEFAULT '1',
+            pricing_model_source TEXT NOT NULL DEFAULT 'response',
             created_at TEXT NOT NULL DEFAULT (datetime('now')), updated_at TEXT NOT NULL DEFAULT (datetime('now'))
         )", []).map_err(|e| AppError::Database(e.to_string()))?;
 
@@ -170,6 +172,7 @@ impl Database {
         // 10. Proxy Request Logs 表
         conn.execute("CREATE TABLE IF NOT EXISTS proxy_request_logs (
             request_id TEXT PRIMARY KEY, provider_id TEXT NOT NULL, app_type TEXT NOT NULL, model TEXT NOT NULL,
+            request_model TEXT,
             input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0,
             cache_read_tokens INTEGER NOT NULL DEFAULT 0, cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
             input_cost_usd TEXT NOT NULL DEFAULT '0', output_cost_usd TEXT NOT NULL DEFAULT '0',
@@ -352,6 +355,11 @@ impl Database {
                         Self::migrate_v3_to_v4(conn)?;
                         Self::set_user_version(conn, 4)?;
                     }
+                    4 => {
+                        log::info!("迁移数据库从 v4 到 v5（计费模式支持）");
+                        Self::migrate_v4_to_v5(conn)?;
+                        Self::set_user_version(conn, 5)?;
+                    }
                     _ => {
                         return Err(AppError::Database(format!(
                             "未知的数据库版本 {version}，无法迁移到 {SCHEMA_VERSION}"
@@ -521,6 +529,7 @@ impl Database {
         // proxy_request_logs 表
         conn.execute("CREATE TABLE IF NOT EXISTS proxy_request_logs (
             request_id TEXT PRIMARY KEY, provider_id TEXT NOT NULL, app_type TEXT NOT NULL, model TEXT NOT NULL,
+            request_model TEXT,
             input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0,
             cache_read_tokens INTEGER NOT NULL DEFAULT 0, cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
             input_cost_usd TEXT NOT NULL DEFAULT '0', output_cost_usd TEXT NOT NULL DEFAULT '0',
@@ -677,6 +686,8 @@ impl Database {
             circuit_failure_threshold INTEGER NOT NULL DEFAULT 4, circuit_success_threshold INTEGER NOT NULL DEFAULT 2,
             circuit_timeout_seconds INTEGER NOT NULL DEFAULT 60, circuit_error_rate_threshold REAL NOT NULL DEFAULT 0.6,
             circuit_min_requests INTEGER NOT NULL DEFAULT 10,
+            default_cost_multiplier TEXT NOT NULL DEFAULT '1',
+            pricing_model_source TEXT NOT NULL DEFAULT 'response',
             created_at TEXT NOT NULL DEFAULT (datetime('now')), updated_at TEXT NOT NULL DEFAULT (datetime('now'))
         )", [])?;
 
@@ -879,6 +890,30 @@ impl Database {
         Ok(())
     }
 
+    /// v4 -> v5 迁移：新增计费模式配置与请求模型字段
+    fn migrate_v4_to_v5(conn: &Connection) -> Result<(), AppError> {
+        if Self::table_exists(conn, "proxy_config")? {
+            Self::add_column_if_missing(
+                conn,
+                "proxy_config",
+                "default_cost_multiplier",
+                "TEXT NOT NULL DEFAULT '1'",
+            )?;
+            Self::add_column_if_missing(
+                conn,
+                "proxy_config",
+                "pricing_model_source",
+                "TEXT NOT NULL DEFAULT 'response'",
+            )?;
+        }
+        if Self::table_exists(conn, "proxy_request_logs")? {
+            Self::add_column_if_missing(conn, "proxy_request_logs", "request_model", "TEXT")?;
+        }
+
+        log::info!("v4 -> v5 迁移完成：已添加计费模式与请求模型字段");
+        Ok(())
+    }
+
     /// 插入默认模型定价数据
     /// 格式: (model_id, display_name, input, output, cache_read, cache_creation)
     /// 注意: model_id 使用短横线格式（如 claude-haiku-4-5），与 API 返回的模型名称标准化后一致

src-tauri/src/database/tests.rs

@@ -151,7 +151,7 @@ fn normalize_default(default: &Option<String>) -> Option<String> {
 }
 
 #[test]
-fn migration_sets_user_version_when_missing() {
+fn schema_migration_sets_user_version_when_missing() {
     let conn = Connection::open_in_memory().expect("open memory db");
 
     Database::create_tables_on_conn(&conn).expect("create tables");
@@ -169,7 +169,7 @@ fn migration_sets_user_version_when_missing() {
 }
 
 #[test]
-fn migration_rejects_future_version() {
+fn schema_migration_rejects_future_version() {
     let conn = Connection::open_in_memory().expect("open memory db");
     Database::create_tables_on_conn(&conn).expect("create tables");
     Database::set_user_version(&conn, SCHEMA_VERSION + 1).expect("set future version");
@@ -183,7 +183,7 @@ fn migration_rejects_future_version() {
 }
 
 #[test]
-fn migration_adds_missing_columns_for_providers() {
+fn schema_migration_adds_missing_columns_for_providers() {
     let conn = Connection::open_in_memory().expect("open memory db");
 
     // 创建旧版 providers 表，缺少新增列
@@ -224,7 +224,7 @@ fn migration_adds_missing_columns_for_providers() {
 }
 
 #[test]
-fn migration_aligns_column_defaults_and_types() {
+fn schema_migration_aligns_column_defaults_and_types() {
     let conn = Connection::open_in_memory().expect("open memory db");
     conn.execute_batch(LEGACY_SCHEMA_SQL)
         .expect("seed old schema");
@@ -268,7 +268,67 @@ fn migration_aligns_column_defaults_and_types() {
 }
 
 #[test]
-fn create_tables_repairs_legacy_proxy_config_singleton_to_per_app() {
+fn schema_create_tables_include_pricing_model_columns() {
+    let conn = Connection::open_in_memory().expect("open memory db");
+    Database::create_tables_on_conn(&conn).expect("create tables");
+
+    let multiplier = get_column_info(&conn, "proxy_config", "default_cost_multiplier");
+    assert_eq!(multiplier.r#type, "TEXT");
+    assert_eq!(multiplier.notnull, 1);
+    assert_eq!(normalize_default(&multiplier.default).as_deref(), Some("1"));
+
+    let pricing_source = get_column_info(&conn, "proxy_config", "pricing_model_source");
+    assert_eq!(pricing_source.r#type, "TEXT");
+    assert_eq!(pricing_source.notnull, 1);
+    assert_eq!(
+        normalize_default(&pricing_source.default).as_deref(),
+        Some("response")
+    );
+
+    let request_model = get_column_info(&conn, "proxy_request_logs", "request_model");
+    assert_eq!(request_model.r#type, "TEXT");
+    assert_eq!(request_model.notnull, 0);
+}
+
+#[test]
+fn schema_migration_v4_adds_pricing_model_columns() {
+    let conn = Connection::open_in_memory().expect("open memory db");
+    conn.execute_batch(
+        r#"
+        CREATE TABLE proxy_config (app_type TEXT PRIMARY KEY);
+        CREATE TABLE proxy_request_logs (request_id TEXT PRIMARY KEY, model TEXT NOT NULL);
+        "#,
+    )
+    .expect("seed v4 schema");
+
+    Database::set_user_version(&conn, 4).expect("set user_version=4");
+    Database::apply_schema_migrations_on_conn(&conn).expect("apply migrations");
+
+    let multiplier = get_column_info(&conn, "proxy_config", "default_cost_multiplier");
+    assert_eq!(multiplier.r#type, "TEXT");
+    assert_eq!(multiplier.notnull, 1);
+    assert_eq!(normalize_default(&multiplier.default).as_deref(), Some("1"));
+
+    let pricing_source = get_column_info(&conn, "proxy_config", "pricing_model_source");
+    assert_eq!(pricing_source.r#type, "TEXT");
+    assert_eq!(pricing_source.notnull, 1);
+    assert_eq!(
+        normalize_default(&pricing_source.default).as_deref(),
+        Some("response")
+    );
+
+    let request_model = get_column_info(&conn, "proxy_request_logs", "request_model");
+    assert_eq!(request_model.r#type, "TEXT");
+    assert_eq!(request_model.notnull, 0);
+
+    assert_eq!(
+        Database::get_user_version(&conn).expect("version after migration"),
+        SCHEMA_VERSION
+    );
+}
+
+#[test]
+fn schema_create_tables_repairs_legacy_proxy_config_singleton_to_per_app() {
     let conn = Connection::open_in_memory().expect("open memory db");
 
     // 模拟测试版 v2：user_version=2，但 proxy_config 仍是单例结构（无 app_type）
@@ -433,7 +493,7 @@ fn migration_from_v3_8_schema_v1_to_current_schema_v3() {
 }
 
 #[test]
-fn dry_run_does_not_write_to_disk() {
+fn schema_dry_run_does_not_write_to_disk() {
     // Create minimal valid config for migration
     let mut apps = HashMap::new();
     apps.insert("claude".to_string(), ProviderManager::default());
@@ -507,7 +567,7 @@ fn dry_run_validates_schema_compatibility() {
 }
 
 #[test]
-fn model_pricing_is_seeded_on_init() {
+fn schema_model_pricing_is_seeded_on_init() {
     let db = Database::memory().expect("create memory db");
 
     let conn = db.conn.lock().expect("lock conn");

src-tauri/src/gemini_config.rs

@@ -1,18 +1,10 @@
-use crate::config::write_text_file;
+use crate::config::{get_home_dir, write_text_file};
 use crate::error::AppError;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 
-/// 获取用户主目录，带回退和日志
-fn get_home_dir() -> PathBuf {
-    dirs::home_dir().unwrap_or_else(|| {
-        log::warn!("无法获取用户主目录，回退到当前目录");
-        PathBuf::from(".")
-    })
-}
-
 /// 获取 Gemini 配置目录路径（支持设置覆盖）
 pub fn get_gemini_dir() -> PathBuf {
     if let Some(custom) = crate::settings::get_gemini_override_dir() {

src-tauri/src/lib.rs

@@ -745,6 +745,24 @@ pub fn run() {
                 restore_proxy_state_on_startup(&state).await;
             });
 
+            // 静默启动：根据设置决定是否显示主窗口
+            let settings = crate::settings::get_settings();
+            if let Some(window) = app.get_webview_window("main") {
+                if settings.silent_startup {
+                    // 静默启动模式：保持窗口隐藏
+                    let _ = window.hide();
+                    #[cfg(target_os = "windows")]
+                    let _ = window.set_skip_taskbar(true);
+                    #[cfg(target_os = "macos")]
+                    tray::apply_tray_policy(app.handle(), false);
+                    log::info!("静默启动模式：主窗口已隐藏");
+                } else {
+                    // 正常启动模式：显示窗口
+                    let _ = window.show();
+                    log::info!("正常启动模式：主窗口已显示");
+                }
+            }
+
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -877,6 +895,10 @@ pub fn run() {
             commands::update_global_proxy_config,
             commands::get_proxy_config_for_app,
             commands::update_proxy_config_for_app,
+            commands::get_default_cost_multiplier,
+            commands::set_default_cost_multiplier,
+            commands::get_pricing_model_source,
+            commands::set_pricing_model_source,
             commands::is_proxy_running,
             commands::is_live_takeover_active,
             commands::switch_proxy_provider,

src-tauri/src/provider.rs

@@ -215,6 +215,9 @@ pub struct ProviderMeta {
     /// 成本倍数（用于计算实际成本）
     #[serde(rename = "costMultiplier", skip_serializing_if = "Option::is_none")]
     pub cost_multiplier: Option<String>,
+    /// 计费模式来源（response/request）
+    #[serde(rename = "pricingModelSource", skip_serializing_if = "Option::is_none")]
+    pub pricing_model_source: Option<String>,
     /// 每日消费限额（USD）
     #[serde(rename = "limitDailyUsd", skip_serializing_if = "Option::is_none")]
     pub limit_daily_usd: Option<String>,
@@ -614,3 +617,267 @@ pub struct OpenCodeModelLimit {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub output: Option<u64>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        ClaudeModelConfig, CodexModelConfig, GeminiModelConfig, OpenCodeProviderConfig, Provider,
+        ProviderManager, ProviderMeta, UniversalProvider,
+    };
+    use serde_json::json;
+
+    #[test]
+    fn provider_meta_serializes_pricing_model_source() {
+        let mut meta = ProviderMeta::default();
+        meta.pricing_model_source = Some("response".to_string());
+
+        let value = serde_json::to_value(&meta).expect("serialize ProviderMeta");
+
+        assert_eq!(
+            value
+                .get("pricingModelSource")
+                .and_then(|item| item.as_str()),
+            Some("response")
+        );
+        assert!(value.get("pricing_model_source").is_none());
+    }
+
+    #[test]
+    fn provider_meta_omits_pricing_model_source_when_none() {
+        let meta = ProviderMeta::default();
+        let value = serde_json::to_value(&meta).expect("serialize ProviderMeta");
+
+        assert!(value.get("pricingModelSource").is_none());
+    }
+
+    #[test]
+    fn provider_with_id_populates_defaults() {
+        let settings_config = json!({
+            "env": { "API_KEY": "test" }
+        });
+        let provider = Provider::with_id(
+            "provider-1".to_string(),
+            "Provider".to_string(),
+            settings_config.clone(),
+            Some("https://example.com".to_string()),
+        );
+
+        assert_eq!(provider.id, "provider-1");
+        assert_eq!(provider.name, "Provider");
+        assert_eq!(provider.settings_config, settings_config);
+        assert_eq!(provider.website_url.as_deref(), Some("https://example.com"));
+        assert!(provider.category.is_none());
+        assert!(provider.created_at.is_none());
+        assert!(provider.sort_index.is_none());
+        assert!(provider.notes.is_none());
+        assert!(provider.meta.is_none());
+        assert!(provider.icon.is_none());
+        assert!(provider.icon_color.is_none());
+        assert!(!provider.in_failover_queue);
+    }
+
+    #[test]
+    fn provider_manager_get_all_providers_returns_map() {
+        let mut manager = ProviderManager::default();
+        let provider = Provider::with_id(
+            "provider-1".to_string(),
+            "Provider".to_string(),
+            json!({ "env": {} }),
+            None,
+        );
+        manager.providers.insert("provider-1".to_string(), provider);
+
+        assert_eq!(manager.get_all_providers().len(), 1);
+        assert!(manager.get_all_providers().contains_key("provider-1"));
+    }
+
+    #[test]
+    fn universal_provider_to_claude_provider_uses_models() {
+        let mut universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+        universal.apps.claude = true;
+        universal.models.claude = Some(ClaudeModelConfig {
+            model: Some("claude-main".to_string()),
+            haiku_model: Some("claude-haiku".to_string()),
+            sonnet_model: Some("claude-sonnet".to_string()),
+            opus_model: Some("claude-opus".to_string()),
+        });
+
+        let provider = universal.to_claude_provider().expect("claude provider");
+
+        assert_eq!(provider.id, "universal-claude-u1");
+        assert_eq!(provider.name, "Universal");
+        assert_eq!(provider.category.as_deref(), Some("aggregator"));
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/ANTHROPIC_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("claude-main")
+        );
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/ANTHROPIC_DEFAULT_HAIKU_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("claude-haiku")
+        );
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/ANTHROPIC_DEFAULT_SONNET_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("claude-sonnet")
+        );
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/ANTHROPIC_DEFAULT_OPUS_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("claude-opus")
+        );
+    }
+
+    #[test]
+    fn universal_provider_to_claude_provider_disabled_returns_none() {
+        let universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+
+        assert!(universal.to_claude_provider().is_none());
+    }
+
+    #[test]
+    fn universal_provider_to_codex_provider_appends_v1() {
+        let mut universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+        universal.apps.codex = true;
+        universal.models.codex = Some(CodexModelConfig {
+            model: Some("gpt-4o-mini".to_string()),
+            reasoning_effort: Some("low".to_string()),
+        });
+
+        let provider = universal.to_codex_provider().expect("codex provider");
+        let config = provider
+            .settings_config
+            .get("config")
+            .and_then(|item| item.as_str())
+            .expect("config toml");
+
+        assert!(config.contains("base_url = \"https://api.example.com/v1\""));
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/auth/OPENAI_API_KEY")
+                .and_then(|item| item.as_str()),
+            Some("api-key")
+        );
+    }
+
+    #[test]
+    fn universal_provider_to_codex_provider_keeps_v1_suffix() {
+        let mut universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com/v1".to_string(),
+            "api-key".to_string(),
+        );
+        universal.apps.codex = true;
+
+        let provider = universal.to_codex_provider().expect("codex provider");
+        let config = provider
+            .settings_config
+            .get("config")
+            .and_then(|item| item.as_str())
+            .expect("config toml");
+
+        assert!(config.contains("base_url = \"https://api.example.com/v1\""));
+    }
+
+    #[test]
+    fn universal_provider_to_codex_provider_disabled_returns_none() {
+        let universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+
+        assert!(universal.to_codex_provider().is_none());
+    }
+
+    #[test]
+    fn universal_provider_to_gemini_provider_defaults_model() {
+        let mut universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+        universal.apps.gemini = true;
+
+        let provider = universal.to_gemini_provider().expect("gemini provider");
+
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/GEMINI_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("gemini-2.5-pro")
+        );
+    }
+
+    #[test]
+    fn universal_provider_to_gemini_provider_uses_model() {
+        let mut universal = UniversalProvider::new(
+            "u1".to_string(),
+            "Universal".to_string(),
+            "newapi".to_string(),
+            "https://api.example.com".to_string(),
+            "api-key".to_string(),
+        );
+        universal.apps.gemini = true;
+        universal.models.gemini = Some(GeminiModelConfig {
+            model: Some("gemini-custom".to_string()),
+        });
+
+        let provider = universal.to_gemini_provider().expect("gemini provider");
+
+        assert_eq!(
+            provider
+                .settings_config
+                .pointer("/env/GEMINI_MODEL")
+                .and_then(|item| item.as_str()),
+            Some("gemini-custom")
+        );
+    }
+
+    #[test]
+    fn opencode_provider_config_defaults() {
+        let config = OpenCodeProviderConfig::default();
+        assert_eq!(config.npm, "@ai-sdk/openai-compatible");
+        assert!(config.name.is_none());
+        assert!(config.models.is_empty());
+        assert!(config.options.base_url.is_none());
+        assert!(config.options.api_key.is_none());
+        assert!(config.options.headers.is_none());
+        assert!(config.options.extra.is_empty());
+    }
+}

src-tauri/src/proxy/handlers.rs

@@ -22,9 +22,7 @@ use super::{
 };
 use crate::app_config::AppType;
 use axum::{extract::State, http::StatusCode, response::IntoResponse, Json};
-use rust_decimal::Decimal;
 use serde_json::{json, Value};
-use std::str::FromStr;
 
 // ============================================================================
 // 健康检查和状态查询（简单端点）
@@ -145,6 +143,7 @@ async fn handle_claude_transform(
                             &provider_id,
                             "claude",
                             &model,
+                            &model,
                             usage,
                             latency_ms,
                             first_token_ms,
@@ -215,6 +214,7 @@ async fn handle_claude_transform(
             .unwrap_or("unknown");
         let latency_ms = ctx.latency_ms();
 
+        let request_model = ctx.request_model.clone();
         tokio::spawn({
             let state = state.clone();
             let provider_id = ctx.provider.id.clone();
@@ -225,6 +225,7 @@ async fn handle_claude_transform(
                     &provider_id,
                     "claude",
                     &model,
+                    &request_model,
                     usage,
                     latency_ms,
                     None,
@@ -441,6 +442,7 @@ async fn log_usage(
     provider_id: &str,
     app_type: &str,
     model: &str,
+    request_model: &str,
     usage: TokenUsage,
     latency_ms: u64,
     first_token_ms: Option<u64>,
@@ -451,25 +453,12 @@ async fn log_usage(
 
     let logger = UsageLogger::new(&state.db);
 
-    // 获取 provider 的 cost_multiplier
-    let multiplier = match state.db.get_provider_by_id(provider_id, app_type) {
-        Ok(Some(p)) => {
-            if let Some(meta) = p.meta {
-                if let Some(cm) = meta.cost_multiplier {
-                    Decimal::from_str(&cm).unwrap_or_else(|e| {
-                        log::warn!(
-                            "cost_multiplier 解析失败 (provider_id={provider_id}): {cm} - {e}"
-                        );
-                        Decimal::from(1)
-                    })
-                } else {
-                    Decimal::from(1)
-                }
-            } else {
-                Decimal::from(1)
-            }
-        }
-        _ => Decimal::from(1),
+    let (multiplier, pricing_model_source) =
+        logger.resolve_pricing_config(provider_id, app_type).await;
+    let pricing_model = if pricing_model_source == "request" {
+        request_model
+    } else {
+        model
     };
 
     let request_id = uuid::Uuid::new_v4().to_string();
@@ -479,6 +468,8 @@ async fn log_usage(
         provider_id.to_string(),
         app_type.to_string(),
         model.to_string(),
+        request_model.to_string(),
+        pricing_model.to_string(),
         usage,
         multiplier,
         latency_ms,

src-tauri/src/proxy/response_processor.rs

@@ -13,10 +13,8 @@ use axum::response::{IntoResponse, Response};
 use bytes::Bytes;
 use futures::stream::{Stream, StreamExt};
 use reqwest::header::HeaderMap;
-use rust_decimal::Decimal;
 use serde_json::Value;
 use std::{
-    str::FromStr,
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc,
@@ -128,7 +126,15 @@ pub async fn handle_non_streaming(
                 ctx.request_model.clone()
             };
 
-            spawn_log_usage(state, ctx, usage, &model, status.as_u16(), false);
+            spawn_log_usage(
+                state,
+                ctx,
+                usage,
+                &model,
+                &ctx.request_model,
+                status.as_u16(),
+                false,
+            );
         } else {
             let model = json_value
                 .get("model")
@@ -140,6 +146,7 @@ pub async fn handle_non_streaming(
                 ctx,
                 TokenUsage::default(),
                 &model,
+                &ctx.request_model,
                 status.as_u16(),
                 false,
             );
@@ -159,6 +166,7 @@ pub async fn handle_non_streaming(
             ctx,
             TokenUsage::default(),
             &ctx.request_model,
+            &ctx.request_model,
             status.as_u16(),
             false,
         );
@@ -293,6 +301,7 @@ fn create_usage_collector(
             let state = state.clone();
             let provider_id = provider_id.clone();
             let session_id = session_id.clone();
+            let request_model = request_model.clone();
 
             tokio::spawn(async move {
                 log_usage_internal(
@@ -300,6 +309,7 @@ fn create_usage_collector(
                     &provider_id,
                     app_type_str,
                     &model,
+                    &request_model,
                     usage,
                     latency_ms,
                     first_token_ms,
@@ -315,6 +325,7 @@ fn create_usage_collector(
             let state = state.clone();
             let provider_id = provider_id.clone();
             let session_id = session_id.clone();
+            let request_model = request_model.clone();
 
             tokio::spawn(async move {
                 log_usage_internal(
@@ -322,6 +333,7 @@ fn create_usage_collector(
                     &provider_id,
                     app_type_str,
                     &model,
+                    &request_model,
                     TokenUsage::default(),
                     latency_ms,
                     first_token_ms,
@@ -342,6 +354,7 @@ fn spawn_log_usage(
     ctx: &RequestContext,
     usage: TokenUsage,
     model: &str,
+    request_model: &str,
     status_code: u16,
     is_streaming: bool,
 ) {
@@ -349,6 +362,7 @@ fn spawn_log_usage(
     let provider_id = ctx.provider.id.clone();
     let app_type_str = ctx.app_type_str.to_string();
     let model = model.to_string();
+    let request_model = request_model.to_string();
     let latency_ms = ctx.latency_ms();
     let session_id = ctx.session_id.clone();
 
@@ -358,6 +372,7 @@ fn spawn_log_usage(
             &provider_id,
             &app_type_str,
             &model,
+            &request_model,
             usage,
             latency_ms,
             None,
@@ -376,6 +391,7 @@ async fn log_usage_internal(
     provider_id: &str,
     app_type: &str,
     model: &str,
+    request_model: &str,
     usage: TokenUsage,
     latency_ms: u64,
     first_token_ms: Option<u64>,
@@ -386,26 +402,12 @@ async fn log_usage_internal(
     use super::usage::logger::UsageLogger;
 
     let logger = UsageLogger::new(&state.db);
-
-    // 获取 provider 的 cost_multiplier
-    let multiplier = match state.db.get_provider_by_id(provider_id, app_type) {
-        Ok(Some(p)) => {
-            if let Some(meta) = p.meta {
-                if let Some(cm) = meta.cost_multiplier {
-                    Decimal::from_str(&cm).unwrap_or_else(|e| {
-                        log::warn!(
-                            "cost_multiplier 解析失败 (provider_id={provider_id}): {cm} - {e}"
-                        );
-                        Decimal::from(1)
-                    })
-                } else {
-                    Decimal::from(1)
-                }
-            } else {
-                Decimal::from(1)
-            }
-        }
-        _ => Decimal::from(1),
+    let (multiplier, pricing_model_source) =
+        logger.resolve_pricing_config(provider_id, app_type).await;
+    let pricing_model = if pricing_model_source == "request" {
+        request_model
+    } else {
+        model
     };
 
     let request_id = uuid::Uuid::new_v4().to_string();
@@ -424,6 +426,8 @@ async fn log_usage_internal(
         provider_id.to_string(),
         app_type.to_string(),
         model.to_string(),
+        request_model.to_string(),
+        pricing_model.to_string(),
         usage,
         multiplier,
         latency_ms,
@@ -556,3 +560,185 @@ fn format_headers(headers: &HeaderMap) -> String {
         .collect::<Vec<_>>()
         .join(", ")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::database::Database;
+    use crate::error::AppError;
+    use crate::provider::ProviderMeta;
+    use crate::proxy::failover_switch::FailoverSwitchManager;
+    use crate::proxy::provider_router::ProviderRouter;
+    use crate::proxy::types::{ProxyConfig, ProxyStatus};
+    use rust_decimal::Decimal;
+    use std::collections::HashMap;
+    use std::str::FromStr;
+    use std::sync::Arc;
+    use tokio::sync::RwLock;
+
+    fn build_state(db: Arc<Database>) -> ProxyState {
+        ProxyState {
+            db: db.clone(),
+            config: Arc::new(RwLock::new(ProxyConfig::default())),
+            status: Arc::new(RwLock::new(ProxyStatus::default())),
+            start_time: Arc::new(RwLock::new(None)),
+            current_providers: Arc::new(RwLock::new(HashMap::new())),
+            provider_router: Arc::new(ProviderRouter::new(db.clone())),
+            app_handle: None,
+            failover_manager: Arc::new(FailoverSwitchManager::new(db)),
+        }
+    }
+
+    fn seed_pricing(db: &Database) -> Result<(), AppError> {
+        let conn = crate::database::lock_conn!(db.conn);
+        conn.execute(
+            "INSERT OR REPLACE INTO model_pricing (model_id, display_name, input_cost_per_million, output_cost_per_million)
+             VALUES (?1, ?2, ?3, ?4)",
+            rusqlite::params!["resp-model", "Resp Model", "1.0", "0"],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        conn.execute(
+            "INSERT OR REPLACE INTO model_pricing (model_id, display_name, input_cost_per_million, output_cost_per_million)
+             VALUES (?1, ?2, ?3, ?4)",
+            rusqlite::params!["req-model", "Req Model", "2.0", "0"],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(())
+    }
+
+    fn insert_provider(
+        db: &Database,
+        id: &str,
+        app_type: &str,
+        meta: ProviderMeta,
+    ) -> Result<(), AppError> {
+        let meta_json =
+            serde_json::to_string(&meta).map_err(|e| AppError::Database(e.to_string()))?;
+        let conn = crate::database::lock_conn!(db.conn);
+        conn.execute(
+            "INSERT INTO providers (id, app_type, name, settings_config, meta)
+             VALUES (?1, ?2, ?3, ?4, ?5)",
+            rusqlite::params![id, app_type, "Test Provider", "{}", meta_json],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_log_usage_uses_provider_override_config() -> Result<(), AppError> {
+        let db = Arc::new(Database::memory()?);
+        let app_type = "claude";
+
+        db.set_default_cost_multiplier(app_type, "1.5").await?;
+        db.set_pricing_model_source(app_type, "response").await?;
+        seed_pricing(&db)?;
+
+        let mut meta = ProviderMeta::default();
+        meta.cost_multiplier = Some("2".to_string());
+        meta.pricing_model_source = Some("request".to_string());
+        insert_provider(&db, "provider-1", app_type, meta)?;
+
+        let state = build_state(db.clone());
+        let usage = TokenUsage {
+            input_tokens: 1_000_000,
+            output_tokens: 0,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
+            model: None,
+        };
+
+        log_usage_internal(
+            &state,
+            "provider-1",
+            app_type,
+            "resp-model",
+            "req-model",
+            usage,
+            10,
+            None,
+            false,
+            200,
+            None,
+        )
+        .await;
+
+        let conn = crate::database::lock_conn!(db.conn);
+        let (model, request_model, total_cost, cost_multiplier): (String, String, String, String) =
+            conn.query_row(
+                "SELECT model, request_model, total_cost_usd, cost_multiplier
+                 FROM proxy_request_logs WHERE provider_id = ?1",
+                ["provider-1"],
+                |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        assert_eq!(model, "resp-model");
+        assert_eq!(request_model, "req-model");
+        assert_eq!(
+            Decimal::from_str(&cost_multiplier).unwrap(),
+            Decimal::from_str("2").unwrap()
+        );
+        assert_eq!(
+            Decimal::from_str(&total_cost).unwrap(),
+            Decimal::from_str("4").unwrap()
+        );
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_log_usage_falls_back_to_global_defaults() -> Result<(), AppError> {
+        let db = Arc::new(Database::memory()?);
+        let app_type = "claude";
+
+        db.set_default_cost_multiplier(app_type, "1.5").await?;
+        db.set_pricing_model_source(app_type, "response").await?;
+        seed_pricing(&db)?;
+
+        let meta = ProviderMeta::default();
+        insert_provider(&db, "provider-2", app_type, meta)?;
+
+        let state = build_state(db.clone());
+        let usage = TokenUsage {
+            input_tokens: 1_000_000,
+            output_tokens: 0,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
+            model: None,
+        };
+
+        log_usage_internal(
+            &state,
+            "provider-2",
+            app_type,
+            "resp-model",
+            "req-model",
+            usage,
+            10,
+            None,
+            false,
+            200,
+            None,
+        )
+        .await;
+
+        let conn = crate::database::lock_conn!(db.conn);
+        let (total_cost, cost_multiplier): (String, String) = conn
+            .query_row(
+                "SELECT total_cost_usd, cost_multiplier
+                 FROM proxy_request_logs WHERE provider_id = ?1",
+                ["provider-2"],
+                |row| Ok((row.get(0)?, row.get(1)?)),
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        assert_eq!(
+            Decimal::from_str(&cost_multiplier).unwrap(),
+            Decimal::from_str("1.5").unwrap()
+        );
+        assert_eq!(
+            Decimal::from_str(&total_cost).unwrap(),
+            Decimal::from_str("1.5").unwrap()
+        );
+        Ok(())
+    }
+}

src-tauri/src/proxy/usage/calculator.rs

@@ -40,6 +40,7 @@ impl CostCalculator {
     /// - input_cost: (input_tokens - cache_read_tokens) × 输入价格
     /// - cache_read_cost: cache_read_tokens × 缓存读取价格
     /// - 这样避免缓存部分被重复计费
+    /// - total_cost: 各项成本之和 × 倍率（倍率只作用于最终总价）
     pub fn calculate(
         usage: &TokenUsage,
         pricing: &ModelPricing,
@@ -50,21 +51,20 @@ impl CostCalculator {
         // 计算实际需要按输入价格计费的 token 数（减去缓存命中部分）
         let billable_input_tokens = usage.input_tokens.saturating_sub(usage.cache_read_tokens);
 
-        let input_cost = Decimal::from(billable_input_tokens) * pricing.input_cost_per_million
-            / million
-            * cost_multiplier;
-        let output_cost = Decimal::from(usage.output_tokens) * pricing.output_cost_per_million
-            / million
-            * cost_multiplier;
+        // 各项基础成本（不含倍率）
+        let input_cost =
+            Decimal::from(billable_input_tokens) * pricing.input_cost_per_million / million;
+        let output_cost =
+            Decimal::from(usage.output_tokens) * pricing.output_cost_per_million / million;
         let cache_read_cost =
-            Decimal::from(usage.cache_read_tokens) * pricing.cache_read_cost_per_million / million
-                * cost_multiplier;
+            Decimal::from(usage.cache_read_tokens) * pricing.cache_read_cost_per_million / million;
         let cache_creation_cost = Decimal::from(usage.cache_creation_tokens)
             * pricing.cache_creation_cost_per_million
-            / million
-            * cost_multiplier;
+            / million;
 
-        let total_cost = input_cost + output_cost + cache_read_cost + cache_creation_cost;
+        // 总成本 = 各项基础成本之和 × 倍率
+        let base_total = input_cost + output_cost + cache_read_cost + cache_creation_cost;
+        let total_cost = base_total * cost_multiplier;
 
         CostBreakdown {
             input_cost,
@@ -151,8 +151,9 @@ mod tests {
 
         let cost = CostCalculator::calculate(&usage, &pricing, multiplier);
 
-        // input: 1000 * 3.0 / 1M * 1.5 = 0.0045
-        assert_eq!(cost.input_cost, Decimal::from_str("0.0045").unwrap());
+        // input_cost: 基础价格（不含倍率）= 1000 * 3.0 / 1M = 0.003
+        assert_eq!(cost.input_cost, Decimal::from_str("0.003").unwrap());
+        // total_cost: 基础价格 × 倍率 = 0.003 * 1.5 = 0.0045
         assert_eq!(cost.total_cost, Decimal::from_str("0.0045").unwrap());
     }
 

src-tauri/src/proxy/usage/logger.rs

@@ -6,7 +6,7 @@ use crate::database::Database;
 use crate::error::AppError;
 use crate::services::usage_stats::find_model_pricing_row;
 use rust_decimal::Decimal;
-use std::time::SystemTime;
+use std::{str::FromStr, time::SystemTime};
 
 /// 请求日志
 #[derive(Debug, Clone)]
@@ -15,6 +15,7 @@ pub struct RequestLog {
     pub provider_id: String,
     pub app_type: String,
     pub model: String,
+    pub request_model: String,
     pub usage: TokenUsage,
     pub cost: Option<CostBreakdown>,
     pub latency_ms: u64,
@@ -73,17 +74,18 @@ impl<'a> UsageLogger<'a> {
 
         conn.execute(
             "INSERT INTO proxy_request_logs (
-                request_id, provider_id, app_type, model,
+                request_id, provider_id, app_type, model, request_model,
                 input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens,
                 input_cost_usd, output_cost_usd, cache_read_cost_usd, cache_creation_cost_usd, total_cost_usd,
                 latency_ms, first_token_ms, status_code, error_message, session_id,
                 provider_type, is_streaming, cost_multiplier, created_at
-            ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22)",
+            ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23)",
             rusqlite::params![
                 log.request_id,
                 log.provider_id,
                 log.app_type,
                 log.model,
+                log.request_model,
                 log.usage.input_tokens,
                 log.usage.output_tokens,
                 log.usage.cache_read_tokens,
@@ -123,11 +125,13 @@ impl<'a> UsageLogger<'a> {
         error_message: String,
         latency_ms: u64,
     ) -> Result<(), AppError> {
+        let request_model = model.clone();
         let log = RequestLog {
             request_id,
             provider_id,
             app_type,
             model,
+            request_model,
             usage: TokenUsage::default(),
             cost: None,
             latency_ms,
@@ -160,11 +164,13 @@ impl<'a> UsageLogger<'a> {
         session_id: Option<String>,
         provider_type: Option<String>,
     ) -> Result<(), AppError> {
+        let request_model = model.clone();
         let log = RequestLog {
             request_id,
             provider_id,
             app_type,
             model,
+            request_model,
             usage: TokenUsage::default(),
             cost: None,
             latency_ms,
@@ -194,6 +200,88 @@ impl<'a> UsageLogger<'a> {
         }
     }
 
+    /// 获取有效的倍率与计费模式来源（供应商优先，未配置则回退全局默认）
+    pub async fn resolve_pricing_config(
+        &self,
+        provider_id: &str,
+        app_type: &str,
+    ) -> (Decimal, String) {
+        let default_multiplier_raw = match self.db.get_default_cost_multiplier(app_type).await {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!("[USG-003] 获取默认倍率失败 (app_type={app_type}): {e}");
+                "1".to_string()
+            }
+        };
+        let default_multiplier = match Decimal::from_str(&default_multiplier_raw) {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!(
+                    "[USG-003] 默认倍率解析失败 (app_type={app_type}): {default_multiplier_raw} - {e}"
+                );
+                Decimal::from(1)
+            }
+        };
+
+        let default_pricing_source_raw = match self.db.get_pricing_model_source(app_type).await {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!("[USG-003] 获取默认计费模式失败 (app_type={app_type}): {e}");
+                "response".to_string()
+            }
+        };
+        let default_pricing_source =
+            if matches!(default_pricing_source_raw.as_str(), "response" | "request") {
+                default_pricing_source_raw
+            } else {
+                log::warn!(
+                "[USG-003] 默认计费模式无效 (app_type={app_type}): {default_pricing_source_raw}"
+            );
+                "response".to_string()
+            };
+
+        let provider = self
+            .db
+            .get_provider_by_id(provider_id, app_type)
+            .ok()
+            .flatten();
+
+        let (provider_multiplier, provider_pricing_source) = provider
+            .as_ref()
+            .and_then(|p| p.meta.as_ref())
+            .map(|meta| {
+                (
+                    meta.cost_multiplier.as_deref(),
+                    meta.pricing_model_source.as_deref(),
+                )
+            })
+            .unwrap_or((None, None));
+
+        let cost_multiplier = match provider_multiplier {
+            Some(value) => match Decimal::from_str(value) {
+                Ok(parsed) => parsed,
+                Err(e) => {
+                    log::warn!(
+                        "[USG-003] 供应商倍率解析失败 (provider_id={provider_id}): {value} - {e}"
+                    );
+                    default_multiplier
+                }
+            },
+            None => default_multiplier,
+        };
+
+        let pricing_model_source = match provider_pricing_source {
+            Some(value) if matches!(value, "response" | "request") => value.to_string(),
+            Some(value) => {
+                log::warn!("[USG-003] 供应商计费模式无效 (provider_id={provider_id}): {value}");
+                default_pricing_source.clone()
+            }
+            None => default_pricing_source.clone(),
+        };
+
+        (cost_multiplier, pricing_model_source)
+    }
+
     /// 计算并记录请求
     #[allow(clippy::too_many_arguments)]
     pub fn log_with_calculation(
@@ -202,6 +290,8 @@ impl<'a> UsageLogger<'a> {
         provider_id: String,
         app_type: String,
         model: String,
+        request_model: String,
+        pricing_model: String,
         usage: TokenUsage,
         cost_multiplier: Decimal,
         latency_ms: u64,
@@ -211,10 +301,10 @@ impl<'a> UsageLogger<'a> {
         provider_type: Option<String>,
         is_streaming: bool,
     ) -> Result<(), AppError> {
-        let pricing = self.get_model_pricing(&model)?;
+        let pricing = self.get_model_pricing(&pricing_model)?;
 
         if pricing.is_none() {
-            log::warn!("[USG-002] 模型定价未找到，成本将记录为 0");
+            log::warn!("[USG-002] 模型定价未找到，成本将记录为 0: {pricing_model}");
         }
 
         let cost = CostCalculator::try_calculate(&usage, pricing.as_ref(), cost_multiplier);
@@ -224,6 +314,7 @@ impl<'a> UsageLogger<'a> {
             provider_id,
             app_type,
             model,
+            request_model,
             usage,
             cost,
             latency_ms,
@@ -274,6 +365,8 @@ mod tests {
             "provider-1".to_string(),
             "claude".to_string(),
             "test-model".to_string(),
+            "req-model".to_string(),
+            "test-model".to_string(),
             usage,
             Decimal::from(1),
             100,
@@ -286,14 +379,15 @@ mod tests {
 
         // 验证记录已插入
         let conn = crate::database::lock_conn!(db.conn);
-        let count: i64 = conn
+        let (count, request_model): (i64, String) = conn
             .query_row(
-                "SELECT COUNT(*) FROM proxy_request_logs WHERE request_id = 'req-123'",
+                "SELECT COUNT(*), request_model FROM proxy_request_logs WHERE request_id = 'req-123'",
                 [],
-                |row| row.get(0),
+                |row| Ok((row.get(0)?, row.get(1)?)),
             )
             .unwrap();
         assert_eq!(count, 1);
+        assert_eq!(request_model, "req-model");
         Ok(())
     }
 

src-tauri/src/services/provider/live.rs

@@ -182,33 +182,67 @@ pub(crate) fn write_live_snapshot(app_type: &AppType, provider: &Provider) -> Re
     Ok(())
 }
 
+/// Sync all providers to live configuration (for additive mode apps)
+///
+/// Writes all providers from the database to the live configuration file.
+/// Used for OpenCode and other additive mode applications.
+fn sync_all_providers_to_live(state: &AppState, app_type: &AppType) -> Result<(), AppError> {
+    let providers = state.db.get_all_providers(app_type.as_str())?;
+
+    for provider in providers.values() {
+        if let Err(e) = write_live_snapshot(app_type, provider) {
+            log::warn!(
+                "Failed to sync {:?} provider '{}' to live: {e}",
+                app_type,
+                provider.id
+            );
+            // Continue syncing other providers, don't abort
+        }
+    }
+
+    log::info!(
+        "Synced {} {:?} providers to live config",
+        providers.len(),
+        app_type
+    );
+    Ok(())
+}
+
 /// Sync current provider to live configuration
 ///
 /// 使用有效的当前供应商 ID（验证过存在性）。
 /// 优先从本地 settings 读取，验证后 fallback 到数据库的 is_current 字段。
 /// 这确保了配置导入后无效 ID 会自动 fallback 到数据库。
+///
+/// For additive mode apps (OpenCode), all providers are synced instead of just the current one.
 pub fn sync_current_to_live(state: &AppState) -> Result<(), AppError> {
-    for app_type in [AppType::Claude, AppType::Codex, AppType::Gemini] {
-        // Use validated effective current provider
-        let current_id =
-            match crate::settings::get_effective_current_provider(&state.db, &app_type)? {
-                Some(id) => id,
-                None => continue,
-            };
+    // Sync providers based on mode
+    for app_type in AppType::all() {
+        if app_type.is_additive_mode() {
+            // Additive mode: sync ALL providers
+            sync_all_providers_to_live(state, &app_type)?;
+        } else {
+            // Switch mode: sync only current provider
+            let current_id =
+                match crate::settings::get_effective_current_provider(&state.db, &app_type)? {
+                    Some(id) => id,
+                    None => continue,
+                };
 
-        let providers = state.db.get_all_providers(app_type.as_str())?;
-        if let Some(provider) = providers.get(&current_id) {
-            write_live_snapshot(&app_type, provider)?;
+            let providers = state.db.get_all_providers(app_type.as_str())?;
+            if let Some(provider) = providers.get(&current_id) {
+                write_live_snapshot(&app_type, provider)?;
+            }
+            // Note: get_effective_current_provider already validates existence,
+            // so providers.get() should always succeed here
         }
-        // Note: get_effective_current_provider already validates existence,
-        // so providers.get() should always succeed here
     }
 
     // MCP sync
     McpService::sync_all_enabled(state)?;
 
     // Skill sync
-    for app_type in [AppType::Claude, AppType::Codex, AppType::Gemini] {
+    for app_type in AppType::all() {
         if let Err(e) = crate::services::skill::SkillService::sync_to_app(&state.db, &app_type) {
             log::warn!("同步 Skill 到 {app_type:?} 失败: {e}");
             // Continue syncing other apps, don't abort

src-tauri/src/services/skill.rs

@@ -252,6 +252,50 @@ impl SkillService {
             .map(|s| s.to_string_lossy().to_string())
             .unwrap_or_else(|| skill.directory.clone());
 
+        // 检查数据库中是否已有同名 directory 的 skill（来自其他仓库）
+        let existing_skills = db.get_all_installed_skills()?;
+        for existing in existing_skills.values() {
+            if existing.directory.eq_ignore_ascii_case(&install_name) {
+                // 检查是否来自同一仓库
+                let same_repo = existing.repo_owner.as_deref() == Some(&skill.repo_owner)
+                    && existing.repo_name.as_deref() == Some(&skill.repo_name);
+                if same_repo {
+                    // 同一仓库的同名 skill，返回现有记录（可能需要更新启用状态）
+                    let mut updated = existing.clone();
+                    updated.apps.set_enabled_for(current_app, true);
+                    db.save_skill(&updated)?;
+                    Self::sync_to_app_dir(&updated.directory, current_app)?;
+                    log::info!(
+                        "Skill {} 已存在，更新 {:?} 启用状态",
+                        updated.name,
+                        current_app
+                    );
+                    return Ok(updated);
+                } else {
+                    // 不同仓库的同名 skill，报错
+                    return Err(anyhow!(format_skill_error(
+                        "SKILL_DIRECTORY_CONFLICT",
+                        &[
+                            ("directory", &install_name),
+                            (
+                                "existing_repo",
+                                &format!(
+                                    "{}/{}",
+                                    existing.repo_owner.as_deref().unwrap_or("unknown"),
+                                    existing.repo_name.as_deref().unwrap_or("unknown")
+                                )
+                            ),
+                            (
+                                "new_repo",
+                                &format!("{}/{}", skill.repo_owner, skill.repo_name)
+                            ),
+                        ],
+                        Some("uninstallFirst"),
+                    )));
+                }
+            }
+        }
+
         let dest = ssot_dir.join(&install_name);
 
         // 如果已存在则跳过下载
@@ -933,10 +977,12 @@ impl SkillService {
         Ok(meta)
     }
 
-    /// 去重技能列表
+    /// 去重技能列表（基于完整 key，不同仓库的同名 skill 分开显示）
     fn deduplicate_discoverable_skills(skills: &mut Vec<DiscoverableSkill>) {
         let mut seen = HashMap::new();
         skills.retain(|skill| {
+            // 使用完整 key（owner/repo:directory）作为唯一标识
+            // 这样不同仓库的同名 skill 会分开显示
             let unique_key = skill.key.to_lowercase();
             if let std::collections::hash_map::Entry::Vacant(e) = seen.entry(unique_key) {
                 e.insert(true);

src-tauri/src/services/usage_stats.rs

@@ -94,6 +94,9 @@ pub struct RequestLogDetail {
     pub provider_name: Option<String>,
     pub app_type: String,
     pub model: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_model: Option<String>,
+    pub cost_multiplier: String,
     pub input_tokens: u32,
     pub output_tokens: u32,
     pub cache_read_tokens: u32,
@@ -140,7 +143,7 @@ impl Database {
         };
 
         let sql = format!(
-            "SELECT 
+            "SELECT
                 COUNT(*) as total_requests,
                 COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost,
                 COALESCE(SUM(input_tokens), 0) as total_input_tokens,
@@ -218,7 +221,7 @@ impl Database {
         }
 
         let sql = "
-            SELECT 
+            SELECT
                 CAST((created_at - ?1) / ?3 AS INTEGER) as bucket_idx,
                 COUNT(*) as request_count,
                 COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost,
@@ -295,7 +298,7 @@ impl Database {
     pub fn get_provider_stats(&self) -> Result<Vec<ProviderStats>, AppError> {
         let conn = lock_conn!(self.conn);
 
-        let sql = "SELECT 
+        let sql = "SELECT
                 l.provider_id,
                 p.name as provider_name,
                 COUNT(*) as request_count,
@@ -343,7 +346,7 @@ impl Database {
     pub fn get_model_stats(&self) -> Result<Vec<ModelStats>, AppError> {
         let conn = lock_conn!(self.conn);
 
-        let sql = "SELECT 
+        let sql = "SELECT
                 model,
                 COUNT(*) as request_count,
                 COALESCE(SUM(input_tokens + output_tokens), 0) as total_tokens,
@@ -424,7 +427,7 @@ impl Database {
 
         // 获取总数
         let count_sql = format!(
-            "SELECT COUNT(*) FROM proxy_request_logs l 
+            "SELECT COUNT(*) FROM proxy_request_logs l
              LEFT JOIN providers p ON l.provider_id = p.id AND l.app_type = p.app_type
              {where_clause}"
         );
@@ -440,6 +443,7 @@ impl Database {
 
         let sql = format!(
             "SELECT l.request_id, l.provider_id, p.name as provider_name, l.app_type, l.model,
+                    l.request_model, l.cost_multiplier,
                     l.input_tokens, l.output_tokens, l.cache_read_tokens, l.cache_creation_tokens,
                     l.input_cost_usd, l.output_cost_usd, l.cache_read_cost_usd, l.cache_creation_cost_usd, l.total_cost_usd,
                     l.is_streaming, l.latency_ms, l.first_token_ms, l.duration_ms,
@@ -460,22 +464,26 @@ impl Database {
                 provider_name: row.get(2)?,
                 app_type: row.get(3)?,
                 model: row.get(4)?,
-                input_tokens: row.get::<_, i64>(5)? as u32,
-                output_tokens: row.get::<_, i64>(6)? as u32,
-                cache_read_tokens: row.get::<_, i64>(7)? as u32,
-                cache_creation_tokens: row.get::<_, i64>(8)? as u32,
-                input_cost_usd: row.get(9)?,
-                output_cost_usd: row.get(10)?,
-                cache_read_cost_usd: row.get(11)?,
-                cache_creation_cost_usd: row.get(12)?,
-                total_cost_usd: row.get(13)?,
-                is_streaming: row.get::<_, i64>(14)? != 0,
-                latency_ms: row.get::<_, i64>(15)? as u64,
-                first_token_ms: row.get::<_, Option<i64>>(16)?.map(|v| v as u64),
-                duration_ms: row.get::<_, Option<i64>>(17)?.map(|v| v as u64),
-                status_code: row.get::<_, i64>(18)? as u16,
-                error_message: row.get(19)?,
-                created_at: row.get(20)?,
+                request_model: row.get(5)?,
+                cost_multiplier: row
+                    .get::<_, Option<String>>(6)?
+                    .unwrap_or_else(|| "1".to_string()),
+                input_tokens: row.get::<_, i64>(7)? as u32,
+                output_tokens: row.get::<_, i64>(8)? as u32,
+                cache_read_tokens: row.get::<_, i64>(9)? as u32,
+                cache_creation_tokens: row.get::<_, i64>(10)? as u32,
+                input_cost_usd: row.get(11)?,
+                output_cost_usd: row.get(12)?,
+                cache_read_cost_usd: row.get(13)?,
+                cache_creation_cost_usd: row.get(14)?,
+                total_cost_usd: row.get(15)?,
+                is_streaming: row.get::<_, i64>(16)? != 0,
+                latency_ms: row.get::<_, i64>(17)? as u64,
+                first_token_ms: row.get::<_, Option<i64>>(18)?.map(|v| v as u64),
+                duration_ms: row.get::<_, Option<i64>>(19)?.map(|v| v as u64),
+                status_code: row.get::<_, i64>(20)? as u16,
+                error_message: row.get(21)?,
+                created_at: row.get(22)?,
             })
         })?;
 
@@ -511,6 +519,7 @@ impl Database {
 
         let result = conn.query_row(
             "SELECT l.request_id, l.provider_id, p.name as provider_name, l.app_type, l.model,
+                    l.request_model, l.cost_multiplier,
                     input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens,
                     input_cost_usd, output_cost_usd, cache_read_cost_usd, cache_creation_cost_usd, total_cost_usd,
                     is_streaming, latency_ms, first_token_ms, duration_ms,
@@ -526,22 +535,24 @@ impl Database {
                     provider_name: row.get(2)?,
                     app_type: row.get(3)?,
                     model: row.get(4)?,
-                    input_tokens: row.get::<_, i64>(5)? as u32,
-                    output_tokens: row.get::<_, i64>(6)? as u32,
-                    cache_read_tokens: row.get::<_, i64>(7)? as u32,
-                    cache_creation_tokens: row.get::<_, i64>(8)? as u32,
-                    input_cost_usd: row.get(9)?,
-                    output_cost_usd: row.get(10)?,
-                    cache_read_cost_usd: row.get(11)?,
-                    cache_creation_cost_usd: row.get(12)?,
-                    total_cost_usd: row.get(13)?,
-                    is_streaming: row.get::<_, i64>(14)? != 0,
-                    latency_ms: row.get::<_, i64>(15)? as u64,
-                    first_token_ms: row.get::<_, Option<i64>>(16)?.map(|v| v as u64),
-                    duration_ms: row.get::<_, Option<i64>>(17)?.map(|v| v as u64),
-                    status_code: row.get::<_, i64>(18)? as u16,
-                    error_message: row.get(19)?,
-                    created_at: row.get(20)?,
+                    request_model: row.get(5)?,
+                    cost_multiplier: row.get::<_, Option<String>>(6)?.unwrap_or_else(|| "1".to_string()),
+                    input_tokens: row.get::<_, i64>(7)? as u32,
+                    output_tokens: row.get::<_, i64>(8)? as u32,
+                    cache_read_tokens: row.get::<_, i64>(9)? as u32,
+                    cache_creation_tokens: row.get::<_, i64>(10)? as u32,
+                    input_cost_usd: row.get(11)?,
+                    output_cost_usd: row.get(12)?,
+                    cache_read_cost_usd: row.get(13)?,
+                    cache_creation_cost_usd: row.get(14)?,
+                    total_cost_usd: row.get(15)?,
+                    is_streaming: row.get::<_, i64>(16)? != 0,
+                    latency_ms: row.get::<_, i64>(17)? as u64,
+                    first_token_ms: row.get::<_, Option<i64>>(18)?.map(|v| v as u64),
+                    duration_ms: row.get::<_, Option<i64>>(19)?.map(|v| v as u64),
+                    status_code: row.get::<_, i64>(20)? as u16,
+                    error_message: row.get(21)?,
+                    created_at: row.get(22)?,
                 })
             },
         );
@@ -691,21 +702,26 @@ impl Database {
         )?;
 
         let million = rust_decimal::Decimal::from(1_000_000u64);
-        let input_cost = rust_decimal::Decimal::from(log.input_tokens as u64) * pricing.input
-            / million
-            * multiplier;
-        let output_cost = rust_decimal::Decimal::from(log.output_tokens as u64) * pricing.output
-            / million
-            * multiplier;
+
+        // 与 CostCalculator::calculate 保持一致的计算逻辑：
+        // 1. input_cost 需要扣除 cache_read_tokens（避免缓存部分被重复计费）
+        // 2. 各项成本是基础成本（不含倍率）
+        // 3. 倍率只作用于最终总价
+        let billable_input_tokens =
+            (log.input_tokens as u64).saturating_sub(log.cache_read_tokens as u64);
+        let input_cost =
+            rust_decimal::Decimal::from(billable_input_tokens) * pricing.input / million;
+        let output_cost =
+            rust_decimal::Decimal::from(log.output_tokens as u64) * pricing.output / million;
         let cache_read_cost = rust_decimal::Decimal::from(log.cache_read_tokens as u64)
             * pricing.cache_read
-            / million
-            * multiplier;
+            / million;
         let cache_creation_cost = rust_decimal::Decimal::from(log.cache_creation_tokens as u64)
             * pricing.cache_creation
-            / million
-            * multiplier;
-        let total_cost = input_cost + output_cost + cache_read_cost + cache_creation_cost;
+            / million;
+        // 总成本 = 基础成本之和 × 倍率
+        let base_total = input_cost + output_cost + cache_read_cost + cache_creation_cost;
+        let total_cost = base_total * multiplier;
 
         log.input_cost_usd = format!("{input_cost:.6}");
         log.output_cost_usd = format!("{output_cost:.6}");

src-tauri/src/settings.rs

@@ -79,6 +79,9 @@ pub struct AppSettings {
     /// 是否开机自启
     #[serde(default)]
     pub launch_on_startup: bool,
+    /// 静默启动（程序启动时不显示主窗口，仅托盘运行）
+    #[serde(default)]
+    pub silent_startup: bool,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub language: Option<String>,
 
@@ -114,6 +117,14 @@ pub struct AppSettings {
     /// Skill 同步方式：auto（默认，优先 symlink）、symlink、copy
     #[serde(default)]
     pub skill_sync_method: SyncMethod,
+
+    // ===== 终端设置 =====
+    /// 首选终端应用（可选，默认使用系统默认终端）
+    /// - macOS: "terminal" | "iterm2" | "warp" | "alacritty" | "kitty" | "ghostty"
+    /// - Windows: "cmd" | "powershell" | "wt" (Windows Terminal)
+    /// - Linux: "gnome-terminal" | "konsole" | "xfce4-terminal" | "alacritty" | "kitty" | "ghostty"
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub preferred_terminal: Option<String>,
 }
 
 fn default_show_in_tray() -> bool {
@@ -132,6 +143,7 @@ impl Default for AppSettings {
             enable_claude_plugin_integration: false,
             skip_claude_onboarding: false,
             launch_on_startup: false,
+            silent_startup: false,
             language: None,
             visible_apps: None,
             claude_config_dir: None,
@@ -143,6 +155,7 @@ impl Default for AppSettings {
             current_provider_gemini: None,
             current_provider_opencode: None,
             skill_sync_method: SyncMethod::default(),
+            preferred_terminal: None,
         }
     }
 }
@@ -150,7 +163,11 @@ impl Default for AppSettings {
 impl AppSettings {
     fn settings_path() -> Option<PathBuf> {
         // settings.json 保留用于旧版本迁移和无数据库场景
-        dirs::home_dir().map(|h| h.join(".cc-switch").join("settings.json"))
+        Some(
+            crate::config::get_home_dir()
+                .join(".cc-switch")
+                .join("settings.json"),
+        )
     }
 
     fn normalize_paths(&mut self) {
@@ -402,3 +419,17 @@ pub fn get_skill_sync_method() -> SyncMethod {
         })
         .skill_sync_method
 }
+
+// ===== 终端设置管理函数 =====
+
+/// 获取首选终端应用
+pub fn get_preferred_terminal() -> Option<String> {
+    settings_store()
+        .read()
+        .unwrap_or_else(|e| {
+            log::warn!("设置锁已毒化，使用恢复值: {e}");
+            e.into_inner()
+        })
+        .preferred_terminal
+        .clone()
+}

src-tauri/tests/import_export_sync.rs

@@ -971,12 +971,18 @@ fn export_sql_returns_error_for_invalid_path() {
 
     let state = create_test_state().expect("create test state");
 
-    // Try to export to an invalid path (parent directory doesn't exist)
-    let invalid_path = PathBuf::from("/nonexistent/directory/export.sql");
+    // Try to export to an invalid path (nonexistent parent or invalid name on Windows)
+    let invalid_parent = if cfg!(windows) {
+        std::env::temp_dir().join("cc-switch-test-invalid<>dir")
+    } else {
+        PathBuf::from("/nonexistent/directory")
+    };
+    let invalid_path = invalid_parent.join("export.sql");
     let err = state
         .db
         .export_sql(&invalid_path)
         .expect_err("export to invalid path should fail");
+    let invalid_prefix = invalid_parent.to_string_lossy();
 
     // The error can be either IoContext or Io depending on where it fails
     match err {
@@ -988,8 +994,8 @@ fn export_sql_returns_error_for_invalid_path() {
         }
         AppError::Io { path, .. } => {
             assert!(
-                path.starts_with("/nonexistent"),
-                "expected error for /nonexistent path, got: {path:?}"
+                path.starts_with(invalid_prefix.as_ref()),
+                "expected error for {invalid_parent:?}, got: {path:?}"
             );
         }
         other => panic!("expected IoContext or Io error, got {other:?}"),

src-tauri/tests/proxy_commands.rs

@@ -0,0 +1,78 @@
+use cc_switch_lib::{
+    get_default_cost_multiplier_test_hook, get_pricing_model_source_test_hook,
+    set_default_cost_multiplier_test_hook, set_pricing_model_source_test_hook, AppError,
+};
+
+#[path = "support.rs"]
+mod support;
+use support::{create_test_state, ensure_test_home, reset_test_fs, test_mutex};
+
+// 测试使用 Mutex 进行串行化，跨 await 持锁是预期行为
+#[allow(clippy::await_holding_lock)]
+#[tokio::test]
+async fn default_cost_multiplier_commands_round_trip() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let _home = ensure_test_home();
+
+    let state = create_test_state().expect("create test state");
+
+    let default = get_default_cost_multiplier_test_hook(&state, "claude")
+        .await
+        .expect("read default multiplier");
+    assert_eq!(default, "1");
+
+    set_default_cost_multiplier_test_hook(&state, "claude", "1.5")
+        .await
+        .expect("set multiplier");
+    let updated = get_default_cost_multiplier_test_hook(&state, "claude")
+        .await
+        .expect("read updated multiplier");
+    assert_eq!(updated, "1.5");
+
+    let err = set_default_cost_multiplier_test_hook(&state, "claude", "not-a-number")
+        .await
+        .expect_err("invalid multiplier should error");
+    // 错误已改为 Localized 类型（支持 i18n）
+    match err {
+        AppError::Localized { key, .. } => {
+            assert_eq!(key, "error.invalidMultiplier");
+        }
+        other => panic!("expected localized error, got {other:?}"),
+    }
+}
+
+// 测试使用 Mutex 进行串行化，跨 await 持锁是预期行为
+#[allow(clippy::await_holding_lock)]
+#[tokio::test]
+async fn pricing_model_source_commands_round_trip() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let _home = ensure_test_home();
+
+    let state = create_test_state().expect("create test state");
+
+    let default = get_pricing_model_source_test_hook(&state, "claude")
+        .await
+        .expect("read default pricing model source");
+    assert_eq!(default, "response");
+
+    set_pricing_model_source_test_hook(&state, "claude", "request")
+        .await
+        .expect("set pricing model source");
+    let updated = get_pricing_model_source_test_hook(&state, "claude")
+        .await
+        .expect("read updated pricing model source");
+    assert_eq!(updated, "request");
+
+    let err = set_pricing_model_source_test_hook(&state, "claude", "invalid")
+        .await
+        .expect_err("invalid pricing model source should error");
+    // 错误已改为 Localized 类型（支持 i18n）
+    match err {
+        AppError::Localized { key, .. } => {
+            assert_eq!(key, "error.invalidPricingMode");
+        }
+        other => panic!("expected localized error, got {other:?}"),
+    }
+}

src/App.tsx

@@ -750,13 +750,6 @@ function App() {
                   >
                     CC Switch
                   </a>
-                  <UpdateBadge
-                    onClick={() => {
-                      setSettingsDefaultTab("about");
-                      setCurrentView("settings");
-                    }}
-                    className="absolute -top-4 -right-4"
-                  />
                 </div>
                 <Button
                   variant="ghost"
@@ -770,6 +763,12 @@ function App() {
                 >
                   <Settings className="w-4 h-4" />
                 </Button>
+                <UpdateBadge
+                  onClick={() => {
+                    setSettingsDefaultTab("about");
+                    setCurrentView("settings");
+                  }}
+                />
                 {isCurrentAppTakeoverActive && (
                   <Button
                     variant="ghost"

src/components/UpdateBadge.tsx

@@ -1,6 +1,7 @@
 import { useUpdate } from "@/contexts/UpdateContext";
 import { useTranslation } from "react-i18next";
 import { Button } from "@/components/ui/button";
+import { ArrowUpCircle } from "lucide-react";
 
 interface UpdateBadgeProps {
   className?: string;
@@ -30,17 +31,12 @@ export function UpdateBadge({ className = "", onClick }: UpdateBadgeProps) {
       aria-label={title}
       onClick={onClick}
       className={`
-        relative h-6 w-6 rounded-full
-        ${isActive ? "text-blue-600 dark:text-blue-300 hover:bg-blue-50 dark:hover:bg-blue-500/10" : "text-muted-foreground hover:bg-muted/60"}
+        relative h-8 w-8 rounded-full
+        ${isActive ? "text-green-600 dark:text-green-400 hover:bg-green-50 dark:hover:bg-green-500/10" : "text-muted-foreground hover:bg-muted/60"}
         ${className}
       `}
     >
-      <span
-        className={`
-          absolute inset-0 m-auto h-2 w-2 rounded-full ring-1 ring-background
-          ${isActive ? "bg-blue-500 dark:bg-blue-400" : "bg-blue-300/70 dark:bg-blue-300/60"}
-        `}
-      />
+      <ArrowUpCircle className="h-5 w-5" />
     </Button>
   );
 }

src/components/providers/forms/ProviderAdvancedConfig.tsx

@@ -5,6 +5,7 @@ import {
   ChevronRight,
   FlaskConical,
   Globe,
+  Coins,
   Eye,
   EyeOff,
   X,
@@ -13,14 +14,31 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Switch } from "@/components/ui/switch";
 import { Button } from "@/components/ui/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
 import { cn } from "@/lib/utils";
 import type { ProviderTestConfig, ProviderProxyConfig } from "@/types";
 
+export type PricingModelSourceOption = "inherit" | "request" | "response";
+
+interface ProviderPricingConfig {
+  enabled: boolean;
+  costMultiplier?: string;
+  pricingModelSource: PricingModelSourceOption;
+}
+
 interface ProviderAdvancedConfigProps {
   testConfig: ProviderTestConfig;
   proxyConfig: ProviderProxyConfig;
+  pricingConfig: ProviderPricingConfig;
   onTestConfigChange: (config: ProviderTestConfig) => void;
   onProxyConfigChange: (config: ProviderProxyConfig) => void;
+  onPricingConfigChange: (config: ProviderPricingConfig) => void;
 }
 
 /** 从 ProviderProxyConfig 构建完整 URL */
@@ -71,14 +89,19 @@ function parseProxyUrl(url: string): Partial<ProviderProxyConfig> {
 export function ProviderAdvancedConfig({
   testConfig,
   proxyConfig,
+  pricingConfig,
   onTestConfigChange,
   onProxyConfigChange,
+  onPricingConfigChange,
 }: ProviderAdvancedConfigProps) {
   const { t } = useTranslation();
   const [isTestConfigOpen, setIsTestConfigOpen] = useState(testConfig.enabled);
   const [isProxyConfigOpen, setIsProxyConfigOpen] = useState(
     proxyConfig.enabled,
   );
+  const [isPricingConfigOpen, setIsPricingConfigOpen] = useState(
+    pricingConfig.enabled,
+  );
   const [showPassword, setShowPassword] = useState(false);
 
   // 代理 URL 输入状态（仅在初始化时从 proxyConfig 构建）
@@ -97,6 +120,11 @@ export function ProviderAdvancedConfig({
     setIsProxyConfigOpen(proxyConfig.enabled);
   }, [proxyConfig.enabled]);
 
+  // 同步外部 pricingConfig.enabled 变化到展开状态
+  useEffect(() => {
+    setIsPricingConfigOpen(pricingConfig.enabled);
+  }, [pricingConfig.enabled]);
+
   // 仅在外部 proxyConfig 变化且非用户输入时同步（如：重置表单、加载数据）
   useEffect(() => {
     if (!isUserTyping) {
@@ -450,6 +478,143 @@ export function ProviderAdvancedConfig({
           </div>
         </div>
       </div>
+
+      {/* 计费配置 */}
+      <div className="rounded-lg border border-border/50 bg-muted/20">
+        <button
+          type="button"
+          className="flex w-full items-center justify-between p-4 hover:bg-muted/30 transition-colors"
+          onClick={() => setIsPricingConfigOpen(!isPricingConfigOpen)}
+        >
+          <div className="flex items-center gap-3">
+            <Coins className="h-4 w-4 text-muted-foreground" />
+            <span className="font-medium">
+              {t("providerAdvanced.pricingConfig", {
+                defaultValue: "计费配置",
+              })}
+            </span>
+          </div>
+          <div className="flex items-center gap-3">
+            <div
+              className="flex items-center gap-2"
+              onClick={(e) => e.stopPropagation()}
+            >
+              <Label
+                htmlFor="pricing-config-enabled"
+                className="text-sm text-muted-foreground"
+              >
+                {t("providerAdvanced.useCustomPricing", {
+                  defaultValue: "使用单独配置",
+                })}
+              </Label>
+              <Switch
+                id="pricing-config-enabled"
+                checked={pricingConfig.enabled}
+                onCheckedChange={(checked) => {
+                  onPricingConfigChange({ ...pricingConfig, enabled: checked });
+                  if (checked) setIsPricingConfigOpen(true);
+                }}
+              />
+            </div>
+            {isPricingConfigOpen ? (
+              <ChevronDown className="h-4 w-4 text-muted-foreground" />
+            ) : (
+              <ChevronRight className="h-4 w-4 text-muted-foreground" />
+            )}
+          </div>
+        </button>
+        <div
+          className={cn(
+            "overflow-hidden transition-all duration-200",
+            isPricingConfigOpen
+              ? "max-h-[500px] opacity-100"
+              : "max-h-0 opacity-0",
+          )}
+        >
+          <div className="border-t border-border/50 p-4 space-y-4">
+            <p className="text-sm text-muted-foreground">
+              {t("providerAdvanced.pricingConfigDesc", {
+                defaultValue:
+                  "为此供应商配置单独的计费参数，不启用时使用全局默认配置。",
+              })}
+            </p>
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div className="space-y-2">
+                <Label htmlFor="cost-multiplier">
+                  {t("providerAdvanced.costMultiplier", {
+                    defaultValue: "成本倍率",
+                  })}
+                </Label>
+                <Input
+                  id="cost-multiplier"
+                  type="number"
+                  step="0.01"
+                  inputMode="decimal"
+                  value={pricingConfig.costMultiplier || ""}
+                  onChange={(e) =>
+                    onPricingConfigChange({
+                      ...pricingConfig,
+                      costMultiplier: e.target.value || undefined,
+                    })
+                  }
+                  placeholder={t("providerAdvanced.costMultiplierPlaceholder", {
+                    defaultValue: "留空使用全局默认（1）",
+                  })}
+                  disabled={!pricingConfig.enabled}
+                />
+                <p className="text-xs text-muted-foreground">
+                  {t("providerAdvanced.costMultiplierHint", {
+                    defaultValue: "实际成本 = 基础成本 × 倍率，支持小数如 1.5",
+                  })}
+                </p>
+              </div>
+              <div className="space-y-2">
+                <Label htmlFor="pricing-model-source">
+                  {t("providerAdvanced.pricingModelSourceLabel", {
+                    defaultValue: "计费模式",
+                  })}
+                </Label>
+                <Select
+                  value={pricingConfig.pricingModelSource}
+                  onValueChange={(value) =>
+                    onPricingConfigChange({
+                      ...pricingConfig,
+                      pricingModelSource: value as PricingModelSourceOption,
+                    })
+                  }
+                  disabled={!pricingConfig.enabled}
+                >
+                  <SelectTrigger id="pricing-model-source">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="inherit">
+                      {t("providerAdvanced.pricingModelSourceInherit", {
+                        defaultValue: "继承全局默认",
+                      })}
+                    </SelectItem>
+                    <SelectItem value="request">
+                      {t("providerAdvanced.pricingModelSourceRequest", {
+                        defaultValue: "请求模型",
+                      })}
+                    </SelectItem>
+                    <SelectItem value="response">
+                      {t("providerAdvanced.pricingModelSourceResponse", {
+                        defaultValue: "返回模型",
+                      })}
+                    </SelectItem>
+                  </SelectContent>
+                </Select>
+                <p className="text-xs text-muted-foreground">
+                  {t("providerAdvanced.pricingModelSourceHint", {
+                    defaultValue: "选择按请求模型还是返回模型进行定价匹配",
+                  })}
+                </p>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
     </div>
   );
 }

src/components/providers/forms/ProviderForm.tsx

@@ -46,7 +46,10 @@ import { BasicFormFields } from "./BasicFormFields";
 import { ClaudeFormFields } from "./ClaudeFormFields";
 import { CodexFormFields } from "./CodexFormFields";
 import { GeminiFormFields } from "./GeminiFormFields";
-import { ProviderAdvancedConfig } from "./ProviderAdvancedConfig";
+import {
+  ProviderAdvancedConfig,
+  type PricingModelSourceOption,
+} from "./ProviderAdvancedConfig";
 import {
   useProviderCategory,
   useApiKeyState,
@@ -121,6 +124,9 @@ interface ProviderFormProps {
   showButtons?: boolean;
 }
 
+const normalizePricingSource = (value?: string): PricingModelSourceOption =>
+  value === "request" || value === "response" ? value : "inherit";
+
 export function ProviderForm({
   appId,
   providerId,
@@ -168,6 +174,19 @@ export function ProviderForm({
   const [proxyConfig, setProxyConfig] = useState<ProviderProxyConfig>(
     () => initialData?.meta?.proxyConfig ?? { enabled: false },
   );
+  const [pricingConfig, setPricingConfig] = useState<{
+    enabled: boolean;
+    costMultiplier?: string;
+    pricingModelSource: PricingModelSourceOption;
+  }>(() => ({
+    enabled:
+      initialData?.meta?.costMultiplier !== undefined ||
+      initialData?.meta?.pricingModelSource !== undefined,
+    costMultiplier: initialData?.meta?.costMultiplier,
+    pricingModelSource: normalizePricingSource(
+      initialData?.meta?.pricingModelSource,
+    ),
+  }));
 
   // 使用 category hook
   const { category } = useProviderCategory({
@@ -188,6 +207,15 @@ export function ProviderForm({
     setEndpointAutoSelect(initialData?.meta?.endpointAutoSelect ?? true);
     setTestConfig(initialData?.meta?.testConfig ?? { enabled: false });
     setProxyConfig(initialData?.meta?.proxyConfig ?? { enabled: false });
+    setPricingConfig({
+      enabled:
+        initialData?.meta?.costMultiplier !== undefined ||
+        initialData?.meta?.pricingModelSource !== undefined,
+      costMultiplier: initialData?.meta?.costMultiplier,
+      pricingModelSource: normalizePricingSource(
+        initialData?.meta?.pricingModelSource,
+      ),
+    });
   }, [appId, initialData]);
 
   const defaultValues: ProviderFormData = useMemo(
@@ -940,6 +968,13 @@ export function ProviderForm({
       // 添加高级配置
       testConfig: testConfig.enabled ? testConfig : undefined,
       proxyConfig: proxyConfig.enabled ? proxyConfig : undefined,
+      costMultiplier: pricingConfig.enabled
+        ? pricingConfig.costMultiplier
+        : undefined,
+      pricingModelSource:
+        pricingConfig.enabled && pricingConfig.pricingModelSource !== "inherit"
+          ? pricingConfig.pricingModelSource
+          : undefined,
     };
 
     onSubmit(payload);
@@ -1464,8 +1499,10 @@ export function ProviderForm({
         <ProviderAdvancedConfig
           testConfig={testConfig}
           proxyConfig={proxyConfig}
+          pricingConfig={pricingConfig}
           onTestConfigChange={setTestConfig}
           onProxyConfigChange={setProxyConfig}
+          onPricingConfigChange={setPricingConfig}
         />
 
         {showButtons && (

src/components/settings/DirectorySettings.tsx

@@ -15,6 +15,7 @@ interface DirectorySettingsProps {
   claudeDir?: string;
   codexDir?: string;
   geminiDir?: string;
+  opencodeDir?: string;
   onDirectoryChange: (app: AppId, value?: string) => void;
   onBrowseDirectory: (app: AppId) => Promise<void>;
   onResetDirectory: (app: AppId) => Promise<void>;
@@ -29,6 +30,7 @@ export function DirectorySettings({
   claudeDir,
   codexDir,
   geminiDir,
+  opencodeDir,
   onDirectoryChange,
   onBrowseDirectory,
   onResetDirectory,
@@ -117,6 +119,17 @@ export function DirectorySettings({
           onBrowse={() => onBrowseDirectory("gemini")}
           onReset={() => onResetDirectory("gemini")}
         />
+
+        <DirectoryInput
+          label={t("settings.opencodeConfigDir")}
+          description={undefined}
+          value={opencodeDir}
+          resolvedValue={resolvedDirs.opencode}
+          placeholder={t("settings.browsePlaceholderOpencode")}
+          onChange={(val) => onDirectoryChange("opencode", val)}
+          onBrowse={() => onBrowseDirectory("opencode")}
+          onReset={() => onResetDirectory("opencode")}
+        />
       </section>
     </>
   );

src/components/settings/SettingsPage.tsx

@@ -36,6 +36,7 @@ import { ThemeSettings } from "@/components/settings/ThemeSettings";
 import { WindowSettings } from "@/components/settings/WindowSettings";
 import { AppVisibilitySettings } from "@/components/settings/AppVisibilitySettings";
 import { SkillSyncMethodSettings } from "@/components/settings/SkillSyncMethodSettings";
+import { TerminalSettings } from "@/components/settings/TerminalSettings";
 import { DirectorySettings } from "@/components/settings/DirectorySettings";
 import { ImportExportSection } from "@/components/settings/ImportExportSection";
 import { AboutSection } from "@/components/settings/AboutSection";
@@ -256,6 +257,12 @@ export function SettingsPage({
                       handleAutoSave({ skillSyncMethod: method })
                     }
                   />
+                  <TerminalSettings
+                    value={settings.preferredTerminal}
+                    onChange={(terminal) =>
+                      handleAutoSave({ preferredTerminal: terminal })
+                    }
+                  />
                 </motion.div>
               ) : null}
             </TabsContent>
@@ -300,6 +307,7 @@ export function SettingsPage({
                           claudeDir={settings.claudeConfigDir}
                           codexDir={settings.codexConfigDir}
                           geminiDir={settings.geminiConfigDir}
+                          opencodeDir={settings.opencodeConfigDir}
                           onDirectoryChange={updateDirectory}
                           onBrowseDirectory={browseDirectory}
                           onResetDirectory={resetDirectory}

src/components/settings/TerminalSettings.tsx

@@ -0,0 +1,111 @@
+import { useTranslation } from "react-i18next";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { isMac, isWindows, isLinux } from "@/lib/platform";
+
+// Terminal options per platform
+const MACOS_TERMINALS = [
+  { value: "terminal", labelKey: "settings.terminal.options.macos.terminal" },
+  { value: "iterm2", labelKey: "settings.terminal.options.macos.iterm2" },
+  { value: "alacritty", labelKey: "settings.terminal.options.macos.alacritty" },
+  { value: "kitty", labelKey: "settings.terminal.options.macos.kitty" },
+  { value: "ghostty", labelKey: "settings.terminal.options.macos.ghostty" },
+] as const;
+
+const WINDOWS_TERMINALS = [
+  { value: "cmd", labelKey: "settings.terminal.options.windows.cmd" },
+  {
+    value: "powershell",
+    labelKey: "settings.terminal.options.windows.powershell",
+  },
+  { value: "wt", labelKey: "settings.terminal.options.windows.wt" },
+] as const;
+
+const LINUX_TERMINALS = [
+  {
+    value: "gnome-terminal",
+    labelKey: "settings.terminal.options.linux.gnomeTerminal",
+  },
+  { value: "konsole", labelKey: "settings.terminal.options.linux.konsole" },
+  {
+    value: "xfce4-terminal",
+    labelKey: "settings.terminal.options.linux.xfce4Terminal",
+  },
+  { value: "alacritty", labelKey: "settings.terminal.options.linux.alacritty" },
+  { value: "kitty", labelKey: "settings.terminal.options.linux.kitty" },
+  { value: "ghostty", labelKey: "settings.terminal.options.linux.ghostty" },
+] as const;
+
+// Get terminals for the current platform
+function getTerminalOptions() {
+  if (isMac()) {
+    return MACOS_TERMINALS;
+  }
+  if (isWindows()) {
+    return WINDOWS_TERMINALS;
+  }
+  if (isLinux()) {
+    return LINUX_TERMINALS;
+  }
+  // Fallback to macOS options
+  return MACOS_TERMINALS;
+}
+
+// Get default terminal for the current platform
+function getDefaultTerminal(): string {
+  if (isMac()) {
+    return "terminal";
+  }
+  if (isWindows()) {
+    return "cmd";
+  }
+  if (isLinux()) {
+    return "gnome-terminal";
+  }
+  return "terminal";
+}
+
+export interface TerminalSettingsProps {
+  value?: string;
+  onChange: (value: string) => void;
+}
+
+export function TerminalSettings({ value, onChange }: TerminalSettingsProps) {
+  const { t } = useTranslation();
+  const terminals = getTerminalOptions();
+  const defaultTerminal = getDefaultTerminal();
+
+  // Use value or default
+  const currentValue = value || defaultTerminal;
+
+  return (
+    <section className="space-y-2">
+      <header className="space-y-1">
+        <h3 className="text-sm font-medium">{t("settings.terminal.title")}</h3>
+        <p className="text-xs text-muted-foreground">
+          {t("settings.terminal.description")}
+        </p>
+      </header>
+      <Select value={currentValue} onValueChange={onChange}>
+        <SelectTrigger className="w-[200px]">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {terminals.map((terminal) => (
+            <SelectItem key={terminal.value} value={terminal.value}>
+              {t(terminal.labelKey)}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+      <p className="text-xs text-muted-foreground">
+        {t("settings.terminal.fallbackHint")}
+      </p>
+    </section>
+  );
+}

src/components/settings/WindowSettings.tsx

@@ -1,6 +1,6 @@
 import { useTranslation } from "react-i18next";
 import type { SettingsFormState } from "@/hooks/useSettings";
-import { AppWindow, MonitorUp, Power } from "lucide-react";
+import { AppWindow, MonitorUp, Power, EyeOff } from "lucide-react";
 import { ToggleRow } from "@/components/ui/toggle-row";
 
 interface WindowSettingsProps {
@@ -27,6 +27,14 @@ export function WindowSettings({ settings, onChange }: WindowSettingsProps) {
           onCheckedChange={(value) => onChange({ launchOnStartup: value })}
         />
 
+        <ToggleRow
+          icon={<EyeOff className="h-4 w-4 text-green-500" />}
+          title={t("settings.silentStartup")}
+          description={t("settings.silentStartupDescription")}
+          checked={!!settings.silentStartup}
+          onCheckedChange={(value) => onChange({ silentStartup: value })}
+        />
+
         <ToggleRow
           icon={<MonitorUp className="h-4 w-4 text-purple-500" />}
           title={t("settings.enableClaudePluginIntegration")}

src/components/skills/SkillsPage.tsx

@@ -65,10 +65,17 @@ export const SkillsPage = forwardRef<SkillsPageHandle, SkillsPageProps>(
     const addRepoMutation = useAddSkillRepo();
     const removeRepoMutation = useRemoveSkillRepo();
 
-    // 已安装的 directory 集合
-    const installedDirs = useMemo(() => {
+    // 已安装的 skill key 集合（使用 directory + repoOwner + repoName 组合判断）
+    const installedKeys = useMemo(() => {
       if (!installedSkills) return new Set<string>();
-      return new Set(installedSkills.map((s) => s.directory.toLowerCase()));
+      return new Set(
+        installedSkills.map((s) => {
+          // 构建唯一 key：directory + repoOwner + repoName
+          const owner = s.repoOwner?.toLowerCase() || "";
+          const name = s.repoName?.toLowerCase() || "";
+          return `${s.directory.toLowerCase()}:${owner}:${name}`;
+        }),
+      );
     }, [installedSkills]);
 
     type DiscoverableSkillItem = DiscoverableSkill & { installed: boolean };
@@ -80,12 +87,14 @@ export const SkillsPage = forwardRef<SkillsPageHandle, SkillsPageProps>(
         const installName =
           d.directory.split("/").pop()?.toLowerCase() ||
           d.directory.toLowerCase();
+        // 使用 directory + repoOwner + repoName 组合判断是否已安装
+        const key = `${installName}:${d.repoOwner.toLowerCase()}:${d.repoName.toLowerCase()}`;
         return {
           ...d,
-          installed: installedDirs.has(installName),
+          installed: installedKeys.has(key),
         };
       });
-    }, [discoverableSkills, installedDirs]);
+    }, [discoverableSkills, installedKeys]);
 
     const loading = loadingDiscoverable || fetchingDiscoverable;
 

src/components/usage/PricingConfigPanel.tsx

@@ -1,6 +1,5 @@
-import { useState } from "react";
+import { useState, useEffect } from "react";
 import { useTranslation } from "react-i18next";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import {
   Table,
   TableBody,
@@ -19,10 +18,31 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
 import { useModelPricing, useDeleteModelPricing } from "@/lib/query/usage";
 import { PricingEditModal } from "./PricingEditModal";
 import type { ModelPricing } from "@/types/usage";
-import { Plus, Pencil, Trash2, ChevronDown, ChevronRight } from "lucide-react";
+import { Plus, Pencil, Trash2, Loader2 } from "lucide-react";
+import { toast } from "sonner";
+import { proxyApi } from "@/lib/api/proxy";
+
+const PRICING_APPS = ["claude", "codex", "gemini"] as const;
+type PricingApp = (typeof PRICING_APPS)[number];
+type PricingModelSource = "request" | "response";
+
+interface AppConfig {
+  multiplier: string;
+  source: PricingModelSource;
+}
+
+type AppConfigState = Record<PricingApp, AppConfig>;
 
 export function PricingConfigPanel() {
   const { t } = useTranslation();
@@ -31,13 +51,137 @@ export function PricingConfigPanel() {
   const [editingModel, setEditingModel] = useState<ModelPricing | null>(null);
   const [isAddingNew, setIsAddingNew] = useState(false);
   const [deleteConfirm, setDeleteConfirm] = useState<string | null>(null);
-  const [isExpanded, setIsExpanded] = useState(false);
+
+  // 三个应用的配置状态
+  const [appConfigs, setAppConfigs] = useState<AppConfigState>({
+    claude: { multiplier: "1", source: "response" },
+    codex: { multiplier: "1", source: "response" },
+    gemini: { multiplier: "1", source: "response" },
+  });
+  const [originalConfigs, setOriginalConfigs] = useState<AppConfigState | null>(
+    null,
+  );
+  const [isConfigLoading, setIsConfigLoading] = useState(true);
+  const [isSaving, setIsSaving] = useState(false);
+
+  // 检查是否有改动
+  const isDirty =
+    originalConfigs !== null &&
+    PRICING_APPS.some(
+      (app) =>
+        appConfigs[app].multiplier !== originalConfigs[app].multiplier ||
+        appConfigs[app].source !== originalConfigs[app].source,
+    );
+
+  // 加载所有应用的配置
+  useEffect(() => {
+    let isMounted = true;
+
+    const loadAllConfigs = async () => {
+      setIsConfigLoading(true);
+      try {
+        const results = await Promise.all(
+          PRICING_APPS.map(async (app) => {
+            const [multiplier, source] = await Promise.all([
+              proxyApi.getDefaultCostMultiplier(app),
+              proxyApi.getPricingModelSource(app),
+            ]);
+            return {
+              app,
+              multiplier,
+              source: (source === "request"
+                ? "request"
+                : "response") as PricingModelSource,
+            };
+          }),
+        );
+
+        if (!isMounted) return;
+
+        const newState: AppConfigState = {
+          claude: { multiplier: "1", source: "response" },
+          codex: { multiplier: "1", source: "response" },
+          gemini: { multiplier: "1", source: "response" },
+        };
+        for (const result of results) {
+          newState[result.app] = {
+            multiplier: result.multiplier,
+            source: result.source,
+          };
+        }
+        setAppConfigs(newState);
+        setOriginalConfigs(newState);
+      } catch (error) {
+        const message =
+          error instanceof Error
+            ? error.message
+            : typeof error === "string"
+              ? error
+              : "Unknown error";
+        toast.error(
+          t("settings.globalProxy.pricingLoadFailed", { error: message }),
+        );
+      } finally {
+        if (isMounted) setIsConfigLoading(false);
+      }
+    };
+
+    loadAllConfigs();
+    return () => {
+      isMounted = false;
+    };
+  }, [t]);
+
+  // 保存所有配置
+  const handleSaveAll = async () => {
+    // 验证所有倍率
+    for (const app of PRICING_APPS) {
+      const trimmed = appConfigs[app].multiplier.trim();
+      if (!trimmed) {
+        toast.error(
+          `${t(`apps.${app}`)}: ${t("settings.globalProxy.defaultCostMultiplierRequired")}`,
+        );
+        return;
+      }
+      if (!/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+        toast.error(
+          `${t(`apps.${app}`)}: ${t("settings.globalProxy.defaultCostMultiplierInvalid")}`,
+        );
+        return;
+      }
+    }
+
+    setIsSaving(true);
+    try {
+      await Promise.all(
+        PRICING_APPS.flatMap((app) => [
+          proxyApi.setDefaultCostMultiplier(
+            app,
+            appConfigs[app].multiplier.trim(),
+          ),
+          proxyApi.setPricingModelSource(app, appConfigs[app].source),
+        ]),
+      );
+      toast.success(t("settings.globalProxy.pricingSaved"));
+      setOriginalConfigs({ ...appConfigs });
+    } catch (error) {
+      const message =
+        error instanceof Error
+          ? error.message
+          : typeof error === "string"
+            ? error
+            : "Unknown error";
+      toast.error(
+        t("settings.globalProxy.pricingSaveFailed", { error: message }),
+      );
+    } finally {
+      setIsSaving(false);
+    }
+  };
 
   const handleDelete = (modelId: string) => {
     deleteMutation.mutate(modelId, {
-      onSuccess: () => {
-        setDeleteConfirm(null);
-      },
+      onSuccess: () => setDeleteConfirm(null),
     });
   };
 
@@ -55,151 +199,242 @@ export function PricingConfigPanel() {
 
   if (isLoading) {
     return (
-      <Card className="border rounded-lg">
-        <CardHeader
-          className="cursor-pointer"
-          onClick={() => setIsExpanded(!isExpanded)}
-        >
-          <div className="flex items-center gap-2">
-            <ChevronRight className="h-4 w-4" />
-            <CardTitle className="text-base">
-              {t("usage.modelPricing")}
-            </CardTitle>
-          </div>
-        </CardHeader>
-      </Card>
+      <div className="flex items-center justify-center p-4">
+        <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+      </div>
     );
   }
 
   if (error) {
     return (
-      <Card className="border rounded-lg">
-        <CardHeader
-          className="cursor-pointer"
-          onClick={() => setIsExpanded(!isExpanded)}
-        >
-          <div className="flex items-center gap-2">
-            {isExpanded ? (
-              <ChevronDown className="h-4 w-4" />
-            ) : (
-              <ChevronRight className="h-4 w-4" />
-            )}
-            <CardTitle className="text-base">
-              {t("usage.modelPricing")}
-            </CardTitle>
-          </div>
-        </CardHeader>
-        {isExpanded && (
-          <CardContent>
-            <Alert variant="destructive">
-              <AlertDescription>
-                {t("usage.loadPricingError")}: {String(error)}
-              </AlertDescription>
-            </Alert>
-          </CardContent>
-        )}
-      </Card>
+      <Alert variant="destructive">
+        <AlertDescription>
+          {t("usage.loadPricingError")}: {String(error)}
+        </AlertDescription>
+      </Alert>
     );
   }
 
   return (
-    <div className="space-y-4">
-      <div className="flex items-center justify-between mb-4">
-        <h4 className="text-sm font-medium text-muted-foreground">
-          {t("usage.modelPricingDesc")} {t("usage.perMillion")}
-        </h4>
-        <Button
-          onClick={(e) => {
-            e.stopPropagation();
-            handleAddNew();
-          }}
-          size="sm"
-        >
-          <Plus className="mr-1 h-4 w-4" />
-          {t("common.add")}
-        </Button>
-      </div>
+    <div className="space-y-6">
+      {/* 全局计费默认配置 - 紧凑表格布局 */}
+      <div className="space-y-2">
+        <div className="flex items-center justify-between">
+          <div>
+            <h4 className="text-sm font-medium">
+              {t("settings.globalProxy.pricingDefaultsTitle")}
+            </h4>
+            <p className="text-xs text-muted-foreground">
+              {t("settings.globalProxy.pricingDefaultsDescription")}
+            </p>
+          </div>
+          <Button
+            onClick={handleSaveAll}
+            disabled={isConfigLoading || isSaving || !isDirty}
+            size="sm"
+          >
+            {isSaving ? (
+              <>
+                <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" />
+                {t("common.saving")}
+              </>
+            ) : (
+              t("common.save")
+            )}
+          </Button>
+        </div>
 
-      <div className="space-y-4">
-        {!pricing || pricing.length === 0 ? (
-          <Alert>
-            <AlertDescription>{t("usage.noPricingData")}</AlertDescription>
-          </Alert>
+        {isConfigLoading ? (
+          <div className="flex items-center justify-center py-4">
+            <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
+          </div>
         ) : (
-          <div className="rounded-md bg-card/60 shadow-sm">
-            <Table>
-              <TableHeader>
-                <TableRow>
-                  <TableHead>{t("usage.model")}</TableHead>
-                  <TableHead>{t("usage.displayName")}</TableHead>
-                  <TableHead className="text-right">
-                    {t("usage.inputCost")}
-                  </TableHead>
-                  <TableHead className="text-right">
-                    {t("usage.outputCost")}
-                  </TableHead>
-                  <TableHead className="text-right">
-                    {t("usage.cacheReadCost")}
-                  </TableHead>
-                  <TableHead className="text-right">
-                    {t("usage.cacheWriteCost")}
-                  </TableHead>
-                  <TableHead className="text-right">
-                    {t("common.actions")}
-                  </TableHead>
-                </TableRow>
-              </TableHeader>
-              <TableBody>
-                {pricing.map((model) => (
-                  <TableRow key={model.modelId}>
-                    <TableCell className="font-mono text-sm">
-                      {model.modelId}
-                    </TableCell>
-                    <TableCell>{model.displayName}</TableCell>
-                    <TableCell className="text-right font-mono text-sm">
-                      ${model.inputCostPerMillion}
-                    </TableCell>
-                    <TableCell className="text-right font-mono text-sm">
-                      ${model.outputCostPerMillion}
-                    </TableCell>
-                    <TableCell className="text-right font-mono text-sm">
-                      ${model.cacheReadCostPerMillion}
-                    </TableCell>
-                    <TableCell className="text-right font-mono text-sm">
-                      ${model.cacheCreationCostPerMillion}
-                    </TableCell>
-                    <TableCell className="text-right">
-                      <div className="flex justify-end gap-1">
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          onClick={() => {
-                            setIsAddingNew(false);
-                            setEditingModel(model);
-                          }}
-                          title={t("common.edit")}
-                        >
-                          <Pencil className="h-4 w-4" />
-                        </Button>
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          onClick={() => setDeleteConfirm(model.modelId)}
-                          title={t("common.delete")}
-                          className="text-destructive hover:text-destructive"
-                        >
-                          <Trash2 className="h-4 w-4" />
-                        </Button>
-                      </div>
-                    </TableCell>
-                  </TableRow>
+          <div className="rounded-md border border-border/50 overflow-hidden">
+            <table className="w-full text-sm">
+              <thead>
+                <tr className="border-b border-border/50 bg-muted/30">
+                  <th className="px-3 py-2 text-left font-medium text-muted-foreground w-24">
+                    {t("settings.globalProxy.pricingAppLabel")}
+                  </th>
+                  <th className="px-3 py-2 text-left font-medium text-muted-foreground">
+                    {t("settings.globalProxy.defaultCostMultiplierLabel")}
+                  </th>
+                  <th className="px-3 py-2 text-left font-medium text-muted-foreground">
+                    {t("settings.globalProxy.pricingModelSourceLabel")}
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                {PRICING_APPS.map((app, idx) => (
+                  <tr
+                    key={app}
+                    className={
+                      idx < PRICING_APPS.length - 1
+                        ? "border-b border-border/30"
+                        : ""
+                    }
+                  >
+                    <td className="px-3 py-1.5 font-medium">
+                      {t(`apps.${app}`)}
+                    </td>
+                    <td className="px-3 py-1.5">
+                      <Input
+                        type="number"
+                        step="0.01"
+                        inputMode="decimal"
+                        value={appConfigs[app].multiplier}
+                        onChange={(e) =>
+                          setAppConfigs((prev) => ({
+                            ...prev,
+                            [app]: { ...prev[app], multiplier: e.target.value },
+                          }))
+                        }
+                        disabled={isSaving}
+                        placeholder="1"
+                        className="h-7 w-24"
+                      />
+                    </td>
+                    <td className="px-3 py-1.5">
+                      <Select
+                        value={appConfigs[app].source}
+                        onValueChange={(value) =>
+                          setAppConfigs((prev) => ({
+                            ...prev,
+                            [app]: {
+                              ...prev[app],
+                              source: value as PricingModelSource,
+                            },
+                          }))
+                        }
+                        disabled={isSaving}
+                      >
+                        <SelectTrigger className="h-7 w-28">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="response">
+                            {t(
+                              "settings.globalProxy.pricingModelSourceResponse",
+                            )}
+                          </SelectItem>
+                          <SelectItem value="request">
+                            {t(
+                              "settings.globalProxy.pricingModelSourceRequest",
+                            )}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </td>
+                  </tr>
                 ))}
-              </TableBody>
-            </Table>
+              </tbody>
+            </table>
           </div>
         )}
       </div>
 
+      {/* 分隔线 */}
+      <div className="border-t border-border/50" />
+
+      {/* 模型定价配置 */}
+      <div className="space-y-4">
+        <div className="flex items-center justify-between">
+          <h4 className="text-sm font-medium text-muted-foreground">
+            {t("usage.modelPricingDesc")} {t("usage.perMillion")}
+          </h4>
+          <Button
+            onClick={(e) => {
+              e.stopPropagation();
+              handleAddNew();
+            }}
+            size="sm"
+          >
+            <Plus className="mr-1 h-4 w-4" />
+            {t("common.add")}
+          </Button>
+        </div>
+
+        <div className="space-y-4">
+          {!pricing || pricing.length === 0 ? (
+            <Alert>
+              <AlertDescription>{t("usage.noPricingData")}</AlertDescription>
+            </Alert>
+          ) : (
+            <div className="rounded-md bg-card/60 shadow-sm">
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>{t("usage.model")}</TableHead>
+                    <TableHead>{t("usage.displayName")}</TableHead>
+                    <TableHead className="text-right">
+                      {t("usage.inputCost")}
+                    </TableHead>
+                    <TableHead className="text-right">
+                      {t("usage.outputCost")}
+                    </TableHead>
+                    <TableHead className="text-right">
+                      {t("usage.cacheReadCost")}
+                    </TableHead>
+                    <TableHead className="text-right">
+                      {t("usage.cacheWriteCost")}
+                    </TableHead>
+                    <TableHead className="text-right">
+                      {t("common.actions")}
+                    </TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {pricing.map((model) => (
+                    <TableRow key={model.modelId}>
+                      <TableCell className="font-mono text-sm">
+                        {model.modelId}
+                      </TableCell>
+                      <TableCell>{model.displayName}</TableCell>
+                      <TableCell className="text-right font-mono text-sm">
+                        ${model.inputCostPerMillion}
+                      </TableCell>
+                      <TableCell className="text-right font-mono text-sm">
+                        ${model.outputCostPerMillion}
+                      </TableCell>
+                      <TableCell className="text-right font-mono text-sm">
+                        ${model.cacheReadCostPerMillion}
+                      </TableCell>
+                      <TableCell className="text-right font-mono text-sm">
+                        ${model.cacheCreationCostPerMillion}
+                      </TableCell>
+                      <TableCell className="text-right">
+                        <div className="flex justify-end gap-1">
+                          <Button
+                            variant="ghost"
+                            size="icon"
+                            onClick={() => {
+                              setIsAddingNew(false);
+                              setEditingModel(model);
+                            }}
+                            title={t("common.edit")}
+                          >
+                            <Pencil className="h-4 w-4" />
+                          </Button>
+                          <Button
+                            variant="ghost"
+                            size="icon"
+                            onClick={() => setDeleteConfirm(model.modelId)}
+                            title={t("common.delete")}
+                            className="text-destructive hover:text-destructive"
+                          >
+                            <Trash2 className="h-4 w-4" />
+                          </Button>
+                        </div>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+            </div>
+          )}
+        </div>
+      </div>
+
       {editingModel && (
         <PricingEditModal
           open={!!editingModel}

src/components/usage/RequestDetailPanel.tsx

@@ -184,6 +184,9 @@ export function RequestDetailPanel({
               <div>
                 <dt className="text-muted-foreground">
                   {t("usage.inputCost", "输入成本")}
+                  <span className="ml-1 text-xs">
+                    ({t("usage.baseCost", "基础")})
+                  </span>
                 </dt>
                 <dd className="font-mono">
                   ${parseFloat(request.inputCostUsd).toFixed(6)}
@@ -192,6 +195,9 @@ export function RequestDetailPanel({
               <div>
                 <dt className="text-muted-foreground">
                   {t("usage.outputCost", "输出成本")}
+                  <span className="ml-1 text-xs">
+                    ({t("usage.baseCost", "基础")})
+                  </span>
                 </dt>
                 <dd className="font-mono">
                   ${parseFloat(request.outputCostUsd).toFixed(6)}
@@ -200,6 +206,9 @@ export function RequestDetailPanel({
               <div>
                 <dt className="text-muted-foreground">
                   {t("usage.cacheReadCost", "缓存读取成本")}
+                  <span className="ml-1 text-xs">
+                    ({t("usage.baseCost", "基础")})
+                  </span>
                 </dt>
                 <dd className="font-mono">
                   ${parseFloat(request.cacheReadCostUsd).toFixed(6)}
@@ -208,14 +217,35 @@ export function RequestDetailPanel({
               <div>
                 <dt className="text-muted-foreground">
                   {t("usage.cacheCreationCost", "缓存写入成本")}
+                  <span className="ml-1 text-xs">
+                    ({t("usage.baseCost", "基础")})
+                  </span>
                 </dt>
                 <dd className="font-mono">
                   ${parseFloat(request.cacheCreationCostUsd).toFixed(6)}
                 </dd>
               </div>
-              <div className="col-span-2 border-t pt-3">
+              {/* 显示成本倍率（如果不等于1） */}
+              {request.costMultiplier &&
+                parseFloat(request.costMultiplier) !== 1 && (
+                  <div className="col-span-2 border-t pt-3">
+                    <dt className="text-muted-foreground">
+                      {t("usage.costMultiplier", "成本倍率")}
+                    </dt>
+                    <dd className="font-mono">×{request.costMultiplier}</dd>
+                  </div>
+                )}
+              <div
+                className={`col-span-2 ${request.costMultiplier && parseFloat(request.costMultiplier) !== 1 ? "" : "border-t"} pt-3`}
+              >
                 <dt className="text-muted-foreground">
                   {t("usage.totalCost", "总成本")}
+                  {request.costMultiplier &&
+                    parseFloat(request.costMultiplier) !== 1 && (
+                      <span className="ml-1 text-xs">
+                        ({t("usage.withMultiplier", "含倍率")})
+                      </span>
+                    )}
                 </dt>
                 <dd className="text-lg font-semibold text-primary">
                   ${parseFloat(request.totalCostUsd).toFixed(6)}

src/components/usage/RequestLogTable.tsx

@@ -250,7 +250,7 @@ export function RequestLogTable() {
                   <TableHead className="whitespace-nowrap">
                     {t("usage.provider")}
                   </TableHead>
-                  <TableHead className="min-w-[280px] whitespace-nowrap">
+                  <TableHead className="min-w-[200px] whitespace-nowrap">
                     {t("usage.billingModel")}
                   </TableHead>
                   <TableHead className="text-right whitespace-nowrap">
@@ -265,6 +265,9 @@ export function RequestLogTable() {
                   <TableHead className="text-right min-w-[90px] whitespace-nowrap">
                     {t("usage.cacheCreationTokens")}
                   </TableHead>
+                  <TableHead className="text-right whitespace-nowrap">
+                    {t("usage.multiplier")}
+                  </TableHead>
                   <TableHead className="text-right whitespace-nowrap">
                     {t("usage.totalCost")}
                   </TableHead>
@@ -280,7 +283,7 @@ export function RequestLogTable() {
                 {logs.length === 0 ? (
                   <TableRow>
                     <TableCell
-                      colSpan={10}
+                      colSpan={11}
                       className="text-center text-muted-foreground"
                     >
                       {t("usage.noData")}
@@ -297,11 +300,25 @@ export function RequestLogTable() {
                       <TableCell>
                         {log.providerName || t("usage.unknownProvider")}
                       </TableCell>
-                      <TableCell
-                        className="font-mono text-sm max-w-[280px] truncate"
-                        title={log.model}
-                      >
-                        {log.model}
+                      <TableCell className="font-mono text-xs max-w-[200px]">
+                        <div
+                          className="truncate"
+                          title={
+                            log.requestModel && log.requestModel !== log.model
+                              ? `${t("usage.requestModel")}: ${log.requestModel}\n${t("usage.responseModel")}: ${log.model}`
+                              : log.model
+                          }
+                        >
+                          {log.model}
+                        </div>
+                        {log.requestModel && log.requestModel !== log.model && (
+                          <div
+                            className="truncate text-muted-foreground text-[10px]"
+                            title={log.requestModel}
+                          >
+                            ← {log.requestModel}
+                          </div>
+                        )}
                       </TableCell>
                       <TableCell className="text-right">
                         {log.inputTokens.toLocaleString()}
@@ -315,6 +332,15 @@ export function RequestLogTable() {
                       <TableCell className="text-right">
                         {log.cacheCreationTokens.toLocaleString()}
                       </TableCell>
+                      <TableCell className="text-right font-mono text-xs">
+                        {parseFloat(log.costMultiplier) !== 1 ? (
+                          <span className="text-orange-600">
+                            ×{log.costMultiplier}
+                          </span>
+                        ) : (
+                          <span className="text-muted-foreground">×1</span>
+                        )}
+                      </TableCell>
                       <TableCell className="text-right">
                         ${parseFloat(log.totalCostUsd).toFixed(6)}
                       </TableCell>

src/hooks/useDirectorySettings.ts

@@ -5,13 +5,14 @@ import { homeDir, join } from "@tauri-apps/api/path";
 import { settingsApi, type AppId } from "@/lib/api";
 import type { SettingsFormState } from "./useSettingsForm";
 
-type DirectoryKey = "appConfig" | "claude" | "codex" | "gemini";
+type DirectoryKey = "appConfig" | "claude" | "codex" | "gemini" | "opencode";
 
 export interface ResolvedDirectories {
   appConfig: string;
   claude: string;
   codex: string;
   gemini: string;
+  opencode: string;
 }
 
 const sanitizeDir = (value?: string | null): string | undefined => {
@@ -39,7 +40,13 @@ const computeDefaultConfigDir = async (
   try {
     const home = await homeDir();
     const folder =
-      app === "claude" ? ".claude" : app === "codex" ? ".codex" : ".gemini";
+      app === "claude"
+        ? ".claude"
+        : app === "codex"
+          ? ".codex"
+          : app === "gemini"
+            ? ".gemini"
+            : ".config/opencode";
     return await join(home, folder);
   } catch (error) {
     console.error(
@@ -70,6 +77,7 @@ export interface UseDirectorySettingsResult {
     claudeDir?: string,
     codexDir?: string,
     geminiDir?: string,
+    opencodeDir?: string,
   ) => void;
 }
 
@@ -96,6 +104,7 @@ export function useDirectorySettings({
     claude: "",
     codex: "",
     gemini: "",
+    opencode: "",
   });
   const [isLoading, setIsLoading] = useState(true);
 
@@ -104,6 +113,7 @@ export function useDirectorySettings({
     claude: "",
     codex: "",
     gemini: "",
+    opencode: "",
   });
   const initialAppConfigDirRef = useRef<string | undefined>(undefined);
 
@@ -119,19 +129,23 @@ export function useDirectorySettings({
           claudeDir,
           codexDir,
           geminiDir,
+          opencodeDir,
           defaultAppConfig,
           defaultClaudeDir,
           defaultCodexDir,
           defaultGeminiDir,
+          defaultOpencodeDir,
         ] = await Promise.all([
           settingsApi.getAppConfigDirOverride(),
           settingsApi.getConfigDir("claude"),
           settingsApi.getConfigDir("codex"),
           settingsApi.getConfigDir("gemini"),
+          settingsApi.getConfigDir("opencode"),
           computeDefaultAppConfigDir(),
           computeDefaultConfigDir("claude"),
           computeDefaultConfigDir("codex"),
           computeDefaultConfigDir("gemini"),
+          computeDefaultConfigDir("opencode"),
         ]);
 
         if (!active) return;
@@ -143,6 +157,7 @@ export function useDirectorySettings({
           claude: defaultClaudeDir ?? "",
           codex: defaultCodexDir ?? "",
           gemini: defaultGeminiDir ?? "",
+          opencode: defaultOpencodeDir ?? "",
         };
 
         setAppConfigDir(normalizedOverride);
@@ -153,6 +168,7 @@ export function useDirectorySettings({
           claude: claudeDir || defaultsRef.current.claude,
           codex: codexDir || defaultsRef.current.codex,
           gemini: geminiDir || defaultsRef.current.gemini,
+          opencode: opencodeDir || defaultsRef.current.opencode,
         });
       } catch (error) {
         console.error(
@@ -183,7 +199,9 @@ export function useDirectorySettings({
             ? { claudeConfigDir: sanitized }
             : key === "codex"
               ? { codexConfigDir: sanitized }
-              : { geminiConfigDir: sanitized },
+              : key === "gemini"
+                ? { geminiConfigDir: sanitized }
+                : { opencodeConfigDir: sanitized },
         );
       }
 
@@ -205,7 +223,13 @@ export function useDirectorySettings({
   const updateDirectory = useCallback(
     (app: AppId, value?: string) => {
       updateDirectoryState(
-        app === "claude" ? "claude" : app === "codex" ? "codex" : "gemini",
+        app === "claude"
+          ? "claude"
+          : app === "codex"
+            ? "codex"
+            : app === "gemini"
+              ? "gemini"
+              : "opencode",
         value,
       );
     },
@@ -215,13 +239,21 @@ export function useDirectorySettings({
   const browseDirectory = useCallback(
     async (app: AppId) => {
       const key: DirectoryKey =
-        app === "claude" ? "claude" : app === "codex" ? "codex" : "gemini";
+        app === "claude"
+          ? "claude"
+          : app === "codex"
+            ? "codex"
+            : app === "gemini"
+              ? "gemini"
+              : "opencode";
       const currentValue =
         key === "claude"
           ? (settings?.claudeConfigDir ?? resolvedDirs.claude)
           : key === "codex"
             ? (settings?.codexConfigDir ?? resolvedDirs.codex)
-            : (settings?.geminiConfigDir ?? resolvedDirs.gemini);
+            : key === "gemini"
+              ? (settings?.geminiConfigDir ?? resolvedDirs.gemini)
+              : (settings?.opencodeConfigDir ?? resolvedDirs.opencode);
 
       try {
         const picked = await settingsApi.selectConfigDirectory(currentValue);
@@ -263,7 +295,13 @@ export function useDirectorySettings({
   const resetDirectory = useCallback(
     async (app: AppId) => {
       const key: DirectoryKey =
-        app === "claude" ? "claude" : app === "codex" ? "codex" : "gemini";
+        app === "claude"
+          ? "claude"
+          : app === "codex"
+            ? "codex"
+            : app === "gemini"
+              ? "gemini"
+              : "opencode";
       if (!defaultsRef.current[key]) {
         const fallback = await computeDefaultConfigDir(app);
         if (fallback) {
@@ -292,7 +330,12 @@ export function useDirectorySettings({
   }, [updateDirectoryState]);
 
   const resetAllDirectories = useCallback(
-    (claudeDir?: string, codexDir?: string, geminiDir?: string) => {
+    (
+      claudeDir?: string,
+      codexDir?: string,
+      geminiDir?: string,
+      opencodeDir?: string,
+    ) => {
       setAppConfigDir(initialAppConfigDirRef.current);
       setResolvedDirs({
         appConfig:
@@ -300,6 +343,7 @@ export function useDirectorySettings({
         claude: claudeDir ?? defaultsRef.current.claude,
         codex: codexDir ?? defaultsRef.current.codex,
         gemini: geminiDir ?? defaultsRef.current.gemini,
+        opencode: opencodeDir ?? defaultsRef.current.opencode,
       });
     },
     [],

src/hooks/useSettings.ts

@@ -109,6 +109,7 @@ export function useSettings(): UseSettingsResult {
       sanitizeDir(data?.claudeConfigDir),
       sanitizeDir(data?.codexConfigDir),
       sanitizeDir(data?.geminiConfigDir),
+      sanitizeDir(data?.opencodeConfigDir),
     );
     setRequiresRestart(false);
   }, [
@@ -131,12 +132,16 @@ export function useSettings(): UseSettingsResult {
         const sanitizedClaudeDir = sanitizeDir(mergedSettings.claudeConfigDir);
         const sanitizedCodexDir = sanitizeDir(mergedSettings.codexConfigDir);
         const sanitizedGeminiDir = sanitizeDir(mergedSettings.geminiConfigDir);
+        const sanitizedOpencodeDir = sanitizeDir(
+          mergedSettings.opencodeConfigDir,
+        );
 
         const payload: Settings = {
           ...mergedSettings,
           claudeConfigDir: sanitizedClaudeDir,
           codexConfigDir: sanitizedCodexDir,
           geminiConfigDir: sanitizedGeminiDir,
+          opencodeConfigDir: sanitizedOpencodeDir,
           language: mergedSettings.language,
         };
 
@@ -238,16 +243,21 @@ export function useSettings(): UseSettingsResult {
         const sanitizedClaudeDir = sanitizeDir(mergedSettings.claudeConfigDir);
         const sanitizedCodexDir = sanitizeDir(mergedSettings.codexConfigDir);
         const sanitizedGeminiDir = sanitizeDir(mergedSettings.geminiConfigDir);
+        const sanitizedOpencodeDir = sanitizeDir(
+          mergedSettings.opencodeConfigDir,
+        );
         const previousAppDir = initialAppConfigDir;
         const previousClaudeDir = sanitizeDir(data?.claudeConfigDir);
         const previousCodexDir = sanitizeDir(data?.codexConfigDir);
         const previousGeminiDir = sanitizeDir(data?.geminiConfigDir);
+        const previousOpencodeDir = sanitizeDir(data?.opencodeConfigDir);
 
         const payload: Settings = {
           ...mergedSettings,
           claudeConfigDir: sanitizedClaudeDir,
           codexConfigDir: sanitizedCodexDir,
           geminiConfigDir: sanitizedGeminiDir,
+          opencodeConfigDir: sanitizedOpencodeDir,
           language: mergedSettings.language,
         };
 
@@ -344,11 +354,17 @@ export function useSettings(): UseSettingsResult {
           console.warn("[useSettings] Failed to refresh tray menu", error);
         }
 
-        // 如果 Claude/Codex/Gemini 的目录覆盖发生变化，则立即将“当前使用的供应商”写回对应应用的 live 配置
+        // 如果 Claude/Codex/Gemini/OpenCode 的目录覆盖发生变化，则立即将"当前使用的供应商"写回对应应用的 live 配置
         const claudeDirChanged = sanitizedClaudeDir !== previousClaudeDir;
         const codexDirChanged = sanitizedCodexDir !== previousCodexDir;
         const geminiDirChanged = sanitizedGeminiDir !== previousGeminiDir;
-        if (claudeDirChanged || codexDirChanged || geminiDirChanged) {
+        const opencodeDirChanged = sanitizedOpencodeDir !== previousOpencodeDir;
+        if (
+          claudeDirChanged ||
+          codexDirChanged ||
+          geminiDirChanged ||
+          opencodeDirChanged
+        ) {
           const syncResult = await syncCurrentProvidersLiveSafe();
           if (!syncResult.ok) {
             console.warn(

src/hooks/useSettingsForm.ts

@@ -83,9 +83,12 @@ export function useSettingsForm(): UseSettingsFormResult {
       minimizeToTrayOnClose: data.minimizeToTrayOnClose ?? true,
       enableClaudePluginIntegration:
         data.enableClaudePluginIntegration ?? false,
+      silentStartup: data.silentStartup ?? false,
       skipClaudeOnboarding: data.skipClaudeOnboarding ?? false,
       claudeConfigDir: sanitizeDir(data.claudeConfigDir),
       codexConfigDir: sanitizeDir(data.codexConfigDir),
+      geminiConfigDir: sanitizeDir(data.geminiConfigDir),
+      opencodeConfigDir: sanitizeDir(data.opencodeConfigDir),
       language: normalizedLanguage,
     };
 
@@ -138,9 +141,12 @@ export function useSettingsForm(): UseSettingsFormResult {
         minimizeToTrayOnClose: serverData.minimizeToTrayOnClose ?? true,
         enableClaudePluginIntegration:
           serverData.enableClaudePluginIntegration ?? false,
+        silentStartup: serverData.silentStartup ?? false,
         skipClaudeOnboarding: serverData.skipClaudeOnboarding ?? false,
         claudeConfigDir: sanitizeDir(serverData.claudeConfigDir),
         codexConfigDir: sanitizeDir(serverData.codexConfigDir),
+        geminiConfigDir: sanitizeDir(serverData.geminiConfigDir),
+        opencodeConfigDir: sanitizeDir(serverData.opencodeConfigDir),
         language: normalizedLanguage,
       };
 

src/i18n/locales/en.json

@@ -265,6 +265,8 @@
     "windowBehaviorHint": "Configure window minimize and Claude plugin integration policies.",
     "launchOnStartup": "Launch on Startup",
     "launchOnStartupDescription": "Automatically run CC Switch when system starts",
+    "silentStartup": "Silent Startup",
+    "silentStartupDescription": "Start in background mode without showing main window",
     "autoLaunchFailed": "Failed to set auto-launch",
     "minimizeToTray": "Minimize to tray on close",
     "minimizeToTrayDescription": "When checked, clicking the close button will hide to system tray, otherwise the app will exit directly.",
@@ -287,6 +289,33 @@
       "copy": "Copy Files",
       "symlinkHint": "Symlinks save disk space and enable real-time sync. Note: May require admin privileges or Developer Mode on Windows"
     },
+    "terminal": {
+      "title": "Preferred Terminal",
+      "description": "Choose which terminal app to use when clicking the terminal button",
+      "fallbackHint": "If the selected terminal is unavailable, the system default will be used",
+      "options": {
+        "macos": {
+          "terminal": "Terminal.app",
+          "iterm2": "iTerm2",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        },
+        "windows": {
+          "cmd": "Command Prompt",
+          "powershell": "PowerShell",
+          "wt": "Windows Terminal"
+        },
+        "linux": {
+          "gnomeTerminal": "GNOME Terminal",
+          "konsole": "Konsole",
+          "xfce4Terminal": "Xfce4 Terminal",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        }
+      }
+    },
     "configDirectoryOverride": "Configuration Directory Override (Advanced)",
     "configDirectoryDescription": "When using Claude Code or Codex in environments like WSL, you can manually specify the configuration directory to the one in WSL to keep provider data consistent with the main environment.",
     "appConfigDir": "CC Switch Configuration Directory",
@@ -298,9 +327,12 @@
     "codexConfigDirDescription": "Override Codex configuration directory.",
     "geminiConfigDir": "Gemini Configuration Directory",
     "geminiConfigDirDescription": "Override Gemini configuration directory (.env).",
+    "opencodeConfigDir": "OpenCode Configuration Directory",
+    "opencodeConfigDirDescription": "Override OpenCode configuration directory (opencode.json).",
     "browsePlaceholderClaude": "e.g., /home/<your-username>/.claude",
     "browsePlaceholderCodex": "e.g., /home/<your-username>/.codex",
     "browsePlaceholderGemini": "e.g., /home/<your-username>/.gemini",
+    "browsePlaceholderOpencode": "e.g., /home/<your-username>/.config/opencode",
     "browseDirectory": "Browse Directory",
     "resetDefault": "Reset to default directory (takes effect after saving)",
     "checkForUpdates": "Check for Updates",
@@ -344,7 +376,21 @@
       "saved": "Proxy settings saved",
       "saveFailed": "Save failed: {{error}}",
       "testSuccess": "Connected! Latency {{latency}}ms",
-      "testFailed": "Connection failed: {{error}}"
+      "testFailed": "Connection failed: {{error}}",
+      "pricingDefaultsTitle": "Pricing Defaults",
+      "pricingDefaultsDescription": "Set the default multiplier and pricing model source per app.",
+      "pricingAppLabel": "App",
+      "defaultCostMultiplierLabel": "Default Multiplier",
+      "defaultCostMultiplierHint": "Multiplier for cost calculation, decimals supported.",
+      "pricingModelSourceLabel": "Pricing Model Source",
+      "pricingModelSourceRequest": "Request model",
+      "pricingModelSourceResponse": "Response model",
+      "pricingSave": "Save Pricing Defaults",
+      "pricingSaved": "Pricing defaults saved",
+      "pricingSaveFailed": "Failed to save pricing defaults: {{error}}",
+      "pricingLoadFailed": "Failed to load pricing defaults: {{error}}",
+      "defaultCostMultiplierRequired": "Default multiplier is required",
+      "defaultCostMultiplierInvalid": "Invalid multiplier format"
     }
   },
   "apps": {
@@ -480,7 +526,18 @@
     "useCustomProxy": "Use separate proxy",
     "proxyConfigDesc": "Configure separate network proxy for this provider. Uses system proxy or global settings when disabled.",
     "proxyUsername": "Username (optional)",
-    "proxyPassword": "Password (optional)"
+    "proxyPassword": "Password (optional)",
+    "pricingConfig": "Pricing Config",
+    "useCustomPricing": "Use separate config",
+    "pricingConfigDesc": "Configure separate pricing parameters for this provider. Uses global defaults when disabled.",
+    "costMultiplier": "Cost Multiplier",
+    "costMultiplierPlaceholder": "Leave empty to use global default (1)",
+    "costMultiplierHint": "Actual cost = Base cost × Multiplier, supports decimals like 1.5",
+    "pricingModelSourceLabel": "Pricing Mode",
+    "pricingModelSourceInherit": "Inherit global default",
+    "pricingModelSourceRequest": "Request model",
+    "pricingModelSourceResponse": "Response model",
+    "pricingModelSourceHint": "Choose whether to match pricing by request model or response model"
   },
   "codexConfig": {
     "authJson": "auth.json (JSON) *",
@@ -583,6 +640,9 @@
     "cacheCreationTokens": "Cache Creation",
     "timingInfo": "Duration/TTFT",
     "status": "Status",
+    "multiplier": "Multiplier",
+    "requestModel": "Request Model",
+    "responseModel": "Response Model",
     "noData": "No data",
     "unknownProvider": "Unknown Provider",
     "stream": "Stream",
@@ -625,7 +685,19 @@
     "input": "Input",
     "output": "Output",
     "cacheWrite": "Creation",
-    "cacheRead": "Hit"
+    "cacheRead": "Hit",
+    "baseCost": "Base",
+    "costMultiplier": "Cost Multiplier",
+    "withMultiplier": "with multiplier",
+    "requestDetail": "Request Detail",
+    "requestNotFound": "Request not found",
+    "basicInfo": "Basic Info",
+    "tokenUsage": "Token Usage",
+    "cacheCreationCost": "Cache Creation Cost",
+    "costBreakdown": "Cost Breakdown",
+    "performance": "Performance",
+    "latency": "Latency",
+    "errorMessage": "Error Message"
   },
   "usageScript": {
     "title": "Configure Usage Query",
@@ -972,6 +1044,7 @@
       "downloadTimeoutHint": "Please check network connection or retry later",
       "skillPathNotFound": "Skill path '{{path}}' not found in repository {{owner}}/{{name}}",
       "skillDirNotFound": "Skill directory not found: {{path}}",
+      "directoryConflict": "Skill directory '{{directory}}' is already occupied by {{existing_repo}}, cannot install from {{new_repo}}",
       "emptyArchive": "Downloaded archive is empty",
       "downloadFailed": "Download failed: HTTP {{status}}",
       "allBranchesFailed": "All branches failed, tried: {{branches}}",
@@ -990,7 +1063,8 @@
         "retryLater": "Please retry later",
         "checkRepoUrl": "Please check repository URL and branch name",
         "checkDiskSpace": "Please check disk space",
-        "checkPermission": "Please check directory permissions"
+        "checkPermission": "Please check directory permissions",
+        "uninstallFirst": "Please uninstall the existing skill with the same name first"
       }
     },
     "repo": {

src/i18n/locales/ja.json

@@ -265,6 +265,8 @@
     "windowBehaviorHint": "最小化動作や Claude プラグイン連携を設定します。",
     "launchOnStartup": "起動時に自動実行",
     "launchOnStartupDescription": "システム起動時に CC Switch を自動起動します",
+    "silentStartup": "サイレント起動",
+    "silentStartupDescription": "起動時にメインウィンドウを表示せず、トレイのみで起動",
     "autoLaunchFailed": "自動起動の設定に失敗しました",
     "minimizeToTray": "閉じるときトレイへ最小化",
     "minimizeToTrayDescription": "チェックすると閉じるボタンでトレイに隠し、オフならアプリを終了します。",
@@ -287,6 +289,33 @@
       "copy": "ファイルコピー",
       "symlinkHint": "シンボリックリンクはディスク容量を節約し、リアルタイム同期を有効にします。注意：Windowsでは管理者権限または開発者モードが必要な場合があります"
     },
+    "terminal": {
+      "title": "優先ターミナル",
+      "description": "ターミナルボタンをクリックした時に使用するターミナルアプリを選択",
+      "fallbackHint": "選択したターミナルが利用できない場合、システムのデフォルトが使用されます",
+      "options": {
+        "macos": {
+          "terminal": "Terminal.app",
+          "iterm2": "iTerm2",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        },
+        "windows": {
+          "cmd": "コマンドプロンプト",
+          "powershell": "PowerShell",
+          "wt": "Windows Terminal"
+        },
+        "linux": {
+          "gnomeTerminal": "GNOME Terminal",
+          "konsole": "Konsole",
+          "xfce4Terminal": "Xfce4 Terminal",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        }
+      }
+    },
     "configDirectoryOverride": "設定ディレクトリの上書き（詳細）",
     "configDirectoryDescription": "WSL などで Claude Code や Codex を使う場合、ここで設定ディレクトリを WSL 側に合わせるとデータを揃えられます。",
     "appConfigDir": "CC Switch 設定ディレクトリ",
@@ -298,9 +327,12 @@
     "codexConfigDirDescription": "Codex の設定ディレクトリを上書きします。",
     "geminiConfigDir": "Gemini 設定ディレクトリ",
     "geminiConfigDirDescription": "Gemini の設定ディレクトリ（.env）を上書きします。",
+    "opencodeConfigDir": "OpenCode 設定ディレクトリ",
+    "opencodeConfigDirDescription": "OpenCode の設定ディレクトリ（opencode.json）を上書きします。",
     "browsePlaceholderClaude": "例: /home/<your-username>/.claude",
     "browsePlaceholderCodex": "例: /home/<your-username>/.codex",
     "browsePlaceholderGemini": "例: /home/<your-username>/.gemini",
+    "browsePlaceholderOpencode": "例: /home/<your-username>/.config/opencode",
     "browseDirectory": "ディレクトリを選択",
     "resetDefault": "デフォルトに戻す（保存後に反映）",
     "checkForUpdates": "アップデートを確認",
@@ -344,7 +376,21 @@
       "saved": "プロキシ設定を保存しました",
       "saveFailed": "保存に失敗しました: {{error}}",
       "testSuccess": "接続成功！遅延 {{latency}}ms",
-      "testFailed": "接続に失敗しました: {{error}}"
+      "testFailed": "接続に失敗しました: {{error}}",
+      "pricingDefaultsTitle": "課金のデフォルト設定",
+      "pricingDefaultsDescription": "アプリごとのデフォルト倍率と課金モードを設定します。",
+      "pricingAppLabel": "アプリ",
+      "defaultCostMultiplierLabel": "デフォルト倍率",
+      "defaultCostMultiplierHint": "コスト計算用の倍率（小数対応）。",
+      "pricingModelSourceLabel": "課金モード",
+      "pricingModelSourceRequest": "リクエストモデル",
+      "pricingModelSourceResponse": "レスポンスモデル",
+      "pricingSave": "課金設定を保存",
+      "pricingSaved": "課金設定を保存しました",
+      "pricingSaveFailed": "課金設定の保存に失敗しました: {{error}}",
+      "pricingLoadFailed": "課金設定の読み込みに失敗しました: {{error}}",
+      "defaultCostMultiplierRequired": "デフォルト倍率は必須です",
+      "defaultCostMultiplierInvalid": "デフォルト倍率の形式が正しくありません"
     }
   },
   "apps": {
@@ -480,7 +526,18 @@
     "useCustomProxy": "個別プロキシを使用",
     "proxyConfigDesc": "このプロバイダーに個別のネットワークプロキシを設定します。無効の場合はシステムプロキシまたはグローバル設定を使用します。",
     "proxyUsername": "ユーザー名（任意）",
-    "proxyPassword": "パスワード（任意）"
+    "proxyPassword": "パスワード（任意）",
+    "pricingConfig": "課金設定",
+    "useCustomPricing": "個別設定を使用",
+    "pricingConfigDesc": "このプロバイダーに個別の課金パラメータを設定します。無効の場合はグローバル設定を使用します。",
+    "costMultiplier": "コスト倍率",
+    "costMultiplierPlaceholder": "空白の場合はグローバル設定を使用（1）",
+    "costMultiplierHint": "実際のコスト = 基本コスト × 倍率、1.5 などの小数をサポート",
+    "pricingModelSourceLabel": "課金モード",
+    "pricingModelSourceInherit": "グローバル設定を継承",
+    "pricingModelSourceRequest": "リクエストモデル",
+    "pricingModelSourceResponse": "レスポンスモデル",
+    "pricingModelSourceHint": "リクエストモデルまたはレスポンスモデルで価格を照合するかを選択"
   },
   "codexConfig": {
     "authJson": "auth.json (JSON) *",
@@ -583,6 +640,9 @@
     "cacheCreationTokens": "キャッシュ作成",
     "timingInfo": "応答時間/TTFT",
     "status": "ステータス",
+    "multiplier": "倍率",
+    "requestModel": "リクエストモデル",
+    "responseModel": "レスポンスモデル",
     "noData": "データなし",
     "unknownProvider": "不明なプロバイダー",
     "stream": "ストリーム",
@@ -625,7 +685,19 @@
     "input": "Input",
     "output": "Output",
     "cacheWrite": "作成",
-    "cacheRead": "ヒット"
+    "cacheRead": "ヒット",
+    "baseCost": "基本",
+    "costMultiplier": "コスト倍率",
+    "withMultiplier": "倍率込み",
+    "requestDetail": "リクエスト詳細",
+    "requestNotFound": "リクエストが見つかりません",
+    "basicInfo": "基本情報",
+    "tokenUsage": "Token 使用量",
+    "cacheCreationCost": "キャッシュ作成コスト",
+    "costBreakdown": "コスト明細",
+    "performance": "パフォーマンス",
+    "latency": "レイテンシー",
+    "errorMessage": "エラーメッセージ"
   },
   "usageScript": {
     "title": "利用状況を設定",
@@ -972,6 +1044,7 @@
       "downloadTimeoutHint": "ネットワークを確認するか、時間をおいて再試行してください",
       "skillPathNotFound": "リポジトリ {{owner}}/{{name}} にスキルパス '{{path}}' がありません",
       "skillDirNotFound": "スキルディレクトリが見つかりません: {{path}}",
+      "directoryConflict": "スキルディレクトリ '{{directory}}' は既に {{existing_repo}} で使用されています。{{new_repo}} からインストールできません",
       "emptyArchive": "ダウンロードしたアーカイブが空です",
       "downloadFailed": "ダウンロードに失敗しました: HTTP {{status}}",
       "allBranchesFailed": "すべてのブランチで失敗しました。試行: {{branches}}",
@@ -990,7 +1063,8 @@
         "retryLater": "時間をおいて再試行してください",
         "checkRepoUrl": "リポジトリ URL とブランチ名を確認してください",
         "checkDiskSpace": "ディスク容量を確認してください",
-        "checkPermission": "ディレクトリの権限を確認してください"
+        "checkPermission": "ディレクトリの権限を確認してください",
+        "uninstallFirst": "同名のスキルを先にアンインストールしてください"
       }
     },
     "repo": {

src/i18n/locales/zh.json

@@ -265,6 +265,8 @@
     "windowBehaviorHint": "配置窗口最小化与 Claude 插件联动策略。",
     "launchOnStartup": "开机自启",
     "launchOnStartupDescription": "随系统启动自动运行 CC Switch",
+    "silentStartup": "静默启动",
+    "silentStartupDescription": "程序启动时不显示主窗口，仅在系统托盘运行",
     "autoLaunchFailed": "设置开机自启失败",
     "minimizeToTray": "关闭时最小化到托盘",
     "minimizeToTrayDescription": "勾选后点击关闭按钮会隐藏到系统托盘，取消则直接退出应用。",
@@ -287,6 +289,33 @@
       "copy": "文件复制",
       "symlinkHint": "软连接节省磁盘空间并支持实时同步。注意：Windows 可能需要管理员权限或开启开发者模式"
     },
+    "terminal": {
+      "title": "首选终端",
+      "description": "选择点击终端按钮时使用的终端应用",
+      "fallbackHint": "如果选择的终端不可用，将自动使用系统默认终端",
+      "options": {
+        "macos": {
+          "terminal": "Terminal.app",
+          "iterm2": "iTerm2",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        },
+        "windows": {
+          "cmd": "命令提示符",
+          "powershell": "PowerShell",
+          "wt": "Windows Terminal"
+        },
+        "linux": {
+          "gnomeTerminal": "GNOME Terminal",
+          "konsole": "Konsole",
+          "xfce4Terminal": "Xfce4 Terminal",
+          "alacritty": "Alacritty",
+          "kitty": "Kitty",
+          "ghostty": "Ghostty"
+        }
+      }
+    },
     "configDirectoryOverride": "配置目录覆盖（高级）",
     "configDirectoryDescription": "在 WSL 等环境使用 Claude Code 或 Codex 的时候，可手动指定为 WSL 里的配置目录，供应商数据与主环境保持一致。",
     "appConfigDir": "CC Switch 配置目录",
@@ -298,9 +327,12 @@
     "codexConfigDirDescription": "覆盖 Codex 配置目录。",
     "geminiConfigDir": "Gemini 配置目录",
     "geminiConfigDirDescription": "覆盖 Gemini 配置目录 (.env)。",
+    "opencodeConfigDir": "OpenCode 配置目录",
+    "opencodeConfigDirDescription": "覆盖 OpenCode 配置目录 (opencode.json)。",
     "browsePlaceholderClaude": "例如：/home/<你的用户名>/.claude",
     "browsePlaceholderCodex": "例如：/home/<你的用户名>/.codex",
     "browsePlaceholderGemini": "例如：/home/<你的用户名>/.gemini",
+    "browsePlaceholderOpencode": "例如：/home/<你的用户名>/.config/opencode",
     "browseDirectory": "浏览目录",
     "resetDefault": "恢复默认目录（需保存后生效）",
     "checkForUpdates": "检查更新",
@@ -344,7 +376,21 @@
       "saved": "代理设置已保存",
       "saveFailed": "保存失败：{{error}}",
       "testSuccess": "连接成功！延迟 {{latency}}ms",
-      "testFailed": "连接失败：{{error}}"
+      "testFailed": "连接失败：{{error}}",
+      "pricingDefaultsTitle": "计费默认配置",
+      "pricingDefaultsDescription": "设置各应用的默认倍率与计费模式来源。",
+      "pricingAppLabel": "应用",
+      "defaultCostMultiplierLabel": "默认倍率",
+      "defaultCostMultiplierHint": "用于成本计算的倍率，支持小数。",
+      "pricingModelSourceLabel": "计费模式",
+      "pricingModelSourceRequest": "请求模型",
+      "pricingModelSourceResponse": "返回模型",
+      "pricingSave": "保存计费配置",
+      "pricingSaved": "计费配置已保存",
+      "pricingSaveFailed": "保存计费配置失败：{{error}}",
+      "pricingLoadFailed": "加载计费配置失败：{{error}}",
+      "defaultCostMultiplierRequired": "默认倍率不能为空",
+      "defaultCostMultiplierInvalid": "默认倍率格式不正确"
     }
   },
   "apps": {
@@ -480,7 +526,18 @@
     "useCustomProxy": "使用单独代理",
     "proxyConfigDesc": "为此供应商配置单独的网络代理，不启用时使用系统代理或全局设置。",
     "proxyUsername": "用户名（可选）",
-    "proxyPassword": "密码（可选）"
+    "proxyPassword": "密码（可选）",
+    "pricingConfig": "计费配置",
+    "useCustomPricing": "使用单独配置",
+    "pricingConfigDesc": "为此供应商配置单独的计费参数，不启用时使用全局默认配置。",
+    "costMultiplier": "成本倍率",
+    "costMultiplierPlaceholder": "留空使用全局默认（1）",
+    "costMultiplierHint": "实际成本 = 基础成本 × 倍率，支持小数如 1.5",
+    "pricingModelSourceLabel": "计费模式",
+    "pricingModelSourceInherit": "继承全局默认",
+    "pricingModelSourceRequest": "请求模型",
+    "pricingModelSourceResponse": "返回模型",
+    "pricingModelSourceHint": "选择按请求模型还是返回模型进行定价匹配"
   },
   "codexConfig": {
     "authJson": "auth.json (JSON) *",
@@ -583,6 +640,9 @@
     "cacheCreationTokens": "缓存创建",
     "timingInfo": "用时/首字",
     "status": "状态",
+    "multiplier": "倍率",
+    "requestModel": "请求模型",
+    "responseModel": "返回模型",
     "noData": "暂无数据",
     "unknownProvider": "未知供应商",
     "stream": "流",
@@ -625,7 +685,19 @@
     "input": "Input",
     "output": "Output",
     "cacheWrite": "创建",
-    "cacheRead": "命中"
+    "cacheRead": "命中",
+    "baseCost": "基础",
+    "costMultiplier": "成本倍率",
+    "withMultiplier": "含倍率",
+    "requestDetail": "请求详情",
+    "requestNotFound": "请求未找到",
+    "basicInfo": "基本信息",
+    "tokenUsage": "Token 使用量",
+    "cacheCreationCost": "缓存写入成本",
+    "costBreakdown": "成本明细",
+    "performance": "性能信息",
+    "latency": "延迟",
+    "errorMessage": "错误信息"
   },
   "usageScript": {
     "title": "配置用量查询",
@@ -972,6 +1044,7 @@
       "downloadTimeoutHint": "请检查网络连接或稍后重试",
       "skillPathNotFound": "仓库 {{owner}}/{{name}} 中未找到技能路径 '{{path}}'",
       "skillDirNotFound": "技能目录不存在：{{path}}",
+      "directoryConflict": "技能目录 '{{directory}}' 已被 {{existing_repo}} 占用，无法从 {{new_repo}} 安装",
       "emptyArchive": "下载的压缩包为空",
       "downloadFailed": "下载失败：HTTP {{status}}",
       "allBranchesFailed": "所有分支下载失败，尝试了：{{branches}}",
@@ -990,7 +1063,8 @@
         "retryLater": "请稍后重试",
         "checkRepoUrl": "请检查仓库地址和分支名称",
         "checkDiskSpace": "请检查磁盘空间",
-        "checkPermission": "请检查目录权限"
+        "checkPermission": "请检查目录权限",
+        "uninstallFirst": "请先卸载已安装的同名技能"
       }
     },
     "repo": {

src/lib/api/proxy.ts

@@ -92,4 +92,29 @@ export const proxyApi = {
   async updateProxyConfigForApp(config: AppProxyConfig): Promise<void> {
     return invoke("update_proxy_config_for_app", { config });
   },
+
+  // ========== 计费默认配置 API ==========
+
+  // 获取默认成本倍率
+  async getDefaultCostMultiplier(appType: string): Promise<string> {
+    return invoke("get_default_cost_multiplier", { appType });
+  },
+
+  // 设置默认成本倍率
+  async setDefaultCostMultiplier(
+    appType: string,
+    value: string,
+  ): Promise<void> {
+    return invoke("set_default_cost_multiplier", { appType, value });
+  },
+
+  // 获取计费模式来源
+  async getPricingModelSource(appType: string): Promise<string> {
+    return invoke("get_pricing_model_source", { appType });
+  },
+
+  // 设置计费模式来源
+  async setPricingModelSource(appType: string, value: string): Promise<void> {
+    return invoke("set_pricing_model_source", { appType, value });
+  },
 };

src/lib/errors/skillErrorParser.ts

@@ -35,6 +35,7 @@ function getErrorI18nKey(code: string): string {
     DOWNLOAD_TIMEOUT: "skills.error.downloadTimeout",
     DOWNLOAD_FAILED: "skills.error.downloadFailed",
     SKILL_DIR_NOT_FOUND: "skills.error.skillDirNotFound",
+    SKILL_DIRECTORY_CONFLICT: "skills.error.directoryConflict",
     EMPTY_ARCHIVE: "skills.error.emptyArchive",
     GET_HOME_DIR_FAILED: "skills.error.getHomeDirFailed",
   };
@@ -52,6 +53,7 @@ function getSuggestionI18nKey(suggestion: string): string {
     retryLater: "skills.error.suggestion.retryLater",
     checkRepoUrl: "skills.error.suggestion.checkRepoUrl",
     checkPermission: "skills.error.suggestion.checkPermission",
+    uninstallFirst: "skills.error.suggestion.uninstallFirst",
     http403: "skills.error.http403",
     http404: "skills.error.http404",
     http429: "skills.error.http429",

src/types.ts

@@ -135,6 +135,10 @@ export interface ProviderMeta {
   testConfig?: ProviderTestConfig;
   // 供应商单独的代理配置
   proxyConfig?: ProviderProxyConfig;
+  // 供应商成本倍率
+  costMultiplier?: string;
+  // 供应商计费模式来源
+  pricingModelSource?: string;
 }
 
 // Skill 同步方式
@@ -162,6 +166,8 @@ export interface Settings {
   skipClaudeOnboarding?: boolean;
   // 是否开机自启
   launchOnStartup?: boolean;
+  // 静默启动（程序启动时不显示主窗口）
+  silentStartup?: boolean;
   // 首选语言（可选，默认中文）
   language?: "en" | "zh" | "ja";
 
@@ -189,6 +195,13 @@ export interface Settings {
   // ===== Skill 同步设置 =====
   // Skill 同步方式：auto（默认，优先 symlink）、symlink、copy
   skillSyncMethod?: SkillSyncMethod;
+
+  // ===== 终端设置 =====
+  // 首选终端应用（可选，默认使用系统默认终端）
+  // macOS: "terminal" | "iterm2" | "warp" | "alacritty" | "kitty" | "ghostty"
+  // Windows: "cmd" | "powershell" | "wt"
+  // Linux: "gnome-terminal" | "konsole" | "xfce4-terminal" | "alacritty" | "kitty" | "ghostty"
+  preferredTerminal?: string;
 }
 
 // MCP 服务器连接参数（宽松：允许扩展字段）

src/types/usage.ts

@@ -13,6 +13,8 @@ export interface RequestLog {
   providerName?: string;
   appType: string;
   model: string;
+  requestModel?: string;
+  costMultiplier: string;
   inputTokens: number;
   outputTokens: number;
   cacheReadTokens: number;

tests/components/GlobalProxySettings.test.tsx

@@ -0,0 +1,83 @@
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { GlobalProxySettings } from "@/components/settings/GlobalProxySettings";
+
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+const mutateAsyncMock = vi.fn();
+const testMutateAsyncMock = vi.fn();
+const scanMutateAsyncMock = vi.fn();
+
+vi.mock("@/hooks/useGlobalProxy", () => ({
+  useGlobalProxyUrl: () => ({ data: "http://127.0.0.1:7890", isLoading: false }),
+  useSetGlobalProxyUrl: () => ({
+    mutateAsync: mutateAsyncMock,
+    isPending: false,
+  }),
+  useTestProxy: () => ({
+    mutateAsync: testMutateAsyncMock,
+    isPending: false,
+  }),
+  useScanProxies: () => ({
+    mutateAsync: scanMutateAsyncMock,
+    isPending: false,
+  }),
+}));
+
+describe("GlobalProxySettings", () => {
+  beforeEach(() => {
+    mutateAsyncMock.mockReset();
+    testMutateAsyncMock.mockReset();
+    scanMutateAsyncMock.mockReset();
+  });
+
+  it("renders proxy URL input with saved value", async () => {
+    render(<GlobalProxySettings />);
+
+    const urlInput = screen.getByPlaceholderText(
+      "http://127.0.0.1:7890 / socks5://127.0.0.1:1080",
+    );
+    // URL 对象会在末尾添加斜杠
+    await waitFor(() =>
+      expect(urlInput).toHaveValue("http://127.0.0.1:7890/"),
+    );
+  });
+
+  it("saves proxy URL when save button is clicked", async () => {
+    render(<GlobalProxySettings />);
+
+    const urlInput = screen.getByPlaceholderText(
+      "http://127.0.0.1:7890 / socks5://127.0.0.1:1080",
+    );
+
+    fireEvent.change(urlInput, { target: { value: "http://localhost:8080" } });
+
+    const saveButton = screen.getByRole("button", { name: "common.save" });
+    fireEvent.click(saveButton);
+
+    await waitFor(() => expect(mutateAsyncMock).toHaveBeenCalled());
+    // 没有用户名时，URL 不经过 URL 对象解析，所以没有尾部斜杠
+    expect(mutateAsyncMock).toHaveBeenCalledWith("http://localhost:8080");
+  });
+
+  it("clears proxy URL when clear button is clicked", async () => {
+    render(<GlobalProxySettings />);
+
+    const urlInput = screen.getByPlaceholderText(
+      "http://127.0.0.1:7890 / socks5://127.0.0.1:1080",
+    );
+
+    // Wait for initial value to load
+    await waitFor(() =>
+      expect(urlInput).toHaveValue("http://127.0.0.1:7890/"),
+    );
+
+    // Click clear button
+    const clearButton = screen.getByTitle("settings.globalProxy.clear");
+    fireEvent.click(clearButton);
+
+    expect(urlInput).toHaveValue("");
+  });
+});

tests/hooks/useDirectorySettings.test.tsx

@@ -64,9 +64,12 @@ describe("useDirectorySettings", () => {
     );
 
     getAppConfigDirOverrideMock.mockResolvedValue(null);
-    getConfigDirMock.mockImplementation(async (app: string) =>
-      app === "claude" ? "/remote/claude" : "/remote/codex",
-    );
+    getConfigDirMock.mockImplementation(async (app: string) => {
+      if (app === "claude") return "/remote/claude";
+      if (app === "codex") return "/remote/codex";
+      if (app === "gemini") return "/remote/gemini";
+      return "/remote/opencode";
+    });
     selectConfigDirectoryMock.mockReset();
   });
 
@@ -84,7 +87,8 @@ describe("useDirectorySettings", () => {
       appConfig: "/override/app",
       claude: "/remote/claude",
       codex: "/remote/codex",
-      gemini: "/remote/codex", // Gemini 使用 codex 作为默认
+      gemini: "/remote/gemini",
+      opencode: "/remote/opencode",
     });
   });
 
@@ -214,10 +218,17 @@ describe("useDirectorySettings", () => {
     await waitFor(() => expect(result.current.isLoading).toBe(false));
 
     act(() => {
-      result.current.resetAllDirectories("/server/claude", "/server/codex");
+      result.current.resetAllDirectories(
+        "/server/claude",
+        "/server/codex",
+        "/server/gemini",
+        "/server/opencode",
+      );
     });
 
     expect(result.current.resolvedDirs.claude).toBe("/server/claude");
     expect(result.current.resolvedDirs.codex).toBe("/server/codex");
+    expect(result.current.resolvedDirs.gemini).toBe("/server/gemini");
+    expect(result.current.resolvedDirs.opencode).toBe("/server/opencode");
   });
 });

tests/hooks/useSettings.test.tsx

@@ -381,6 +381,7 @@ describe("useSettings hook", () => {
       "/server/claude",
       undefined,
       undefined, // geminiConfigDir
+      undefined, // opencodeConfigDir
     );
     expect(metadataMock.setRequiresRestart).toHaveBeenCalledWith(false);
   });

tests/setupGlobals.ts

@@ -0,0 +1,26 @@
+const storage = new Map<string, string>();
+
+if (
+  typeof globalThis.localStorage === "undefined" ||
+  typeof globalThis.localStorage?.getItem !== "function"
+) {
+  Object.defineProperty(globalThis, "localStorage", {
+    value: {
+      getItem: (key: string) => storage.get(key) ?? null,
+      setItem: (key: string, value: string) => {
+        storage.set(key, String(value));
+      },
+      removeItem: (key: string) => {
+        storage.delete(key);
+      },
+      clear: () => {
+        storage.clear();
+      },
+      key: (index: number) => Array.from(storage.keys())[index] ?? null,
+      get length() {
+        return storage.size;
+      },
+    },
+    configurable: true,
+  });
+}

vitest.config.ts

@@ -11,7 +11,7 @@ export default defineConfig({
   },
   test: {
     environment: "jsdom",
-    setupFiles: ["./tests/setupTests.ts"],
+    setupFiles: ["./tests/setupGlobals.ts", "./tests/setupTests.ts"],
     globals: true,
     coverage: {
       reporter: ["text", "lcov"],