SamuelSchlesinger
diff --git a/‎CLAUDE.md‎
Lines changed: 22 additions & 14 deletions b/‎CLAUDE.md‎
Lines changed: 22 additions & 14 deletions
diff --git a/‎src/application/state/command.rs‎
Lines changed: 44 additions & 17 deletions b/‎src/application/state/command.rs‎
Lines changed: 44 additions & 17 deletions
diff --git a/‎src/application/state/mod.rs‎
Lines changed: 13 additions & 7 deletions b/‎src/application/state/mod.rs‎
Lines changed: 13 additions & 7 deletions
@@ -38,7 +38,7 @@ src/
 
 **Formula Functions**: Registered in `FunctionRegistry` in `parser.rs`. All take `&[Value]` and return `Result<Value, String>`. The `Value` enum supports dual number/string types with `.to_number()`, `.to_string()`, and `.is_truthy()` conversions.
 
-**Cell Dependencies**: `Spreadsheet` tracks cell dependencies bidirectionally. When a cell changes via `set_cell()`, dependent cells automatically recalculate. Dependencies are not serialized - call `rebuild_dependencies()` after loading.
+**Cell Dependencies**: A single workbook-wide `WorkbookGraph` on `Workbook` tracks all dependencies (same-sheet AND cross-sheet) keyed by `NodeKey = (SheetId, row, col)`. Not serialized — lazily built by `Workbook::build_dep_graph_from_scratch` on first recalc. Per-sheet `dependents`/`dependencies` maps no longer exist (deleted with the legacy cascade). `Spreadsheet::set_cell` is a pure write — propagation goes through `Workbook::recalc_via_graph_result`, which the public `set_cell_on_active` / `write_cells_on_active` / `clear_*_on_active` mutators call internally. See "Calc engine architecture" below.
 
 **App Modes**: `AppMode` enum drives UI state. Each mode has a corresponding handler in `InputHandler` and rendering logic in `ui.rs`. State transitions go through methods on `App`.
 
@@ -50,9 +50,9 @@ src/
 
 **Cross-sheet structural edits**: `Workbook::insert_row_on_active`, `delete_row_on_active`, `insert_col_on_active`, `delete_col_on_active` perform the same-sheet structural mutation and also walk every OTHER sheet's formulas to shift any sheet-qualified refs to the mutated sheet (e.g. inserting a row at Sheet1!A5 shifts `=Sheet1!A5` to `=Sheet1!A6` on every other sheet). Refs to a deleted sheet's removed row/col become `#REF!`. Routes through `App::insert_row`/`delete_row`/etc.
 
-**Sheet rename/delete**: `Workbook::rename_sheet` rewrites all formula refs (and named-range values) from old to new name, then triggers cross-sheet propagation so dependents recompute. `Workbook::remove_sheet` rewrites every dangling `=GoneSheet!A1` on surviving sheets to `=#REF!` (Excel-equivalent), then purges the dep graph.
+**Sheet rename/delete**: `Workbook::rename_sheet` rewrites all formula refs (and named-range values) from old to new name, marks formula cells dirty, then triggers `recalc_via_graph_result()`. `Workbook::remove_sheet` rewrites every dangling `=GoneSheet!A1` on surviving sheets to `=#REF!` (Excel-equivalent), then calls `rebuild_cross_sheet_deps` (which wipes + rebuilds the unified graph from scratch).
 
-**Cross-sheet propagation helper**: `App::propagate_cell_change(row, col)` runs `register_cross_sheet_deps` + `propagate_cross_sheet_changes` on the workbook for the current sheet. Use it from any mutation path (cut, paste, replace_all, vim delete, undo/redo) that writes/clears cells outside of `set_cell_with_undo` / `clear_cell_with_undo`, which already call it internally.
+**Mutation API**: Single source of truth is `Workbook::set_cell_on_active` / `clear_cell_on_active` / `write_cells_on_active` / `clear_cells_on_active`. Each writes the cell(s) via `Spreadsheet::set_cell`/etc (pure writes — no cascade), updates the unified graph, marks dirty, and runs `recalc_via_graph_result()` to flush dependents. Callers outside the workbook should never call `Spreadsheet::set_cell` directly — they'd write the value but skip propagation. The application-level helper `App::propagate_cell_change(row, col)` is kept for bespoke paths that need to manually flush but is rarely needed (the standard mutators auto-flush).
 
 ## Testing
 
