fix: pass clippy --all-targets -D warnings + fmt for CI

Outcome:
- cargo fmt --all -- --check  → pass
- cargo clippy --all-targets --all-features -- -D warnings  → pass
- cargo test --workspace --release  → 139 / 139 pass

Specific fixes:
- bridge: replace `len() == 0` with `is_empty()` (clippy::len_zero).
- llm: surface `MockBackend::config()` instead of dead-coding the field.
- claude-client: drop unused imports (futures::StreamExt, tokio::sync::mpsc,
  tracing::{error,info}); allow dead `error_type` field used only for
  serde deserialisation; derive Default for ClaudeModel via #[default].
- lsm + esn: rand 0.9 deprecation rename (`thread_rng` → `rng`,
  `gen` → `random`). These were latent because the workspace didn't
  compile before; pinning rand 0.9 surfaced the deprecation warnings,
  which the CI lint gate treats as errors.
- neurophone-core: deduplicate accidental `#![forbid(unsafe_code)]`,
  drop unused `Arc`/`Duration` imports, derive Default for SystemState,
  remove `>= 0` checks on unsigned types (clippy::absurd_extreme_comparisons),
  swap `vec!["..."]` for an array literal (clippy::useless_vec).
- claude-client integration tests: use `RangeInclusive::contains` instead
  of manual `>=` / `<=` chain (clippy::manual_range_contains).
- All eight criterion benches: migrate to `std::hint::black_box`
  (criterion::black_box was deprecated in criterion 0.6).
- sensors bench: don't pass a unit value to black_box.
- property test: derive iteration counter from enumerate() instead of
  a parallel mutable variable (clippy::explicit_counter_loop).
- cargo fmt --all run; 24 files normalised (import order, trailing
  commas in long groups, line breaks in nested formats).

https://claude.ai/code/session_012opuP3HehkjDkF1XQ8nFex

Author: claude

crates/bridge/benches/bridge_bench.rs

@@ -3,19 +3,23 @@
 //! Benches for the bridge crate.
 
 use bridge::{Bridge, BridgeConfig};
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use ndarray::Array1;
+use std::hint::black_box;
 
 fn bench_encode_sizes(c: &mut Criterion) {
     let mut g = c.benchmark_group("bridge_encode");
     for &(n_lsm, n_esn) in &[(100usize, 50usize), (512, 300), (2048, 1024)] {
         let lsm = Array1::from_elem(n_lsm, 0.4);
         let esn = Array1::from_elem(n_esn, 0.4);
-        g.bench_with_input(BenchmarkId::from_parameter(format!("lsm{n_lsm}_esn{n_esn}")),
-            &(lsm, esn), |b, (lsm, esn)| {
+        g.bench_with_input(
+            BenchmarkId::from_parameter(format!("lsm{n_lsm}_esn{n_esn}")),
+            &(lsm, esn),
+            |b, (lsm, esn)| {
                 let mut br = Bridge::new(BridgeConfig::default()).unwrap();
                 b.iter(|| black_box(br.encode(lsm.view(), esn.view())))
-            });
+            },
+        );
     }
     g.finish();
 }
@@ -28,7 +32,9 @@ fn bench_encode_with_dynamics(c: &mut Criterion) {
         let esn = Array1::from_elem(300, 0.4);
         b.iter(|| {
             t = t.wrapping_add(1);
-            for v in lsm.iter_mut() { *v = ((t % 100) as f32) * 0.01; }
+            for v in lsm.iter_mut() {
+                *v = ((t % 100) as f32) * 0.01;
+            }
             black_box(br.encode(lsm.view(), esn.view()));
         })
     });

crates/bridge/src/lib.rs

