Deploy Poimen Memory K8s cluster with ArgoCD tracking (M2.2, M3.5-M3.7)

crates/mem-store/src/rebuild.rs

@@ -0,0 +1,80 @@
+use crate::EventRecord;
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+/// Deterministic rebuild state from JSONL event log.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RebuildState {
+    pub memories: BTreeMap<String, String>,  // query_id -> final_memory
+    pub event_count: u32,
+    pub chunks_seen: u32,
+    pub chunks_used: u32,
+}
+
+impl RebuildState {
+    /// Rebuild from event records (must be deterministic).
+    pub fn from_events(events: &[EventRecord]) -> Result<Self> {
+        let mut memories = BTreeMap::new();
+        let mut chunks_seen = 0;
+        let mut chunks_used = 0;
+        
+        // Group events by query
+        let mut by_query: BTreeMap<String, Vec<&EventRecord>> = BTreeMap::new();
+        for event in events {
+            by_query.entry(event.query.clone()).or_insert_with(Vec::new).push(event);
+        }
+        
+        // Replay events for each query
+        for (query_id, query_events) in by_query {
+            let memory = String::new();
+            let mut q_seen = 0;
+            let mut q_used = 0;
+            
+            for event in query_events {
+                // Parse event_type (very simplified)
+                if event.event_type.contains("Memory") {
+                    // Would parse the actual memory update from data
+                    // For now: assume memory doesn't change without update
+                }
+                if event.event_type.contains("Evidence") {
+                    q_used += 1;
+                }
+                if event.event_type.contains("Gate") {
+                    q_seen += 1;
+                }
+            }
+            
+            memories.insert(query_id, memory);
+            chunks_seen += q_seen;
+            chunks_used += q_used;
+        }
+        
+        Ok(Self {
+            memories,
+            event_count: events.len() as u32,
+            chunks_seen,
+            chunks_used,
+        })
+    }
+    
+    /// Serialize to JSONL (must match original byte-for-byte).
+    pub fn to_events(&self) -> Vec<EventRecord> {
+        // This is a placeholder - real rebuild would deserialize the exact events
+        // The key is that deserialization + re-serialization produces identical bytes
+        vec![]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    
+    #[test]
+    fn test_rebuild_empty() {
+        let events = vec![];
+        let state = RebuildState::from_events(&events).unwrap();
+        assert_eq!(state.event_count, 0);
+    }
+}