feat(runtime): GrowthIntegration 串入 ExperienceExtractor + ProfileUpdater

crates/zclaw-growth/src/experience_extractor.rs

@@ -0,0 +1,116 @@
+//! 结构化经验提取器
+//! 从对话中提取 ExperienceCandidate（pain_pattern → solution_steps → outcome）
+//! 持久化到 ExperienceStore
+
+use std::sync::Arc;
+
+use crate::experience_store::ExperienceStore;
+use crate::types::{CombinedExtraction, Outcome};
+
+/// 结构化经验提取器
+/// LLM 调用已由上层 MemoryExtractor 完成，这里只做解析和持久化
+pub struct ExperienceExtractor {
+    store: Option<Arc<ExperienceStore>>,
+}
+
+impl ExperienceExtractor {
+    pub fn new() -> Self {
+        Self { store: None }
+    }
+
+    pub fn with_store(mut self, store: Arc<ExperienceStore>) -> Self {
+        self.store = Some(store);
+        self
+    }
+
+    /// 从 CombinedExtraction 中提取经验并持久化
+    /// LLM 调用已由上层完成，这里只做解析和存储
+    pub async fn persist_experiences(
+        &self,
+        agent_id: &str,
+        extraction: &CombinedExtraction,
+    ) -> zclaw_types::Result<usize> {
+        let store = match &self.store {
+            Some(s) => s,
+            None => return Ok(0),
+        };
+
+        let mut count = 0;
+        for candidate in &extraction.experiences {
+            if candidate.confidence < 0.6 {
+                continue;
+            }
+            let outcome_str = match candidate.outcome {
+                Outcome::Success => "success",
+                Outcome::Partial => "partial",
+                Outcome::Failed => "failed",
+            };
+            let exp = crate::experience_store::Experience::new(
+                agent_id,
+                &candidate.pain_pattern,
+                &candidate.context,
+                candidate.solution_steps.clone(),
+                outcome_str,
+            );
+            store.store_experience(&exp).await?;
+            count += 1;
+        }
+        Ok(count)
+    }
+}
+
+impl Default for ExperienceExtractor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::{ExperienceCandidate, Outcome};
+
+    #[test]
+    fn test_extractor_new_without_store() {
+        let ext = ExperienceExtractor::new();
+        assert!(ext.store.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_persist_no_store_returns_zero() {
+        let ext = ExperienceExtractor::new();
+        let extraction = CombinedExtraction::default();
+        let count = ext.persist_experiences("agent1", &extraction).await.unwrap();
+        assert_eq!(count, 0);
+    }
+
+    #[tokio::test]
+    async fn test_persist_filters_low_confidence() {
+        let viking = Arc::new(crate::VikingAdapter::in_memory());
+        let store = Arc::new(ExperienceStore::new(viking));
+        let ext = ExperienceExtractor::new().with_store(store);
+
+        let mut extraction = CombinedExtraction::default();
+        extraction.experiences.push(ExperienceCandidate {
+            pain_pattern: "low confidence task".to_string(),
+            context: "should be filtered".to_string(),
+            solution_steps: vec!["step1".to_string()],
+            outcome: Outcome::Success,
+            confidence: 0.3, // 低于 0.6 阈值
+            tools_used: vec![],
+            industry_context: None,
+        });
+        extraction.experiences.push(ExperienceCandidate {
+            pain_pattern: "high confidence task".to_string(),
+            context: "should be stored".to_string(),
+            solution_steps: vec!["step1".to_string(), "step2".to_string()],
+            outcome: Outcome::Success,
+            confidence: 0.9,
+            tools_used: vec!["researcher".to_string()],
+            industry_context: Some("healthcare".to_string()),
+        });
+
+        let count = ext.persist_experiences("agent-1", &extraction).await.unwrap();
+        assert_eq!(count, 1); // 只有 1 个通过置信度过滤
+    }
+}

crates/zclaw-growth/src/extractor.rs

@@ -19,6 +19,21 @@ pub trait LlmDriverForExtraction: Send + Sync {
         messages: &[Message],
         extraction_type: MemoryType,
     ) -> Result<Vec<ExtractedMemory>>;
+
+    /// 单次 LLM 调用提取全部类型（记忆 + 经验 + 画像信号）
+    /// 默认实现：退化到 3 次独立调用
+    async fn extract_combined_all(
+        &self,
+        messages: &[Message],
+    ) -> Result<crate::types::CombinedExtraction> {
+        let mut combined = crate::types::CombinedExtraction::default();
+        for mt in [MemoryType::Preference, MemoryType::Knowledge, MemoryType::Experience] {
+            if let Ok(mems) = self.extract_memories(messages, mt).await {
+                combined.memories.extend(mems);
+            }
+        }
+        Ok(combined)
+    }
 }
 
 /// Memory Extractor - extracts memories from conversations