@@ -85,27 +85,35 @@ Gotchas when writing new PTY tests:
 
 ## Calc engine architecture
 
-tshts ships two recalc engines that produce identical results:
+tshts has ONE recalc engine: the unified graph-driven level executor. (The legacy per-sheet `recalculate_dependents` cascade and the `propagate_cross_sheet_changes*` family were deleted — see "Mutation discipline" below.)
 
-**Legacy per-sheet cascade**: `Spreadsheet::set_cell` triggers `recalculate_dependents` which BFSes the per-sheet `dependents` HashMap. Cross-sheet propagation runs as a separate `Workbook::propagate_cross_sheet_changes` pass. This is the path most user edits flow through (every `set_cell_on_active` / `write_cells_on_active` call).
+**The graph**: `Workbook::graph` is a workbook-wide `WorkbookGraph` keyed by `NodeKey = (SheetId, row, col)`. Bidirectional: `dependencies[N]` is the set of cells `N` reads, `dependents[N]` is the set of cells that read `N`. Same-sheet AND cross-sheet edges live in this one structure. Built lazily via `Workbook::build_dep_graph_from_scratch` (called from `register_cross_sheet_deps` on the first write, on load, and after structural edits) and maintained incrementally by `register_cross_sheet_deps` per write.
 
-**Graph-driven level executor**: `Workbook::recalc_via_graph` builds the unified workbook-level dep graph (`WorkbookGraph`, keyed by stable `SheetId(u32)`), drains the dirty set, computes topological levels via Kahn's algorithm, and walks levels in order. Each level evaluates against an immutable workbook snapshot; results merge back at the level boundary. Used by `:recalc` (`App::recalc_all`).
+**`Workbook::cell_purities`** is the parallel-keyed cache of per-cell `FunctionPurity` classifications. Pure cells are stored implicitly (absent from the map). Volatile / side-effecting cells are explicit.
+
+**`Workbook::structural_targets`** is the per-`VolatileStructural`-cell cache of the dynamic targets (INDIRECT/OFFSET resolved cells) recorded after the last eval. Smart auto-seed compares against the user-dirty closure to decide whether to re-seed.
+
+**Mutation discipline**: `Workbook::set_cell_on_active` / `clear_cell_on_active` / `write_cells_on_active` / `clear_cells_on_active` are the only public single-source-of-truth mutation APIs. Each one writes the cell(s) via `Spreadsheet::set_cell`/`clear_cell`/`set_many`/`clear_many` (which are pure writes — no cascade), updates the unified graph via `register_cross_sheet_deps`, marks dirty, and triggers a single `recalc_via_graph_result()` that propagates to all dependents. `Spreadsheet::set_cell` directly is reserved for low-level test fixtures and intra-engine machinery (the iterative-cyclic loop).
+
+**`Workbook::recalc_via_graph_result`** is the entry point — drains `dirty`, builds `seeds`, computes `transitive_dependents` + topological levels via Kahn's algorithm, dispatches to an executor. Self-loops are retained in the graph (they're cyclic — see "Iterative calc" below).
 
 The executor is pluggable via the `RecalcExecutor` trait (`src/domain/services/executor.rs`):
-- `SequentialExecutor` — single-threaded reference impl.
-- `ParallelExecutor` — rayon-based; partitions each level by function purity, dispatches pure cells via `par_iter().with_min_len(64)`, runs structural-volatile (`INDIRECT`, `OFFSET`) and side-effecting (`GET`) cells serially within the level barrier. Falls back to sequential below `parallel_threshold`.
+- `SequentialExecutor` — single-threaded reference impl. One workbook snapshot for the whole recalc, mutated between levels so the next level reads fresh values from prior levels.
+- `ParallelExecutor` — rayon-based; partitions each level by function purity, dispatches pure cells via `par_iter().with_min_len(K)`, runs structural-volatile (`INDIRECT`, `OFFSET`) and side-effecting (`GET`) cells serially within the level barrier. Uses `Arc<Workbook>` snapshot reused across levels via `Arc::make_mut` at the level boundary (refcount = 1 after `par_iter().collect()`).
 
-`recalc_via_graph` auto-selects between the two: Parallel when any level has ≥ `TSHTS_PAR_THRESHOLD` cells (default 512), otherwise Sequential. Below that the per-level workbook clone dominates the parallel savings.
+`recalc_via_graph` auto-selects: Parallel when any level has ≥ `TSHTS_PAR_THRESHOLD` cells (default 512), otherwise Sequential.
 
