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

crates/mem-store/src/event_log.rs

@@ -0,0 +1,54 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::fs::{create_dir_all, OpenOptions};
+use std::io::Write;
+use std::path::PathBuf;
+
+/// JSONL event record.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct EventRecord {
+    pub project: String,
+    pub query: String,
+    pub run: String,
+    pub turn: u32,
+    pub event_type: String,
+    pub data: serde_json::Value,
+}
+
+/// Event log writer.
+pub struct LogWriter {
+    path: PathBuf,
+}
+
+impl LogWriter {
+    /// Open or create log file.
+    pub fn new(project: &str, query: &str, run: &str) -> Result<Self> {
+        let dir = PathBuf::from(format!("log/{}/{}", project, query));
+        create_dir_all(&dir)?;
+        Ok(Self {
+            path: dir.join(format!("{}.jsonl", run)),
+        })
+    }
+
+    /// Append event to log.
+    pub fn log(&mut self, record: EventRecord) -> Result<()> {
+        let mut file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.path)?;
+        
+        serde_json::to_writer(&mut file, &record)?;
+        file.write_all(b"\n")?;
+        Ok(())
+    }
+
+    /// Read all events from log.
+    pub fn read_all(&self) -> Result<Vec<EventRecord>> {
+        let contents = std::fs::read_to_string(&self.path)?;
+        contents
+            .lines()
+            .filter(|line| !line.is_empty())
+            .map(|line| serde_json::from_str(line).map_err(|e| anyhow::anyhow!("Parse error: {}", e)))
+            .collect()
+    }
+}

crates/mem-store/src/lib.rs

@@ -1 +1,11 @@
-pub mod placeholder {}
+pub mod event_log;
+pub mod pgvector;
+pub mod rebuild;
+pub mod pg_repo;
+pub mod obsidian;
+
+pub use event_log::{EventRecord, LogWriter};
+pub use pgvector::{VectorRecord, VectorStore};
+pub use rebuild::RebuildState;
+pub use pg_repo::{PgRepo, MemoryNode, VectorKind, Level, ScoredNode};
+pub use obsidian::ObsidianProjector;

crates/mem-store/src/obsidian.rs

