store: internal locking, remove Arc<Mutex<Store>> wrapper

Store now has internal Mutex for capnp appends and AtomicU64 for
size tracking. All methods take &self. The external Arc<Mutex<Store>>
is replaced with Arc<Store>.

- Store::append_lock protects file appends
- local.rs functions take &Store (not &mut Store)
- access_local() returns Arc<Store>
- All .lock().await calls removed from callers

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

src/hippocampus/store/ops.rs

@@ -16,7 +16,7 @@ pub fn current_provenance() -> String {
 
 impl Store {
     /// Add or update a node (appends to log + updates index).
-    pub fn upsert_node(&mut self, mut node: Node) -> Result<()> {
+    pub fn upsert_node(&self, mut node: Node) -> Result<()> {
         if let Some(existing) = self.get_node(&node.key)? {
             node.uuid = existing.uuid;
             node.version = existing.version + 1;
@@ -30,7 +30,7 @@ impl Store {
     }
 
     /// Add a relation (appends to log + indexes)
-    pub fn add_relation(&mut self, rel: Relation) -> Result<()> {
+    pub fn add_relation(&self, rel: Relation) -> Result<()> {
         let db = self.db.as_ref().ok_or_else(|| anyhow!("store not loaded"))?;
         let txn = db.begin_write()?;
         self.append_relations(std::slice::from_ref(&rel))?;
@@ -70,13 +70,13 @@ impl Store {
     ///
     /// Provenance is determined by the POC_PROVENANCE env var if set,
     /// otherwise defaults to Manual.
-    pub fn upsert(&mut self, key: &str, content: &str) -> Result<&'static str> {
+    pub fn upsert(&self, key: &str, content: &str) -> Result<&'static str> {
         let prov = current_provenance();
         self.upsert_provenance(key, content, &prov)
     }
 
     /// Upsert with explicit provenance (for agent-created nodes).
-    pub fn upsert_provenance(&mut self, key: &str, content: &str, provenance: &str) -> Result<&'static str> {
+    pub fn upsert_provenance(&self, key: &str, content: &str, provenance: &str) -> Result<&'static str> {
         let db = self.db.as_ref().ok_or_else(|| anyhow!("store not loaded"))?;
 
         if let Some(existing) = self.get_node(key)? {
@@ -105,7 +105,7 @@ impl Store {
     }
 
     /// Soft-delete a node (appends deleted version, removes from index).
-    pub fn delete_node(&mut self, key: &str) -> Result<()> {
+    pub fn delete_node(&self, key: &str) -> Result<()> {
         let prov = current_provenance();
         let db = self.db.as_ref().ok_or_else(|| anyhow!("store not loaded"))?;
 
@@ -129,7 +129,7 @@ impl Store {
     /// Graph edges (source/target UUIDs) are unaffected — they're already
     /// UUID-based. We update the human-readable source_key/target_key strings
     /// on relations, and created_at is preserved untouched.
-    pub fn rename_node(&mut self, old_key: &str, new_key: &str) -> Result<()> {
+    pub fn rename_node(&self, old_key: &str, new_key: &str) -> Result<()> {
         if old_key == new_key {
             return Ok(());
         }
@@ -199,7 +199,7 @@ impl Store {
     }
 
     /// Cap node degree by soft-deleting edges from mega-hubs.
-    pub fn cap_degree(&mut self, max_degree: usize) -> Result<(usize, usize)> {
+    pub fn cap_degree(&self, max_degree: usize) -> Result<(usize, usize)> {
         let db = self.db.as_ref().ok_or_else(|| anyhow!("store not loaded"))?;
         let keys = index::all_keys(db)?;
 
@@ -306,7 +306,7 @@ impl Store {
     }
 
     /// Set a node's weight directly. Returns (old, new).
-    pub fn set_weight(&mut self, key: &str, weight: f32) -> Result<(f32, f32)> {
+    pub fn set_weight(&self, key: &str, weight: f32) -> Result<(f32, f32)> {
         let weight = weight.clamp(0.01, 1.0);
         let db = self.db.as_ref().ok_or_else(|| anyhow!("store not loaded"))?;
         let mut node = self.get_node(key)?
@@ -327,7 +327,7 @@ impl Store {
 
     /// Set the strength of a link between two nodes.
     /// Returns the old strength. Creates link if it doesn't exist.
-    pub fn set_link_strength(&mut self, source: &str, target: &str, strength: f32) -> Result<f32> {
+    pub fn set_link_strength(&self, source: &str, target: &str, strength: f32) -> Result<f32> {
         let strength = strength.clamp(0.01, 1.0);
 
         let source_uuid = self.get_node(source)?
@@ -372,7 +372,7 @@ impl Store {
 
     /// Add a link between two nodes with Jaccard-based initial strength.
     /// Returns the strength, or a message if the link already exists.
-    pub fn add_link(&mut self, source: &str, target: &str, provenance: &str) -> Result<f32> {
+    pub fn add_link(&self, source: &str, target: &str, provenance: &str) -> Result<f32> {
         let source_uuid = self.get_node(source)?
             .map(|n| n.uuid)
             .ok_or_else(|| anyhow!("source not found: {}", source))?;