fix(calc): NOW/TODAY clock at autofill/paste/command, formatted-value tests

### NOW/TODAY clock at user-action boundaries beyond editing

Tier 2 fixed the interactive-edit path (editing.rs). The other user-
action eval sites had the same NOW/TODAY divergence on multi-cell ops:

  * autofill.rs — both row and column autofill paths
  * clipboard.rs — multi-cell paste + single-cell paste
  * command.rs — `:table create` initial value eval

Each now wraps its `evaluator.evaluate_formula` call in
`with_recalc_clock(now_serial(), || ...)` so any volatile cells in the
filled / pasted / created formulas see the same clock the immediately-
following auto-recalc will. Previously, an autofilled column of `=NOW()`
formulas could briefly flash with multiple distinct wall-clock times
before the recalc collapsed them onto a single snapshot — now the
filled values agree from the start.

### Expanded executor-parity fuzz to 6 formula shapes

Was: only `+ - *` on cell refs. Now picks per cell from:

  * arithmetic chain (original)
  * IF with `>`-comparison branches
  * SUM over a B-column helper sub-range
  * MAX over a B-column helper sub-range
  * ABS of a referenced cell
  * VLOOKUP (approximate-match) into the helper column

A small mirror block in column B (cells 0..helpers) gives range-aware
functions something contiguous to consult. 20 random seeds still pass —
the property is "Sequential and Parallel agree on every cell," and the
expanded coverage exercises far more of the executor's per-purity
dispatch surface.

### Number-formatting scenario + 2 product fixes it caught

New scenario `formatting` puts (raw value, format command) pairs into
column A and asserts the rendered cell text contains the expected
formatted substring (e.g. raw=9876.54 + currency → "$9,876.54").
Framework gains a `rendered_text_checks` method on Scenario (defaults
empty) and a `RenderedTextCheck` type. Runner asserts post-recalc and
post-auto-fit.

The scenario caught two real product bugs:

  * **Currency rendered sign in wrong place.** -42.5 with currency
    format displayed as `$-42.50`. Excel convention is `-$42.50` —
    sign BEFORE the symbol. Fixed in `style::format_cell_value`
    (Currency branch): format the absolute value, then prepend sign.
  * **Auto-resize ignored formatted width.** `auto_resize_column` and
    `auto_resize_all_columns` measured `cell.value.width()` (raw),
    so a `9876.54` raw value sized to 7 chars even though the
    currency-formatted display needs 9. Both helpers now call
    `format_cell_value` to size by what the user actually sees.

Tests: 592 lib + 19 PTY scenarios (+1 formatting) + all 11 PTY suites
green. Zero warnings.

Author: SamuelSchlesinger

src/application/state/autofill.rs

@@ -105,7 +105,13 @@ impl App {
                         continue;
                     }
 
