refinedigital
diff --git a/‎crates/ruvector-nervous-system/Cargo.toml‎
Lines changed: 5 additions & 0 deletions b/‎crates/ruvector-nervous-system/Cargo.toml‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎crates/ruvector-nervous-system/tests/ewc_tests.rs‎
Lines changed: 77 additions & 18 deletions b/‎crates/ruvector-nervous-system/tests/ewc_tests.rs‎
Lines changed: 77 additions & 18 deletions
@@ -36,6 +36,11 @@ approx = "0.5"
 default = ["parallel"]
 serde = ["dep:bincode"]
 parallel = ["rayon"]
+# Gate absolute throughput / latency assertions in tests behind this feature.
+# `cargo test` (no features) runs the smoke versions only — they exercise the
+# code paths and assert correctness. `cargo test --features perf-tests` adds
+# the absolute-threshold variants intended for tuned/release-mode runners.
+perf-tests = []
 
 [[bench]]
 name = "pattern_separation"
 
@@ -1,3 +1,14 @@
+// EWC tests
+//
+// Smoke vs perf split convention
+// ------------------------------
+// `test_performance_targets` is split into a smoke version (always-on,
+// asserts only correctness — Fisher computation completes, gradients are
+// finite) and `test_performance_targets_perf` (gated behind
+// `#[cfg(feature = "perf-tests")]`) which keeps the absolute latency
+// thresholds. Run perf with
+// `cargo test -p ruvector-nervous-system --features perf-tests`.
+
 use ruvector_nervous_system::plasticity::consolidate::{
     ComplementaryLearning, Experience, RewardConsolidation, EWC,
 };
@@ -273,11 +284,19 @@ fn test_interleaved_training_balancing() {
     assert!(cls.hippocampus_size() > 50);
 }
 
-#[test]
-fn test_performance_targets() {
+/// Returns `(ewc, fisher_time, loss, loss_time, grad, grad_time)` after
+/// driving the standard EWC perf workload (Fisher / loss / gradient on 1M
+/// params). Shared between the smoke and perf variants below.
+fn run_ewc_perf_workload() -> (
+    EWC,
+    std::time::Duration,
+    f32,
+    std::time::Duration,
+    Vec<f32>,
+    std::time::Duration,
+) {
     use std::time::Instant;
 
-    // Fisher computation: <100ms for 1M parameters
     let mut ewc = EWC::new(1000.0);
     let params = vec![0.5; 1_000_000];
     let gradients: Vec<Vec<f32>> = (0..50).map(|_| vec![0.1; 1_000_000]).collect();
@@ -286,35 +305,75 @@ fn test_performance_targets() {
     ewc.compute_fisher(&params, &gradients).unwrap();
     let fisher_time = start.elapsed();
 
+    let new_params = vec![0.6; 1_000_000];
+
+    let start = Instant::now();
+    let loss = ewc.ewc_loss(&new_params);
+    let loss_time = start.elapsed();
+
+    let start = Instant::now();
+    let grad = ewc.ewc_gradient(&new_params);
+    let grad_time = start.elapsed();
+
+    (ewc, fisher_time, loss, loss_time, grad, grad_time)
+}
+
+#[test]
+fn test_performance_targets() {
+    // Smoke: exercise Fisher / loss / gradient at 1M params and verify the
+    // outputs are well-formed. No absolute timing assertion; see
+    // `test_performance_targets_perf` for the threshold gate.
+    let (ewc, fisher_time, loss, loss_time, grad, grad_time) = run_ewc_perf_workload();
+
+    println!("Fisher computation (1M params): {:?}", fisher_time);
+    println!("EWC loss (1M params): {:?}  loss={}", loss_time, loss);
+    println!("EWC gradient (1M params): {:?}", grad_time);
+
+    // Functional assertions — all three operations must produce sane output.
+    assert_eq!(
+        ewc.num_params(),
+        1_000_000,
+        "Fisher computation must record param count"
+    );
+    assert!(loss.is_finite(), "EWC loss must be finite, got {}", loss);
+    assert_eq!(
+        grad.len(),
+        1_000_000,
+        "EWC gradient must have one entry per parameter"
+    );
+    assert!(
+        grad.iter().all(|g| g.is_finite()),
+        "all EWC gradient entries must be finite"
+    );
+    assert!(
+        grad.iter().all(|g| *g >= 0.0),
+        "EWC gradient entries must be non-negative (Fisher-weighted L2)"
+    );
+}
+
+#[cfg(feature = "perf-tests")]
+#[test]
+fn test_performance_targets_perf() {
+    // Perf gate: keep the absolute latency budgets the original test asserted
+    // — Fisher <100ms (release), loss/gradient <1ms (release). The relaxed
+    // numbers below cover debug+contention CI but still catch catastrophic
+    // regressions.
+    let (_ewc, fisher_time, _loss, loss_time, _grad, grad_time) = run_ewc_perf_workload();
+
     println!("Fisher computation (1M params): {:?}", fisher_time);
-    // Relaxed for debug builds running under parallel test contention on
-    // 1 vCPU CI runners. Real release-mode timings are <100ms; this only
-    // catches catastrophic regressions.
     assert!(
         fisher_time.as_millis() < 2000,
         "Fisher computation too slow: {:?}",
         fisher_time
     );
 
-    // EWC loss: <1ms for 1M parameters (release). Debug + contention can
-    // push this to a few tens of ms.
-    let new_params = vec![0.6; 1_000_000];
-    let start = Instant::now();
-    let _loss = ewc.ewc_loss(&new_params);
-    let loss_time = start.elapsed();
-
     println!("EWC loss (1M params): {:?}", loss_time);
     assert!(
         loss_time.as_millis() < 100,
         "EWC loss too slow: {:?}",
         loss_time
     );
 
-    // EWC gradient: <1ms for 1M parameters (release).
-    let start = Instant::now();
-    let _grad = ewc.ewc_gradient(&new_params);
-    let grad_time = start.elapsed();
-
     println!("EWC gradient (1M params): {:?}", grad_time);
     assert!(
         grad_time.as_millis() < 100,