-**Tuning**: set `TSHTS_PAR_THRESHOLD=N` to change the parallel-dispatch cutoff. `RAYON_NUM_THREADS=N` controls worker count. `cargo bench --bench calc_engine` runs the archetype benchmarks (wide/deep/fanout × small/medium/large) so you can pick a threshold that matches your workload.
+**Tuning**: `TSHTS_PAR_THRESHOLD=N` for parallel-dispatch cutoff. `RAYON_NUM_THREADS=N` for worker count. `cargo bench --bench calc_engine` runs the archetype benchmarks.
 
 **Volatile semantics** (matched to Excel/OpenFormula):
 - `NOW`/`TODAY` read a clock snapshot captured at recalc start (via the `RECALC_CLOCK` thread-local published by each executor's `run`). Two clock-volatile cells in the same pass return identical values; calls outside a recalc fall back to `SystemTime::now()`.
-- `RAND`/`RANDBETWEEN` use a thread-local PRNG; cross-worker non-determinism is the intended trade — within a pass each worker's outputs are independent.
-- `OFFSET`/`INDIRECT` are tagged `VolatileStructural` and auto-seeded into the dirty set on every recalc, so changes to their value-derived targets propagate through their static dependents within one pass (matches Excel's "always recompute volatile").
-- `GET` is `SideEffecting`; serialized via the existing HTTP-fetcher worker (no executor changes needed).
+- `RAND`/`RANDBETWEEN` use a thread-local PRNG.
+- `OFFSET`/`INDIRECT` are tagged `VolatileStructural` and consulted via the smart auto-seed: a structural cell is seeded into the dirty set only when its recorded `structural_targets` intersect the user-dirty closure.
+- `GET` is `SideEffecting`; serialized via the HTTP-fetcher worker (cache-seeded for tests via `fetcher::test_hooks`).
+
+**Iterative calc**: `Workbook::iterative_calc_cyclic` runs over the cyclic remainder from `topo_levels_from_seeds`. Gauss-Seidel-style: each pass evaluates against a fresh snapshot, mutates the live workbook between passes. Uses the highest `iter_max` and tightest `iter_epsilon` across participating sheets. Two-pass string stability for non-numeric flip-flop detection.
 
-**Cross-sheet cycles**: handled by `Workbook::iterative_calc_cyclic` — a workbook-level Gauss-Seidel loop that walks every cyclic cell across all sheets per pass. Uses the highest `iter_max` and tightest `iter_epsilon` across participating sheets. Detects non-convergence (returns `Err(iter_max)`) and handles non-numeric flip-flop via two-pass string stability. Per-pass post-write maintenance (CF cache, spill ghosts, `maybe_spill`) is performed inside `with_recalc_context` to mirror the acyclic path.
+**Non-convergence is strict**: cycles that exhaust `iter_max` without converging get `#NUM!` written to every cyclic cell (rather than the iter_max'th iteration value, which would be a misleading artifact of the setting). `CalcError::DidNotConverge` is returned and bubbles to `App::status_message` via `recalc_via_graph_result`. Convergent cycles (legitimate fixed-point iteration like `=A1/2+1 → 2`) get the converged value, no error. Self-loops (`=A1+1` written to A1) are normal cycles: routed to `iterative_calc_cyclic` like any other cyclic remainder.
 
 ## Dependencies
 
 
@@ -863,23 +863,50 @@ impl App {
                 }
             }
             ["trace", "dependents"] => {
-                let pos = (self.selected_row, self.selected_col);
-                let deps = self.workbook.current_sheet().dependents.get(&pos).cloned();
-                match deps {
-                    Some(set) if !set.is_empty() => {
-                        let s: Vec<String> = set
-                            .iter()
-                            .map(|(r, c)| {
-                                format!(
-                                    "{}{}",
-                                    crate::domain::Spreadsheet::column_label(*c),
-                                    r + 1
-                                )
-                            })
-                            .collect();
-                        self.status_message = Some(format!("Dependents: {}", s.join(", ")));
-                    }
-                    _ => self.status_message = Some("(no dependents)".to_string()),
+                // Walk the unified workbook graph for cells that read
+                // (sheet, row, col). The graph is keyed by NodeKey =
+                // (SheetId, row, col) and is the single source of truth
+                // post-cascade-removal.
+                let sheet_idx = self.workbook.active_sheet;
+                let sheet_id = self.workbook.sheet_ids[sheet_idx];
+                let node = (sheet_id, self.selected_row, self.selected_col);
+                let mut seed = std::collections::HashSet::new();
+                seed.insert(node);
+                let downstream: Vec<_> = self
+                    .workbook
+                    .graph
+                    .transitive_dependents(&seed)
+                    .into_iter()
+                    .filter(|d| *d != node) // strip self
+                    .collect();
+                if downstream.is_empty() {
+                    self.status_message = Some("(no dependents)".to_string());
+                } else {
+                    let mut labels: Vec<String> = downstream
+                        .iter()
+                        .map(|(sid, r, c)| {
+                            let sheet_name = self
+                                .workbook
+                                .sheet_ids
+                                .iter()
+                                .position(|s| s == sid)
+                                .map(|i| self.workbook.sheet_names[i].clone())
+                                .unwrap_or_else(|| "?".to_string());
+                            let same_sheet = *sid == sheet_id;
+                            let cell_label = format!(
+                                "{}{}",
+                                crate::domain::Spreadsheet::column_label(*c),
+                                r + 1
+                            );
+                            if same_sheet {
+                                cell_label
+                            } else {
+                                format!("{}!{}", sheet_name, cell_label)
+                            }
+                        })
+                        .collect();
+                    labels.sort();
+                    self.status_message = Some(format!("Dependents: {}", labels.join(", ")));
                 }
             }
             ["table", "list"] => {
 
@@ -368,11 +368,12 @@ fn restore_workbook(workbook: &mut Workbook, pre: &Workbook) {
 fn restore_cell(workbook: &mut Workbook, row: usize, col: usize, data: Option<&CellData>) {
     // Route through the workbook chokepoints so the dirty set is
     // populated; undo/redo were previously skipping dirty entirely.
+    // `set_cell_on_active` / `clear_cell_on_active` both run a single
+    // graph-driven recalc internally, so no separate propagate call.
     match data {
         Some(d) => workbook.set_cell_on_active(row, col, d.clone()),
         None => workbook.clear_cell_on_active(row, col),
     }
-    workbook.propagate_active_cell(row, col);
 }
 
 /// Bulk-apply CellModified-style entries from a batch in O(N) total —
@@ -426,7 +427,6 @@ where
     // The legacy per-sheet dep graph needs rebuilding because we
     // bypassed `add_cell_dependencies`. The unified graph gets
     // rebuilt lazily inside recalc_via_graph_result.
-    workbook.sheets[active_idx].rebuild_dependencies();
     workbook.rebuild_cross_sheet_deps();
     workbook.build_dep_graph_from_scratch();
     // Use the Result variant — the eprintln-swallowing wrapper would
@@ -740,7 +740,6 @@ impl App {
             // Keep the per-sheet dep graph in sync — the legacy cross-
             // sheet engine still reads it, and `build_dep_graph_from_scratch`
             // uses the per-sheet refs as input.
-            sheet.rebuild_dependencies();
             // Mark every formula cell on this sheet dirty.
             let name = self.workbook.sheet_names[idx].clone();
             for (&(r, c), cd) in &sheet.cells {
@@ -810,11 +809,18 @@ impl App {
         }
     }
 
-    /// Cross-sheet propagation hook for cell mutations that don't go through
-    /// `Workbook::write_cells_on_active`. Forwards to the workbook, which
-    /// owns the actual dep registration + propagation logic.
+    /// Propagation hook for cell mutations that don't go through
+    /// `Workbook::write_cells_on_active`. With the unified graph executor
+    /// as the single source of truth, propagation is just "mark dirty
+    /// + recalc," which `set_cell_on_active` already does. This helper
+    /// stays for callers that wrote a cell via some bespoke path and
+    /// then explicitly want to flush; today it just runs a recalc.
     pub(crate) fn propagate_cell_change(&mut self, row: usize, col: usize) {
-        self.workbook.propagate_active_cell(row, col);
+        // Mark the cell dirty (the bespoke caller may not have done it)
+        // and run the unified recalc.
+        let sheet_name = self.workbook.sheet_names[self.workbook.active_sheet].clone();
+        self.workbook.mark_dirty(&sheet_name, row, col);
+        let _ = self.workbook.recalc_via_graph_result();
     }
 
     pub fn redo(&mut self) {