Cache Store in process — stop reloading on every tool call

Store::cached() returns a process-global Arc<tokio::sync::Mutex<Store>>
that loads once and reloads only when log files change (is_stale()
checks file sizes). All memory and journal tools use cached_store()
instead of Store::load() per invocation.

Fixes CPU saturation from HashMap hashing when multiple subconscious
agents make concurrent tool calls.

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

src/hippocampus/store/persist.rs

@@ -18,8 +18,36 @@ use std::collections::HashMap;
 use std::fs;
 use std::io::{BufReader, Seek};
 use std::path::Path;
+use std::sync::Arc;
+
+/// Process-global cached store. Reloads only when log files change.
+static CACHED_STORE: tokio::sync::OnceCell<Arc<tokio::sync::Mutex<Store>>> =
+    tokio::sync::OnceCell::const_new();
 
 impl Store {
+    /// Get or create the process-global cached store.
+    /// Reloads from disk if log files have changed since last load.
+    pub async fn cached() -> Result<Arc<tokio::sync::Mutex<Store>>, String> {
+        let store = CACHED_STORE.get_or_try_init(|| async {
+            let s = Store::load()?;
+            Ok::<_, String>(Arc::new(tokio::sync::Mutex::new(s)))
+        }).await?;
+        {
+            let mut guard = store.lock().await;
+            if guard.is_stale() {
+                *guard = Store::load()?;
+            }
+        }
+        Ok(store.clone())
+    }
+
+    /// Check if the on-disk logs have grown since we loaded.
+    pub fn is_stale(&self) -> bool {
+        let nodes_size = fs::metadata(nodes_path()).map(|m| m.len()).unwrap_or(0);
+        let rels_size = fs::metadata(relations_path()).map(|m| m.len()).unwrap_or(0);
+        nodes_size != self.loaded_nodes_size || rels_size != self.loaded_rels_size
+    }
+
     /// Load store from state.bin cache if fresh, otherwise rebuild from capnp logs.
     ///
     /// Staleness check uses log file sizes (not mtimes). Since logs are