fix(perturbation-sim): address Codex P2 review on #504

P2-1 (Cargo.toml): the optional ndarray dep was a PATH dep — Cargo reads the
path manifest at resolution, so a clean checkout without ../../../ndarray failed
even with ndarray-simd OFF, breaking the zero-dep default. Switched to the GIT
source (helix pattern): it resolves remotely and is only fetched/built when the
feature activates it. Verified: default `cargo test` now resolves the git dep
without any local sibling — 49 tests pass.

P2-2 (cascade.rs): edge_field recorded the all-lines BASE flow for lines that
trip in later rounds, underreporting redistribution-driven trips (a line with
~0 base flow that trips on a large redistributed flow showed ~0 footprint). Now
capture trip_flow[e] = the current-round flow at the round each line trips
(seed/survivors default to base); edge_field for a tripped line uses that
overload. New regression test round_trip_edge_field_is_the_overload_not_base
asserts a round-≥1 trip's edge_field exceeds its limit.

49 tests pass; clippy -D warnings clean; fmt clean.

Author: claude

crates/perturbation-sim/Cargo.lock

@@ -20,11 +20,13 @@ ndarray-simd = ["dep:ndarray"]
 
 [dependencies]
 # The AdaWorldAPI fork ("The Foundation"), optional + behind `ndarray-simd`.
-# Path dep: perturbation-sim lives inside lance-graph, which already path-deps
-# this sibling for its core crates, so the fork is expected present. Clean-
-# checkout alternative (helix pattern): swap to
-#   ndarray = { git = "https://github.com/AdaWorldAPI/ndarray.git", branch = "master", optional = true, default-features = false, features = ["std"] }
-ndarray = { path = "../../../ndarray", optional = true, default-features = false, features = ["std"] }
+# Sourced by GIT (not a local path): an optional *path* dep is read at manifest
+# resolution, so a clean checkout without the sibling `../../../ndarray` fails
+# even with the feature OFF — breaking the zero-dep default (codex P2 on #504,
+# the helix-#460 lesson). A git source resolves remotely and is only fetched/
+# built when `ndarray-simd` activates it. Local-dev alternative: swap to
+#   ndarray = { path = "../../../ndarray", optional = true, default-features = false, features = ["std"] }
+ndarray = { git = "https://github.com/AdaWorldAPI/ndarray.git", branch = "master", optional = true, default-features = false, features = ["std"] }
 
 [lib]
 name = "perturbation_sim"

crates/perturbation-sim/Cargo.toml

@@ -112,6 +112,10 @@ pub fn simulate_outage(
     alive[seed_line] = false;
     let mut trip_round = vec![-1i32; m];
     trip_round[seed_line] = 0;
+    // Flow each line carried in the round it tripped (the overload that caused
+    // it). Seeded with the base flow so the seed line — and any survivor —
+    // defaults sensibly; round-trips overwrite with their current-round flow.
+    let mut trip_flow = flow_base.clone();
 
     // Assigned on every loop iteration before any break (the loop body always
     // runs at least once), so no initializer is needed.
@@ -149,6 +153,7 @@ pub fn simulate_outage(
         for e in new_trips {
             alive[e] = false;
             trip_round[e] = rounds as i32;
+            trip_flow[e] = flow[e]; // the overloaded flow that tripped it
         }
     }
 
@@ -159,7 +164,7 @@ pub fn simulate_outage(
             if alive[e] {
                 (flow[e] - flow_base[e]).abs()
             } else {
-                flow_base[e].abs()
+                trip_flow[e].abs()
             }
         })
         .collect();
@@ -229,6 +234,38 @@ mod tests {
         assert!(r.shape.node_field.iter().any(|&x| x > 1e-9));
     }
 
+    #[test]
+    fn round_trip_edge_field_is_the_overload_not_base() {
+        // A line that trips in a later round tripped because its REDISTRIBUTED
+        // flow exceeded its limit — so its edge_field must be that overload
+        // (> limit), not its (smaller) base flow. Guards the Codex P2 fix.
+        let g = Grid::new(
+            4,
+            vec![
+                Edge::new(0, 1, 1.0, 0.6),
+                Edge::new(1, 2, 1.0, 0.6),
+                Edge::new(2, 3, 1.0, 0.6),
+                Edge::new(3, 0, 1.0, 0.6),
+            ],
+        );
+        let p = vec![1.0, 0.0, -1.0, 0.0];
+        let r = simulate_outage(&g, &p, 0, CascadeConfig::default());
+        let mut checked = 0;
+        for e in 0..g.edges.len() {
+            if r.shape.trip_round[e] >= 1 {
+                assert!(
+                    r.shape.edge_field[e] > g.edges[e].limit - 1e-9,
+                    "round-{} trip {e}: edge_field {} should be the overload (> limit {})",
+                    r.shape.trip_round[e],
+                    r.shape.edge_field[e],
+                    g.edges[e].limit
+                );
+                checked += 1;
+            }
+        }
+        assert!(checked >= 1, "expected at least one round-≥1 trip to check");
+    }
+
     #[test]
     fn islanding_is_flagged() {
         // Two triangles + one bridge; tripping the bridge islands the grid.