Replace rkyv/bincode caching with redb indices

Remove three-tier loading (rkyv snapshot, bincode cache, capnp replay)
in favor of direct capnp log replay + redb for indexed access.

- Remove all rkyv derives from types (Node, Relation, enums, etc.)
- Remove Snapshot struct, RKYV_MAGIC, CACHE_MAGIC constants
- Remove load_snapshot_mmap(), save(), save_snapshot()
- Remove MmapView, AnyView from view.rs (keep StoreView trait)
- Simplify Store::load() to just replay capnp logs
- Add db.rs with redb schema: nodes, uuid_to_key, visits, transcript_progress
- Simplify cmd_fsck to just check capnp integrity + graph health

capnp logs remain source of truth; redb indices will be rebuilt on demand.

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

src/hippocampus/store/view.rs

@@ -1,18 +1,9 @@
-// Read-only access abstractions for the memory store
-//
-// StoreView: trait abstracting over owned Store and zero-copy MmapView.
-// MmapView: mmap'd rkyv snapshot for sub-millisecond read-only access.
-// AnyView: enum dispatch selecting fastest available view at runtime.
+// Read-only access abstraction for the memory store
 
 use super::types::*;
 
-use std::fs;
-
 // ---------------------------------------------------------------------------
 // StoreView: read-only access trait for search and graph code.
-//
-// Abstracts over owned Store and zero-copy MmapView so the same
-// spreading-activation and graph code works with either.
 // ---------------------------------------------------------------------------
 
 pub trait StoreView {
@@ -67,140 +58,3 @@ impl StoreView for Store {
         self.params
     }
 }
-
-// ---------------------------------------------------------------------------
-// MmapView: zero-copy store access via mmap'd rkyv snapshot.
-//
-// Holds the mmap alive; all string reads go directly into the mapped
-// pages without allocation. Falls back to None if snapshot is stale.
-// ---------------------------------------------------------------------------
-
-pub struct MmapView {
-    mmap: memmap2::Mmap,
-    _file: fs::File,
-    data_offset: usize,
-    data_len: usize,
-}
-
-impl MmapView {
-    /// Try to open a fresh rkyv snapshot. Returns None if missing or stale.
-    pub fn open() -> Option<Self> {
-        let path = snapshot_path();
-        let file = fs::File::open(&path).ok()?;
-        let mmap = unsafe { memmap2::Mmap::map(&file) }.ok()?;
-
-        if mmap.len() < RKYV_HEADER_LEN { return None; }
-        if mmap[..4] != RKYV_MAGIC { return None; }
-
-        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);
-
-        let cached_nodes = u64::from_le_bytes(mmap[8..16].try_into().unwrap());
-        let cached_rels = u64::from_le_bytes(mmap[16..24].try_into().unwrap());
-        let data_len = u64::from_le_bytes(mmap[24..32].try_into().unwrap()) as usize;
-
-        if cached_nodes != nodes_size || cached_rels != rels_size { return None; }
-        if mmap.len() < RKYV_HEADER_LEN + data_len { return None; }
-
-        Some(MmapView { mmap, _file: file, data_offset: RKYV_HEADER_LEN, data_len })
-    }
-
-    fn snapshot(&self) -> &ArchivedSnapshot {
-        let data = &self.mmap[self.data_offset..self.data_offset + self.data_len];
-        unsafe { rkyv::archived_root::<Snapshot>(data) }
-    }
-}
-
-impl StoreView for MmapView {
-    fn for_each_node<F: FnMut(&str, &str, f32)>(&self, mut f: F) {
-        let snap = self.snapshot();
-        for (key, node) in snap.nodes.iter() {
-            f(key, &node.content, node.weight);
-        }
-    }
-
-    fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, mut f: F) {
-        let snap = self.snapshot();
-        for (key, node) in snap.nodes.iter() {
-            let nt = match node.node_type {
-                ArchivedNodeType::EpisodicSession => NodeType::EpisodicSession,
-                ArchivedNodeType::EpisodicDaily => NodeType::EpisodicDaily,
-                ArchivedNodeType::EpisodicWeekly => NodeType::EpisodicWeekly,
-                ArchivedNodeType::EpisodicMonthly => NodeType::EpisodicMonthly,
-                ArchivedNodeType::Semantic => NodeType::Semantic,
-            };
-            f(key, nt, node.timestamp);
-        }
-    }
-
-    fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, mut f: F) {
-        let snap = self.snapshot();
-        for rel in snap.relations.iter() {
-            if rel.deleted { continue; }
-            let rt = match rel.rel_type {
-                ArchivedRelationType::Link => RelationType::Link,
-                ArchivedRelationType::Causal => RelationType::Causal,
-                ArchivedRelationType::Auto => RelationType::Auto,
-            };
-            f(&rel.source_key, &rel.target_key, rel.strength, rt);
-        }
-    }
-
-    fn node_weight(&self, key: &str) -> f64 {
-        let snap = self.snapshot();
-        snap.nodes.get(key)
-            .map(|n| n.weight as f64)
-            .unwrap_or(snap.params.default_weight)
-    }
-
-    fn node_content(&self, key: &str) -> Option<&str> {
-        let snap = self.snapshot();
-        snap.nodes.get(key).map(|n| &*n.content)
-    }
-
-    fn params(&self) -> Params {
-        let p = &self.snapshot().params;
-        Params {
-            default_weight: p.default_weight,
-            decay_factor: p.decay_factor,
-            use_boost: p.use_boost,
-            prune_threshold: p.prune_threshold,
-            edge_decay: p.edge_decay,
-            max_hops: p.max_hops,
-            min_activation: p.min_activation,
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// AnyView: enum dispatch for read-only access.
-//
-// MmapView when the snapshot is fresh, owned Store as fallback.
-// The match on each call is a single predicted branch — zero overhead.
-// ---------------------------------------------------------------------------
-
-pub enum AnyView {
-    Mmap(MmapView),
-    Owned(Store),
-}
-
-impl StoreView for AnyView {
-    fn for_each_node<F: FnMut(&str, &str, f32)>(&self, f: F) {
-        match self { AnyView::Mmap(v) => v.for_each_node(f), AnyView::Owned(s) => s.for_each_node(f) }
-    }
-    fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, f: F) {
-        match self { AnyView::Mmap(v) => v.for_each_node_meta(f), AnyView::Owned(s) => s.for_each_node_meta(f) }
-    }
-    fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, f: F) {
-        match self { AnyView::Mmap(v) => v.for_each_relation(f), AnyView::Owned(s) => s.for_each_relation(f) }
-    }
-    fn node_weight(&self, key: &str) -> f64 {
-        match self { AnyView::Mmap(v) => v.node_weight(key), AnyView::Owned(s) => s.node_weight(key) }
-    }
-    fn node_content(&self, key: &str) -> Option<&str> {
-        match self { AnyView::Mmap(v) => v.node_content(key), AnyView::Owned(s) => s.node_content(key) }
-    }
-    fn params(&self) -> Params {
-        match self { AnyView::Mmap(v) => v.params(), AnyView::Owned(s) => s.params() }
-    }
-}