@@ -0,0 +1,193 @@
+use crate::EventRecord;
+use anyhow::Result;
+use std::collections::{BTreeMap, HashMap};
+use std::fs;
+
+/// Obsidian vault projector (deterministic, byte-identical).
+pub struct ObsidianProjector {
+    vault_dir: String,
+    _emit_evidence: bool,
+}
+
+/// Vault note metadata (stable frontmatter order).
+#[derive(Debug, Clone)]
+pub struct VaultNote {
+    pub project: String,
+    pub level: String,
+    pub query_id: Option<String>,
+    pub updated: String,
+    pub chunks_seen: u32,
+    pub chunks_used: u32,
+    pub run_id: String,
+    pub body: String,
+    pub parents: Vec<(String, String)>,
+}
+
+impl ObsidianProjector {
+    /// Create projector.
+    pub fn new(_log_dir: &str, vault_dir: &str, emit_evidence: bool) -> Self {
+        Self {
+            vault_dir: vault_dir.to_string(),
+            _emit_evidence: emit_evidence,
+        }
+    }
+
+    /// Project log to vault (deterministic).
+    pub fn project(&self, events: &[EventRecord]) -> Result<()> {
+        fs::create_dir_all(&self.vault_dir)?;
+
+        // Group by project and query
+        let mut by_project: HashMap<String, HashMap<String, Vec<&EventRecord>>> = HashMap::new();
+
+        for event in events {
+            by_project
+                .entry(event.project.clone())
+                .or_insert_with(HashMap::new)
+                .entry(event.query.clone())
+                .or_insert_with(Vec::new)
+                .push(event);
+        }
+
+        // Generate notes per project (in sorted order for determinism)
+        let mut sorted_projects: Vec<_> = by_project.iter().collect();
+        sorted_projects.sort_by_key(|(p, _)| p.as_str());
+
+        for (project, queries) in sorted_projects {
+            let proj_dir = format!("{}/{}", self.vault_dir, project);
+            fs::create_dir_all(&proj_dir)?;
+
+            // Generate index (L2)
+            let index_note = VaultNote {
+                project: project.clone(),
+                level: "L2".to_string(),
+                query_id: None,
+                updated: "2026-01-01".to_string(),
+                chunks_seen: 0,
+                chunks_used: 0,
+                run_id: "index".to_string(),
+                body: String::new(),
+                parents: vec![],
+            };
+            self.write_note(&proj_dir, "index", &index_note)?;
+
+            // Generate per-query notes (L1) in sorted order
+            let mut sorted_queries: Vec<_> = queries.iter().collect();
+            sorted_queries.sort_by_key(|(qid, _)| qid.as_str());
+
+            for (query_id, query_events) in sorted_queries {
+                let (chunks_seen, chunks_used, body, parents) =
+                    Self::summarize_query(query_events);
+
+                let note = VaultNote {
+                    project: project.clone(),
+                    level: "L1".to_string(),
+                    query_id: Some(query_id.to_string()),
+                    updated: "2026-01-01".to_string(),
+                    chunks_seen,
+                    chunks_used,
+                    run_id: "run1".to_string(),
+                    body,
+                    parents,
+                };
+
+                self.write_note(&proj_dir, query_id, &note)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Write note with deterministic formatting.
+    fn write_note(&self, dir: &str, name: &str, note: &VaultNote) -> Result<()> {
+        // Stable frontmatter order (BTreeMap keeps keys sorted)
+        let mut fm = BTreeMap::new();
+        fm.insert("chunks_seen", note.chunks_seen.to_string());
+        fm.insert("chunks_used", note.chunks_used.to_string());
+        fm.insert("level", note.level.clone());
+        fm.insert("project", note.project.clone());
+        if let Some(qid) = &note.query_id {
+            fm.insert("query_id", qid.clone());
+        }
+        fm.insert("run_id", note.run_id.clone());
+        fm.insert("updated", note.updated.clone());
+
+        // Build frontmatter
+        let mut content = String::from("---\n");
+        for (k, v) in fm.iter() {
+            content.push_str(&format!("{}: {}\n", k, v));
+        }
+        content.push_str("---\n");
+
+        // Title
+        let title = note.query_id.as_ref().unwrap_or(&note.project);
+        content.push_str(&format!("# {}\n\n", title));
+
+        // Body
+        if note.body.is_empty() {
+            content.push_str("No evidence found.\n\n");
+        } else {
+            content.push_str(&note.body);
+            if !note.body.ends_with('\n') {
+                content.push('\n');
+            }
+            content.push('\n');
+        }
+
+        // Provenance (sorted)
+        if !note.parents.is_empty() {
+            content.push_str("## Provenance\n");
+            let mut sorted_parents = note.parents.clone();
+            sorted_parents.sort();
+            for (source, time) in sorted_parents {
+                content.push_str(&format!("- [[{}-{}]]\n", source, time));
+            }
+        }
+
+        // Ensure exactly one trailing newline
+        if !content.ends_with('\n') {
+            content.push('\n');
+        }
+
+        // Write to file
+        let path = format!("{}/{}.md", dir, name);
+        fs::write(&path, &content)?;
+
+        Ok(())
+    }
+
+    /// Summarize query events.
+    fn summarize_query(
+        events: &[&EventRecord],
+    ) -> (u32, u32, String, Vec<(String, String)>) {
+        let mut chunks_seen = 0u32;
+        let mut chunks_used = 0u32;
+        let mut body = String::new();
+        let mut parents = Vec::new();
+
+        for event in events.iter() {
+            if event.event_type.contains("Gate") {
+                chunks_seen += 1;
+            }
+            if event.event_type.contains("Evidence") {
+                chunks_used += 1;
+            }
+            // Simplified parent extraction
+            if let Some(obj) = event.data.as_object() {
+                if let Some(parent) = obj.get("parent") {
+                    if let Some(s) = parent.as_str() {
+                        parents.push((s.to_string(), format!("t{}", event.turn)));
+                    }
+                }
+            }
+        }
+
+        if chunks_used > 0 {
+            body = format!(
+                "Extracted from {} chunks, using {}\n",
+                chunks_seen, chunks_used
+            );
+        }
+
+        (chunks_seen, chunks_used, body, parents)
+    }
+}

crates/mem-store/src/pg_repo.rs

@@ -0,0 +1,210 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+/// Vector kind (text or symptom).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum VectorKind {
+    Text,
+    Symptom,
+}
+
+impl std::fmt::Display for VectorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            VectorKind::Text => write!(f, "text"),
+            VectorKind::Symptom => write!(f, "symptom"),
+        }
+    }
+}
+
+/// Level (L0, L1, L2).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Level {
+    L0,
+    L1,
+    L2,
+}
+
+/// Memory node (idempotent upsert key: sha256).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryNode {
+    pub sha256: String,
+    pub level: Level,
+    pub project: String,
+    pub text: String,
+    pub tokens: u32,
+}
+
+/// Scored search result.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ScoredNode {
+    pub node: MemoryNode,
+    pub distance: f32,
+    pub matched_kind: VectorKind,
+}
+
+/// PostgreSQL repository (in-memory mock for now).
+pub struct PgRepo {
+    // Nodes by sha256
+    nodes: BTreeMap<String, MemoryNode>,
+    // Vectors by (sha256, kind)
+    vectors: BTreeMap<(String, VectorKind), Vec<f32>>,
+    // Parents edges: child_sha -> vec of parent_shas
+    edges: BTreeMap<String, Vec<String>>,
+}
+
+impl PgRepo {
+    /// Create new repo (mock, no real DB).
+    pub fn new() -> Self {
+        Self {
+            nodes: BTreeMap::new(),
+            vectors: BTreeMap::new(),
+            edges: BTreeMap::new(),
+        }
+    }
+
+    /// Upsert node (idempotent).
+    pub fn upsert_node(&mut self, node: &MemoryNode) -> Result<()> {
+        self.nodes.insert(node.sha256.clone(), node.clone());
+        Ok(())
+    }
+
+    /// Upsert many nodes (batching embedding calls).
+    pub fn upsert_many(&mut self, nodes: &[MemoryNode]) -> Result<()> {
+        for node in nodes {
+            self.upsert_node(node)?;
+        }
+        Ok(())
+    }
+
+    /// Upsert vector for node.
+    pub fn upsert_vector(&mut self, sha: &str, kind: VectorKind, embedding: &[f32]) -> Result<()> {
+        if !self.nodes.contains_key(sha) {
+            return Err(anyhow::anyhow!("Node {} not found", sha));
+        }
+        self.vectors.insert((sha.to_string(), kind), embedding.to_vec());
+        Ok(())
+    }
+
+    /// Insert edges (requires both endpoints exist).
+    pub fn insert_edges(&mut self, child: &str, parents: &[String]) -> Result<()> {
+        if !self.nodes.contains_key(child) {
+            return Err(anyhow::anyhow!("Child node {} not found", child));
+        }
+        for parent in parents {
+            if !self.nodes.contains_key(parent) {
+                return Err(anyhow::anyhow!("Parent node {} not found", parent));
+            }
+        }
+        self.edges.insert(child.to_string(), parents.to_vec());
+        Ok(())
+    }
+
+    /// Search by cosine distance.
+    pub fn search(
+        &self,
+        q: &[f32],
+        kind: VectorKind,
+        levels: &[Level],
+    ) -> Result<Vec<ScoredNode>> {
+        let mut results = Vec::new();
+
+        for ((sha, vkind), embedding) in &self.vectors {
+            if *vkind != kind {
+                continue;
+            }
+
+            if let Some(node) = self.nodes.get(sha) {
+                if !levels.contains(&node.level) {
+                    continue;
+                }
+
+                if let Some(dist) = cosine_distance(q, embedding) {
+                    results.push(ScoredNode {
+                        node: node.clone(),
+                        distance: dist,
+                        matched_kind: kind,
+                    });
+                }
+            }
+        }
+
+        // Sort by distance (ascending)
+        results.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
+        Ok(results)
+    }
+
+    /// Parents of node.
+    pub fn parents_of(&self, sha: &str) -> Result<Vec<MemoryNode>> {
+        let parent_shas = self.edges.get(sha).cloned().unwrap_or_default();
+        let parents: Vec<_> = parent_shas
+            .iter()
+            .filter_map(|p_sha| self.nodes.get(p_sha).cloned())
+            .collect();
+        Ok(parents)
+    }
+
+    /// Clear all nodes for project.
+    pub fn clear_project(&mut self, project: &str) -> Result<()> {
+        let nodes_to_remove: Vec<String> = self
+            .nodes
+            .iter()
+            .filter(|(_, n)| n.project == project)
+            .map(|(sha, _)| sha.clone())
+            .collect();
+
+        // Remove vectors
+        self.vectors.retain(|(sha, _), _| !nodes_to_remove.contains(sha));
+
+        // Remove edges
+        self.edges.retain(|child, _| !nodes_to_remove.contains(child));
+
+        // Remove nodes
+        self.nodes.retain(|sha, _| !nodes_to_remove.contains(sha));
+
+        Ok(())
+    }
+
+    /// Get all nodes.
+    pub fn all_nodes(&self) -> Vec<&MemoryNode> {
+        self.nodes.values().collect()
+    }
+
+    /// Verify: count upserted nodes.
+    pub fn node_count(&self) -> usize {
+        self.nodes.len()
+    }
+
+    /// Verify: count edges.
+    pub fn edge_count(&self) -> usize {
+        self.edges.len()
+    }
+}
+
+/// Cosine distance (1 - cosine_similarity).
+fn cosine_distance(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() || a.is_empty() {
+        return None;
+    }
+
+    let mut dot = 0.0;
+    let mut norm_a = 0.0;
+    let mut norm_b = 0.0;
+
+    for (x, y) in a.iter().zip(b.iter()) {
+        dot += x * y;
+        norm_a += x * x;
+        norm_b += y * y;
+    }
+
+    let norm_a = norm_a.sqrt();
+    let norm_b = norm_b.sqrt();
+
+    if norm_a == 0.0 || norm_b == 0.0 {
+        return None;
+    }
+
+    let similarity = dot / (norm_a * norm_b);
+    Some(1.0 - similarity)
+}

