Keep prepared search readers warm and verify abrupt indexing recovery

crates/searchi-service/tests/prepared_google_cpu.rs

@@ -0,0 +1,87 @@
+//! Genuine Google CPU proof for background prepared-graph publication.
+use anyhow::Result;
+use searchi_core::SearchIndex;
+use searchi_service::{HybridSearch, PreparedGraphs, SearchOptions};
+use std::fs;
+
+#[test]
+#[ignore = "Requires verified Google models and normal worker; CPU only"]
+fn prepared_publication_keeps_warmed_query_reader_hot() -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let model = std::env::var_os("SEARCHI_GEMMA_MODEL_DIR").expect("Verified models required");
+    let worker = std::env::var_os("SEARCHI_GEMMA_WORKER").expect("Normal worker required");
+    let temp = tempfile::tempdir()?;
+    let root = temp.path().join("documents");
+    fs::create_dir(&root)?;
+    let file = root.join("supplier.txt");
+    fs::write(
+        &file,
+        "The supplier agreement ends with sixty days written notice.",
+    )?;
+    let db = temp.path().join("index.db");
+    let mut lexical = SearchIndex::open(&db)?;
+    lexical.index_folder(&root)?;
+    let graphs = PreparedGraphs::default();
+    let mut indexer = HybridSearch::open(&db, &model, &worker, 1)?;
+    indexer.share_prepared_graphs(&graphs)?;
+    indexer.index_embeddings()?;
+    let mut reader = HybridSearch::open(&db, &model, &worker, 1)?;
+    reader.share_prepared_graphs(&graphs)?;
+    reader.warmup()?;
+    let query = "How can we end our supplier partnership?";
+    reader.search(query, 10, &SearchOptions::default())?;
+    fs::write(
+        &file,
+        "The supplier agreement ends with ninety days written notice.",
+    )?;
+    lexical.index_folder(&root)?;
+    indexer.index_embeddings()?;
+    drop(indexer); // The shared graph outlives the background model worker.
+    let response = reader.search_measured(query, 10, &SearchOptions::default(), true)?;
+    assert_eq!(response.results[0].filename, "supplier.txt");
+    assert!(response.results[0].snippet.contains("ninety days"));
+    let trace = response.metrics.trace.expect("Detailed trace required");
+    assert!(
+        trace
+            .iter()
+            .any(|span| span.counters.get("query_cache_hit") == Some(&1)),
+        "The retained query model must preserve its real-vector LRU across publication"
+    );
+    let loads: Vec<_> = trace
+        .iter()
+        .filter(|span| span.name == "semantic.ann_load")
+        .collect();
+    assert!(!loads.is_empty());
+    assert!(loads
+        .iter()
+        .all(|span| span.counters.get("cache_hit") == Some(&1)));
+    assert!(!trace.iter().any(|span| matches!(
+        span.name.as_str(),
+        "semantic.ann_blob_read" | "semantic.ann_checksum" | "semantic.ann_deserialize"
+    )));
+    let unseen = reader.search_measured(
+        "What notice is required for the contract to end?",
+        10,
+        &SearchOptions::default(),
+        true,
+    )?;
+    assert!(unseen.results[0].snippet.contains("ninety days"));
+    let unseen_trace = unseen.metrics.trace.expect("Unseen query trace required");
+    assert!(
+        unseen_trace
+            .iter()
+            .any(|span| span.counters.get("query_cache_hit") == Some(&0)),
+        "A distinct foreground input must execute genuine query inference"
+    );
+    assert!(unseen_trace
+        .iter()
+        .filter(|span| span.name == "semantic.ann_load")
+        .all(|span| span.counters.get("cache_hit") == Some(&1)));
+    assert!(!unseen_trace.iter().any(|span| matches!(
+        span.name.as_str(),
+        "semantic.ann_blob_read" | "semantic.ann_checksum" | "semantic.ann_deserialize"
+    )));
+    eprintln!("Prepared reader CPU fixture: retained_query_ms={:.3}, unseen_query_ms={:.3}; one document, not a scale benchmark",
+        response.metrics.total_ms, unseen.metrics.total_ms);
+    Ok(())
+}