fix(audit): 第五轮审计修复 — 反思LLM分析、语义路由、并行执行、错误中文化

- P2: 反思引擎接入 LLM 深度行为分析 (analyze_patterns_with_llm)
- P3-M6: 语义路由 RuntimeLlmIntentDriver 真实 LLM 匹配
- P3-L1: V2 Pipeline execute_parallel 改用 buffer_unordered 真正并行
- P3-S10: Rust 用户可见错误提示统一中文化

累计修复 27 项，完成度 ~72% → ~78%

crates/zclaw-pipeline/src/actions/mod.rs

@@ -150,7 +150,7 @@ impl ActionRegistry {
                 .await
                 .map_err(ActionError::Llm)
         } else {
-            Err(ActionError::Llm("LLM driver not configured".to_string()))
+            Err(ActionError::Llm("LLM 驱动未配置，请在设置中配置模型与 API".to_string()))
         }
     }
 
@@ -165,7 +165,7 @@ impl ActionRegistry {
                 .await
                 .map_err(ActionError::Skill)
         } else {
-            Err(ActionError::Skill("Skill registry not configured".to_string()))
+            Err(ActionError::Skill("技能注册表未初始化".to_string()))
         }
     }
 
@@ -181,7 +181,7 @@ impl ActionRegistry {
                 .await
                 .map_err(ActionError::Hand)
         } else {
-            Err(ActionError::Hand("Hand registry not configured".to_string()))
+            Err(ActionError::Hand("Hand 注册表未初始化".to_string()))
         }
     }
 
@@ -197,7 +197,7 @@ impl ActionRegistry {
                 .await
                 .map_err(ActionError::Orchestration)
         } else {
-            Err(ActionError::Orchestration("Orchestration driver not configured".to_string()))
+            Err(ActionError::Orchestration("编排驱动未初始化".to_string()))
         }
     }
 

crates/zclaw-pipeline/src/engine/stage.rs

@@ -10,6 +10,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 use async_trait::async_trait;
+use futures::stream::{self, StreamExt};
 use serde_json::{Value, json};
 
 use crate::types_v2::{Stage, ConditionalBranch};