@@ -29,13 +29,20 @@ pub struct BridgeConfig {
 }
 
 impl Default for BridgeConfig {
-    fn default() -> Self { Self { activation_threshold: 0.3, lsm_weight: 0.5 } }
+    fn default() -> Self {
+        Self {
+            activation_threshold: 0.3,
+            lsm_weight: 0.5,
+        }
+    }
 }
 
 impl BridgeConfig {
     pub fn validate(&self) -> Result<(), BridgeError> {
         if !(0.0..=1.0).contains(&self.activation_threshold) {
-            return Err(BridgeError::InvalidConfig("activation_threshold ∉ [0,1]".into()));
+            return Err(BridgeError::InvalidConfig(
+                "activation_threshold ∉ [0,1]".into(),
+            ));
         }
         if !(0.0..=1.0).contains(&self.lsm_weight) {
             return Err(BridgeError::InvalidConfig("lsm_weight ∉ [0,1]".into()));
@@ -69,20 +76,31 @@ pub struct Bridge {
 impl Bridge {
     pub fn new(config: BridgeConfig) -> Result<Self, BridgeError> {
         config.validate()?;
-        Ok(Self { config, last_lsm: None })
+        Ok(Self {
+            config,
+            last_lsm: None,
+        })
     }
 
-    pub fn config(&self) -> &BridgeConfig { &self.config }
+    pub fn config(&self) -> &BridgeConfig {
+        &self.config
+    }
 
     fn count_active(view: ArrayView1<f32>, thresh: f32) -> usize {
         view.iter().filter(|v| v.abs() >= thresh).count()
     }
 
     fn rms_delta(prev: &Array1<f32>, curr: ArrayView1<f32>) -> f32 {
-        if prev.len() != curr.len() { return 0.0; }
+        if prev.len() != curr.len() {
+            return 0.0;
+        }
         let n = prev.len() as f32;
-        if n == 0.0 { return 0.0; }
-        let sum_sq: f32 = prev.iter().zip(curr.iter())
+        if n == 0.0 {
+            return 0.0;
+        }
+        let sum_sq: f32 = prev
+            .iter()
+            .zip(curr.iter())
             .map(|(a, b)| (a - b).powi(2))
             .sum();
         (sum_sq / n).sqrt().min(1.0)
@@ -93,8 +111,16 @@ impl Bridge {
         let t = self.config.activation_threshold;
         let lsm_active = Self::count_active(lsm, t);
         let esn_active = Self::count_active(esn, t);
-        let lsm_frac = if lsm.len() == 0 { 0.0 } else { lsm_active as f32 / lsm.len() as f32 };
-        let esn_frac = if esn.len() == 0 { 0.0 } else { esn_active as f32 / esn.len() as f32 };
+        let lsm_frac = if lsm.is_empty() {
+            0.0
+        } else {
+            lsm_active as f32 / lsm.len() as f32
+        };
+        let esn_frac = if esn.is_empty() {
+            0.0
+        } else {
+            esn_active as f32 / esn.len() as f32
+        };
         let w = self.config.lsm_weight;
         let salience = (w * lsm_frac + (1.0 - w) * esn_frac).clamp(0.0, 1.0);
 
@@ -106,10 +132,18 @@ impl Bridge {
         let description = describe(salience, urgency, lsm_active, esn_active);
         self.last_lsm = Some(lsm.to_owned());
 
-        NeuralContext { salience, urgency, lsm_active, esn_active, description }
+        NeuralContext {
+            salience,
+            urgency,
+            lsm_active,
+            esn_active,
+            description,
+        }
     }
 
-    pub fn reset(&mut self) { self.last_lsm = None; }
+    pub fn reset(&mut self) {
+        self.last_lsm = None;
+    }
 }
 
 fn describe(salience: f32, urgency: f32, lsm_active: usize, esn_active: usize) -> String {
@@ -129,20 +163,34 @@ fn describe(salience: f32, urgency: f32, lsm_active: usize, esn_active: usize) -
     )
 }
 
-pub fn hello() -> &'static str { "bridge" }
+pub fn hello() -> &'static str {
+    "bridge"
+}
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use ndarray::Array1;
 
-    #[test] fn config_validates() {
-        assert!(BridgeConfig { activation_threshold: -0.1, lsm_weight: 0.5 }.validate().is_err());
-        assert!(BridgeConfig { activation_threshold: 0.5, lsm_weight: 1.5 }.validate().is_err());
+    #[test]
+    fn config_validates() {
+        assert!(BridgeConfig {
+            activation_threshold: -0.1,
+            lsm_weight: 0.5
+        }
+        .validate()
+        .is_err());
+        assert!(BridgeConfig {
+            activation_threshold: 0.5,
+            lsm_weight: 1.5
+        }
+        .validate()
+        .is_err());
         assert!(BridgeConfig::default().validate().is_ok());
     }
 
-    #[test] fn quiet_state_low_salience() {
+    #[test]
+    fn quiet_state_low_salience() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let lsm = Array1::zeros(100);
         let esn = Array1::zeros(50);
@@ -153,7 +201,8 @@ mod tests {
         assert!(ctx.description.contains("quiet"));
     }
 
-    #[test] fn high_state_high_salience() {
+    #[test]
+    fn high_state_high_salience() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let lsm = Array1::from_elem(100, 1.0);
         let esn = Array1::from_elem(50, 1.0);
@@ -162,29 +211,33 @@ mod tests {
         assert!(ctx.description.contains("high"));
     }
 
-    #[test] fn urgency_zero_on_first_call() {
+    #[test]
+    fn urgency_zero_on_first_call() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let lsm = Array1::from_elem(10, 0.5);
         let ctx = b.encode(lsm.view(), Array1::zeros(10).view());
         assert!(ctx.urgency.abs() < 1e-6);
     }
 
-    #[test] fn urgency_rises_with_change() {
+    #[test]
+    fn urgency_rises_with_change() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let _ = b.encode(Array1::zeros(10).view(), Array1::zeros(10).view());
         let ctx = b.encode(Array1::from_elem(10, 1.0).view(), Array1::zeros(10).view());
         assert!(ctx.urgency > 0.5);
     }
 
-    #[test] fn reset_clears_history() {
+    #[test]
+    fn reset_clears_history() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let _ = b.encode(Array1::from_elem(10, 1.0).view(), Array1::zeros(10).view());
         b.reset();
         let ctx = b.encode(Array1::zeros(10).view(), Array1::zeros(10).view());
         assert!(ctx.urgency.abs() < 1e-6);
     }
 
-    #[test] fn description_contains_markers() {
+    #[test]
+    fn description_contains_markers() {
         let mut b = Bridge::new(BridgeConfig::default()).unwrap();
         let ctx = b.encode(Array1::zeros(10).view(), Array1::zeros(10).view());
         assert!(ctx.description.starts_with("[NEURAL_STATE]"));

crates/bridge/tests/aspect_lifecycle.rs

@@ -7,13 +7,19 @@ use ndarray::Array1;
 
 #[test]
 fn aspect_invalid_threshold_rejected() {
-    let cfg = BridgeConfig { activation_threshold: 1.5, lsm_weight: 0.5 };
+    let cfg = BridgeConfig {
+        activation_threshold: 1.5,
+        lsm_weight: 0.5,
+    };
     assert!(Bridge::new(cfg).is_err());
 }
 
 #[test]
 fn aspect_invalid_weight_rejected() {
-    let cfg = BridgeConfig { activation_threshold: 0.5, lsm_weight: -0.1 };
+    let cfg = BridgeConfig {
+        activation_threshold: 0.5,
+        lsm_weight: -0.1,
+    };
     assert!(Bridge::new(cfg).is_err());
 }
 

crates/bridge/tests/integration_encode.rs

@@ -28,7 +28,10 @@ fn salience_monotonic_in_active_fraction() {
 
 #[test]
 fn lsm_weight_zero_uses_only_esn() {
-    let cfg = BridgeConfig { lsm_weight: 0.0, ..Default::default() };
+    let cfg = BridgeConfig {
+        lsm_weight: 0.0,
+        ..Default::default()
+    };
     let mut b = Bridge::new(cfg).unwrap();
     let lsm = Array1::from_elem(10, 1.0);
     let esn = Array1::zeros(10);
@@ -38,7 +41,10 @@ fn lsm_weight_zero_uses_only_esn() {
 
 #[test]
 fn lsm_weight_one_uses_only_lsm() {
-    let cfg = BridgeConfig { lsm_weight: 1.0, ..Default::default() };
+    let cfg = BridgeConfig {
+        lsm_weight: 1.0,
+        ..Default::default()
+    };
     let mut b = Bridge::new(cfg).unwrap();
     let lsm = Array1::zeros(10);
     let esn = Array1::from_elem(10, 1.0);

crates/claude-client/benches/claude_bench.rs

@@ -3,7 +3,8 @@
 //! Benches for the Claude client (offline / routing only — no network).
 
 use claude_client::{HybridInference, Message};
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
 
 fn bench_complexity_estimation(c: &mut Criterion) {
     let h = HybridInference::new(None);
@@ -28,5 +29,10 @@ fn bench_message_construction(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, bench_complexity_estimation, bench_should_use_cloud, bench_message_construction);
+criterion_group!(
+    benches,
+    bench_complexity_estimation,
+    bench_should_use_cloud,
+    bench_message_construction
+);
 criterion_main!(benches);