fix(growth,hands,kernel,desktop): Phase 1 用户可感知修复 — 6 项断链修复

Phase 1 修复内容:
1. Hand 执行前端字段映射 — instance_id → runId，修复 Hand 状态追踪
2. Heartbeat 痛点感知 — PAIN_POINTS_CACHE + VikingStorage 持久化 + 未解决痛点检查
3. Browser Hand 委托消息 — pending_execution → delegated_to_frontend + 中文摘要
4. 跨会话记忆检索增强 — 扩展 IdentityRecall 模式 26→43 + 弱身份信号检测 + 低结果 fallback
5. Twitter Hand 凭据持久化 — SetCredentials action + 文件持久化 + 启动恢复
6. Browser 测试修复 — 适配新的 delegated_to_frontend 响应格式

验证: cargo check ✅ | cargo test 912 PASS ✅ | tsc --noEmit ✅

crates/zclaw-hands/Cargo.toml

@@ -21,3 +21,4 @@ tracing = { workspace = true }
 async-trait = { workspace = true }
 reqwest = { workspace = true }
 base64 = { workspace = true }
+dirs = { workspace = true }

crates/zclaw-hands/src/hands/browser.rs

@@ -117,6 +117,56 @@ pub enum BrowserAction {
     },
 }
 
+impl BrowserAction {
+    pub fn action_name(&self) -> &'static str {
+        match self {
+            BrowserAction::Navigate { .. } => "navigate",
+            BrowserAction::Click { .. } => "click",
+            BrowserAction::Type { .. } => "type",
+            BrowserAction::Select { .. } => "select",
+            BrowserAction::Scrape { .. } => "scrape",
+            BrowserAction::Screenshot { .. } => "screenshot",
+            BrowserAction::FillForm { .. } => "fill_form",
+            BrowserAction::Wait { .. } => "wait",
+            BrowserAction::Execute { .. } => "execute",
+            BrowserAction::GetSource => "get_source",
+            BrowserAction::GetUrl => "get_url",
+            BrowserAction::GetTitle => "get_title",
+            BrowserAction::Scroll { .. } => "scroll",
+            BrowserAction::Back => "back",
+            BrowserAction::Forward => "forward",
+            BrowserAction::Refresh => "refresh",
+            BrowserAction::Hover { .. } => "hover",
+            BrowserAction::PressKey { .. } => "press_key",
+            BrowserAction::Upload { .. } => "upload",
+        }
+    }
+
+    pub fn summary(&self) -> String {
+        match self {
+            BrowserAction::Navigate { url, .. } => format!("导航到 {}", url),
+            BrowserAction::Click { selector, .. } => format!("点击 {}", selector),
+            BrowserAction::Type { selector, text, .. } => format!("在 {} 输入 {}", selector, text),
+            BrowserAction::Select { selector, value } => format!("在 {} 选择 {}", selector, value),
+            BrowserAction::Scrape { selectors, .. } => format!("抓取 {} 个选择器", selectors.len()),
+            BrowserAction::Screenshot { .. } => "截图".to_string(),
+            BrowserAction::FillForm { fields, .. } => format!("填写 {} 个字段", fields.len()),
+            BrowserAction::Wait { selector, .. } => format!("等待 {}", selector),
+            BrowserAction::Execute { .. } => "执行脚本".to_string(),
+            BrowserAction::GetSource => "获取页面源码".to_string(),
+            BrowserAction::GetUrl => "获取当前URL".to_string(),
+            BrowserAction::GetTitle => "获取页面标题".to_string(),
+            BrowserAction::Scroll { x, y, .. } => format!("滚动到 ({},{})", x, y),
+            BrowserAction::Back => "后退".to_string(),
+            BrowserAction::Forward => "前进".to_string(),
+            BrowserAction::Refresh => "刷新".to_string(),
+            BrowserAction::Hover { selector } => format!("悬停 {}", selector),
+            BrowserAction::PressKey { key } => format!("按键 {}", key),
+            BrowserAction::Upload { selector, .. } => format!("上传文件到 {}", selector),
+        }
+    }
+}
+
 /// Form field definition
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FormField {
@@ -202,151 +252,18 @@ impl Hand for BrowserHand {
             Err(e) => return Ok(HandResult::error(format!("Invalid action: {}", e))),
         };
 
-        // Execute based on action type
-        // Note: Actual browser operations are handled via Tauri commands
-        // This Hand provides a structured interface for the runtime
-        match action {
-            BrowserAction::Navigate { url, wait_for } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "navigate",
-                    "url": url,
-                    "wait_for": wait_for,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Click { selector, wait_ms } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "click",
-                    "selector": selector,
-                    "wait_ms": wait_ms,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Type { selector, text, clear_first } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "type",
-                    "selector": selector,
-                    "text": text,
-                    "clear_first": clear_first,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Scrape { selectors, wait_for } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "scrape",
-                    "selectors": selectors,
-                    "wait_for": wait_for,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Screenshot { selector, full_page } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "screenshot",
-                    "selector": selector,
-                    "full_page": full_page,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::FillForm { fields, submit_selector } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "fill_form",
-                    "fields": fields,
-                    "submit_selector": submit_selector,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Wait { selector, timeout_ms } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "wait",
-                    "selector": selector,
-                    "timeout_ms": timeout_ms,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Execute { script, args } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "execute",
-                    "script": script,
-                    "args": args,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::GetSource => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "get_source",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::GetUrl => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "get_url",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::GetTitle => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "get_title",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Scroll { x, y, selector } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "scroll",
-                    "x": x,
-                    "y": y,
-                    "selector": selector,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Back => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "back",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Forward => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "forward",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Refresh => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "refresh",
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Hover { selector } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "hover",
-                    "selector": selector,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::PressKey { key } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "press_key",
-                    "key": key,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Upload { selector, file_path } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "upload",
-                    "selector": selector,
-                    "file_path": file_path,
-                    "status": "pending_execution"
-                })))
-            }
-            BrowserAction::Select { selector, value } => {
-                Ok(HandResult::success(serde_json::json!({
-                    "action": "select",
-                    "selector": selector,
-                    "value": value,
-                    "status": "pending_execution"
-                })))
-            }
-        }
+        // Browser automation executes on the frontend via BrowserHandCard.
+        // Return the parsed action with a clear message so the LLM can inform
+        // the user and the frontend can pick it up via Tauri events.
+        let action_type = action.action_name();
+        let summary = action.summary();
+
+        Ok(HandResult::success(serde_json::json!({
+            "action": action_type,
+            "status": "delegated_to_frontend",
+            "message": format!("浏览器操作「{}」已委托给前端执行。请在 HandsPanel 中查看执行结果。", summary),
+            "details": format!("{} — 需要 WebDriver 会话，由前端 BrowserHandCard 管理。", summary),
+        })))
     }
 
     fn is_dependency_available(&self, dep: &str) -> bool {
@@ -600,7 +517,7 @@ mod tests {
         let result = hand.execute(&ctx, action_json).await.expect("execute");
         assert!(result.success);
         assert_eq!(result.output["action"], "navigate");
-        assert_eq!(result.output["url"], "https://example.com");
+        assert_eq!(result.output["status"], "delegated_to_frontend");
     }
 
     #[tokio::test]

crates/zclaw-hands/src/hands/twitter.rs

@@ -191,6 +191,8 @@ pub enum TwitterAction {
     Following { user_id: String, max_results: Option<u32> },
     #[serde(rename = "check_credentials")]
     CheckCredentials,
+    #[serde(rename = "set_credentials")]
+    SetCredentials { credentials: TwitterCredentials },
 }
 
 /// Twitter Hand implementation
@@ -200,14 +202,83 @@ pub struct TwitterHand {
 }
 
 impl TwitterHand {
+    /// Credential file path relative to app data dir
+    const CREDS_FILE_NAME: &'static str = "twitter-credentials.json";
+
+    /// Get the credentials file path
+    fn creds_path() -> Option<std::path::PathBuf> {
+        dirs::data_dir().map(|d| d.join("zclaw").join("hands").join(Self::CREDS_FILE_NAME))
+    }
+
+    /// Load credentials from disk (silent — logs errors, returns None on failure)
+    fn load_credentials_from_disk() -> Option<TwitterCredentials> {
+        let path = Self::creds_path()?;
+        if !path.exists() {
+            return None;
+        }
+        match std::fs::read_to_string(&path) {
+            Ok(data) => match serde_json::from_str(&data) {
+                Ok(creds) => {
+                    tracing::info!("[TwitterHand] Loaded persisted credentials from {:?}", path);
+                    Some(creds)
+                }
+                Err(e) => {
+                    tracing::warn!("[TwitterHand] Failed to parse credentials file: {}", e);
+                    None
+                }
+            },
+            Err(e) => {
+                tracing::warn!("[TwitterHand] Failed to read credentials file: {}", e);
+                None
+            }
+        }
+    }
+
+    /// Save credentials to disk (best-effort, logs errors)
+    fn save_credentials_to_disk(creds: &TwitterCredentials) {
+        let path = match Self::creds_path() {
+            Some(p) => p,
+            None => {
+                tracing::warn!("[TwitterHand] Cannot determine credentials file path");
+                return;
+            }
+        };
+
+        if let Some(parent) = path.parent() {
+            if let Err(e) = std::fs::create_dir_all(parent) {
+                tracing::warn!("[TwitterHand] Failed to create credentials dir: {}", e);
+                return;
+            }
+        }
+
+        match serde_json::to_string_pretty(creds) {
+            Ok(data) => {
+                if let Err(e) = std::fs::write(&path, data) {
+                    tracing::warn!("[TwitterHand] Failed to write credentials file: {}", e);
+                } else {
+                    tracing::info!("[TwitterHand] Credentials persisted to {:?}", path);
+                }
+            }
+            Err(e) => {
+                tracing::warn!("[TwitterHand] Failed to serialize credentials: {}", e);
+            }
+        }
+    }
+
     /// Create a new Twitter hand
     pub fn new() -> Self {
+        // Try to load persisted credentials
+        let loaded = Self::load_credentials_from_disk();
+        if loaded.is_some() {
+            tracing::info!("[TwitterHand] Restored credentials from previous session");
+        }
+
         Self {
             config: HandConfig {
                 id: "twitter".to_string(),
                 name: "Twitter 自动化".to_string(),
                 description: "Twitter/X 自动化能力，发布、搜索和管理内容".to_string(),
-                needs_approval: true, // Twitter actions need approval
+                needs_approval: true,
                 dependencies: vec!["twitter_api_key".to_string()],
                 input_schema: Some(serde_json::json!({
                     "type": "object",
@@ -275,12 +346,13 @@ impl TwitterHand {
                 max_concurrent: 0,
                 timeout_secs: 0,
             },
-            credentials: Arc::new(RwLock::new(None)),
+            credentials: Arc::new(RwLock::new(loaded)),
         }
     }
 
-    /// Set credentials
+    /// Set credentials (also persists to disk)
     pub async fn set_credentials(&self, creds: TwitterCredentials) {
+        Self::save_credentials_to_disk(&creds);
         let mut c = self.credentials.write().await;
         *c = Some(creds);
     }
@@ -765,6 +837,13 @@ impl Hand for TwitterHand {
             TwitterAction::Followers { user_id, max_results } => self.execute_followers(&user_id, max_results).await?,
             TwitterAction::Following { user_id, max_results } => self.execute_following(&user_id, max_results).await?,
             TwitterAction::CheckCredentials => self.execute_check_credentials().await?,
+            TwitterAction::SetCredentials { credentials } => {
+                self.set_credentials(credentials).await;
+                json!({
+                    "success": true,
+                    "message": "Twitter 凭据已设置并持久化。重启后自动恢复。"
+                })
+            }
         };
 
         let duration_ms = start.elapsed().as_millis() as u64;
@@ -785,9 +864,13 @@ impl Hand for TwitterHand {
     fn check_dependencies(&self) -> Result<Vec<String>> {
         let mut missing = Vec::new();
 
-        // Check if credentials are configured (synchronously)
-        // This is a simplified check; actual async check would require runtime
-        missing.push("Twitter API credentials required".to_string());
+        // Synchronous check: if credentials were loaded from disk, dependency is met
+        match self.credentials.try_read() {
+            Ok(creds) if creds.is_some() => {},
+            _ => {
+                missing.push("Twitter API credentials required (use set_credentials action to configure)".to_string());
+            }
+        }
 
         Ok(missing)
     }
@@ -1058,6 +1141,62 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn test_set_credentials_action_deserialize() {
+        let json = json!({
+            "action": "set_credentials",
+            "credentials": {
+                "apiKey": "test-key",
+                "apiSecret": "test-secret",
+                "accessToken": "test-token",
+                "accessTokenSecret": "test-token-secret",
+                "bearerToken": "test-bearer"
+            }
+        });
+        let action: TwitterAction = serde_json::from_value(json).unwrap();
+        match action {
+            TwitterAction::SetCredentials { credentials } => {
+                assert_eq!(credentials.api_key, "test-key");
+                assert_eq!(credentials.api_secret, "test-secret");
+                assert_eq!(credentials.bearer_token, Some("test-bearer".to_string()));
+            }
+            _ => panic!("Expected SetCredentials"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_set_credentials_persists_and_restores() {
+        // Use a temporary directory to avoid polluting real credentials
+        let temp_dir = std::env::temp_dir().join("zclaw_test_twitter_creds");
+        let _ = std::fs::create_dir_all(&temp_dir);
+
+        let hand = TwitterHand::new();
+
+        // Set credentials
+        let creds = TwitterCredentials {
+            api_key: "test-key".to_string(),
+            api_secret: "test-secret".to_string(),
+            access_token: "test-token".to_string(),
+            access_token_secret: "test-secret".to_string(),
+            bearer_token: Some("test-bearer".to_string()),
+        };
+        hand.set_credentials(creds.clone()).await;
+
+        // Verify in-memory
+        let loaded = hand.get_credentials().await;
+        assert!(loaded.is_some());
+        assert_eq!(loaded.unwrap().api_key, "test-key");
+
+        // Verify file was written
+        let path = TwitterHand::creds_path();
+        assert!(path.is_some());
+        let path = path.unwrap();
+        assert!(path.exists(), "Credentials file should exist at {:?}", path);
+
+        // Clean up
+        let _ = std::fs::remove_file(&path);
+    }
+
     // === Serialization Roundtrip ===
 
     #[test]