hippocampus: move MemoryNode + store ops to where they belong

MemoryNode moved from agent/memory.rs to hippocampus/memory.rs — it's
a view over hippocampus data, not agent-specific.

Store operations (set_weight, set_link_strength, add_link) moved into
store/ops.rs. CLI code (cli/graph.rs, cli/node.rs) and agent tools
both call the same store methods now. render_node() delegates to
MemoryNode::from_store().render() — 3 lines instead of 40.

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

src/hippocampus/memory.rs

@@ -0,0 +1,144 @@
+// hippocampus/memory.rs — In-memory view of a graph node
+//
+// MemoryNode is a lightweight representation of a loaded node:
+// key, content, links, version, weight. Used by the agent for
+// context tracking and by tools for direct store access.
+
+use super::store::Store;
+
+/// A memory node loaded into the agent's working memory.
+#[derive(Debug, Clone)]
+pub struct MemoryNode {
+    pub key: String,
+    pub content: String,
+    pub links: Vec<Link>,
+    /// Version from the store — used for change detection.
+    pub version: u32,
+    /// Weight in the graph.
+    pub weight: f32,
+}
+
+/// A link to a neighbor node.
+#[derive(Debug, Clone)]
+pub struct Link {
+    pub target: String,
+    pub strength: f32,
+    /// Whether this link target is already referenced inline in the content.
+    pub inline: bool,
+}
+
+impl MemoryNode {
+    /// Load a node from the store by key. Returns None if not found.
+    pub fn load(key: &str) -> Option<Self> {
+        let store = Store::load().ok()?;
+        Self::from_store(&store, key)
+    }
+
+    /// Load from an already-open store.
+    pub fn from_store(store: &Store, key: &str) -> Option<Self> {
+        let node = store.nodes.get(key)?;
+
+        // Collect neighbor strengths
+        let mut neighbors: std::collections::HashMap<&str, f32> = std::collections::HashMap::new();
+        for r in &store.relations {
+            if r.deleted { continue; }
+            if r.source_key == key {
+                let e = neighbors.entry(&r.target_key).or_insert(0.0);
+                *e = e.max(r.strength);
+            } else if r.target_key == key {
+                let e = neighbors.entry(&r.source_key).or_insert(0.0);
+                *e = e.max(r.strength);
+            }
+        }
+
+        let mut links: Vec<Link> = neighbors.into_iter()
+            .map(|(target, strength)| Link {
+                inline: node.content.contains(target),
+                target: target.to_string(),
+                strength,
+            })
+            .collect();
+        links.sort_by(|a, b| b.strength.total_cmp(&a.strength));
+
+        Some(MemoryNode {
+            key: key.to_string(),
+            content: node.content.clone(),
+            links,
+            version: node.version,
+            weight: node.weight,
+        })
+    }
+
+    /// Render for inclusion in the context window.
+    pub fn render(&self) -> String {
+        let mut out = self.content.clone();
+
+        // Footer: links not already referenced inline
+        let footer_links: Vec<&Link> = self.links.iter()
+            .filter(|l| !l.inline)
+            .collect();
+
+        if !footer_links.is_empty() {
+            let total = footer_links.len();
+            out.push_str("\n\n---\nLinks:");
+            for link in footer_links.iter().take(15) {
+                out.push_str(&format!("\n  ({:.2})  `poc-memory render {}`",
+                    link.strength, link.target));
+            }
+            if total > 15 {
+                out.push_str(&format!("\n  ... and {} more (`poc-memory graph link {}`)",
+                    total - 15, self.key));
+            }
+        }
+        out
+    }
+
+    /// Write content to the store and return an updated MemoryNode.
+    pub fn write(key: &str, content: &str, provenance: Option<&str>) -> Result<Self, String> {
+        let prov = provenance.unwrap_or("manual");
+        let mut store = Store::load()?;
+        store.upsert_provenance(key, content, prov)?;
+        store.save()?;
+
+        Self::from_store(&store, key)
+            .ok_or_else(|| format!("wrote {} but failed to load back", key))
+    }
+
+    /// Search for nodes matching a query. Returns lightweight results.
+    pub fn search(query: &str) -> Result<Vec<SearchResult>, String> {
+        let store = Store::load()?;
+        let results = super::query::engine::search(query, &store);
+
+        Ok(results.into_iter().take(20).map(|hit| SearchResult {
+            key: hit.key.clone(),
+            score: hit.activation as f32,
+            snippet: hit.snippet.unwrap_or_default(),
+        }).collect())
+    }
+
+    /// Mark a node as used (boosts weight).
+    pub fn mark_used(key: &str) -> Result<String, String> {
+        let mut store = Store::load()?;
+        if !store.nodes.contains_key(key) {
+            return Err(format!("node not found: {}", key));
+        }
+        store.mark_used(key);
+        store.save()?;
+        Ok(format!("marked {} as used", key))
+    }
+}
+
+/// A search result — lightweight, not a full node load.
+#[derive(Debug, Clone)]
+pub struct SearchResult {
+    pub key: String,
+    pub score: f32,
+    pub snippet: String,
+}
+
+impl SearchResult {
+    /// Format for display.
+    pub fn render(&self) -> String {
+        format!("({:.2}) {} — {}", self.score, self.key, self.snippet)
+    }
+}