crates/mem-store/src/pgvector.rs

@@ -0,0 +1,81 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+/// Vector embedding record in pgvector.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VectorRecord {
+    pub id: String,
+    pub chunk_id: String,
+    pub kind: String,  // "text" | "symptom"
+    pub embedding: Vec<f32>,  // 768-dimensional for nomic
+    pub tokens: u32,
+}
+
+/// pgvector client.
+pub struct VectorStore {
+    // In production: PostgreSQL connection
+    // For now: in-memory vec
+    records: Vec<VectorRecord>,
+}
+
+impl VectorStore {
+    /// Create a new vector store.
+    pub fn new() -> Self {
+        Self {
+            records: Vec::new(),
+        }
+    }
+
+    /// Insert a vector record.
+    pub fn insert(&mut self, record: VectorRecord) -> Result<()> {
+        self.records.push(record);
+        Ok(())
+    }
+
+    /// Search by cosine similarity.
+    pub fn search(&self, query: &[f32], limit: usize, min_score: f32) -> Result<Vec<(String, f32)>> {
+        let mut results = Vec::new();
+        
+        for record in &self.records {
+            if let Some(score) = cosine_similarity(query, &record.embedding) {
+                if score >= min_score {
+                    results.push((record.id.clone(), score));
+                }
+            }
+        }
+        
+        results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+        Ok(results.into_iter().take(limit).collect())
+    }
+
+    /// Get all records.
+    pub fn all(&self) -> Vec<&VectorRecord> {
+        self.records.iter().collect()
+    }
+}
+
+/// Compute cosine similarity between two vectors.
+fn cosine_similarity(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() {
+        return None;
+    }
+    
+    let mut dot_product = 0.0;
+    let mut norm_a = 0.0;
+    let mut norm_b = 0.0;
+    
+    for (x, y) in a.iter().zip(b.iter()) {
+        dot_product += x * y;
+        norm_a += x * x;
+        norm_b += y * y;
+    }
+    
+    let norm_a = norm_a.sqrt();
+    let norm_b = norm_b.sqrt();
+    
+    if norm_a == 0.0 || norm_b == 0.0 {
+        return None;
+    }
+    
+    Some(dot_product / (norm_a * norm_b))
+}

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);
+    }
+}