feat(persistent): wire all 8 modality stores to redb backends

The `persistent` feature previously only wired graph (redb) and document
(Tantivy) — vector, tensor, semantic, temporal, provenance, and spatial
remained in-memory and lost data on restart.

Changes:
- Propagate redb-backend feature to all 6 remaining modality crates
- Make RedbVersionStore generic over T (was hardcoded to serde_json::Value,
  but InMemoryOctadStore requires Data = OctadSnapshot)
- Update ConcreteOctadStore type alias to use all Redb* stores
- Construct persistent stores in AppState::new_async with per-modality
  redb files (vector.redb, tensor.redb, semantic.redb, etc.)
- Gate in-memory imports behind #[cfg(not(feature = "persistent"))]

Verified: all 8 redb files created on startup, data survives stop/restart
with WAL replay recovering 6/6 entities and modality flags intact for
semantic, provenance, and temporal stores.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

rust-core/verisim-api/Cargo.toml

@@ -47,9 +47,17 @@ hex = "0.4"
 
 [features]
 default = []
-# Enable persistent storage backends (redb for graph, file-backed Tantivy for documents, WAL).
-# Requires VERISIM_PERSISTENCE_DIR environment variable at runtime.
-persistent = ["verisim-graph/redb-backend"]
+# Enable persistent storage backends (redb for all modalities, file-backed Tantivy for
+# documents, WAL for crash recovery).  Requires VERISIM_PERSISTENCE_DIR at runtime.
+persistent = [
+    "verisim-graph/redb-backend",
+    "verisim-vector/redb-backend",
+    "verisim-tensor/redb-backend",
+    "verisim-semantic/redb-backend",
+    "verisim-temporal/redb-backend",
+    "verisim-provenance/redb-backend",
+    "verisim-spatial/redb-backend",
+]
 
 # Build-dependencies removed: protobuf code is pre-generated at src/proto/verisim.rs.
 # To regenerate after changing proto/verisim.proto, run:

rust-core/verisim-api/src/lib.rs

@@ -35,6 +35,18 @@ use verisim_drift::{DriftDetector, DriftMetrics, DriftThresholds, DriftType};
 use verisim_graph::SimpleGraphStore;
 #[cfg(feature = "persistent")]
 use verisim_graph::RedbGraphStore;
