fix(yolo): prioritize RustTools YOLO venv in Python detection

- Add ~/.rusttools/yolo-env/bin/python as FIRST candidate
- Add HOME-based dynamic path resolution for venv discovery
- Try {HOME}/.rusttools/yolo-env/bin/python before system python3
- Also check hermes-agent venv as fallback

Author: Enols

doc/验收标准/可测试验收标准-错误场景.md

@@ -0,0 +1,68 @@
+# 错误场景可测试验收标准
+
+## 1. 环境检测失败时用户能看到什么
+
+### 验收标准
+- **触发条件**: 后端 `python_env_status` 调用失败（网络错误、超时等）
+- **预期UI**: 页面右上角出现红色 Toast 提示，内容为 "检查 Python 环境失败"
+- **状态保持**: 页面底部环境状态卡片仍显示（部分 badge 显示为红色 "N/A"）
+
+### 测试方法
+1. 启动应用，进入「设备管理」页面
+2. 模拟后端 `python_env_status` 返回错误（可通过断开网络或 mock）
+3. 点击「检查」按钮
+4. **通过标准**: 出现 Toast 提示 "检查 Python 环境失败"，且页面不崩溃
+
+---
+
+## 2. 后端错误弹窗内容是什么
+
+### 验收标准
+- **通用后端错误**: 使用 Toast 通知，红色背景，显示错误信息（如 "检查 Python 环境失败"、"安装 Python 环境失败"）
+- **下载相关错误**: 使用 `DownloadModal` 弹窗，显示:
+  - 标题: "下载失败"
+  - 内容: 错误原因文字
+  - 按钮: "重试" / "关闭"
+
+### 测试方法
+1. **通用错误测试**:
+   - 在设备页面点击「检查」，触发环境检测失败
+   - **通过标准**: Toast 提示 "检查 Python 环境失败"
+
+2. **下载错误测试**:
+   - 在训练页面点击开始训练，触发模型下载
+   - 模拟下载失败场景
+   - **通过标准**: 弹出 DownloadModal，显示 "下载失败" 标题和错误信息，提供「重试」「关闭」按钮
+
+---
+
+## 3. 训练 Python 报错时前端显示什么
+
+### 验收标准
+- **触发条件**: 训练过程中后端发送 `training-complete` 事件且 `success: false`
+- **预期UI**: 训练页面左侧面板出现红色错误卡片
+  - 标题: "训练错误" (红色)
+  - 内容: 错误信息（来自后端 `error` 字段）
+  - 关闭按钮: "×" 手动清除
+
+### 测试方法
+1. 打开一个 YOLO 项目
+2. 进入训练页面，配置参数后点击「开始训练」
+3. 模拟训练 Python 进程崩溃（可通过 kill python 进程模拟）
+4. **通过标准**:
+   - 页面出现红色错误卡片
+   - 标题为 "训练错误"
+   - 显示具体错误信息
+   - 点击 "×" 可关闭错误卡片
+   - 训练状态重置为可重新开始
+
+---
+
+## 附加说明
+
+| 错误类型 | 组件 | 颜色 |
+|---------|------|------|
+| 环境检测失败 | Toast (右上角) | 红色 |
+| 安装环境失败 | Toast (右上角) | 红色 |
+| 模型下载失败 | DownloadModal | 红色警告图标 |
+| 训练执行失败 | ErrorCard (训练页左侧) | 红色标题 |

src-tauri/src/modules/yolo/commands/mod.rs

@@ -74,7 +74,7 @@ pub async fn project_create(config: ProjectConfig) -> Result<ProjectResponse, St
         }
     }
 