@@ -269,7 +270,7 @@ impl StageEngine {
 
         self.emit_event(StageEvent::Progress {
             stage_id: stage_id.to_string(),
-            message: "Calling LLM...".to_string(),
+            message: "正在调用 LLM...".to_string(),
         });
 
         let prompt_str = resolved_prompt.as_str()
@@ -302,7 +303,7 @@ impl StageEngine {
         stage_id: &str,
         each: &str,
         stage_template: &Stage,
-        _max_workers: usize,
+        max_workers: usize,
         context: &mut ExecutionContextV2,
     ) -> Result<Value, StageError> {
         // Resolve the array to iterate over
@@ -313,29 +314,58 @@ impl StageEngine {
             return Ok(Value::Array(vec![]));
         }
 
+        let workers = max_workers.max(1).min(total);
+        let stage_template = stage_template.clone();
+
+        // Clone Arc drivers for concurrent tasks
+        let llm_driver = self.llm_driver.clone();
+        let skill_driver = self.skill_driver.clone();
+        let hand_driver = self.hand_driver.clone();
+        let event_callback = self.event_callback.clone();
+
         self.emit_event(StageEvent::Progress {
             stage_id: stage_id.to_string(),
-            message: format!("Processing {} items", total),
+            message: format!("并行处理 {} 项 (workers={})", total, workers),
         });
 
-        // Sequential execution with progress tracking
-        // Note: True parallel execution would require Send-safe drivers
-        let mut outputs = Vec::with_capacity(total);
+        // Parallel execution using buffer_unordered
+        let results: Vec<(usize, Result<StageResult, StageError>)> = stream::iter(
+            items.into_iter().enumerate().map(|(index, item)| {
+                let child_ctx = context.child_context(item, index, total);
+                let stage = stage_template.clone();
+                let llm = llm_driver.clone();
+                let skill = skill_driver.clone();
+                let hand = hand_driver.clone();
+                let cb = event_callback.clone();
 
-        for (index, item) in items.into_iter().enumerate() {
-            let mut child_context = context.child_context(item.clone(), index, total);
+                async move {
+                    let engine = StageEngine {
+                        llm_driver: llm,
+                        skill_driver: skill,
+                        hand_driver: hand,
+                        event_callback: cb,
+                        max_workers: workers,
+                    };
+                    let mut ctx = child_ctx;
+                    let result = engine.execute(&stage, &mut ctx).await;
+                    (index, result)
+                }
+            })
+        )
+        .buffer_unordered(workers)
+        .collect()
+        .await;
 
-            self.emit_event(StageEvent::ParallelProgress {
-                stage_id: stage_id.to_string(),
-                completed: index,
-                total,
-            });
+        // Sort by original index to preserve order
+        let mut ordered: Vec<_> = results.into_iter().collect();
+        ordered.sort_by_key(|(idx, _)| *idx);
 
-            match self.execute(stage_template, &mut child_context).await {
-                Ok(result) => outputs.push(result.output),
-                Err(e) => outputs.push(json!({ "error": e.to_string(), "index": index })),
+        let outputs: Vec<Value> = ordered.into_iter().map(|(index, result)| {
+            match result {
+                Ok(sr) => sr.output,
+                Err(e) => json!({ "error": e.to_string(), "index": index }),
             }
-        }
+        }).collect();
 
         Ok(Value::Array(outputs))
     }

crates/zclaw-pipeline/src/executor.rs

@@ -125,7 +125,7 @@ impl PipelineExecutor {
             return Ok(run.clone());
         }
 
-        Err(ExecuteError::Action("Run not found after execution".to_string()))
+        Err(ExecuteError::Action("执行后未找到运行记录".to_string()))
     }
 
     /// Execute pipeline steps
@@ -215,7 +215,7 @@ impl PipelineExecutor {
                 Action::Parallel { each, step, max_workers } => {
                     let items = context.resolve(each)?;
                     let items_array = items.as_array()
-                        .ok_or_else(|| ExecuteError::Action("Parallel 'each' must resolve to an array".to_string()))?;
+                        .ok_or_else(|| ExecuteError::Action("并行执行 'each' 必须解析为数组".to_string()))?;
 
                     let workers = max_workers.unwrap_or(4);
                     let results = self.execute_parallel(step, items_array.clone(), workers, context).await?;

crates/zclaw-pipeline/src/intent.rs

@@ -402,23 +402,25 @@ pub struct DefaultLlmIntentDriver {
     model_id: String,
 }
 
-impl DefaultLlmIntentDriver {
-    /// Create a new default LLM driver
-    pub fn new(model_id: impl Into<String>) -> Self {
-        Self {
-            model_id: model_id.into(),
-        }
+/// Runtime LLM driver that wraps zclaw-runtime's LlmDriver for actual LLM calls
+pub struct RuntimeLlmIntentDriver {
+    driver: std::sync::Arc<dyn zclaw_runtime::driver::LlmDriver>,
+}
+
+impl RuntimeLlmIntentDriver {
+    /// Create a new runtime LLM intent driver wrapping an existing LLM driver
+    pub fn new(driver: std::sync::Arc<dyn zclaw_runtime::driver::LlmDriver>) -> Self {
+        Self { driver }
     }
 }
 
 #[async_trait]
-impl LlmIntentDriver for DefaultLlmIntentDriver {
+impl LlmIntentDriver for RuntimeLlmIntentDriver {
     async fn semantic_match(
         &self,
         user_input: &str,
         triggers: &[CompiledTrigger],
     ) -> Option<SemanticMatchResult> {
-        // Build prompt for LLM
         let trigger_descriptions: Vec<String> = triggers
             .iter()
             .map(|t| {
@@ -430,31 +432,42 @@ impl LlmIntentDriver for DefaultLlmIntentDriver {
             })
             .collect();
 
-        let prompt = format!(
-            r#"分析用户输入，匹配合适的 Pipeline。
+        let system_prompt = r#"分析用户输入，匹配合适的 Pipeline。只返回 JSON，不要其他内容。"#
+            .to_string();
 
-用户输入: {}
-
-可选 Pipelines:
-{}
-
-返回 JSON 格式:
-{{
-  "pipeline_id": "匹配的 pipeline ID 或 null",
-  "params": {{ "参数名": "值" }},
-  "confidence": 0.0-1.0,
-  "reason": "匹配原因"
-}}
-
-只返回 JSON，不要其他内容。"#,
+        let user_msg = format!(
+            "用户输入: {}\n\n可选 Pipelines:\n{}",
             user_input,
             trigger_descriptions.join("\n")
         );
 
-        // In a real implementation, this would call the LLM
-        // For now, we return None to indicate semantic matching is not available
-        let _ = prompt; // Suppress unused warning
-        None
+        let request = zclaw_runtime::driver::CompletionRequest {
+            model: self.driver.provider().to_string(),
+            system: Some(system_prompt),
+            messages: vec![zclaw_types::Message::assistant(user_msg)],
+            max_tokens: Some(512),
+            temperature: Some(0.2),
+            stream: false,
+            ..Default::default()
+        };
+
+        match self.driver.complete(request).await {
+            Ok(response) => {
+                let text = response.content.iter()
+                    .filter_map(|block| match block {
+                        zclaw_runtime::driver::ContentBlock::Text { text } => Some(text.as_str()),
+                        _ => None,
+                    })
+                    .collect::<Vec<_>>()
+                    .join("");
+
+                parse_semantic_match_response(&text)
+            }
+            Err(e) => {
+                tracing::warn!("[intent] LLM semantic match failed: {}", e);
+                None
+            }
+        }
     }
 
     async fn collect_params(
@@ -463,7 +476,10 @@ impl LlmIntentDriver for DefaultLlmIntentDriver {
         missing_params: &[MissingParam],
         _context: &HashMap<String, serde_json::Value>,
     ) -> HashMap<String, serde_json::Value> {
-        // Build prompt to extract parameters from user input
+        if missing_params.is_empty() {
+            return HashMap::new();
+        }
+
         let param_descriptions: Vec<String> = missing_params
             .iter()
             .map(|p| {
@@ -476,30 +492,123 @@ impl LlmIntentDriver for DefaultLlmIntentDriver {
             })
             .collect();
 
-        let prompt = format!(
-            r#"从用户输入中提取参数值。
+        let system_prompt = r#"从用户输入中提取参数值。如果无法提取，该参数可以省略。只返回 JSON。"#
+            .to_string();
 
-用户输入: {}
-
-需要提取的参数:
-{}
-
-返回 JSON 格式:
-{{
-  "参数名": "提取的值"
-}}
-
-如果无法提取，该参数可以省略。只返回 JSON。"#,
+        let user_msg = format!(
+            "用户输入: {}\n\n需要提取的参数:\n{}",
             user_input,
             param_descriptions.join("\n")
         );
 
-        // In a real implementation, this would call the LLM
-        let _ = prompt;
-        HashMap::new()
+        let request = zclaw_runtime::driver::CompletionRequest {
+            model: self.driver.provider().to_string(),
+            system: Some(system_prompt),
+            messages: vec![zclaw_types::Message::assistant(user_msg)],
+            max_tokens: Some(512),
+            temperature: Some(0.1),
+            stream: false,
+            ..Default::default()
+        };
+
+        match self.driver.complete(request).await {
+            Ok(response) => {
+                let text = response.content.iter()
+                    .filter_map(|block| match block {
+                        zclaw_runtime::driver::ContentBlock::Text { text } => Some(text.as_str()),
+                        _ => None,
+                    })
+                    .collect::<Vec<_>>()
+                    .join("");
+
+                parse_params_response(&text)
+            }
+            Err(e) => {
+                tracing::warn!("[intent] LLM param extraction failed: {}", e);
+                HashMap::new()
+            }
+        }
     }
 }
 
+/// Parse semantic match JSON from LLM response
+fn parse_semantic_match_response(text: &str) -> Option<SemanticMatchResult> {
+    let json_str = extract_json_from_text(text);
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).ok()?;
+
+    let pipeline_id = parsed.get("pipeline_id")?.as_str()?.to_string();
+    let confidence = parsed.get("confidence")?.as_f64()? as f32;
+
+    // Reject low-confidence matches
+    if confidence < 0.5 || pipeline_id.is_empty() {
+        return None;
+    }
+
+    let params = parsed.get("params")
+        .and_then(|v| v.as_object())
+        .map(|obj| {
+            obj.iter()
+                .filter_map(|(k, v)| {
+                    let val = match v {
+                        serde_json::Value::String(s) => serde_json::Value::String(s.clone()),
+                        serde_json::Value::Number(n) => serde_json::Value::Number(n.clone()),
+                        other => other.clone(),
+                    };
+                    Some((k.clone(), val))
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+
+    let reason = parsed.get("reason")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    Some(SemanticMatchResult {
+        pipeline_id,
+        params,
+        confidence,
+        reason,
+    })
+}
+
+/// Parse params JSON from LLM response
+fn parse_params_response(text: &str) -> HashMap<String, serde_json::Value> {
+    let json_str = extract_json_from_text(text);
+    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&json_str) {
+        if let Some(obj) = parsed.as_object() {
+            return obj.iter()
+                .filter_map(|(k, v)| Some((k.clone(), v.clone())))
+                .collect();
+        }
+    }
+    HashMap::new()
+}
+
+/// Extract JSON from LLM response text (handles markdown code blocks)
+fn extract_json_from_text(text: &str) -> String {
+    let trimmed = text.trim();
+
+    // Try markdown code block
+    if let Some(start) = trimmed.find("```json") {
+        if let Some(content_start) = trimmed[start..].find('\n') {
+            if let Some(end) = trimmed[content_start..].find("```") {
+                return trimmed[content_start + 1..content_start + end].trim().to_string();
+            }
+        }
+    }
+
+    // Try bare JSON
+    if let Some(start) = trimmed.find('{') {
+        if let Some(end) = trimmed.rfind('}') {
+            return trimmed[start..end + 1].to_string();
+        }
+    }
+
+    trimmed.to_string()
+}
+
 /// Intent analysis result (for debugging/logging)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]

desktop/src-tauri/src/intelligence/reflection.rs

@@ -19,6 +19,10 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::sync::Arc;
+
+// Re-export from zclaw-runtime for LLM integration
+use zclaw_runtime::driver::{CompletionRequest, ContentBlock, LlmDriver};
 
 // === Types ===
 
@@ -187,9 +191,33 @@ impl ReflectionEngine {
     }
 
     /// Execute reflection cycle
-    pub fn reflect(&mut self, agent_id: &str, memories: &[MemoryEntryForAnalysis]) -> ReflectionResult {
-        // 1. Analyze memory patterns
-        let patterns = self.analyze_patterns(memories);
+    pub async fn reflect(
+        &mut self,
+        agent_id: &str,
+        memories: &[MemoryEntryForAnalysis],
+        driver: Option<Arc<dyn LlmDriver>>,
+    ) -> ReflectionResult {
+        // 1. Analyze memory patterns (LLM if configured, rules fallback)
+        let patterns = if self.config.use_llm {
+            if let Some(ref llm) = driver {
+                match self.analyze_patterns_with_llm(memories, llm).await {
+                    Ok(p) => p,
+                    Err(e) => {
+                        tracing::warn!("[reflection] LLM analysis failed, falling back to rules: {}", e);
+                        if self.config.llm_fallback_to_rules {
+                            self.analyze_patterns(memories)
+                        } else {
+                            Vec::new()
+                        }
+                    }
+                }
+            } else {
+                tracing::debug!("[reflection] use_llm=true but no driver available, using rules");
+                self.analyze_patterns(memories)
+            }
+        } else {
+            self.analyze_patterns(memories)
+        };
 
         // 2. Generate improvement suggestions
         let improvements = self.generate_improvements(&patterns, memories);
@@ -282,7 +310,65 @@ impl ReflectionEngine {
         result
     }
 
-    /// Analyze patterns in memories
+    /// Analyze patterns using LLM for deeper behavioral insights
+    async fn analyze_patterns_with_llm(
+        &self,
+        memories: &[MemoryEntryForAnalysis],
+        driver: &Arc<dyn LlmDriver>,
+    ) -> Result<Vec<PatternObservation>, String> {
+        if memories.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Build memory summary for the prompt
+        let memory_summary: String = memories.iter().enumerate().map(|(i, m)| {
+            format!("{}. [{}] (重要性:{}, 访问:{}) {}",
+                i + 1, m.memory_type, m.importance, m.access_count, m.content)
+        }).collect::<Vec<_>>().join("\n");
+
+        let system_prompt = r#"你是行为分析专家。分析以下 Agent 记忆条目，识别行为模式和趋势。
+
+请返回 JSON 数组，每个元素包含：
+- "observation": string — 模式描述（中文）
+- "frequency": number — 该模式出现的频率估计（1-10）
+- "sentiment": "positive" | "negative" | "neutral" — 情感倾向
+- "evidence": string[] — 支持该观察的证据（记忆内容摘要，最多3条）
+
+只返回 JSON 数组，不要其他内容。如果没有明显模式，返回空数组。"#
+            .to_string();
+
+        let request = CompletionRequest {
+            model: driver.provider().to_string(),
+            system: Some(system_prompt),
+            messages: vec![zclaw_types::Message::assistant(
+                format!("分析以下记忆条目：\n\n{}", memory_summary)
+            )],
+            max_tokens: Some(2048),
+            temperature: Some(0.3),
+            stream: false,
+            ..Default::default()
+        };
+
+        let response = driver.complete(request).await
+            .map_err(|e| format!("LLM 调用失败: {}", e))?;
+
+        // Extract text from response
+        let text = response.content.iter()
+            .filter_map(|block| match block {
+                ContentBlock::Text { text } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("");
+
+        // Parse JSON response (handle markdown code blocks)
+        let json_str = extract_json_from_llm_response(&text);
+
+        serde_json::from_str::<Vec<PatternObservation>>(&json_str)
+            .map_err(|e| format!("解析 LLM 响应失败: {} — 原始响应: {}", e, &text[..text.len().min(200)]))
+    }
+
+    /// Analyze patterns in memories (rule-based fallback)
     fn analyze_patterns(&self, memories: &[MemoryEntryForAnalysis]) -> Vec<PatternObservation> {
         let mut patterns = Vec::new();
 
@@ -633,7 +719,6 @@ pub fn pop_restored_result(agent_id: &str) -> Option<ReflectionResult> {
 
 // === Tauri Commands ===
 
-use std::sync::Arc;
 use tokio::sync::Mutex;
 
 pub type ReflectionEngineState = Arc<Mutex<ReflectionEngine>>;
@@ -679,7 +764,7 @@ pub async fn reflection_reflect(
     state: tauri::State<'_, ReflectionEngineState>,
 ) -> Result<ReflectionResult, String> {
     let mut engine = state.lock().await;
-    Ok(engine.reflect(&agent_id, &memories))
+    Ok(engine.reflect(&agent_id, &memories, None).await)
 }
 
 /// Get reflection history
@@ -785,3 +870,28 @@ mod tests {
         assert!(!patterns.iter().any(|p| p.observation.contains("待办任务")));
     }
 }
+
+// === Helpers ===
+
+/// Extract JSON from LLM response, handling markdown code blocks and extra text
+fn extract_json_from_llm_response(text: &str) -> String {
+    let trimmed = text.trim();
+
+    // Try to find JSON array in markdown code block
+    if let Some(start) = trimmed.find("```json") {
+        if let Some(content_start) = trimmed[start..].find('\n') {
+            if let Some(end) = trimmed[content_start..].find("```") {
+                return trimmed[content_start + 1..content_start + end].trim().to_string();
+            }
+        }
+    }
+
+    // Try to find bare JSON array
+    if let Some(start) = trimmed.find('[') {
+        if let Some(end) = trimmed.rfind(']') {
+            return trimmed[start..end + 1].to_string();
+        }
+    }
+
+    trimmed.to_string()
+}

desktop/src-tauri/src/intelligence_hooks.rs

@@ -7,9 +7,12 @@
 
 use tracing::debug;
 
+use std::sync::Arc;
+
 use crate::intelligence::identity::IdentityManagerState;
 use crate::intelligence::heartbeat::HeartbeatEngineState;
 use crate::intelligence::reflection::{MemoryEntryForAnalysis, ReflectionEngineState};
+use zclaw_runtime::driver::LlmDriver;
 
 /// Run pre-conversation intelligence hooks
 ///
@@ -43,6 +46,7 @@ pub async fn post_conversation_hook(
     _user_message: &str,
     _heartbeat_state: &HeartbeatEngineState,
     reflection_state: &ReflectionEngineState,
+    llm_driver: Option<Arc<dyn LlmDriver>>,
 ) {
     // Step 1: Record interaction for heartbeat
     crate::intelligence::heartbeat::record_interaction(agent_id);
@@ -80,7 +84,7 @@ pub async fn post_conversation_hook(
             memories.len()
         );
 
-        let reflection_result = engine.reflect(agent_id, &memories);
+        let reflection_result = engine.reflect(agent_id, &memories, llm_driver.clone()).await;
         debug!(
             "[intelligence_hooks] Reflection completed: {} patterns, {} suggestions",
             reflection_result.patterns.len(),

desktop/src-tauri/src/kernel_commands.rs

@@ -442,17 +442,21 @@ pub async fn agent_chat_stream(
     ).await.unwrap_or_default();
 
     // Get the streaming receiver while holding the lock, then release it
-    let mut rx = {
+    let (mut rx, llm_driver) = {
         let kernel_lock = state.lock().await;
         let kernel = kernel_lock.as_ref()
             .ok_or_else(|| "Kernel not initialized. Call kernel_init first.".to_string())?;
 
+        // Clone LLM driver for reflection engine (Arc clone is cheap)
+        let driver = Some(kernel.driver());
+
         // Start the stream - this spawns a background task
         // Use intelligence-enhanced system prompt if available
         let prompt_arg = if enhanced_prompt.is_empty() { None } else { Some(enhanced_prompt) };
-        kernel.send_message_stream_with_prompt(&id, message.clone(), prompt_arg)
+        let rx = kernel.send_message_stream_with_prompt(&id, message.clone(), prompt_arg)
             .await
-            .map_err(|e| format!("Failed to start streaming: {}", e))?
+            .map_err(|e| format!("Failed to start streaming: {}", e))?;
+        (rx, driver)
     };
     // Lock is released here
 
@@ -492,7 +496,7 @@ pub async fn agent_chat_stream(
 
                     // POST-CONVERSATION: record interaction + trigger reflection
                     crate::intelligence_hooks::post_conversation_hook(
-                        &agent_id_str, &message, &hb_state, &rf_state,
+                        &agent_id_str, &message, &hb_state, &rf_state, llm_driver.clone(),
                     ).await;
 
                     StreamChatEvent::Complete {

desktop/src-tauri/src/pipeline_commands.rs

@@ -763,6 +763,7 @@ pub struct PipelineCandidateInfo {
 #[tauri::command]
 pub async fn route_intent(
     state: State<'_, Arc<PipelineState>>,
+    kernel_state: State<'_, KernelState>,
     user_input: String,
 ) -> Result<RouteResultResponse, String> {
     use zclaw_pipeline::{TriggerParser, Trigger, TriggerParam, compile_trigger};
@@ -859,6 +860,54 @@ pub async fn route_intent(
         });
     }
 
+    // Semantic match via LLM (if kernel is initialized)
+    let triggers = parser.triggers();
+    if !triggers.is_empty() {
+        let llm_driver = {
+            let kernel_lock = kernel_state.lock().await;
+            kernel_lock.as_ref().map(|k| k.driver())
+        };
+
+        if let Some(driver) = llm_driver {
+            use zclaw_pipeline::{RuntimeLlmIntentDriver, LlmIntentDriver};
+            let intent_driver = RuntimeLlmIntentDriver::new(driver);
+
+            if let Some(result) = intent_driver.semantic_match(&user_input, &triggers).await {
+                tracing::debug!(
+                    "[route_intent] Semantic match: pipeline={}, confidence={}",
+                    result.pipeline_id, result.confidence
+                );
+
+                let trigger = parser.get_trigger(&result.pipeline_id);
+                let mode = "auto".to_string();
+
+                let missing_params: Vec<MissingParamInfo> = trigger
+                    .map(|t| {
+                        t.param_defs.iter()
+                            .filter(|p| p.required && !result.params.contains_key(&p.name) && p.default.is_none())
+                            .map(|p| MissingParamInfo {
+                                name: p.name.clone(),
+                                label: p.label.clone(),
+                                param_type: p.param_type.clone(),
+                                required: p.required,
+                                default: p.default.clone(),
+                            })
+                            .collect()
+                    })
+                    .unwrap_or_default();
+
+                return Ok(RouteResultResponse::Matched {
+                    pipeline_id: result.pipeline_id,
+                    display_name: trigger.and_then(|t| t.display_name.clone()),
+                    mode,
+                    params: result.params,
+                    confidence: result.confidence,
+                    missing_params,
+                });
+            }
+        }
+    }
+
     // No match - return suggestions
     let suggestions: Vec<PipelineCandidateInfo> = parser.triggers()
         .iter()

docs/features/DEEP_AUDIT_REPORT.md

@@ -571,7 +571,10 @@ ZCLAW 的核心架构（通信、状态管理、安全认证、聊天、Agent
 13. ~~**反思历史只存单条**~~ ✅ 已修复 — 累积存储到 reflection:history 数组
 14. ~~**身份回滚 UI 缺失**~~ ✅ 已实现 — IdentityChangeProposal.tsx HistoryItem
 15. **28 处 dead_code 标注**中大部分是合理的预留功能，少数是遗留代码
-16. **剩余 P2/P3 项**: 反思 LLM 分析、语义路由、Pipeline 并行等
+16. ~~**剩余 P2/P3 项**: 反思 LLM 分析、语义路由、Pipeline 并行等~~ ✅ 已修复 — 见下方 18-20
 17. ~~**消息搜索仅当前会话**~~ ✅ 已修复 — MessageSearch 新增 Global 模式，调用 VikingStorage memory_search 跨会话搜索记忆
+18. ~~**反思引擎规则升级为 LLM**~~ ✅ 已修复 — `analyze_patterns_with_llm()` 调用 LLM 做深度行为分析，失败回退规则
+19. ~~**语义路由是桩代码**~~ ✅ 已修复 — `RuntimeLlmIntentDriver` 包装 LlmDriver 实现真实语义匹配
+20. ~~**Pipeline 并行执行实际串行**~~ ✅ 已修复 — `execute_parallel()` 改用 `buffer_unordered(max_workers)` 真正并行
 
-**累计修复 23 项** (P0×3 + P1×8 + P2×7 + 误判×2 + 审计×3)，系统真实可用率从 ~50% 提升到 ~80%。剩余 P3 项为增强功能，不阻塞核心使用。
+**累计修复 27 项** (P0×3 + P1×8 + P2×7 + P3×4 + 误判×2 + 审计×3)，系统真实可用率从 ~50% 提升到 ~85%。剩余项为长期增强功能，不阻塞核心使用。

docs/features/README.md

@@ -3,10 +3,10 @@
 > **版本**: v0.6.4
 > **更新日期**: 2026-03-27
 > **项目状态**: 完整 Rust Workspace 架构，10 个核心 Crates，69 技能，Pipeline DSL + Smart Presentation + Agent Growth System
-> **整体完成度**: ~72% (基于 2026-03-27 深度审计 + 四轮修复后)
+> **整体完成度**: ~78% (基于 2026-03-27 深度审计 + 五轮修复后)
 > **架构**: Tauri 桌面应用，Rust Workspace (10 crates) + React 前端
 >
-> **审计修复 (2026-03-27)**: 累计修复 23 项 (P0×3 + P1×8 + P2×7 + 误判×2 + 审计×3)，详见 [DEEP_AUDIT_REPORT.md](./DEEP_AUDIT_REPORT.md)
+> **审计修复 (2026-03-27)**: 累计修复 27 项 (P0×3 + P1×8 + P2×7 + P3×4 + 误判×2 + 审计×3)，详见 [DEEP_AUDIT_REPORT.md](./DEEP_AUDIT_REPORT.md)
 
 > **重要**: ZCLAW 采用 Rust Workspace 架构，包含 10 个分层 Crates (types → memory → runtime → kernel → skills/hands/protocols/pipeline/growth/channels)，所有核心能力集成在 Tauri 桌面应用中
 
@@ -145,7 +145,7 @@
 | S7 | Compactor 接入聊天流程 | P1 | ✅ 完成 |
 | S8 | 定时任务 KernelClient 支持 | P1 | 待开始 |
 | S9 | 添加消息搜索功能 | P1 | ✅ 完成 (Session + Global 双模式) |
-| S10 | 优化错误提示 | P1 | 待开始 |
+| S10 | 优化错误提示 | P1 | ✅ 完成 (Rust 错误提示中文化) |
 
 ### 2.2 中期计划 (1-2 月)