+#[cfg(feature = "persistent")]
+use verisim_vector::RedbVectorStore;
+#[cfg(feature = "persistent")]
+use verisim_tensor::RedbTensorStore;
+#[cfg(feature = "persistent")]
+use verisim_semantic::RedbSemanticStore;
+#[cfg(feature = "persistent")]
+use verisim_temporal::RedbVersionStore;
+#[cfg(feature = "persistent")]
+use verisim_provenance::RedbProvenanceStore;
+#[cfg(feature = "persistent")]
+use verisim_spatial::RedbSpatialStore;
 use verisim_planner::{
     CacheConfig, ExplainOutput, ExplainAnalyzeOutput, LogicalPlan, ParamValue,
     PhysicalPlan, PlanCache, Planner, PlannerConfig, PreparedId, PreparedStatement,
@@ -46,15 +58,22 @@ use verisim_octad::{
     OctadSpatialInput, OctadStore, OctadTensorInput, OctadVectorInput,
     InMemoryOctadStore, ProvenanceStore, SpatialStore,
 };
+#[cfg(not(feature = "persistent"))]
 use verisim_provenance::InMemoryProvenanceStore;
+#[cfg(not(feature = "persistent"))]
 use verisim_spatial::InMemorySpatialStore;
 use verisim_normalizer::{create_default_normalizer, Normalizer, NormalizerStatus};
+#[cfg(not(feature = "persistent"))]
 use verisim_semantic::InMemorySemanticStore;
 use verisim_semantic::zkp_bridge::{self as zkp_api, PrivacyLevel, ZkpProofRequest as ZkpBridgeRequest};
 use verisim_semantic::circuit_registry::CircuitRegistry;
+#[cfg(not(feature = "persistent"))]
 use verisim_temporal::InMemoryVersionStore;
+#[cfg(not(feature = "persistent"))]
 use verisim_tensor::InMemoryTensorStore;
-use verisim_vector::{DistanceMetric, BruteForceVectorStore};
+use verisim_vector::DistanceMetric;
+#[cfg(not(feature = "persistent"))]
+use verisim_vector::BruteForceVectorStore;
 
 /// Type alias for our concrete OctadStore implementation (octad: 8 modality stores).
 ///
@@ -73,17 +92,18 @@ pub type ConcreteOctadStore = InMemoryOctadStore<
     InMemorySpatialStore,
 >;
 
-/// Persistent variant: redb graph store, file-backed Tantivy, WAL enabled.
+/// Persistent variant: all modalities backed by redb, file-backed Tantivy for
+/// documents, WAL enabled for crash recovery.
 #[cfg(feature = "persistent")]
 pub type ConcreteOctadStore = InMemoryOctadStore<
     RedbGraphStore,
-    BruteForceVectorStore,
+    RedbVectorStore,
     TantivyDocumentStore,
-    InMemoryTensorStore,
-    InMemorySemanticStore,
-    InMemoryVersionStore<OctadSnapshot>,
-    InMemoryProvenanceStore,
-    InMemorySpatialStore,
+    RedbTensorStore,
+    RedbSemanticStore,
+    RedbVersionStore<OctadSnapshot>,
+    RedbProvenanceStore,
+    RedbSpatialStore,
 >;
 
 /// API errors
@@ -525,14 +545,71 @@ impl AppState {
             (g, d)
         };
 
+        // --- Vector store ---
+        #[cfg(feature = "persistent")]
+        let vector = Arc::new(
+            RedbVectorStore::open(
+                format!("{}/vector.redb", persist_dir),
+                config.vector_dimension,
+                DistanceMetric::Cosine,
+            )
+            .await
+            .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let vector = Arc::new(BruteForceVectorStore::new(
             config.vector_dimension,
             DistanceMetric::Cosine,
         ));
+
+        // --- Tensor store ---
+        #[cfg(feature = "persistent")]
+        let tensor = Arc::new(
+            RedbTensorStore::open(format!("{}/tensor.redb", persist_dir))
+                .await
+                .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let tensor = Arc::new(InMemoryTensorStore::new());
+
+        // --- Semantic store ---
+        #[cfg(feature = "persistent")]
+        let semantic = Arc::new(
+            RedbSemanticStore::open(format!("{}/semantic.redb", persist_dir))
+                .await
+                .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let semantic = Arc::new(InMemorySemanticStore::new());
+
+        // --- Temporal (versioning) store ---
+        #[cfg(feature = "persistent")]
+        let temporal = Arc::new(
+            RedbVersionStore::open(format!("{}/temporal.redb", persist_dir))
+                .await
+                .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let temporal = Arc::new(InMemoryVersionStore::new());
+
+        // --- Provenance store ---
+        #[cfg(feature = "persistent")]
+        let provenance = Arc::new(
+            RedbProvenanceStore::open(format!("{}/provenance.redb", persist_dir))
+                .await
+                .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let provenance = Arc::new(InMemoryProvenanceStore::new());
+
+        // --- Spatial store ---
+        #[cfg(feature = "persistent")]
+        let spatial = Arc::new(
+            RedbSpatialStore::open(format!("{}/spatial.redb", persist_dir))
+                .await
+                .map_err(|e| ApiError::Internal(e.to_string()))?,
+        );
+        #[cfg(not(feature = "persistent"))]
         let spatial = Arc::new(InMemorySpatialStore::new());
 
         let octad_store_inner = InMemoryOctadStore::new(

rust-core/verisim-temporal/src/persistent.rs

@@ -8,38 +8,41 @@
 // cache for fast reads.  Writes go to redb first (durable), then update the
 // cache.
 //
-// The associated type `Data` is `serde_json::Value`, making this store a
-// universal versioned key-value store.  Higher layers can convert to/from
-// concrete types using serde.
+// The store is generic over `T` (the versioned data type).  Any type that is
+// Serialize + DeserializeOwned + Clone + Send + Sync can be versioned.
 
 use std::collections::{BTreeMap, HashMap};
+use std::marker::PhantomData;
 use std::path::Path;
 use std::sync::{Arc, RwLock};
 
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
+use serde::{de::DeserializeOwned, Serialize};
 use tracing::info;
 use verisim_storage::redb_backend::RedbBackend;
 use verisim_storage::typed::TypedStore;
 
 use crate::{TemporalError, TemporalStore, TimeRange, Version};
 
-/// Type alias matching the InMemory store's internal structure.
-type VersionHistory = HashMap<String, BTreeMap<u64, Version<serde_json::Value>>>;
-
 /// Persistent version store: redb for durability, in-memory BTreeMap cache for
 /// fast reads and range queries.
 ///
 /// Each entity's entire version history is stored as a serialized
-/// `BTreeMap<u64, Version<serde_json::Value>>` under the entity_id key.
-pub struct RedbVersionStore {
+/// `BTreeMap<u64, Version<T>>` under the entity_id key.
+///
+/// `T` is the versioned data type — typically `OctadSnapshot` when used inside
+/// `InMemoryOctadStore`, or `serde_json::Value` for generic use.
+pub struct RedbVersionStore<T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static> {
     /// Typed store for version histories, keyed by entity_id.
     store: TypedStore<RedbBackend>,
     /// In-memory cache of all version histories.
-    versions: Arc<RwLock<VersionHistory>>,
+    versions: Arc<RwLock<HashMap<String, BTreeMap<u64, Version<T>>>>>,
+    /// Phantom data for the generic parameter.
+    _marker: PhantomData<T>,
 }
 
-impl RedbVersionStore {
+impl<T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static> RedbVersionStore<T> {
     /// Open (or create) a persistent version store at the given path.
     ///
     /// On open, all existing version histories are scanned from redb into the
@@ -49,12 +52,12 @@ impl RedbVersionStore {
             .map_err(|e| TemporalError::Conflict(format!("redb open: {}", e)))?;
         let store = TypedStore::new(backend, "ver");
 
-        let entries: Vec<(String, BTreeMap<u64, Version<serde_json::Value>>)> = store
+        let entries: Vec<(String, BTreeMap<u64, Version<T>>)> = store
             .scan_prefix("", 1_000_000)
             .await
             .map_err(|e| TemporalError::Conflict(format!("scan: {}", e)))?;
 
-        let mut cache: VersionHistory = HashMap::new();
+        let mut cache: HashMap<String, BTreeMap<u64, Version<T>>> = HashMap::new();
         for (id, history) in entries {
             cache.insert(id, history);
         }
@@ -66,6 +69,7 @@ impl RedbVersionStore {
         Ok(Self {
             store,
             versions: Arc::new(RwLock::new(cache)),
+            _marker: PhantomData,
         })
     }
 
@@ -89,8 +93,10 @@ impl RedbVersionStore {
 }
 
 #[async_trait]
-impl TemporalStore for RedbVersionStore {
-    type Data = serde_json::Value;
+impl<T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static> TemporalStore
+    for RedbVersionStore<T>
+{
+    type Data = T;
 
     async fn append(
         &self,
@@ -214,7 +220,7 @@ mod tests {
 
         // Write data in one session.
         {
-            let store = RedbVersionStore::open(&path).await.unwrap();
+            let store = RedbVersionStore::<serde_json::Value>::open(&path).await.unwrap();
             let v1 = store
                 .append(
                     "entity-1",
@@ -240,7 +246,7 @@ mod tests {
 
         // Reopen and verify data survived.
         {
-            let store = RedbVersionStore::open(&path).await.unwrap();
+            let store = RedbVersionStore::<serde_json::Value>::open(&path).await.unwrap();
 
             let latest = store.latest("entity-1").await.unwrap().unwrap();
             assert_eq!(latest.version, 2);