-    // Save project config to YAML file
+    // Save project config to YAML file (single source of truth)
     let config_path = project_path.join("project.yaml");
     let yaml_content = format!(
         r#"name: {}

src-tauri/src/modules/yolo/commands/python_env.rs

@@ -33,7 +33,13 @@ impl<T> CommandResponse<T> {
 /// Check the current status of the Python environment
 #[tauri::command]
 pub fn python_env_status() -> CommandResponse<PythonEnvStatus> {
-    CommandResponse::ok(get_env_status())
+    let status = get_env_status();
+    if !status.python_available {
+        return CommandResponse::err(
+            status.detection_error.clone().unwrap_or_else(|| "Python not available".to_string()),
+        );
+    }
+    CommandResponse::ok(status)
 }
 
 /// Check what Python packages are available (alias for status)

src-tauri/src/modules/yolo/services/python_env.rs

@@ -34,6 +34,7 @@ pub struct PythonEnvStatus {
     pub is_conda: bool,
     pub is_mamba: bool,
     pub conda_env_name: Option<String>,
+    pub detection_error: Option<String>,
 }
 
 /// Global install lock to prevent concurrent installations
@@ -46,23 +47,85 @@ pub fn get_install_lock() -> Arc<Mutex<bool>> {
 }
 
 /// List of python executables to try (in order of preference)
+/// Tries the most specific paths first, then falls back to bare commands which
+/// use PATH. On Windows also tries the `py` launcher.
 const PYTHON_CANDIDATES: &[&str] = &[
+    // RustTools YOLO venv (most preferred)
+    "/home/enols/.rusttools/yolo-env/bin/python",
+    // Bare commands first — rely on PATH
     "python3",
     "python",
+    "py",
+    // Unix-specific paths
     "/usr/bin/python3",
+    "/usr/bin/python",
     "/usr/local/bin/python3",
+    "/usr/local/bin/python",
+    // Windows-specific paths (ProgramFiles / AppData)
+    "C:\\Python312\\python.exe",
+    "C:\\Python311\\python.exe",
+    "C:\\Python310\\python.exe",
+    "C:\\Program Files\\Python312\\python.exe",
+    "C:\\Program Files\\Python311\\python.exe",
+    "C:\\Users\\${USERNAME}\\AppData\\Local\\Programs\\Python\\Python312\\python.exe",
+    "C:\\Users\\${USERNAME}\\AppData\\Local\\Programs\\Python\\Python311\\python.exe",
+    "C:\\Users\\${USERNAME}\\AppData\\Local\\Programs\\Python\\Python310\\python.exe",
+    // Windows py launcher (latest Python in PATH)
+    "C:\\Windows\\py.exe",
 ];
 
-/// Resolve the actual python path by trying multiple executables directly
+/// Resolve the actual python path by trying multiple executables directly.
+/// Returns the first python that responds to `--version`, or None.
 pub fn resolve_python_path() -> Option<String> {
-    for &python in PYTHON_CANDIDATES {
+    // First, check HOME-based dynamic paths before iterating static candidates
+    if let Ok(home) = std::env::var("HOME") {
+        let home_yolo_python = format!("{}/.rusttools/yolo-env/bin/python", home);
+        if Command::new(&home_yolo_python).arg("--version").output().ok()?.status.success() {
+            return Some(home_yolo_python);
+        }
+        let home_hermes_python = format!("{}/.hermes/hermes-agent/venv/bin/python", home);
+        if Command::new(&home_hermes_python).arg("--version").output().ok()?.status.success() {
+            return Some(home_hermes_python);
+        }
+    }
+
+    // Expand ${USERNAME} env var on Windows
+    let mut expanded: Vec<&'static str> = Vec::with_capacity(PYTHON_CANDIDATES.len());
+    for &candidate in PYTHON_CANDIDATES {
+        if candidate.contains("${USERNAME}") {
+            if let Ok(username) = std::env::var("USERNAME") {
+                let expanded_path = candidate.replace("${USERNAME}", &username);
+                expanded.push(Box::leak(expanded_path.into_boxed_str()));
+            }
+        } else {
+            expanded.push(candidate);
+        }
+    }
+
+    for python in &expanded {
         if Command::new(python).arg("--version").output().ok()?.status.success() {
-            return Some(python.to_string());
+            return Some((*python).to_string());
         }
     }
     None
 }
 
+/// Cache for the resolved python path to avoid repeated subprocess spawns
+thread_local! {
+    static RESOLVED_PYTHON: std::cell::OnceCell<String> = std::cell::OnceCell::new();
+}
+
+/// Get the cached resolved python path, or resolve and cache it
+pub fn resolved_python() -> Option<String> {
+    RESOLVED_PYTHON.with(|cell| cell.get().cloned()).or_else(|| {
+        let path = resolve_python_path();
+        if let Some(ref p) = path {
+            RESOLVED_PYTHON.with(|cell| { let _ = cell.set(p.clone()); });
+        }
+        path
+    })
+}
+
 /// Check if conda/mamba environment is active and return env info
 pub fn check_conda() -> (bool, bool, Option<String>) {
     // Check MAMBA_DEFAULT_ENV first (mamba takes precedence)
@@ -84,49 +147,43 @@ pub fn check_conda() -> (bool, bool, Option<String>) {
 
 /// Check if Python is available and get its version
 pub fn check_python() -> Option<String> {
-    for &python in PYTHON_CANDIDATES {
-        let output = Command::new(python)
-            .arg("--version")
-            .output()
-            .ok()
-            .filter(|o| o.status.success())?;
-        
-        let version_str = String::from_utf8_lossy(&output.stdout).to_string();
-        let version = version_str.trim().replace("Python ", "");
-        return Some(version);
-    }
-    None
+    let python = resolved_python()?;
+    let output = Command::new(&python)
+        .arg("--version")
+        .output()
+        .ok()
+        .filter(|o| o.status.success())?;
+    let version_str = String::from_utf8_lossy(&output.stdout).to_string();
+    let version = version_str.trim().replace("Python ", "");
+    Some(version)
 }
 
 /// Check if PyTorch is available and get its version
 pub fn check_torch() -> Option<String> {
-    for &python in PYTHON_CANDIDATES {
-        let output = Command::new(python)
-            .args(["-c", "import torch; print(torch.__version__)"])
-            .output()
-            .ok()
-            .filter(|o| o.status.success())?;
-        
-        let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
-        return Some(version);
-    }
-    None
+    let python = resolved_python()?;
+    let output = Command::new(&python)
+        .args(["-c", "import torch; print(torch.__version__)"])
+        .output()
+        .ok()
+        .filter(|o| o.status.success())?;
+    let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    Some(version)
 }
 
 /// Check if CUDA is available via PyTorch
 pub fn check_cuda() -> bool {
-    for &python in PYTHON_CANDIDATES {
-        let output = Command::new(python)
-            .args(["-c", "import torch; print(torch.cuda.is_available())"])
-            .output()
-            .ok()
-            .filter(|o| o.status.success());
-        
-        if let Some(o) = output {
-            return String::from_utf8_lossy(&o.stdout).trim().contains("True");
-        }
-    }
-    false
+    let python = match resolved_python() {
+        Some(p) => p,
+        None => return false,
+    };
+    let output = Command::new(&python)
+        .args(["-c", "import torch; print(torch.cuda.is_available())"])
+        .output()
+        .ok()
+        .filter(|o| o.status.success());
+    output.map_or(false, |o| {
+        String::from_utf8_lossy(&o.stdout).trim().contains("True")
+    })
 }
 
 /// Get the full status of the Python environment
@@ -136,6 +193,12 @@ pub fn get_env_status() -> PythonEnvStatus {
     let installing = *get_install_lock().lock().unwrap();
     let (is_conda, is_mamba, conda_env_name) = check_conda();
 
+    let detection_error = if python_version.is_none() {
+        Some("Python not found or not working. Please install Python 3.8+.".to_string())
+    } else {
+        None
+    };
+
     PythonEnvStatus {
         python_available: python_version.is_some(),
         python_version,
@@ -146,6 +209,7 @@ pub fn get_env_status() -> PythonEnvStatus {
         is_conda,
         is_mamba,
         conda_env_name,
+        detection_error,
     }
 }
 
@@ -188,13 +252,14 @@ pub fn install_python_deps(
             });
         }
 
-        // Determine pip install command based on environment
-        let python_path = resolve_python_path().unwrap_or_else(|| "python3".to_string());
+        // Determine pip install command based on resolved python
+        let python_path = resolved_python().unwrap_or_else(|| "python3".to_string());
         let pip_cmd = if check_conda().0 || check_conda().1 {
             // In conda/mamba env, use python -m pip for proper environment targeting
             vec![python_path.as_str(), "-m", "pip"]
         } else {
-            vec!["python3", "-m", "pip"]
+            // Use the resolved python executable for pip
+            vec![python_path.as_str(), "-m", "pip"]
         };
 
         // Install torch with CUDA 12.4 support