feat: artifact disk cache — f32 holo + compact predictive, 14s→850ms warm search

Author: Avery Felts

Cargo.lock

@@ -290,17 +290,16 @@ graphiq/
 ### Storage Layout
 
 ```
-.graphiq/graphiq.db
-  ├── symbols          # name, kind, signature, source, file, line
-  ├── edges            # source, target, kind
-  ├── files            # path, language, symbol_count
-  ├── edges_fts        # FTS5 index (name, decomposed, hints, sig, source)
-  ├── manifest.json    # artifact freshness tracking
-  └── [computed at query time]
-      ├── spectral     # Chebyshev heat diffusion infrastructure
-      ├── cruncher     # adjacency lists, term sets, IDF
-      ├── predictive   # conditional term models per symbol
-      └── fingerprints # channel fingerprint vectors per symbol
+.graphiq/
+├── graphiq.db              SQLite database (symbols, edges, FTS5 index)
+├── manifest.json           artifact freshness tracking
+└── cache/                  precomputed artifacts (zstd-compressed)
+    ├── cruncher.bin.zst
+    ├── holo_f32.bin.zst
+    ├── spectral.bin.zst
+    ├── predictive_compact.bin.zst
+    ├── fingerprints.bin.zst
+    └── self_model.bin.zst
 ```
 
 ### Operating System Support
@@ -313,7 +312,51 @@ graphiq/
 
 ## Benchmarks
 
-See [docs/benchmarks.md](docs/benchmarks.md) for full results including per-category breakdowns, deep graph edge counts, and router performance analysis.
+v6 unified pipeline. 3 codebases (TypeScript, Rust, Go). Separate NDCG (20 queries/codebase) and MRR (25 queries/codebase) query sets.
+
+### Accuracy vs Grep
+
+| Metric | Grep | GraphIQ | Δ |
+|---|---|---|---|
+| MRR@10 | 0.941 | **0.959** | +1.9% |
+| NDCG@10 | 0.288 | **0.378** | +31% |
+| Combined | 0.615 | **0.669** | +8.7% |
+
+| Category | Grep | GraphIQ | Winner |
+|---|---|---|---|
+| symbol-exact | 0.887 | **0.899** | GraphIQ |
+| symbol-partial | **0.711** | 0.708 | Grep (marginal) |
+| nl-descriptive | 0.069 | **0.289** | GraphIQ (4.2x) |
+| nl-abstract | 0.030 | **0.216** | GraphIQ (7.2x) |
+| error-debug | 0.159 | **0.268** | GraphIQ (1.7x) |
+| file-path | **0.066** | 0.048 | Grep |
+| cross-cutting | 0.000 | **0.137** | GraphIQ |
+
+### Search Speed
+
+All artifacts cached to disk after first query. Subsequent CLI searches load from cache.
+
+| Metric | Time |
+|---|---|
+| Cold search (first run) | ~30s |
+| Warm search (cached) | **~850ms** |
+| In-process query (MCP/bench) | ~18μs |
+
+### Artifact Cache
+
+```
+.graphiq/cache/           Total: ~75MB
+├── cruncher.bin.zst      6.5MB   adjacency lists, term sets, IDF
+├── holo_f32.bin.zst      42MB    holographic name vectors (f32)
+├── spectral.bin.zst      17MB    Chebyshev heat diffusion
+├── predictive_compact.bin.zst  8.8MB  conditional term models (top-200/symbol)
+├── fingerprints.bin.zst  78KB    channel fingerprint vectors
+└── self_model.bin.zst    356KB   deterministic concept nodes
+```
+
+Cache is validated against DB stats on every search — stale cache is transparently rebuilt. `graphiq reindex` and `graphiq upgrade-index` invalidate the cache automatically.
+
+See [docs/benchmarks.md](docs/benchmarks.md) for full per-codebase breakdowns and methodology.
 
 ## Documentation
 

README.md

@@ -1,6 +1,6 @@
 [package]
 name = "graphiq-bench"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 
 [[bin]]

crates/graphiq-bench/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "graphiq-cli"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 
 [[bin]]

crates/graphiq-cli/Cargo.toml