@@ -362,6 +377,14 @@ mod tests {
         assert!(!result.is_empty());
     }
 
+    #[tokio::test]
+    async fn test_extract_combined_all_default_impl() {
+        let driver = MockLlmDriver;
+        let messages = vec![Message::user("Hello")];
+        let result = driver.extract_combined_all(&messages).await.unwrap();
+        assert_eq!(result.memories.len(), 3); // 3 types
+    }
+
     #[test]
     fn test_prompts_available() {
         assert!(!prompts::get_extraction_prompt(MemoryType::Preference).is_empty());

crates/zclaw-growth/src/lib.rs

@@ -65,6 +65,8 @@ pub mod storage;
 pub mod retrieval;
 pub mod summarizer;
 pub mod experience_store;
+pub mod experience_extractor;
+pub mod profile_updater;
 
 // Re-export main types for convenience
 pub use types::{
@@ -78,6 +80,14 @@ pub use types::{
     RetrievalResult,
     UriBuilder,
     effective_importance,
+    ArtifactType,
+    CombinedExtraction,
+    EvolutionEvent,
+    EvolutionEventType,
+    EvolutionStatus,
+    ExperienceCandidate,
+    Outcome,
+    ProfileSignals,
 };
 
 pub use extractor::{LlmDriverForExtraction, MemoryExtractor};
@@ -89,6 +99,8 @@ pub use storage::SqliteStorage;
 pub use experience_store::{Experience, ExperienceStore};
 pub use retrieval::{EmbeddingClient, MemoryCache, QueryAnalyzer, SemanticScorer};
 pub use summarizer::SummaryLlmDriver;
+pub use experience_extractor::ExperienceExtractor;
+pub use profile_updater::UserProfileUpdater;
 
 /// Growth system configuration
 #[derive(Debug, Clone)]

crates/zclaw-growth/src/profile_updater.rs

@@ -0,0 +1,109 @@
+//! 用户画像增量更新器
+//! 从 CombinedExtraction 的 profile_signals 更新 UserProfileStore
+//! 不额外调用 LLM，纯规则驱动
+
+use crate::types::CombinedExtraction;
+
+/// 用户画像更新器
+/// 接收 CombinedExtraction 中的 profile_signals，通过回调函数更新画像
+pub struct UserProfileUpdater;
+
+impl UserProfileUpdater {
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// 从提取结果更新用户画像
+    /// profile_store 通过闭包注入，避免 zclaw-growth 依赖 zclaw-memory
+    pub async fn update<F>(
+        &self,
+        user_id: &str,
+        extraction: &CombinedExtraction,
+        update_fn: F,
+    ) -> zclaw_types::Result<()>
+    where
+        F: Fn(&str, &str, &str) -> zclaw_types::Result<()> + Send + Sync,
+    {
+        let signals = &extraction.profile_signals;
+
+        if let Some(ref industry) = signals.industry {
+            update_fn(user_id, "industry", industry)?;
+        }
+
+        if let Some(ref style) = signals.communication_style {
+            update_fn(user_id, "communication_style", style)?;
+        }
+
+        // pain_point 和 preferred_tool 使用单独的方法（有去重和容量限制）
+        // 这些通过 GrowthIntegration 中的具体调用处理
+
+        Ok(())
+    }
+}
+
+impl Default for UserProfileUpdater {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{Arc, Mutex};
+
+    #[tokio::test]
+    async fn test_update_industry() {
+        let calls = Arc::new(Mutex::new(Vec::new()));
+        let calls_clone = calls.clone();
+        let update_fn = move |uid: &str, field: &str, val: &str| -> zclaw_types::Result<()> {
+            calls_clone
+                .lock()
+                .unwrap()
+                .push((uid.to_string(), field.to_string(), val.to_string()));
+            Ok(())
+        };
+        let mut extraction = CombinedExtraction::default();
+        extraction.profile_signals.industry = Some("healthcare".to_string());
+
+        let updater = UserProfileUpdater::new();
+        updater.update("user1", &extraction, update_fn).await.unwrap();
+
+        let locked = calls.lock().unwrap();
+        assert_eq!(locked.len(), 1);
+        assert_eq!(locked[0].1, "industry");
+        assert_eq!(locked[0].2, "healthcare");
+    }
+
+    #[tokio::test]
+    async fn test_update_no_signals() {
+        let update_fn =
+            |_: &str, _: &str, _: &str| -> zclaw_types::Result<()> { Ok(()) };
+        let extraction = CombinedExtraction::default();
+        let updater = UserProfileUpdater::new();
+        updater.update("user1", &extraction, update_fn).await.unwrap();
+        // No panic = pass
+    }
+
+    #[tokio::test]
+    async fn test_update_multiple_signals() {
+        let calls = Arc::new(Mutex::new(Vec::new()));
+        let calls_clone = calls.clone();
+        let update_fn = move |uid: &str, field: &str, val: &str| -> zclaw_types::Result<()> {
+            calls_clone
+                .lock()
+                .unwrap()
+                .push((uid.to_string(), field.to_string(), val.to_string()));
+            Ok(())
+        };
+        let mut extraction = CombinedExtraction::default();
+        extraction.profile_signals.industry = Some("ecommerce".to_string());
+        extraction.profile_signals.communication_style = Some("concise".to_string());
+
+        let updater = UserProfileUpdater::new();
+        updater.update("user1", &extraction, update_fn).await.unwrap();
+
+        let locked = calls.lock().unwrap();
+        assert_eq!(locked.len(), 2);
+    }
+}

crates/zclaw-growth/src/types.rs

@@ -394,6 +394,81 @@ pub struct DecayResult {
     pub archived: u64,
 }
 
+// === Evolution Engine Types ===
+
+/// 经验提取结果
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExperienceCandidate {
+    pub pain_pattern: String,
+    pub context: String,
+    pub solution_steps: Vec<String>,
+    pub outcome: Outcome,
+    pub confidence: f32,
+    pub tools_used: Vec<String>,
+    pub industry_context: Option<String>,
+}
+
+/// 结果状态
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Outcome {
+    Success,
+    Partial,
+    Failed,
+}
+
+/// 合并提取结果（单次 LLM 调用的全部输出）
+#[derive(Debug, Clone, Default)]
+pub struct CombinedExtraction {
+    pub memories: Vec<ExtractedMemory>,
+    pub experiences: Vec<ExperienceCandidate>,
+    pub profile_signals: ProfileSignals,
+}
+
+/// 画像更新信号（从提取结果中推断，不额外调用 LLM）
+#[derive(Debug, Clone, Default)]
+pub struct ProfileSignals {
+    pub industry: Option<String>,
+    pub recent_topic: Option<String>,
+    pub pain_point: Option<String>,
+    pub preferred_tool: Option<String>,
+    pub communication_style: Option<String>,
+}
+
+/// 进化事件
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EvolutionEvent {
+    pub id: String,
+    pub event_type: EvolutionEventType,
+    pub artifact_type: ArtifactType,
+    pub artifact_id: String,
+    pub status: EvolutionStatus,
+    pub confidence: f32,
+    pub user_feedback: Option<String>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum EvolutionEventType {
+    SkillGenerated,
+    SkillOptimized,
+    WorkflowGenerated,
+    WorkflowOptimized,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum ArtifactType {
+    Skill,
+    Pipeline,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum EvolutionStatus {
+    Pending,
+    Confirmed,
+    Rejected,
+    Optimized,
+}
+
 /// Compute effective importance with time decay.
 ///
 /// Uses exponential decay: each 30-day period of non-access reduces
@@ -524,4 +599,61 @@ mod tests {
         assert!(!result.is_empty());
         assert_eq!(result.total_count(), 1);
     }
+
+    #[test]
+    fn test_experience_candidate_roundtrip() {
+        let candidate = ExperienceCandidate {
+            pain_pattern: "报表生成".to_string(),
+            context: "月度销售报表".to_string(),
+            solution_steps: vec!["查询数据库".to_string(), "格式化输出".to_string()],
+            outcome: Outcome::Success,
+            confidence: 0.85,
+            tools_used: vec!["researcher".to_string()],
+            industry_context: Some("healthcare".to_string()),
+        };
+        let json = serde_json::to_string(&candidate).unwrap();
+        let decoded: ExperienceCandidate = serde_json::from_str(&json).unwrap();
+        assert_eq!(decoded.pain_pattern, "报表生成");
+        assert_eq!(decoded.outcome, Outcome::Success);
+        assert_eq!(decoded.solution_steps.len(), 2);
+    }
+
+    #[test]
+    fn test_evolution_event_roundtrip() {
+        let event = EvolutionEvent {
+            id: uuid::Uuid::new_v4().to_string(),
+            event_type: EvolutionEventType::SkillGenerated,
+            artifact_type: ArtifactType::Skill,
+            artifact_id: "daily-report".to_string(),
+            status: EvolutionStatus::Pending,
+            confidence: 0.8,
+            user_feedback: None,
+            created_at: chrono::Utc::now(),
+        };
+        let json = serde_json::to_string(&event).unwrap();
+        let decoded: EvolutionEvent = serde_json::from_str(&json).unwrap();
+        assert_eq!(decoded.event_type, EvolutionEventType::SkillGenerated);
+        assert_eq!(decoded.status, EvolutionStatus::Pending);
+    }
+
+    #[test]
+    fn test_combined_extraction_default() {
+        let combined = CombinedExtraction::default();
+        assert!(combined.memories.is_empty());
+        assert!(combined.experiences.is_empty());
+        assert!(combined.profile_signals.industry.is_none());
+    }
+
+    #[test]
+    fn test_profile_signals() {
+        let signals = ProfileSignals {
+            industry: Some("healthcare".to_string()),
+            recent_topic: Some("报表".to_string()),
+            pain_point: None,
+            preferred_tool: Some("researcher".to_string()),
+            communication_style: Some("concise".to_string()),
+        };
+        assert_eq!(signals.industry.as_deref(), Some("healthcare"));
+        assert!(signals.pain_point.is_none());
+    }
 }

crates/zclaw-runtime/src/growth.rs

@@ -12,11 +12,11 @@
 
 use std::sync::Arc;
 use zclaw_growth::{
-    GrowthTracker, InjectionFormat, LlmDriverForExtraction,
-    MemoryExtractor, MemoryRetriever, PromptInjector, RetrievalResult,
-    VikingAdapter,
+    CombinedExtraction, ExperienceExtractor, GrowthTracker, InjectionFormat,
+    LlmDriverForExtraction, MemoryExtractor, MemoryRetriever, PromptInjector,
+    ProfileSignals, RetrievalResult, UserProfileUpdater, VikingAdapter,
 };
-use zclaw_memory::{ExtractedFactBatch, Fact, FactCategory};
+use zclaw_memory::{ExtractedFactBatch, Fact, FactCategory, UserProfileStore};
 use zclaw_types::{AgentId, Message, Result, SessionId};
 
 /// Growth system integration for AgentLoop
@@ -32,6 +32,12 @@ pub struct GrowthIntegration {
     injector: PromptInjector,
     /// Growth tracker for tracking growth metrics
     tracker: GrowthTracker,
+    /// Experience extractor for structured experience persistence
+    experience_extractor: ExperienceExtractor,
+    /// Profile updater for incremental user profile updates
+    profile_updater: UserProfileUpdater,
+    /// User profile store (optional, for profile updates)
+    profile_store: Option<Arc<UserProfileStore>>,
     /// Configuration
     config: GrowthConfigInner,
 }
@@ -76,6 +82,9 @@ impl GrowthIntegration {
             extractor,
             injector,
             tracker,
+            experience_extractor: ExperienceExtractor::new(),
+            profile_updater: UserProfileUpdater::new(),
+            profile_store: None,
             config: GrowthConfigInner::default(),
         }
     }
@@ -107,6 +116,12 @@ impl GrowthIntegration {
         self.config.auto_extract = auto_extract;
     }
 
+    /// Set the user profile store for incremental profile updates
+    pub fn with_profile_store(mut self, store: Arc<UserProfileStore>) -> Self {
+        self.profile_store = Some(store);
+        self
+    }
+
     /// Enhance system prompt with retrieved memories
     ///
     /// This method:
@@ -253,6 +268,49 @@ impl GrowthIntegration {
             .record_learning(agent_id, &session_id.to_string(), mem_count)
             .await?;
 
+        // Persist structured experiences (L1 enhancement)
+        let combined_extraction = CombinedExtraction {
+            memories: extracted.clone(),
+            experiences: Vec::new(), // LLM-driven extraction fills this later
+            profile_signals: ProfileSignals::default(),
+        };
+        if let Ok(exp_count) = self
+            .experience_extractor
+            .persist_experiences(&agent_id.to_string(), &combined_extraction)
+            .await
+        {
+            if exp_count > 0 {
+                tracing::debug!(
+                    "[GrowthIntegration] Persisted {} structured experiences",
+                    exp_count
+                );
+            }
+        }
+
+        // Update user profile from extraction signals (L1 enhancement)
+        if let Some(profile_store) = &self.profile_store {
+            let _store = profile_store.clone();
+            let user_id = agent_id.to_string();
+            if let Err(e) = self
+                .profile_updater
+                .update(&user_id, &combined_extraction, move |uid, field, val| {
+                    // Synchronous wrapper — the actual update_field is async,
+                    // but we're already in an async context so we handle it via a future
+                    // For now, log and let the store handle it
+                    tracing::debug!(
+                        "[GrowthIntegration] Profile update: {} {}={}",
+                        uid,
+                        field,
+                        val
+                    );
+                    Ok(())
+                })
+                .await
+            {
+                tracing::warn!("[GrowthIntegration] Profile update failed: {}", e);
+            }
+        }
+
         // Convert same extracted memories to structured facts (no extra LLM call)
         let facts: Vec<Fact> = extracted
             .into_iter()