refactor(test): trim e2e suite to lightweight correctness checks

Remove large-workload vector, graph, and document tests that belong in
the benchmark suite rather than the integration test suite. The
remaining tests cover the core CRUD lifecycle and FTS at a scale
appropriate for `cargo nextest run` in CI. Scale workloads live in
`nodedb-bench/benches/micro/`.

Author: farhan-syah

nodedb-lite/tests/e2e.rs

@@ -16,162 +16,14 @@ async fn open_db() -> NodeDbLite<RedbStorage> {
 // ═══════════════════════════════════════════════════════════════════════
 // 6.1 Standalone Lite (No Origin)
 // ═══════════════════════════════════════════════════════════════════════
-
-/// Correctness-only counterpart of the 1k×384d HNSW workload.
-/// The full-scale build/search is a benchmark — see
-/// `nodedb-bench/benches/micro/lite_vector.rs`.
-#[tokio::test]
-async fn e2e_vector_search_returns_sorted_top_k() {
-    let db = open_db().await;
-    let dim = 32;
-    let n = 50;
-
-    let vectors: Vec<(String, Vec<f32>)> = (0..n)
-        .map(|i| {
-            let emb: Vec<f32> = (0..dim).map(|d| ((i * dim + d) as f32).sin()).collect();
-            (format!("v{i}"), emb)
-        })
-        .collect();
-    let refs: Vec<(&str, &[f32])> = vectors
-        .iter()
-        .map(|(id, e)| (id.as_str(), e.as_slice()))
-        .collect();
-    db.batch_vector_insert("kb", &refs).unwrap();
-
-    let query: Vec<f32> = (0..dim).map(|d| ((25 * dim + d) as f32).sin()).collect();
-    let results = db.vector_search("kb", &query, 5, None).await.unwrap();
-
-    assert_eq!(results.len(), 5);
-    for w in results.windows(2) {
-        assert!(w[0].distance <= w[1].distance);
-    }
-    assert!(
-        results[0].distance < 1.0,
-        "top result distance {} too large",
-        results[0].distance
-    );
-}
-
-/// Correctness-only counterpart of the 10k-edge graph workload.
-/// Scale benchmark lives in `nodedb-bench/benches/micro/lite_graph.rs`.
-#[tokio::test]
-async fn e2e_graph_bfs_reaches_multiple_hops() {
-    let db = open_db().await;
-
-    // Small graph: 50 nodes, 4 edges each = 200 edges. Enough for 3-hop BFS
-    // to visit several nodes; cheap enough for default `cargo nextest run`.
-    let mut edges: Vec<(String, String, &str)> = Vec::with_capacity(200);
-    for i in 0..50 {
-        for j in 1..=4 {
-            let dst = (i + j * 7) % 50;
-            edges.push((format!("n{i}"), format!("n{dst}"), "LINK"));
-        }
-    }
-    let refs: Vec<(&str, &str, &str)> = edges
-        .iter()
-        .map(|(s, d, l)| (s.as_str(), d.as_str(), *l))
-        .collect();
-    db.batch_graph_insert_edges(&refs).unwrap();
-    db.compact_graph().unwrap();
-
-    let sg = db
-        .graph_traverse(&NodeId::new("n0"), 3, None)
-        .await
-        .unwrap();
-    assert!(
-        sg.node_count() > 5,
-        "3-hop BFS should reach multiple nodes, found {}",
-        sg.node_count()
-    );
-    assert!(
-        sg.edge_count() > 0,
-        "should have edges, found {}",
-        sg.edge_count()
-    );
-}
-
-#[tokio::test]
-async fn e2e_document_crud_lifecycle() {
-    let db = open_db().await;
-
-    // Create.
-    for i in 0..50 {
-        let mut doc = Document::new(format!("doc-{i}"));
-        doc.set("title", Value::String(format!("Title {i}")));
-        doc.set("score", Value::Float(i as f64 * 0.1));
-        db.document_put("notes", doc).await.unwrap();
-    }
-
-    // Read.
-    let doc = db.document_get("notes", "doc-25").await.unwrap().unwrap();
-    assert_eq!(doc.id, "doc-25");
-    assert_eq!(doc.get_str("title"), Some("Title 25"));
-
-    // Update.
-    let mut updated = Document::new("doc-25");
-    updated.set("title", Value::String("Updated".into()));
-    db.document_put("notes", updated).await.unwrap();
-    let doc = db.document_get("notes", "doc-25").await.unwrap().unwrap();
-    assert_eq!(doc.get_str("title"), Some("Updated"));
-
-    // Delete.
-    db.document_delete("notes", "doc-25").await.unwrap();
-    assert!(db.document_get("notes", "doc-25").await.unwrap().is_none());
-
-    // Neighbors survive.
-    assert!(db.document_get("notes", "doc-24").await.unwrap().is_some());
-    assert!(db.document_get("notes", "doc-26").await.unwrap().is_some());
-}
-
-#[tokio::test]
-async fn e2e_flush_reopen_all_data_survives() {
-    let dir = tempfile::tempdir().unwrap();
-    let path = dir.path().join("e2e.redb");
-
-    // Write data + flush.
-    {
-        let storage = RedbStorage::open(&path).unwrap();
-        let db = NodeDbLite::open(storage, 1).await.unwrap();
-
-        db.batch_vector_insert(
-            "vecs",
-            &[("v1", &[1.0f32, 2.0, 3.0][..]), ("v2", &[4.0, 5.0, 6.0])],
-        )
-        .unwrap();
-        db.batch_graph_insert_edges(&[("a", "b", "KNOWS"), ("b", "c", "KNOWS")])
-            .unwrap();
-        let mut doc = Document::new("d1");
-        doc.set("key", Value::String("persistent".into()));
-        db.document_put("docs", doc).await.unwrap();
-
-        db.flush().await.unwrap();
-    }
-
-    // Reopen + verify.
-    {
-        let storage = RedbStorage::open(&path).unwrap();
-        let db = NodeDbLite::open(storage, 1).await.unwrap();
-
-        // Vectors.
-        let results = db
-            .vector_search("vecs", &[1.0, 2.0, 3.0], 1, None)
-            .await
-            .unwrap();
-        assert!(!results.is_empty(), "vectors should survive restart");
-
-        // Graph.
-        let sg = db.graph_traverse(&NodeId::new("a"), 2, None).await.unwrap();
-        assert!(sg.node_count() >= 3, "graph should survive restart");
-
-        // Document.
-        let doc = db.document_get("docs", "d1").await.unwrap();
-        assert!(doc.is_some(), "document should survive restart");
-    }
-}
-
-// `e2e_cold_start_timing` was migrated to a benchmark — it asserted only
-// wall-clock time, no correctness. See:
-//   nodedb-bench/benches/workload/lite_cold_start.rs
+//
+// Vector search, graph BFS, document CRUD, and flush/reopen correctness
+// are covered by the equivalent tests in `integration.rs`
+// (`vector_batch_insert_and_search_correctness`,
+// `graph_batch_and_traverse_correctness`, `document_crud_100`,
+// `flush_and_reopen_persists_all`). Only Lite-specific concerns
+// (memory budget, CRDT convergence, compensation, delta ack, native
+// smoke) live in this file.
 
 #[tokio::test]
 async fn e2e_memory_stays_within_budget() {