@@ -270,34 +270,82 @@ fn cmd_search(
     let cache = graphiq_core::cache::HotCache::with_defaults();
     cache.prewarm(&db, 200);
 
-    let goober = graphiq_core::cruncher::build_cruncher_index(&db).ok().map(|ci| {
-        let hi = graphiq_core::cruncher::build_holo_index(&db, &ci);
-        (ci, hi)
-    });
+    let db_dir = db_path.parent().unwrap_or(db_path);
+    let mut ac = graphiq_core::artifact_cache::ArtifactCache::new(db_dir, &db);
+
+    let goober = if let Some(ci) = ac.load::<graphiq_core::cruncher::CruncherIndex>("cruncher") {
+        let hi = if let Some(cached_hi) = ac.load_holo() {
+            cached_hi
+        } else {
+            let hi = graphiq_core::cruncher::build_holo_index(&db, &ci);
+            ac.save_holo(&hi);
+            hi
+        };
+        Some((ci, hi))
+    } else {
+        graphiq_core::cruncher::build_cruncher_index(&db).ok().map(|ci| {
+            ac.save("cruncher", &ci);
+            let hi = graphiq_core::cruncher::build_holo_index(&db, &ci);
+            ac.save_holo(&hi);
+            (ci, hi)
+        })
+    };
 
     let mut engine = graphiq_core::search::SearchEngine::new(&db, &cache);
     if let Some((ref ci, ref hi)) = goober {
         engine = engine.with_goober(ci, hi);
     }
 
-    let spectral = graphiq_core::spectral::compute_spectral(&db).ok();
+    let spectral = if let Some(si) = ac.load::<graphiq_core::spectral::SpectralIndex>("spectral") {
+        Some(si)
+    } else {
+        let si = graphiq_core::spectral::compute_spectral(&db).ok();
+        if let Some(ref s) = si {
+            ac.save("spectral", s);
+        }
+        si
+    };
     if let Some(ref spec) = spectral {
         engine = engine.with_spectral(spec);
     }
 
-    let predictive = graphiq_core::spectral::compute_predictive_model(&db).ok();
+    let predictive = if let Some(pm) = ac.load_predictive() {
+        Some(pm)
+    } else {
+        let pm = graphiq_core::spectral::compute_predictive_model(&db).ok();
+        if let Some(ref p) = pm {
+            ac.save_predictive(p);
+        }
+        pm
+    };
     if let Some(ref pm) = predictive {
         engine = engine.with_predictive(pm);
     }
 
-    let (fp_vec, fp_id_map) = graphiq_core::spectral::compute_channel_fingerprints(&db);
+    let (fp_vec, fp_id_map) = if let Some(cached) = ac.load::<(Vec<graphiq_core::spectral::ChannelFingerprint>, std::collections::HashMap<i64, usize>)>("fingerprints") {
+        cached
+    } else {
+        let fps = graphiq_core::spectral::compute_channel_fingerprints(&db);
+        ac.save("fingerprints", &(fps.0.clone(), fps.1.clone()));
+        fps
+    };
     engine = engine.with_fingerprints(&fp_vec, &fp_id_map);
 
-    let self_model = graphiq_core::self_model::build_self_model(&db).ok();
+    let self_model = if let Some(sm) = ac.load::<graphiq_core::self_model::RepoSelfModel>("self_model") {
+        Some(sm)
+    } else {
+        let sm = graphiq_core::self_model::build_self_model(&db).ok();
+        if let Some(ref s) = sm {
+            ac.save("self_model", s);
+        }
+        sm
+    };
     if let Some(ref sm) = self_model {
         engine = engine.with_self_model(sm);
     }
 
+    ac.save_manifest(&db);
+
     if debug {
         eprintln!("search mode: {}", engine.active_mode());
     }
@@ -517,6 +565,8 @@ fn cmd_reindex(path: &std::path::Path, db_path: &std::path::Path) {
 
     let manifest = graphiq_core::manifest::build_manifest_all_ready(&db);
     let db_dir = db_path.parent().unwrap_or(std::path::Path::new("."));
+    let ac = graphiq_core::artifact_cache::ArtifactCache::new(db_dir, &db);
+    ac.invalidate();
     if let Err(e) = graphiq_core::manifest::write_manifest(db_dir, &manifest) {
         eprintln!("  warning: failed to write manifest: {e}");
     }

crates/graphiq-cli/src/main.rs

@@ -1,13 +1,15 @@
 [package]
 name = "graphiq-core"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 
 [dependencies]
 rusqlite = { version = "0.34", features = ["bundled"] }
 sha2 = "0.10"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+bincode = "1"
+zstd = "0.13"
 rayon = "1.10"
 ignore = "0.4"
 thiserror = "2"