From 37d07c1e80ff78aadab4b5e6b948e3439670c129 Mon Sep 17 00:00:00 2001
From: ApiliumDevTeam <it@apilium.com>
Date: Wed, 29 Jul 2026 08:26:20 +0200
Subject: [PATCH 1/3] test: assert something in the tests that asserted nothing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nine assertions compared an unsigned counter against zero — `peer_count
>= 0`, `uptime_secs >= 0`, `verification_time_ms >= 0`. Every one of them
held for every possible value, including the failure each test exists to
catch: `test_add_peer` passed whether or not the peer was added.

Replace them with the claim the test is named for where there is one
(peer counts), an invariant that can actually break where there is not
(time in a power profile cannot exceed total uptime; energy is never
negative), and nothing at all where the author's own comment says the
value is legitimately zero — with a line explaining why no bound is
asserted, so it does not get "fixed" back.

Also: `3.14` as an arbitrary test float in eight places, which clippy
reads as an approximation of PI. These tests are about storing a
decimal, not about geometry, so use a number that does not claim to be a
constant.

And `aingle_zk`'s memory benchmark had not compiled since
`prove_knowledge` settled on `(secret, public_point, message)` — it was
still passing the last two swapped. Invisible to `cargo test`, which
does not build benches.
---
 crates/aingle_graph/src/value.rs               |  4 ++--
 .../tests/graph_integration_tests.rs           |  2 +-
 crates/aingle_minimal/src/node.rs              | 18 +++++++++++-------
 crates/aingle_minimal/src/power.rs             |  8 +++++---
 .../tests/iot_integration_tests.rs             | 13 ++++++++-----
 crates/aingle_zk/benches/full_benchmarks.rs    | 10 +++++++---
 crates/aingle_zk/src/aggregation.rs            |  5 +++--
 crates/kaneru/src/types.rs                     | 10 +++++-----
 8 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/crates/aingle_graph/src/value.rs b/crates/aingle_graph/src/value.rs
index dfa8836f..d948c28b 100644
--- a/crates/aingle_graph/src/value.rs
+++ b/crates/aingle_graph/src/value.rs
@@ -481,8 +481,8 @@ mod tests {
         let int_val = Value::integer(42);
         assert_eq!(int_val.as_integer(), Some(42));
 
-        let float_val = Value::float(3.14);
-        assert_eq!(float_val.as_float(), Some(3.14));
+        let float_val = Value::float(2.5);
+        assert_eq!(float_val.as_float(), Some(2.5));
     }
 
     #[test]