-                    let new_value = evaluator.evaluate_formula(&adjusted_formula);
+                    // Publish a clock so any NOW()/TODAY() in the autofilled
+                    // formula uses the same snapshot the auto-recalc will,
+                    // and so all cells filled in this batch agree on time.
+                    let new_value = crate::domain::parser::with_recalc_clock(
+                        crate::domain::parser::now_serial(),
+                        || evaluator.evaluate_formula(&adjusted_formula),
+                    );
                     changes.push((*target_row, col, CellData {
                         value: new_value,
                         formula: Some(adjusted_formula),
@@ -189,7 +195,11 @@ impl App {
                         continue;
                     }
 
-                    let new_value = evaluator.evaluate_formula(&adjusted_formula);
+                    // See row-autofill path above for the clock-publish rationale.
+                    let new_value = crate::domain::parser::with_recalc_clock(
+                        crate::domain::parser::now_serial(),
+                        || evaluator.evaluate_formula(&adjusted_formula),
+                    );
                     changes.push((row, *target_col, CellData {
                         value: new_value,
                         formula: Some(adjusted_formula),

src/application/state/clipboard.rs

@@ -202,27 +202,33 @@ impl App {
         let dest_row = self.selected_row;
         let dest_col = self.selected_col;
 
-        // Compute all new cells first (evaluator borrows spreadsheet immutably)
-        let new_cells: Vec<_> = {
-            let evaluator = crate::domain::FormulaEvaluator::new(self.workbook.current_sheet());
-            clipboard.cells.iter().filter_map(|(row_off, col_off, cell)| {
-                let target_row = dest_row + row_off;
-                let target_col = dest_col + col_off;
-                if target_row >= self.workbook.current_sheet().rows || target_col >= self.workbook.current_sheet().cols {
-                    return None;
-                }
-                let new_cell = if let Some(ref formula) = cell.formula {
-                    let row_offset = target_row as i32 - (clipboard.source_row + row_off) as i32;
-                    let col_offset = target_col as i32 - (clipboard.source_col + col_off) as i32;
-                    let adjusted = evaluator.adjust_formula_references(formula, row_offset, col_offset);
-                    let value = evaluator.evaluate_formula(&adjusted);
-                    CellData { value, formula: Some(adjusted), format: cell.format.clone(), comment: cell.comment.clone(), spill_anchor: None }
-                } else {
-                    cell.clone()
-                };
-                Some((target_row, target_col, new_cell))
-            }).collect()
-        };
+        // Compute all new cells first (evaluator borrows spreadsheet immutably).
+        // One clock snapshot for the whole paste so any pasted =NOW() cells
+        // agree on time, and so they match what the auto-recalc immediately
+        // following will use.
+        let new_cells: Vec<_> = crate::domain::parser::with_recalc_clock(
+            crate::domain::parser::now_serial(),
+            || {
+                let evaluator = crate::domain::FormulaEvaluator::new(self.workbook.current_sheet());
+                clipboard.cells.iter().filter_map(|(row_off, col_off, cell)| {
+                    let target_row = dest_row + row_off;
+                    let target_col = dest_col + col_off;
+                    if target_row >= self.workbook.current_sheet().rows || target_col >= self.workbook.current_sheet().cols {
+                        return None;
+                    }
+                    let new_cell = if let Some(ref formula) = cell.formula {
+                        let row_offset = target_row as i32 - (clipboard.source_row + row_off) as i32;
+                        let col_offset = target_col as i32 - (clipboard.source_col + col_off) as i32;
+                        let adjusted = evaluator.adjust_formula_references(formula, row_offset, col_offset);
+                        let value = evaluator.evaluate_formula(&adjusted);
+                        CellData { value, formula: Some(adjusted), format: cell.format.clone(), comment: cell.comment.clone(), spill_anchor: None }
+                    } else {
+                        cell.clone()
+                    };
+                    Some((target_row, target_col, new_cell))
+                }).collect()
+            },
+        );
 
         // Now apply changes (mutably borrows spreadsheet) — collect the
         // undo batch, then push all writes through `set_many` in one shot
@@ -315,7 +321,11 @@ impl App {
                         }
                     }
                     let evaluator = FormulaEvaluator::new(self.workbook.current_sheet());
-                    let evaluated = evaluator.evaluate_formula(value);
+                    // Same clock-publish rationale as the multi-cell paste path.
+                    let evaluated = crate::domain::parser::with_recalc_clock(
+                        crate::domain::parser::now_serial(),
+                        || evaluator.evaluate_formula(value),
+                    );
                     CellData {
                         value: evaluated,
                         formula: Some(value.to_string()),

src/application/state/command.rs

@@ -742,7 +742,12 @@ impl App {
                             self.workbook.current_sheet(),
                             &self.workbook.named_ranges,
                         );
-                        let initial = evaluator.evaluate_formula(&formula);
+                        // Publish a clock for the same NOW()/TODAY()
+                        // consistency reason as the editing/autofill/paste paths.
+                        let initial = crate::domain::parser::with_recalc_clock(
+                            crate::domain::parser::now_serial(),
+                            || evaluator.evaluate_formula(&formula),
+                        );
                         rows.push((
                             t.0 + 1 + i,
                             t.1 + 1,

src/domain/models/spreadsheet.rs

@@ -585,11 +585,21 @@ impl Spreadsheet {
     /// viewport so a single wide cell can't push other columns off-screen).
     pub fn auto_resize_column_with_cap(&mut self, col: usize, max_cap: usize) {
         use unicode_width::UnicodeWidthStr;
+        use super::style::format_cell_value;
         let mut max_width = Self::column_label(col).width();
 
         for (&(_, c), cell) in &self.cells {
             if c == col {
-                let value_width = cell.value.width();
+                // The rendered width drives the auto-fit, not the raw
+                // value's width. A cell with raw "9876.54" and currency
+                // format displays as "$9,876.54" (9 chars vs 7); sizing
+                // by raw width would clip the displayed text.
+                let displayed = if let Some(ref fmt) = cell.format {
+                    format_cell_value(&cell.value, fmt)
+                } else {
+                    cell.value.clone()
+                };
+                let value_width = displayed.width();
                 let formula_width = cell.formula.as_ref().map(|f| f.width()).unwrap_or(0);
                 let content_width = value_width.max(formula_width);
                 max_width = max_width.max(content_width);
@@ -606,12 +616,19 @@ impl Spreadsheet {
     /// O(cols × cells) — the per-column loop iterated the entire HashMap.
     pub fn auto_resize_all_columns(&mut self) {
         use unicode_width::UnicodeWidthStr;
+        use super::style::format_cell_value;
         let mut widths: HashMap<usize, usize> = HashMap::with_capacity(self.cols);
         for col in 0..self.cols {
             widths.insert(col, Self::column_label(col).width());
         }
         for (&(_, c), cell) in &self.cells {
-            let value_width = cell.value.width();
+            // Width the user sees, not raw — see auto_resize_column_with_cap.
+            let displayed = if let Some(ref fmt) = cell.format {
+                format_cell_value(&cell.value, fmt)
+            } else {
+                cell.value.clone()
+            };
+            let value_width = displayed.width();
             let formula_width = cell.formula.as_ref().map(|f| f.width()).unwrap_or(0);
             let content_width = value_width.max(formula_width);
             let entry = widths.entry(c).or_insert(3);

src/domain/models/style.rs

@@ -109,8 +109,18 @@ pub fn format_cell_value(value: &str, format: &CellFormat) -> String {
         }
         NumberFormat::Currency { symbol, decimals } => {
             if let Ok(n) = value.parse::<f64>() {
-                let formatted = format!("{:.prec$}", n, prec = *decimals as usize);
-                format!("{}{}", symbol, add_thousands_separator(&formatted))
+                // Excel convention: sign goes BEFORE the currency symbol
+                // ("-$42.50"), not between the symbol and the magnitude
+                // ("$-42.50"). Format the absolute value, then prepend
+                // the sign manually so the symbol always sits next to
+                // the digits.
+                let abs_formatted = format!("{:.prec$}", n.abs(), prec = *decimals as usize);
+                let body = add_thousands_separator(&abs_formatted);
+                if n < 0.0 {
+                    format!("-{}{}", symbol, body)
+                } else {
+                    format!("{}{}", symbol, body)
+                }
             } else {
                 value.to_string()
             }

src/domain/services/executor.rs

@@ -811,36 +811,97 @@ mod tests {
         let n_literals = (n_cells as u32 / 3).max(3);     // ~1/3 literals
         let mut cells: Vec<(usize, usize, String)> = Vec::new();
         // Literals come first so later formulas always have something
-        // to reference.
+        // to reference. Mix integers and small positive numbers so
+        // SUMPRODUCT and IF-comparison branches see varied inputs.
         for i in 0..n_literals {
-            // Random integer in [-50, 50]. Avoid floats here so string
-            // comparison is stable across the two executors.
             let v = ((next() % 100) as i64) - 50;
             cells.push((i as usize, 0, v.to_string()));
         }
+        // Build a few helper cells in column B so range-aware functions
+        // (SUM, AVERAGE, VLOOKUP) have a contiguous block to consult.
+        // These are mirrors of column A's first ten literals.
+        let n_helpers = n_literals.min(10) as usize;
+        for i in 0..n_helpers {
+            cells.push((i, 1, format!("=A{}", i + 1)));
+        }
         for i in n_literals..(n_cells as u32) {
             let row = i as usize;
-            // Pick 1..=3 earlier cells to combine.
-            let n_refs = 1 + (next() % 3) as usize;
-            let mut formula = String::from("=");
-            for j in 0..n_refs {
-                if j > 0 {
-                    let op = match next() % 4 {
-                        0 => '+',
-                        1 => '-',
-                        2 => '*',
-                        _ => '+', // skip '/' to avoid #DIV/0! noise
-                    };
-                    formula.push(op);
-                }
-                let pick = (next() as usize) % (i as usize);
-                formula.push_str(&format!("A{}", pick + 1));
-            }
+            // Pick a random shape per cell — operator chain, IF, SUM,
+            // MAX, ABS, or VLOOKUP. Each path exercises a different
+            // executor surface; if Sequential and Parallel diverge on
+            // any of them, the fuzz catches it.
+            let formula = match next() % 6 {
+                0 => gen_arith(&mut next, i),
+                1 => gen_if(&mut next, i),
+                2 => gen_sum_range(&mut next, i, n_helpers),
+                3 => gen_max_range(&mut next, i, n_helpers),
+                4 => gen_abs(&mut next, i),
+                _ => gen_vlookup(&mut next, i, n_helpers),
+            };
             cells.push((row, 0, formula));
         }
         cells
     }
 
+    fn gen_arith(next: &mut impl FnMut() -> u32, i: u32) -> String {
+        let n_refs = 1 + (next() % 3) as usize;
+        let mut f = String::from("=");
+        for j in 0..n_refs {
+            if j > 0 {
+                let op = match next() % 4 {
+                    0 => '+',
+                    1 => '-',
+                    2 => '*',
+                    _ => '+', // skip '/' to avoid #DIV/0! noise
+                };
+                f.push(op);
+            }
+            let pick = (next() as usize) % (i as usize);
+            f.push_str(&format!("A{}", pick + 1));
+        }
+        f
+    }
+
+    fn gen_if(next: &mut impl FnMut() -> u32, i: u32) -> String {
+        let a = (next() as usize) % (i as usize) + 1;
+        let b = (next() as usize) % (i as usize) + 1;
+        let c = (next() as usize) % (i as usize) + 1;
+        let d = (next() as usize) % (i as usize) + 1;
+        format!("=IF(A{}>A{},A{},A{})", a, b, c, d)
+    }
+
+    fn gen_sum_range(next: &mut impl FnMut() -> u32, _i: u32, helpers: usize) -> String {
+        if helpers < 2 { return "=0".to_string(); }
+        // Sum a sub-range of column B (the helpers).
+        let lo = (next() as usize) % helpers;
+        let hi_extra = (next() as usize) % (helpers - lo);
+        let hi = lo + hi_extra;
+        format!("=SUM(B{}:B{})", lo + 1, hi + 1)
+    }
+
+    fn gen_max_range(next: &mut impl FnMut() -> u32, _i: u32, helpers: usize) -> String {
+        if helpers < 2 { return "=0".to_string(); }
+        let lo = (next() as usize) % helpers;
+        let hi_extra = (next() as usize) % (helpers - lo);
+        let hi = lo + hi_extra;
+        format!("=MAX(B{}:B{})", lo + 1, hi + 1)
+    }
+
+    fn gen_abs(next: &mut impl FnMut() -> u32, i: u32) -> String {
+        let pick = (next() as usize) % (i as usize) + 1;
+        format!("=ABS(A{})", pick)
+    }
+
+    fn gen_vlookup(next: &mut impl FnMut() -> u32, _i: u32, helpers: usize) -> String {
+        if helpers < 2 { return "=0".to_string(); }
+        // VLOOKUP into B's helper column. Use approximate-match
+        // (TRUE) since helpers may not be sorted — Excel returns the
+        // last-matching key in approximate mode regardless. Both
+        // executors should behave identically.
+        let target = (next() as usize) % helpers + 1;
+        format!("=IFERROR(VLOOKUP(A{},B1:B{},1,TRUE),0)", target, helpers)
+    }
+
     /// Single-snapshot recalc must propagate per-level writes into the
     /// snapshot the next level reads from. Without that, a depth-3
     /// chain (A1=lit, A2=A1+1, A3=A2+1) would have A3 reading A2's