perf(index): skip store and search sync on no-op incremental reindex

Add GraphDelta::is_empty() and use it to detect when the graph is
unchanged after extraction+merge+classify. When empty, skip SQLite
save (2.8s), search index sync (1.1s), and PRAGMA optimize — still
run localization and asset snapshots since they scan independent files.

Also fix save_incremental to compute the delta only once instead of
three times (was called twice via StoreWriteStats::from_graphs plus
once directly), and return early with empty stats when delta is empty.

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

Author: ahavili

grapha/src/app/index.rs

@@ -153,8 +153,76 @@ pub(crate) fn handle_index(
             .map(|prev| delta::GraphDelta::between(prev, &graph))
     };
 
+    let graph_unchanged = delta.as_ref().is_some_and(|d| d.is_empty());
+
     let search_index_path = store_path.join("search_index");
     let index_root = path.clone();
+
+    if graph_unchanged {
+        let snapshot_result = std::thread::scope(|scope| {
+            let localization_handle = scope.spawn(|| {
+                let t = Instant::now();
+                let stats =
+                    localization::build_and_save_catalog_snapshot(&index_root, &store_path)?;
+                Ok::<_, anyhow::Error>((t.elapsed(), stats))
+            });
+
+            let assets_handle = scope.spawn(|| {
+                let t = Instant::now();
+                let stats = assets::build_and_save_snapshot(&index_root, &store_path)?;
+                Ok::<_, anyhow::Error>((t.elapsed(), stats))
+            });
+
+            let localization = localization_handle
+                .join()
+                .expect("localization thread panicked")?;
+            let assets = assets_handle.join().expect("assets thread panicked")?;
+            Ok::<_, anyhow::Error>((localization, assets))
+        });
+        let ((localize_elapsed, localize_stats), (assets_elapsed, assets_stats)) = snapshot_result?;
+
+        extraction_cache
+            .save_entries(&pipeline.extraction_cache_entries)
+            .with_context(|| "failed to save extraction cache".to_string())?;
+
+        eprintln!("  \x1b[32m✓\x1b[0m no graph changes detected, skipping store and search sync");
+        progress::done_elapsed(
+            &format!(
+                "saved localization snapshot ({} records)",
+                localize_stats.record_count
+            ),
+            localize_elapsed,
+        );
+        for warning in &localize_stats.warnings {
+            eprintln!(
+                "  \x1b[33m!\x1b[0m skipped invalid localization catalog {}: {}",
+                warning.catalog_file, warning.reason
+            );
+        }
+        progress::done_elapsed(
+            &format!(
+                "saved asset snapshot ({} images)",
+                assets_stats.record_count
+            ),
+            assets_elapsed,
+        );
+        for warning in &assets_stats.warnings {
+            eprintln!(
+                "  \x1b[33m!\x1b[0m skipped invalid asset catalog {}: {}",
+                warning.catalog_path, warning.reason
+            );
+        }
+
+        progress::summary(&format!(
+            "\n  {} nodes, {} edges indexed in {:.1}s",
+            graph.nodes.len(),
+            graph.edges.len(),
+            total_start.elapsed().as_secs_f64(),
+        ));
+
+        return Ok(());
+    }
+
     let save_result = std::thread::scope(|scope| {
         let save_handle = scope.spawn(|| {
             let t = Instant::now();

grapha/src/delta.rs

@@ -132,6 +132,15 @@ impl<'a> GraphDelta<'a> {
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.added_nodes.is_empty()
+            && self.updated_nodes.is_empty()
+            && self.deleted_node_ids.is_empty()
+            && self.added_edges.is_empty()
+            && self.updated_edges.is_empty()
+            && self.deleted_edge_ids.is_empty()
+    }
+
     pub fn node_stats(&self) -> EntitySyncStats {
         EntitySyncStats {
             added: self.added_nodes.len(),

grapha/src/store/sqlite/write.rs

@@ -154,21 +154,29 @@ pub(super) fn save_incremental(
     previous: Option<&grapha_core::graph::Graph>,
     graph: &grapha_core::graph::Graph,
 ) -> anyhow::Result<StoreWriteStats> {
-    let current_stats =
-        StoreWriteStats::from_graphs(previous, graph, crate::delta::SyncMode::Incremental);
-    let full_stats =
-        StoreWriteStats::from_graphs(previous, graph, crate::delta::SyncMode::FullRebuild);
-
     let conn = store.open_for_write()?;
     let schema_version = schema::schema_version(&conn)?;
     if previous.is_none() || schema_version.as_deref() != Some(schema::STORE_SCHEMA_VERSION) {
+        let full_stats =
+            StoreWriteStats::from_graphs(previous, graph, crate::delta::SyncMode::FullRebuild);
         drop(conn);
         save_full(store, graph)?;
         return Ok(full_stats);
     }
 
     let previous_graph = previous.expect("checked is_some above");
     let delta = GraphDelta::between(previous_graph, graph);
+
+    let stats = StoreWriteStats {
+        mode: crate::delta::SyncMode::Incremental,
+        nodes: delta.node_stats(),
+        edges: delta.edge_stats(),
+    };
+
+    if delta.is_empty() {
+        return Ok(stats);
+    }
+
     let tx = conn.unchecked_transaction()?;
     schema::write_meta(&tx, graph)?;
 
@@ -209,5 +217,5 @@ pub(super) fn save_incremental(
     tx.commit()?;
     conn.execute_batch("PRAGMA optimize;")?;
 
-    Ok(current_stats)
+    Ok(stats)
 }