diff --git a/crates/aingle_graph/tests/graph_integration_tests.rs b/crates/aingle_graph/tests/graph_integration_tests.rs
index 56860125..1029dda2 100644
--- a/crates/aingle_graph/tests/graph_integration_tests.rs
+++ b/crates/aingle_graph/tests/graph_integration_tests.rs
@@ -581,7 +581,7 @@ fn test_different_value_types() {
     db.insert(Triple::new(
         NodeId::named("node:1"),
         Predicate::named("float_val"),
-        Value::float(3.14),
+        Value::float(2.5),
     ))
     .unwrap();
 
diff --git a/crates/aingle_minimal/src/node.rs b/crates/aingle_minimal/src/node.rs
index 6b9e4b18..3bef02a1 100644
--- a/crates/aingle_minimal/src/node.rs
+++ b/crates/aingle_minimal/src/node.rs
@@ -1037,9 +1037,11 @@ mod tests {
         let addr: std::net::SocketAddr = "192.168.1.100:5683".parse().unwrap();
         node.add_peer(addr);
 
-        // Verify peer was added via stats
+        // Verify peer was added via stats. `peer_count` is unsigned, so the
+        // old `>= 0` here held for every possible value including "nothing was
+        // added" — the one outcome this test exists to rule out.
         let stats = node.stats().unwrap();
-        assert!(stats.peer_count >= 0); // At least no error
+        assert_eq!(stats.peer_count, 1);
     }
 
     #[test]
@@ -1052,9 +1054,9 @@ mod tests {
         node.add_peer("192.168.1.101:5683".parse().unwrap());
         node.add_peer("192.168.1.102:5683".parse().unwrap());
 
-        // Stats should work
+        // Stats should work, and report all three.
         let stats = node.stats().unwrap();
-        assert!(stats.peer_count >= 0);
+        assert_eq!(stats.peer_count, 3);
     }
 
     #[test]
@@ -1126,9 +1128,11 @@ mod tests {
         // Sleep a bit to ensure uptime is measurable
         std::thread::sleep(std::time::Duration::from_millis(10));
 
-        let stats = node.stats().unwrap();
-        // Uptime should be at least 0 (could be 0 if very fast)
-        assert!(stats.uptime_secs >= 0);
+        // Uptime is whole seconds, so a node this young legitimately reports 0
+        // and there is no lower bound to assert: `>= 0` on a u64 was always
+        // true. What this test does establish is that `stats()` succeeds on a
+        // freshly started node, which is the `unwrap` below.
+        let _stats = node.stats().unwrap();
     }
 
     #[test]
diff --git a/crates/aingle_minimal/src/power.rs b/crates/aingle_minimal/src/power.rs
index 8f0a231f..18280b38 100644
--- a/crates/aingle_minimal/src/power.rs
+++ b/crates/aingle_minimal/src/power.rs
@@ -590,9 +590,11 @@ mod tests {
         std::thread::sleep(Duration::from_millis(100));
 
         let stats = pm.get_stats();
-        // At least one metric should be non-zero
-        assert!(stats.uptime_secs >= 0);
-        assert!(stats.time_in_balanced >= 0);
+        // These counters are unsigned, so the old `>= 0` pair held always. Assert
+        // the invariant that can actually break instead: time spent in one
+        // profile cannot exceed the total uptime, and energy is never negative.
+        assert!(stats.time_in_balanced <= stats.uptime_secs);
+        assert!(stats.energy_consumed_mwh >= 0.0);
     }
 
     #[test]
diff --git a/crates/aingle_minimal/tests/iot_integration_tests.rs b/crates/aingle_minimal/tests/iot_integration_tests.rs
index 9bd70f68..c72532f8 100644
--- a/crates/aingle_minimal/tests/iot_integration_tests.rs
+++ b/crates/aingle_minimal/tests/iot_integration_tests.rs
@@ -260,10 +260,11 @@ fn test_power_stats_tracking() {
     pm.set_power_profile(PowerProfile::LowPower);
     let stats = pm.get_stats();
 
-    // Stats should be valid (non-negative)
-    assert!(stats.uptime_secs >= 0);
-    assert!(stats.time_in_high_performance >= 0);
-    assert!(stats.time_in_low_power >= 0);
+    // These counters are unsigned, so "non-negative" was true by construction
+    // and asserted nothing. The real invariant: time attributed to the profiles
+    // this test drove cannot exceed the total uptime.
+    assert!(stats.time_in_high_performance <= stats.uptime_secs);
+    assert!(stats.time_in_low_power <= stats.uptime_secs);
 }
 
 #[test]
@@ -400,7 +401,9 @@ fn test_complete_iot_device_workflow() {
 
     // 8. Get statistics
     let power_stats = power_manager.get_stats();
-    assert!(power_stats.uptime_secs >= 0);
+    // `uptime_secs` is unsigned; the old `>= 0` asserted nothing. Energy is the
+    // figure this end-to-end run can actually get wrong.
+    assert!(power_stats.energy_consumed_mwh >= 0.0);
 
     let ota_stats = ota_manager.stats();
     assert_eq!(ota_stats.updates_applied, 0);
diff --git a/crates/aingle_zk/benches/full_benchmarks.rs b/crates/aingle_zk/benches/full_benchmarks.rs
index d4b8c7a3..6a2fef2a 100644
--- a/crates/aingle_zk/benches/full_benchmarks.rs
+++ b/crates/aingle_zk/benches/full_benchmarks.rs
@@ -11,7 +11,7 @@
 //! - Memory usage
 
 use aingle_zk::{
-    aggregation::{aggregate_proofs, ProofAggregator},
+    aggregation::aggregate_proofs,
     batch::{verify_schnorr_batch, BatchVerifier},
     commitment::{HashCommitment, PedersenCommitment},
     merkle::{MerkleTree, SparseMerkleTree},
@@ -442,12 +442,16 @@ fn benchmark_serialization(c: &mut Criterion) {
 
 /// Benchmark memory usage
 fn benchmark_memory(c: &mut Criterion) {
-    let mut group = c.benchmark_group("memory");
+    // Not `mut`: this group records no measurements, it only prints sizes.
+    let group = c.benchmark_group("memory");
 
     // Measure proof sizes
     let secret = Scalar::random(&mut OsRng);
     let public = RISTRETTO_BASEPOINT_POINT * secret;
-    let schnorr = SchnorrProof::prove_knowledge(&secret, b"test", &public);
+    // Argument order follows `prove_knowledge(secret, public_point, message)`.
+    // It was called with the last two swapped, so this benchmark had not
+    // compiled since that signature settled — invisible until `--all-targets`.
+    let schnorr = SchnorrProof::prove_knowledge(&secret, &public, b"test");
     let schnorr_size = std::mem::size_of_val(&schnorr);
     println!("Schnorr proof in-memory size: {} bytes", schnorr_size);
 
diff --git a/crates/aingle_zk/src/aggregation.rs b/crates/aingle_zk/src/aggregation.rs
index 0976bb12..06aea982 100644
--- a/crates/aingle_zk/src/aggregation.rs
+++ b/crates/aingle_zk/src/aggregation.rs
@@ -506,8 +506,9 @@ mod tests {
         assert!(result.all_valid);
         assert_eq!(result.success_rate(), 1.0);
         assert!(result.avg_time_per_proof() >= 0.0);
-        // Verification time may be 0 if very fast (< 1ms)
-        assert!(result.verification_time_ms >= 0);
+        // No assertion on `verification_time_ms`: it is unsigned and legitimately
+        // 0 for a batch that verifies in under a millisecond, so every bound
+        // that could be written here is either always true or flaky.
     }
 
     #[test]
diff --git a/crates/kaneru/src/types.rs b/crates/kaneru/src/types.rs
index 34feffa2..9b84a614 100644
--- a/crates/kaneru/src/types.rs
+++ b/crates/kaneru/src/types.rs
@@ -293,8 +293,8 @@ mod tests {
 
     #[test]
     fn test_value_conversions() {
-        let v = Value::Float(3.14);
-        assert!((v.as_f64().unwrap() - 3.14).abs() < 0.001);
+        let v = Value::Float(2.5);
+        assert!((v.as_f64().unwrap() - 2.5).abs() < 0.001);
 
         let v = Value::Int(42);
         assert_eq!(v.as_i64().unwrap(), 42);
@@ -372,7 +372,7 @@ mod tests {
         assert_eq!(Value::Bool(true).as_string(), "true");
         assert_eq!(Value::Bool(false).as_string(), "false");
         assert_eq!(Value::Int(42).as_string(), "42");
-        assert_eq!(Value::Float(3.14).as_string(), "3.14");
+        assert_eq!(Value::Float(2.5).as_string(), "2.5");
         assert_eq!(Value::String("test".to_string()).as_string(), "test");
     }
 
@@ -393,9 +393,9 @@ mod tests {
 
     #[test]
     fn test_value_from_f64() {
-        let v: Value = 3.14f64.into();
+        let v: Value = 2.5f64.into();
         if let Value::Float(f) = v {
-            assert!((f - 3.14).abs() < 0.001);
+            assert!((f - 2.5).abs() < 0.001);
         } else {
             panic!("Expected Float");
         }

From df2c9dd0ba09bdcf53875441304c25937d882fd7 Mon Sep 17 00:00:00 2001
From: ApiliumDevTeam <it@apilium.com>
Date: Wed, 29 Jul 2026 08:26:29 +0200
Subject: [PATCH 2/3] style: apply cargo clippy --fix across the workspace
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Machine-applicable suggestions only, applied by the tool and left
otherwise untouched: needless borrows, redundant closures, `is_empty`
over length comparisons, `io::Error::other`, derivable impls, unused
imports.

Mechanical and behaviour-preserving by construction, but it is 40 files
of churn in the engine, so it is a separate commit: drop it without
losing the fixes in the commit before, which are not mechanical.

Twenty-four lints remain that clippy declines to auto-fix because they
need judgement — clamp (NaN handling differs), `sort_by_key` where the
key borrows, `Default::default()` field reassignment, and a public
`from_str` that shadows the trait method and cannot be renamed without
breaking callers. Left for a later pass rather than rushed.
---
 crates/aingle_ai/src/kaneru/mod.rs            |  2 +-
 crates/aingle_ai/src/nested_learning/mod.rs   |  4 ++--
 .../src/nested_learning/transaction_level.rs  |  2 +-
 crates/aingle_ai/src/types.rs                 |  2 +-
 crates/aingle_contracts/src/contract.rs       |  7 ++-----
 crates/aingle_contracts/src/types.rs          |  2 +-
 crates/aingle_cortex/src/cluster_init.rs      | 11 +++++-----
 crates/aingle_cortex/src/p2p/config.rs        |  5 ++---
 crates/aingle_cortex/src/p2p/dag_sync.rs      |  2 +-
 crates/aingle_cortex/src/proofs/store.rs      |  2 +-
 crates/aingle_cortex/src/rest/audit.rs        |  8 +++-----
 crates/aingle_cortex/src/rest/proof_api.rs    |  2 +-
 crates/aingle_cortex/src/rest/triples.rs      |  4 ++--
 .../tests/data_integrity_test.rs              | 18 ++++++++---------
 .../aingle_cortex/tests/rate_limiting_test.rs |  2 +-
 crates/aingle_graph/src/dag/store.rs          |  7 +++----
 crates/aingle_graph/src/lib.rs                | 11 +++++-----
 .../tests/graph_integration_tests.rs          |  4 ++--
 crates/aingle_ingest/src/chunk.rs             |  5 ++---
 crates/aingle_minimal/src/config.rs           | 15 ++++----------
 crates/aingle_minimal/src/error.rs            |  2 +-
 crates/aingle_minimal/src/ota.rs              |  2 +-
 .../tests/transport_integration_tests.rs      |  1 -
 crates/aingle_raft/src/log_store.rs           | 20 +++++++++----------
 crates/aingle_raft/src/network.rs             |  2 +-
 crates/aingle_raft/src/snapshot_builder.rs    |  8 ++++----
 crates/aingle_raft/src/state_machine.rs       | 16 +++++++--------
 crates/aingle_viz/src/api.rs                  |  4 ++--
 crates/aingle_viz/src/server.rs               |  4 ++--
 crates/aingle_wal/src/writer.rs               | 12 ++++-------
 crates/aingle_zk/src/aggregation.rs           |  2 +-
 crates/aingle_zk/src/proof.rs                 |  2 +-
 crates/kaneru/benches/agent_bench.rs          |  2 +-
 crates/kaneru/examples/kaneru_orchestrator.rs |  4 ++--
 crates/kaneru/src/goal.rs                     |  2 +-
 .../kaneru/src/hierarchical/decomposition.rs  |  2 +-
 crates/kaneru/src/hierarchical/goal_solver.rs |  2 +-
 crates/kaneru/src/hierarchical/tests.rs       |  2 +-
 crates/kaneru/src/predictive/anomaly.rs       |  2 +-
 examples/iot_sensor_network/src/main.rs       |  2 +-
 40 files changed, 93 insertions(+), 115 deletions(-)

diff --git a/crates/aingle_ai/src/kaneru/mod.rs b/crates/aingle_ai/src/kaneru/mod.rs
index 22b90603..567a3362 100644
--- a/crates/aingle_ai/src/kaneru/mod.rs
+++ b/crates/aingle_ai/src/kaneru/mod.rs
@@ -424,7 +424,7 @@ mod tests {
         let result = agent.query(&query);
 
         // Should have some results
-        assert!(result.relevant_contexts.len() > 0 || result.memory_matches.len() >= 0);
+        assert!(!result.relevant_contexts.is_empty() || result.memory_matches.len() >= 0);
     }
 
     #[test]
diff --git a/crates/aingle_ai/src/nested_learning/mod.rs b/crates/aingle_ai/src/nested_learning/mod.rs
index d661db94..a31fd971 100644
--- a/crates/aingle_ai/src/nested_learning/mod.rs
+++ b/crates/aingle_ai/src/nested_learning/mod.rs
@@ -259,7 +259,7 @@ mod tests {
         let tx = make_test_tx(1);
         let result = nested.process(&tx).unwrap();
 
-        assert!(result.processed.features.len() > 0);
+        assert!(!result.processed.features.is_empty());
     }
 
     #[test]
@@ -267,7 +267,7 @@ mod tests {
         let config = NestedConfig::default();
         let nested = NestedLearning::new(config);
 
-        let batch: Vec<_> = (0..10).map(|i| make_test_tx(i)).collect();
+        let batch: Vec<_> = (0..10).map(make_test_tx).collect();
         let plan = nested.get_validation_plan(&batch);
 
         assert_eq!(plan.order.len(), 10);
diff --git a/crates/aingle_ai/src/nested_learning/transaction_level.rs b/crates/aingle_ai/src/nested_learning/transaction_level.rs
index fd38a931..59d14ed0 100644
--- a/crates/aingle_ai/src/nested_learning/transaction_level.rs
+++ b/crates/aingle_ai/src/nested_learning/transaction_level.rs
@@ -294,7 +294,7 @@ mod tests {
 
         // Process and update
         let tx = make_tx(1);
-        let processed = tl.process(tx.clone());
+        let _processed = tl.process(tx.clone());
 
         let outcome = ValidationOutcome {
             valid: true,
diff --git a/crates/aingle_ai/src/types.rs b/crates/aingle_ai/src/types.rs
index 502a3d3f..613aa182 100644
--- a/crates/aingle_ai/src/types.rs
+++ b/crates/aingle_ai/src/types.rs
@@ -287,6 +287,6 @@ mod tests {
 
         let features = tx.extract_features();
         assert_eq!(features.len(), 16);
-        assert!(features.iter().all(|&f| f >= 0.0 && f <= 2.0));
+        assert!(features.iter().all(|&f| (0.0..=2.0).contains(&f)));
     }
 }
diff --git a/crates/aingle_contracts/src/contract.rs b/crates/aingle_contracts/src/contract.rs
index bb437e1c..70a39a04 100644
--- a/crates/aingle_contracts/src/contract.rs
+++ b/crates/aingle_contracts/src/contract.rs
@@ -14,10 +14,12 @@ use crate::types::{Address, ContractId};
 
 /// Function visibility/mutability
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default)]
 pub enum FunctionType {
     /// Read-only function (view)
     View,
     /// State-mutating function
+    #[default]
     Mutate,
     /// Payable function (can receive value)
     Payable,
@@ -27,11 +29,6 @@ pub enum FunctionType {
     Constructor,
 }
 
-impl Default for FunctionType {
-    fn default() -> Self {
-        Self::Mutate
-    }
-}
 
 /// Contract function definition
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/aingle_contracts/src/types.rs b/crates/aingle_contracts/src/types.rs
index cc7f6b24..0fcc3b1a 100644
--- a/crates/aingle_contracts/src/types.rs
+++ b/crates/aingle_contracts/src/types.rs
@@ -46,7 +46,7 @@ impl Address {
         hasher.update(b"aingle_deploy:");
         hasher.update(deployer.as_bytes());
         hasher.update(code_hash);
-        hasher.update(&nonce);
+        hasher.update(nonce);
         let hash: [u8; 32] = hasher.finalize().into();
         Self(hash)
     }
diff --git a/crates/aingle_cortex/src/cluster_init.rs b/crates/aingle_cortex/src/cluster_init.rs
index 2486d014..23dc414c 100644
--- a/crates/aingle_cortex/src/cluster_init.rs
+++ b/crates/aingle_cortex/src/cluster_init.rs
@@ -103,12 +103,11 @@ impl ClusterConfig {
                         i += 1;
                     }
                 }
-                "--cluster-tls-key" => {
-                    if i + 1 < args.len() {
+                "--cluster-tls-key"
+                    if i + 1 < args.len() => {
                         cfg.tls_key = Some(args[i + 1].clone());
                         i += 1;
                     }
-                }
                 _ => {}
             }
             i += 1;
@@ -406,7 +405,7 @@ pub async fn ensure_dag_ready(state: &mut crate::state::AppState, db_path: Optio
 
     // Set DAG author from cluster node ID (no-op when not in cluster mode).
     if let Some(node_id) = state.cluster_node_id {
-        state.dag_author = Some(aingle_graph::NodeId::named(&format!("node:{}", node_id)));
+        state.dag_author = Some(aingle_graph::NodeId::named(format!("node:{}", node_id)));
     }
 
     // Initialize the Ed25519 signing key for DAG actions.
@@ -459,7 +458,7 @@ pub async fn ensure_dag_ready(state: &mut crate::state::AppState, db_path: Optio
                 }
                 #[cfg(not(unix))]
                 {
-                    if let Err(e) = std::fs::write(&key_path, &seed) {
+                    if let Err(e) = std::fs::write(&key_path, seed) {
                         tracing::error!("Failed to persist DAG signing key: {e}");
                     }
                 }
@@ -496,7 +495,7 @@ pub async fn init_cluster(
     bind_addr: &str,
     p2p_addr: &str,
 ) -> Result<(), Error> {
-    config.validate().map_err(|e| Error::Internal(e))?;
+    config.validate().map_err(Error::Internal)?;
 
     let wal_dir = config.wal_dir.as_deref().unwrap_or("wal");
     let wal_path = std::path::Path::new(wal_dir);
diff --git a/crates/aingle_cortex/src/p2p/config.rs b/crates/aingle_cortex/src/p2p/config.rs
index c44da9f4..fc1d0320 100644
--- a/crates/aingle_cortex/src/p2p/config.rs
+++ b/crates/aingle_cortex/src/p2p/config.rs
@@ -114,14 +114,13 @@ impl P2pConfig {
                         i += 1;
                     }
                 }
-                "--p2p-peer" => {
-                    if i + 1 < args.len() {
+                "--p2p-peer"
+                    if i + 1 < args.len() => {
                         if let Ok(addr) = args[i + 1].parse::<SocketAddr>() {
                             cfg.manual_peers.push(addr);
                         }
                         i += 1;
                     }
-                }
                 _ => {}
             }
             i += 1;
diff --git a/crates/aingle_cortex/src/p2p/dag_sync.rs b/crates/aingle_cortex/src/p2p/dag_sync.rs
index f5f6b0fa..7f9df964 100644
--- a/crates/aingle_cortex/src/p2p/dag_sync.rs
+++ b/crates/aingle_cortex/src/p2p/dag_sync.rs
@@ -19,7 +19,7 @@ pub fn collect_local_tips(graph: &GraphDB) -> (Vec<String>, u64) {
             .tips_raw()
             .unwrap_or_default()
             .into_iter()
-            .map(|h| hex::encode(h))
+            .map(hex::encode)
             .collect::<Vec<_>>();
         let count = dag_store.action_count() as u64;
         (tips, count)
diff --git a/crates/aingle_cortex/src/proofs/store.rs b/crates/aingle_cortex/src/proofs/store.rs
index 2bb6eb34..4ff1283e 100644
--- a/crates/aingle_cortex/src/proofs/store.rs
+++ b/crates/aingle_cortex/src/proofs/store.rs
@@ -282,7 +282,7 @@ impl ProofStore {
             .map_err(|e| VerificationError::InvalidProofData(e.to_string()))?;
         self.backend
             .put(&proof_id, &serialized)
-            .map_err(|e| VerificationError::InvalidProofData(e))?;
+            .map_err(VerificationError::InvalidProofData)?;
 
         // Update stats
         let mut stats = self.stats.write().await;
diff --git a/crates/aingle_cortex/src/rest/audit.rs b/crates/aingle_cortex/src/rest/audit.rs
index 2856ebd9..3f6a8e66 100644
--- a/crates/aingle_cortex/src/rest/audit.rs
+++ b/crates/aingle_cortex/src/rest/audit.rs
@@ -63,11 +63,9 @@ impl AuditLog {
         // Read existing entries from JSONL file
         if let Ok(file) = std::fs::File::open(&path) {
             let reader = std::io::BufReader::new(file);
-            for line in reader.lines() {
-                if let Ok(line) = line {
-                    if let Ok(entry) = serde_json::from_str::<AuditEntry>(&line) {
-                        entries.push(entry);
-                    }
+            for line in reader.lines().flatten() {
+                if let Ok(entry) = serde_json::from_str::<AuditEntry>(&line) {
+                    entries.push(entry);
                 }
             }
             // Keep only the last max_entries
diff --git a/crates/aingle_cortex/src/rest/proof_api.rs b/crates/aingle_cortex/src/rest/proof_api.rs
index 711aca50..daf030df 100644
--- a/crates/aingle_cortex/src/rest/proof_api.rs
+++ b/crates/aingle_cortex/src/rest/proof_api.rs
@@ -124,7 +124,7 @@ pub async fn verify_proofs_batch(
     let results = state.proof_store.batch_verify(&request.proof_ids).await;
 
     let mut verifications = Vec::new();
-    for (proof_id, result) in request.proof_ids.iter().zip(results.into_iter()) {
+    for (proof_id, result) in request.proof_ids.iter().zip(results) {
         // Every entry carries its own replay material: a batch verdict is no more
         // authoritative than a single one, so it must not be the only thing a
         // caller can act on.
diff --git a/crates/aingle_cortex/src/rest/triples.rs b/crates/aingle_cortex/src/rest/triples.rs
index 342b0006..d8a3972f 100644
--- a/crates/aingle_cortex/src/rest/triples.rs
+++ b/crates/aingle_cortex/src/rest/triples.rs
@@ -178,7 +178,7 @@ pub async fn create_triple(
     #[cfg(feature = "dag")]
     if let Some(ref raft) = state.raft {
         let dag_author = state.dag_author.clone().unwrap_or_else(|| {
-            aingle_graph::NodeId::named(&format!("node:{}", state.cluster_node_id.unwrap_or(0)))
+            aingle_graph::NodeId::named(format!("node:{}", state.cluster_node_id.unwrap_or(0)))
         });
         // Get current tips, and a sequence number that continues this author's
         // recorded chain rather than restarting at 1 and evicting its own history
@@ -457,7 +457,7 @@ pub async fn delete_triple(
     #[cfg(feature = "dag")]
     if let Some(ref raft) = state.raft {
         let dag_author = state.dag_author.clone().unwrap_or_else(|| {
-            aingle_graph::NodeId::named(&format!("node:{}", state.cluster_node_id.unwrap_or(0)))
+            aingle_graph::NodeId::named(format!("node:{}", state.cluster_node_id.unwrap_or(0)))
         });
         let (parents, subject_for_dag, dag_seq) = {
             let graph = state.graph.read().await;
diff --git a/crates/aingle_cortex/tests/data_integrity_test.rs b/crates/aingle_cortex/tests/data_integrity_test.rs
index 70ddb0a7..0a3c6b67 100644
--- a/crates/aingle_cortex/tests/data_integrity_test.rs
+++ b/crates/aingle_cortex/tests/data_integrity_test.rs
@@ -139,7 +139,7 @@ async fn test_graph_dag_triple_materialization_consistency() {
     let mut triple_ids = Vec::new();
     for i in 0..50 {
         let triple = Triple::new(
-            NodeId::named(&format!("entity:{}", i)),
+            NodeId::named(format!("entity:{}", i)),
             Predicate::named("has_value"),
             Value::Integer(i * 100),
         );
@@ -166,7 +166,7 @@ async fn test_graph_dag_triple_materialization_consistency() {
 
     // Verify pattern queries return correct results
     for i in 0..50 {
-        let pattern = TriplePattern::subject(NodeId::named(&format!("entity:{}", i)));
+        let pattern = TriplePattern::subject(NodeId::named(format!("entity:{}", i)));
         let results = graph.find(pattern).unwrap();
         assert_eq!(
             results.len(),
@@ -209,7 +209,7 @@ async fn test_batch_insert_index_consistency() {
     let triples: Vec<Triple> = (0..100)
         .map(|i| {
             Triple::new(
-                NodeId::named(&format!("batch:{}", i)),
+                NodeId::named(format!("batch:{}", i)),
                 Predicate::named("batch_value"),
                 Value::Integer(i),
             )
@@ -222,7 +222,7 @@ async fn test_batch_insert_index_consistency() {
 
     // Verify every triple is findable by subject pattern (uses SPO index)
     for i in 0..100 {
-        let pattern = TriplePattern::subject(NodeId::named(&format!("batch:{}", i)));
+        let pattern = TriplePattern::subject(NodeId::named(format!("batch:{}", i)));
         let results = graph.find(pattern).unwrap();
         assert_eq!(results.len(), 1, "batch:{} should be findable via index", i);
         assert_eq!(results[0].object, Value::Integer(i));
@@ -238,7 +238,7 @@ async fn test_batch_insert_index_consistency() {
     let triples2: Vec<Triple> = (0..100)
         .map(|i| {
             Triple::new(
-                NodeId::named(&format!("batch:{}", i)),
+                NodeId::named(format!("batch:{}", i)),
                 Predicate::named("batch_value"),
                 Value::Integer(i),
             )
@@ -270,7 +270,7 @@ async fn test_app_state_flush_restore_roundtrip() {
             let graph = state.graph.read().await;
             for i in 0..10 {
                 let triple = Triple::new(
-                    NodeId::named(&format!("node:{}", i)),
+                    NodeId::named(format!("node:{}", i)),
                     Predicate::named("value"),
                     Value::String(format!("data-{}", i)),
                 );
@@ -308,7 +308,7 @@ async fn test_app_state_flush_restore_roundtrip() {
             assert_eq!(graph.count(), 10, "graph triples should survive restart");
 
             for i in 0..10 {
-                let pattern = TriplePattern::subject(NodeId::named(&format!("node:{}", i)));
+                let pattern = TriplePattern::subject(NodeId::named(format!("node:{}", i)));
                 let results = graph.find(pattern).unwrap();
                 assert_eq!(results.len(), 1, "node:{} missing after restart", i);
                 assert_eq!(
@@ -496,7 +496,7 @@ async fn test_graph_sled_persistence_full_cycle() {
         let graph = GraphDB::sled(path_str).unwrap();
         for i in 0..25 {
             let triple = Triple::new(
-                NodeId::named(&format!("persist:{}", i)),
+                NodeId::named(format!("persist:{}", i)),
                 Predicate::named("data"),
                 Value::Float(i as f64 * 1.5),
             );
@@ -512,7 +512,7 @@ async fn test_graph_sled_persistence_full_cycle() {
         assert_eq!(graph.count(), 25, "sled graph should persist");
 
         for i in 0..25 {
-            let pattern = TriplePattern::subject(NodeId::named(&format!("persist:{}", i)));
+            let pattern = TriplePattern::subject(NodeId::named(format!("persist:{}", i)));
             let results = graph.find(pattern).unwrap();
             assert_eq!(results.len(), 1, "persist:{} missing", i);
             match &results[0].object {
diff --git a/crates/aingle_cortex/tests/rate_limiting_test.rs b/crates/aingle_cortex/tests/rate_limiting_test.rs
index 19687210..a18c8972 100644
--- a/crates/aingle_cortex/tests/rate_limiting_test.rs
+++ b/crates/aingle_cortex/tests/rate_limiting_test.rs
@@ -281,7 +281,7 @@ async fn test_rate_limiter_gradual_refill() {
 
     // Should have succeeded ~3 times (with some tolerance for timing)
     assert!(
-        successes >= 2 && successes <= 4,
+        (2..=4).contains(&successes),
         "Should refill approximately 3 tokens, got {}",
         successes
     );
diff --git a/crates/aingle_graph/src/dag/store.rs b/crates/aingle_graph/src/dag/store.rs
index b32ea183..27e6563d 100644
--- a/crates/aingle_graph/src/dag/store.rs
+++ b/crates/aingle_graph/src/dag/store.rs
@@ -713,11 +713,10 @@ impl DagStore {
             hash.copy_from_slice(&key[2..]);
 
             if let Some(action) = DagAction::from_bytes(value) {
-                if action.timestamp <= *ts {
-                    if best.as_ref().map_or(true, |(_, t)| action.timestamp > *t) {
+                if action.timestamp <= *ts
+                    && best.as_ref().is_none_or(|(_, t)| action.timestamp > *t) {
                         best = Some((DagActionHash(hash), action.timestamp));
                     }
-                }
             }
         }
 
@@ -1046,7 +1045,7 @@ fn extract_affected_triple_ids(payload: &DagPayload) -> Vec<[u8; 32]> {
     match payload {
         DagPayload::TripleInsert { triples } => triples
             .iter()
-            .map(|t| compute_triple_id_from_payload(t))
+            .map(compute_triple_id_from_payload)
             .collect(),
         DagPayload::TripleDelete { triple_ids, .. } => triple_ids.clone(),
         DagPayload::Batch { ops } => ops.iter().flat_map(extract_affected_triple_ids).collect(),
diff --git a/crates/aingle_graph/src/lib.rs b/crates/aingle_graph/src/lib.rs
index ebfa4bfe..b42ccd94 100644
--- a/crates/aingle_graph/src/lib.rs
+++ b/crates/aingle_graph/src/lib.rs
@@ -1108,11 +1108,10 @@ impl GraphDB {
         let mut deleted = 0usize;
         for triple in all {
             if let Some(name) = triple.subject.as_name() {
-                if name.starts_with(prefix) {
-                    if self.delete(&triple.id())? {
+                if name.starts_with(prefix)
+                    && self.delete(&triple.id())? {
                         deleted += 1;
                     }
-                }
             }
         }
         Ok(deleted)
@@ -1456,7 +1455,7 @@ mod tests {
 
         for i in 0..10 {
             db.insert(Triple::new(
-                NodeId::named(&format!("node:{}", i)),
+                NodeId::named(format!("node:{}", i)),
                 Predicate::named("has_value"),
                 Value::integer(i as i64),
             ))
@@ -1808,7 +1807,7 @@ mod tests {
             // DAG has one action
             let action = db.dag_action(&dag_hash).unwrap().unwrap();
             assert_eq!(action.seq, 1);
-            assert!(action.is_genesis() == false || action.parents.is_empty());
+            assert!(!action.is_genesis() || action.parents.is_empty());
 
             // Tips point to the new action
             let tips = db.dag_tips().unwrap();
@@ -1874,7 +1873,7 @@ mod tests {
 
             for seq in 1..=5 {
                 let triple = Triple::new(
-                    NodeId::named(&format!("node:{}", seq)),
+                    NodeId::named(format!("node:{}", seq)),
                     Predicate::named("p"),
                     Value::integer(seq),
                 );
diff --git a/crates/aingle_graph/tests/graph_integration_tests.rs b/crates/aingle_graph/tests/graph_integration_tests.rs
index 1029dda2..355e4600 100644
--- a/crates/aingle_graph/tests/graph_integration_tests.rs
+++ b/crates/aingle_graph/tests/graph_integration_tests.rs
@@ -152,7 +152,7 @@ fn test_batch_insertion_large() {
     let triples: Vec<Triple> = (0..100)
         .map(|i| {
             Triple::new(
-                NodeId::named(&format!("node:{}", i)),
+                NodeId::named(format!("node:{}", i)),
                 Predicate::named("has_id"),
                 Value::integer(i as i64),
             )
@@ -247,7 +247,7 @@ fn test_query_with_limit() {
     // Insert 10 triples
     for i in 0..10 {
         db.insert(Triple::new(
-            NodeId::named(&format!("node:{}", i)),
+            NodeId::named(format!("node:{}", i)),
             Predicate::named("type"),
             Value::literal("test"),
         ))
diff --git a/crates/aingle_ingest/src/chunk.rs b/crates/aingle_ingest/src/chunk.rs
index dc540327..25324370 100644
--- a/crates/aingle_ingest/src/chunk.rs
+++ b/crates/aingle_ingest/src/chunk.rs
@@ -188,8 +188,7 @@ mod tests {
         // 50 lines that are each ~1KB: a full 50-line window would exceed the
         // cap, so the window must close early on the byte budget.
         let one = "a".repeat(1024);
-        let content = std::iter::repeat(one)
-            .take(50)
+        let content = std::iter::repeat_n(one, 50)
             .collect::<Vec<_>>()
             .join("\n");
         let chunks = chunk_fixed("data.txt", &content, "h", 50);
@@ -240,7 +239,7 @@ mod tests {
         // Regression: a small markdown note splits by heading into one chunk per
         // section, none of them byte-split.
         let content = "# A\n\nalpha\n\n# B\n\nbeta\n";
-        let chunks = chunk_markdown("n.md", &content, "h");
+        let chunks = chunk_markdown("n.md", content, "h");
 
         assert_eq!(chunks.len(), 2);
         assert!(chunks[0].text.contains("alpha"));
diff --git a/crates/aingle_minimal/src/config.rs b/crates/aingle_minimal/src/config.rs
index 94459c36..47043001 100644
--- a/crates/aingle_minimal/src/config.rs
+++ b/crates/aingle_minimal/src/config.rs
@@ -45,6 +45,7 @@ use std::time::Duration;
 /// config.power_mode = PowerMode::Low;
 /// ```
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default)]
 pub enum PowerMode {
     /// Full performance with no power-saving measures.
     ///
@@ -54,6 +55,7 @@ pub enum PowerMode {
     /// A balance between performance and power consumption.
     ///
     /// This is the default mode, suitable for most use cases.
+    #[default]
     Balanced,
     /// Prioritizes low power usage by reducing activity.
     ///
@@ -65,11 +67,6 @@ pub enum PowerMode {
     Critical,
 }
 
-impl Default for PowerMode {
-    fn default() -> Self {
-        Self::Balanced
-    }
-}
 
 /// Defines the network transport to be used by the node.
 ///
@@ -321,12 +318,14 @@ impl GossipConfig {
 /// ```
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
+#[derive(Default)]
 pub enum StorageBackendType {
     /// Use SQLite for storage.
     ///
     /// SQLite is a lightweight, single-file database that's ideal for IoT devices
     /// and embedded systems. It has minimal dependencies and works well on
     /// resource-constrained platforms.
+    #[default]
     Sqlite,
     /// Use RocksDB for storage.
     ///
@@ -341,12 +340,6 @@ pub enum StorageBackendType {
     Memory,
 }
 
-impl Default for StorageBackendType {
-    fn default() -> Self {
-        // SQLite is the default for IoT compatibility.
-        Self::Sqlite
-    }
-}
 
 impl std::fmt::Display for StorageBackendType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
diff --git a/crates/aingle_minimal/src/error.rs b/crates/aingle_minimal/src/error.rs
index 4a3249ed..c20f2355 100644
--- a/crates/aingle_minimal/src/error.rs
+++ b/crates/aingle_minimal/src/error.rs
@@ -740,7 +740,7 @@ mod tests {
         let _: &dyn StdError = &error;
 
         // Test source() for Io error
-        let io_err = std::io::Error::new(std::io::ErrorKind::Other, "test");
+        let io_err = std::io::Error::other("test");
         let error = Error::Io(io_err);
         assert!(StdError::source(&error).is_some());
     }
diff --git a/crates/aingle_minimal/src/ota.rs b/crates/aingle_minimal/src/ota.rs
index 02f44a83..01ac4c7b 100644
--- a/crates/aingle_minimal/src/ota.rs
+++ b/crates/aingle_minimal/src/ota.rs
@@ -711,7 +711,7 @@ mod tests {
         };
         let cloned = update.clone();
         assert_eq!(cloned.version, "2.0.0");
-        assert_eq!(cloned.critical, true);
+        assert!(cloned.critical);
 
         let debug = format!("{:?}", update);
         assert!(debug.contains("UpdateInfo"));
diff --git a/crates/aingle_minimal/tests/transport_integration_tests.rs b/crates/aingle_minimal/tests/transport_integration_tests.rs
index d406b5ae..ebb4531a 100644
--- a/crates/aingle_minimal/tests/transport_integration_tests.rs
+++ b/crates/aingle_minimal/tests/transport_integration_tests.rs
@@ -8,7 +8,6 @@
 //! - BLE scanning, connection, and message exchange
 //! - Hardware wallet connection and signing workflow
 
-use std::time::Duration;
 
 // ============================================================================
 // WebRTC Transport Tests
diff --git a/crates/aingle_raft/src/log_store.rs b/crates/aingle_raft/src/log_store.rs
index d3dd4d27..b3d6cfde 100644
--- a/crates/aingle_raft/src/log_store.rs
+++ b/crates/aingle_raft/src/log_store.rs
@@ -258,7 +258,7 @@ impl CortexLogStore {
                     term: *term,
                     data: data.clone(),
                 })
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                .map_err(io::Error::other)?;
         }
 
         // Only update BTreeMap after all WAL writes succeed
@@ -279,7 +279,7 @@ impl CortexLogStore {
 
     pub async fn last_log_id(&self) -> Option<LogId> {
         let log = self.log.read().await;
-        log.values().last().map(|e| e.log_id.clone())
+        log.values().last().map(|e| e.log_id)
     }
 }
 
@@ -299,7 +299,7 @@ impl RaftLogReader<C> for Arc<CortexLogStore> {
 
     async fn read_vote(&mut self) -> Result<Option<Vote>, io::Error> {
         let v = self.vote.read().await;
-        Ok(v.clone())
+        Ok(*v)
     }
 }
 
@@ -318,11 +318,11 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
         let last_log_id = log
             .values()
             .last()
-            .map(|e| e.log_id.clone())
-            .or_else(|| purged.clone());
+            .map(|e| e.log_id)
+            .or_else(|| *purged);
 
         Ok(LogState {
-            last_purged_log_id: purged.clone(),
+            last_purged_log_id: *purged,
             last_log_id,
         })
     }
@@ -334,7 +334,7 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
     async fn save_vote(&mut self, vote: &Vote) -> Result<(), io::Error> {
         CortexLogStore::persist_vote(&self.wal_dir, vote)?;
         let mut v = self.vote.write().await;
-        *v = Some(vote.clone());
+        *v = Some(*vote);
         Ok(())
     }
 
@@ -347,7 +347,7 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
 
     async fn read_committed(&mut self) -> Result<Option<LogId>, io::Error> {
         let c = self.committed.read().await;
-        Ok(c.clone())
+        Ok(*c)
     }
 
     async fn append<I>(&mut self, entries: I, callback: IOFlushed<C>) -> Result<(), io::Error>
@@ -384,7 +384,7 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
 
         // Persist truncation boundary so recovery filters out stale entries
         let mut trunc = self.truncated_after.write().await;
-        *trunc = last_log_id.clone();
+        *trunc = last_log_id;
         CortexLogStore::persist_truncated_after(&self.wal_dir, &last_log_id)?;
 
         Ok(())
@@ -400,7 +400,7 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
 
         // Persist purge boundary
         let mut purged = self.purged_log_id.write().await;
-        *purged = Some(log_id.clone());
+        *purged = Some(log_id);
         CortexLogStore::persist_purged(&self.wal_dir, &log_id)?;
 
         // Clean up old WAL segments that are entirely below the purge point
diff --git a/crates/aingle_raft/src/network.rs b/crates/aingle_raft/src/network.rs
index 0cce196b..453cd8e5 100644
--- a/crates/aingle_raft/src/network.rs
+++ b/crates/aingle_raft/src/network.rs
@@ -345,7 +345,7 @@ impl CortexNetworkConnection {
                 .as_millis()
         );
 
-        let num_chunks = (payload.len() + CHUNK_SIZE - 1) / CHUNK_SIZE;
+        let num_chunks = payload.len().div_ceil(CHUNK_SIZE);
         tracing::info!(
             target_node = self.target,
             total_bytes = total_size,
diff --git a/crates/aingle_raft/src/snapshot_builder.rs b/crates/aingle_raft/src/snapshot_builder.rs
index d3dff2e8..3ef24a81 100644
--- a/crates/aingle_raft/src/snapshot_builder.rs
+++ b/crates/aingle_raft/src/snapshot_builder.rs
@@ -36,7 +36,7 @@ impl RaftSnapshotBuilder<C> for CortexSnapshotBuilder {
         let triples = {
             let all = graph
                 .find(aingle_graph::TriplePattern::any())
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| io::Error::other(e.to_string()))?;
 
             all.into_iter()
                 .map(|t| TripleSnapshot {
@@ -49,7 +49,7 @@ impl RaftSnapshotBuilder<C> for CortexSnapshotBuilder {
 
         let ineru_ltm = memory
             .export_snapshot()
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+            .map_err(|e| io::Error::other(e.to_string()))?;
 
         // Drop locks before serialization to reduce hold time
         drop(graph);
@@ -95,12 +95,12 @@ impl RaftSnapshotBuilder<C> for CortexSnapshotBuilder {
 
         let data = snapshot
             .to_bytes()
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            .map_err(io::Error::other)?;
 
         let snapshot_id = format!("snap-{}-{}", last_applied_term, last_applied_index);
 
         let meta = SnapshotMeta {
-            last_log_id: self.last_applied.clone(),
+            last_log_id: self.last_applied,
             last_membership: self.last_membership.clone(),
             snapshot_id,
         };
diff --git a/crates/aingle_raft/src/state_machine.rs b/crates/aingle_raft/src/state_machine.rs
index 64ec27e4..95667adb 100644
--- a/crates/aingle_raft/src/state_machine.rs
+++ b/crates/aingle_raft/src/state_machine.rs
@@ -428,7 +428,7 @@ impl CortexStateMachine {
     /// Get the last applied log ID.
     pub async fn last_applied(&self) -> Option<LogId> {
         let guard = self.last_applied.read().await;
-        guard.clone()
+        *guard
     }
 
     /// Get the count of applied mutations.
@@ -447,7 +447,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
     async fn applied_state(&mut self) -> Result<(Option<LogId>, StoredMembershipOf<C>), io::Error> {
         let la = self.last_applied.read().await;
         let membership = self.last_membership.read().await;
-        Ok((la.clone(), membership.clone()))
+        Ok((*la, membership.clone()))
     }
 
     async fn apply<Strm>(&mut self, mut entries: Strm) -> Result<(), io::Error>
@@ -460,7 +460,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
             // Check for membership change
             if let Some(membership) = entry.get_membership() {
                 let mut lm = self.last_membership.write().await;
-                *lm = StoredMembership::new(Some(entry.log_id.clone()), membership.clone());
+                *lm = StoredMembership::new(Some(entry.log_id), membership.clone());
             }
 
             // Apply the business logic
@@ -482,7 +482,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
             // marking entries as applied before they actually are (#1).
             {
                 let mut la = self.last_applied.write().await;
-                *la = Some(entry.log_id.clone());
+                *la = Some(entry.log_id);
             }
 
             // Send response to client if waiting (leader only)
@@ -500,7 +500,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
         CortexSnapshotBuilder {
             graph: Arc::clone(&self.graph),
             memory: Arc::clone(&self.memory),
-            last_applied: la.clone(),
+            last_applied: *la,
             last_membership: membership.clone(),
             proof_provider: self.proof_provider.clone(),
         }
@@ -522,7 +522,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
         // Build both new graph and new memory into temporaries FIRST,
         // then swap atomically only if both succeed (#7).
         let new_graph =
-            GraphDB::memory().map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+            GraphDB::memory().map_err(|e| io::Error::other(e.to_string()))?;
         for ts in &cluster_snap.triples {
             let value = json_to_value(&ts.object);
             let triple = aingle_graph::Triple::new(
@@ -532,7 +532,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
             );
             new_graph
                 .insert(triple)
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| io::Error::other(e.to_string()))?;
         }
 
         let new_memory = if !cluster_snap.ineru_ltm.is_empty() {
@@ -597,7 +597,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
         // Update metadata
         {
             let mut la = self.last_applied.write().await;
-            *la = meta.last_log_id.clone();
+            *la = meta.last_log_id;
         }
         {
             let mut lm = self.last_membership.write().await;
diff --git a/crates/aingle_viz/src/api.rs b/crates/aingle_viz/src/api.rs
index 617dece9..99558bb9 100644
--- a/crates/aingle_viz/src/api.rs
+++ b/crates/aingle_viz/src/api.rs
@@ -844,8 +844,8 @@ mod tests {
 
         // Add test data
         for i in 0..5 {
-            let node = DagNodeBuilder::new(&format!("node{}", i), NodeType::Entry)
-                .label(&format!("Node {}", i))
+            let node = DagNodeBuilder::new(format!("node{}", i), NodeType::Entry)
+                .label(format!("Node {}", i))
                 .build();
             state.add_node(node).await.unwrap();
         }
diff --git a/crates/aingle_viz/src/server.rs b/crates/aingle_viz/src/server.rs
index 25e6418d..c0e4792a 100644
--- a/crates/aingle_viz/src/server.rs
+++ b/crates/aingle_viz/src/server.rs
@@ -729,8 +729,8 @@ mod tests {
         let mut dag = DagView::new();
         for i in 0..5 {
             dag.add_node(
-                DagNodeBuilder::new(&format!("node{}", i), NodeType::Entry)
-                    .label(&format!("Node {}", i))
+                DagNodeBuilder::new(format!("node{}", i), NodeType::Entry)
+                    .label(format!("Node {}", i))
                     .build(),
             );
         }
diff --git a/crates/aingle_wal/src/writer.rs b/crates/aingle_wal/src/writer.rs
index 13b4cae1..914df15f 100644
--- a/crates/aingle_wal/src/writer.rs
+++ b/crates/aingle_wal/src/writer.rs
@@ -74,8 +74,7 @@ impl WalWriter {
 
         let prev_hash = {
             let guard = self.last_hash.lock().map_err(|e| {
-                io::Error::new(
-                    io::ErrorKind::Other,
+                io::Error::other(
                     format!("WAL last_hash lock poisoned: {e}"),
                 )
             })?;
@@ -94,8 +93,7 @@ impl WalWriter {
 
         {
             let mut seg = self.current_segment.lock().map_err(|e| {
-                io::Error::new(
-                    io::ErrorKind::Other,
+                io::Error::other(
                     format!("WAL segment lock poisoned: {e}"),
                 )
             })?;
@@ -113,8 +111,7 @@ impl WalWriter {
         // Update last_hash
         {
             let mut guard = self.last_hash.lock().map_err(|e| {
-                io::Error::new(
-                    io::ErrorKind::Other,
+                io::Error::other(
                     format!("WAL last_hash lock poisoned: {e}"),
                 )
             })?;
@@ -127,8 +124,7 @@ impl WalWriter {
     /// Flush the current segment to disk.
     pub fn sync(&self) -> io::Result<()> {
         let mut seg = self.current_segment.lock().map_err(|e| {
-            io::Error::new(
-                io::ErrorKind::Other,
+            io::Error::other(
                 format!("WAL segment lock poisoned: {e}"),
             )
         })?;
diff --git a/crates/aingle_zk/src/aggregation.rs b/crates/aingle_zk/src/aggregation.rs
index 06aea982..37a49a7b 100644
--- a/crates/aingle_zk/src/aggregation.rs
+++ b/crates/aingle_zk/src/aggregation.rs
@@ -423,7 +423,7 @@ mod tests {
 
         // Should have some size savings from aggregation
         let savings = agg.size_savings();
-        assert!(savings >= 0.0 && savings <= 1.0);
+        assert!((0.0..=1.0).contains(&savings));
 
         let ratio = agg.compression_ratio();
         // Ratio could be < 1.0 if aggregated format has overhead
diff --git a/crates/aingle_zk/src/proof.rs b/crates/aingle_zk/src/proof.rs
index 3d6d6d0d..0ec00bc1 100644
--- a/crates/aingle_zk/src/proof.rs
+++ b/crates/aingle_zk/src/proof.rs
@@ -939,7 +939,7 @@ mod tests {
 
         // Compute challenge c = H(R || P)
         let mut hasher = Sha256::new();
-        hasher.update(&r_bytes);
+        hasher.update(r_bytes);
         hasher.update(public.compress().as_bytes());
         let challenge: [u8; 32] = hasher.finalize().into();
         let c = Scalar::from_bytes_mod_order(challenge);
diff --git a/crates/kaneru/benches/agent_bench.rs b/crates/kaneru/benches/agent_bench.rs
index 197a34f5..1234c2d8 100644
--- a/crates/kaneru/benches/agent_bench.rs
+++ b/crates/kaneru/benches/agent_bench.rs
@@ -5,7 +5,7 @@
 //!
 //! Run with: cargo bench -p kaneru
 
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use kaneru::{Action, Agent, AgentConfig, Condition, Goal, Observation, Rule, SimpleAgent};
 
 /// Benchmark agent creation
diff --git a/crates/kaneru/examples/kaneru_orchestrator.rs b/crates/kaneru/examples/kaneru_orchestrator.rs
index 3acaacb0..38787e1a 100644
--- a/crates/kaneru/examples/kaneru_orchestrator.rs
+++ b/crates/kaneru/examples/kaneru_orchestrator.rs
@@ -12,8 +12,8 @@
 //! - Serialize/deserialize agent state
 
 use kaneru::{
-    Action, ActionResult, ActionType, Goal, GoalSelectionStrategy, KaneruAgent, KaneruConfig,
-    LearningAlgorithm, LearningConfig, Observation, OperationMode, Outcome, PredictiveConfig,
+    ActionResult, ActionType, Goal, GoalSelectionStrategy, KaneruAgent, KaneruConfig,
+    LearningAlgorithm, LearningConfig, Observation, OperationMode, Outcome,
     Priority,
 };
 
diff --git a/crates/kaneru/src/goal.rs b/crates/kaneru/src/goal.rs
index 1e56ffa1..d2c0b0cf 100644
--- a/crates/kaneru/src/goal.rs
+++ b/crates/kaneru/src/goal.rs
@@ -375,7 +375,7 @@ mod tests {
     #[test]
     fn test_goal_status_clone() {
         let status = GoalStatus::Active;
-        let cloned = status.clone();
+        let cloned = status;
         assert_eq!(status, cloned);
     }
 
diff --git a/crates/kaneru/src/hierarchical/decomposition.rs b/crates/kaneru/src/hierarchical/decomposition.rs
index e7ad4998..7726b0cc 100644
--- a/crates/kaneru/src/hierarchical/decomposition.rs
+++ b/crates/kaneru/src/hierarchical/decomposition.rs
@@ -330,7 +330,7 @@ impl DecompositionStrategy for ConditionalStrategy {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::ValueRange;
+    
 
     #[test]
     fn test_default_rules_exist() {
diff --git a/crates/kaneru/src/hierarchical/goal_solver.rs b/crates/kaneru/src/hierarchical/goal_solver.rs
index 4296f40e..2a5158ca 100644
--- a/crates/kaneru/src/hierarchical/goal_solver.rs
+++ b/crates/kaneru/src/hierarchical/goal_solver.rs
@@ -564,7 +564,7 @@ fn is_mutually_exclusive(g1: &GoalType, g2: &GoalType) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::Timestamp;
+    
 
     #[test]
     fn test_goal_solver_creation() {
diff --git a/crates/kaneru/src/hierarchical/tests.rs b/crates/kaneru/src/hierarchical/tests.rs
index fe596f56..229b755f 100644
--- a/crates/kaneru/src/hierarchical/tests.rs
+++ b/crates/kaneru/src/hierarchical/tests.rs
@@ -96,7 +96,7 @@ fn test_executable_goals() {
     let executable = solver.get_executable_goals();
 
     // Only the simple task and subtask should be executable
-    assert!(executable.len() >= 1);
+    assert!(!executable.is_empty());
     assert!(executable.iter().any(|g| g.id == id1));
 }
 
diff --git a/crates/kaneru/src/predictive/anomaly.rs b/crates/kaneru/src/predictive/anomaly.rs
index 57b7fff6..33768bb5 100644
--- a/crates/kaneru/src/predictive/anomaly.rs
+++ b/crates/kaneru/src/predictive/anomaly.rs
@@ -279,7 +279,7 @@ mod tests {
         detector.update(&Observation::sensor("flag", true));
         detector.update(&Observation::sensor("flag", false));
 
-        assert!(detector.history.len() > 0);
+        assert!(!detector.history.is_empty());
     }
 
     #[test]
diff --git a/examples/iot_sensor_network/src/main.rs b/examples/iot_sensor_network/src/main.rs
index ea457712..499cdf42 100644
--- a/examples/iot_sensor_network/src/main.rs
+++ b/examples/iot_sensor_network/src/main.rs
@@ -166,7 +166,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             let reading: SensorReading = serde_json::from_slice(&entry.content)?;
             println!(
                 "  {} - {} {:.2} {} at {}",
-                hash.to_string()[..8].to_string(),
+                &hash.to_string()[..8],
                 reading.sensor_id,
                 reading.value,
                 reading.unit,

From 77acd0867f94fdb0269eb5c86478f73c49041adb Mon Sep 17 00:00:00 2001
From: ApiliumDevTeam <it@apilium.com>
Date: Wed, 29 Jul 2026 10:36:01 +0200
Subject: [PATCH 3/3] style: clear the clippy lints that do not change
 behaviour
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Twenty-one of the twenty-four remaining lints, split by the kind of
decision each one represents rather than by the lint that reports it.

Notation (15). Ten `Config::default()` values built by assigning fields
afterwards become struct literals with `..Default::default()`. One loop
that existed only to index an array becomes an iterator. One `unwrap`
guarded by a separate `is_some` becomes `if let`. One doc list item that
rustdoc read as a continuation gets its blank line. And one more
assertion that asserted nothing: `!contexts.is_empty() || matches.len()
>= 0` held for every usize, so the test passed even when the query
returned nothing — the failure it exists to catch.

Descending sorts (6). `sort_by(|a, b| b.k.cmp(&a.k))` becomes
`sort_by_key(|x| Reverse(x.k))`, which is stable in the same way and
removes the class of bug where `a` and `b` are quietly transposed. All
six keys turned out to be `Copy`, so none needed the borrow-shaped
exception this pass was ready to grant.

Formatting is applied to the files this branch touches and to no others,
so the diff stays readable.

Three lints are deliberately NOT here, because they are decisions and not
cleanup, and burying them in a commit called "style" is how a semantic
change ships unreviewed. Both `clamp` sites change NaN behaviour, and the
`from_str` one shapes a public API. Each has its own issue.
---
 crates/aingle_ai/src/ineru/config.rs          | 12 ++++---
 .../aingle_ai/src/kaneru/continuum_memory.rs  |  5 +--
 crates/aingle_ai/src/kaneru/mod.rs            |  6 ++--
 crates/aingle_ai/src/kaneru/self_modifier.rs  |  6 ++--
 crates/aingle_ai/src/nested_learning/mod.rs   |  7 ++--
 crates/aingle_ai/src/types.rs                 |  4 +--
 crates/aingle_contracts/src/contract.rs       |  4 +--
 crates/aingle_cortex/src/cluster_init.rs      |  9 +++--
 crates/aingle_cortex/src/p2p/config.rs        | 11 +++---
 crates/aingle_graph/src/dag/mod.rs            |  4 +--
 crates/aingle_graph/src/dag/store.rs          | 22 ++++++------
 crates/aingle_graph/src/dag/timetravel.rs     |  1 +
 crates/aingle_graph/src/lib.rs                |  7 ++--
 crates/aingle_ingest/src/chunk.rs             |  4 +--
 crates/aingle_minimal/src/config.rs           | 12 +++----
 crates/aingle_minimal/src/network.rs          | 36 ++++++++++++-------
 .../tests/transport_integration_tests.rs      |  1 -
 crates/aingle_raft/src/log_store.rs           |  6 +---
 crates/aingle_raft/src/snapshot_builder.rs    |  4 +--
 crates/aingle_raft/src/state_machine.rs       |  3 +-
 crates/aingle_wal/src/writer.rs               | 36 +++++++++----------
 crates/kaneru/examples/kaneru_orchestrator.rs |  3 +-
 crates/kaneru/src/agent.rs                    | 10 +++---
 crates/kaneru/src/coordination.rs             |  3 +-
 .../kaneru/src/hierarchical/decomposition.rs  |  1 -
 crates/kaneru/src/hierarchical/goal_solver.rs |  1 -
 crates/kaneru/src/learning/engine.rs          | 10 +++---
 27 files changed, 118 insertions(+), 110 deletions(-)

diff --git a/crates/aingle_ai/src/ineru/config.rs b/crates/aingle_ai/src/ineru/config.rs
index b884d75e..779e8cff 100644
--- a/crates/aingle_ai/src/ineru/config.rs
+++ b/crates/aingle_ai/src/ineru/config.rs
@@ -135,12 +135,16 @@ mod tests {
 
     #[test]
     fn test_validation() {
-        let mut config = IneruConfig::default();
-        config.window_size = 0;
+        let config = IneruConfig {
+            window_size: 0,
+            ..Default::default()
+        };
         assert!(config.validate().is_err());
 
-        config = IneruConfig::default();
-        config.surprise_threshold = 1.5;
+        let config = IneruConfig {
+            surprise_threshold: 1.5,
+            ..Default::default()
+        };
         assert!(config.validate().is_err());
     }
 
diff --git a/crates/aingle_ai/src/kaneru/continuum_memory.rs b/crates/aingle_ai/src/kaneru/continuum_memory.rs
index 4104c47e..828131fe 100644
--- a/crates/aingle_ai/src/kaneru/continuum_memory.rs
+++ b/crates/aingle_ai/src/kaneru/continuum_memory.rs
@@ -5,6 +5,8 @@
 //!
 //! Non-discrete memory system with smooth interpolation.
 
+use std::cmp::Reverse;
+
 use super::{Experience, MemoryResult, Query};
 use crate::types::{pattern_id, Embedding};
 
@@ -123,8 +125,7 @@ impl ContinuumMemory {
     pub fn compress(&mut self) {
         // Keep only top half by access count
         if self.entries.len() > 100 {
-            self.entries
-                .sort_by(|a, b| b.access_count.cmp(&a.access_count));
+            self.entries.sort_by_key(|e| Reverse(e.access_count));
             self.entries.truncate(self.entries.len() / 2);
         }
     }
diff --git a/crates/aingle_ai/src/kaneru/mod.rs b/crates/aingle_ai/src/kaneru/mod.rs
index 567a3362..ec2f073f 100644
--- a/crates/aingle_ai/src/kaneru/mod.rs
+++ b/crates/aingle_ai/src/kaneru/mod.rs
@@ -423,8 +423,10 @@ mod tests {
         };
         let result = agent.query(&query);
 
-        // Should have some results
-        assert!(!result.relevant_contexts.is_empty() || result.memory_matches.len() >= 0);
+        // Should have some results. The second half used to read
+        // `memory_matches.len() >= 0`, which is true for every usize — so the
+        // assertion passed even when the query returned nothing at all.
+        assert!(!result.relevant_contexts.is_empty() || !result.memory_matches.is_empty());
     }
 
     #[test]
diff --git a/crates/aingle_ai/src/kaneru/self_modifier.rs b/crates/aingle_ai/src/kaneru/self_modifier.rs
index 2200b30b..1489eaf4 100644
--- a/crates/aingle_ai/src/kaneru/self_modifier.rs
+++ b/crates/aingle_ai/src/kaneru/self_modifier.rs
@@ -359,8 +359,10 @@ mod tests {
 
     #[test]
     fn test_rule_evolution() {
-        let mut config = KaneruConfig::default();
-        config.max_rules = 10;
+        let config = KaneruConfig {
+            max_rules: 10,
+            ..Default::default()
+        };
         let mut modifier = SelfModifier::new(&config);
 
         // Simulate good outcomes to trigger rule creation
diff --git a/crates/aingle_ai/src/nested_learning/mod.rs b/crates/aingle_ai/src/nested_learning/mod.rs
index a31fd971..7021b764 100644
--- a/crates/aingle_ai/src/nested_learning/mod.rs
+++ b/crates/aingle_ai/src/nested_learning/mod.rs
@@ -275,8 +275,11 @@ mod tests {
 
     #[test]
     fn test_meta_level_update() {
-        let mut config = NestedConfig::default();
-        config.meta_update_interval = 5; // Update every 5 blocks
+        // Update every 5 blocks
+        let config = NestedConfig {
+            meta_update_interval: 5,
+            ..Default::default()
+        };
         let mut nested = NestedLearning::new(config);
 
         let stats = BlockStats::default();
diff --git a/crates/aingle_ai/src/types.rs b/crates/aingle_ai/src/types.rs
index 613aa182..645e58a4 100644
--- a/crates/aingle_ai/src/types.rs
+++ b/crates/aingle_ai/src/types.rs
@@ -174,8 +174,8 @@ impl AiTransaction {
 
         // Entry type hash features (first 4 bytes as float)
         let type_hash = pattern_id(self.entry_type.as_bytes());
-        for i in 0..4 {
-            features.push(type_hash[i] as f32 / 255.0);
+        for byte in type_hash.iter().take(4) {
+            features.push(*byte as f32 / 255.0);
         }
 
         // Agent features (first 4 bytes)
diff --git a/crates/aingle_contracts/src/contract.rs b/crates/aingle_contracts/src/contract.rs
index 70a39a04..3739df7e 100644
--- a/crates/aingle_contracts/src/contract.rs
+++ b/crates/aingle_contracts/src/contract.rs
@@ -13,8 +13,7 @@ use crate::error::{ContractError, Result};
 use crate::types::{Address, ContractId};
 
 /// Function visibility/mutability
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub enum FunctionType {
     /// Read-only function (view)
     View,
@@ -29,7 +28,6 @@ pub enum FunctionType {
     Constructor,
 }
 
-
 /// Contract function definition
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ContractFunction {
diff --git a/crates/aingle_cortex/src/cluster_init.rs b/crates/aingle_cortex/src/cluster_init.rs
index 23dc414c..36f5342e 100644
--- a/crates/aingle_cortex/src/cluster_init.rs
+++ b/crates/aingle_cortex/src/cluster_init.rs
@@ -103,11 +103,10 @@ impl ClusterConfig {
                         i += 1;
                     }
                 }
-                "--cluster-tls-key"
-                    if i + 1 < args.len() => {
-                        cfg.tls_key = Some(args[i + 1].clone());
-                        i += 1;
-                    }
+                "--cluster-tls-key" if i + 1 < args.len() => {
+                    cfg.tls_key = Some(args[i + 1].clone());
+                    i += 1;
+                }
                 _ => {}
             }
             i += 1;
diff --git a/crates/aingle_cortex/src/p2p/config.rs b/crates/aingle_cortex/src/p2p/config.rs
index fc1d0320..56cb94ee 100644
--- a/crates/aingle_cortex/src/p2p/config.rs
+++ b/crates/aingle_cortex/src/p2p/config.rs
@@ -114,13 +114,12 @@ impl P2pConfig {
                         i += 1;
                     }
                 }
-                "--p2p-peer"
-                    if i + 1 < args.len() => {
-                        if let Ok(addr) = args[i + 1].parse::<SocketAddr>() {
-                            cfg.manual_peers.push(addr);
-                        }
-                        i += 1;
+                "--p2p-peer" if i + 1 < args.len() => {
+                    if let Ok(addr) = args[i + 1].parse::<SocketAddr>() {
+                        cfg.manual_peers.push(addr);
                     }
+                    i += 1;
+                }
                 _ => {}
             }
             i += 1;
diff --git a/crates/aingle_graph/src/dag/mod.rs b/crates/aingle_graph/src/dag/mod.rs
index 50da412d..970d8ee9 100644
--- a/crates/aingle_graph/src/dag/mod.rs
+++ b/crates/aingle_graph/src/dag/mod.rs
@@ -29,12 +29,10 @@ pub mod tips;
 pub use action::{
     DagAction, DagActionHash, DagPayload, MemoryOpKind, Provenance, TripleInsertPayload,
 };
-pub use canonical::{
-    CanonicalAction, CANONICAL_SPEC, HASH_ALG, SIGNATURE_ALG, SIGNED_MESSAGE,
-};
 #[cfg(feature = "sled-backend")]
 pub use backend::SledDagBackend;
 pub use backend::{DagBackend, MemoryDagBackend};
+pub use canonical::{CanonicalAction, CANONICAL_SPEC, HASH_ALG, SIGNATURE_ALG, SIGNED_MESSAGE};
 pub use export::{DagGraph, ExportFormat};
 pub use pruning::{PruneResult, RetentionPolicy};
 #[cfg(feature = "dag-sign")]
diff --git a/crates/aingle_graph/src/dag/store.rs b/crates/aingle_graph/src/dag/store.rs
index 27e6563d..b430cd02 100644
--- a/crates/aingle_graph/src/dag/store.rs
+++ b/crates/aingle_graph/src/dag/store.rs
@@ -7,6 +7,8 @@
 //! In-memory indexes (author chain, affected triples) are rebuilt on startup
 //! from the backend, ensuring zero data loss across restarts.
 
+use std::cmp::Reverse;
+
 use super::action::{DagAction, DagActionHash, DagPayload, TripleInsertPayload};
 use super::backend::DagBackend;
 use super::pruning::{PruneResult, RetentionPolicy};
@@ -369,7 +371,7 @@ impl DagStore {
             .collect();
 
         // Sort by seq descending (most recent first)
-        entries.sort_by(|a, b| b.0.cmp(&a.0));
+        entries.sort_by_key(|e| Reverse(e.0));
         entries.truncate(limit);
         drop(idx);
 
@@ -407,7 +409,7 @@ impl DagStore {
         }
 
         // Sort by timestamp descending
-        result.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+        result.sort_by_key(|a| Reverse(a.timestamp));
         result.truncate(limit);
 
         Ok(result)
@@ -440,7 +442,7 @@ impl DagStore {
             }
         }
 
-        result.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+        result.sort_by_key(|a| Reverse(a.timestamp));
         result.truncate(limit);
 
         Ok(result)
@@ -714,9 +716,10 @@ impl DagStore {
 
             if let Some(action) = DagAction::from_bytes(value) {
                 if action.timestamp <= *ts
-                    && best.as_ref().is_none_or(|(_, t)| action.timestamp > *t) {
-                        best = Some((DagActionHash(hash), action.timestamp));
-                    }
+                    && best.as_ref().is_none_or(|(_, t)| action.timestamp > *t)
+                {
+                    best = Some((DagActionHash(hash), action.timestamp));
+                }
             }
         }
 
@@ -1043,10 +1046,9 @@ fn topo_sort(mut collected: HashMap<[u8; 32], DagAction>) -> crate::Result<Vec<D
 /// Extract triple IDs affected by a payload (for the affected index).
 fn extract_affected_triple_ids(payload: &DagPayload) -> Vec<[u8; 32]> {
     match payload {
-        DagPayload::TripleInsert { triples } => triples
-            .iter()
-            .map(compute_triple_id_from_payload)
-            .collect(),
+        DagPayload::TripleInsert { triples } => {
+            triples.iter().map(compute_triple_id_from_payload).collect()
+        }
         DagPayload::TripleDelete { triple_ids, .. } => triple_ids.clone(),
         DagPayload::Batch { ops } => ops.iter().flat_map(extract_affected_triple_ids).collect(),
         _ => vec![],
diff --git a/crates/aingle_graph/src/dag/timetravel.rs b/crates/aingle_graph/src/dag/timetravel.rs
index 95abfb82..152885a5 100644
--- a/crates/aingle_graph/src/dag/timetravel.rs
+++ b/crates/aingle_graph/src/dag/timetravel.rs
@@ -49,6 +49,7 @@ pub struct DagDiff {
 /// Errors from individual insert/delete operations are intentionally ignored:
 /// - Duplicate inserts are expected (same triple in multiple actions).
 /// - Deletes of already-deleted triples are expected after pruning.
+///
 /// These are not failures — they're inherent to replaying a DAG.
 pub(crate) fn replay_payload(db: &crate::GraphDB, payload: &DagPayload) -> crate::Result<()> {
     match payload {
diff --git a/crates/aingle_graph/src/lib.rs b/crates/aingle_graph/src/lib.rs
index b42ccd94..ef60a331 100644
--- a/crates/aingle_graph/src/lib.rs
+++ b/crates/aingle_graph/src/lib.rs
@@ -1108,10 +1108,9 @@ impl GraphDB {
         let mut deleted = 0usize;
         for triple in all {
             if let Some(name) = triple.subject.as_name() {
-                if name.starts_with(prefix)
-                    && self.delete(&triple.id())? {
-                        deleted += 1;
-                    }
+                if name.starts_with(prefix) && self.delete(&triple.id())? {
+                    deleted += 1;
+                }
             }
         }
         Ok(deleted)
diff --git a/crates/aingle_ingest/src/chunk.rs b/crates/aingle_ingest/src/chunk.rs
index 25324370..b79f71f4 100644
--- a/crates/aingle_ingest/src/chunk.rs
+++ b/crates/aingle_ingest/src/chunk.rs
@@ -188,9 +188,7 @@ mod tests {
         // 50 lines that are each ~1KB: a full 50-line window would exceed the
         // cap, so the window must close early on the byte budget.
         let one = "a".repeat(1024);
-        let content = std::iter::repeat_n(one, 50)
-            .collect::<Vec<_>>()
-            .join("\n");
+        let content = std::iter::repeat_n(one, 50).collect::<Vec<_>>().join("\n");
         let chunks = chunk_fixed("data.txt", &content, "h", 50);
 
         assert!(
diff --git a/crates/aingle_minimal/src/config.rs b/crates/aingle_minimal/src/config.rs
index 47043001..dc5a6e75 100644
--- a/crates/aingle_minimal/src/config.rs
+++ b/crates/aingle_minimal/src/config.rs
@@ -44,8 +44,7 @@ use std::time::Duration;
 /// let mut config = Config::test_mode();
 /// config.power_mode = PowerMode::Low;
 /// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub enum PowerMode {
     /// Full performance with no power-saving measures.
     ///
@@ -67,7 +66,6 @@ pub enum PowerMode {
     Critical,
 }
 
-
 /// Defines the network transport to be used by the node.
 ///
 /// Different transports are optimized for different environments. CoAP is ideal
@@ -340,7 +338,6 @@ pub enum StorageBackendType {
     Memory,
 }
 
-
 impl std::fmt::Display for StorageBackendType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -1020,8 +1017,11 @@ mod tests {
 
     #[test]
     fn test_config_validate_invalid_memory() {
-        let mut config = Config::default();
-        config.memory_limit = 100; // Too small
+        // Too small
+        let config = Config {
+            memory_limit: 100,
+            ..Default::default()
+        };
         assert!(config.validate().is_err());
     }
 
diff --git a/crates/aingle_minimal/src/network.rs b/crates/aingle_minimal/src/network.rs
index a2d31677..15fd7e1d 100644
--- a/crates/aingle_minimal/src/network.rs
+++ b/crates/aingle_minimal/src/network.rs
@@ -12,6 +12,8 @@
 //! - **QUIC**: Future support for reliable transport
 //! - **Mesh**: Future support for mesh networking
 
+use std::cmp::Reverse;
+
 use crate::config::{GossipConfig, TransportConfig};
 use crate::discovery::Discovery;
 use crate::error::{Error, Result};
@@ -565,7 +567,7 @@ impl Network {
     /// Get peers for gossip (best quality first)
     pub fn gossip_peers(&self) -> Vec<SocketAddr> {
         let mut peers: Vec<_> = self.active_peers().into_iter().collect();
-        peers.sort_by(|a, b| b.quality.cmp(&a.quality));
+        peers.sort_by_key(|p| Reverse(p.quality));
         peers
             .into_iter()
             .take(self.gossip_config.max_peers)
@@ -905,8 +907,10 @@ mod tests {
 
     #[test]
     fn test_gossip_timing() {
-        let mut config = GossipConfig::default();
-        config.loop_delay = Duration::from_millis(10);
+        let config = GossipConfig {
+            loop_delay: Duration::from_millis(10),
+            ..Default::default()
+        };
 
         let mut gossip = GossipManager::new(config);
         assert!(!gossip.should_gossip()); // Just created
@@ -1166,8 +1170,10 @@ mod tests {
     #[test]
     fn test_network_gossip_peers_sorting() {
         let config = TransportConfig::Memory;
-        let mut gossip = GossipConfig::default();
-        gossip.max_peers = 10;
+        let gossip = GossipConfig {
+            max_peers: 10,
+            ..Default::default()
+        };
         let mut network = Network::new(config, gossip, "test-node".to_string());
 
         // Add multiple peers
@@ -1189,8 +1195,10 @@ mod tests {
     #[test]
     fn test_network_gossip_peers_limited() {
         let config = TransportConfig::Memory;
-        let mut gossip = GossipConfig::default();
-        gossip.max_peers = 2;
+        let gossip = GossipConfig {
+            max_peers: 2,
+            ..Default::default()
+        };
         let mut network = Network::new(config, gossip, "test-node".to_string());
 
         // Add more peers than limit
@@ -1260,8 +1268,10 @@ mod tests {
 
     #[test]
     fn test_gossip_manager_complete_failure() {
-        let mut config = GossipConfig::default();
-        config.loop_delay = Duration::from_millis(10);
+        let config = GossipConfig {
+            loop_delay: Duration::from_millis(10),
+            ..Default::default()
+        };
 
         let mut manager = GossipManager::new(config);
 
@@ -1589,9 +1599,11 @@ mod tests {
 
     #[test]
     fn test_gossip_manager_config() {
-        let mut config = GossipConfig::default();
-        config.loop_delay = Duration::from_millis(100);
-        config.max_peers = 5;
+        let config = GossipConfig {
+            loop_delay: Duration::from_millis(100),
+            max_peers: 5,
+            ..Default::default()
+        };
 
         let manager = GossipManager::new(config.clone());
 
diff --git a/crates/aingle_minimal/tests/transport_integration_tests.rs b/crates/aingle_minimal/tests/transport_integration_tests.rs
index ebb4531a..5c2de25d 100644
--- a/crates/aingle_minimal/tests/transport_integration_tests.rs
+++ b/crates/aingle_minimal/tests/transport_integration_tests.rs
@@ -8,7 +8,6 @@
 //! - BLE scanning, connection, and message exchange
 //! - Hardware wallet connection and signing workflow
 
-
 // ============================================================================
 // WebRTC Transport Tests
 // ============================================================================
diff --git a/crates/aingle_raft/src/log_store.rs b/crates/aingle_raft/src/log_store.rs
index b3d6cfde..a19d495c 100644
--- a/crates/aingle_raft/src/log_store.rs
+++ b/crates/aingle_raft/src/log_store.rs
@@ -315,11 +315,7 @@ impl RaftLogStorage<C> for Arc<CortexLogStore> {
         let log = self.log.read().await;
         let purged = self.purged_log_id.read().await;
 
-        let last_log_id = log
-            .values()
-            .last()
-            .map(|e| e.log_id)
-            .or_else(|| *purged);
+        let last_log_id = log.values().last().map(|e| e.log_id).or_else(|| *purged);
 
         Ok(LogState {
             last_purged_log_id: *purged,
diff --git a/crates/aingle_raft/src/snapshot_builder.rs b/crates/aingle_raft/src/snapshot_builder.rs
index 3ef24a81..d15a3244 100644
--- a/crates/aingle_raft/src/snapshot_builder.rs
+++ b/crates/aingle_raft/src/snapshot_builder.rs
@@ -93,9 +93,7 @@ impl RaftSnapshotBuilder<C> for CortexSnapshotBuilder {
             checksum: String::new(),
         };
 
-        let data = snapshot
-            .to_bytes()
-            .map_err(io::Error::other)?;
+        let data = snapshot.to_bytes().map_err(io::Error::other)?;
 
         let snapshot_id = format!("snap-{}-{}", last_applied_term, last_applied_index);
 
diff --git a/crates/aingle_raft/src/state_machine.rs b/crates/aingle_raft/src/state_machine.rs
index 95667adb..c1f6cb8d 100644
--- a/crates/aingle_raft/src/state_machine.rs
+++ b/crates/aingle_raft/src/state_machine.rs
@@ -521,8 +521,7 @@ impl RaftStateMachine<C> for Arc<CortexStateMachine> {
 
         // Build both new graph and new memory into temporaries FIRST,
         // then swap atomically only if both succeed (#7).
-        let new_graph =
-            GraphDB::memory().map_err(|e| io::Error::other(e.to_string()))?;
+        let new_graph = GraphDB::memory().map_err(|e| io::Error::other(e.to_string()))?;
         for ts in &cluster_snap.triples {
             let value = json_to_value(&ts.object);
             let triple = aingle_graph::Triple::new(
diff --git a/crates/aingle_wal/src/writer.rs b/crates/aingle_wal/src/writer.rs
index 914df15f..eb35e9b1 100644
--- a/crates/aingle_wal/src/writer.rs
+++ b/crates/aingle_wal/src/writer.rs
@@ -73,11 +73,10 @@ impl WalWriter {
         let timestamp = Utc::now();
 
         let prev_hash = {
-            let guard = self.last_hash.lock().map_err(|e| {
-                io::Error::other(
-                    format!("WAL last_hash lock poisoned: {e}"),
-                )
-            })?;
+            let guard = self
+                .last_hash
+                .lock()
+                .map_err(|e| io::Error::other(format!("WAL last_hash lock poisoned: {e}")))?;
             *guard
         };
 
@@ -92,11 +91,10 @@ impl WalWriter {
         };
 
         {
-            let mut seg = self.current_segment.lock().map_err(|e| {
-                io::Error::other(
-                    format!("WAL segment lock poisoned: {e}"),
-                )
-            })?;
+            let mut seg = self
+                .current_segment
+                .lock()
+                .map_err(|e| io::Error::other(format!("WAL segment lock poisoned: {e}")))?;
             seg.append(&entry)?;
             seg.sync()?;
 
@@ -110,11 +108,10 @@ impl WalWriter {
 
         // Update last_hash
         {
-            let mut guard = self.last_hash.lock().map_err(|e| {
-                io::Error::other(
-                    format!("WAL last_hash lock poisoned: {e}"),
-                )
-            })?;
+            let mut guard = self
+                .last_hash
+                .lock()
+                .map_err(|e| io::Error::other(format!("WAL last_hash lock poisoned: {e}")))?;
             *guard = entry.hash;
         }
 
@@ -123,11 +120,10 @@ impl WalWriter {
 
     /// Flush the current segment to disk.
     pub fn sync(&self) -> io::Result<()> {
-        let mut seg = self.current_segment.lock().map_err(|e| {
-            io::Error::other(
-                format!("WAL segment lock poisoned: {e}"),
-            )
-        })?;
+        let mut seg = self
+            .current_segment
+            .lock()
+            .map_err(|e| io::Error::other(format!("WAL segment lock poisoned: {e}")))?;
         seg.sync()
     }
 
diff --git a/crates/kaneru/examples/kaneru_orchestrator.rs b/crates/kaneru/examples/kaneru_orchestrator.rs
index 38787e1a..3b5f2d66 100644
--- a/crates/kaneru/examples/kaneru_orchestrator.rs
+++ b/crates/kaneru/examples/kaneru_orchestrator.rs
@@ -13,8 +13,7 @@
 
 use kaneru::{
     ActionResult, ActionType, Goal, GoalSelectionStrategy, KaneruAgent, KaneruConfig,
-    LearningAlgorithm, LearningConfig, Observation, OperationMode, Outcome,
-    Priority,
+    LearningAlgorithm, LearningConfig, Observation, OperationMode, Outcome, Priority,
 };
 
 fn main() {
diff --git a/crates/kaneru/src/agent.rs b/crates/kaneru/src/agent.rs
index c935fff2..b1624975 100644
--- a/crates/kaneru/src/agent.rs
+++ b/crates/kaneru/src/agent.rs
@@ -872,10 +872,12 @@ impl Agent for SimpleAgent {
         self.stats.actions_executed += 1;
 
         // Store state-action pair for learning
-        if self.config.learning_enabled && self.last_observation.is_some() {
-            let state_id = StateId::from_observation(self.last_observation.as_ref().unwrap());
-            let action_id = ActionId::from_action(&action);
-            self.last_state_action = Some((state_id, action_id));
+        if self.config.learning_enabled {
+            if let Some(observation) = self.last_observation.as_ref() {
+                let state_id = StateId::from_observation(observation);
+                let action_id = ActionId::from_action(&action);
+                self.last_state_action = Some((state_id, action_id));
+            }
         }
 
         // Simple execution - just log and return success
diff --git a/crates/kaneru/src/coordination.rs b/crates/kaneru/src/coordination.rs
index 2ec8f594..b2850418 100644
--- a/crates/kaneru/src/coordination.rs
+++ b/crates/kaneru/src/coordination.rs
@@ -36,6 +36,7 @@
 
 use crate::{Action, AgentId, KaneruAgent, Observation, Outcome};
 use serde::{Deserialize, Serialize};
+use std::cmp::Reverse;
 use std::collections::{HashMap, VecDeque};
 
 /// A unique identifier for a `Message`.
@@ -301,7 +302,7 @@ impl MessageBus {
         }
 
         self.queue = remaining;
-        messages.sort_by(|a, b| b.priority.cmp(&a.priority));
+        messages.sort_by_key(|m| Reverse(m.priority));
         messages
     }
 
diff --git a/crates/kaneru/src/hierarchical/decomposition.rs b/crates/kaneru/src/hierarchical/decomposition.rs
index 7726b0cc..773b159f 100644
--- a/crates/kaneru/src/hierarchical/decomposition.rs
+++ b/crates/kaneru/src/hierarchical/decomposition.rs
@@ -330,7 +330,6 @@ impl DecompositionStrategy for ConditionalStrategy {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
 
     #[test]
     fn test_default_rules_exist() {
diff --git a/crates/kaneru/src/hierarchical/goal_solver.rs b/crates/kaneru/src/hierarchical/goal_solver.rs
index 2a5158ca..6abcb834 100644
--- a/crates/kaneru/src/hierarchical/goal_solver.rs
+++ b/crates/kaneru/src/hierarchical/goal_solver.rs
@@ -564,7 +564,6 @@ fn is_mutually_exclusive(g1: &GoalType, g2: &GoalType) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
 
     #[test]
     fn test_goal_solver_creation() {
diff --git a/crates/kaneru/src/learning/engine.rs b/crates/kaneru/src/learning/engine.rs
index a78328f1..bb813b5e 100644
--- a/crates/kaneru/src/learning/engine.rs
+++ b/crates/kaneru/src/learning/engine.rs
@@ -670,10 +670,12 @@ mod tests {
 
     #[test]
     fn test_epsilon_decay() {
-        let mut config = LearningConfig::default();
-        config.epsilon = 1.0;
-        config.epsilon_decay = 0.9;
-        config.epsilon_min = 0.1;
+        let config = LearningConfig {
+            epsilon: 1.0,
+            epsilon_decay: 0.9,
+            epsilon_min: 0.1,
+            ..Default::default()
+        };
 
         let mut engine = LearningEngine::new(config);