diff --git a/crates/common/src/metrics/questdb_sink.rs b/crates/common/src/metrics/questdb_sink.rs
index 3d01ea29e..005bb9368 100644
--- a/crates/common/src/metrics/questdb_sink.rs
+++ b/crates/common/src/metrics/questdb_sink.rs
@@ -220,7 +220,7 @@ pub fn flush() {
 
     if let Ok(handle) = Handle::try_current() {
         // We need to block on the async health_check which triggers a flush
-        let _ = handle.block_on(async {
+        handle.block_on(async {
             // Force a health check which will attempt to flush
             client.health_check().await;
         });
diff --git a/crates/ml-asset-selection/src/lib.rs b/crates/ml-asset-selection/src/lib.rs
index 1f44d5063..dc0bfa0b7 100644
--- a/crates/ml-asset-selection/src/lib.rs
+++ b/crates/ml-asset-selection/src/lib.rs
@@ -104,7 +104,7 @@ struct SymbolConfigEntry {
 impl AssetUniverse {
     /// Create an empty universe.
     #[must_use]
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { assets: Vec::new() }
     }
 
diff --git a/crates/ml-asset-selection/src/scorer.rs b/crates/ml-asset-selection/src/scorer.rs
index 9789f9421..f0353abca 100644
--- a/crates/ml-asset-selection/src/scorer.rs
+++ b/crates/ml-asset-selection/src/scorer.rs
@@ -122,7 +122,7 @@ impl PredictabilityScorer {
         let deque = self
             .history
             .entry(result.symbol.clone())
-            .or_insert_with(VecDeque::new);
+            .or_default();
         deque.push_back(result);
         while deque.len() > self.window_size {
             deque.pop_front();
@@ -160,7 +160,7 @@ impl PredictabilityScorer {
             + self.weights.liquidity * liquidity
             + self.weights.regime_fit * regime_fit;
         AssetScore {
-            symbol: symbol.to_string(),
+            symbol: symbol.to_owned(),
             predictability,
             liquidity,
             regime_fit,
diff --git a/crates/ml-asset-selection/src/selector.rs b/crates/ml-asset-selection/src/selector.rs
index 0a556b935..03d98d8c5 100644
--- a/crates/ml-asset-selection/src/selector.rs
+++ b/crates/ml-asset-selection/src/selector.rs
@@ -73,7 +73,7 @@ impl fmt::Debug for ActiveSetSelector {
 impl ActiveSetSelector {
     /// Create a new selector with the given configuration.
     #[must_use]
-    pub fn new(config: ActiveSetConfig) -> Self {
+    pub const fn new(config: ActiveSetConfig) -> Self {
         Self {
             config,
             active_set: Vec::new(),
diff --git a/crates/ml-backtesting/src/action_loader.rs b/crates/ml-backtesting/src/action_loader.rs
index 41aca0425..61c2bfa0d 100644
--- a/crates/ml-backtesting/src/action_loader.rs
+++ b/crates/ml-backtesting/src/action_loader.rs
@@ -8,7 +8,7 @@ use std::io::BufReader;
 use std::path::Path;
 
 /// DQN action record from CSV (13,552 actions, 10 columns)
-/// Format: timestamp,action,q_buy,q_sell,q_hold,open,high,low,close,volume
+/// Format: `timestamp,action,q_buy,q_sell,q_hold,open,high,low,close,volume`
 #[derive(Debug, Clone, Deserialize)]
 pub struct DQNActionRecord {
     /// ISO8601 timestamp (e.g., "2024-10-20T23:31:00.000000000Z")
@@ -37,7 +37,7 @@ pub struct DQNActionRecord {
 /// Load DQN actions from CSV file
 ///
 /// # Arguments
-/// * `csv_path` - Path to CSV file (e.g., "/tmp/dqn_actions_wave3.csv")
+/// * `csv_path` - Path to CSV file (e.g., "/`tmp/dqn_actions_wave3.csv`")
 ///
 /// # Returns
 /// * `Ok(Vec<DQNActionRecord>)` - Parsed and validated actions
@@ -45,7 +45,7 @@ pub struct DQNActionRecord {
 ///
 /// # Validations
 /// 1. Action bounds: 0 <= action <= 2
-/// 2. Finite Q-values: q_buy, q_sell, q_hold must be finite (no NaN/Inf)
+/// 2. Finite Q-values: `q_buy`, `q_sell`, `q_hold` must be finite (no NaN/Inf)
 /// 3. Timestamp ordering: timestamps must be monotonically increasing
 ///
 /// # Example
diff --git a/crates/ml-backtesting/src/barrier_backtest.rs b/crates/ml-backtesting/src/barrier_backtest.rs
index 3736ae7ba..48217e098 100644
--- a/crates/ml-backtesting/src/barrier_backtest.rs
+++ b/crates/ml-backtesting/src/barrier_backtest.rs
@@ -56,7 +56,7 @@ pub struct BarrierBacktester {
 
 impl BarrierBacktester {
     /// Create new barrier backtester
-    pub fn new(walk_forward_windows: usize, train_test_split: f64) -> Self {
+    pub const fn new(walk_forward_windows: usize, train_test_split: f64) -> Self {
         Self {
             walk_forward_windows,
             train_test_split,
@@ -64,12 +64,12 @@ impl BarrierBacktester {
     }
 
     /// Get walk-forward windows configuration
-    pub fn walk_forward_windows(&self) -> usize {
+    pub const fn walk_forward_windows(&self) -> usize {
         self.walk_forward_windows
     }
 
     /// Get train/test split ratio
-    pub fn train_test_split(&self) -> f64 {
+    pub const fn train_test_split(&self) -> f64 {
         self.train_test_split
     }
 
diff --git a/crates/ml-backtesting/src/report.rs b/crates/ml-backtesting/src/report.rs
index 1b2d8a6b1..f1a540e00 100644
--- a/crates/ml-backtesting/src/report.rs
+++ b/crates/ml-backtesting/src/report.rs
@@ -134,38 +134,38 @@ impl BacktestReport {
         report.push_str(&format!(
             "| Total Return | {:.2}% | >0% | {} |\n",
             m.total_return_pct,
-            if m.total_return_pct > 0.0 { "✅" } else { "❌" }
+            if m.total_return_pct > 0.0 { "\u{2705}" } else { "\u{274c}" }
         ));
         
         // Sharpe Ratio
         report.push_str(&format!(
             "| Sharpe Ratio | {:.2} | >1.5 | {} |\n",
             m.sharpe_ratio,
-            if m.sharpe_ratio > 1.5 { "✅" } else { "❌" }
+            if m.sharpe_ratio > 1.5 { "\u{2705}" } else { "\u{274c}" }
         ));
         
         // Max Drawdown
         report.push_str(&format!(
             "| Max Drawdown | {:.2}% | <20% | {} |\n",
             m.max_drawdown_pct,
-            if m.max_drawdown_pct < 20.0 { "✅" } else { "❌" }
+            if m.max_drawdown_pct < 20.0 { "\u{2705}" } else { "\u{274c}" }
         ));
         
         // Win Rate
         report.push_str(&format!(
             "| Win Rate | {:.1}% | >50% | {} |\n",
             m.win_rate * 100.0,
-            if m.win_rate > 0.50 { "✅" } else { "❌" }
+            if m.win_rate > 0.50 { "\u{2705}" } else { "\u{274c}" }
         ));
         
         // Alpha
         report.push_str(&format!(
             "| Alpha vs B&H | {:.2}% | >0% | {} |\n",
             m.alpha,
-            if m.alpha > 0.0 { "✅" } else { "❌" }
+            if m.alpha > 0.0 { "\u{2705}" } else { "\u{274c}" }
         ));
         
-        report.push_str("\n");
+        report.push('\n');
         
         // Comparison to baseline (if provided)
         if let Some(baseline) = &self.baseline_results {
@@ -175,7 +175,7 @@ impl BacktestReport {
             
             // Returns comparison
             let return_change = m.total_return_pct - baseline.total_return_pct;
-            let return_arrow = if return_change > 0.0 { "↗️" } else if return_change < 0.0 { "↘️" } else { "→" };
+            let return_arrow = if return_change > 0.0 { "\u{2197}\u{fe0f}" } else if return_change < 0.0 { "\u{2198}\u{fe0f}" } else { "\u{2192}" };
             report.push_str(&format!(
                 "| Returns | {:.2}% | {:.2}% | {:+.2}% | {} |\n",
                 baseline.total_return_pct, m.total_return_pct, return_change, return_arrow
@@ -183,7 +183,7 @@ impl BacktestReport {
             
             // Sharpe comparison
             let sharpe_change = m.sharpe_ratio - baseline.sharpe_ratio;
-            let sharpe_arrow = if sharpe_change > 0.0 { "↗️" } else if sharpe_change < 0.0 { "↘️" } else { "→" };
+            let sharpe_arrow = if sharpe_change > 0.0 { "\u{2197}\u{fe0f}" } else if sharpe_change < 0.0 { "\u{2198}\u{fe0f}" } else { "\u{2192}" };
             report.push_str(&format!(
                 "| Sharpe | {:.2} | {:.2} | {:+.2} | {} |\n",
                 baseline.sharpe_ratio, m.sharpe_ratio, sharpe_change, sharpe_arrow
@@ -191,7 +191,7 @@ impl BacktestReport {
             
             // Drawdown comparison (lower is better)
             let dd_change = m.max_drawdown_pct - baseline.max_drawdown_pct;
-            let dd_arrow = if dd_change < 0.0 { "↗️" } else if dd_change > 0.0 { "↘️" } else { "→" };
+            let dd_arrow = if dd_change < 0.0 { "\u{2197}\u{fe0f}" } else if dd_change > 0.0 { "\u{2198}\u{fe0f}" } else { "\u{2192}" };
             report.push_str(&format!(
                 "| Drawdown | {:.2}% | {:.2}% | {:+.2}% | {} |\n",
                 baseline.max_drawdown_pct, m.max_drawdown_pct, dd_change, dd_arrow
@@ -199,7 +199,7 @@ impl BacktestReport {
             
             // Win Rate comparison
             let wr_change = (m.win_rate - baseline.win_rate) * 100.0;
-            let wr_arrow = if wr_change > 0.0 { "↗️" } else if wr_change < 0.0 { "↘️" } else { "→" };
+            let wr_arrow = if wr_change > 0.0 { "\u{2197}\u{fe0f}" } else if wr_change < 0.0 { "\u{2198}\u{fe0f}" } else { "\u{2192}" };
             report.push_str(&format!(
                 "| Win Rate | {:.1}% | {:.1}% | {:+.1}% | {} |\n",
                 baseline.win_rate * 100.0, m.win_rate * 100.0, wr_change, wr_arrow
@@ -207,13 +207,13 @@ impl BacktestReport {
             
             // Alpha comparison
             let alpha_change = m.alpha - baseline.alpha;
-            let alpha_arrow = if alpha_change > 0.0 { "↗️" } else if alpha_change < 0.0 { "↘️" } else { "→" };
+            let alpha_arrow = if alpha_change > 0.0 { "\u{2197}\u{fe0f}" } else if alpha_change < 0.0 { "\u{2198}\u{fe0f}" } else { "\u{2192}" };
             report.push_str(&format!(
                 "| Alpha | {:.2}% | {:.2}% | {:+.2}% | {} |\n",
                 baseline.alpha, m.alpha, alpha_change, alpha_arrow
             ));
             
-            report.push_str("\n");
+            report.push('\n');
         }
         
         // Trade Statistics
@@ -229,7 +229,7 @@ impl BacktestReport {
             report.push_str(&format!("| Trades vs Baseline | {:+} |\n", trade_diff));
         }
         
-        report.push_str("\n");
+        report.push('\n');
         
         // Deployment Recommendation
         report.push_str("## Deployment Recommendation\n\n");
@@ -242,27 +242,27 @@ impl BacktestReport {
         let criteria_passed = self.count_criteria_passed();
         report.push_str(&format!("- **Criteria Passed**: {}/5\n", criteria_passed));
         report.push_str(&format!("- **Total Return**: {} ({})\n", 
-            if m.total_return_pct > 0.0 { "✅ PASS" } else { "❌ FAIL" },
+            if m.total_return_pct > 0.0 { "\u{2705} PASS" } else { "\u{274c} FAIL" },
             format!("{:.2}% > 0%", m.total_return_pct)
         ));
         report.push_str(&format!("- **Sharpe Ratio**: {} ({})\n", 
-            if m.sharpe_ratio > 1.5 { "✅ PASS" } else { "❌ FAIL" },
+            if m.sharpe_ratio > 1.5 { "\u{2705} PASS" } else { "\u{274c} FAIL" },
             format!("{:.2} > 1.5", m.sharpe_ratio)
         ));
         report.push_str(&format!("- **Max Drawdown**: {} ({})\n", 
-            if m.max_drawdown_pct < 20.0 { "✅ PASS" } else { "❌ FAIL" },
+            if m.max_drawdown_pct < 20.0 { "\u{2705} PASS" } else { "\u{274c} FAIL" },
             format!("{:.2}% < 20%", m.max_drawdown_pct)
         ));
         report.push_str(&format!("- **Win Rate**: {} ({})\n", 
-            if m.win_rate > 0.50 { "✅ PASS" } else { "❌ FAIL" },
+            if m.win_rate > 0.50 { "\u{2705} PASS" } else { "\u{274c} FAIL" },
             format!("{:.1}% > 50%", m.win_rate * 100.0)
         ));
         report.push_str(&format!("- **Alpha vs B&H**: {} ({})\n", 
-            if m.alpha > 0.0 { "✅ PASS" } else { "❌ FAIL" },
+            if m.alpha > 0.0 { "\u{2705} PASS" } else { "\u{274c} FAIL" },
             format!("{:.2}% > 0%", m.alpha)
         ));
         
-        report.push_str("\n");
+        report.push('\n');
         
         // Footer
         report.push_str("---\n\n");
@@ -307,7 +307,7 @@ impl BacktestReport {
         
         if passes >= 4 {
             Recommendation {
-                status: "✅ APPROVE - Ready for Production".to_owned(),
+                status: "\u{2705} APPROVE - Ready for Production".to_owned(),
                 reasoning: format!(
                     "Model passes {}/5 production criteria. Strong performance with {} return, {} Sharpe ratio, and {} win rate. \
                     Risk is acceptable with {} max drawdown. Model demonstrates profitability with {} alpha vs buy-and-hold. \
@@ -322,7 +322,7 @@ impl BacktestReport {
             }
         } else if passes >= 2 {
             Recommendation {
-                status: "⚠️ REVIEW - Marginal Performance".to_owned(),
+                status: "\u{26a0}\u{fe0f} REVIEW - Marginal Performance".to_owned(),
                 reasoning: format!(
                     "Model passes {}/5 production criteria. Performance is marginal and requires careful review. \
                     \n\n**Concerns**:\n{}
@@ -333,7 +333,7 @@ impl BacktestReport {
             }
         } else {
             Recommendation {
-                status: "❌ REJECT - Not Production Ready".to_owned(),
+                status: "\u{274c} REJECT - Not Production Ready".to_owned(),
                 reasoning: format!(
                     "Model only passes {}/5 production criteria. Performance is insufficient for production deployment. \
                     \n\n**Critical Issues**:\n{}
@@ -355,19 +355,19 @@ impl BacktestReport {
         let mut concerns = Vec::new();
         
         if m.total_return_pct <= 0.0 {
-            concerns.push(format!("- ❌ Negative total return ({:.2}%)", m.total_return_pct));
+            concerns.push(format!("- \u{274c} Negative total return ({:.2}%)", m.total_return_pct));
         }
         if m.sharpe_ratio <= 1.5 {
-            concerns.push(format!("- ❌ Low Sharpe ratio ({:.2} < 1.5)", m.sharpe_ratio));
+            concerns.push(format!("- \u{274c} Low Sharpe ratio ({:.2} < 1.5)", m.sharpe_ratio));
         }
         if m.max_drawdown_pct >= 20.0 {
-            concerns.push(format!("- ❌ Excessive drawdown ({:.2}% > 20%)", m.max_drawdown_pct));
+            concerns.push(format!("- \u{274c} Excessive drawdown ({:.2}% > 20%)", m.max_drawdown_pct));
         }
         if m.win_rate <= 0.50 {
-            concerns.push(format!("- ❌ Poor win rate ({:.1}% < 50%)", m.win_rate * 100.0));
+            concerns.push(format!("- \u{274c} Poor win rate ({:.1}% < 50%)", m.win_rate * 100.0));
         }
         if m.alpha <= 0.0 {
-            concerns.push(format!("- ❌ Negative alpha ({:.2}%)", m.alpha));
+            concerns.push(format!("- \u{274c} Negative alpha ({:.2}%)", m.alpha));
         }
         
         if concerns.is_empty() {
diff --git a/crates/ml-checkpoint/src/compression.rs b/crates/ml-checkpoint/src/compression.rs
index 608c6dafe..6cb6e6eeb 100644
--- a/crates/ml-checkpoint/src/compression.rs
+++ b/crates/ml-checkpoint/src/compression.rs
@@ -19,7 +19,7 @@ pub struct CompressionManager {
 
 impl CompressionManager {
     /// Create a new compression manager
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { default_level: 3 }
     }
 
@@ -255,7 +255,7 @@ impl CompressionStats {
     }
 
     /// Calculate average compression time
-    pub fn avg_compress_time_us(&self) -> u64 {
+    pub const fn avg_compress_time_us(&self) -> u64 {
         if self.compression_count > 0 {
             self.total_compress_time_us / self.compression_count
         } else {
@@ -264,7 +264,7 @@ impl CompressionStats {
     }
 
     /// Calculate average decompression time
-    pub fn avg_decompress_time_us(&self) -> u64 {
+    pub const fn avg_decompress_time_us(&self) -> u64 {
         if self.decompression_count > 0 {
             self.total_decompress_time_us / self.decompression_count
         } else {
@@ -273,7 +273,7 @@ impl CompressionStats {
     }
 
     /// Calculate compression savings in bytes
-    pub fn bytes_saved(&self) -> u64 {
+    pub const fn bytes_saved(&self) -> u64 {
         self.total_uncompressed
             .saturating_sub(self.total_compressed)
     }
diff --git a/crates/ml-checkpoint/src/lib.rs b/crates/ml-checkpoint/src/lib.rs
index 7e7bee003..0d74993b9 100644
--- a/crates/ml-checkpoint/src/lib.rs
+++ b/crates/ml-checkpoint/src/lib.rs
@@ -59,7 +59,7 @@ pub enum CheckpointFormat {
     Binary,
     /// JSON format (human-readable)
     JSON,
-    /// MessagePack format (compact)
+    /// `MessagePack` format (compact)
     MessagePack,
     /// Custom optimized format
     Custom,
@@ -210,7 +210,7 @@ impl CheckpointMetadata {
     }
 
     /// Add training state information
-    pub fn with_training_state(
+    pub const fn with_training_state(
         mut self,
         epoch: Option<u64>,
         step: Option<u64>,
@@ -501,8 +501,8 @@ impl CheckpointManager {
         let (epoch, step, loss, accuracy) = model.get_training_state();
         let mut metadata = CheckpointMetadata::new(
             model.model_type(),
-            model.model_name().to_string(),
-            model.model_version().to_string(),
+            model.model_name().to_owned(),
+            model.model_version().to_owned(),
         )
         .with_training_state(epoch, step, loss, accuracy)
         .with_hyperparameters(model.get_hyperparameters())
@@ -574,7 +574,7 @@ impl CheckpointManager {
             .record_save(original_size, save_time_us, compression_savings);
 
         info!(
-            "Checkpoint saved: {} ({} bytes, {}µs, {:.1}% compression)",
+            "Checkpoint saved: {} ({} bytes, {}\u{b5}s, {:.1}% compression)",
             filename,
             final_data.len(),
             save_time_us,
@@ -648,7 +648,7 @@ impl CheckpointManager {
             .record_load(final_data.len() as u64, load_time_us);
 
         info!(
-            "Checkpoint loaded: {} ({} bytes, {}µs)",
+            "Checkpoint loaded: {} ({} bytes, {}\u{b5}s)",
             filename,
             final_data.len(),
             load_time_us
diff --git a/crates/ml-checkpoint/src/signer.rs b/crates/ml-checkpoint/src/signer.rs
index 7f29e7072..a93d7016c 100644
--- a/crates/ml-checkpoint/src/signer.rs
+++ b/crates/ml-checkpoint/src/signer.rs
@@ -239,39 +239,36 @@ impl CheckpointSigner {
             key_id.replace('-', "_")
         );
 
-        match std::env::var(&env_key) {
-            Ok(key_hex) => {
-                let key_data = hex::decode(&key_hex).map_err(|e| MLError::ConfigError(format!("Invalid key hex in {}: {}", env_key, e)))?;
+        if let Ok(key_hex) = std::env::var(&env_key) {
+            let key_data = hex::decode(&key_hex).map_err(|e| MLError::ConfigError(format!("Invalid key hex in {}: {}", env_key, e)))?;
 
-                if key_data.len() != 32 {
-                    return Err(MLError::ConfigError(format!(
-                            "Invalid key length in {} (expected 32 bytes, got {})",
-                            env_key,
-                            key_data.len()
-                        )));
-                }
+            if key_data.len() != 32 {
+                return Err(MLError::ConfigError(format!(
+                        "Invalid key length in {} (expected 32 bytes, got {})",
+                        env_key,
+                        key_data.len()
+                    )));
+            }
 
-                info!(
-                    "Loaded signing key for {:?} from environment (key_id: {})",
-                    model_type, key_id
-                );
-                Ok(key_data)
-            },
-            Err(_) => {
-                // Generate a default key for development/testing
-                warn!(
-                    "No signing key found in Vault or environment for {:?} (key_id: {}), using default development key",
-                    model_type, key_id
-                );
+            info!(
+                "Loaded signing key for {:?} from environment (key_id: {})",
+                model_type, key_id
+            );
+            Ok(key_data)
+        } else {
+            // Generate a default key for development/testing
+            warn!(
+                "No signing key found in Vault or environment for {:?} (key_id: {}), using default development key",
+                model_type, key_id
+            );
 
-                // Generate deterministic key from model_type + key_id for consistency
-                let seed = format!("foxhunt-{:?}-{}", model_type, key_id);
-                let mut hasher = Sha256::new();
-                use sha2::Digest;
-                hasher.update(seed.as_bytes());
-                let hash = hasher.finalize();
-                Ok(hash.to_vec())
-            },
+            // Generate deterministic key from model_type + key_id for consistency
+            let seed = format!("foxhunt-{:?}-{}", model_type, key_id);
+            let mut hasher = Sha256::new();
+            use sha2::Digest;
+            hasher.update(seed.as_bytes());
+            let hash = hasher.finalize();
+            Ok(hash.to_vec())
         }
     }
 
diff --git a/crates/ml-checkpoint/src/storage.rs b/crates/ml-checkpoint/src/storage.rs
index cde755c61..f5d6dbbeb 100644
--- a/crates/ml-checkpoint/src/storage.rs
+++ b/crates/ml-checkpoint/src/storage.rs
@@ -435,7 +435,7 @@ impl CheckpointStorage for MemoryStorage {
                     .map_err(|e| MLError::ConcurrencyError {
                         operation: format!("write lock checkpoints: {}", e),
                     })?;
-            checkpoints.insert(filename.to_string(), data.to_vec());
+            checkpoints.insert(filename.to_owned(), data.to_vec());
         }
 
         {
@@ -445,7 +445,7 @@ impl CheckpointStorage for MemoryStorage {
                     .map_err(|e| MLError::ConcurrencyError {
                         operation: format!("write lock metadata: {}", e),
                     })?;
-            metadata_map.insert(filename.to_string(), metadata.clone());
+            metadata_map.insert(filename.to_owned(), metadata.clone());
         }
 
         debug!(
diff --git a/crates/ml-checkpoint/src/validation.rs b/crates/ml-checkpoint/src/validation.rs
index 2d9e65836..232a863f0 100644
--- a/crates/ml-checkpoint/src/validation.rs
+++ b/crates/ml-checkpoint/src/validation.rs
@@ -133,7 +133,7 @@ impl ValidationManager {
 
         // Validate metrics ranges
         if let Some(accuracy) = metadata.accuracy {
-            if accuracy < 0.0 || accuracy > 1.0 {
+            if !(0.0..=1.0).contains(&accuracy) {
                 return Err(MLError::ModelError(format!(
                     "Accuracy must be between 0 and 1, got: {}",
                     accuracy
@@ -286,7 +286,7 @@ impl ValidationManager {
     }
 
     /// Get validation statistics
-    pub fn get_stats(&self) -> &ValidationStats {
+    pub const fn get_stats(&self) -> &ValidationStats {
         &self.stats
     }
 }
diff --git a/crates/ml-checkpoint/src/versioning.rs b/crates/ml-checkpoint/src/versioning.rs
index 7977de91f..c9fa6786a 100644
--- a/crates/ml-checkpoint/src/versioning.rs
+++ b/crates/ml-checkpoint/src/versioning.rs
@@ -32,7 +32,7 @@ pub struct SemanticVersion {
 
 impl SemanticVersion {
     /// Create a new semantic version
-    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
+    pub const fn new(major: u32, minor: u32, patch: u32) -> Self {
         Self {
             major,
             minor,
@@ -46,11 +46,11 @@ impl SemanticVersion {
     pub fn parse(version_str: &str) -> Result<Self, MLError> {
         let mut parts = version_str.split('+');
         let version_part = parts.next().unwrap_or("");
-        let build_metadata = parts.next().map(|s| s.to_string());
+        let build_metadata = parts.next().map(|s| s.to_owned());
 
         let mut version_pre_parts = version_part.split('-');
         let version_core = version_pre_parts.next().unwrap_or("");
-        let pre_release = version_pre_parts.next().map(|s| s.to_string());
+        let pre_release = version_pre_parts.next().map(|s| s.to_owned());
 
         let version_nums: Vec<&str> = version_core.split('.').collect();
         if version_nums.len() != 3 {
@@ -99,7 +99,7 @@ impl SemanticVersion {
     }
 
     /// Check if this version is compatible with another version
-    pub fn is_compatible_with(&self, other: &SemanticVersion) -> bool {
+    pub const fn is_compatible_with(&self, other: &SemanticVersion) -> bool {
         // Major version must match for compatibility
         if self.major != other.major {
             return false;
@@ -116,7 +116,7 @@ impl SemanticVersion {
     }
 
     /// Get compatibility risk level
-    pub fn compatibility_risk(&self, other: &SemanticVersion) -> CompatibilityRisk {
+    pub const fn compatibility_risk(&self, other: &SemanticVersion) -> CompatibilityRisk {
         if self.major != other.major {
             CompatibilityRisk::High
         } else if self.minor != other.minor {
@@ -265,7 +265,7 @@ impl VersionManager {
         handler: MigrationHandler,
     ) {
         let key = (model_type, from_version.clone(), to_version.clone());
-        self.migration_handlers.insert(key.clone(), handler);
+        self.migration_handlers.insert(key, handler);
         info!(
             "Registered migration handler for {:?} -> {:?}",
             from_version, to_version
diff --git a/crates/ml-data-validation/src/corrector.rs b/crates/ml-data-validation/src/corrector.rs
index 901b4c839..c8ef2f709 100644
--- a/crates/ml-data-validation/src/corrector.rs
+++ b/crates/ml-data-validation/src/corrector.rs
@@ -34,7 +34,7 @@ impl std::fmt::Debug for DataCorrector {
 
 impl DataCorrector {
     /// Create new data corrector
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             corrections_applied: std::sync::atomic::AtomicUsize::new(0),
         }
@@ -122,7 +122,7 @@ impl DataCorrector {
         let vol_mad = calculate_mad(&volumes, vol_median);
 
         // Correct volume outliers
-        for (_i, bar) in corrected.iter_mut().enumerate() {
+        for bar in corrected.iter_mut() {
             // Use modified z-score with MAD: z = 0.6745 * (x - median) / MAD
             // This is more robust to outliers than standard z-score
             let modified_z = if vol_mad > 0.0 {
@@ -168,7 +168,7 @@ impl DataCorrector {
         }
 
         let mut filled = Vec::new();
-        filled.push(bars[0].clone());
+        filled.push(bars[0]);
 
         for i in 1..bars.len() {
             let prev = &bars[i - 1];
@@ -191,7 +191,7 @@ impl DataCorrector {
                     .fetch_add(missing_bars as usize, std::sync::atomic::Ordering::Relaxed);
             }
 
-            filled.push(curr.clone());
+            filled.push(*curr);
         }
 
         Ok(filled)
diff --git a/crates/ml-data-validation/src/cpcv.rs b/crates/ml-data-validation/src/cpcv.rs
index 016dbff27..6f7c1d3af 100644
--- a/crates/ml-data-validation/src/cpcv.rs
+++ b/crates/ml-data-validation/src/cpcv.rs
@@ -12,7 +12,7 @@
 //!
 //! ## Key Features
 //!
-//! - **Combinatorial splits**: Generates all C(n_groups, n_test_groups) possible splits
+//! - **Combinatorial splits**: Generates all `C(n_groups`, `n_test_groups`) possible splits
 //! - **Purging**: Removes data around train/test boundaries to avoid lookahead bias
 //! - **Embargo**: Applies an embargo period after each test set to prevent leakage
 //! - **Unbiased estimation**: Computes performance across all combinations
@@ -153,7 +153,7 @@ impl CPCVValidator {
         Ok(Self { config })
     }
 
-    /// Return the number of combinatorial splits: C(n_groups, n_test_groups).
+    /// Return the number of combinatorial splits: `C(n_groups`, `n_test_groups`).
     ///
     /// This is the total number of distinct ways to choose `n_test_groups` groups
     /// from `n_groups` groups.
@@ -164,7 +164,7 @@ impl CPCVValidator {
     /// Generate all combinatorial purged cross-validation splits.
     ///
     /// Partitions `n_samples` data points into `n_groups` contiguous groups,
-    /// then generates all C(n_groups, n_test_groups) possible train/test splits.
+    /// then generates all `C(n_groups`, `n_test_groups`) possible train/test splits.
     /// For each split, purging and embargo are applied to remove data points
     /// near train/test boundaries.
     ///
@@ -360,7 +360,7 @@ impl CPCVValidator {
     }
 
     /// Get a reference to the current configuration.
-    pub fn config(&self) -> &CPCVConfig {
+    pub const fn config(&self) -> &CPCVConfig {
         &self.config
     }
 }
diff --git a/crates/ml-data-validation/src/fdr.rs b/crates/ml-data-validation/src/fdr.rs
index 929eb112a..78e751204 100644
--- a/crates/ml-data-validation/src/fdr.rs
+++ b/crates/ml-data-validation/src/fdr.rs
@@ -143,7 +143,7 @@ impl FDRCorrector {
     /// # Arguments
     ///
     /// * `config` -- FDR configuration specifying alpha and method.
-    pub fn new(config: FDRConfig) -> Self {
+    pub const fn new(config: FDRConfig) -> Self {
         Self { config }
     }
 
diff --git a/crates/ml-data-validation/src/rules.rs b/crates/ml-data-validation/src/rules.rs
index e12a6d77b..c157ccb82 100644
--- a/crates/ml-data-validation/src/rules.rs
+++ b/crates/ml-data-validation/src/rules.rs
@@ -52,7 +52,7 @@ impl ValidationError {
     }
 
     /// Set bar index
-    pub fn at_index(mut self, index: usize) -> Self {
+    pub const fn at_index(mut self, index: usize) -> Self {
         self.bar_index = Some(index);
         self
     }
@@ -88,8 +88,14 @@ pub trait ValidationRule: Send + Sync {
 #[derive(Debug)]
 pub struct IntegrityRule;
 
+impl Default for IntegrityRule {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl IntegrityRule {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 }
@@ -190,7 +196,7 @@ pub struct ContinuityRule {
 }
 
 impl ContinuityRule {
-    pub fn new(threshold: f64) -> Self {
+    pub const fn new(threshold: f64) -> Self {
         Self { threshold }
     }
 }
@@ -243,8 +249,14 @@ impl ValidationRule for ContinuityRule {
 #[derive(Debug)]
 pub struct IndicatorRule;
 
+impl Default for IndicatorRule {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl IndicatorRule {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 }
@@ -277,7 +289,7 @@ impl ValidationRule for IndicatorRule {
                     )
                     .at_index(i),
                 );
-            } else if rsi < 0.0 || rsi > 100.0 {
+            } else if !(0.0..=100.0).contains(&rsi) {
                 errors.push(
                     ValidationError::error(
                         "indicator",
@@ -376,7 +388,7 @@ pub struct TimestampRule {
 }
 
 impl TimestampRule {
-    pub fn new(expected_interval_secs: i64) -> Self {
+    pub const fn new(expected_interval_secs: i64) -> Self {
         Self {
             expected_interval_secs,
         }
@@ -444,7 +456,7 @@ pub struct CompletenessRule {
 }
 
 impl CompletenessRule {
-    pub fn new(expected_interval_secs: i64, min_completeness_ratio: f64) -> Self {
+    pub const fn new(expected_interval_secs: i64, min_completeness_ratio: f64) -> Self {
         Self {
             expected_interval_secs,
             min_completeness_ratio,
@@ -484,7 +496,7 @@ impl ValidationRule for CompletenessRule {
             errors.push(ValidationError::error(
                 "completeness",
                 format!(
-                    "Data completeness: {:.1}% (expected: ≥{:.1}%) - {}/{} bars present",
+                    "Data completeness: {:.1}% (expected: \u{2265}{:.1}%) - {}/{} bars present",
                     completeness_ratio * 100.0,
                     self.min_completeness_ratio * 100.0,
                     actual_bars,
diff --git a/crates/ml-data-validation/src/validator.rs b/crates/ml-data-validation/src/validator.rs
index cfaad5e8e..227337a88 100644
--- a/crates/ml-data-validation/src/validator.rs
+++ b/crates/ml-data-validation/src/validator.rs
@@ -40,7 +40,7 @@ impl ValidationResult {
     }
 
     /// Check if validation passed (no errors)
-    pub fn is_valid(&self) -> bool {
+    pub const fn is_valid(&self) -> bool {
         self.valid
     }
 
@@ -67,25 +67,25 @@ impl ValidationResult {
     pub fn generate_report(&self) -> String {
         let mut report = String::new();
 
-        report.push_str("═══════════════════════════════════════════════════════════\n");
+        report.push_str("\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\n");
         report.push_str("                 DATA VALIDATION REPORT\n");
-        report.push_str("═══════════════════════════════════════════════════════════\n\n");
+        report.push_str("\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\n\n");
 
         // Overall status
         if self.is_valid() {
-            report.push_str("✅ Status: PASS\n");
+            report.push_str("\u{2705} Status: PASS\n");
         } else {
-            report.push_str("❌ Status: FAIL\n");
+            report.push_str("\u{274c} Status: FAIL\n");
         }
 
-        _ = writeln!(report, "📊 Total bars validated: {}", self.total_bars);
-        _ = writeln!(report, "🔴 Errors: {}", self.error_count());
-        _ = writeln!(report, "🟡 Warnings: {}\n", self.warning_count());
+        _ = writeln!(report, "\u{1f4ca} Total bars validated: {}", self.total_bars);
+        _ = writeln!(report, "\u{1f534} Errors: {}", self.error_count());
+        _ = writeln!(report, "\u{1f7e1} Warnings: {}\n", self.warning_count());
 
         // Errors section
         if !self.errors.is_empty() {
-            report.push_str("🔴 ERRORS:\n");
-            report.push_str("───────────────────────────────────────────────────────────\n");
+            report.push_str("\u{1f534} ERRORS:\n");
+            report.push_str("\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\n");
 
             // Group errors by category
             let mut categories = std::collections::HashMap::new();
@@ -110,13 +110,13 @@ impl ValidationResult {
                     _ = writeln!(report, "    ... and {} more", errors.len() - 5);
                 }
             }
-            report.push_str("\n");
+            report.push('\n');
         }
 
         // Warnings section
         if !self.warnings.is_empty() {
-            report.push_str("🟡 WARNINGS:\n");
-            report.push_str("───────────────────────────────────────────────────────────\n");
+            report.push_str("\u{1f7e1} WARNINGS:\n");
+            report.push_str("\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\n");
 
             // Group warnings by category
             let mut categories = std::collections::HashMap::new();
@@ -146,10 +146,10 @@ impl ValidationResult {
                     _ = writeln!(report, "    ... and {} more", warnings.len() - 3);
                 }
             }
-            report.push_str("\n");
+            report.push('\n');
         }
 
-        report.push_str("═══════════════════════════════════════════════════════════\n");
+        report.push_str("\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\u{2550}\n");
 
         report
     }
@@ -228,7 +228,7 @@ impl DataValidator {
     }
 
     /// Enable metrics tracking
-    pub fn with_metrics_enabled(mut self, enabled: bool) -> Self {
+    pub const fn with_metrics_enabled(mut self, enabled: bool) -> Self {
         self.metrics_enabled = enabled;
         self
     }
diff --git a/crates/ml-ensemble/src/coordinator.rs b/crates/ml-ensemble/src/coordinator.rs
index 63159e7f3..69bdf8315 100644
--- a/crates/ml-ensemble/src/coordinator.rs
+++ b/crates/ml-ensemble/src/coordinator.rs
@@ -461,7 +461,7 @@ impl ModelRegistry {
         if let Some(shadow_path) = self.shadow.remove(model_id) {
             let old_path = self
                 .active
-                .insert(model_id.to_string(), shadow_path.clone());
+                .insert(model_id.to_string(), shadow_path);
 
             if let Some(old) = old_path {
                 // Move old to shadow for potential rollback
diff --git a/crates/ml-ensemble/src/coordinator_extended.rs b/crates/ml-ensemble/src/coordinator_extended.rs
index 2be008b0a..909ce9697 100644
--- a/crates/ml-ensemble/src/coordinator_extended.rs
+++ b/crates/ml-ensemble/src/coordinator_extended.rs
@@ -87,7 +87,7 @@ impl DiversityAnalyzer {
             let history = self
                 .prediction_history
                 .entry(pred.model_id.clone())
-                .or_insert_with(Vec::new);
+                .or_default();
 
             history.push(pred.value);
 
@@ -300,7 +300,7 @@ impl PerformanceTracker {
         let returns = self
             .model_returns
             .entry(model_id.to_string())
-            .or_insert_with(Vec::new);
+            .or_default();
 
         returns.push(return_value);
 
diff --git a/crates/ml-ensemble/src/training_integration.rs b/crates/ml-ensemble/src/training_integration.rs
index f34143f1b..b820abd77 100644
--- a/crates/ml-ensemble/src/training_integration.rs
+++ b/crates/ml-ensemble/src/training_integration.rs
@@ -211,9 +211,9 @@ impl EnsembleTrainingIntegration {
             / predictions.len() as f64;
 
         // Normalize to [0, 1] range (assuming predictions in [-1, 1])
-        let diversity = (variance.sqrt() / 2.0).min(1.0);
+        
 
-        diversity
+        (variance.sqrt() / 2.0).min(1.0)
     }
 
     /// Validate ensemble is ready for production inference
diff --git a/crates/ml-ensemble/src/voting.rs b/crates/ml-ensemble/src/voting.rs
index 81e1f7c30..d79e935be 100644
--- a/crates/ml-ensemble/src/voting.rs
+++ b/crates/ml-ensemble/src/voting.rs
@@ -12,7 +12,9 @@ use crate::MLError;
 
 /// Voting strategy for ensemble aggregation
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default)]
 pub enum VotingStrategy {
+    #[default]
     WeightedAverage,
     ConfidenceWeighted,
     Adaptive,
@@ -20,11 +22,6 @@ pub enum VotingStrategy {
     MajorityVote,
 }
 
-impl Default for VotingStrategy {
-    fn default() -> Self {
-        VotingStrategy::WeightedAverage
-    }
-}
 
 /// Voting configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/ml-ensemble/src/weights.rs b/crates/ml-ensemble/src/weights.rs
index 9f07f4afb..4f0de4a30 100644
--- a/crates/ml-ensemble/src/weights.rs
+++ b/crates/ml-ensemble/src/weights.rs
@@ -41,17 +41,11 @@ impl ModelWeights {
 }
 
 #[derive(Debug)]
+#[derive(Default)]
 pub struct WeightConfig {
     pub regime_adaptation: bool,
 }
 
-impl Default for WeightConfig {
-    fn default() -> Self {
-        Self {
-            regime_adaptation: false,
-        }
-    }
-}
 
 #[derive(Debug)]
 pub struct DynamicWeightManager {
diff --git a/crates/ml-explainability/src/integrated_gradients.rs b/crates/ml-explainability/src/integrated_gradients.rs
index 7c821f01d..f5aed0bc6 100644
--- a/crates/ml-explainability/src/integrated_gradients.rs
+++ b/crates/ml-explainability/src/integrated_gradients.rs
@@ -121,7 +121,7 @@ impl IntegratedGradients {
 
             // Accumulate
             accumulated_grads = Some(match accumulated_grads {
-                Some(acc) => acc.add(&grad)?,
+                Some(acc) => acc.add(grad)?,
                 None => grad.clone(),
             });
         }
diff --git a/crates/ml-features/src/adx_features.rs b/crates/ml-features/src/adx_features.rs
index e3905e3eb..2b81d7100 100644
--- a/crates/ml-features/src/adx_features.rs
+++ b/crates/ml-features/src/adx_features.rs
@@ -16,31 +16,31 @@
 //!
 //! ## Algorithm: Wilder's 14-Period ADX
 //! 1. **True Range (TR)**:
-//!    TR = max(high - low, |high - prev_close|, |low - prev_close|)
+//!    TR = max(high - low, |high - `prev_close`|, |low - `prev_close`|)
 //!
 //! 2. **Directional Movement (+DM, -DM)**:
-//!    +DM = max(0, high - prev_high) if up_move > down_move
-//!    -DM = max(0, prev_low - low) if down_move > up_move
+//!    +DM = max(0, high - `prev_high`) if `up_move` > `down_move`
+//!    -DM = max(0, `prev_low` - low) if `down_move` > `up_move`
 //!
 //! 3. **Wilder's Smoothing** (exponential moving average with α = 1/14):
 //!    First 14 bars: simple sum
 //!    Bar 14: smoothed = sum / 14
-//!    Bar 15+: smoothed = (smoothed_prev × 13 + new_value) / 14
+//!    Bar 15+: smoothed = (`smoothed_prev` × 13 + `new_value`) / 14
 //!
 //! 4. **Directional Indicators**:
-//!    +DI = (smoothed_+DM / smoothed_TR) × 100
-//!    -DI = (smoothed_-DM / smoothed_TR) × 100
+//!    +DI = (smoothed_+DM / `smoothed_TR`) × 100
+//!    -DI = (smoothed_-DM / `smoothed_TR`) × 100
 //!
 //! 5. **DX (Directional Movement Index)**:
 //!    DX = (|+DI - -DI| / (+DI + -DI)) × 100
 //!
 //! 6. **ADX (Average of DX)**:
 //!    First 28 bars: simple average of DX
-//!    Bar 29+: ADX = (ADX_prev × 13 + DX) / 14
+//!    Bar 29+: ADX = (`ADX_prev` × 13 + DX) / 14
 //!
 //! ## References
 //! - Wilder, J. Wells (1978). "New Concepts in Technical Trading Systems"
-//! - WAVE_19_COMPREHENSIVE_FEATURE_ENGINEERING_PLAN.md
+//! - `WAVE_19_COMPREHENSIVE_FEATURE_ENGINEERING_PLAN.md`
 //! - ml/src/regime/trending.rs (ADX implementation reference)
 
 use std::collections::VecDeque;
@@ -144,7 +144,7 @@ impl AdxFeatureExtractor {
     pub fn update(&mut self, bar: &OHLCVBar) -> [f64; 5] {
         // Bar 0: Initialize with first bar
         if self.prev_bar.is_none() {
-            self.prev_bar = Some(bar.clone());
+            self.prev_bar = Some(*bar);
             self.bar_count = 1;
             return [0.0; 5];
         }
@@ -180,7 +180,7 @@ impl AdxFeatureExtractor {
         }
 
         self.bar_count += 1;
-        self.prev_bar = Some(bar.clone());
+        self.prev_bar = Some(*bar);
 
         // Return zeros until we have enough data for DI calculation
         if self.bar_count < self.period + 1 {
@@ -270,12 +270,12 @@ impl AdxFeatureExtractor {
     }
 
     /// Get current bar count (useful for checking initialization status)
-    pub fn bar_count(&self) -> usize {
+    pub const fn bar_count(&self) -> usize {
         self.bar_count
     }
 
     /// Check if ADX is fully initialized (requires 2 × period bars)
-    pub fn is_initialized(&self) -> bool {
+    pub const fn is_initialized(&self) -> bool {
         self.bar_count >= 2 * self.period
     }
 }
@@ -290,7 +290,7 @@ impl Default for AdxFeatureExtractor {
 
 /// Calculate True Range (TR)
 ///
-/// TR = max(high - low, |high - prev_close|, |low - prev_close|)
+/// TR = max(high - low, |high - `prev_close`|, |low - `prev_close`|)
 #[inline]
 fn calculate_true_range(bar: &OHLCVBar, prev: &OHLCVBar) -> f64 {
     let hl = bar.high - bar.low;
@@ -303,10 +303,10 @@ fn calculate_true_range(bar: &OHLCVBar, prev: &OHLCVBar) -> f64 {
 /// Calculate Directional Movement (+DM, -DM)
 ///
 /// Rules:
-/// - If (high - prev_high) > (prev_low - low) AND (high - prev_high) > 0:
-///   +DM = high - prev_high, -DM = 0
-/// - Else if (prev_low - low) > (high - prev_high) AND (prev_low - low) > 0:
-///   +DM = 0, -DM = prev_low - low
+/// - If (high - `prev_high`) > (`prev_low` - low) AND (high - `prev_high`) > 0:
+///   +DM = high - `prev_high`, -DM = 0
+/// - Else if (`prev_low` - low) > (high - `prev_high`) AND (`prev_low` - low) > 0:
+///   +DM = 0, -DM = `prev_low` - low
 /// - Else:
 ///   +DM = 0, -DM = 0
 #[inline]
@@ -331,7 +331,7 @@ fn calculate_directional_movement(bar: &OHLCVBar, prev: &OHLCVBar) -> (f64, f64)
 
 /// Apply Wilder's smoothing formula
 ///
-/// smoothed_new = (smoothed_old × (period - 1) + new_value) / period
+/// `smoothed_new` = (`smoothed_old` × (period - 1) + `new_value`) / period
 #[inline]
 fn wilder_smooth(smoothed: f64, new_value: f64, period: usize) -> f64 {
     (smoothed * (period - 1) as f64 + new_value) / period as f64
@@ -339,8 +339,8 @@ fn wilder_smooth(smoothed: f64, new_value: f64, period: usize) -> f64 {
 
 /// Calculate Directional Indicators (+DI, -DI)
 ///
-/// +DI = (smoothed_+DM / smoothed_TR) × 100
-/// -DI = (smoothed_-DM / smoothed_TR) × 100
+/// +DI = (smoothed_+DM / `smoothed_TR`) × 100
+/// -DI = (smoothed_-DM / `smoothed_TR`) × 100
 #[inline]
 fn calculate_directional_indicators(
     smoothed_plus_dm: f64,
@@ -394,7 +394,7 @@ fn classify_trend_strength(adx: f64) -> f64 {
 
 /// Safe clipping: Clip value to [min, max] range, handles NaN/Inf
 #[inline]
-fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
+const fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
     if !value.is_finite() {
         return 0.0;
     }
diff --git a/crates/ml-features/src/alternative_bars.rs b/crates/ml-features/src/alternative_bars.rs
index 8dccc61dc..d6fa7628b 100644
--- a/crates/ml-features/src/alternative_bars.rs
+++ b/crates/ml-features/src/alternative_bars.rs
@@ -127,17 +127,17 @@ impl TickBarSampler {
     }
 
     /// Get the tick threshold
-    pub fn threshold(&self) -> usize {
+    pub const fn threshold(&self) -> usize {
         self.threshold
     }
 
     /// Get the current tick count (0 to threshold-1)
-    pub fn tick_count(&self) -> usize {
+    pub const fn tick_count(&self) -> usize {
         self.tick_count
     }
 
     /// Reset the sampler state for a new bar
-    fn reset(&mut self) {
+    const fn reset(&mut self) {
         self.tick_count = 0;
         self.first_timestamp = None;
         self.current_open = None;
@@ -207,15 +207,15 @@ impl VolumeBarSampler {
         })
     }
 
-    pub fn threshold(&self) -> u64 {
+    pub const fn threshold(&self) -> u64 {
         self.threshold
     }
 
-    pub fn cumulative_volume(&self) -> u64 {
+    pub const fn cumulative_volume(&self) -> u64 {
         self.cumulative_volume
     }
 
-    fn reset(&mut self) {
+    const fn reset(&mut self) {
         self.cumulative_volume = 0;
         self.first_timestamp = None;
         self.current_open = None;
@@ -278,7 +278,7 @@ impl DollarBarSampler {
     }
 
     /// Get current threshold (for test compatibility)
-    pub fn get_threshold(&self) -> f64 {
+    pub const fn get_threshold(&self) -> f64 {
         self.threshold
     }
 
@@ -331,20 +331,20 @@ impl DollarBarSampler {
         })
     }
 
-    pub fn threshold(&self) -> f64 {
+    pub const fn threshold(&self) -> f64 {
         self.threshold
     }
 
-    pub fn cumulative_dollar(&self) -> f64 {
+    pub const fn cumulative_dollar(&self) -> f64 {
         self.cumulative_dollar
     }
 
     /// Get accumulated dollar volume (test compatibility alias)
-    pub fn get_accumulated(&self) -> f64 {
+    pub const fn get_accumulated(&self) -> f64 {
         self.cumulative_dollar
     }
 
-    fn reset(&mut self) {
+    const fn reset(&mut self) {
         self.cumulative_dollar = 0.0;
         self.first_timestamp = None;
         self.current_open = None;
@@ -473,7 +473,7 @@ impl ImbalanceBarSampler {
     /// # Tick Classification
     /// - Buy tick: `price > previous_price` → direction = +1
     /// - Sell tick: `price < previous_price` → direction = -1
-    /// - Unchanged: `price == previous_price` → use last_direction (MLFinLab convention)
+    /// - Unchanged: `price == previous_price` → use `last_direction` (`MLFinLab` convention)
     pub fn update(
         &mut self,
         price: f64,
@@ -545,17 +545,17 @@ impl ImbalanceBarSampler {
     }
 
     /// Get current cumulative imbalance
-    pub fn get_imbalance(&self) -> f64 {
+    pub const fn get_imbalance(&self) -> f64 {
         self.cumulative_imbalance
     }
 
     /// Get current threshold
-    pub fn get_threshold(&self) -> f64 {
+    pub const fn get_threshold(&self) -> f64 {
         self.threshold
     }
 
     /// Reset the sampler state for a new bar
-    fn reset(&mut self) {
+    const fn reset(&mut self) {
         self.cumulative_imbalance = 0.0;
         self.first_timestamp = None;
         self.current_open = None;
@@ -651,7 +651,7 @@ impl RunBarSampler {
     /// - Buy tick: `price > previous_price` → direction = +1
     /// - Sell tick: `price < previous_price` → direction = -1
     /// - Unchanged: `price == previous_price` → no direction (run continues)
-    /// - Direction change: Resets run_count to 1
+    /// - Direction change: Resets `run_count` to 1
     pub fn update(
         &mut self,
         price: f64,
@@ -760,22 +760,22 @@ impl RunBarSampler {
     }
 
     /// Get the run threshold
-    pub fn threshold(&self) -> usize {
+    pub const fn threshold(&self) -> usize {
         self.threshold
     }
 
     /// Get the current run count
-    pub fn run_count(&self) -> usize {
+    pub const fn run_count(&self) -> usize {
         self.run_count
     }
 
     /// Get the current direction (-1 for sell, 0 for neutral, +1 for buy)
-    pub fn direction(&self) -> i8 {
+    pub const fn direction(&self) -> i8 {
         self.current_direction
     }
 
     /// Reset the sampler state for a new bar
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.run_count = 0;
         self.current_direction = 0;
         self.first_timestamp = None;
diff --git a/crates/ml-features/src/barrier_optimization.rs b/crates/ml-features/src/barrier_optimization.rs
index ed7dfc87a..b3d1a0f67 100644
--- a/crates/ml-features/src/barrier_optimization.rs
+++ b/crates/ml-features/src/barrier_optimization.rs
@@ -100,7 +100,7 @@ impl BarrierOptimizer {
     }
 
     /// Create optimizer with custom search ranges
-    pub fn with_ranges(
+    pub const fn with_ranges(
         profit_range: Vec<f64>,
         stop_range: Vec<f64>,
         horizon_range: Vec<usize>,
@@ -211,9 +211,9 @@ impl BarrierOptimizer {
     /// Simulate triple barrier trading strategy
     ///
     /// For each entry point, we:
-    /// 1. Calculate profit target: entry * (1 + profit_factor * volatility)
-    /// 2. Calculate stop loss: entry * (1 - stop_factor * volatility)
-    /// 3. Hold for up to time_horizon periods
+    /// 1. Calculate profit target: entry * (1 + `profit_factor` * volatility)
+    /// 2. Calculate stop loss: entry * (1 - `stop_factor` * volatility)
+    /// 3. Hold for up to `time_horizon` periods
     /// 4. Exit when price hits barrier or horizon reached
     fn simulate_triple_barrier_trading(&self, params: &BarrierParams, prices: &[f64]) -> Vec<f64> {
         // Preallocate capacity: estimate max trades as prices.len() / time_horizon
@@ -309,8 +309,8 @@ impl BarrierOptimizer {
 
     /// Calculate Sharpe ratio from returns
     ///
-    /// Sharpe = (mean_return - risk_free_rate) / std_dev_return
-    /// Assuming risk_free_rate = 0 for simplicity
+    /// Sharpe = (`mean_return` - `risk_free_rate`) / `std_dev_return`
+    /// Assuming `risk_free_rate` = 0 for simplicity
     pub fn calculate_sharpe(&self, returns: &[f64]) -> f64 {
         if returns.is_empty() {
             return 0.0;
diff --git a/crates/ml-features/src/config.rs b/crates/ml-features/src/config.rs
index 36b6c7c93..13fccbc39 100644
--- a/crates/ml-features/src/config.rs
+++ b/crates/ml-features/src/config.rs
@@ -8,8 +8,8 @@
 //!
 //! ## Architecture
 //!
-//! FeatureConfig provides a single source of truth for feature extraction
-//! across both training (DbnSequenceLoader) and inference (ProductionFeatureExtractorAdapter).
+//! `FeatureConfig` provides a single source of truth for feature extraction
+//! across both training (`DbnSequenceLoader`) and inference (`ProductionFeatureExtractorAdapter`).
 //! This eliminates the previous padding bug (256 features via 25x repetition).
 //!
 //! ## Usage
@@ -209,7 +209,7 @@ pub fn wave_d_features() -> Vec<Feature> {
 /// Feature extraction configuration for Wave 19 progressive engineering
 ///
 /// Tracks which feature groups are enabled across Wave A/B/C/D phases.
-/// Used by both training (DbnSequenceLoader) and inference (ProductionFeatureExtractorAdapter).
+/// Used by both training (`DbnSequenceLoader`) and inference (`ProductionFeatureExtractorAdapter`).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FeatureConfig {
     /// Feature engineering phase (Wave A/B/C/D)
@@ -277,8 +277,8 @@ impl FeatureConfig {
     /// Total: 26 features
     ///
     /// Note: Microstructure features (Amihud, Roll, Corwin-Schultz) exist in ml crate
-    /// but are not yet integrated into common/ml_strategy.rs 26-feature system.
-    pub fn wave_a() -> Self {
+    /// but are not yet integrated into `common/ml_strategy.rs` 26-feature system.
+    pub const fn wave_a() -> Self {
         Self {
             phase: FeaturePhase::WaveA,
             enable_ohlcv: true,
@@ -298,7 +298,7 @@ impl FeatureConfig {
     /// - Wave A: 26 features (OHLCV + technical indicators)
     /// - Alternative bars: 10 features (dollar, volume, tick, run, imbalance bars)
     /// Total: 36 features
-    pub fn wave_b() -> Self {
+    pub const fn wave_b() -> Self {
         Self {
             phase: FeaturePhase::WaveB,
             enable_ohlcv: true,
@@ -318,7 +318,7 @@ impl FeatureConfig {
     /// - Base: 39 features (OHLCV 5 + Technical 21 + Microstructure 3 + Alternative bars 10)
     /// - Wave C additions: 162 features (fractional differentiation, regime detection, statistical features)
     /// Total: 201 features (indices 0-200)
-    pub fn wave_c() -> Self {
+    pub const fn wave_c() -> Self {
         Self {
             phase: FeaturePhase::WaveC,
             enable_ohlcv: true,
@@ -342,7 +342,7 @@ impl FeatureConfig {
     ///   - Regime Transition Probabilities: 5 features (indices 216-220)
     ///   - Adaptive Strategy Metrics: 4 features (indices 221-224)
     /// Total: 225 features (indices 0-224)
-    pub fn wave_d() -> Self {
+    pub const fn wave_d() -> Self {
         Self {
             phase: FeaturePhase::WaveD,
             enable_ohlcv: true,
@@ -360,7 +360,7 @@ impl FeatureConfig {
     ///
     /// Returns the total number of features that will be extracted
     /// based on the current configuration.
-    pub fn feature_count(&self) -> usize {
+    pub const fn feature_count(&self) -> usize {
         let mut count = 0;
 
         if self.enable_ohlcv {
@@ -404,7 +404,7 @@ impl FeatureConfig {
 
     /// Get feature indices for each group
     ///
-    /// Returns (start_idx, end_idx) for each enabled feature group.
+    /// Returns (`start_idx`, `end_idx`) for each enabled feature group.
     /// This allows data loaders to know which indices correspond to which features.
     pub fn feature_indices(&self) -> FeatureIndices {
         let mut indices = FeatureIndices::default();
@@ -448,7 +448,7 @@ impl FeatureConfig {
     }
 
     /// Check if a specific feature group is enabled
-    pub fn is_enabled(&self, group: FeatureGroup) -> bool {
+    pub const fn is_enabled(&self, group: FeatureGroup) -> bool {
         match group {
             FeatureGroup::OHLCV => self.enable_ohlcv,
             FeatureGroup::TechnicalIndicators => self.enable_technical_indicators,
@@ -498,7 +498,7 @@ pub enum FeatureGroup {
 
 /// Feature index ranges for each group
 ///
-/// Provides (start_idx, end_idx) for each feature group to allow
+/// Provides (`start_idx`, `end_idx`) for each feature group to allow
 /// data loaders and models to identify which indices correspond to which features.
 #[derive(Debug, Clone, Default)]
 pub struct FeatureIndices {
diff --git a/crates/ml-features/src/ewma.rs b/crates/ml-features/src/ewma.rs
index f21db9ae3..21511413d 100644
--- a/crates/ml-features/src/ewma.rs
+++ b/crates/ml-features/src/ewma.rs
@@ -5,7 +5,7 @@
 //!
 //! # Formula
 //!
-//! EWMA_t = α * value_t + (1 - α) * EWMA_{t-1}
+//! `EWMA_t` = α * `value_t` + (1 - α) * EWMA_{t-1}
 //!
 //! where α = 2 / (span + 1)
 //!
@@ -99,7 +99,7 @@ impl EWMACalculator {
     /// # Formula
     ///
     /// First update: EWMA = value (initialization)
-    /// Subsequent updates: EWMA = α * value + (1 - α) * EWMA_prev
+    /// Subsequent updates: EWMA = α * value + (1 - α) * `EWMA_prev`
     ///
     /// # Examples
     ///
@@ -136,7 +136,7 @@ impl EWMACalculator {
     /// calculator.update(100.0);
     /// assert!(calculator.current().is_some());  // Initialized
     /// ```
-    pub fn current(&self) -> Option<f64> {
+    pub const fn current(&self) -> Option<f64> {
         self.ewma
     }
 
@@ -145,7 +145,7 @@ impl EWMACalculator {
     /// # Returns
     ///
     /// Number of periods for EWMA calculation
-    pub fn span(&self) -> usize {
+    pub const fn span(&self) -> usize {
         self.span
     }
 
@@ -154,7 +154,7 @@ impl EWMACalculator {
     /// # Returns
     ///
     /// Smoothing factor: α = 2 / (span + 1)
-    pub fn alpha(&self) -> f64 {
+    pub const fn alpha(&self) -> f64 {
         self.alpha
     }
 
@@ -172,7 +172,7 @@ impl EWMACalculator {
     /// calculator.reset();
     /// assert!(calculator.current().is_none());
     /// ```
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.ewma = None;
     }
 
@@ -181,7 +181,7 @@ impl EWMACalculator {
     /// # Returns
     ///
     /// true if at least one value has been added, false otherwise
-    pub fn is_initialized(&self) -> bool {
+    pub const fn is_initialized(&self) -> bool {
         self.ewma.is_some()
     }
 }
@@ -226,7 +226,7 @@ impl AdaptiveThreshold {
         }
     }
 
-    /// Update threshold with new value and return (lower_bound, upper_bound)
+    /// Update threshold with new value and return (`lower_bound`, `upper_bound`)
     ///
     /// # Arguments
     ///
@@ -234,7 +234,7 @@ impl AdaptiveThreshold {
     ///
     /// # Returns
     ///
-    /// Tuple of (lower_bound, upper_bound) for adaptive threshold.
+    /// Tuple of (`lower_bound`, `upper_bound`) for adaptive threshold.
     /// Returns (value, value) if not initialized.
     ///
     /// # Examples
@@ -261,7 +261,7 @@ impl AdaptiveThreshold {
     }
 
     /// Get current mean (EWMA)
-    pub fn mean(&self) -> Option<f64> {
+    pub const fn mean(&self) -> Option<f64> {
         self.ewma.current()
     }
 
@@ -271,7 +271,7 @@ impl AdaptiveThreshold {
     }
 
     /// Reset threshold to uninitialized state
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.ewma.reset();
         self.variance_ewma.reset();
     }
diff --git a/crates/ml-features/src/feature_extraction.rs b/crates/ml-features/src/feature_extraction.rs
index d745b2f86..af3b34c19 100644
--- a/crates/ml-features/src/feature_extraction.rs
+++ b/crates/ml-features/src/feature_extraction.rs
@@ -299,7 +299,7 @@ pub fn extract_ml_features(bars: &[OHLCVBar]) -> Result<Vec<Vec<f32>>, MLError>
 
 /// Compute ATR (Average True Range) for a slice of bars
 ///
-/// This is a public helper function for other modules (e.g., regime_adaptive.rs)
+/// This is a public helper function for other modules (e.g., `regime_adaptive.rs`)
 /// that need ATR calculation.
 ///
 /// ## Arguments
diff --git a/crates/ml-features/src/mbp10_loader.rs b/crates/ml-features/src/mbp10_loader.rs
index 53c63ea27..9b2b30824 100644
--- a/crates/ml-features/src/mbp10_loader.rs
+++ b/crates/ml-features/src/mbp10_loader.rs
@@ -139,7 +139,7 @@ pub fn compute_ofi_with_trades(
         }
         Err(e) => {
             tracing::warn!(
-                "Failed to load trades from {}: {} — falling back to MBP-10 only",
+                "Failed to load trades from {}: {} \u{2014} falling back to MBP-10 only",
                 trades_file.display(),
                 e
             );
@@ -287,7 +287,7 @@ where
             match result {
                 Ok(features) => {
                     tracing::info!(
-                        "  {} → {} OFI features",
+                        "  {} \u{2192} {} OFI features",
                         file.file_name().unwrap_or_default().to_string_lossy(),
                         features.len()
                     );
@@ -339,13 +339,13 @@ where
 /// # Returns
 ///
 /// Slice of up to `window_size` snapshots starting from the first snapshot
-/// with timestamp >= target_ts. Returns empty slice if no snapshots exist
+/// with timestamp >= `target_ts`. Returns empty slice if no snapshots exist
 /// at or after the target timestamp.
 ///
 /// # Algorithm
 ///
 /// - Simple linear search (TODO: optimize with binary search for large datasets)
-/// - Returns snapshots starting from the first one with timestamp >= target_ts
+/// - Returns snapshots starting from the first one with timestamp >= `target_ts`
 ///
 /// # Example
 ///
diff --git a/crates/ml-features/src/microstructure.rs b/crates/ml-features/src/microstructure.rs
index c540537d3..e94168632 100644
--- a/crates/ml-features/src/microstructure.rs
+++ b/crates/ml-features/src/microstructure.rs
@@ -18,7 +18,7 @@
 //! - Amihud (2002): "Illiquidity and Stock Returns"
 //! - Roll (1984): "A Simple Implicit Measure of the Effective Bid-Ask Spread"
 //! - Corwin & Schultz (2012): "A Simple Way to Estimate Bid-Ask Spreads"
-//! - Hudson & Thames MLFinLab: Research-backed implementations
+//! - Hudson & Thames `MLFinLab`: Research-backed implementations
 
 /// Trait for microstructure features with normalization for ML models
 pub trait MicrostructureFeatures {
@@ -47,8 +47,8 @@ pub trait MicrostructureFeatures {
 /// ```
 ///
 /// Where:
-/// - `return_t` = (price_t - price_{t-1}) / price_{t-1}
-/// - `dollar_volume_t` = price_t * volume_t
+/// - `return_t` = (`price_t` - price_{t-1}) / price_{t-1}
+/// - `dollar_volume_t` = `price_t` * `volume_t`
 ///
 /// ## Interpretation
 /// - **High illiquidity** (>1e-6): Large price impact per dollar traded (illiquid market)
@@ -176,22 +176,22 @@ impl AmihudIlliquidity {
     }
 
     /// Returns the current illiquidity value (alias for compute for compatibility)
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.ema_illiq
     }
 
     /// Returns the EMA smoothing factor
-    pub fn alpha(&self) -> f64 {
+    pub const fn alpha(&self) -> f64 {
         self.alpha
     }
 
     /// Returns the current EMA illiquidity value
-    pub fn ema_illiquidity(&self) -> f64 {
+    pub const fn ema_illiquidity(&self) -> f64 {
         self.ema_illiq
     }
 
     /// Returns the previous price used for return calculation
-    pub fn prev_price(&self) -> f64 {
+    pub const fn prev_price(&self) -> f64 {
         self.prev_price
     }
 }
@@ -241,8 +241,8 @@ impl MicrostructureFeatures for AmihudIlliquidity {
 /// ```
 ///
 /// Where:
-/// - Δp_t = p_t - p_{t-1} (price change at time t)
-/// - cov() = covariance between consecutive price changes
+/// - `Δp_t` = `p_t` - p_{t-1} (price change at time t)
+/// - `cov()` = covariance between consecutive price changes
 ///
 /// ## Intuition
 /// Bid-ask bounce creates negative serial correlation in transaction prices.
@@ -251,11 +251,11 @@ impl MicrostructureFeatures for AmihudIlliquidity {
 /// ## Implementation Details
 /// - Uses rolling window of 20 price changes for stability
 /// - Handles negative covariance (take sqrt of absolute value)
-/// - O(1) amortized update using VecDeque
+/// - O(1) amortized update using `VecDeque`
 /// - Returns 0.0 for insufficient data (<3 prices)
 ///
 /// ## Performance
-/// - Update: O(1) amortized (VecDeque push/pop)
+/// - Update: O(1) amortized (`VecDeque` push/pop)
 /// - Compute: O(n) where n=20 (window size)
 /// - Memory: 72 bytes (8B per price × 20 + overhead)
 /// - Latency: <2μs per update+compute
@@ -285,7 +285,7 @@ impl RollMeasure {
     /// - `price`: Transaction price (e.g., close price)
     ///
     /// ## Performance
-    /// - O(1) amortized (VecDeque push/pop)
+    /// - O(1) amortized (`VecDeque` push/pop)
     /// - <500ns typical latency
     pub fn update(&mut self, price: f64) {
         if !price.is_finite() {
@@ -307,7 +307,7 @@ impl RollMeasure {
     /// - Returns 0.0 if insufficient data (<3 prices)
     ///
     /// ## Performance
-    /// - O(n) where n=window_size (20)
+    /// - O(n) where `n=window_size` (20)
     /// - <2μs typical latency
     pub fn compute(&self) -> f64 {
         // Need at least 3 prices for 2 price changes
@@ -345,7 +345,7 @@ impl RollMeasure {
         spread.min(100.0)
     }
 
-    /// Compute serial covariance: cov(Δp_t, Δp_{t-1})
+    /// Compute serial covariance: `cov(Δp_t`, Δp_{t-1})
     ///
     /// ## Formula
     /// ```text
@@ -353,7 +353,7 @@ impl RollMeasure {
     /// ```
     ///
     /// ## Performance
-    /// - O(n) where n = length of price_changes
+    /// - O(n) where n = length of `price_changes`
     /// - <1μs for n=20
     fn compute_serial_covariance(&self, price_changes: &[f64]) -> f64 {
         if price_changes.len() < 2 {
@@ -544,7 +544,7 @@ impl CorwinSchultzSpread {
         let e_alpha = alpha.exp();
         let spread = 2.0 * (e_alpha - 1.0) / (1.0 + e_alpha);
 
-        (spread.is_finite() && spread >= 0.0).then(|| spread)
+        (spread.is_finite() && spread >= 0.0).then_some(spread)
     }
 }
 
diff --git a/crates/ml-features/src/microstructure_features.rs b/crates/ml-features/src/microstructure_features.rs
index 42188ccb4..f58b867da 100644
--- a/crates/ml-features/src/microstructure_features.rs
+++ b/crates/ml-features/src/microstructure_features.rs
@@ -1,6 +1,6 @@
 //! Wave C Microstructure Features for HFT ML Models
 //!
-//! This module implements 12 microstructure features from MLFinLab Chapter 19:
+//! This module implements 12 microstructure features from `MLFinLab` Chapter 19:
 //! - **Spread Estimators** (3): Roll, Corwin-Schultz, High-Low Spread
 //! - **Liquidity Metrics** (2): Amihud Illiquidity, Volume-Weighted Spread
 //! - **Trade Arrival** (2): Tick Count, Inter-Arrival Time
@@ -31,8 +31,8 @@
 //! - Data: OHLCV-only (no Level-2 order book required)
 //!
 //! ## References
-//! - MLFinLab Chapter 19: Market Microstructure Features
-//! - See WAVE_C_MICROSTRUCTURE_FEATURE_DESIGN.md for detailed specifications
+//! - `MLFinLab` Chapter 19: Market Microstructure Features
+//! - See `WAVE_C_MICROSTRUCTURE_FEATURE_DESIGN.md` for detailed specifications
 
 use std::collections::VecDeque;
 
@@ -113,7 +113,7 @@ impl HighLowSpread {
         self.ema_spread
     }
 
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.ema_spread
     }
 }
@@ -205,7 +205,7 @@ impl VolumeWeightedSpread {
         self.ema_spread
     }
 
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.ema_spread
     }
 }
@@ -304,7 +304,7 @@ impl TickCount {
         self.tick_count
     }
 
-    pub fn compute(&self) -> usize {
+    pub const fn compute(&self) -> usize {
         self.tick_count
     }
 }
@@ -494,7 +494,7 @@ impl BuySellImbalance {
         self.ema_imbalance
     }
 
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.ema_imbalance
     }
 }
@@ -627,7 +627,7 @@ impl KyleLambda {
         cov / var_s
     }
 
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.cached_lambda
     }
 }
@@ -748,7 +748,7 @@ impl PriceImpact {
         self.ema_impact
     }
 
-    pub fn compute(&self) -> f64 {
+    pub const fn compute(&self) -> f64 {
         self.ema_impact
     }
 }
diff --git a/crates/ml-features/src/normalization.rs b/crates/ml-features/src/normalization.rs
index 1fb17dbe7..df9811cfc 100644
--- a/crates/ml-features/src/normalization.rs
+++ b/crates/ml-features/src/normalization.rs
@@ -20,7 +20,7 @@
 //! - Online: No batch recomputation required
 //!
 //! ## Memory Optimization (Wave G)
-//! - Fixed-size ring buffers replace VecDeque (zero heap allocations)
+//! - Fixed-size ring buffers replace `VecDeque` (zero heap allocations)
 //! - Lazy buffer initialization (only allocate when first value arrives)
 //! - Projected savings: 49.4 KB → ~10 KB per symbol (80% reduction)
 //!
@@ -72,6 +72,12 @@ pub struct RingBuffer<T: Copy + Default, const N: usize> {
     len: usize,
 }
 
+impl<T: Copy + Default, const N: usize> Default for RingBuffer<T, N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T: Copy + Default, const N: usize> RingBuffer<T, N> {
     /// Create new empty ring buffer
     pub fn new() -> Self {
@@ -83,7 +89,7 @@ impl<T: Copy + Default, const N: usize> RingBuffer<T, N> {
     }
 
     /// Push value into ring buffer (overwrites oldest if full)
-    pub fn push(&mut self, value: T) {
+    pub const fn push(&mut self, value: T) {
         if N == 0 {
             return; // Zero-capacity buffer: cannot store any values
         }
@@ -95,12 +101,12 @@ impl<T: Copy + Default, const N: usize> RingBuffer<T, N> {
     }
 
     /// Get current number of elements
-    pub fn len(&self) -> usize {
+    pub const fn len(&self) -> usize {
         self.len
     }
 
     /// Check if buffer is empty
-    pub fn is_empty(&self) -> bool {
+    pub const fn is_empty(&self) -> bool {
         self.len == 0
     }
 
@@ -414,8 +420,8 @@ pub struct NormalizationStats {
 /// Buffer is lazily initialized only when first value arrives.
 ///
 /// ## Memory Optimization
-/// - OLD: VecDeque with capacity=window_size → heap allocation
-/// - NEW: Option<RingBuffer<f64, 100>> → None until first value
+/// - OLD: `VecDeque` with `capacity=window_size` → heap allocation
+/// - NEW: Option<`RingBuffer`<f64, 100>> → None until first value
 /// - Savings: 800 bytes per normalizer (100 × 8 bytes)
 #[derive(Debug)]
 pub struct RollingZScore {
@@ -498,7 +504,7 @@ impl RollingZScore {
     }
 
     /// Reset normalizer state
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.buffer = None; // Drop buffer (lazy reallocation on next update)
         self.mean = 0.0;
         self.m2 = 0.0;
@@ -516,8 +522,8 @@ impl RollingZScore {
 /// Handles skewed distributions (e.g., volume) better than z-score.
 ///
 /// ## Memory Optimization
-/// - OLD: VecDeque with capacity=window_size → heap allocation
-/// - NEW: Option<RingBuffer<f64, 100>> → None until first value
+/// - OLD: `VecDeque` with `capacity=window_size` → heap allocation
+/// - NEW: Option<`RingBuffer`<f64, 100>> → None until first value
 /// - Savings: 800 bytes per normalizer
 #[derive(Debug)]
 pub struct RollingPercentileRank {
@@ -563,7 +569,7 @@ impl RollingPercentileRank {
     }
 
     /// Reset normalizer state
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.buffer = None; // Drop buffer (lazy reallocation on next update)
     }
 }
@@ -619,7 +625,7 @@ impl LogZScoreNormalizer {
     }
 
     /// Reset normalizer state
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.zscore.reset();
     }
 }
@@ -639,7 +645,7 @@ struct NaNHandler {
 }
 
 impl NaNHandler {
-    fn new() -> Self {
+    const fn new() -> Self {
         Self {
             last_valid: [0.0; 225],
             nan_count: [0; 225],
@@ -675,7 +681,7 @@ impl NaNHandler {
     }
 
     /// Reset handler state
-    fn reset(&mut self) {
+    const fn reset(&mut self) {
         self.last_valid = [0.0; 225];
         self.nan_count = [0; 225];
     }
diff --git a/crates/ml-features/src/ofi_calculator.rs b/crates/ml-features/src/ofi_calculator.rs
index 0ec02fa9a..89dae6541 100644
--- a/crates/ml-features/src/ofi_calculator.rs
+++ b/crates/ml-features/src/ofi_calculator.rs
@@ -71,7 +71,7 @@ pub struct OFIFeatures {
 
 impl OFIFeatures {
     /// Convert to array (for integration with feature extraction)
-    pub fn to_array(&self) -> [f64; 8] {
+    pub const fn to_array(&self) -> [f64; 8] {
         [
             self.ofi_level1,
             self.ofi_level5,
@@ -85,7 +85,7 @@ impl OFIFeatures {
     }
 
     /// Create zero-initialized features (for missing data)
-    pub fn zeros() -> Self {
+    pub const fn zeros() -> Self {
         Self {
             ofi_level1: 0.0,
             ofi_level5: 0.0,
@@ -99,7 +99,7 @@ impl OFIFeatures {
     }
 
     /// Check if all features are finite (no NaN/Inf)
-    pub fn is_valid(&self) -> bool {
+    pub const fn is_valid(&self) -> bool {
         self.ofi_level1.is_finite()
             && self.ofi_level5.is_finite()
             && self.depth_imbalance.is_finite()
@@ -150,7 +150,7 @@ impl OFICalculator {
         }
     }
 
-    /// Feed a real trade event (from Databento Schema::Trades).
+    /// Feed a real trade event (from Databento `Schema::Trades`).
     ///
     /// Call this for each trade between MBP-10 snapshots to populate VPIN,
     /// Kyle's Lambda, and trade imbalance with actual trade data instead of
@@ -313,7 +313,7 @@ impl OFICalculator {
 
     /// Feature 3: Depth Imbalance
     ///
-    /// Formula: (total_bid_vol - total_ask_vol) / (total_bid_vol + total_ask_vol)
+    /// Formula: (`total_bid_vol` - `total_ask_vol`) / (`total_bid_vol` + `total_ask_vol`)
     /// Range: [-1, +1]
     fn calc_depth_imbalance(snapshot: &Mbp10Snapshot) -> f64 {
         let bid_depth: f64 = snapshot.levels.iter().map(|l| l.bid_sz as f64).sum();
@@ -366,7 +366,7 @@ impl Default for OFICalculator {
 
 impl OFICalculator {
     /// Returns true if real trade data has been fed via `feed_trade()`.
-    pub fn has_trade_data(&self) -> bool {
+    pub const fn has_trade_data(&self) -> bool {
         self.has_trade_data
     }
 }
@@ -426,7 +426,7 @@ impl VPINCalculator {
 /// Kyle's Lambda (Market Impact Coefficient)
 ///
 /// Based on Kyle (1985)
-/// Lambda = regression slope of price_change vs signed_volume
+/// Lambda = regression slope of `price_change` vs `signed_volume`
 #[derive(Debug)]
 struct KyleLambdaCalculator {
     price_changes: VecDeque<f64>,
@@ -495,7 +495,7 @@ struct TradeImbalanceTracker {
 }
 
 impl TradeImbalanceTracker {
-    fn new(window_size: usize) -> Self {
+    const fn new(window_size: usize) -> Self {
         Self {
             buy_pressure: 0.0,
             sell_pressure: 0.0,
@@ -656,7 +656,7 @@ fn linear_regression_slope(points: &[(f64, f64)]) -> f64 {
 }
 
 /// Safe clipping with NaN/Inf handling
-fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
+const fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
     if !value.is_finite() {
         return 0.0;
     }
diff --git a/crates/ml-features/src/pipeline.rs b/crates/ml-features/src/pipeline.rs
index e5691081b..1d7436eed 100644
--- a/crates/ml-features/src/pipeline.rs
+++ b/crates/ml-features/src/pipeline.rs
@@ -61,15 +61,15 @@ use crate::time_features::TimeFeatureExtractor;
 use crate::volume_features::VolumeFeatureExtractor;
 use crate::OHLCVBar;
 
-/// Wrapper around VecDeque that provides lazy allocation for bars
+/// Wrapper around `VecDeque` that provides lazy allocation for bars
 ///
 /// Memory Optimization (Wave G17):
-/// - OLD: VecDeque<OHLCVBar> with capacity 60 → ~12.5KB per symbol
-/// - NEW: Option<VecDeque<OHLCVBar>> → 0 bytes until first bar (lazy allocated)
+/// - OLD: `VecDeque`<OHLCVBar> with capacity 60 → ~12.5KB per symbol
+/// - NEW: Option<`VecDeque`<OHLCVBar>> → 0 bytes until first bar (lazy allocated)
 /// - Savings: ~10KB per symbol × 100K symbols = 1 GB
 ///
-/// Note: Cannot use RingBuffer here because OHLCVBar contains DateTime which doesn't implement Copy.
-/// RingBuffer is used only for primitive types (f64) in normalization.
+/// Note: Cannot use `RingBuffer` here because `OHLCVBar` contains `DateTime` which doesn't implement Copy.
+/// `RingBuffer` is used only for primitive types (f64) in normalization.
 #[derive(Debug, Clone)]
 struct BarsBuffer {
     buffer: Option<VecDeque<OHLCVBar>>,
@@ -223,7 +223,7 @@ impl FeatureExtractionPipeline {
 
     /// Update rolling window with new bar
     pub fn update(&mut self, bar: &OHLCVBar) {
-        self.bars.push_back(bar.clone());
+        self.bars.push_back(*bar);
         // Note: BarsBuffer (RingBuffer) automatically maintains window size
         // via circular overwriting, no need for manual pop_front
 
@@ -325,7 +325,7 @@ impl FeatureExtractionPipeline {
         if self.total_extractions % 1000 == 0 {
             let total_us = start_time.elapsed().as_micros() as u64;
             tracing::debug!(
-                "Pipeline performance: {} extractions, {:.2}μs avg (Stage1: {:.1}μs, Stage2: {:.1}μs, Stage3: {:.1}μs, Stage4: {:.1}μs, Stage5: {:.1}μs)",
+                "Pipeline performance: {} extractions, {:.2}\u{3bc}s avg (Stage1: {:.1}\u{3bc}s, Stage2: {:.1}\u{3bc}s, Stage3: {:.1}\u{3bc}s, Stage4: {:.1}\u{3bc}s, Stage5: {:.1}\u{3bc}s)",
                 self.total_extractions,
                 total_us,
                 self.stage_latencies[0],
@@ -666,7 +666,7 @@ impl FeatureExtractionPipeline {
     }
 
     /// Safe clipping to range
-    fn safe_clip(&self, value: f64, min: f64, max: f64) -> f64 {
+    const fn safe_clip(&self, value: f64, min: f64, max: f64) -> f64 {
         if value.is_nan() || value.is_infinite() {
             return 0.0;
         }
diff --git a/crates/ml-features/src/position_features.rs b/crates/ml-features/src/position_features.rs
index 3054b8d9a..fd4e86d4f 100644
--- a/crates/ml-features/src/position_features.rs
+++ b/crates/ml-features/src/position_features.rs
@@ -22,8 +22,8 @@ const MIN_VOLATILITY: f64 = 1e-10;
 
 /// Extracts position-aware features for RL agents.
 ///
-/// Maintains an EMA of absolute returns to normalize unrealized PnL,
-/// ensuring the agent perceives PnL relative to recent market movement.
+/// Maintains an EMA of absolute returns to normalize unrealized `PnL`,
+/// ensuring the agent perceives `PnL` relative to recent market movement.
 #[derive(Debug, Clone)]
 pub struct PositionFeatures {
     /// EMA smoothing factor: alpha = 2 / (span + 1)
@@ -72,16 +72,16 @@ impl PositionFeatures {
     /// # Arguments
     ///
     /// * `position_size` - Current position size (positive = long, negative = short, 0 = flat).
-    /// * `unrealized_pnl` - Dollar PnL of the open position.
+    /// * `unrealized_pnl` - Dollar `PnL` of the open position.
     /// * `bars_held` - Number of bars the current position has been held.
     /// * `entry_price` - Average entry price of the current position.
     /// * `current_price` - Current mid/close price.
     ///
     /// # Feature definitions
     ///
-    /// 1. **unrealized_pnl_norm**: `unrealized_pnl / ema_volatility` (0 when flat or no vol).
-    /// 2. **bars_in_position_norm**: `ln(1 + bars_held) / ln(1 + MAX_BARS)`, clamped to [0, 1].
-    /// 3. **cost_basis_bps_norm**: `(current_price / entry_price - 1) * 10_000`, clamped to [-500, 500],
+    /// 1. **`unrealized_pnl_norm`**: `unrealized_pnl / ema_volatility` (0 when flat or no vol).
+    /// 2. **`bars_in_position_norm`**: `ln(1 + bars_held) / ln(1 + MAX_BARS)`, clamped to [0, 1].
+    /// 3. **`cost_basis_bps_norm`**: `(current_price / entry_price - 1) * 10_000`, clamped to [-500, 500],
     ///    then scaled to [-1, 1] by dividing by 500. Sign is flipped for short positions.
     #[must_use]
     pub fn extract(
diff --git a/crates/ml-features/src/price_features.rs b/crates/ml-features/src/price_features.rs
index 6b1e488cb..29bd38d5b 100644
--- a/crates/ml-features/src/price_features.rs
+++ b/crates/ml-features/src/price_features.rs
@@ -14,7 +14,7 @@
 //!
 //! ## Feature Index Allocation
 //! - Features 27-41: Price-based features (15 total)
-//! - Extends existing 26-feature system (0-25 used, see WAVE_19_FEATURE_INDEX_MAP.md)
+//! - Extends existing 26-feature system (0-25 used, see `WAVE_19_FEATURE_INDEX_MAP.md`)
 
 use std::collections::VecDeque;
 
@@ -26,7 +26,7 @@ pub struct PriceFeatureExtractor;
 
 impl PriceFeatureExtractor {
     /// Create new extractor (stateless, so just returns unit struct)
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 
@@ -86,7 +86,7 @@ impl PriceFeatureExtractor {
         features
     }
 
-    /// 1. Simple return: (close - prev_close) / prev_close
+    /// 1. Simple return: (close - `prev_close`) / `prev_close`
     pub fn compute_simple_return(bars: &VecDeque<OHLCVBar>) -> f64 {
         if bars.len() < 2 {
             return 0.0;
@@ -99,7 +99,7 @@ impl PriceFeatureExtractor {
         safe_clip((curr - prev) / (prev + 1e-8), -0.5, 0.5)
     }
 
-    /// 2. Log return: ln(close / prev_close)
+    /// 2. Log return: ln(close / `prev_close`)
     pub fn compute_log_return(bars: &VecDeque<OHLCVBar>) -> f64 {
         if bars.len() < 2 {
             return 0.0;
@@ -112,7 +112,7 @@ impl PriceFeatureExtractor {
         safe_log_return(curr, prev)
     }
 
-    /// 3. Volatility-adjusted return: simple_return / volatility
+    /// 3. Volatility-adjusted return: `simple_return` / volatility
     pub fn compute_volatility_adjusted_return(bars: &VecDeque<OHLCVBar>) -> f64 {
         if bars.len() < 20 {
             return 0.0;
@@ -179,7 +179,7 @@ impl PriceFeatureExtractor {
         safe_clip(yz, 0.0, 0.5)
     }
 
-    /// 7. Price velocity: (close - close`[n_periods_ago]`) / n_periods
+    /// 7. Price velocity: (close - close`[n_periods_ago]`) / `n_periods`
     pub fn compute_price_velocity(bars: &VecDeque<OHLCVBar>, period: usize) -> f64 {
         if bars.len() <= period {
             return 0.0;
@@ -192,7 +192,7 @@ impl PriceFeatureExtractor {
         safe_clip((curr - prev) / period as f64, -10.0, 10.0)
     }
 
-    /// 8. Price acceleration: velocity - prev_velocity
+    /// 8. Price acceleration: velocity - `prev_velocity`
     pub fn compute_price_acceleration(bars: &VecDeque<OHLCVBar>) -> f64 {
         if bars.len() < 3 {
             return 0.0;
@@ -412,7 +412,7 @@ fn safe_log_return(current: f64, previous: f64) -> f64 {
 }
 
 /// Safe clipping: Clip value to [min, max] range
-fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
+const fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
     if !value.is_finite() {
         return 0.0;
     }
diff --git a/crates/ml-features/src/regime_adx.rs b/crates/ml-features/src/regime_adx.rs
index 71668b85f..c9a2891ed 100644
--- a/crates/ml-features/src/regime_adx.rs
+++ b/crates/ml-features/src/regime_adx.rs
@@ -14,8 +14,8 @@
 //! ## Algorithm
 //! 1. Calculate True Range (TR), +DM, -DM for each bar
 //! 2. Apply Wilder's smoothing (similar to EMA with alpha=1/period)
-//! 3. Compute +DI = 100 * smoothed_+DM / smoothed_TR
-//! 4. Compute -DI = 100 * smoothed_-DM / smoothed_TR
+//! 3. Compute +DI = 100 * smoothed_+DM / `smoothed_TR`
+//! 4. Compute -DI = 100 * smoothed_-DM / `smoothed_TR`
 //! 5. Compute DX = 100 * |+DI - -DI| / (+DI + -DI)
 //! 6. Compute ADX = Wilder's smooth of DX
 //!
@@ -124,7 +124,7 @@ impl RegimeADXFeatures {
 
         // Need previous bar for calculations
         if self.prev_bar.is_none() {
-            self.prev_bar = Some(bar.clone());
+            self.prev_bar = Some(*bar);
             return [0.0; 5];
         }
 
@@ -152,7 +152,7 @@ impl RegimeADXFeatures {
         self.update_adx();
 
         // Store current bar as previous
-        self.prev_bar = Some(bar.clone());
+        self.prev_bar = Some(*bar);
 
         // Return feature vector: [ADX, +DI, -DI, DX, ATR]
         [
@@ -165,12 +165,12 @@ impl RegimeADXFeatures {
     }
 
     /// Get current bar count (for warmup tracking)
-    pub fn bar_count(&self) -> usize {
+    pub const fn bar_count(&self) -> usize {
         self.bar_count
     }
 
     /// Get Wilder's alpha constant
-    pub fn get_alpha(&self) -> f64 {
+    pub const fn get_alpha(&self) -> f64 {
         self.alpha
     }
 
@@ -205,8 +205,8 @@ impl RegimeADXFeatures {
 
     /// Calculate +DM and -DM using Wilder's rules
     ///
-    /// +DM = max(0, H - H_prev) if high_diff > low_diff and high_diff > 0
-    /// -DM = max(0, L_prev - L) if low_diff > high_diff and low_diff > 0
+    /// +DM = max(0, H - `H_prev`) if `high_diff` > `low_diff` and `high_diff` > 0
+    /// -DM = max(0, `L_prev` - L) if `low_diff` > `high_diff` and `low_diff` > 0
     fn calculate_directional_movements(&self, bar: &OHLCVBar, prev: &OHLCVBar) -> (f64, f64) {
         // WAVE 8 AGENT 32 FIX: Validate inputs are finite before arithmetic
         // If any input is NaN/Inf, return (0.0, 0.0) to prevent NaN propagation
@@ -241,7 +241,7 @@ impl RegimeADXFeatures {
         (plus_dm, minus_dm)
     }
 
-    /// Update smoothed values using Wilder's EMA: S_new = S_old × (1-α) + value × α
+    /// Update smoothed values using Wilder's EMA: `S_new` = `S_old` × (1-α) + value × α
     fn update_smoothed_values(&mut self, tr: f64, plus_dm: f64, minus_dm: f64) {
         // ATR smoothing
         let new_atr = match self.atr {
@@ -277,7 +277,7 @@ impl RegimeADXFeatures {
         });
     }
 
-    /// Calculate +DI and -DI: DI = (DM_smooth / ATR) × 100
+    /// Calculate +DI and -DI: DI = (`DM_smooth` / ATR) × 100
     fn calculate_directional_indicators(&mut self) {
         let atr_val = self.atr.unwrap_or(1.0);
 
diff --git a/crates/ml-features/src/statistical_features.rs b/crates/ml-features/src/statistical_features.rs
index aabcbed59..2ab0db9fc 100644
--- a/crates/ml-features/src/statistical_features.rs
+++ b/crates/ml-features/src/statistical_features.rs
@@ -3,7 +3,7 @@
 //! This module implements 7+ rolling statistical features with efficient algorithms:
 //! - Rolling statistics (mean, std, min, max) using ring buffers and monotonic deques
 //! - Distribution features (quantile position, autocorrelation)
-//! - Higher moments (skewness, kurtosis - integrated from price_features.rs)
+//! - Higher moments (skewness, kurtosis - integrated from `price_features.rs`)
 //!
 //! ## Performance Target
 //! - <100μs for all features per bar (50x better than existing statistical features)
@@ -19,8 +19,8 @@
 //! - SIMD-ready vectorized operations (AVX2)
 //!
 //! ## References
-//! - WAVE_19_COMPREHENSIVE_FEATURE_ENGINEERING_PLAN.md
-//! - ml/src/features/price_features.rs (skewness, kurtosis)
+//! - `WAVE_19_COMPREHENSIVE_FEATURE_ENGINEERING_PLAN.md`
+//! - `ml/src/features/price_features.rs` (skewness, kurtosis)
 
 use std::collections::VecDeque;
 
@@ -35,12 +35,12 @@ pub struct StatisticalFeatureExtractor {
 
 impl StatisticalFeatureExtractor {
     /// Create new extractor with default 20-period window
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { _private: () }
     }
 
     /// Create new extractor with custom window size
-    pub fn with_window_size(_window_size: usize) -> Self {
+    pub const fn with_window_size(_window_size: usize) -> Self {
         Self { _private: () }
     }
 
@@ -222,7 +222,7 @@ impl StatisticalFeatureExtractor {
 
     /// Feature 48: Rolling entropy (Shannon entropy of return bins)
     ///
-    /// Formula: -Σ(p_i * log(p_i)) where p_i is probability of bin i
+    /// Formula: -`Σ(p_i` * `log(p_i)`) where `p_i` is probability of bin i
     /// Range: [0.0, 3.0] (0 = deterministic, 3.0 = maximum entropy)
     pub fn compute_rolling_entropy(bars: &VecDeque<OHLCVBar>, period: usize) -> f64 {
         if bars.len() < period + 1 || period < 5 {
@@ -327,7 +327,7 @@ fn safe_log_return(current: f64, previous: f64) -> f64 {
 }
 
 /// Safe clipping: Clip value to [min, max] range, handles NaN/Inf
-fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
+const fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
     if !value.is_finite() {
         return 0.0;
     }
diff --git a/crates/ml-features/src/time_features.rs b/crates/ml-features/src/time_features.rs
index 5eb3bb0de..1b20a4cb4 100644
--- a/crates/ml-features/src/time_features.rs
+++ b/crates/ml-features/src/time_features.rs
@@ -123,8 +123,8 @@ impl TimeFeatureExtractor {
     /// - `timestamp`: Current timestamp (UTC)
     ///
     /// # Returns
-    /// - Array of 8 features: [hour_sin, hour_cos, day_sin, day_cos, time_since_open,
-    ///   time_until_close, correlation_regime, volatility_regime]
+    /// - Array of 8 features: [`hour_sin`, `hour_cos`, `day_sin`, `day_cos`, `time_since_open`,
+    ///   `time_until_close`, `correlation_regime`, `volatility_regime`]
     pub fn extract_features(&self, timestamp: DateTime<Utc>) -> [f64; 8] {
         let mut features = [0.0; 8];
 
@@ -187,7 +187,7 @@ impl TimeFeatureExtractor {
     /// Time since market open in normalized form
     ///
     /// # Arguments
-    /// - `et_time`: DateTime in US Eastern Time
+    /// - `et_time`: `DateTime` in US Eastern Time
     ///
     /// # Returns
     /// - Normalized time since open [0, 1] for regular session (9:30 AM - 4:00 PM)
@@ -203,7 +203,7 @@ impl TimeFeatureExtractor {
     /// Time until market close in normalized form
     ///
     /// # Arguments
-    /// - `et_time`: DateTime in US Eastern Time
+    /// - `et_time`: `DateTime` in US Eastern Time
     ///
     /// # Returns
     /// - Normalized time until close [0, 1] for regular session
diff --git a/crates/ml-features/src/trades_loader.rs b/crates/ml-features/src/trades_loader.rs
index c2af70e28..31777b8ce 100644
--- a/crates/ml-features/src/trades_loader.rs
+++ b/crates/ml-features/src/trades_loader.rs
@@ -1,4 +1,4 @@
-//! Trade Data Loader for DBN Schema::Trades
+//! Trade Data Loader for DBN `Schema::Trades`
 //!
 //! Loads Databento trade records from `.dbn` or `.dbn.zst` files and provides
 //! time-windowed access for feeding into `OFICalculator::feed_trade()` (VPIN,
diff --git a/crates/ml-features/src/types.rs b/crates/ml-features/src/types.rs
index 74e84ed79..7b8440975 100644
--- a/crates/ml-features/src/types.rs
+++ b/crates/ml-features/src/types.rs
@@ -80,7 +80,7 @@ pub struct CacheMetadata {
     pub created_at: DateTime<Utc>,
     /// SHA-256 hash of input OHLCV data
     pub data_hash: String,
-    /// MinIO object key
+    /// `MinIO` object key
     pub object_key: String,
     /// Feature matrix statistics
     pub stats: Option<FeatureStats>,
@@ -183,27 +183,27 @@ impl CacheStats {
     }
 
     /// Record cache hit
-    pub fn record_hit(&mut self) {
+    pub const fn record_hit(&mut self) {
         self.hits += 1;
     }
 
     /// Record cache miss
-    pub fn record_miss(&mut self) {
+    pub const fn record_miss(&mut self) {
         self.misses += 1;
     }
 
     /// Record invalidation
-    pub fn record_invalidation(&mut self) {
+    pub const fn record_invalidation(&mut self) {
         self.invalidations += 1;
     }
 
     /// Record features computed
-    pub fn record_computed(&mut self, count: usize) {
+    pub const fn record_computed(&mut self, count: usize) {
         self.features_computed += count as u64;
     }
 
     /// Record features loaded
-    pub fn record_loaded(&mut self, count: usize) {
+    pub const fn record_loaded(&mut self, count: usize) {
         self.features_loaded += count as u64;
     }
 
diff --git a/crates/ml-features/src/volume_features.rs b/crates/ml-features/src/volume_features.rs
index fa0d16111..b2317ebd3 100644
--- a/crates/ml-features/src/volume_features.rs
+++ b/crates/ml-features/src/volume_features.rs
@@ -18,13 +18,13 @@
 //!
 //! ## Performance Target
 //! - Latency: <150μs for all 10 features per bar
-//! - Memory: <100 bytes per bar (reuses existing VecDeque)
+//! - Memory: <100 bytes per bar (reuses existing `VecDeque`)
 //!
 //! ## Integration
 //! These features extend the 256-dimension feature vector to 266 dimensions.
 //!
 //! ## References
-//! - WAVE_C_VOLUME_FEATURES_DESIGN.md (comprehensive design document)
+//! - `WAVE_C_VOLUME_FEATURES_DESIGN.md` (comprehensive design document)
 //! - ml/src/features/extraction.rs (existing 40 volume features)
 
 use anyhow::Result;
@@ -48,7 +48,7 @@ pub struct VolumeFeatureExtractor {
 
 impl VolumeFeatureExtractor {
     /// Creates a new volume feature extractor (Wave G17: lazy allocation)
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { bars: None }
     }
 
@@ -125,7 +125,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 256: Volume ratio to SMA-50
     ///
-    /// Formula: (current_volume - sma_50) / sma_50
+    /// Formula: (`current_volume` - `sma_50`) / `sma_50`
     /// Range: [-2.0, 5.0]
     fn compute_volume_ratio_sma50(&self) -> f64 {
         if self.bars().len() < 50 {
@@ -144,7 +144,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 257/258: Volume ROC (Rate of Change)
     ///
-    /// Formula: (current_volume - volume_n_bars_ago) / volume_n_bars_ago
+    /// Formula: (`current_volume` - `volume_n_bars_ago`) / `volume_n_bars_ago`
     /// Range: [-1.0, 3.0]
     fn compute_volume_roc(&self, period: usize) -> f64 {
         let len = self.bars().len();
@@ -164,7 +164,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 259: Volume acceleration (second derivative)
     ///
-    /// Formula: (velocity_1 - velocity_2) / 1000
+    /// Formula: (`velocity_1` - `velocity_2`) / 1000
     /// Range: [-5.0, 5.0]
     fn compute_volume_acceleration(&self) -> f64 {
         if self.bars().len() < 3 {
@@ -251,7 +251,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 263: Volume percentile rank
     ///
-    /// Formula: count(vol < current_vol) / period
+    /// Formula: count(vol < `current_vol`) / period
     /// Range: [0.0, 1.0]
     fn compute_volume_percentile(&self, period: usize) -> f64 {
         if self.bars().len() < period {
@@ -276,7 +276,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 264: Volume concentration (Herfindahl-Hirschman Index)
     ///
-    /// Formula: HHI = Σ(vol_i / total_vol)²
+    /// Formula: HHI = `Σ(vol_i` / `total_vol)²`
     /// Range: [0.0, 1.0] (normalized from [1/n, 1])
     fn compute_volume_concentration_hhi(&self, period: usize) -> f64 {
         if self.bars().len() < period {
@@ -309,7 +309,7 @@ impl VolumeFeatureExtractor {
 
     /// Feature 265: Volume imbalance (buy vs sell pressure)
     ///
-    /// Formula: (buy_vol - sell_vol) / total_vol
+    /// Formula: (`buy_vol` - `sell_vol`) / `total_vol`
     /// Range: [-1.0, 1.0]
     fn compute_volume_imbalance(&self, period: usize) -> f64 {
         if self.bars().len() < period {
@@ -394,7 +394,7 @@ impl Default for VolumeFeatureExtractor {
 // ===== Utility Functions =====
 
 /// Safe clipping: Clip value to [min, max] range, handles NaN/Inf
-fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
+const fn safe_clip(value: f64, min: f64, max: f64) -> f64 {
     if !value.is_finite() {
         return 0.0;
     }
diff --git a/crates/ml-hyperopt/src/early_stopping.rs b/crates/ml-hyperopt/src/early_stopping.rs
index 027fe5df3..905eab908 100644
--- a/crates/ml-hyperopt/src/early_stopping.rs
+++ b/crates/ml-hyperopt/src/early_stopping.rs
@@ -1032,7 +1032,7 @@ impl EarlyStoppingObserver {
     fn get_or_create_state(&mut self, trial_num: usize) -> &mut EarlyStoppingState {
         self.state
             .entry(trial_num)
-            .or_insert_with(EarlyStoppingState::new)
+            .or_default()
     }
 
     /// Check if should stop based on strategy
diff --git a/crates/ml-hyperopt/src/optimizer.rs b/crates/ml-hyperopt/src/optimizer.rs
index 725bb38d2..03b5c14b4 100644
--- a/crates/ml-hyperopt/src/optimizer.rs
+++ b/crates/ml-hyperopt/src/optimizer.rs
@@ -381,7 +381,7 @@ impl ArgminOptimizer {
             let res = Executor::new(cost_fn, solver)
                 .configure(|state| state.max_iters(max_iters as u64))
                 .add_observer(
-                    observer.clone(),
+                    observer,
                     argmin::core::observers::ObserverMode::Always,
                 )
                 .run();
@@ -401,7 +401,7 @@ impl ArgminOptimizer {
                     );
                     info!("  Evaluations: {}", trial_counter.load(std::sync::atomic::Ordering::Relaxed));
                 },
-                Err(e) => return Err(e.into()),
+                Err(e) => return Err(e),
             }
         } else {
             info!("No remaining budget for Particle Swarm optimization");
@@ -665,7 +665,7 @@ impl ArgminOptimizer {
         let trial_counter = Arc::new(std::sync::atomic::AtomicUsize::new(0));
 
         // OOM Layer 2: Start at ceil(max/2), ramp up after first success
-        let initial_concurrency = ((strategy.max_concurrent_trials + 1) / 2).max(1);
+        let initial_concurrency = strategy.max_concurrent_trials.div_ceil(2).max(1);
         let concurrency = std::sync::atomic::AtomicUsize::new(initial_concurrency);
 
         info!(
@@ -789,7 +789,7 @@ impl ArgminOptimizer {
             let res = Executor::new(cost_fn, solver)
                 .configure(|state| state.max_iters(max_iters as u64))
                 .add_observer(
-                    observer.clone(),
+                    observer,
                     argmin::core::observers::ObserverMode::Always,
                 )
                 .run();
@@ -808,7 +808,7 @@ impl ArgminOptimizer {
                     );
                     info!("  Evaluations: {}", trial_counter.load(std::sync::atomic::Ordering::Relaxed));
                 },
-                Err(e) => return Err(e.into()),
+                Err(e) => return Err(e),
             }
         } else {
             info!("No remaining budget for Particle Swarm optimization");
diff --git a/crates/ml-hyperopt/src/traits.rs b/crates/ml-hyperopt/src/traits.rs
index e24bcae87..a5e9de407 100644
--- a/crates/ml-hyperopt/src/traits.rs
+++ b/crates/ml-hyperopt/src/traits.rs
@@ -64,18 +64,15 @@ use crate::MLError;
 /// In two-phase optimization, Phase A uses `EpisodeReward` for fast convergence,
 /// then Phase B switches to `Sharpe` for financial quality refinement.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Default)]
 pub enum ObjectiveMode {
     /// Phase A: Optimize episode reward (fast convergence signal)
     EpisodeReward,
     /// Phase B: Optimize Sharpe ratio (financial quality)
+    #[default]
     Sharpe,
 }
 
-impl Default for ObjectiveMode {
-    fn default() -> Self {
-        ObjectiveMode::Sharpe
-    }
-}
 
 /// Strategy computed by HardwareBudget for optimal GPU utilization during hyperopt.
 #[derive(Debug, Clone)]
@@ -111,22 +108,19 @@ impl HardwareBudget {
     /// and other GPU consumers are already subtracted.
     /// Falls back to `cpu_only()` if detection fails (no GPU, driver error, etc.).
     pub fn detect() -> Self {
-        match ml_core::memory_optimization::auto_batch_size::detect_gpu_memory() {
-            Ok((total_mb, free_mb, name)) => {
-                // Use free VRAM — on desktop GPUs the display server can consume
-                // 300-1500 MB of the total. Using total_mb would overestimate
-                // available budget and cause OOM on small GPUs (e.g. RTX 3050 Ti 4GB).
-                let gpu_memory_mb = free_mb as usize;
-                info!(
-                    "HardwareBudget: detected {} — {}MB total, {}MB free (using free as budget)",
-                    name, total_mb as usize, gpu_memory_mb
-                );
-                Self { gpu_memory_mb, gpu_name: name }
-            }
-            Err(_) => {
-                info!("HardwareBudget: no GPU detected, using CPU-only defaults");
-                Self::cpu_only()
-            }
+        if let Ok((total_mb, free_mb, name)) = ml_core::memory_optimization::auto_batch_size::detect_gpu_memory() {
+            // Use free VRAM — on desktop GPUs the display server can consume
+            // 300-1500 MB of the total. Using total_mb would overestimate
+            // available budget and cause OOM on small GPUs (e.g. RTX 3050 Ti 4GB).
+            let gpu_memory_mb = free_mb as usize;
+            info!(
+                "HardwareBudget: detected {} — {}MB total, {}MB free (using free as budget)",
+                name, total_mb as usize, gpu_memory_mb
+            );
+            Self { gpu_memory_mb, gpu_name: name }
+        } else {
+            info!("HardwareBudget: no GPU detected, using CPU-only defaults");
+            Self::cpu_only()
         }
     }
 
@@ -294,7 +288,7 @@ impl HardwareBudget {
         let mut lo: usize = 256;
         let mut hi: usize = 8192;
         while lo < hi {
-            let mid = (lo + hi + 1) / 2;
+            let mid = (lo + hi).div_ceil(2);
             let vram = Self::estimate_trial_vram_mb_full(
                 mid,
                 batch_size,
diff --git a/crates/ml-labeling/src/benchmarks.rs b/crates/ml-labeling/src/benchmarks.rs
index a655607e6..65ae6a846 100644
--- a/crates/ml-labeling/src/benchmarks.rs
+++ b/crates/ml-labeling/src/benchmarks.rs
@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use tracing::info;
 
 use super::concurrent_tracking::{BarrierTracker, ConcurrentBarrierTracker, PricePoint};
-use super::constants::*;
+use super::constants::{MAX_TRIPLE_BARRIER_LATENCY_US, MAX_META_LABELING_LATENCY_US, MAX_FRACTIONAL_DIFF_LATENCY_US, MIN_BATCH_THROUGHPUT_LPS};
 use super::gpu_acceleration::LabelingError;
 use super::types::BarrierConfig;
 
diff --git a/crates/ml-labeling/src/concurrent_tracking.rs b/crates/ml-labeling/src/concurrent_tracking.rs
index fba2b83c1..619317d9e 100644
--- a/crates/ml-labeling/src/concurrent_tracking.rs
+++ b/crates/ml-labeling/src/concurrent_tracking.rs
@@ -9,7 +9,7 @@ use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use super::constants::*;
+use super::constants::MAX_TRIPLE_BARRIER_LATENCY_US;
 use super::gpu_acceleration::LabelingError;
 use super::types::{BarrierConfig, BarrierResult, EventLabel};
 
@@ -21,7 +21,7 @@ pub struct PricePoint {
 }
 
 impl PricePoint {
-    pub fn new(price_cents: u64, timestamp_ns: u64) -> Self {
+    pub const fn new(price_cents: u64, timestamp_ns: u64) -> Self {
         Self {
             price_cents,
             timestamp_ns,
@@ -77,12 +77,12 @@ impl BarrierTracker {
         }
     }
 
-    pub fn tracker_id(&self) -> Uuid {
+    pub const fn tracker_id(&self) -> Uuid {
         self.tracker_id
     }
 
     /// Check if price update triggers any barrier
-    pub fn check_barriers(&self, price_point: &PricePoint) -> Option<BarrierResult> {
+    pub const fn check_barriers(&self, price_point: &PricePoint) -> Option<BarrierResult> {
         let holding_period = price_point
             .timestamp_ns
             .saturating_sub(self.entry_timestamp_ns);
@@ -113,7 +113,7 @@ impl BarrierTracker {
     }
 }
 
-/// Concurrent barrier tracker using DashMap
+/// Concurrent barrier tracker using `DashMap`
 #[derive(Debug)]
 pub struct ConcurrentBarrierTracker {
     trackers: Arc<DashMap<Uuid, BarrierTracker>>,
diff --git a/crates/ml-labeling/src/fractional_diff.rs b/crates/ml-labeling/src/fractional_diff.rs
index 96c0d65d9..e877bae87 100644
--- a/crates/ml-labeling/src/fractional_diff.rs
+++ b/crates/ml-labeling/src/fractional_diff.rs
@@ -135,7 +135,7 @@ impl StreamingDifferentiator {
     }
 
     /// Get processed count
-    pub fn processed_count(&self) -> u64 {
+    pub const fn processed_count(&self) -> u64 {
         self.processed_count
     }
 
@@ -249,12 +249,12 @@ impl FractionalDifferentiator {
     }
 
     /// Get configuration
-    pub fn get_config(&self) -> &FractionalDiffConfig {
+    pub const fn get_config(&self) -> &FractionalDiffConfig {
         &self.config
     }
 
     /// Get coefficients
-    pub fn get_coeffs(&self) -> &FractionalCoeffs {
+    pub const fn get_coeffs(&self) -> &FractionalCoeffs {
         &self.coeffs
     }
 }
diff --git a/crates/ml-labeling/src/gpu_acceleration.rs b/crates/ml-labeling/src/gpu_acceleration.rs
index cce5da5a8..692e24e31 100644
--- a/crates/ml-labeling/src/gpu_acceleration.rs
+++ b/crates/ml-labeling/src/gpu_acceleration.rs
@@ -17,7 +17,7 @@ pub struct GPULabelingEngine {
 
 impl GPULabelingEngine {
     /// Create new `GPU` labeling engine
-    pub fn new(device: Device) -> Result<Self, LabelingError> {
+    pub const fn new(device: Device) -> Result<Self, LabelingError> {
         Ok(Self { device })
     }
 
diff --git a/crates/ml-labeling/src/lib.rs b/crates/ml-labeling/src/lib.rs
index c66890d5d..3092200a1 100644
--- a/crates/ml-labeling/src/lib.rs
+++ b/crates/ml-labeling/src/lib.rs
@@ -2,7 +2,7 @@
 //!
 //! This module provides high-performance machine learning labeling algorithms
 //! optimized for ultra-low latency financial applications. All implementations
-//! use FixedPoint arithmetic for financial precision and target sub-microsecond
+//! use `FixedPoint` arithmetic for financial precision and target sub-microsecond
 //! performance.
 //!
 //! ## Core Features
@@ -12,7 +12,7 @@
 //! - **Fractional Differentiation**: Streaming transforms with <1us latency
 //! - **Sample Weighting**: Volatility/return/time-based weighting algorithms
 //! - **GPU Acceleration**: Batch processing with CUDA via candle integration
-//! - **Concurrent Processing**: Lock-free barrier tracking with DashMap
+//! - **Concurrent Processing**: Lock-free barrier tracking with `DashMap`
 //!
 //! ## Performance Targets
 //!
@@ -26,7 +26,7 @@
 //!
 //! All components use integer arithmetic (cents, nanoseconds, basis points)
 //! for financial precision, matching the Python reference implementation
-//! patterns from the HFTTrendfollowing project.
+//! patterns from the `HFTTrendfollowing` project.
 
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 #![cfg_attr(test, allow(clippy::unwrap_used, clippy::expect_used))]
@@ -87,7 +87,7 @@ pub mod constants {
 
 /// Utility functions for labeling operations
 pub mod utils {
-    use super::constants::*;
+    use super::constants::{CENTS_PER_DOLLAR, BASIS_POINTS_PER_DOLLAR, NANOSECONDS_PER_SECOND};
 
     /// Convert price to cents
     pub fn price_to_cents(price: f64) -> u64 {
diff --git a/crates/ml-labeling/src/meta_labeling/primary_model.rs b/crates/ml-labeling/src/meta_labeling/primary_model.rs
index 13c7d77a8..710d56e20 100644
--- a/crates/ml-labeling/src/meta_labeling/primary_model.rs
+++ b/crates/ml-labeling/src/meta_labeling/primary_model.rs
@@ -43,7 +43,7 @@ impl Label {
     /// - Buy = 1
     /// - Hold = 0
     /// - Sell = -1
-    pub fn to_i8(&self) -> i8 {
+    pub const fn to_i8(&self) -> i8 {
         match self {
             Label::Buy => 1,
             Label::Sell => -1,
@@ -52,7 +52,7 @@ impl Label {
     }
 
     /// Create label from integer representation
-    pub fn from_i8(value: i8) -> Self {
+    pub const fn from_i8(value: i8) -> Self {
         match value {
             1 => Label::Buy,
             -1 => Label::Sell,
@@ -125,7 +125,7 @@ impl PrimaryDirectionalModel {
     }
 
     /// Get model name
-    pub fn name(&self) -> &str {
+    pub const fn name(&self) -> &str {
         "PrimaryDirectionalModel"
     }
 
@@ -234,7 +234,7 @@ impl PrimaryDirectionalModel {
     }
 
     /// Get configuration
-    pub fn config(&self) -> &PrimaryModelConfig {
+    pub const fn config(&self) -> &PrimaryModelConfig {
         &self.config
     }
 }
diff --git a/crates/ml-labeling/src/meta_labeling/secondary_model.rs b/crates/ml-labeling/src/meta_labeling/secondary_model.rs
index 368129666..50b6e2c4e 100644
--- a/crates/ml-labeling/src/meta_labeling/secondary_model.rs
+++ b/crates/ml-labeling/src/meta_labeling/secondary_model.rs
@@ -99,7 +99,7 @@ pub struct PrimaryPrediction {
 pub struct TradeDecision {
     /// Whether to execute the trade
     pub should_trade: bool,
-    /// Position size (fraction of portfolio, 0.0 to max_bet_size)
+    /// Position size (fraction of portfolio, 0.0 to `max_bet_size`)
     pub bet_size: f64,
     /// Adjusted confidence after secondary analysis
     pub confidence: f64,
@@ -145,7 +145,7 @@ pub struct SecondaryBettingModel {
     total_predictions: Arc<AtomicU64>,
     total_trades: Arc<AtomicU64>,
     total_bet_size: Arc<AtomicU64>, // Stored as fixed-point (multiply by 1e6)
-    /// Exponential moving average of prediction confidence, fixed-point (x 1_000_000)
+    /// Exponential moving average of prediction confidence, fixed-point (x `1_000_000`)
     confidence_ema: Arc<AtomicU64>,
     /// EMA smoothing factor (higher = more weight on recent observations)
     confidence_ema_alpha: f64,
@@ -167,12 +167,12 @@ impl SecondaryBettingModel {
     }
 
     /// Get model name
-    pub fn name(&self) -> &str {
+    pub const fn name(&self) -> &str {
         "secondary_betting_model"
     }
 
     /// Check if model is ready for predictions
-    pub fn is_ready(&self) -> bool {
+    pub const fn is_ready(&self) -> bool {
         true // Rule-based model is always ready
     }
 
diff --git a/crates/ml-labeling/src/meta_labeling_engine.rs b/crates/ml-labeling/src/meta_labeling_engine.rs
index 6862703bf..43f13dbfd 100644
--- a/crates/ml-labeling/src/meta_labeling_engine.rs
+++ b/crates/ml-labeling/src/meta_labeling_engine.rs
@@ -26,7 +26,7 @@ pub struct MetaLabelConfig {
 }
 
 impl MetaLabelConfig {
-    pub fn standard() -> Self {
+    pub const fn standard() -> Self {
         Self {
             confidence_threshold: 0.5,
             min_bet_size: 0.01,
@@ -36,7 +36,7 @@ impl MetaLabelConfig {
 }
 
 impl MetaLabelingEngine {
-    pub fn new(config: MetaLabelConfig) -> Self {
+    pub const fn new(config: MetaLabelConfig) -> Self {
         Self { config }
     }
 
diff --git a/crates/ml-labeling/src/sample_weights.rs b/crates/ml-labeling/src/sample_weights.rs
index 62eeb037b..3151880f5 100644
--- a/crates/ml-labeling/src/sample_weights.rs
+++ b/crates/ml-labeling/src/sample_weights.rs
@@ -20,7 +20,7 @@ pub struct WeightingConfig {
 
 impl WeightingConfig {
     /// Standard configuration values
-    pub fn standard() -> Self {
+    pub const fn standard() -> Self {
         Self {
             time_decay: 0.95,
             return_scale: 1.0,
@@ -37,7 +37,7 @@ pub struct SampleWeightCalculator {
 
 impl SampleWeightCalculator {
     /// Create new calculator with given configuration
-    pub fn new(config: WeightingConfig) -> Self {
+    pub const fn new(config: WeightingConfig) -> Self {
         Self { config }
     }
 
diff --git a/crates/ml-labeling/src/triple_barrier.rs b/crates/ml-labeling/src/triple_barrier.rs
index 3832e7f36..d1d80409f 100644
--- a/crates/ml-labeling/src/triple_barrier.rs
+++ b/crates/ml-labeling/src/triple_barrier.rs
@@ -1,7 +1,7 @@
 //! Triple Barrier Engine implementation
 //!
 //! High-performance triple barrier labeling with <80us latency target.
-//! Based on the Python reference implementation from HFTTrendfollowing
+//! Based on the Python reference implementation from `HFTTrendfollowing`
 //! with optimizations for ultra-low latency financial applications.
 
 use std::collections::VecDeque;
@@ -13,8 +13,8 @@ use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use super::constants::*;
-use super::types::*;
+use super::constants::BASIS_POINTS_PER_DOLLAR;
+use super::types::{BarrierConfig, BarrierTouchedFirst, BarrierResult, EventLabel};
 
 /// Price point for tracking
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
@@ -24,7 +24,7 @@ pub struct PricePoint {
 }
 
 impl PricePoint {
-    pub fn new(price_cents: u64, timestamp_ns: u64) -> Self {
+    pub const fn new(price_cents: u64, timestamp_ns: u64) -> Self {
         Self {
             price_cents,
             timestamp_ns,
@@ -46,7 +46,7 @@ pub struct BarrierTracker {
 }
 
 impl BarrierTracker {
-    pub fn new(entry_price_cents: u64, entry_timestamp_ns: u64, config: BarrierConfig) -> Self {
+    pub const fn new(entry_price_cents: u64, entry_timestamp_ns: u64, config: BarrierConfig) -> Self {
         let upper_barrier_cents = entry_price_cents
             + (entry_price_cents * config.profit_target_bps as u64)
                 / BASIS_POINTS_PER_DOLLAR as u64;
@@ -135,7 +135,7 @@ impl BarrierTracker {
         }
     }
 
-    fn calculate_quality_score(&self, _price_point: PricePoint) -> f64 {
+    const fn calculate_quality_score(&self, _price_point: PricePoint) -> f64 {
         // Simple quality score based on how quickly the barrier was hit
         match self.final_result {
             Some(BarrierResult::ProfitTarget) => 0.9,
@@ -145,7 +145,7 @@ impl BarrierTracker {
         }
     }
 
-    pub fn is_closed(&self) -> bool {
+    pub const fn is_closed(&self) -> bool {
         self.final_result.is_some()
     }
 }
diff --git a/crates/ml-labeling/src/types.rs b/crates/ml-labeling/src/types.rs
index 258c876c2..ea01a3335 100644
--- a/crates/ml-labeling/src/types.rs
+++ b/crates/ml-labeling/src/types.rs
@@ -27,7 +27,7 @@ pub struct BarrierConfig {
 
 impl BarrierConfig {
     /// Conservative configuration
-    pub fn conservative() -> Self {
+    pub const fn conservative() -> Self {
         Self {
             profit_target_bps: 100,
             stop_loss_bps: 50,
@@ -90,7 +90,7 @@ pub struct EventLabel {
 
 impl EventLabel {
     /// Create new event label
-    pub fn new(
+    pub const fn new(
         event_timestamp_ns: u64,
         entry_price_cents: u64,
         barrier_result: BarrierResult,
@@ -111,12 +111,12 @@ impl EventLabel {
     }
 
     /// Check if the label is profitable
-    pub fn is_profitable(&self) -> bool {
+    pub const fn is_profitable(&self) -> bool {
         self.return_bps > 0
     }
 
     /// Check if processing meets latency target
-    pub fn meets_latency_target(&self, target_us: u32) -> bool {
+    pub const fn meets_latency_target(&self, target_us: u32) -> bool {
         self.processing_latency_us <= target_us
     }
 
@@ -215,7 +215,7 @@ pub struct MetaLabel {
 }
 
 impl MetaLabel {
-    pub fn new(
+    pub const fn new(
         timestamp_ns: u64,
         confidence: f64,
         prediction: i8,
@@ -250,7 +250,7 @@ pub struct FractionalDiffConfig {
 }
 
 impl FractionalDiffConfig {
-    pub fn standard() -> Self {
+    pub const fn standard() -> Self {
         Self {
             diff_order: 0.5,
             max_lags: 50,
@@ -282,7 +282,7 @@ pub struct WeightedSample {
 }
 
 impl WeightedSample {
-    pub fn new(timestamp_ns: u64, features: Vec<f64>, label: i8, weight: f64) -> Self {
+    pub const fn new(timestamp_ns: u64, features: Vec<f64>, label: i8, weight: f64) -> Self {
         Self {
             timestamp_ns,
             features,
diff --git a/crates/ml-observability/src/dashboards.rs b/crates/ml-observability/src/dashboards.rs
index f316e4e27..bb462d963 100644
--- a/crates/ml-observability/src/dashboards.rs
+++ b/crates/ml-observability/src/dashboards.rs
@@ -49,7 +49,7 @@ pub struct MetricsDashboard {
 }
 
 impl MetricsDashboard {
-    pub fn new(config: DashboardConfig) -> Self {
+    pub const fn new(config: DashboardConfig) -> Self {
         Self { config }
     }
 
diff --git a/crates/ml-observability/src/metrics.rs b/crates/ml-observability/src/metrics.rs
index 32fbb4d7f..ea042b05d 100644
--- a/crates/ml-observability/src/metrics.rs
+++ b/crates/ml-observability/src/metrics.rs
@@ -48,7 +48,7 @@ fn bucket_symbol(symbol: &str) -> &'static str {
     }
 
     // Equities (1-5 alphabetic chars)
-    if upper_str.len() >= 1 && upper_str.len() <= 5 && upper_str.chars().all(|c| c.is_alphabetic())
+    if !upper_str.is_empty() && upper_str.len() <= 5 && upper_str.chars().all(|c| c.is_alphabetic())
     {
         return "equities";
     }
@@ -145,7 +145,7 @@ impl MLMetricsCollector {
                 "ml_prediction_latency_microseconds",
                 "ML prediction processing latency in microseconds",
             )
-            .buckets(latency_buckets.clone()),
+            .buckets(latency_buckets),
             &["model_type", "operation"],
         )?;
 
@@ -331,8 +331,8 @@ impl MLMetricsCollector {
         let asset_class = symbol.map(bucket_symbol).unwrap_or("unknown");
         let labels = [
             model_type.to_string(),
-            model_name.to_string(),
-            asset_class.to_string(),
+            model_name.to_owned(),
+            asset_class.to_owned(),
         ];
         let label_refs: Vec<&str> = labels.iter().map(|s| s.as_str()).collect();
         self.inference_latency
@@ -351,13 +351,13 @@ impl MLMetricsCollector {
         // Update counters
         let labels1 = [
             model_type.to_string(),
-            model_name.to_string(),
+            model_name.to_owned(),
             "success".to_owned(),
         ];
         let label_refs1: Vec<&str> = labels1.iter().map(|s| s.as_str()).collect();
         self.predictions_total.with_label_values(&label_refs1).inc();
 
-        let labels2 = [model_type.to_string(), model_name.to_string()];
+        let labels2 = [model_type.to_string(), model_name.to_owned()];
         let label_refs2: Vec<&str> = labels2.iter().map(|s| s.as_str()).collect();
         self.successful_predictions
             .with_label_values(&label_refs2)
@@ -366,7 +366,7 @@ impl MLMetricsCollector {
         self.record_inference_latency(model_type, model_name, None, latency_us);
 
         // Update confidence
-        let labels3 = [model_type.to_string(), model_name.to_string()];
+        let labels3 = [model_type.to_string(), model_name.to_owned()];
         let label_refs3: Vec<&str> = labels3.iter().map(|s| s.as_str()).collect();
         self.model_confidence
             .with_label_values(&label_refs3)
@@ -416,7 +416,7 @@ impl MLMetricsCollector {
 
         let labels = [
             model_type.to_string(),
-            model_name.to_string(),
+            model_name.to_owned(),
             "failure".to_owned(),
         ];
         let label_refs: Vec<&str> = labels.iter().map(|s| s.as_str()).collect();
@@ -424,8 +424,8 @@ impl MLMetricsCollector {
 
         let labels2 = [
             model_type.to_string(),
-            model_name.to_string(),
-            error_type.to_string(),
+            model_name.to_owned(),
+            error_type.to_owned(),
         ];
         let label_refs2: Vec<&str> = labels2.iter().map(|s| s.as_str()).collect();
         self.failed_predictions
@@ -435,7 +435,7 @@ impl MLMetricsCollector {
 
     /// Update model health status
     pub fn update_model_status(&self, model_type: ModelType, model_name: &str, is_healthy: bool) {
-        let labels = [model_type.to_string(), model_name.to_string()];
+        let labels = [model_type.to_string(), model_name.to_owned()];
         let label_refs: Vec<&str> = labels.iter().map(|s| s.as_str()).collect();
         self.model_status
             .with_label_values(&label_refs)
@@ -459,8 +459,8 @@ impl MLMetricsCollector {
     ) {
         let labels = [
             model_type.to_string(),
-            model_name.to_string(),
-            feature_group.to_string(),
+            model_name.to_owned(),
+            feature_group.to_owned(),
         ];
         let label_refs: Vec<&str> = labels.iter().map(|s| s.as_str()).collect();
         self.drift_detection_score
@@ -538,22 +538,22 @@ impl MLMetricsCollector {
         }
     }
 
-    fn calculate_total_predictions(&self) -> u64 {
+    const fn calculate_total_predictions(&self) -> u64 {
         // This would sum all prediction counters - simplified for now
         0
     }
 
-    fn calculate_average_latency(&self) -> f64 {
+    const fn calculate_average_latency(&self) -> f64 {
         // This would calculate weighted average from histograms - simplified for now
         0.0
     }
 
-    fn calculate_error_rate(&self) -> f64 {
+    const fn calculate_error_rate(&self) -> f64 {
         // This would calculate error rate from counters - simplified for now
         0.0
     }
 
-    fn calculate_health_score(&self) -> f64 {
+    const fn calculate_health_score(&self) -> f64 {
         // This would calculate overall system health - simplified for now
         1.0
     }
@@ -663,7 +663,7 @@ impl MLPerformanceMonitor {
         }
     }
 
-    pub fn with_thresholds(mut self, thresholds: AlertThresholds) -> Self {
+    pub const fn with_thresholds(mut self, thresholds: AlertThresholds) -> Self {
         self.alert_thresholds = thresholds;
         self
     }
diff --git a/crates/ml-ppo/src/action_masking.rs b/crates/ml-ppo/src/action_masking.rs
index eb7a21dda..40bc7255a 100644
--- a/crates/ml-ppo/src/action_masking.rs
+++ b/crates/ml-ppo/src/action_masking.rs
@@ -14,7 +14,7 @@
 //!
 //! # 45-Action Factored Space (5 exposure × 3 order × 3 urgency):
 //! Index = exposure * 9 + order * 3 + urgency
-//! - exposure_idx = idx / 9
+//! - `exposure_idx` = idx / 9
 //!   - 0 = Short100 (indices 0..9)
 //!   - 1 = Short50  (indices 9..18)
 //!   - 2 = Flat     (indices 18..27)
@@ -34,7 +34,7 @@ use candle_core::{Result, Tensor};
 /// # Returns
 /// Boolean mask where:
 /// - `true` = action is valid (does not violate position limits)
-/// - `false` = action is invalid (would exceed max_position)
+/// - `false` = action is invalid (would exceed `max_position`)
 ///
 /// # Current Action Mapping (3 Actions):
 /// - 0 = BUY: Increase position by +1.0
@@ -42,15 +42,15 @@ use candle_core::{Result, Tensor};
 /// - 2 = HOLD: Keep position unchanged
 ///
 /// # Masking Logic:
-/// - Mask BUY if current_position + 1.0 > max_position
-/// - Mask SELL if current_position - 1.0 < -max_position
+/// - Mask BUY if `current_position` + 1.0 > `max_position`
+/// - Mask SELL if `current_position` - 1.0 < -`max_position`
 /// - HOLD is always valid
 ///
 /// # 45-Action Factored Space:
 /// Index = exposure * 9 + order * 3 + urgency (matches `FactoredAction::from_index`)
-/// - exposure_idx = idx / 9: 0=Short100, 1=Short50, 2=Flat, 3=Long50, 4=Long100
-/// - Long50/Long100 (indices 27..45) masked when current_position >= max_position
-/// - Short100/Short50 (indices 0..18) masked when current_position <= -max_position
+/// - `exposure_idx` = idx / 9: 0=Short100, 1=Short50, 2=Flat, 3=Long50, 4=Long100
+/// - Long50/Long100 (indices 27..45) masked when `current_position` >= `max_position`
+/// - Short100/Short50 (indices 0..18) masked when `current_position` <= -`max_position`
 /// - Flat (indices 18..27) always valid
 ///
 /// # Example
@@ -120,7 +120,7 @@ pub fn create_action_mask(current_position: f64, max_position: f64, num_actions:
 /// This ensures that after softmax, masked actions have probability ≈0.
 ///
 /// # Arguments
-/// * `logits` - Raw logits from policy network (shape: [num_actions])
+/// * `logits` - Raw logits from policy network (shape: [`num_actions`])
 /// * `mask` - Boolean mask where false = invalid action
 ///
 /// # Returns
diff --git a/crates/ml-ppo/src/action_space.rs b/crates/ml-ppo/src/action_space.rs
index 91fadde1f..d0bcfd842 100644
--- a/crates/ml-ppo/src/action_space.rs
+++ b/crates/ml-ppo/src/action_space.rs
@@ -42,23 +42,23 @@ pub enum ActionSpace {
     /// Continuous trading action (position sizing)
     ///
     /// Range: 0.0 to 1.0 (position size as fraction of capital)
-    /// Used by: ContinuousPPO (Gaussian policy network)
+    /// Used by: `ContinuousPPO` (Gaussian policy network)
     Continuous(ContinuousAction),
 }
 
 impl ActionSpace {
     /// Create discrete action from factored action
-    pub fn discrete(action: FactoredAction) -> Self {
+    pub const fn discrete(action: FactoredAction) -> Self {
         ActionSpace::Discrete(action)
     }
 
     /// Create continuous action from position size
-    pub fn continuous(action: ContinuousAction) -> Self {
+    pub const fn continuous(action: ContinuousAction) -> Self {
         ActionSpace::Continuous(action)
     }
 
     /// Get action type
-    pub fn action_type(&self) -> ActionType {
+    pub const fn action_type(&self) -> ActionType {
         match self {
             ActionSpace::Discrete(_) => ActionType::Discrete,
             ActionSpace::Continuous(_) => ActionType::Continuous,
@@ -119,7 +119,7 @@ impl ActionSpace {
     }
 
     /// Get discrete action (if applicable)
-    pub fn as_discrete(&self) -> Option<&FactoredAction> {
+    pub const fn as_discrete(&self) -> Option<&FactoredAction> {
         match self {
             ActionSpace::Discrete(action) => Some(action),
             ActionSpace::Continuous(_) => None,
@@ -127,7 +127,7 @@ impl ActionSpace {
     }
 
     /// Get continuous action (if applicable)
-    pub fn as_continuous(&self) -> Option<&ContinuousAction> {
+    pub const fn as_continuous(&self) -> Option<&ContinuousAction> {
         match self {
             ActionSpace::Discrete(_) => None,
             ActionSpace::Continuous(action) => Some(action),
diff --git a/crates/ml-ppo/src/adaptive_entropy.rs b/crates/ml-ppo/src/adaptive_entropy.rs
index dcf0c5d62..df82b3b0a 100644
--- a/crates/ml-ppo/src/adaptive_entropy.rs
+++ b/crates/ml-ppo/src/adaptive_entropy.rs
@@ -35,7 +35,7 @@ pub struct AdaptiveEntropyConfig {
     /// Initial entropy coefficient (will be tuned from here).
     /// Default: 0.05
     pub initial_alpha: f64,
-    /// Target entropy as fraction of max entropy (ln(num_actions)).
+    /// Target entropy as fraction of max entropy (`ln(num_actions)`).
     /// `target_entropy = target_ratio * ln(num_actions)` (positive).
     /// Default: 0.5
     pub target_ratio: f64,
@@ -74,7 +74,7 @@ impl Default for AdaptiveEntropyConfig {
 /// - When `H(pi) > target`: loss is positive, gradient pushes alpha down
 #[allow(missing_debug_implementations)]
 pub struct AdaptiveEntropyCoeff {
-    /// VarMap holding the learnable log(alpha) parameter
+    /// `VarMap` holding the learnable log(alpha) parameter
     vars: VarMap,
     /// Target entropy (positive for discrete actions, e.g., 1.904 for 45 actions)
     target_entropy: f64,
@@ -137,7 +137,7 @@ impl AdaptiveEntropyCoeff {
     /// Return the current entropy coefficient `alpha = exp(log_alpha)`.
     ///
     /// # Errors
-    /// Returns [`MLError`] if the VarMap lock is poisoned or the parameter is missing.
+    /// Returns [`MLError`] if the `VarMap` lock is poisoned or the parameter is missing.
     pub fn alpha(&self) -> Result<f64, MLError> {
         let log_alpha_tensor = self.get_log_alpha()?;
         // log_alpha has shape [1], squeeze to scalar
@@ -270,11 +270,11 @@ impl AdaptiveEntropyCoeff {
     }
 
     /// Return the target entropy value (positive for discrete actions).
-    pub fn target_entropy(&self) -> f64 {
+    pub const fn target_entropy(&self) -> f64 {
         self.target_entropy
     }
 
-    /// Helper: retrieve the log_alpha tensor from the VarMap.
+    /// Helper: retrieve the `log_alpha` tensor from the `VarMap`.
     fn get_log_alpha(&self) -> Result<Tensor, MLError> {
         let binding = self.vars.data().lock().map_err(|e| {
             MLError::LockError(format!("VarMap lock poisoned: {}", e))
diff --git a/crates/ml-ppo/src/composite_reward.rs b/crates/ml-ppo/src/composite_reward.rs
index f875be824..a3acfede6 100644
--- a/crates/ml-ppo/src/composite_reward.rs
+++ b/crates/ml-ppo/src/composite_reward.rs
@@ -1,7 +1,7 @@
 //! Composite risk-adjusted reward for PPO financial trading
 //!
 //! Combines multiple reward signals to balance return, risk, and drawdown:
-//! R = w1 * return_component - w2 * downside_risk + w3 * differential_return
+//! R = w1 * `return_component` - w2 * `downside_risk` + w3 * `differential_return`
 //!
 //! Research: Risk-Aware RL Reward (2025) — 42% return, 8% max drawdown.
 
diff --git a/crates/ml-ppo/src/continuous_action_masking.rs b/crates/ml-ppo/src/continuous_action_masking.rs
index 1bccb1b22..97b158e77 100644
--- a/crates/ml-ppo/src/continuous_action_masking.rs
+++ b/crates/ml-ppo/src/continuous_action_masking.rs
@@ -13,13 +13,13 @@
 //! # Constraint Types
 //!
 //! ## Hard Constraints (Clipping)
-//! - Absolute position limits: |position| ≤ max_position
+//! - Absolute position limits: |position| ≤ `max_position`
 //! - Enforced via action clipping: action = clamp(action, min, max)
 //! - Guarantees safety: constraint violations impossible
 //!
 //! ## Soft Constraints (Penalties)
 //! - Gradual discouragement near limits via penalty coefficient
-//! - Penalty = penalty_coeff × max(0, |action| - soft_threshold)²
+//! - Penalty = `penalty_coeff` × max(0, |action| - `soft_threshold)²`
 //! - Encourages staying away from hard limits (margin of safety)
 
 use candle_core::{Device, IndexOp, Tensor};
@@ -56,7 +56,7 @@ pub struct ContinuousActionConstraints {
     pub max_position: f32,
     /// Soft constraint penalty coefficient (0.0 = disabled, 1.0 = moderate, 10.0 = strong)
     pub penalty_coeff: f32,
-    /// Soft threshold as fraction of max_position (e.g., 0.8 = penalize beyond 80% of limit)
+    /// Soft threshold as fraction of `max_position` (e.g., 0.8 = penalize beyond 80% of limit)
     pub soft_threshold_fraction: f32,
 }
 
@@ -68,7 +68,7 @@ impl ContinuousActionConstraints {
     ///
     /// # Arguments
     ///
-    /// * `state` - State tensor (shape: [batch_size, state_dim])
+    /// * `state` - State tensor (shape: [`batch_size`, `state_dim`])
     /// * `max_position_abs` - Maximum position magnitude (e.g., 2.0)
     ///
     /// # Returns
@@ -79,8 +79,8 @@ impl ContinuousActionConstraints {
     ///
     /// Extract current position from state tensor (e.g., state[:, 0]) to compute
     /// asymmetric bounds based on current risk:
-    /// - If position = +1.5, max_long = +2.0, but max_short = -2.0
-    /// - If high volatility, reduce max_position dynamically
+    /// - If position = +1.5, `max_long` = +2.0, but `max_short` = -2.0
+    /// - If high volatility, reduce `max_position` dynamically
     pub fn from_state(state: &Tensor, max_position_abs: f32) -> Result<Self, MLError> {
         // Validate state shape (batch_size, state_dim)
         if state.dims().len() != 2 {
@@ -112,7 +112,7 @@ impl ContinuousActionConstraints {
     }
 
     /// Create with custom parameters
-    pub fn new(
+    pub const fn new(
         min_position: f32,
         max_position: f32,
         penalty_coeff: f32,
@@ -128,7 +128,7 @@ impl ContinuousActionConstraints {
 
     /// Apply hard constraint (clip action to valid range)
     ///
-    /// Guarantees that returned action is within [min_position, max_position].
+    /// Guarantees that returned action is within [`min_position`, `max_position`].
     /// Use this as final safety check before executing action.
     ///
     /// # Example
@@ -142,13 +142,13 @@ impl ContinuousActionConstraints {
     /// assert_eq!(constraints.clip_action(-3.0), -2.0); // Clamp to min
     /// assert_eq!(constraints.clip_action(1.0), 1.0);   // Within bounds
     /// ```
-    pub fn clip_action(&self, action: f32) -> f32 {
+    pub const fn clip_action(&self, action: f32) -> f32 {
         action.clamp(self.min_position, self.max_position)
     }
 
     /// Compute soft penalty for constraint violation
     ///
-    /// Encourages staying within soft_threshold via quadratic penalty.
+    /// Encourages staying within `soft_threshold` via quadratic penalty.
     /// Penalty increases as action approaches hard limit.
     ///
     /// # Formula
@@ -187,23 +187,23 @@ impl ContinuousActionConstraints {
 
     /// Adjust Gaussian distribution to respect constraints
     ///
-    /// Modifies mean and log_std to keep most of the distribution mass within valid bounds.
+    /// Modifies mean and `log_std` to keep most of the distribution mass within valid bounds.
     /// Uses truncation strategy: shift mean away from limits if too close.
     ///
     /// # Strategy
     ///
-    /// 1. If mean + 2σ > max_position: shift mean down to max_position - 2σ
-    /// 2. If mean - 2σ < min_position: shift mean up to min_position + 2σ
-    /// 3. If std too large: reduce to (max_position - min_position) / 4
+    /// 1. If mean + 2σ > `max_position`: shift mean down to `max_position` - 2σ
+    /// 2. If mean - 2σ < `min_position`: shift mean up to `min_position` + 2σ
+    /// 3. If std too large: reduce to (`max_position` - `min_position`) / 4
     ///
     /// # Arguments
     ///
-    /// * `mean` - Mean of Gaussian distribution (shape: [batch_size, 1])
-    /// * `log_std` - Log standard deviation (shape: [batch_size, 1])
+    /// * `mean` - Mean of Gaussian distribution (shape: [`batch_size`, 1])
+    /// * `log_std` - Log standard deviation (shape: [`batch_size`, 1])
     ///
     /// # Returns
     ///
-    /// Tuple of (adjusted_mean, adjusted_log_std)
+    /// Tuple of (`adjusted_mean`, `adjusted_log_std`)
     ///
     /// # Example
     ///
@@ -319,14 +319,14 @@ impl ContinuousActionConstraints {
 ///
 /// # Arguments
 ///
-/// * `mean` - Mean from policy network (shape: [batch_size, 1])
-/// * `log_std` - Log std from policy network (shape: [batch_size, 1])
+/// * `mean` - Mean from policy network (shape: [`batch_size`, 1])
+/// * `log_std` - Log std from policy network (shape: [`batch_size`, 1])
 /// * `constraints` - State-dependent constraints
 /// * `device` - Device for tensor operations
 ///
 /// # Returns
 ///
-/// Tuple of (masked_mean, masked_log_std) that respect constraints
+/// Tuple of (`masked_mean`, `masked_log_std`) that respect constraints
 ///
 /// # Usage in PPO Training
 ///
diff --git a/crates/ml-ppo/src/continuous_demo.rs b/crates/ml-ppo/src/continuous_demo.rs
index 44c532e63..068906623 100644
--- a/crates/ml-ppo/src/continuous_demo.rs
+++ b/crates/ml-ppo/src/continuous_demo.rs
@@ -9,7 +9,7 @@ use candle_core::{Device, Tensor};
 
 /// Simple demo showing Gaussian policy for continuous position sizing
 pub fn demo_continuous_position_sizing() -> Result<(), MLError> {
-    println!("🚀 Continuous Position Sizing Demo");
+    println!("\u{1f680} Continuous Position Sizing Demo");
 
     // Create configuration for continuous policy
     let config = ContinuousPolicyConfig {
@@ -25,29 +25,29 @@ pub fn demo_continuous_position_sizing() -> Result<(), MLError> {
     let device = Device::Cpu;
     let policy = ContinuousPolicyNetwork::new(config, device.clone())?;
 
-    println!("✅ Created continuous policy network");
+    println!("\u{2705} Created continuous policy network");
 
     // Demo different market conditions
     let market_scenarios = vec![
         (
-            "🐂 Bullish Market",
+            "\u{1f402} Bullish Market",
             vec![1.0, 0.1, 0.8, 0.02, 0.7, 0.1, 0.05, 0.3],
         ),
         (
-            "🐻 Bearish Market",
+            "\u{1f43b} Bearish Market",
             vec![0.2, 0.3, 0.3, 0.08, 0.2, -0.2, 0.03, 0.1],
         ),
         (
-            "📈 Volatile Market",
+            "\u{1f4c8} Volatile Market",
             vec![0.5, 0.8, 0.6, 0.15, 0.4, 0.0, 0.1, 0.5],
         ),
         (
-            "💤 Stable Market",
+            "\u{1f4a4} Stable Market",
             vec![0.6, 0.1, 0.9, 0.01, 0.5, 0.05, 0.02, 0.2],
         ),
     ];
 
-    println!("\n📊 Position Sizing Recommendations:");
+    println!("\n\u{1f4ca} Position Sizing Recommendations:");
 
     for (scenario_name, state_vec) in market_scenarios {
         let state_tensor =
@@ -94,7 +94,7 @@ pub fn demo_continuous_position_sizing() -> Result<(), MLError> {
     let entropy = policy.entropy(&test_state)?;
     let entropy_value = entropy.flatten_all()?.to_vec1::<f32>()?[0];
     println!(
-        "\n🎲 Current Exploration Level (Entropy): {:.3}",
+        "\n\u{1f3b2} Current Exploration Level (Entropy): {:.3}",
         entropy_value
     );
 
@@ -104,7 +104,7 @@ pub fn demo_continuous_position_sizing() -> Result<(), MLError> {
     let log_std_value = log_std.flatten_all()?.to_vec1::<f32>()?[0];
     let std_value = log_std_value.exp();
 
-    println!("📈 Policy Parameters for Test State:");
+    println!("\u{1f4c8} Policy Parameters for Test State:");
     println!("  Mean Position Size: {:.1}%", mean_value * 100.0);
     println!("  Standard Deviation: {:.3}", std_value);
 
@@ -113,7 +113,7 @@ pub fn demo_continuous_position_sizing() -> Result<(), MLError> {
 
 /// Demonstrate the difference between discrete and continuous actions
 pub fn compare_discrete_vs_continuous() -> Result<(), MLError> {
-    println!("\n🔄 Discrete vs Continuous Action Comparison");
+    println!("\n\u{1f504} Discrete vs Continuous Action Comparison");
 
     // Discrete actions (traditional approach)
     let discrete_actions = vec![
@@ -123,29 +123,29 @@ pub fn compare_discrete_vs_continuous() -> Result<(), MLError> {
         "Large (75%)",
         "Max (100%)",
     ];
-    println!("🎯 Discrete Actions Available:");
+    println!("\u{1f3af} Discrete Actions Available:");
     for (i, action) in discrete_actions.into_iter().enumerate() {
         println!("  Action {}: {}", i, action);
     }
 
     // Continuous actions (our approach)
-    println!("\n🌊 Continuous Actions Available:");
+    println!("\n\u{1f30a} Continuous Actions Available:");
     println!("  Any position size from 0.0% to 100.0%");
     println!("  Examples: 23.7%, 67.2%, 89.1%, 15.6%, 42.8%");
 
     // Benefits comparison
-    println!("\n✅ Benefits of Continuous Position Sizing:");
-    println!("  • Fine-grained control: Can size positions to exact risk tolerance");
-    println!("  • Adaptive: Policy learns optimal sizing for each market condition");
-    println!("  • Efficient: No need to discretize a naturally continuous problem");
-    println!("  • Gaussian exploration: Natural exploration around learned mean");
+    println!("\n\u{2705} Benefits of Continuous Position Sizing:");
+    println!("  \u{2022} Fine-grained control: Can size positions to exact risk tolerance");
+    println!("  \u{2022} Adaptive: Policy learns optimal sizing for each market condition");
+    println!("  \u{2022} Efficient: No need to discretize a naturally continuous problem");
+    println!("  \u{2022} Gaussian exploration: Natural exploration around learned mean");
 
     Ok(())
 }
 
 /// Example of how continuous policy integrates with trading system
 pub fn trading_integration_example() -> Result<(), MLError> {
-    println!("\n🏗️ Trading System Integration Example");
+    println!("\n\u{1f3d7}\u{fe0f} Trading System Integration Example");
 
     let config = ContinuousPolicyConfig {
         state_dim: 16,             // Richer state representation
@@ -188,12 +188,12 @@ pub fn trading_integration_example() -> Result<(), MLError> {
     let (action_value, log_prob) = policy.sample_action(&state_tensor)?;
     let recommended_position = ContinuousAction::new(action_value);
 
-    println!("📊 Trading State Analysis:");
+    println!("\u{1f4ca} Trading State Analysis:");
     println!("  Market Condition: Mixed signals with moderate volatility");
     println!("  Risk Level: Medium");
     println!("  Portfolio Status: 60% cash, 40% equity");
 
-    println!("\n🎯 AI Recommendation:");
+    println!("\n\u{1f3af} AI Recommendation:");
     println!(
         "  Position Size: {:.1}%",
         recommended_position.position_size() * 100.0
@@ -205,7 +205,7 @@ pub fn trading_integration_example() -> Result<(), MLError> {
     let position_value = portfolio_value * recommended_position.position_size();
     let shares_to_buy = (position_value / 150.0) as i32; // $150 per share
 
-    println!("\n💰 Trade Execution:");
+    println!("\n\u{1f4b0} Trade Execution:");
     println!("  Portfolio Value: ${:.0}", portfolio_value);
     println!("  Position Value: ${:.0}", position_value);
     println!("  Shares to Buy: {} shares", shares_to_buy);
diff --git a/crates/ml-ppo/src/continuous_policy.rs b/crates/ml-ppo/src/continuous_policy.rs
index b94fde0b2..499158b09 100644
--- a/crates/ml-ppo/src/continuous_policy.rs
+++ b/crates/ml-ppo/src/continuous_policy.rs
@@ -131,17 +131,17 @@ impl ContinuousPolicyNetwork {
         })
     }
 
-    /// Create continuous policy network from a VarBuilder (for loading checkpoints)
+    /// Create continuous policy network from a `VarBuilder` (for loading checkpoints)
     ///
     /// # Arguments
     ///
     /// * `config` - Continuous policy configuration
-    /// * `vb` - VarBuilder containing pre-trained weights
+    /// * `vb` - `VarBuilder` containing pre-trained weights
     /// * `device` - Device to load model on
     ///
     /// # Returns
     ///
-    /// ContinuousPolicyNetwork with loaded weights
+    /// `ContinuousPolicyNetwork` with loaded weights
     pub fn from_varbuilder(
         config: ContinuousPolicyConfig,
         vb: VarBuilder<'_>,
@@ -327,7 +327,7 @@ impl ContinuousPolicyNetwork {
         // Gaussian log probability formula
         let log_2pi = (2.0 * PI).ln();
         let log_2pi_tensor = Tensor::full(log_2pi, squared_diff.dims(), &self.device)
-            .map_err(|e| MLError::ModelError(format!("Failed to create log 2π tensor: {}", e)))?;
+            .map_err(|e| MLError::ModelError(format!("Failed to create log 2\u{3c0} tensor: {}", e)))?;
 
         let log_prob = (log_2pi_tensor * (-0.5))?
             .sub(&log_stds)?
@@ -370,17 +370,17 @@ impl ContinuousPolicyNetwork {
     }
 
     /// Get network variables
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Get device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 
     /// Get configuration
-    pub fn config(&self) -> &ContinuousPolicyConfig {
+    pub const fn config(&self) -> &ContinuousPolicyConfig {
         &self.config
     }
 
@@ -469,14 +469,14 @@ pub struct ContinuousAction {
 
 impl ContinuousAction {
     /// Create new continuous action
-    pub fn new(position_size: f32) -> Self {
+    pub const fn new(position_size: f32) -> Self {
         Self {
             position_size: position_size.clamp(0.0, 1.0),
         }
     }
 
     /// Get position size
-    pub fn position_size(&self) -> f32 {
+    pub const fn position_size(&self) -> f32 {
         self.position_size
     }
 
diff --git a/crates/ml-ppo/src/continuous_ppo.rs b/crates/ml-ppo/src/continuous_ppo.rs
index 85db47644..5b31a94b9 100644
--- a/crates/ml-ppo/src/continuous_ppo.rs
+++ b/crates/ml-ppo/src/continuous_ppo.rs
@@ -85,7 +85,7 @@ pub struct ContinuousTrajectoryStep {
 }
 
 impl ContinuousTrajectoryStep {
-    pub fn new(
+    pub const fn new(
         state: Vec<f32>,
         action: ContinuousAction,
         log_prob: f32,
@@ -110,8 +110,14 @@ pub struct ContinuousTrajectory {
     steps: Vec<ContinuousTrajectoryStep>,
 }
 
+impl Default for ContinuousTrajectory {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ContinuousTrajectory {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { steps: Vec::new() }
     }
 
@@ -673,24 +679,24 @@ impl ContinuousPPO {
     }
 
     /// Get training steps
-    pub fn get_training_steps(&self) -> u64 {
+    pub const fn get_training_steps(&self) -> u64 {
         self.training_steps
     }
 
     /// Get configuration
-    pub fn get_config(&self) -> &ContinuousPPOConfig {
+    pub const fn get_config(&self) -> &ContinuousPPOConfig {
         &self.config
     }
 
     /// Get current exploration parameter (log std)
-    /// Note: Flows don't have a log_std parameter - returns 0.0 for compatibility
-    pub fn get_exploration_param(&self, _state: &[f32]) -> Result<f32, MLError> {
+    /// Note: Flows don't have a `log_std` parameter - returns 0.0 for compatibility
+    pub const fn get_exploration_param(&self, _state: &[f32]) -> Result<f32, MLError> {
         Ok(0.0) // Flows don't have log_std
     }
 
     /// Set exploration parameter (for fixed std mode)
-    /// Note: No-op for flows as they don't have a log_std parameter
-    pub fn set_exploration_param(&mut self, _log_std: f32) -> Result<(), MLError> {
+    /// Note: No-op for flows as they don't have a `log_std` parameter
+    pub const fn set_exploration_param(&mut self, _log_std: f32) -> Result<(), MLError> {
         Ok(()) // No-op for flows
     }
 }
diff --git a/crates/ml-ppo/src/continuous_transaction_costs.rs b/crates/ml-ppo/src/continuous_transaction_costs.rs
index a6a256bf0..c1b6ae28a 100644
--- a/crates/ml-ppo/src/continuous_transaction_costs.rs
+++ b/crates/ml-ppo/src/continuous_transaction_costs.rs
@@ -13,8 +13,8 @@
 //! # Fee Structure (Aligned with DQN)
 //!
 //! - Market: 15 bps (0.15%) - Immediate execution, high cost
-//! - LimitMaker: 5 bps (0.05%) - Passive order, maker rebate
-//! - IoC: 10 bps (0.10%) - Immediate-or-cancel, medium cost
+//! - `LimitMaker`: 5 bps (0.05%) - Passive order, maker rebate
+//! - `IoC`: 10 bps (0.10%) - Immediate-or-cancel, medium cost
 
 pub use ml_core::action_space::OrderType;
 use serde::{Deserialize, Serialize};
@@ -66,18 +66,18 @@ pub enum SlippageModel {
     /// No slippage (theoretical)
     None,
 
-    /// Linear slippage: cost = slope × |position_change|
+    /// Linear slippage: cost = slope × |`position_change`|
     /// slope in bps per contract (e.g., 0.1 bps per contract)
     Linear { slope: f32 },
 
-    /// Quadratic slippage: cost = coefficient × |position_change|²
+    /// Quadratic slippage: cost = coefficient × |`position_change|²`
     /// coefficient in bps (e.g., 0.5 → 0.5 bps for 1 contract, 2 bps for 2 contracts)
     Quadratic { coefficient: f32 },
 }
 
 impl ContinuousTransactionCosts {
     /// Create new transaction cost model
-    pub fn new(
+    pub const fn new(
         base_cost_bps: f32,
         slippage_model: SlippageModel,
         order_type: OrderType,
@@ -161,13 +161,13 @@ impl ContinuousTransactionCosts {
 
     /// Compute cost gradient for backpropagation
     ///
-    /// Gradient of total cost w.r.t. position_change.
+    /// Gradient of total cost w.r.t. `position_change`.
     /// Useful for incorporating transaction costs into policy gradient.
     ///
     /// # Formula
     ///
-    /// For Linear slippage: d(cost)/d(pos) = contract_value × (base_bps + slope) / 10000
-    /// For Quadratic slippage: d(cost)/d(pos) = contract_value × (base_bps + 2 × coeff × |pos|) / 10000
+    /// For Linear slippage: d(cost)/d(pos) = `contract_value` × (`base_bps` + slope) / 10000
+    /// For Quadratic slippage: d(cost)/d(pos) = `contract_value` × (`base_bps` + 2 × coeff × |pos|) / 10000
     ///
     /// # Returns
     ///
@@ -225,7 +225,7 @@ impl ContinuousTransactionCosts {
 
 /// Default HFT cost model (aligned with DQN)
 ///
-/// Uses LimitMaker orders (5 bps) with linear slippage (0.1 bps/contract).
+/// Uses `LimitMaker` orders (5 bps) with linear slippage (0.1 bps/contract).
 /// Contract value: $5000 (ES futures).
 ///
 /// # Example
@@ -242,7 +242,7 @@ impl ContinuousTransactionCosts {
 /// let cost = costs.compute_cost(1.0, 0.0, 1.0);
 /// assert!((cost - 3.0).abs() < 0.1);
 /// ```
-pub fn default_hft_cost_model() -> ContinuousTransactionCosts {
+pub const fn default_hft_cost_model() -> ContinuousTransactionCosts {
     ContinuousTransactionCosts {
         base_cost_bps: 5.0, // LimitMaker (aligned with DQN)
         slippage_model: SlippageModel::Linear { slope: 0.1 },
@@ -254,7 +254,7 @@ pub fn default_hft_cost_model() -> ContinuousTransactionCosts {
 /// Conservative cost model (Market orders, quadratic slippage)
 ///
 /// Higher costs for realistic simulation of aggressive execution.
-pub fn conservative_cost_model() -> ContinuousTransactionCosts {
+pub const fn conservative_cost_model() -> ContinuousTransactionCosts {
     ContinuousTransactionCosts {
         base_cost_bps: 15.0, // Market orders
         slippage_model: SlippageModel::Quadratic { coefficient: 0.5 },
@@ -264,7 +264,7 @@ pub fn conservative_cost_model() -> ContinuousTransactionCosts {
 }
 
 /// Zero-cost model (for testing/ablation studies)
-pub fn zero_cost_model() -> ContinuousTransactionCosts {
+pub const fn zero_cost_model() -> ContinuousTransactionCosts {
     ContinuousTransactionCosts {
         base_cost_bps: 0.0,
         slippage_model: SlippageModel::None,
diff --git a/crates/ml-ppo/src/entropy_regularization.rs b/crates/ml-ppo/src/entropy_regularization.rs
index c146cbc08..aea2535d4 100644
--- a/crates/ml-ppo/src/entropy_regularization.rs
+++ b/crates/ml-ppo/src/entropy_regularization.rs
@@ -31,7 +31,7 @@ use ml_core::MLError;
 /// to encourage exploration and maintain action diversity.
 #[derive(Debug, Clone)]
 pub struct EntropyRegularizer {
-    /// Maximum possible entropy: log(num_actions)
+    /// Maximum possible entropy: `log(num_actions)`
     max_entropy: f64,
     /// Normalized entropy threshold (0.7) for bonus/penalty
     entropy_threshold: f64,
@@ -58,7 +58,7 @@ impl EntropyRegularizer {
     /// Calculate Shannon entropy from action probabilities
     ///
     /// # Arguments
-    /// * `action_probs` - Action probability tensor, shape [batch_size, num_actions] or [num_actions]
+    /// * `action_probs` - Action probability tensor, shape [`batch_size`, `num_actions`] or [`num_actions`]
     ///
     /// # Returns
     /// Raw Shannon entropy H(π) = -Σ π(a|s) * log(π(a|s))
@@ -95,7 +95,7 @@ impl EntropyRegularizer {
     /// Calculate entropy bonus/penalty from action probabilities
     ///
     /// # Arguments
-    /// * `action_probs` - Action probability tensor, shape [batch_size, num_actions] or [num_actions]
+    /// * `action_probs` - Action probability tensor, shape [`batch_size`, `num_actions`] or [`num_actions`]
     ///
     /// # Returns
     /// - Positive value: Bonus for high entropy (> 0.7 normalized)
diff --git a/crates/ml-ppo/src/flow_policy/coupling_layer.rs b/crates/ml-ppo/src/flow_policy/coupling_layer.rs
index 136552fdb..1f47f66c4 100644
--- a/crates/ml-ppo/src/flow_policy/coupling_layer.rs
+++ b/crates/ml-ppo/src/flow_policy/coupling_layer.rs
@@ -51,7 +51,7 @@ impl AffineCouplingLayer {
     /// * `context_dim` - Dimension of context (state) input
     /// * `scale_clamp` - Maximum absolute value for scale network output (typically 5.0)
     /// * `mask_vec` - Binary mask vector indicating which dimensions to transform
-    /// * `vb` - VarBuilder for parameter initialization
+    /// * `vb` - `VarBuilder` for parameter initialization
     ///
     /// # Returns
     /// Initialized coupling layer or error
@@ -122,7 +122,7 @@ impl AffineCouplingLayer {
     /// * `context_dim` - Dimension of context (state) input
     /// * `scale_clamp` - Maximum absolute value for scale network output
     /// * `mask_vec` - Binary mask vector
-    /// * `vb` - VarBuilder pointing to saved parameters
+    /// * `vb` - `VarBuilder` pointing to saved parameters
     pub(super) fn from_varbuilder(
         action_dim: usize,
         context_dim: usize,
@@ -167,8 +167,8 @@ impl AffineCouplingLayer {
     /// Forward transformation: x -> y
     ///
     /// # Arguments
-    /// * `x` - Input tensor [batch_size, action_dim]
-    /// * `ctx` - Context tensor [batch_size, context_dim] (typically state)
+    /// * `x` - Input tensor [`batch_size`, `action_dim`]
+    /// * `ctx` - Context tensor [`batch_size`, `context_dim`] (typically state)
     ///
     /// # Returns
     /// Tuple of (transformed output, log determinant of Jacobian)
@@ -208,8 +208,8 @@ impl AffineCouplingLayer {
     /// Inverse transformation: y -> x
     ///
     /// # Arguments
-    /// * `y` - Transformed tensor [batch_size, action_dim]
-    /// * `ctx` - Context tensor [batch_size, context_dim]
+    /// * `y` - Transformed tensor [`batch_size`, `action_dim`]
+    /// * `ctx` - Context tensor [`batch_size`, `context_dim`]
     ///
     /// # Returns
     /// Tuple of (original input, log determinant of inverse Jacobian)
diff --git a/crates/ml-ppo/src/flow_policy/mod.rs b/crates/ml-ppo/src/flow_policy/mod.rs
index 625f4c024..851020999 100644
--- a/crates/ml-ppo/src/flow_policy/mod.rs
+++ b/crates/ml-ppo/src/flow_policy/mod.rs
@@ -20,10 +20,10 @@ use ml_core::MLError;
 /// log |det(da/dy)| = log(1 - a²) = log((1-a)(1+a))
 ///
 /// # Arguments
-/// * `action` - Squashed action tensor in [-1, 1], shape [batch_size, action_dim].
+/// * `action` - Squashed action tensor in [-1, 1], shape [`batch_size`, `action_dim`].
 ///
 /// # Returns
-/// Log-determinant tensor [batch_size].
+/// Log-determinant tensor [`batch_size`].
 fn tanh_logdet_from_action(action: &Tensor) -> Result<Tensor, MLError> {
     // Clamp action to prevent log(0) at boundaries
     let a_clamped = action
@@ -78,9 +78,9 @@ impl Default for FlowPolicyConfig {
 /// with proper log-determinant corrections for probability density.
 ///
 /// # Architecture
-/// - Context encoder: Linear(state_dim → context_dim) + Tanh
-/// - Flow layers: 4 AffineCouplingLayer blocks with alternating masks
-/// - Action squashing: tanh(flow_output) with log-det correction
+/// - Context encoder: `Linear(state_dim` → `context_dim`) + Tanh
+/// - Flow layers: 4 `AffineCouplingLayer` blocks with alternating masks
+/// - Action squashing: `tanh(flow_output)` with log-det correction
 ///
 /// # Example
 /// ```ignore
@@ -96,7 +96,7 @@ pub struct FlowPolicy {
     layers: Vec<AffineCouplingLayer>,
     /// Configuration parameters.
     config: FlowPolicyConfig,
-    /// VarMap for weight storage (used for checkpointing).
+    /// `VarMap` for weight storage (used for checkpointing).
     vars: VarMap,
     /// Device for computation (CPU/CUDA).
     device: Device,
@@ -113,14 +113,14 @@ impl std::fmt::Debug for FlowPolicy {
 }
 
 impl FlowPolicy {
-    /// Creates a new FlowPolicy with Xavier-initialized weights.
+    /// Creates a new `FlowPolicy` with Xavier-initialized weights.
     ///
     /// # Arguments
     /// * `config` - Configuration specifying network dimensions.
     /// * `device` - Device for tensor operations.
     ///
     /// # Returns
-    /// A new FlowPolicy instance or an error if initialization fails.
+    /// A new `FlowPolicy` instance or an error if initialization fails.
     pub fn new(config: FlowPolicyConfig, device: &Device) -> Result<Self, MLError> {
         let vars = VarMap::new();
         let vb = VarBuilder::from_varmap(&vars, training_dtype(device), device);
@@ -158,7 +158,7 @@ impl FlowPolicy {
         })
     }
 
-    /// Creates a FlowPolicy with explicit state and action dimensions.
+    /// Creates a `FlowPolicy` with explicit state and action dimensions.
     ///
     /// This is a convenience constructor that overrides config dimensions.
     ///
@@ -178,11 +178,11 @@ impl FlowPolicy {
         Self::new(config, device)
     }
 
-    /// Loads a FlowPolicy from a VarBuilder (for checkpoint restoration).
+    /// Loads a `FlowPolicy` from a `VarBuilder` (for checkpoint restoration).
     ///
     /// # Arguments
     /// * `config` - Configuration matching the saved model.
-    /// * `vb` - VarBuilder containing saved weights.
+    /// * `vb` - `VarBuilder` containing saved weights.
     /// * `device` - Device for computation.
     pub fn from_varbuilder(
         config: FlowPolicyConfig,
@@ -231,13 +231,13 @@ impl FlowPolicy {
     /// 2. Sample z ~ N(0, 1)
     /// 3. Transform z → y via coupling layers
     /// 4. Squash y → a via tanh
-    /// 5. Compute log_prob with flow + squashing corrections
+    /// 5. Compute `log_prob` with flow + squashing corrections
     ///
     /// # Arguments
-    /// * `state` - Input state tensor [batch_size, state_dim] or [state_dim].
+    /// * `state` - Input state tensor [`batch_size`, `state_dim`] or [`state_dim`].
     ///
     /// # Returns
-    /// Tuple of (action, log_prob) tensors, both shape [batch_size, action_dim].
+    /// Tuple of (action, `log_prob`) tensors, both shape [`batch_size`, `action_dim`].
     pub fn sample_action(&self, state: &Tensor) -> Result<(Tensor, Tensor), MLError> {
         // Ensure state has batch dimension
         let state = if state.dims().len() == 1 {
@@ -292,15 +292,15 @@ impl FlowPolicy {
         Ok((a, log_prob))
     }
 
-    /// Batch sampling: returns (actions, log_probs) as tensors.
+    /// Batch sampling: returns (actions, `log_probs`) as tensors.
     ///
     /// This is equivalent to `sample_action` but emphasizes batch processing.
     ///
     /// # Arguments
-    /// * `state` - Batch of states [batch_size, state_dim].
+    /// * `state` - Batch of states [`batch_size`, `state_dim`].
     ///
     /// # Returns
-    /// Tuple of (actions, log_probs) tensors.
+    /// Tuple of (actions, `log_probs`) tensors.
     pub fn forward(&self, state: &Tensor) -> Result<(Tensor, Tensor), MLError> {
         self.sample_action(state)
     }
@@ -313,14 +313,14 @@ impl FlowPolicy {
     /// 1. Encode state → context
     /// 2. Unsquash action: a → y = atanh(a)
     /// 3. Inverse flow: y → z
-    /// 4. Compute log_prob = log p(z) - log_det_flow - log_det_squash
+    /// 4. Compute `log_prob` = log p(z) - `log_det_flow` - `log_det_squash`
     ///
     /// # Arguments
-    /// * `states` - Batch of states [batch_size, state_dim].
-    /// * `actions` - Batch of actions [batch_size, action_dim] in [-1, 1].
+    /// * `states` - Batch of states [`batch_size`, `state_dim`].
+    /// * `actions` - Batch of actions [`batch_size`, `action_dim`] in [-1, 1].
     ///
     /// # Returns
-    /// Log probabilities [batch_size, action_dim].
+    /// Log probabilities [`batch_size`, `action_dim`].
     pub fn evaluate_actions(
         &self,
         states: &Tensor,
@@ -386,10 +386,10 @@ impl FlowPolicy {
     /// computing the negative mean log-probability.
     ///
     /// # Arguments
-    /// * `states` - Batch of states [batch_size, state_dim].
+    /// * `states` - Batch of states [`batch_size`, `state_dim`].
     ///
     /// # Returns
-    /// Entropy estimate tensor [batch_size].
+    /// Entropy estimate tensor [`batch_size`].
     pub fn entropy(&self, states: &Tensor) -> Result<Tensor, MLError> {
         // Sample actions and get log_probs: shape [batch_size, 1]
         let (_actions, log_probs) = self.sample_action(states)?;
@@ -405,10 +405,10 @@ impl FlowPolicy {
     /// Encodes state into context vector for conditioning the flow.
     ///
     /// # Arguments
-    /// * `state` - Input state [batch_size, state_dim].
+    /// * `state` - Input state [`batch_size`, `state_dim`].
     ///
     /// # Returns
-    /// Context tensor [batch_size, context_dim].
+    /// Context tensor [`batch_size`, `context_dim`].
     fn encode_context(&self, state: &Tensor) -> Result<Tensor, MLError> {
         let h = self.context_enc.forward(state).map_err(|e| {
             MLError::TensorOperationError(format!("Context encoder forward failed: {}", e))
@@ -420,11 +420,11 @@ impl FlowPolicy {
     /// Forward flow transformation: z → y through coupling layers.
     ///
     /// # Arguments
-    /// * `z` - Base noise [batch_size, action_dim].
-    /// * `ctx` - Context conditioning [batch_size, context_dim].
+    /// * `z` - Base noise [`batch_size`, `action_dim`].
+    /// * `ctx` - Context conditioning [`batch_size`, `context_dim`].
     ///
     /// # Returns
-    /// Tuple of (y, log_det_jacobian).
+    /// Tuple of (y, `log_det_jacobian`).
     fn flow_forward(&self, z: &Tensor, ctx: &Tensor) -> Result<(Tensor, Tensor), MLError> {
         let mut x = z.clone();
         let batch_size = z.dims()[0];
@@ -445,11 +445,11 @@ impl FlowPolicy {
     /// Inverse flow transformation: y → z through coupling layers (reversed).
     ///
     /// # Arguments
-    /// * `y` - Flow output [batch_size, action_dim].
-    /// * `ctx` - Context conditioning [batch_size, context_dim].
+    /// * `y` - Flow output [`batch_size`, `action_dim`].
+    /// * `ctx` - Context conditioning [`batch_size`, `context_dim`].
     ///
     /// # Returns
-    /// Tuple of (z, log_det_jacobian).
+    /// Tuple of (z, `log_det_jacobian`).
     fn flow_inverse(&self, y: &Tensor, ctx: &Tensor) -> Result<(Tensor, Tensor), MLError> {
         let mut x = y.clone();
         let batch_size = y.dims()[0];
@@ -474,7 +474,7 @@ impl FlowPolicy {
     /// * `batch_size` - Number of samples to generate.
     ///
     /// # Returns
-    /// Noise tensor [batch_size, action_dim].
+    /// Noise tensor [`batch_size`, `action_dim`].
     fn sample_base_noise(&self, batch_size: usize) -> Result<Tensor, MLError> {
         let normal = Normal::new(0.0_f32, 1.0_f32).map_err(|e| {
             MLError::TensorOperationError(format!("Normal distribution creation failed: {}", e))
@@ -499,37 +499,37 @@ impl FlowPolicy {
     /// * `layer_idx` - Index of the layer (0-indexed).
     ///
     /// # Returns
-    /// Mask vector [action_dim] with values in {0, 1}.
+    /// Mask vector [`action_dim`] with values in {0, 1}.
     fn make_mask(action_dim: usize, layer_idx: usize) -> Vec<f32> {
         let mask_value = if layer_idx % 2 == 0 { 0.0_f32 } else { 1.0_f32 };
         vec![mask_value; action_dim]
     }
 
-    /// Returns reference to VarMap (for checkpoint saving).
-    pub fn vars(&self) -> &VarMap {
+    /// Returns reference to `VarMap` (for checkpoint saving).
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Returns reference to device.
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 
     /// Returns reference to configuration.
-    pub fn config(&self) -> &FlowPolicyConfig {
+    pub const fn config(&self) -> &FlowPolicyConfig {
         &self.config
     }
 
-    /// Compatibility shim: returns dummy log_std (not applicable to flows).
+    /// Compatibility shim: returns dummy `log_std` (not applicable to flows).
     ///
-    /// Normalizing flows don't have a fixed log_std parameter like Gaussian policies.
+    /// Normalizing flows don't have a fixed `log_std` parameter like Gaussian policies.
     /// Returns zeros for API compatibility with existing PPO code.
     pub fn get_current_log_std(&self) -> Result<Tensor, MLError> {
         Tensor::zeros(self.config.action_dim, training_dtype(&self.device), &self.device)
             .map_err(|e| MLError::TensorOperationError(format!("Log std creation failed: {}", e)))
     }
 
-    /// Compatibility shim: no-op for flows (log_std not applicable).
+    /// Compatibility shim: no-op for flows (`log_std` not applicable).
     pub fn set_log_std(&mut self, _log_std: Tensor) -> Result<(), MLError> {
         // No-op: flows don't have a log_std parameter
         Ok(())
diff --git a/crates/ml-ppo/src/gae.rs b/crates/ml-ppo/src/gae.rs
index 0c6177d38..8b649706b 100644
--- a/crates/ml-ppo/src/gae.rs
+++ b/crates/ml-ppo/src/gae.rs
@@ -32,8 +32,8 @@ impl Default for GAEConfig {
 /// Compute GAE advantages for a single trajectory
 ///
 /// GAE(γ, λ) computes advantages as:
-/// A_t = δ_t + (γλ)δ_{t+1} + (γλ)^2δ_{t+2} + ...
-/// where δ_t = r_t + γV(s_{t+1}) - V(s_t)
+/// `A_t` = `δ_t` + (γλ)δ_{t+1} + (γλ)^2δ_{t+2} + ...
+/// where `δ_t` = `r_t` + γV(s_{t+1}) - `V(s_t)`
 pub fn compute_gae_single_trajectory(
     rewards: &[f32],
     values: &[f32],
@@ -181,7 +181,7 @@ pub fn compute_discounted_returns(
 }
 
 /// Compute temporal difference (TD) advantages
-/// A_t = r_t + γV(s_{t+1}) - V(s_t)
+/// `A_t` = `r_t` + γV(s_{t+1}) - `V(s_t)`
 pub fn compute_td_advantages(
     trajectories: &[Trajectory],
     gamma: f32,
diff --git a/crates/ml-ppo/src/hidden_state_manager.rs b/crates/ml-ppo/src/hidden_state_manager.rs
index f044c24a3..f39ed911c 100644
--- a/crates/ml-ppo/src/hidden_state_manager.rs
+++ b/crates/ml-ppo/src/hidden_state_manager.rs
@@ -1,6 +1,6 @@
 //! Hidden State Management for Recurrent PPO
 //!
-//! Manages LSTM hidden states (h_t, c_t) across timesteps and episodes.
+//! Manages LSTM hidden states (`h_t`, `c_t`) across timesteps and episodes.
 //! States persist within episodes but reset at episode boundaries.
 
 use candle_core::{Device, Tensor};
@@ -12,13 +12,13 @@ use ml_core::mixed_precision::training_dtype;
 
 /// Manages LSTM hidden and cell states for policy and value networks
 pub struct HiddenStateManager {
-    /// Policy network hidden state [num_layers, batch_size, hidden_dim]
+    /// Policy network hidden state [`num_layers`, `batch_size`, `hidden_dim`]
     policy_hidden: Tensor,
-    /// Policy network cell state [num_layers, batch_size, hidden_dim]
+    /// Policy network cell state [`num_layers`, `batch_size`, `hidden_dim`]
     policy_cell: Tensor,
-    /// Value network hidden state [num_layers, batch_size, hidden_dim]
+    /// Value network hidden state [`num_layers`, `batch_size`, `hidden_dim`]
     value_hidden: Tensor,
-    /// Value network cell state [num_layers, batch_size, hidden_dim]
+    /// Value network cell state [`num_layers`, `batch_size`, `hidden_dim`]
     value_cell: Tensor,
     /// Device for tensor operations
     device: Device,
@@ -71,8 +71,8 @@ impl HiddenStateManager {
     /// Update policy network states
     ///
     /// # Arguments
-    /// * `hidden` - New hidden state [num_layers, batch_size, hidden_dim]
-    /// * `cell` - New cell state [num_layers, batch_size, hidden_dim]
+    /// * `hidden` - New hidden state [`num_layers`, `batch_size`, `hidden_dim`]
+    /// * `cell` - New cell state [`num_layers`, `batch_size`, `hidden_dim`]
     pub fn update_policy_state(&mut self, hidden: Tensor, cell: Tensor) -> Result<(), MLError> {
         // Validate shapes
         let expected_shape = &[self.num_layers, self.batch_size, self.hidden_dim];
@@ -99,8 +99,8 @@ impl HiddenStateManager {
     /// Update value network states
     ///
     /// # Arguments
-    /// * `hidden` - New hidden state [num_layers, batch_size, hidden_dim]
-    /// * `cell` - New cell state [num_layers, batch_size, hidden_dim]
+    /// * `hidden` - New hidden state [`num_layers`, `batch_size`, `hidden_dim`]
+    /// * `cell` - New cell state [`num_layers`, `batch_size`, `hidden_dim`]
     pub fn update_value_state(&mut self, hidden: Tensor, cell: Tensor) -> Result<(), MLError> {
         // Validate shapes
         let expected_shape = &[self.num_layers, self.batch_size, self.hidden_dim];
@@ -127,10 +127,10 @@ impl HiddenStateManager {
     /// Reset states for done environments
     ///
     /// # Arguments
-    /// * `done_mask` - Boolean mask [batch_size] where 1 = episode done, 0 = continue
+    /// * `done_mask` - Boolean mask [`batch_size`] where 1 = episode done, 0 = continue
     pub fn reset_on_done(&mut self, done_mask: &Tensor) -> Result<(), MLError> {
         // Validate done_mask shape
-        if done_mask.dims() != &[self.batch_size] {
+        if done_mask.dims() != [self.batch_size] {
             return Err(MLError::InvalidInput(format!(
                 "Invalid done mask shape. Expected [{}], got {:?}",
                 self.batch_size,
diff --git a/crates/ml-ppo/src/lstm_networks.rs b/crates/ml-ppo/src/lstm_networks.rs
index 2ec2a86b6..a4fd4d145 100644
--- a/crates/ml-ppo/src/lstm_networks.rs
+++ b/crates/ml-ppo/src/lstm_networks.rs
@@ -14,7 +14,7 @@ use ml_core::MLError;
 
 /// LSTM-augmented policy network for temporal action selection
 ///
-/// Architecture: MLP → LSTM → Linear(hidden_dim, num_actions)
+/// Architecture: MLP → LSTM → `Linear(hidden_dim`, `num_actions`)
 #[allow(missing_debug_implementations)]
 pub struct LSTMPolicyNetwork {
     /// Input projection layer (maps state to LSTM input dimension)
@@ -159,18 +159,18 @@ impl LSTMPolicyNetwork {
         Ok((logits, new_h, new_c))
     }
 
-    /// Reconstruct an LSTM policy network from a VarBuilder (checkpoint loading)
+    /// Reconstruct an LSTM policy network from a `VarBuilder` (checkpoint loading)
     ///
     /// This loads network weights from a safetensors checkpoint. LSTM hidden/cell
     /// states are NOT saved in checkpoints -- they are re-initialized to zeros on load.
     ///
     /// # Arguments
     /// * `config` - PPO configuration (must match the config used during training)
-    /// * `vb` - VarBuilder backed by loaded safetensors checkpoint
+    /// * `vb` - `VarBuilder` backed by loaded safetensors checkpoint
     /// * `device` - Device to load model on
     ///
     /// # Returns
-    /// LSTMPolicyNetwork with restored weights, or error if checkpoint structure
+    /// `LSTMPolicyNetwork` with restored weights, or error if checkpoint structure
     /// doesn't match config
     pub fn from_varbuilder(
         config: &super::ppo::PPOConfig,
@@ -213,19 +213,19 @@ impl LSTMPolicyNetwork {
     }
 
     /// Get network variables
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Get device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 }
 
 /// LSTM-augmented value network for temporal state value estimation
 ///
-/// Architecture: MLP → LSTM → Linear(hidden_dim, 1)
+/// Architecture: MLP → LSTM → `Linear(hidden_dim`, 1)
 #[allow(missing_debug_implementations)]
 pub struct LSTMValueNetwork {
     /// Input projection layer (maps state to LSTM input dimension)
@@ -372,18 +372,18 @@ impl LSTMValueNetwork {
         Ok((value, new_h, new_c))
     }
 
-    /// Reconstruct an LSTM value network from a VarBuilder (checkpoint loading)
+    /// Reconstruct an LSTM value network from a `VarBuilder` (checkpoint loading)
     ///
     /// This loads network weights from a safetensors checkpoint. LSTM hidden/cell
     /// states are NOT saved in checkpoints -- they are re-initialized to zeros on load.
     ///
     /// # Arguments
     /// * `config` - PPO configuration (must match the config used during training)
-    /// * `vb` - VarBuilder backed by loaded safetensors checkpoint
+    /// * `vb` - `VarBuilder` backed by loaded safetensors checkpoint
     /// * `device` - Device to load model on
     ///
     /// # Returns
-    /// LSTMValueNetwork with restored weights, or error if checkpoint structure
+    /// `LSTMValueNetwork` with restored weights, or error if checkpoint structure
     /// doesn't match config
     pub fn from_varbuilder(
         config: &super::ppo::PPOConfig,
@@ -425,12 +425,12 @@ impl LSTMValueNetwork {
     }
 
     /// Get network variables
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Get device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 }
diff --git a/crates/ml-ppo/src/percentile_scaler.rs b/crates/ml-ppo/src/percentile_scaler.rs
index 37d04985e..e159f13ea 100644
--- a/crates/ml-ppo/src/percentile_scaler.rs
+++ b/crates/ml-ppo/src/percentile_scaler.rs
@@ -1,4 +1,4 @@
-//! Percentile-based advantage scaling (DreamerV3)
+//! Percentile-based advantage scaling (`DreamerV3`)
 //!
 //! Tracks running P5/P95 of returns with EMA decay.
 //! More robust than standard-deviation-based normalization for heavy-tailed
@@ -10,7 +10,7 @@
 //! suppress the scaling of typical returns. Percentile ranges are robust to outliers.
 //!
 //! # References
-//! - Hafner et al., "Mastering Diverse Domains through World Models" (DreamerV3, 2023)
+//! - Hafner et al., "Mastering Diverse Domains through World Models" (`DreamerV3`, 2023)
 
 use serde::{Deserialize, Serialize};
 
@@ -45,7 +45,7 @@ impl PercentileScaler {
     /// - `decay`: 0.99 (slow adaptation, stable estimates)
     /// - `min_scale`: 1.0 (prevents division by zero for constant data)
     #[must_use]
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             p5: 0.0,
             p95: 0.0,
@@ -62,7 +62,7 @@ impl PercentileScaler {
     ///   Typical: 0.99 (stable) to 0.95 (reactive).
     /// - `min_scale`: Minimum P95-P5 range to prevent divide-by-zero.
     #[must_use]
-    pub fn with_params(decay: f64, min_scale: f64) -> Self {
+    pub const fn with_params(decay: f64, min_scale: f64) -> Self {
         Self {
             p5: 0.0,
             p95: 0.0,
@@ -162,19 +162,19 @@ impl PercentileScaler {
 
     /// Get the current P5 estimate.
     #[must_use]
-    pub fn p5(&self) -> f64 {
+    pub const fn p5(&self) -> f64 {
         self.p5
     }
 
     /// Get the current P95 estimate.
     #[must_use]
-    pub fn p95(&self) -> f64 {
+    pub const fn p95(&self) -> f64 {
         self.p95
     }
 
     /// Whether the scaler has been initialized with at least one batch.
     #[must_use]
-    pub fn is_initialized(&self) -> bool {
+    pub const fn is_initialized(&self) -> bool {
         self.initialized
     }
 }
diff --git a/crates/ml-ppo/src/portfolio_tracker.rs b/crates/ml-ppo/src/portfolio_tracker.rs
index 528843808..07dd78c8e 100644
--- a/crates/ml-ppo/src/portfolio_tracker.rs
+++ b/crates/ml-ppo/src/portfolio_tracker.rs
@@ -5,10 +5,10 @@
 //! - Position size (signed: +Long, -Short, 0 for flat)
 //! - Bid-ask spread (for transaction costs)
 //!
-//! The PortfolioTracker is used by PPO trainers to provide portfolio features
+//! The `PortfolioTracker` is used by PPO trainers to provide portfolio features
 //! to the reward function, enabling P&L-based reward calculations.
 //!
-//! This implementation is adapted from DQN's PortfolioTracker to work with
+//! This implementation is adapted from DQN's `PortfolioTracker` to work with
 //! PPO's action space (simple usize indices: 0=BUY, 1=SELL, 2=HOLD).
 
 use tracing::warn;
@@ -30,7 +30,7 @@ pub struct PortfolioTracker {
     initial_capital: f32,
     /// Average bid-ask spread (estimated from historical data)
     avg_spread: f32,
-    /// Last observed price (for parameter-less total_value() calls)
+    /// Last observed price (for parameter-less `total_value()` calls)
     last_price: f32,
     /// Cash reserve requirement as percentage of portfolio value (0-100)
     cash_reserve_percent: f32,
@@ -54,7 +54,7 @@ impl PortfolioTracker {
     ///
     /// let tracker = PortfolioTracker::new(10_000.0, 0.0001, 0.0);
     /// ```
-    pub fn new(initial_capital: f32, avg_spread: f32, cash_reserve_percent: f64) -> Self {
+    pub const fn new(initial_capital: f32, avg_spread: f32, cash_reserve_percent: f64) -> Self {
         Self {
             cash: initial_capital,
             position_size: 0.0,
@@ -83,7 +83,7 @@ impl PortfolioTracker {
     ///
     /// let tracker = PortfolioTracker::with_default_spread(10_000.0);
     /// ```
-    pub fn with_default_spread(initial_capital: f32) -> Self {
+    pub const fn with_default_spread(initial_capital: f32) -> Self {
         Self::new(initial_capital, 0.0001, 0.0)
     }
 
@@ -287,7 +287,7 @@ impl PortfolioTracker {
         self.position_entry_price = 0.0;
 
         warn!(
-            "P2-R: Phase 1 complete - Closed position {:.2} → 0.0, Cash: ${:.2}",
+            "P2-R: Phase 1 complete - Closed position {:.2} \u{2192} 0.0, Cash: ${:.2}",
             old_position, self.cash
         );
 
@@ -377,7 +377,7 @@ impl PortfolioTracker {
     /// assert_eq!(tracker.cash_balance(), 10_000.0);
     /// assert_eq!(tracker.current_position(), 0.0);
     /// ```
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.cash = self.initial_capital;
         self.position_size = 0.0;
         self.position_entry_price = 0.0;
@@ -392,7 +392,7 @@ impl PortfolioTracker {
     /// # Returns
     ///
     /// Current cash balance (may be negative if leveraged)
-    pub fn cash_balance(&self) -> f32 {
+    pub const fn cash_balance(&self) -> f32 {
         self.cash
     }
 
@@ -401,7 +401,7 @@ impl PortfolioTracker {
     /// # Returns
     ///
     /// Current position size (positive = long, negative = short, 0 = flat)
-    pub fn current_position(&self) -> f32 {
+    pub const fn current_position(&self) -> f32 {
         self.position_size
     }
 
@@ -426,7 +426,7 @@ impl PortfolioTracker {
     /// # Returns
     ///
     /// Average entry price (0.0 if no position)
-    pub fn average_entry_price(&self) -> f32 {
+    pub const fn average_entry_price(&self) -> f32 {
         self.position_entry_price
     }
 
@@ -464,7 +464,7 @@ impl PortfolioTracker {
     /// # Returns
     ///
     /// Total transaction costs incurred across all trades
-    pub fn transaction_costs(&self) -> f32 {
+    pub const fn transaction_costs(&self) -> f32 {
         self.cumulative_transaction_costs
     }
 }
diff --git a/crates/ml-ppo/src/position_limits.rs b/crates/ml-ppo/src/position_limits.rs
index b7728b77d..61210c971 100644
--- a/crates/ml-ppo/src/position_limits.rs
+++ b/crates/ml-ppo/src/position_limits.rs
@@ -4,7 +4,7 @@
 //! and maintain minimum cash reserves.
 //!
 //! # Risk Management Rules
-//! 1. **Position Limits**: Prevent position from exceeding max_position (e.g., ±2.0)
+//! 1. **Position Limits**: Prevent position from exceeding `max_position` (e.g., ±2.0)
 //! 2. **Cash Reserves**: Maintain minimum cash percentage (e.g., 20%)
 //! 3. **Risk Reduction**: Always allow actions that reduce risk (move towards zero)
 
@@ -45,7 +45,7 @@
 ///
 /// - Position changes that reduce risk are always allowed (e.g., reducing from 2.5 to 2.0)
 /// - Zero delta (hold) is always allowed
-/// - Position limit is enforced on absolute value: |new_position| <= max_position
+/// - Position limit is enforced on absolute value: |`new_position`| <= `max_position`
 pub fn enforce_position_limit(
     current_position: f64,
     proposed_delta: f64,
diff --git a/crates/ml-ppo/src/ppo.rs b/crates/ml-ppo/src/ppo.rs
index fe12569c5..1fec1b33a 100644
--- a/crates/ml-ppo/src/ppo.rs
+++ b/crates/ml-ppo/src/ppo.rs
@@ -51,14 +51,14 @@ pub enum ActorNetwork {
     /// LSTM-augmented policy network for temporal dependencies
     ///
     /// Used when `PPOConfig::use_lstm = true`.
-    /// Forward pass: (state, h_t, c_t) → (logits, new_h, new_c).
+    /// Forward pass: (state, `h_t`, `c_t`) → (logits, `new_h`, `new_c`).
     /// Requires `HiddenStateManager` for state persistence across timesteps.
     LSTM(LSTMPolicyNetwork),
 }
 
 impl ActorNetwork {
     /// Get device for tensor operations
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         match self {
             ActorNetwork::MLP(network) => network.device(),
             ActorNetwork::LSTM(network) => network.device(),
@@ -66,7 +66,7 @@ impl ActorNetwork {
     }
 
     /// Get network variables for optimizer
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         match self {
             ActorNetwork::MLP(network) => network.vars(),
             ActorNetwork::LSTM(network) => network.vars(),
@@ -144,14 +144,14 @@ pub enum CriticNetwork {
     /// LSTM-augmented value network for temporal dependencies
     ///
     /// Used when `PPOConfig::use_lstm = true`.
-    /// Forward pass: (state, h_t, c_t) → (value, new_h, new_c).
+    /// Forward pass: (state, `h_t`, `c_t`) → (value, `new_h`, `new_c`).
     /// Requires `HiddenStateManager` for state persistence across timesteps.
     LSTM(LSTMValueNetwork),
 }
 
 impl CriticNetwork {
     /// Get device for tensor operations
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         match self {
             CriticNetwork::MLP(network) => network.device(),
             CriticNetwork::LSTM(network) => network.device(),
@@ -159,7 +159,7 @@ impl CriticNetwork {
     }
 
     /// Get network variables for optimizer
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         match self {
             CriticNetwork::MLP(network) => network.vars(),
             CriticNetwork::LSTM(network) => network.vars(),
@@ -234,16 +234,16 @@ pub struct PPOConfig {
     /// LSTM sequence length for training (default: 32)
     pub lstm_sequence_length: usize,
     /// Number of gradient accumulation steps (default: 1 = no accumulation)
-    /// effective_batch = mini_batch_size * accumulation_steps
+    /// `effective_batch` = `mini_batch_size` * `accumulation_steps`
     pub accumulation_steps: usize,
     /// Optional higher clip bound for asymmetric clipping (clip-higher).
-    /// When Some, uses clip(ratio, 1-clip_epsilon, 1+clip_epsilon_high).
+    /// When Some, uses clip(ratio, 1-clip_epsilon, `1+clip_epsilon_high`).
     /// Prevents entropy collapse during long training. None = symmetric (default).
     pub clip_epsilon_high: Option<f32>,
     /// Mixed precision configuration for BF16/FP16 forward pass on supported GPUs.
     /// None = FP32 only. Auto-configured based on GPU architecture at runtime.
     pub mixed_precision: Option<ml_core::mixed_precision::MixedPrecisionConfig>,
-    /// Use symlog transform for value targets (DreamerV3). Default: true.
+    /// Use symlog transform for value targets (`DreamerV3`). Default: true.
     /// Compresses large returns while preserving sign.
     pub use_symlog: bool,
     /// Use adaptive entropy coefficient (SAC-style). Default: true.
@@ -347,10 +347,10 @@ impl PolicyNetwork {
         })
     }
 
-    /// Load actor network from safetensors checkpoint via VarBuilder
+    /// Load actor network from safetensors checkpoint via `VarBuilder`
     ///
     /// # Arguments
-    /// * `vb` - VarBuilder loaded from safetensors file
+    /// * `vb` - `VarBuilder` loaded from safetensors file
     /// * `input_dim` - State dimension (must match training config)
     /// * `hidden_dims` - Hidden layer dimensions (must match training config)
     /// * `output_dim` - Number of actions (must match training config)
@@ -368,7 +368,7 @@ impl PolicyNetwork {
     /// ```
     ///
     /// # Returns
-    /// Loaded PolicyNetwork with restored weights, or error if:
+    /// Loaded `PolicyNetwork` with restored weights, or error if:
     /// - Checkpoint structure doesn't match config (wrong layer names/dimensions)
     /// - Tensor shapes are incompatible
     /// - Safetensors file is corrupted
@@ -428,7 +428,7 @@ impl PolicyNetwork {
     }
 
     /// Set mixed precision config for this network
-    pub fn set_mixed_precision(&mut self, mp: Option<ml_core::mixed_precision::MixedPrecisionConfig>) {
+    pub const fn set_mixed_precision(&mut self, mp: Option<ml_core::mixed_precision::MixedPrecisionConfig>) {
         self.mixed_precision = mp;
     }
 
@@ -446,10 +446,10 @@ impl PolicyNetwork {
                 let target_dtype = mp.dtype.to_dtype();
                 match input.to_dtype(target_dtype) {
                     Ok(converted) => (converted, true),
-                    Err(_) => (input.clone(), false),
+                    Err(_) => (input, false),
                 }
             }
-            _ => (input.clone(), false),
+            _ => (input, false),
         };
 
         for (i, layer) in self.layers.iter().enumerate() {
@@ -534,12 +534,12 @@ impl PolicyNetwork {
     }
 
     /// Get network variables
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Get device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 }
@@ -593,10 +593,10 @@ impl ValueNetwork {
         })
     }
 
-    /// Load critic network from safetensors checkpoint via VarBuilder
+    /// Load critic network from safetensors checkpoint via `VarBuilder`
     ///
     /// # Arguments
-    /// * `vb` - VarBuilder loaded from safetensors file
+    /// * `vb` - `VarBuilder` loaded from safetensors file
     /// * `input_dim` - State dimension (must match training config)
     /// * `hidden_dims` - Hidden layer dimensions (must match training config)
     /// * `device` - Device to load model on (CPU or CUDA)
@@ -613,7 +613,7 @@ impl ValueNetwork {
     /// ```
     ///
     /// # Returns
-    /// Loaded ValueNetwork with restored weights, or error if:
+    /// Loaded `ValueNetwork` with restored weights, or error if:
     /// - Checkpoint structure doesn't match config (wrong layer names/dimensions)
     /// - Tensor shapes are incompatible
     /// - Safetensors file is corrupted
@@ -671,7 +671,7 @@ impl ValueNetwork {
     }
 
     /// Set mixed precision config for this network
-    pub fn set_mixed_precision(&mut self, mp: Option<ml_core::mixed_precision::MixedPrecisionConfig>) {
+    pub const fn set_mixed_precision(&mut self, mp: Option<ml_core::mixed_precision::MixedPrecisionConfig>) {
         self.mixed_precision = mp;
     }
 
@@ -688,10 +688,10 @@ impl ValueNetwork {
                 let target_dtype = mp.dtype.to_dtype();
                 match input.to_dtype(target_dtype) {
                     Ok(converted) => (converted, true),
-                    Err(_) => (input.clone(), false),
+                    Err(_) => (input, false),
                 }
             }
-            _ => (input.clone(), false),
+            _ => (input, false),
         };
 
         for (i, layer) in self.layers.iter().enumerate() {
@@ -713,12 +713,12 @@ impl ValueNetwork {
     }
 
     /// Get network variables
-    pub fn vars(&self) -> &VarMap {
+    pub const fn vars(&self) -> &VarMap {
         &self.vars
     }
 
     /// Get device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 }
@@ -728,16 +728,16 @@ impl ValueNetwork {
 /// # Architecture Modes
 ///
 /// ## MLP Mode (default, `use_lstm = false`)
-/// - `actor`: ActorNetwork::MLP(PolicyNetwork)
-/// - `critic`: CriticNetwork::MLP(ValueNetwork)
+/// - `actor`: `ActorNetwork::MLP(PolicyNetwork)`
+/// - `critic`: `CriticNetwork::MLP(ValueNetwork)`
 /// - `hidden_state_manager`: None
 /// - Forward pass: state → action/value (no temporal dependencies)
 ///
 /// ## LSTM Mode (`use_lstm = true`)
-/// - `actor`: ActorNetwork::LSTM(LSTMPolicyNetwork)
-/// - `critic`: CriticNetwork::LSTM(LSTMValueNetwork)
+/// - `actor`: `ActorNetwork::LSTM(LSTMPolicyNetwork)`
+/// - `critic`: `CriticNetwork::LSTM(LSTMValueNetwork)`
 /// - `hidden_state_manager`: Some(HiddenStateManager)
-/// - Forward pass: (state, h_t, c_t) → (action/value, new_h, new_c)
+/// - Forward pass: (state, `h_t`, `c_t`) → (action/value, `new_h`, `new_c`)
 /// - Requires sequence batching via `TrajectoryBatch::to_sequences()`
 #[allow(missing_debug_implementations)]
 pub struct PPO {
@@ -763,9 +763,9 @@ pub struct PPO {
     pub transaction_cost_bps: Option<f64>,
     /// Maximum absolute position size
     pub max_position_absolute: Option<f64>,
-    /// Hidden state manager for LSTM (None if use_lstm = false)
+    /// Hidden state manager for LSTM (None if `use_lstm` = false)
     pub hidden_state_manager: Option<HiddenStateManager>,
-    /// Adaptive entropy coefficient (replaces fixed entropy_coeff when enabled)
+    /// Adaptive entropy coefficient (replaces fixed `entropy_coeff` when enabled)
     adaptive_entropy: Option<super::adaptive_entropy::AdaptiveEntropyCoeff>,
     /// Percentile scaler for advantage normalization
     percentile_scaler: Option<super::percentile_scaler::PercentileScaler>,
@@ -783,8 +783,8 @@ impl PPO {
     /// # Network Selection
     ///
     /// This constructor dynamically selects MLP or LSTM networks based on `config.use_lstm`:
-    /// - `use_lstm = false` (default): Creates ActorNetwork::MLP + CriticNetwork::MLP
-    /// - `use_lstm = true`: Creates ActorNetwork::LSTM + CriticNetwork::LSTM
+    /// - `use_lstm = false` (default): Creates `ActorNetwork::MLP` + `CriticNetwork::MLP`
+    /// - `use_lstm = true`: Creates `ActorNetwork::LSTM` + `CriticNetwork::LSTM`
     ///
     /// # LSTM Requirements
     ///
@@ -823,7 +823,7 @@ impl PPO {
                 config.state_dim,
                 lstm_hidden_dim,
                 lstm_num_layers,
-                device.clone(),
+                device,
             )?;
 
             (
@@ -842,7 +842,7 @@ impl PPO {
             let mut mlp_critic = ValueNetwork::new(
                 config.state_dim,
                 &config.value_hidden_dims,
-                device.clone(),
+                device,
             )?;
 
             // Wire mixed precision (BF16/FP16) into forward passes if configured
@@ -884,7 +884,7 @@ impl PPO {
                     lstm_num_layers,
                     1, // Default batch size, will be resized when needed
                     lstm_hidden_dim,
-                    &critic.device(),
+                    critic.device(),
                 )
             })
             .transpose()?;
@@ -916,7 +916,7 @@ impl PPO {
         Ok((action, value))
     }
 
-    /// Select action and return (action, log_prob, value).
+    /// Select action and return (action, `log_prob`, value).
     ///
     /// Returns the **real** policy log-probability needed for PPO importance
     /// sampling. Use this instead of [`act`] when collecting trajectories
@@ -1735,7 +1735,7 @@ impl PPO {
     /// * `batch` - Trajectory batch to compute losses on
     ///
     /// # Returns
-    /// Tuple of (policy_loss, value_loss) as scalars
+    /// Tuple of (`policy_loss`, `value_loss`) as scalars
     pub fn compute_losses(&self, batch: &mut TrajectoryBatch) -> Result<(f32, f32), MLError> {
         // Convert batch to tensors
         let device = self.actor.device();
@@ -1788,7 +1788,7 @@ impl PPO {
 
     /// Compute value function loss with return normalization
     ///
-    /// When `use_symlog` is enabled, applies symlog transform (DreamerV3) to compress
+    /// When `use_symlog` is enabled, applies symlog transform (`DreamerV3`) to compress
     /// large returns while preserving sign. Otherwise normalizes to N(0,1).
     fn compute_value_loss(&self, batch: &TrajectoryTensors) -> Result<Tensor, MLError> {
         let predicted_values = self.critic.forward(&batch.states)?;
@@ -1874,12 +1874,12 @@ impl PPO {
     }
 
     /// Get training steps
-    pub fn get_training_steps(&self) -> u64 {
+    pub const fn get_training_steps(&self) -> u64 {
         self.training_steps
     }
 
     /// Get configuration
-    pub fn get_config(&self) -> &PPOConfig {
+    pub const fn get_config(&self) -> &PPOConfig {
         &self.config
     }
 
@@ -1887,7 +1887,7 @@ impl PPO {
     ///
     /// This drops the existing optimizers and updates the config LR fields.
     /// On the next `update()` call, `init_optimizers()` will lazily recreate
-    /// fresh Adam optimizers referencing the same VarMap variables (preserving
+    /// fresh Adam optimizers referencing the same `VarMap` variables (preserving
     /// all trained network weights). The Adam momentum/variance state is reset,
     /// which is acceptable for LR scheduling since the optimizer adapts quickly.
     pub fn update_learning_rates(
@@ -2250,10 +2250,10 @@ impl PPO {
     /// Predict action probabilities for a given state
     ///
     /// # Arguments
-    /// * `state` - State vector (must match config.state_dim)
+    /// * `state` - State vector (must match `config.state_dim`)
     ///
     /// # Returns
-    /// Vector of action probabilities (length = config.num_actions)
+    /// Vector of action probabilities (length = `config.num_actions`)
     pub fn predict(&self, state: &[f32]) -> Result<Vec<f32>, MLError> {
         if state.len() != self.config.state_dim {
             return Err(MLError::InvalidInput(format!(
diff --git a/crates/ml-ppo/src/reward_normalizer.rs b/crates/ml-ppo/src/reward_normalizer.rs
index 7d35b777e..a7017633d 100644
--- a/crates/ml-ppo/src/reward_normalizer.rs
+++ b/crates/ml-ppo/src/reward_normalizer.rs
@@ -59,7 +59,7 @@ impl RewardNormalizer {
     /// - α=0.01 → 100 steps (balanced: reactive yet stable)
     /// - α=0.05 → 20 steps (aggressive: very reactive to changes)
     /// - α=0.001 → 1000 steps (conservative: smooth but slow)
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             mean: 0.0,
             variance: 1.0,
@@ -143,9 +143,9 @@ impl RewardNormalizer {
     /// Get count of values seen (backward compatibility)
     ///
     /// # Note
-    /// EMA doesn't track sample count. Returns u64::MAX to indicate
+    /// EMA doesn't track sample count. Returns `u64::MAX` to indicate
     /// "many samples" for backward compatibility with code that calls this method.
-    pub fn count(&self) -> u64 {
+    pub const fn count(&self) -> u64 {
         if self.initialized {
             u64::MAX
         } else {
diff --git a/crates/ml-ppo/src/reward_shaping.rs b/crates/ml-ppo/src/reward_shaping.rs
index 952c23c09..693b0136b 100644
--- a/crates/ml-ppo/src/reward_shaping.rs
+++ b/crates/ml-ppo/src/reward_shaping.rs
@@ -1,6 +1,6 @@
 //! PPO reward shaping for financial trading
 //!
-//! Provides additional reward components beyond raw PnL to guide PPO training:
+//! Provides additional reward components beyond raw `PnL` to guide PPO training:
 //! - Hold penalty: discourages staying flat when signals exist
 //! - Rolling Sharpe: risk-adjusted reward component
 //! - Diversity bonus: encourages varied action selection (smooth quadratic)
@@ -19,7 +19,7 @@ const MIN_DIVERSITY_ACTIONS: u32 = 10;
 
 /// PPO reward shaper with configurable components.
 ///
-/// Combines multiple reward signals to guide PPO training beyond raw PnL:
+/// Combines multiple reward signals to guide PPO training beyond raw `PnL`:
 ///
 /// 1. **Hold penalty** — applied when the agent is flat and signals suggest
 ///    an actionable opportunity.  Discourages inactivity.
@@ -75,7 +75,7 @@ impl PPORewardShaper {
     /// Shape a reward with all enabled components.
     ///
     /// # Arguments
-    /// * `raw_reward` — raw PnL reward from the environment
+    /// * `raw_reward` — raw `PnL` reward from the environment
     /// * `is_flat` — whether the agent currently holds no position
     /// * `has_signal` — whether market signals suggest an actionable opportunity
     /// * `action_index` — index of the action taken (0..44)
@@ -176,17 +176,17 @@ impl PPORewardShaper {
     }
 
     /// Get hold penalty weight.
-    pub fn hold_penalty_weight(&self) -> f64 {
+    pub const fn hold_penalty_weight(&self) -> f64 {
         self.hold_penalty_weight
     }
 
     /// Get Sharpe weight.
-    pub fn sharpe_weight(&self) -> f64 {
+    pub const fn sharpe_weight(&self) -> f64 {
         self.sharpe_weight
     }
 
     /// Get diversity weight.
-    pub fn diversity_weight(&self) -> f64 {
+    pub const fn diversity_weight(&self) -> f64 {
         self.diversity_weight
     }
 }
diff --git a/crates/ml-ppo/src/symlog.rs b/crates/ml-ppo/src/symlog.rs
index 071ae3cf9..e7f90838e 100644
--- a/crates/ml-ppo/src/symlog.rs
+++ b/crates/ml-ppo/src/symlog.rs
@@ -1,10 +1,10 @@
-//! Symlog value transform (DreamerV3)
+//! Symlog value transform (`DreamerV3`)
 //!
 //! Compresses large values while preserving sign. Near-identity for small values.
 //! Critical for financial returns spanning multiple orders of magnitude.
 //!
 //! # References
-//! - Hafner et al., "Mastering Diverse Domains through World Models" (DreamerV3, 2023)
+//! - Hafner et al., "Mastering Diverse Domains through World Models" (`DreamerV3`, 2023)
 //!
 //! # Properties
 //! - `symlog(0) = 0`
diff --git a/crates/ml-ppo/src/trajectories.rs b/crates/ml-ppo/src/trajectories.rs
index f77cfb188..3f69b4165 100644
--- a/crates/ml-ppo/src/trajectories.rs
+++ b/crates/ml-ppo/src/trajectories.rs
@@ -28,7 +28,7 @@ pub struct TrajectoryStep {
 
 impl TrajectoryStep {
     /// Create new trajectory step
-    pub fn new(
+    pub const fn new(
         state: Vec<f32>,
         action: FactoredAction,
         log_prob: f32,
@@ -60,7 +60,7 @@ pub struct Trajectory {
 
 impl Trajectory {
     /// Create new empty trajectory
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             steps: Vec::new(),
             total_return: 0.0,
@@ -208,7 +208,7 @@ impl TrajectoryBatch {
     /// Create batch from trajectories.
     ///
     /// Uses `extend_*` methods on `Trajectory` to avoid per-trajectory intermediate
-    /// `Vec` allocations for scalar fields (actions, log_probs, values, rewards, dones).
+    /// `Vec` allocations for scalar fields (actions, `log_probs`, values, rewards, dones).
     /// Pre-computes total step count for capacity hints and builds `states_flat` alongside
     /// `states` so that `to_tensors()` can skip the flatten step.
     pub fn from_trajectories(
@@ -504,7 +504,7 @@ pub struct TrajectorySequence {
 
 impl TrajectorySequence {
     /// Get the actual length of this sequence (may be less than max for final sequence)
-    pub fn length(&self) -> usize {
+    pub const fn length(&self) -> usize {
         self.actual_length
     }
 }
diff --git a/crates/ml-ppo/src/trajectory_replay.rs b/crates/ml-ppo/src/trajectory_replay.rs
index 90788f089..de0c78c0b 100644
--- a/crates/ml-ppo/src/trajectory_replay.rs
+++ b/crates/ml-ppo/src/trajectory_replay.rs
@@ -90,7 +90,7 @@ impl TrajectoryReplayBuffer {
     }
 
     /// Get current generation number.
-    pub fn generation(&self) -> u64 {
+    pub const fn generation(&self) -> u64 {
         self.generation
     }
 
diff --git a/crates/ml-ppo/src/transaction_costs.rs b/crates/ml-ppo/src/transaction_costs.rs
index 4ec26a2b2..50fc6bee1 100644
--- a/crates/ml-ppo/src/transaction_costs.rs
+++ b/crates/ml-ppo/src/transaction_costs.rs
@@ -1,12 +1,12 @@
 //! Transaction Cost Module for PPO
 //!
-//! Ported from DQN action_space.rs to provide consistent transaction cost
+//! Ported from DQN `action_space.rs` to provide consistent transaction cost
 //! calculations across both DQN and PPO training.
 //!
 //! # Fee Structure (Wave 2.5 Calibration)
 //! - **Market**: 0.15% (0.0015) - Immediate execution, high cost
-//! - **LimitMaker**: 0.05% (0.0005) - Passive order, maker rebate
-//! - **IoC**: 0.10% (0.0010) - Immediate-or-cancel, medium cost
+//! - **`LimitMaker`**: 0.05% (0.0005) - Passive order, maker rebate
+//! - **`IoC`**: 0.10% (0.0010) - Immediate-or-cancel, medium cost
 
 pub use ml_core::action_space::OrderType;
 
@@ -14,7 +14,7 @@ pub use ml_core::action_space::OrderType;
 ///
 /// # Arguments
 ///
-/// * `order_type` - The type of order (Market, LimitMaker, IoC)
+/// * `order_type` - The type of order (Market, `LimitMaker`, `IoC`)
 /// * `trade_value` - Absolute value of the trade in dollars (price × quantity)
 ///
 /// # Returns
@@ -35,7 +35,7 @@ pub use ml_core::action_space::OrderType;
 ///
 /// - Uses absolute value to handle negative trade values defensively
 /// - Returns 0.0 for zero trade value
-/// - Matches DQN's FactoredAction::calculate_transaction_cost() behavior
+/// - Matches DQN's `FactoredAction::calculate_transaction_cost()` behavior
 pub fn calculate_transaction_cost(order_type: OrderType, trade_value: f64) -> f64 {
     // Use absolute value to handle negative trade values defensively
     let abs_trade_value = trade_value.abs();
diff --git a/crates/ml-regime/src/multi_cusum.rs b/crates/ml-regime/src/multi_cusum.rs
index 7dcd9d6d9..6407d259f 100644
--- a/crates/ml-regime/src/multi_cusum.rs
+++ b/crates/ml-regime/src/multi_cusum.rs
@@ -38,8 +38,10 @@ impl Default for CUSUMConfig {
 /// Detection mode for multi-feature monitoring
 /// Note: Cannot derive Eq because f64 doesn't implement Eq (floating point equality is non-transitive)
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[derive(Default)]
 pub enum DetectionMode {
     /// Any feature triggers detection
+    #[default]
     Any,
     /// All features must trigger detection
     All,
@@ -47,11 +49,6 @@ pub enum DetectionMode {
     WeightedVote { threshold: f64 },
 }
 
-impl Default for DetectionMode {
-    fn default() -> Self {
-        DetectionMode::Any
-    }
-}
 
 /// Multi-feature breakpoint result
 #[derive(Debug, Clone, PartialEq)]
diff --git a/crates/ml-regime/src/ranging.rs b/crates/ml-regime/src/ranging.rs
index 0aa528edf..e1b01e6a4 100644
--- a/crates/ml-regime/src/ranging.rs
+++ b/crates/ml-regime/src/ranging.rs
@@ -89,7 +89,7 @@ impl RangingClassifier {
     /// Ranging signal classification
     pub fn classify(&mut self, bar: OHLCVBar) -> RangingSignal {
         // Add bar to rolling window
-        self.bars.push_back(bar.clone());
+        self.bars.push_back(bar);
         if self.bars.len() > self.max_bars {
             self.bars.pop_front();
             self.upper_band_touches.pop_front();
@@ -315,13 +315,13 @@ impl RangingClassifier {
         let minus_di = (minus_dm_sum / tr_sum) * 100.0;
 
         // ADX calculation
-        let dx = if plus_di + minus_di > 0.0 {
+        
+
+        if plus_di + minus_di > 0.0 {
             ((plus_di - minus_di).abs() / (plus_di + minus_di)) * 100.0
         } else {
             0.0
-        };
-
-        dx // Simplified ADX (using DX directly)
+        } // Simplified ADX (using DX directly)
     }
 
     /// Classify ranging regime based on indicators
diff --git a/crates/ml-regime/src/transition_matrix.rs b/crates/ml-regime/src/transition_matrix.rs
index 0896eaab3..1a50ee7ca 100644
--- a/crates/ml-regime/src/transition_matrix.rs
+++ b/crates/ml-regime/src/transition_matrix.rs
@@ -173,8 +173,7 @@ impl RegimeTransitionMatrix {
                     (1.0 - alpha) * self.transition_matrix[from_idx][j] + alpha;
             } else {
                 // Other transitions: decrease probability
-                self.transition_matrix[from_idx][j] =
-                    (1.0 - alpha) * self.transition_matrix[from_idx][j];
+                self.transition_matrix[from_idx][j] *= (1.0 - alpha);
             }
         }
 
diff --git a/crates/ml-regime/src/trending.rs b/crates/ml-regime/src/trending.rs
index 0eaafc8e8..9cca11d00 100644
--- a/crates/ml-regime/src/trending.rs
+++ b/crates/ml-regime/src/trending.rs
@@ -105,11 +105,11 @@ impl TrendingClassifier {
     /// ```
     pub fn new(adx_threshold: f64, hurst_threshold: f64, lookback_period: usize) -> Self {
         assert!(
-            adx_threshold >= 0.0 && adx_threshold <= 100.0,
+            (0.0..=100.0).contains(&adx_threshold),
             "ADX threshold must be in [0, 100]"
         );
         assert!(
-            hurst_threshold >= 0.0 && hurst_threshold <= 1.0,
+            (0.0..=1.0).contains(&hurst_threshold),
             "Hurst threshold must be in [0, 1]"
         );
         assert!(
diff --git a/crates/ml-regime/src/volatile.rs b/crates/ml-regime/src/volatile.rs
index 010ac0932..876d0b319 100644
--- a/crates/ml-regime/src/volatile.rs
+++ b/crates/ml-regime/src/volatile.rs
@@ -103,7 +103,7 @@ impl VolatileClassifier {
     /// - `VolatileSignal`: Current volatility regime
     pub fn classify(&mut self, bar: OHLCVBar) -> VolatileSignal {
         // Add bar to rolling window
-        self.bars.push_back(bar.clone());
+        self.bars.push_back(bar);
         if self.bars.len() > self.lookback_period {
             self.bars.pop_front();
         }
@@ -204,7 +204,7 @@ impl VolatileClassifier {
         let sum: f64 = self
             .bars
             .iter()
-            .map(|b| compute_parkinson_volatility(b))
+            .map(compute_parkinson_volatility)
             .sum();
         sum / self.bars.len() as f64
     }
diff --git a/crates/ml-security/src/prediction_validator.rs b/crates/ml-security/src/prediction_validator.rs
index 18d53892f..c0d89dc19 100644
--- a/crates/ml-security/src/prediction_validator.rs
+++ b/crates/ml-security/src/prediction_validator.rs
@@ -265,7 +265,7 @@ impl PredictionValidator {
         let mut flags = Vec::new();
 
         // Layer 1: Range check
-        if prediction < -1.0 || prediction > 1.0 {
+        if !(-1.0..=1.0).contains(&prediction) {
             warn!(
                 "Prediction out of bounds for model {}: {} (valid range: [-1.0, 1.0])",
                 model_id, prediction
diff --git a/crates/ml-stress-testing/src/lib.rs b/crates/ml-stress-testing/src/lib.rs
index 3028fea90..6cb472ece 100644
--- a/crates/ml-stress-testing/src/lib.rs
+++ b/crates/ml-stress-testing/src/lib.rs
@@ -115,7 +115,7 @@ impl StressTestOrchestrator {
         // Use test fixtures for symbol configuration
         let test_symbols = vec!["TEST_LARGE_1", "TEST_LARGE_2", "TEST_MID_1", "TEST_SMALL_1"];
         let simulator_config = SimulatorConfig {
-            symbols: test_symbols.into_iter().map(|s| s.to_string()).collect(),
+            symbols: test_symbols.into_iter().map(|s| s.to_owned()).collect(),
             update_rate_hz: config.market_data_rate,
             volatility: 0.02,
             trend: 0.0,
@@ -279,7 +279,7 @@ impl StressTestOrchestrator {
                             phase_stats.record_successful_prediction(latency_us);
 
                             let result = PredictionResult {
-                                model_name: model.name().to_string(),
+                                model_name: model.name().to_owned(),
                                 model_type: model.model_type(),
                                 prediction,
                                 latency_us,
@@ -295,10 +295,10 @@ impl StressTestOrchestrator {
                             phase_stats.record_failed_prediction(latency_us);
 
                             let result = PredictionResult {
-                                model_name: model.name().to_string(),
+                                model_name: model.name().to_owned(),
                                 model_type: model.model_type(),
                                 prediction: ModelPrediction::new(
-                                    model.name().to_string(),
+                                    model.name().to_owned(),
                                     0.0,
                                     0.0,
                                 ),
@@ -381,10 +381,10 @@ impl StressTestOrchestrator {
             config: self.config.clone(),
             total_duration,
             phase_results,
-            total_predictions: total_predictions as u64,
-            total_errors: total_errors as u64,
+            total_predictions: total_predictions,
+            total_errors: total_errors,
             error_rate,
-            latency_stats: latency_stats.clone(),
+            latency_stats: latency_stats,
             requirements_met,
             throughput_achieved: total_predictions as f64 / total_duration.as_secs_f64(),
             recommendations,
@@ -512,6 +512,12 @@ pub struct PhaseStats {
     pub latencies: Vec<u64>,
 }
 
+impl Default for PhaseStats {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl PhaseStats {
     pub fn new() -> Self {
         Self {
diff --git a/crates/ml-stress-testing/src/market_simulator.rs b/crates/ml-stress-testing/src/market_simulator.rs
index 068e7732b..801d6d18b 100644
--- a/crates/ml-stress-testing/src/market_simulator.rs
+++ b/crates/ml-stress-testing/src/market_simulator.rs
@@ -195,7 +195,7 @@ impl MarketDataSimulator {
         state.last_update = SystemTime::now();
 
         Ok(MarketDataUpdate {
-            symbol: symbol.to_string(),
+            symbol: symbol.to_owned(),
             price: state.current_price,
             volume: Decimal::try_from(state.volume).unwrap_or(Decimal::ZERO),
             bid: Price::from_f64(state.bid)
diff --git a/crates/ml-stress-testing/src/performance_analyzer.rs b/crates/ml-stress-testing/src/performance_analyzer.rs
index 4b264f91b..33717582e 100644
--- a/crates/ml-stress-testing/src/performance_analyzer.rs
+++ b/crates/ml-stress-testing/src/performance_analyzer.rs
@@ -71,7 +71,7 @@ impl PerformanceAnalyzer {
     ) {
         self.measurements.push(PerformanceMeasurement {
             timestamp: SystemTime::now(),
-            metric_name: metric_name.to_string(),
+            metric_name: metric_name.to_owned(),
             value,
             labels,
         });
diff --git a/crates/ml-supervised/src/diffusion/config.rs b/crates/ml-supervised/src/diffusion/config.rs
index 6ea6f3334..09318eb01 100644
--- a/crates/ml-supervised/src/diffusion/config.rs
+++ b/crates/ml-supervised/src/diffusion/config.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 /// Noise schedule type for the diffusion process.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum NoiseSchedule {
-    /// Linear beta schedule from beta_start to beta_end.
+    /// Linear beta schedule from `beta_start` to `beta_end`.
     Linear,
     /// Cosine schedule (Nichol & Dhariwal) -- smoother noise progression.
     Cosine,
@@ -20,12 +20,12 @@ impl Default for NoiseSchedule {
 /// Configuration for a Diffusion model.
 ///
 /// OOM-safe defaults: small channels, short sequences, few res blocks.
-/// RTX 3050 Ti (4GB) safe at batch_size <= 32.
+/// RTX 3050 Ti (4GB) safe at `batch_size` <= 32.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DiffusionConfig {
     /// Number of diffusion timesteps (training noise levels).
     pub num_timesteps: usize,
-    /// Number of DDIM sampling steps (inference, << num_timesteps).
+    /// Number of DDIM sampling steps (inference, << `num_timesteps`).
     pub sampling_steps: usize,
     /// Sequence length of generated price paths.
     pub seq_len: usize,
@@ -66,8 +66,8 @@ impl Default for DiffusionConfig {
 }
 
 impl DiffusionConfig {
-    /// Total data dimension (seq_len * feature_dim).
-    pub fn data_dim(&self) -> usize {
+    /// Total data dimension (`seq_len` * `feature_dim`).
+    pub const fn data_dim(&self) -> usize {
         self.seq_len * self.feature_dim
     }
 }
diff --git a/crates/ml-supervised/src/diffusion/denoiser.rs b/crates/ml-supervised/src/diffusion/denoiser.rs
index 2608c5c31..d84b599ad 100644
--- a/crates/ml-supervised/src/diffusion/denoiser.rs
+++ b/crates/ml-supervised/src/diffusion/denoiser.rs
@@ -1,7 +1,7 @@
 //! Denoiser network for the diffusion model.
 //!
 //! Uses a fully-connected architecture with sinusoidal time embedding.
-//! This is more memory-efficient than Conv1D U-Net while still effective
+//! This is more memory-efficient than `Conv1D` U-Net while still effective
 //! for price sequence denoising at small sequence lengths (64-128).
 
 use ml_core::MLError;
@@ -31,7 +31,7 @@ impl TimeEmbedding {
     }
 
     /// Compute sinusoidal embedding for timestep indices.
-    /// Input: (batch,) u32 timestep indices → Output: (batch, hidden_dim)
+    /// Input: (batch,) u32 timestep indices → Output: (batch, `hidden_dim`)
     pub fn forward(&self, t: &Tensor, device: &Device) -> Result<Tensor, MLError> {
         let half_dim = self.embed_dim / 2;
         let t_f32 = t.to_dtype(DType::F32)
@@ -73,7 +73,7 @@ impl TimeEmbedding {
     }
 }
 
-/// A single denoiser block: linear → SiLU → linear + time conditioning + residual.
+/// A single denoiser block: linear → `SiLU` → linear + time conditioning + residual.
 struct DenoiserBlock {
     fc1: Linear,
     fc2: Linear,
@@ -139,8 +139,8 @@ impl DenoiserBlock {
 /// Architecture: input projection → N denoiser blocks → output projection.
 /// Each block is time-conditioned via additive time embedding.
 ///
-/// Memory usage at batch_size=32, data_dim=64, hidden=128:
-///   ~32 * 128 * num_layers * 4 bytes per layer ≈ 48KB -- very safe for 4GB GPU.
+/// Memory usage at `batch_size=32`, `data_dim=64`, hidden=128:
+///   ~32 * 128 * `num_layers` * 4 bytes per layer ≈ 48KB -- very safe for 4GB GPU.
 pub struct Denoiser {
     input_proj: Linear,
     blocks: Vec<DenoiserBlock>,
@@ -199,9 +199,9 @@ impl Denoiser {
         })
     }
 
-    /// Predict noise epsilon given noisy input x_t and timestep t.
+    /// Predict noise epsilon given noisy input `x_t` and timestep t.
     ///
-    /// Input x: (batch, data_dim), t: (batch,) → Output: (batch, data_dim)
+    /// Input x: (batch, `data_dim`), t: (batch,) → Output: (batch, `data_dim`)
     pub fn forward(&self, x: &Tensor, t: &Tensor) -> Result<Tensor, MLError> {
         let x = ml_core::mixed_precision::ensure_training_dtype(x)
             .map_err(|e| MLError::ModelError(e.to_string()))?;
diff --git a/crates/ml-supervised/src/diffusion/mod.rs b/crates/ml-supervised/src/diffusion/mod.rs
index 35aacfc9b..257ea9152 100644
--- a/crates/ml-supervised/src/diffusion/mod.rs
+++ b/crates/ml-supervised/src/diffusion/mod.rs
@@ -4,7 +4,7 @@
 //! - Cosine/linear noise schedules
 //! - Fully-connected denoiser with sinusoidal time embedding
 //! - DDIM sampling for fast inference
-//! - UnifiedTrainable adapter for the training pipeline
+//! - `UnifiedTrainable` adapter for the training pipeline
 
 pub mod config;
 pub mod denoiser;
diff --git a/crates/ml-supervised/src/diffusion/noise.rs b/crates/ml-supervised/src/diffusion/noise.rs
index 34b13b917..e3c154ae7 100644
--- a/crates/ml-supervised/src/diffusion/noise.rs
+++ b/crates/ml-supervised/src/diffusion/noise.rs
@@ -1,6 +1,6 @@
 //! Noise scheduler for the diffusion process.
 //!
-//! Precomputes alpha_bar_t for all timesteps and provides
+//! Precomputes `alpha_bar_t` for all timesteps and provides
 //! forward process (add noise) operations.
 
 use ml_core::MLError;
@@ -10,10 +10,10 @@ use super::config::NoiseSchedule;
 
 /// Precomputed noise schedule for the diffusion process.
 ///
-/// Stores alpha_bar_t (cumulative product of (1 - beta_t)) for
+/// Stores `alpha_bar_t` (cumulative product of (1 - `beta_t`)) for
 /// all T timesteps, enabling efficient forward-process noise addition.
 pub struct NoiseScheduler {
-    /// Cumulative alpha products: alpha_bar_t for each timestep.
+    /// Cumulative alpha products: `alpha_bar_t` for each timestep.
     alpha_bars: Vec<f32>,
     num_timesteps: usize,
     device: Device,
@@ -63,7 +63,7 @@ impl NoiseScheduler {
     }
 
     /// Cosine schedule (Nichol & Dhariwal 2021).
-    /// alpha_bar_t = cos((t/T + s) / (1+s) * pi/2)^2
+    /// `alpha_bar_t` = cos((t/T + s) / (1+s) * pi/2)^2
     fn cosine_schedule(t_max: usize) -> Vec<f32> {
         let s = 0.008_f64; // Small offset to prevent beta_0 = 0
         let mut alpha_bars = Vec::with_capacity(t_max);
@@ -83,7 +83,7 @@ impl NoiseScheduler {
         alpha_bars
     }
 
-    /// Get alpha_bar for a specific timestep.
+    /// Get `alpha_bar` for a specific timestep.
     pub fn get_alpha_bar(&self, t: usize) -> Result<f32, MLError> {
         self.alpha_bars
             .get(t)
@@ -93,9 +93,9 @@ impl NoiseScheduler {
 
     /// Forward process: add noise to clean data x0 at timestep t.
     ///
-    /// q(x_t | x_0) = N(sqrt(alpha_bar_t) * x_0, (1 - alpha_bar_t) * I)
+    /// `q(x_t` | `x_0`) = `N(sqrt(alpha_bar_t)` * `x_0`, (1 - `alpha_bar_t`) * I)
     ///
-    /// Returns (noisy_x, noise) where noise is the sampled epsilon.
+    /// Returns (`noisy_x`, noise) where noise is the sampled epsilon.
     pub fn add_noise(
         &self,
         x0: &Tensor,
@@ -120,7 +120,7 @@ impl NoiseScheduler {
         Ok((noisy, noise))
     }
 
-    /// Get alpha_bar as a tensor (scalar) for a given timestep.
+    /// Get `alpha_bar` as a tensor (scalar) for a given timestep.
     pub fn alpha_bar_tensor(&self, t: usize) -> Result<Tensor, MLError> {
         let ab = self.get_alpha_bar(t)?;
         Tensor::new(&[ab], &self.device)
@@ -128,11 +128,11 @@ impl NoiseScheduler {
     }
 
     /// Number of timesteps.
-    pub fn num_timesteps(&self) -> usize {
+    pub const fn num_timesteps(&self) -> usize {
         self.num_timesteps
     }
 
-    /// Get alpha_bars slice for DDIM sampling.
+    /// Get `alpha_bars` slice for DDIM sampling.
     pub fn alpha_bars(&self) -> &[f32] {
         &self.alpha_bars
     }
diff --git a/crates/ml-supervised/src/diffusion/sampler.rs b/crates/ml-supervised/src/diffusion/sampler.rs
index 1270b8060..a20204e2a 100644
--- a/crates/ml-supervised/src/diffusion/sampler.rs
+++ b/crates/ml-supervised/src/diffusion/sampler.rs
@@ -52,12 +52,12 @@ impl DDIMSampler {
     /// Generate samples from pure noise using DDIM.
     ///
     /// `denoiser`: the trained noise prediction network.
-    /// `scheduler`: noise schedule with alpha_bar values.
+    /// `scheduler`: noise schedule with `alpha_bar` values.
     /// `num_samples`: number of samples to generate.
     /// `data_dim`: dimension of each sample.
     /// `device`: computation device.
     ///
-    /// Returns: (num_samples, data_dim) tensor.
+    /// Returns: (`num_samples`, `data_dim`) tensor.
     pub fn sample(
         &self,
         denoiser: &Denoiser,
diff --git a/crates/ml-supervised/src/kan/config.rs b/crates/ml-supervised/src/kan/config.rs
index 8c2c7b61e..d0f96345b 100644
--- a/crates/ml-supervised/src/kan/config.rs
+++ b/crates/ml-supervised/src/kan/config.rs
@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 
 /// Configuration for a Kolmogorov-Arnold Network.
 ///
-/// KAN replaces fixed activation functions (ReLU) with learnable B-spline
+/// KAN replaces fixed activation functions (`ReLU`) with learnable B-spline
 /// activations on each edge, enabling the network to discover arbitrary
 /// non-linear relationships.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -20,7 +20,7 @@ pub struct KANConfig {
     /// Layer widths including input and output dimensions.
     /// Example: `[51, 32, 16, 1]` means input=51, two hidden layers, output=1.
     pub layer_widths: Vec<usize>,
-    /// Learning rate for AdamW optimizer.
+    /// Learning rate for `AdamW` optimizer.
     pub learning_rate: f64,
     /// L2 weight decay for regularization.
     pub weight_decay: f64,
diff --git a/crates/ml-supervised/src/kan/layer.rs b/crates/ml-supervised/src/kan/layer.rs
index 8157a2be0..2aa5aa55a 100644
--- a/crates/ml-supervised/src/kan/layer.rs
+++ b/crates/ml-supervised/src/kan/layer.rs
@@ -20,9 +20,9 @@ use super::spline::BSplineBasis;
 pub struct KANLayer {
     /// B-spline basis evaluator (shared across all input dims)
     spline_basis: BSplineBasis,
-    /// Learnable spline coefficients: (in_dim * num_bases, out_dim)
+    /// Learnable spline coefficients: (`in_dim` * `num_bases`, `out_dim`)
     coefficients: Tensor,
-    /// Learnable residual weights: (in_dim, out_dim)
+    /// Learnable residual weights: (`in_dim`, `out_dim`)
     residual_weight: Tensor,
     /// Input dimension
     in_dim: usize,
@@ -38,7 +38,7 @@ impl KANLayer {
     /// * `out_dim` - Output dimension
     /// * `grid_size` - B-spline grid points
     /// * `spline_order` - B-spline order (degree + 1)
-    /// * `vb` - VarBuilder for creating learnable parameters
+    /// * `vb` - `VarBuilder` for creating learnable parameters
     pub fn new(
         in_dim: usize,
         out_dim: usize,
diff --git a/crates/ml-supervised/src/kan/mod.rs b/crates/ml-supervised/src/kan/mod.rs
index 2ce5cbe18..9685c11c4 100644
--- a/crates/ml-supervised/src/kan/mod.rs
+++ b/crates/ml-supervised/src/kan/mod.rs
@@ -1,7 +1,7 @@
 //! KAN (Kolmogorov-Arnold Network) module.
 //!
 //! Implements KAN with learnable B-spline activation functions on each edge
-//! of the network, replacing fixed activations (ReLU) with data-driven
+//! of the network, replacing fixed activations (`ReLU`) with data-driven
 //! non-linearities.
 
 pub mod config;
diff --git a/crates/ml-supervised/src/kan/network.rs b/crates/ml-supervised/src/kan/network.rs
index 9874f59fa..4f589077d 100644
--- a/crates/ml-supervised/src/kan/network.rs
+++ b/crates/ml-supervised/src/kan/network.rs
@@ -56,7 +56,7 @@ impl KANNetwork {
     pub fn forward(&self, input: &Tensor) -> Result<Tensor, MLError> {
         let input = ml_core::mixed_precision::ensure_training_dtype(input)
             .map_err(|e| MLError::ModelError(e.to_string()))?;
-        let mut x = input.clone();
+        let mut x = input;
         for layer in &self.layers {
             x = layer.forward(&x)?;
         }
diff --git a/crates/ml-supervised/src/kan/spline.rs b/crates/ml-supervised/src/kan/spline.rs
index e793d4923..0423c73c4 100644
--- a/crates/ml-supervised/src/kan/spline.rs
+++ b/crates/ml-supervised/src/kan/spline.rs
@@ -5,7 +5,7 @@
 //! The evaluator produces a `(batch, num_bases)` tensor for use in KAN layers.
 //!
 //! When a GPU lookup grid is pre-computed via [`BSplineBasis::precompute_gpu_grid`],
-//! evaluation replaces O(n * num_bases * 2^(k-1)) recursive CPU calls with a
+//! evaluation replaces O(n * `num_bases` * 2^(k-1)) recursive CPU calls with a
 //! single GPU gather + linear interpolation, keeping the GPU saturated.
 
 use candle_core::{DType, Device, Tensor};
@@ -20,14 +20,14 @@ use ml_core::MLError;
 /// [`Self::evaluate`] uses GPU gather + lerp instead of CPU recursion.
 #[derive(Debug, Clone)]
 pub struct BSplineBasis {
-    /// Uniform knot vector (length = grid_size + 2 * order).
+    /// Uniform knot vector (length = `grid_size` + 2 * order).
     knots: Vec<f32>,
     /// Spline order (degree + 1).
     order: usize,
-    /// Number of basis functions = grid_size + order - 1.
+    /// Number of basis functions = `grid_size` + order - 1.
     num_bases: usize,
     // -- Pre-computed GPU lookup table --
-    /// Shape: (grid_resolution, num_bases). `None` until `precompute_gpu_grid` is called.
+    /// Shape: (`grid_resolution`, `num_bases`). `None` until `precompute_gpu_grid` is called.
     grid_values: Option<Tensor>,
     /// Domain minimum (first knot).
     grid_min: f32,
@@ -79,7 +79,7 @@ impl BSplineBasis {
     }
 
     /// Number of basis functions produced.
-    pub fn num_bases(&self) -> usize {
+    pub const fn num_bases(&self) -> usize {
         self.num_bases
     }
 
@@ -87,7 +87,7 @@ impl BSplineBasis {
     ///
     /// After calling this, [`Self::evaluate`] uses GPU gather + lerp instead of
     /// recursive CPU Cox-de Boor. Call once after construction; amortizes the
-    /// one-time O(resolution * num_bases * 2^(k-1)) CPU cost.
+    /// one-time O(resolution * `num_bases` * 2^(k-1)) CPU cost.
     ///
     /// # Arguments
     /// * `resolution` - Number of uniformly spaced grid points (e.g. 1024)
diff --git a/crates/ml-supervised/src/lib.rs b/crates/ml-supervised/src/lib.rs
index 8b73cbdaa..77966fab4 100644
--- a/crates/ml-supervised/src/lib.rs
+++ b/crates/ml-supervised/src/lib.rs
@@ -2,7 +2,7 @@
 //!
 //! Contains 8 model architectures: TFT, Mamba-2, Liquid, TGGN, TLOB, KAN, xLSTM, Diffusion.
 //! Each model directory contains the core network, layers, and self-contained training logic.
-//! Checkpointable impls live in the `checkpoint` module. UnifiedTrainable adapters live in `ml`.
+//! Checkpointable impls live in the `checkpoint` module. `UnifiedTrainable` adapters live in `ml`.
 
 // Re-export shared types from ml-core
 pub use ml_core::cuda_compat;
diff --git a/crates/ml-supervised/src/liquid/activation.rs b/crates/ml-supervised/src/liquid/activation.rs
index 219ffc159..ddd920f0b 100644
--- a/crates/ml-supervised/src/liquid/activation.rs
+++ b/crates/ml-supervised/src/liquid/activation.rs
@@ -36,9 +36,9 @@ pub fn sigmoid(x: FixedPoint) -> Result<FixedPoint> {
 
     let denominator = (one + abs_x)?;
     let fraction = (clamped_x / denominator)?;
-    let result = (half * fraction)? + half;
+    
 
-    Ok(result?)
+    ((half * fraction)? + half)
 }
 
 /// Fast tanh approximation using fixed-point arithmetic
@@ -61,8 +61,8 @@ pub fn tanh(x: FixedPoint) -> Result<FixedPoint> {
     Ok(result)
 }
 
-/// ReLU activation function
-pub fn relu(x: FixedPoint) -> FixedPoint {
+/// `ReLU` activation function
+pub const fn relu(x: FixedPoint) -> FixedPoint {
     if x.0 > 0 {
         x
     } else {
@@ -70,7 +70,7 @@ pub fn relu(x: FixedPoint) -> FixedPoint {
     }
 }
 
-/// Leaky ReLU activation function
+/// Leaky `ReLU` activation function
 pub fn leaky_relu(x: FixedPoint, alpha: FixedPoint) -> Result<FixedPoint> {
     if x.0 > 0 {
         Ok(x)
@@ -111,12 +111,12 @@ pub fn gelu(x: FixedPoint) -> Result<FixedPoint> {
     let one_plus_tanh = (FixedPoint::one() + tanh_result)?;
 
     // 0.5 * x * (1 + tanh(...))
-    let result = (half * x)? * one_plus_tanh;
-    Ok(result?)
+    
+    ((half * x)? * one_plus_tanh)
 }
 
 /// Linear activation (identity function)
-pub fn linear(x: FixedPoint) -> FixedPoint {
+pub const fn linear(x: FixedPoint) -> FixedPoint {
     x
 }
 
@@ -135,7 +135,7 @@ pub fn apply_activation(x: FixedPoint, activation_type: ActivationType) -> Resul
 
 /// Activation function derivatives for backpropagation
 pub mod derivatives {
-    use super::*;
+    use super::{FixedPoint, Result, sigmoid, tanh, ActivationType, PRECISION, LiquidError};
 
     /// Sigmoid derivative: σ(x) * (1 - σ(x))
     pub fn sigmoid_derivative(x: FixedPoint) -> Result<FixedPoint> {
@@ -151,8 +151,8 @@ pub mod derivatives {
         FixedPoint::one() - tanh_squared
     }
 
-    /// ReLU derivative
-    pub fn relu_derivative(x: FixedPoint) -> FixedPoint {
+    /// `ReLU` derivative
+    pub const fn relu_derivative(x: FixedPoint) -> FixedPoint {
         if x.0 > 0 {
             FixedPoint::one()
         } else {
@@ -160,8 +160,8 @@ pub mod derivatives {
         }
     }
 
-    /// Leaky ReLU derivative
-    pub fn leaky_relu_derivative(x: FixedPoint, alpha: FixedPoint) -> FixedPoint {
+    /// Leaky `ReLU` derivative
+    pub const fn leaky_relu_derivative(x: FixedPoint, alpha: FixedPoint) -> FixedPoint {
         if x.0 > 0 {
             FixedPoint::one()
         } else {
diff --git a/crates/ml-supervised/src/liquid/candle_cfc.rs b/crates/ml-supervised/src/liquid/candle_cfc.rs
index 9879d7702..5759eacf7 100644
--- a/crates/ml-supervised/src/liquid/candle_cfc.rs
+++ b/crates/ml-supervised/src/liquid/candle_cfc.rs
@@ -1,7 +1,7 @@
-//! Candle-based CfC v2 (Closed-form Continuous-time) Neural Network
+//! Candle-based `CfC` v2 (Closed-form Continuous-time) Neural Network
 //!
 //! Differentiable implementation using Candle tensors for gradient-based training.
-//! This is the training path; the existing FixedPoint implementation in cells.rs/network.rs
+//! This is the training path; the existing `FixedPoint` implementation in cells.rs/network.rs
 //! remains the production inference path.
 
 use candle_core::Tensor;
@@ -11,12 +11,12 @@ use serde::{Deserialize, Serialize};
 use ml_core::cuda_compat::manual_sigmoid;
 use ml_core::MLError;
 
-/// Device configuration for CfC training -- re-exported from central gpu module.
+/// Device configuration for `CfC` training -- re-exported from central gpu module.
 pub use ml_core::gpu::DeviceConfig;
 
-/// CfC v2 training configuration
+/// `CfC` v2 training configuration
 ///
-/// This is distinct from `cells::CfCConfig` which configures the FixedPoint inference path.
+/// This is distinct from `cells::CfCConfig` which configures the `FixedPoint` inference path.
 /// `CfCTrainConfig` configures the Candle-based differentiable training path with
 /// gradient descent, dropout, and market regime adaptation.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -66,7 +66,7 @@ impl Default for CfCTrainConfig {
 /// perceptron with tanh activations. Two linear heads project the final hidden
 /// representation to:
 /// - `f_out`: target hidden state value (tanh-activated)
-/// - `tau_out`: raw time constant values (sigmoid-scaled later in CfC cell)
+/// - `tau_out`: raw time constant values (sigmoid-scaled later in `CfC` cell)
 #[allow(missing_debug_implementations)]
 pub struct BackboneMLP {
     layers: Vec<Linear>,
@@ -75,7 +75,7 @@ pub struct BackboneMLP {
 }
 
 impl BackboneMLP {
-    /// Create a new BackboneMLP.
+    /// Create a new `BackboneMLP`.
     ///
     /// # Arguments
     /// - `input_dim`: dimension of concatenated `[input, hidden_state]`
@@ -119,11 +119,11 @@ impl BackboneMLP {
     /// Forward pass producing `(f_out, tau_out)`.
     ///
     /// - `f_out` is tanh-activated (bounded in [-1, 1])
-    /// - `tau_out` is raw (sigmoid scaling applied in the CfC cell)
+    /// - `tau_out` is raw (sigmoid scaling applied in the `CfC` cell)
     pub fn forward(&self, input: &Tensor) -> Result<(Tensor, Tensor), MLError> {
         let input = ml_core::mixed_precision::ensure_training_dtype(input)
             .map_err(|e| MLError::InferenceError(e.to_string()))?;
-        let mut x = input.clone();
+        let mut x = input;
         for layer in &self.layers {
             x = layer
                 .forward(&x)
@@ -149,13 +149,13 @@ impl BackboneMLP {
     }
 }
 
-/// CfC v2 Cell -- Closed-form Continuous-time cell
+/// `CfC` v2 Cell -- Closed-form Continuous-time cell
 ///
 /// Update rule:
 ///   h(t+dt) = h(t) * exp(-dt/tau(t)) + f(x,h) * (1 - exp(-dt/tau(t)))
 ///
 /// where tau(t) is a learned, input-dependent time constant produced by the
-/// backbone's tau head, scaled to [tau_min, tau_max] via sigmoid.
+/// backbone's tau head, scaled to [`tau_min`, `tau_max`] via sigmoid.
 #[allow(missing_debug_implementations)]
 pub struct CfCCell {
     backbone: BackboneMLP,
@@ -186,9 +186,9 @@ impl CfCCell {
         })
     }
 
-    /// Single CfC step: h_new = h * decay + f * (1 - decay)
+    /// Single `CfC` step: `h_new` = h * decay + f * (1 - decay)
     ///
-    /// where decay = exp(-dt / tau) and tau = sigmoid(tau_raw) * (tau_max - tau_min) + tau_min
+    /// where decay = exp(-dt / tau) and tau = `sigmoid(tau_raw)` * (`tau_max` - `tau_min`) + `tau_min`
     pub fn step(&self, x: &Tensor, h: &Tensor, dt: f32) -> Result<Tensor, MLError> {
         if dt < 0.0 {
             return Err(MLError::InferenceError("dt must be non-negative".to_owned()));
@@ -232,7 +232,7 @@ impl CfCCell {
     }
 }
 
-/// Complete CfC v2 Network for sequence processing
+/// Complete `CfC` v2 Network for sequence processing
 ///
 /// Wraps `CfCCell` with an output projection layer. Given a 3D input tensor
 /// `[batch, seq_len, features]`, unrolls the cell over time steps and projects
@@ -304,7 +304,7 @@ impl CandleCfCNetwork {
         Ok(output)
     }
 
-    /// Forward compatible with UnifiedTrainable (3D input, default dt=0.01)
+    /// Forward compatible with `UnifiedTrainable` (3D input, default dt=0.01)
     pub fn forward(&self, input: &Tensor) -> Result<Tensor, MLError> {
         let input = ml_core::mixed_precision::ensure_training_dtype(input)
             .map_err(|e| MLError::InferenceError(e.to_string()))?;
diff --git a/crates/ml-supervised/src/liquid/cells.rs b/crates/ml-supervised/src/liquid/cells.rs
index efff9088a..07e72c347 100644
--- a/crates/ml-supervised/src/liquid/cells.rs
+++ b/crates/ml-supervised/src/liquid/cells.rs
@@ -1,6 +1,6 @@
 //! Liquid Neural Network Cell Implementations
 //!
-//! Implements LTC (Liquid Time-constant) and CfC (Closed-form Continuous-time)
+//! Implements LTC (Liquid Time-constant) and `CfC` (Closed-form Continuous-time)
 //! cells with fixed-point arithmetic for ultra-low latency inference.
 
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -22,7 +22,7 @@ pub struct LTCConfig {
     pub activation: ActivationType,
 }
 
-/// Configuration for CfC (Closed-form Continuous-time) cells
+/// Configuration for `CfC` (Closed-form Continuous-time) cells
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CfCConfig {
     pub input_size: usize,
@@ -126,15 +126,12 @@ impl LTCCell {
             )));
         }
 
-        let solver = match &self.solver {
-            Some(s) => s,
-            None => {
-                // Re-create solver if needed (after deserialization)
-                self.solver = Some(SolverFactory::create_solver(self.config.solver_type));
-                self.solver.as_ref().ok_or_else(|| {
-                    LiquidError::InferenceError("Solver not initialized".to_owned())
-                })?
-            },
+        let solver = if let Some(s) = &self.solver { s } else {
+            // Re-create solver if needed (after deserialization)
+            self.solver = Some(SolverFactory::create_solver(self.config.solver_type));
+            self.solver.as_ref().ok_or_else(|| {
+                LiquidError::InferenceError("Solver not initialized".to_owned())
+            })?
         };
 
         let mut new_hidden_state = Vec::with_capacity(self.config.hidden_size);
@@ -218,7 +215,7 @@ impl LTCCell {
     }
 }
 
-/// CfC (Closed-form Continuous-time) cell implementation
+/// `CfC` (Closed-form Continuous-time) cell implementation
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CfCCell {
     pub config: CfCConfig,
@@ -304,7 +301,7 @@ impl CfCCell {
         })
     }
 
-    /// Forward pass through the CfC cell
+    /// Forward pass through the `CfC` cell
     pub fn forward(&mut self, input: &[FixedPoint], dt: FixedPoint) -> Result<Vec<FixedPoint>> {
         let start_time = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -319,15 +316,12 @@ impl CfCCell {
             )));
         }
 
-        let _solver = match &self.solver {
-            Some(s) => s,
-            None => {
-                // Re-create solver if needed (after deserialization)
-                self.solver = Some(SolverFactory::create_solver(self.config.solver_type));
-                self.solver.as_ref().ok_or_else(|| {
-                    LiquidError::InferenceError("Solver not initialized".to_owned())
-                })?
-            },
+        let _solver = if let Some(s) = &self.solver { s } else {
+            // Re-create solver if needed (after deserialization)
+            self.solver = Some(SolverFactory::create_solver(self.config.solver_type));
+            self.solver.as_ref().ok_or_else(|| {
+                LiquidError::InferenceError("Solver not initialized".to_owned())
+            })?
         };
 
         // Concatenate input and current state for backbone network
diff --git a/crates/ml-supervised/src/liquid/mod.rs b/crates/ml-supervised/src/liquid/mod.rs
index 32f917216..5fac37c06 100644
--- a/crates/ml-supervised/src/liquid/mod.rs
+++ b/crates/ml-supervised/src/liquid/mod.rs
@@ -1,6 +1,6 @@
 //! Liquid Neural Networks for Ultra-Low Latency HFT
 //!
-//! Implementation of Liquid Time-constant (LTC) and Closed-form Continuous-time (CfC)
+//! Implementation of Liquid Time-constant (LTC) and Closed-form Continuous-time (`CfC`)
 //! neural networks with fixed-point arithmetic for sub-100μs inference.
 
 use std::error::Error;
@@ -48,15 +48,15 @@ impl FixedPoint {
         self.0 as f64 / PRECISION as f64
     }
 
-    pub fn zero() -> Self {
+    pub const fn zero() -> Self {
         FixedPoint(0)
     }
 
-    pub fn one() -> Self {
+    pub const fn one() -> Self {
         FixedPoint(PRECISION)
     }
 
-    pub fn is_finite(&self) -> bool {
+    pub const fn is_finite(&self) -> bool {
         self.0.abs() < i64::MAX / 2
     }
 }
diff --git a/crates/ml-supervised/src/liquid/network.rs b/crates/ml-supervised/src/liquid/network.rs
index 626c83f1a..b7cb87ad0 100644
--- a/crates/ml-supervised/src/liquid/network.rs
+++ b/crates/ml-supervised/src/liquid/network.rs
@@ -1,7 +1,7 @@
 //! Liquid Neural Network Implementation
 //!
 //! Complete liquid network with multiple layers of LTC/CfC cells,
-//! MLModel trait integration, and HFT-optimized inference.
+//! `MLModel` trait integration, and HFT-optimized inference.
 
 use std::collections::HashMap;
 use std::time::{Instant, SystemTime, UNIX_EPOCH};
@@ -242,7 +242,7 @@ impl LiquidNetwork {
     pub fn predict(&mut self, input: &[f64]) -> MLResult<Vec<f64>> {
         let fixed_input: Vec<FixedPoint> = input.iter().map(|&x| FixedPoint::from_f64(x)).collect();
 
-        let fixed_output = self.forward(&fixed_input).map_err(|e| MLError::from(e))?;
+        let fixed_output = self.forward(&fixed_input).map_err(MLError::from)?;
 
         let output: Vec<f64> = fixed_output.iter().map(|fp| fp.to_f64()).collect();
 
@@ -324,11 +324,11 @@ impl LiquidNetwork {
     }
 
     /// Get network performance metrics
-    pub fn get_performance_metrics(&self) -> &PerformanceMetrics {
+    pub const fn get_performance_metrics(&self) -> &PerformanceMetrics {
         &self.performance_metrics
     }
 
-    /// Get metrics as HashMap for compatibility
+    /// Get metrics as `HashMap` for compatibility
     pub fn get_metrics(&self) -> HashMap<String, f64> {
         let mut metrics = HashMap::new();
         metrics.insert(
@@ -351,17 +351,17 @@ impl LiquidNetwork {
     }
 
     /// Get input size
-    pub fn input_size(&self) -> usize {
+    pub const fn input_size(&self) -> usize {
         self.config.input_size
     }
 
     /// Get output size
-    pub fn output_size(&self) -> usize {
+    pub const fn output_size(&self) -> usize {
         self.config.output_size
     }
 
     /// Get total number of parameters
-    pub fn parameter_count(&self) -> usize {
+    pub const fn parameter_count(&self) -> usize {
         self.performance_metrics.total_parameters
     }
 }
diff --git a/crates/ml-supervised/src/liquid/ode_solvers.rs b/crates/ml-supervised/src/liquid/ode_solvers.rs
index f58827308..92cbed8ad 100644
--- a/crates/ml-supervised/src/liquid/ode_solvers.rs
+++ b/crates/ml-supervised/src/liquid/ode_solvers.rs
@@ -106,8 +106,14 @@ pub struct AdaptiveSolver {
     current_regime: MarketRegime,
 }
 
+impl Default for AdaptiveSolver {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl AdaptiveSolver {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             euler: EulerSolver,
             rk4: RK4Solver,
@@ -115,11 +121,11 @@ impl AdaptiveSolver {
         }
     }
 
-    pub fn update_regime(&mut self, regime: MarketRegime) {
+    pub const fn update_regime(&mut self, regime: MarketRegime) {
         self.current_regime = regime;
     }
 
-    fn use_high_accuracy(&self) -> bool {
+    const fn use_high_accuracy(&self) -> bool {
         matches!(
             self.current_regime,
             MarketRegime::Bull | MarketRegime::Bear | MarketRegime::Crisis
@@ -159,7 +165,7 @@ pub struct VolatilityAwareTimeConstants {
 }
 
 impl VolatilityAwareTimeConstants {
-    pub fn new(base_tau: FixedPoint, min_tau: FixedPoint, max_tau: FixedPoint) -> Self {
+    pub const fn new(base_tau: FixedPoint, min_tau: FixedPoint, max_tau: FixedPoint) -> Self {
         Self {
             base_tau,
             min_tau,
@@ -197,7 +203,7 @@ impl VolatilityAwareTimeConstants {
         Ok(())
     }
 
-    pub fn current_tau(&self) -> FixedPoint {
+    pub const fn current_tau(&self) -> FixedPoint {
         self.current_tau
     }
 }
@@ -248,7 +254,7 @@ impl LiquidDynamics {
         }
     }
 
-    /// CfC dynamics with closed-form solution approximation
+    /// `CfC` dynamics with closed-form solution approximation
     pub fn cfc_dynamics<'a>(
         input_weights: &'a [FixedPoint],
         recurrent_weights: &'a [FixedPoint],
@@ -257,9 +263,8 @@ impl LiquidDynamics {
         move |x: FixedPoint, _time: FixedPoint| -> FixedPoint {
             // Simplified CfC dynamics for single cell
             // In practice, this would involve matrix operations
-            let input_contrib = input_weights.get(0).copied().unwrap_or(FixedPoint::zero());
-            let recurrent_contrib = recurrent_weights
-                .get(0)
+            let input_contrib = input_weights.first().copied().unwrap_or(FixedPoint::zero());
+            let recurrent_contrib = recurrent_weights.first()
                 .copied()
                 .unwrap_or(FixedPoint::zero());
 
@@ -318,7 +323,7 @@ impl SolverEnum {
 pub struct SolverFactory;
 
 impl SolverFactory {
-    pub fn create_solver(solver_type: SolverType) -> SolverEnum {
+    pub const fn create_solver(solver_type: SolverType) -> SolverEnum {
         match solver_type {
             SolverType::Euler => SolverEnum::Euler(EulerSolver),
             SolverType::RK4 => SolverEnum::RK4(RK4Solver),
diff --git a/crates/ml-supervised/src/liquid/training.rs b/crates/ml-supervised/src/liquid/training.rs
index f3f50be87..78b0dc2b3 100644
--- a/crates/ml-supervised/src/liquid/training.rs
+++ b/crates/ml-supervised/src/liquid/training.rs
@@ -269,7 +269,7 @@ impl LiquidTrainer {
         }
 
         let mut total_loss = 0.0;
-        for (pred, target) in predictions.into_iter().zip(targets.into_iter()) {
+        for (pred, target) in predictions.iter().zip(targets.iter()) {
             let diff = (*pred - *target)?;
             let squared_error = (diff * diff)?;
             total_loss += squared_error.to_f64();
@@ -347,10 +347,9 @@ impl LiquidTrainer {
             let clip_factor = (self.config.gradient_clip_threshold / gradients.total_norm)?;
 
             // Clip output gradients
-            for (_i, bias_grad) in clipped_gradients
+            for bias_grad in clipped_gradients
                 .output_bias_gradients
                 .iter_mut()
-                .enumerate()
             {
                 *bias_grad = (*bias_grad * clip_factor)?;
             }
@@ -469,7 +468,7 @@ use super::candle_cfc::{CandleCfCNetwork, CfCTrainConfig};
 use ml_core::mixed_precision::training_dtype;
 use ml_core::MLError;
 
-/// Configuration for the Candle-based CfC trainer
+/// Configuration for the Candle-based `CfC` trainer
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CfCTrainerConfig {
     pub cfc: CfCTrainConfig,
@@ -487,7 +486,7 @@ impl Default for CfCTrainerConfig {
     }
 }
 
-/// Candle-based CfC trainer with real gradient-based optimization
+/// Candle-based `CfC` trainer with real gradient-based optimization
 #[allow(missing_debug_implementations)]
 pub struct CandleCfCTrainer {
     network: CandleCfCNetwork,
@@ -521,7 +520,7 @@ impl CandleCfCTrainer {
         })
     }
 
-    pub fn epoch(&self) -> usize {
+    pub const fn epoch(&self) -> usize {
         self.current_epoch
     }
 
@@ -571,11 +570,11 @@ impl CandleCfCTrainer {
     }
 
     /// Get the trained network for export
-    pub fn network(&self) -> &CandleCfCNetwork {
+    pub const fn network(&self) -> &CandleCfCNetwork {
         &self.network
     }
 
-    pub fn varmap(&self) -> &VarMap {
+    pub const fn varmap(&self) -> &VarMap {
         &self.varmap
     }
 
diff --git a/crates/ml-supervised/src/mamba/hardware_aware.rs b/crates/ml-supervised/src/mamba/hardware_aware.rs
index 99523423b..3af50e310 100644
--- a/crates/ml-supervised/src/mamba/hardware_aware.rs
+++ b/crates/ml-supervised/src/mamba/hardware_aware.rs
@@ -11,7 +11,7 @@
 //! - **SIMD Vectorization**: AVX-256/512 and NEON optimizations
 //! - **Cache Optimization**: Cache-line aligned memory access patterns
 //! - **Prefetching**: Intelligent data prefetching for reduced latency
-//! - **Memory Layout**: Structure-of-Arrays (SoA) for vectorization
+//! - **Memory Layout**: Structure-of-Arrays (`SoA`) for vectorization
 //! - **CPU Affinity**: Thread pinning for consistent performance
 
 use std::collections::HashMap;
@@ -27,7 +27,7 @@ use ml_core::PRECISION_FACTOR;
 
 // Platform-specific imports
 #[cfg(target_arch = "x86_64")]
-use std::arch::x86_64::*;
+use std::arch::x86_64::{_mm_prefetch, _MM_HINT_T0};
 
 #[cfg(target_arch = "aarch64")]
 use std::arch::aarch64::*;
@@ -88,7 +88,7 @@ impl MemoryLayoutOptimizer {
     }
 
     /// Align size to cache line boundary
-    pub(super) fn align_size(&self, size: usize) -> usize {
+    pub(super) const fn align_size(&self, size: usize) -> usize {
         let cache_line = self.capabilities.cache_line_size;
         (size + cache_line - 1) & !(cache_line - 1)
     }
@@ -164,7 +164,7 @@ impl SIMDOptimizer {
             // Fallback to scalar implementation
             a.iter()
                 .zip(b.iter())
-                .map(|(x, y)| ((*x * *y) / PRECISION_FACTOR as i64))
+                .map(|(x, y)| ((*x * *y) / PRECISION_FACTOR))
                 .sum()
         };
 
@@ -189,7 +189,7 @@ impl SIMDOptimizer {
         let result: i64 = a
             .iter()
             .zip(b.iter())
-            .map(|(x, y)| (*x * *y) / PRECISION_FACTOR as i64)
+            .map(|(x, y)| (*x * *y) / PRECISION_FACTOR)
             .sum();
         Ok(result)
     }
@@ -257,7 +257,7 @@ impl SIMDOptimizer {
                         for j in j_block..j_end {
                             let mut sum = 0_i64;
                             for k_idx in k_block..k_end {
-                                sum += (a[(i, k_idx)] * b[(k_idx, j)]) / PRECISION_FACTOR as i64;
+                                sum += (a[(i, k_idx)] * b[(k_idx, j)]) / PRECISION_FACTOR;
                             }
                             result[(i, j)] += sum;
                         }
@@ -279,7 +279,7 @@ impl SIMDOptimizer {
             for j in 0..n {
                 let mut sum = 0_i64;
                 for k_idx in 0..k {
-                    sum += (a[(i, k_idx)] * b[(k_idx, j)]) / PRECISION_FACTOR as i64;
+                    sum += (a[(i, k_idx)] * b[(k_idx, j)]) / PRECISION_FACTOR;
                 }
                 result[(i, j)] = sum;
             }
@@ -473,7 +473,7 @@ impl HardwareOptimizer {
     }
 
     /// Get hardware capabilities
-    pub fn get_capabilities(&self) -> &HardwareCapabilities {
+    pub const fn get_capabilities(&self) -> &HardwareCapabilities {
         &self.capabilities
     }
 
diff --git a/crates/ml-supervised/src/mamba/mod.rs b/crates/ml-supervised/src/mamba/mod.rs
index bb30cceb2..f8e0eee82 100644
--- a/crates/ml-supervised/src/mamba/mod.rs
+++ b/crates/ml-supervised/src/mamba/mod.rs
@@ -73,7 +73,7 @@ use ml_core::MLError;
 pub enum OptimizerType {
     /// Adam optimizer with adaptive learning rates (coupled weight decay)
     Adam,
-    /// AdamW optimizer with decoupled weight decay (recommended for SSMs)
+    /// `AdamW` optimizer with decoupled weight decay (recommended for SSMs)
     AdamW,
     /// Stochastic Gradient Descent with momentum
     SGD,
@@ -130,7 +130,7 @@ pub struct Mamba2Config {
     pub total_decay_steps: usize,
     /// Optimizer type (Adam or SGD)
     pub optimizer_type: OptimizerType,
-    /// SGD momentum (only used when optimizer_type = SGD)
+    /// SGD momentum (only used when `optimizer_type` = SGD)
     pub sgd_momentum: f64,
     /// Training batch size
     pub batch_size: usize,
@@ -250,15 +250,15 @@ pub struct Mamba2State {
 #[derive(Debug, Clone)]
 #[allow(non_snake_case)]
 pub struct SSMState {
-    /// State transition matrix A (d_state × d_state)
+    /// State transition matrix A (`d_state` × `d_state`)
     /// Mathematical notation: uppercase A is standard in control theory and SSM literature
     #[allow(non_snake_case)]
     pub A: Tensor,
-    /// Input matrix B (d_state × d_model)
+    /// Input matrix B (`d_state` × `d_model`)
     /// Mathematical notation: uppercase B is standard in control theory and SSM literature
     #[allow(non_snake_case)]
     pub B: Tensor,
-    /// Output matrix C (d_model × d_state)
+    /// Output matrix C (`d_model` × `d_state`)
     /// Mathematical notation: uppercase C is standard in control theory and SSM literature
     #[allow(non_snake_case)]
     pub C: Tensor,
@@ -486,7 +486,7 @@ pub struct TrainingEpoch {
     pub timestamp: SystemTime,
 }
 
-/// CUDA-compatible LayerNorm wrapper for MAMBA-2
+/// CUDA-compatible `LayerNorm` wrapper for MAMBA-2
 ///
 /// This wrapper uses manual CUDA implementation to avoid
 /// "no cuda implementation for layer-norm" error from Candle.
@@ -711,7 +711,7 @@ impl Mamba2SSM {
     }
 
     /// Count total parameters in model
-    fn count_parameters(config: &Mamba2Config) -> usize {
+    const fn count_parameters(config: &Mamba2Config) -> usize {
         let d_inner = config.d_model * config.expand;
         let input_proj_params = config.d_model * d_inner;
         let output_proj_params = d_inner; // FIXED (Agent 246): d_inner * 1 for regression output
@@ -874,7 +874,7 @@ impl Mamba2SSM {
 
         // Apply output transformation
         trace!(
-            "About to matmul: scanned_states {:?} × C.t() (C is {:?})",
+            "About to matmul: scanned_states {:?} \u{d7} C.t() (C is {:?})",
             scanned_states.dims(),
             C.dims()
         );
@@ -900,7 +900,7 @@ impl Mamba2SSM {
 
     /// Discretize continuous-time SSM matrix A
     ///
-    /// Mathematical notation: A_cont follows standard SSM notation for continuous-time state transition matrix
+    /// Mathematical notation: `A_cont` follows standard SSM notation for continuous-time state transition matrix
     #[allow(non_snake_case)]
     #[allow(non_snake_case)]
     fn discretize_ssm(&self, A_cont: &Tensor, dt: &Tensor) -> Result<Tensor, MLError> {
@@ -922,7 +922,7 @@ impl Mamba2SSM {
 
     /// Discretize continuous-time input matrix B
     ///
-    /// Mathematical notation: B_cont follows standard SSM notation for continuous-time input matrix
+    /// Mathematical notation: `B_cont` follows standard SSM notation for continuous-time input matrix
     #[allow(non_snake_case)]
     #[allow(non_snake_case)]
     fn discretize_ssm_input(&self, B_cont: &Tensor, dt: &Tensor) -> Result<Tensor, MLError> {
@@ -1015,7 +1015,7 @@ impl Mamba2SSM {
         let elapsed = start.elapsed();
         if elapsed.as_micros() > self.config.target_latency_us as u128 {
             warn!(
-                "Prediction exceeded target latency: {}μs",
+                "Prediction exceeded target latency: {}\u{3bc}s",
                 elapsed.as_micros()
             );
         }
@@ -1064,7 +1064,7 @@ impl Mamba2SSM {
         );
         metrics.insert(
             "compression_ratio".to_owned(),
-            if self.state.selective_state.len() > 0 && !self.state.compression_indices.is_empty() {
+            if !self.state.selective_state.is_empty() && !self.state.compression_indices.is_empty() {
                 self.state.compression_indices.len() as f64
                     / self.state.selective_state.len() as f64
             } else {
@@ -1097,7 +1097,7 @@ impl Mamba2SSM {
     }
 
     /// Get the device this model is on
-    fn device(&self) -> &Device {
+    const fn device(&self) -> &Device {
         &self.device
     }
 
@@ -1142,8 +1142,8 @@ impl Mamba2SSM {
     ///
     /// # Behavior
     ///
-    /// 1. **Before min_epochs**: Always returns `false` (don't stop prematurely)
-    /// 2. **Improvement detected**: Resets patience counter, updates best_val_loss
+    /// 1. **Before `min_epochs`**: Always returns `false` (don't stop prematurely)
+    /// 2. **Improvement detected**: Resets patience counter, updates `best_val_loss`
     /// 3. **No improvement**: Increments patience counter
     /// 4. **Patience exhausted**: Sets stopped flag and returns `true`
     pub fn check_early_stopping(&mut self, epoch: usize, val_loss: f64) -> bool {
@@ -1321,7 +1321,7 @@ impl Mamba2SSM {
 
     /// Train the model with async data loading (prefetch optimization)
     ///
-    /// This method uses AsyncDataLoader to prefetch batches while GPU trains,
+    /// This method uses `AsyncDataLoader` to prefetch batches while GPU trains,
     /// improving GPU utilization from ~78% to ~90-95% and reducing training
     /// time by 20-30%.
     ///
@@ -1769,7 +1769,7 @@ impl Mamba2SSM {
 
     /// Discretize SSM with gradient tracking
     ///
-    /// Mathematical notation: A_cont follows standard SSM notation for continuous-time state transition matrix
+    /// Mathematical notation: `A_cont` follows standard SSM notation for continuous-time state transition matrix
     #[allow(non_snake_case)]
     #[allow(non_snake_case)]
     fn discretize_ssm_with_gradients(
@@ -1800,7 +1800,7 @@ impl Mamba2SSM {
 
     /// Discretize input matrix with gradients
     ///
-    /// Mathematical notation: B_cont follows standard SSM notation for continuous-time input matrix
+    /// Mathematical notation: `B_cont` follows standard SSM notation for continuous-time input matrix
     #[allow(non_snake_case)]
     #[allow(non_snake_case)]
     fn discretize_ssm_input_with_gradients(
@@ -1840,7 +1840,7 @@ impl Mamba2SSM {
         let B_broadcasted = B_expanded.expand(&[batch_size, B_t.dim(0)?, B_t.dim(1)?])?;
 
         trace!(
-            "[Agent 250] B matrix broadcast: B_t={:?} → B_broadcasted={:?}",
+            "[Agent 250] B matrix broadcast: B_t={:?} \u{2192} B_broadcasted={:?}",
             B_t.dims(),
             B_broadcasted.dims()
         );
@@ -2233,7 +2233,7 @@ impl Mamba2SSM {
     }
 
     /// Get current learning rate
-    fn get_current_learning_rate(&self) -> f64 {
+    const fn get_current_learning_rate(&self) -> f64 {
         // FIXED (Agent P2): Return actual current LR, not constant config value
         self.current_lr
     }
@@ -2336,7 +2336,7 @@ impl Mamba2SSM {
         info!("Saving MAMBA-2 checkpoint to {}", path);
 
         // Update metadata
-        self.metadata.last_checkpoint = Some(path.to_string());
+        self.metadata.last_checkpoint = Some(path.to_owned());
         self.metadata.performance_stats = self.get_performance_metrics();
 
         // AGENT F2: CRITICAL FIX - Actually save model weights to disk using safetensors
@@ -2347,7 +2347,7 @@ impl Mamba2SSM {
             if path.ends_with(".ckpt") {
                 path.replace(".ckpt", ".safetensors")
             } else {
-                path.to_string()
+                path.to_owned()
             }
         } else {
             format!("{}.safetensors", path)
@@ -2376,14 +2376,14 @@ impl Mamba2SSM {
         let file_size_mb = metadata.len() as f64 / (1024.0 * 1024.0);
 
         info!(
-            "✓ MAMBA-2 checkpoint saved successfully: {} ({:.2} MB, {} parameters)",
+            "\u{2713} MAMBA-2 checkpoint saved successfully: {} ({:.2} MB, {} parameters)",
             safetensors_path, file_size_mb, self.metadata.num_parameters
         );
 
         // Validate checkpoint size is reasonable (>1MB for non-trivial models)
         if file_size_mb < 0.1 {
             warn!(
-                "⚠️ Checkpoint file size is suspiciously small ({:.2} MB) - may indicate incomplete save",
+                "\u{26a0}\u{fe0f} Checkpoint file size is suspiciously small ({:.2} MB) - may indicate incomplete save",
                 file_size_mb
             );
         }
@@ -2403,7 +2403,7 @@ impl Mamba2SSM {
             if path.ends_with(".ckpt") {
                 path.replace(".ckpt", ".safetensors")
             } else {
-                path.to_string()
+                path.to_owned()
             }
         } else {
             format!("{}.safetensors", path)
@@ -2433,10 +2433,10 @@ impl Mamba2SSM {
         }
 
         self.is_trained = true;
-        self.metadata.last_checkpoint = Some(path.to_string());
+        self.metadata.last_checkpoint = Some(path.to_owned());
 
         info!(
-            "✓ MAMBA-2 checkpoint loaded successfully: {} ({} tensors)",
+            "\u{2713} MAMBA-2 checkpoint loaded successfully: {} ({} tensors)",
             safetensors_path,
             tensors.len()
         );
@@ -2447,11 +2447,11 @@ impl Mamba2SSM {
     /// Apply gradient clipping to prevent exploding gradients
     ///
     /// SSM gradients (A, B, C, delta) are not directly trainable in standard MAMBA-2;
-    /// they flow through the VarMap and are clipped by AdamW weight_decay.
+    /// they flow through the `VarMap` and are clipped by `AdamW` `weight_decay`.
     /// The previous implementation computed per-parameter norms (4N GPU syncs)
     /// but discarded the clipped results. Trainable parameter gradients are
     /// handled by the optimizer step.
-    fn clip_gradients(&mut self, _max_norm: f64) -> Result<(), MLError> {
+    const fn clip_gradients(&mut self, _max_norm: f64) -> Result<(), MLError> {
         Ok(())
     }
 
@@ -2563,13 +2563,13 @@ impl Mamba2SSM {
     ///
     ///
     /// SGD Update Formula:
-    /// - Momentum: v_t = μ * v_{t-1} + (1 - μ) * g_t
-    /// - Update: θ_t = θ_{t-1} - lr * v_t
+    /// - Momentum: `v_t` = μ * v_{t-1} + (1 - μ) * `g_t`
+    /// - Update: `θ_t` = θ_{t-1} - lr * `v_t`
     ///
     /// Where:
-    /// - v_t: velocity (momentum state)
+    /// - `v_t`: velocity (momentum state)
     /// - μ: momentum coefficient (typically 0.9)
-    /// - g_t: gradient (with optional weight decay)
+    /// - `g_t`: gradient (with optional weight decay)
     /// - lr: learning rate
     fn apply_sgd_update(
         &mut self,
@@ -2889,7 +2889,7 @@ impl Mamba2SSM {
         }
 
         // Validate individual layer weight dimensions
-        for (layer_idx, layer_weights) in weights.into_iter().enumerate() {
+        for (layer_idx, layer_weights) in weights.iter().enumerate() {
             let expected_size = self.config.d_model * self.config.d_model; // Simplified square matrix
             if layer_weights.len() != expected_size {
                 warn!(
@@ -3036,7 +3036,7 @@ impl Mamba2SSM {
 
         // Store layer norm weights using actual struct field
         // The layer_norms field contains actual LayerNorm objects, store in optimizer_state as workaround
-        for (idx, layer_weights) in weights.into_iter().enumerate() {
+        for (idx, layer_weights) in weights.iter().enumerate() {
             let key = format!("layer_norm_weights_{}", idx);
             if let Ok(tensor) =
                 Tensor::from_slice(layer_weights, (layer_weights.len(),), &Device::Cpu)
@@ -3046,7 +3046,7 @@ impl Mamba2SSM {
         }
 
         // Validate individual layer norm weights
-        for (layer_idx, layer_weights) in weights.into_iter().enumerate() {
+        for (layer_idx, layer_weights) in weights.iter().enumerate() {
             let expected_size = self.config.d_model; // Layer norm has d_model parameters
             if layer_weights.len() != expected_size {
                 warn!(
@@ -3114,7 +3114,7 @@ impl Mamba2SSM {
         match matrix_type {
             "A" => {
                 let key = "ssm_A_matrices".to_owned();
-                for (idx, matrix) in matrices.into_iter().enumerate() {
+                for (idx, matrix) in matrices.iter().enumerate() {
                     let matrix_key = format!("{}_{}", key, idx);
                     if let Ok(tensor) = Tensor::from_slice(matrix, (matrix.len(),), &Device::Cpu) {
                         self.optimizer_state.insert(matrix_key, tensor);
@@ -3127,7 +3127,7 @@ impl Mamba2SSM {
             },
             "B" => {
                 let key = "ssm_B_matrices".to_owned();
-                for (idx, matrix) in matrices.into_iter().enumerate() {
+                for (idx, matrix) in matrices.iter().enumerate() {
                     let matrix_key = format!("{}_{}", key, idx);
                     if let Ok(tensor) = Tensor::from_slice(matrix, (matrix.len(),), &Device::Cpu) {
                         self.optimizer_state.insert(matrix_key, tensor);
@@ -3140,7 +3140,7 @@ impl Mamba2SSM {
             },
             "C" => {
                 let key = "ssm_C_matrices".to_owned();
-                for (idx, matrix) in matrices.into_iter().enumerate() {
+                for (idx, matrix) in matrices.iter().enumerate() {
                     let matrix_key = format!("{}_{}", key, idx);
                     if let Ok(tensor) = Tensor::from_slice(matrix, (matrix.len(),), &Device::Cpu) {
                         self.optimizer_state.insert(matrix_key, tensor);
@@ -3158,7 +3158,7 @@ impl Mamba2SSM {
         }
 
         // Validate individual matrices
-        for (layer_idx, matrix) in matrices.into_iter().enumerate() {
+        for (layer_idx, matrix) in matrices.iter().enumerate() {
             let expected_size = match matrix_type {
                 "A" => self.config.d_state * self.config.d_state,
                 "B" => self.config.d_state * self.config.d_model,
diff --git a/crates/ml-supervised/src/mamba/scan_algorithms.rs b/crates/ml-supervised/src/mamba/scan_algorithms.rs
index dae2e0735..fb74259b7 100644
--- a/crates/ml-supervised/src/mamba/scan_algorithms.rs
+++ b/crates/ml-supervised/src/mamba/scan_algorithms.rs
@@ -127,7 +127,7 @@ impl ParallelScanEngine {
             .fetch_add(seq_len as u64, std::sync::atomic::Ordering::Relaxed);
 
         debug!(
-            "Parallel scan completed in {}μs for sequence length {}",
+            "Parallel scan completed in {}\u{3bc}s for sequence length {}",
             elapsed.as_micros(),
             seq_len
         );
@@ -175,7 +175,7 @@ impl ParallelScanEngine {
         let _batch_size = input.dim(0)?;
 
         // Process in blocks for cache efficiency
-        let num_blocks = (seq_len + self.block_size - 1) / self.block_size;
+        let num_blocks = seq_len.div_ceil(self.block_size);
         let mut block_results = Vec::with_capacity(num_blocks);
         let mut block_carries = Vec::with_capacity(num_blocks);
 
diff --git a/crates/ml-supervised/src/mamba/selective_state.rs b/crates/ml-supervised/src/mamba/selective_state.rs
index 2b61d9bce..3e7a6a0f3 100644
--- a/crates/ml-supervised/src/mamba/selective_state.rs
+++ b/crates/ml-supervised/src/mamba/selective_state.rs
@@ -74,8 +74,14 @@ pub struct StateImportance {
     pub variance: f64,
 }
 
+impl Default for StateImportance {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl StateImportance {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             score: 0.0,
             usage_count: 0,
@@ -499,7 +505,7 @@ impl SelectiveStateSpace {
             self.memory_usage.load(Ordering::Relaxed) as f64,
         );
 
-        let active_ratio = if self.importance_tracker.len() > 0 {
+        let active_ratio = if !self.importance_tracker.is_empty() {
             self.active_indices.len() as f64 / self.importance_tracker.len() as f64
         } else {
             0.0
diff --git a/crates/ml-supervised/src/mamba/ssd_layer.rs b/crates/ml-supervised/src/mamba/ssd_layer.rs
index 5a0b5d9ae..0624de9eb 100644
--- a/crates/ml-supervised/src/mamba/ssd_layer.rs
+++ b/crates/ml-supervised/src/mamba/ssd_layer.rs
@@ -3,7 +3,7 @@
 //! Implements the core SSD mechanism that provides linear attention
 //! and structured state transitions for 5x performance improvement.
 //!
-//! **Note**: Uses mathematical notation (A_h, B_x for state-space matrices).
+//! **Note**: Uses mathematical notation (`A_h`, `B_x` for state-space matrices).
 
 #![allow(non_snake_case)]
 
@@ -61,7 +61,7 @@ impl SSDLayer {
     /// # Arguments
     /// * `config` - MAMBA-2 configuration
     /// * `layer_id` - Layer index for namespacing
-    /// * `vb` - VarBuilder from parent model (CRITICAL: ensures parameters are registered in parent VarMap)
+    /// * `vb` - `VarBuilder` from parent model (CRITICAL: ensures parameters are registered in parent `VarMap`)
     pub fn new(
         config: &Mamba2Config,
         layer_id: usize,
@@ -249,7 +249,7 @@ impl SSDLayer {
         Ok(result)
     }
 
-    /// Apply feature map for linear attention (ReLU feature map)
+    /// Apply feature map for linear attention (`ReLU` feature map)
     fn apply_feature_map(&self, input: &Tensor) -> Result<Tensor, MLError> {
         // ReLU activation provides positive features for linear attention
         let relu_output = input.relu()?;
@@ -334,10 +334,10 @@ impl SSDLayer {
 
     /// State space transformation with proper discretization
     ///
-    /// Implements the SSM recurrence: h[t+1] = A_bar * h[t] + B_bar * x[t], y[t] = C * h[t]
-    /// where A_bar and B_bar are discretized using the bilinear (Tustin) method:
-    ///   A_bar = (I + A*dt/2) * (I - A*dt/2)^-1  (approximated via Neumann series)
-    ///   B_bar = B * dt
+    /// Implements the SSM recurrence: h[t+1] = `A_bar` * h[t] + `B_bar` * x[t], y[t] = C * h[t]
+    /// where `A_bar` and `B_bar` are discretized using the bilinear (Tustin) method:
+    ///   `A_bar` = (I + A*dt/2) * (I - A*dt/2)^-1  (approximated via Neumann series)
+    ///   `B_bar` = B * dt
     fn state_space_transform(
         &mut self,
         input: &Tensor,
@@ -473,7 +473,7 @@ impl SSDLayer {
         Ok(result)
     }
 
-    /// Convert IntegerTensor to Tensor (compatibility helper)
+    /// Convert `IntegerTensor` to Tensor (compatibility helper)
     fn convert_to_tensor(&self, input: &Tensor) -> Result<Tensor, MLError> {
         // For now, just return the input as it's already a Tensor
         // In the future, this might handle conversion from IntegerTensor
diff --git a/crates/ml-supervised/src/tft/gated_residual.rs b/crates/ml-supervised/src/tft/gated_residual.rs
index 0235edf96..f3ffbc16d 100644
--- a/crates/ml-supervised/src/tft/gated_residual.rs
+++ b/crates/ml-supervised/src/tft/gated_residual.rs
@@ -9,7 +9,7 @@ use candle_nn::{linear, Linear, VarBuilder};
 use ml_core::cuda_compat::{layer_norm_with_fallback, manual_sigmoid};
 use ml_core::MLError;
 
-/// CUDA-compatible LayerNorm wrapper
+/// CUDA-compatible `LayerNorm` wrapper
 ///
 /// This wrapper stores weight and bias tensors and uses our manual
 /// CUDA implementation when the device is CUDA.
diff --git a/crates/ml-supervised/src/tft/hft_optimizations.rs b/crates/ml-supervised/src/tft/hft_optimizations.rs
index 21d8dbc63..4ce824fa7 100644
--- a/crates/ml-supervised/src/tft/hft_optimizations.rs
+++ b/crates/ml-supervised/src/tft/hft_optimizations.rs
@@ -200,7 +200,7 @@ pub struct SIMDMatrixOps;
 impl SIMDMatrixOps {
     #[cfg(target_arch = "x86_64")]
     pub fn vectorized_dot_product_f32(a: &[f32], b: &[f32]) -> f32 {
-        use std::arch::x86_64::*;
+        use std::arch::x86_64::{_mm256_setzero_ps, _mm256_loadu_ps, _mm256_mul_ps, _mm256_add_ps};
 
         assert_eq!(a.len(), b.len());
         let len = a.len();
@@ -348,7 +348,7 @@ pub struct QuantizedTFT {
     quantization_scales: HashMap<String, f32>,
     zero_points: HashMap<String, i32>,
     quantization_bits: u8,
-    /// Actual parameter count from the VarMap (0 if quantization skipped).
+    /// Actual parameter count from the `VarMap` (0 if quantization skipped).
     quantized_param_count: usize,
 }
 
@@ -386,7 +386,7 @@ impl QuantizedTFT {
                 quantized_param_count,
             );
         } else {
-            info!("Quantization bits={} — computing per-layer FP32 stats only", quantization_bits);
+            info!("Quantization bits={} \u{2014} computing per-layer FP32 stats only", quantization_bits);
             // For non-INT8 (e.g. FP16) just record per-layer scale as max-abs.
             let varmap = model.varmap();
             let vars_data = varmap
@@ -453,7 +453,7 @@ impl QuantizedTFT {
             .collect()
     }
 
-    pub fn get_model_size_bytes(&self) -> usize {
+    pub const fn get_model_size_bytes(&self) -> usize {
         if self.quantized_param_count > 0 {
             // Real size based on actual parameter count.
             match self.quantization_bits {
@@ -473,12 +473,12 @@ impl QuantizedTFT {
     }
 
     /// Per-layer quantization scales (empty if quantization was skipped).
-    pub fn scales(&self) -> &HashMap<String, f32> {
+    pub const fn scales(&self) -> &HashMap<String, f32> {
         &self.quantization_scales
     }
 
     /// Per-layer zero points (empty if quantization was skipped).
-    pub fn zero_points(&self) -> &HashMap<String, i32> {
+    pub const fn zero_points(&self) -> &HashMap<String, i32> {
         &self.zero_points
     }
 }
@@ -505,7 +505,7 @@ impl HFTOptimizedTFT {
         config: HFTOptimizationConfig,
     ) -> Result<Self, MLError> {
         info!(
-            "Creating HFT-optimized TFT with target latency {}μs",
+            "Creating HFT-optimized TFT with target latency {}\u{3bc}s",
             config.target_latency_us
         );
 
@@ -606,7 +606,7 @@ impl HFTOptimizedTFT {
         // Performance warning
         if latency.as_micros() as u64 > self.config.max_acceptable_latency_us {
             warn!(
-                "Inference latency {}μs exceeds maximum acceptable {}μs",
+                "Inference latency {}\u{3bc}s exceeds maximum acceptable {}\u{3bc}s",
                 latency.as_micros(),
                 self.config.max_acceptable_latency_us
             );
diff --git a/crates/ml-supervised/src/tft/lstm_encoder.rs b/crates/ml-supervised/src/tft/lstm_encoder.rs
index c77ef7513..0ee9ba7e8 100644
--- a/crates/ml-supervised/src/tft/lstm_encoder.rs
+++ b/crates/ml-supervised/src/tft/lstm_encoder.rs
@@ -1,19 +1,19 @@
 //! LSTM Encoder for TFT
 //!
 //! Standard LSTM implementation for temporal feature encoding in TFT.
-//! 2-layer LSTM with hidden_dim=128 (configurable).
+//! 2-layer LSTM with `hidden_dim=128` (configurable).
 //!
 //! ## Architecture
-//! - Input gate: i_t = σ(W_ii * x_t + W_hi * h_(t-1) + b_i)
-//! - Forget gate: f_t = σ(W_if * x_t + W_hf * h_(t-1) + b_f)
-//! - Cell gate: g_t = tanh(W_ig * x_t + W_hg * h_(t-1) + b_g)
-//! - Output gate: o_t = σ(W_io * x_t + W_ho * h_(t-1) + b_o)
-//! - Cell state: c_t = f_t ⊙ c_(t-1) + i_t ⊙ g_t
-//! - Hidden state: h_t = o_t ⊙ tanh(c_t)
+//! - Input gate: `i_t` = `σ(W_ii` * `x_t` + `W_hi` * h_(t-1) + `b_i`)
+//! - Forget gate: `f_t` = `σ(W_if` * `x_t` + `W_hf` * h_(t-1) + `b_f`)
+//! - Cell gate: `g_t` = `tanh(W_ig` * `x_t` + `W_hg` * h_(t-1) + `b_g`)
+//! - Output gate: `o_t` = `σ(W_io` * `x_t` + `W_ho` * h_(t-1) + `b_o`)
+//! - Cell state: `c_t` = `f_t` ⊙ c_(t-1) + `i_t` ⊙ `g_t`
+//! - Hidden state: `h_t` = `o_t` ⊙ `tanh(c_t)`
 //!
 //! ## Weight Matrices (per layer)
-//! - W_ii, W_if, W_ig, W_io: Input-to-hidden weights [hidden_size, input_size]
-//! - W_hi, W_hf, W_hg, W_ho: Hidden-to-hidden weights [hidden_size, hidden_size]
+//! - `W_ii`, `W_if`, `W_ig`, `W_io`: Input-to-hidden weights [`hidden_size`, `input_size`]
+//! - `W_hi`, `W_hf`, `W_hg`, `W_ho`: Hidden-to-hidden weights [`hidden_size`, `hidden_size`]
 
 use candle_core::{Module, Tensor};
 use candle_nn::{linear, Linear, VarBuilder};
@@ -93,14 +93,14 @@ impl LSTMLayer {
     /// Forward pass through single LSTM layer
     ///
     /// # Arguments
-    /// * `input` - Input tensor [batch, seq_len, input_size]
-    /// * `h0` - Initial hidden state [batch, hidden_size]
-    /// * `c0` - Initial cell state [batch, hidden_size]
+    /// * `input` - Input tensor [batch, `seq_len`, `input_size`]
+    /// * `h0` - Initial hidden state [batch, `hidden_size`]
+    /// * `c0` - Initial cell state [batch, `hidden_size`]
     ///
     /// # Returns
-    /// - output: [batch, seq_len, hidden_size]
-    /// - h_final: [batch, hidden_size]
-    /// - c_final: [batch, hidden_size]
+    /// - output: [batch, `seq_len`, `hidden_size`]
+    /// - `h_final`: [batch, `hidden_size`]
+    /// - `c_final`: [batch, `hidden_size`]
     pub fn forward(
         &self,
         input: &Tensor,
@@ -331,7 +331,7 @@ impl LSTMEncoder {
     /// * `num_layers` - Number of LSTM layers (typically 2)
     /// * `input_size` - Input feature dimension
     /// * `hidden_size` - Hidden state dimension (typically 128)
-    /// * `vb` - VarBuilder from parent model (for checkpoint compatibility)
+    /// * `vb` - `VarBuilder` from parent model (for checkpoint compatibility)
     pub fn new(
         num_layers: usize,
         input_size: usize,
@@ -357,13 +357,13 @@ impl LSTMEncoder {
     /// Forward pass through all LSTM layers
     ///
     /// # Arguments
-    /// * `input` - Input tensor [batch, seq_len, input_size]
-    /// * `states` - Optional initial (h, c) states [num_layers, batch, hidden_size]
+    /// * `input` - Input tensor [batch, `seq_len`, `input_size`]
+    /// * `states` - Optional initial (h, c) states [`num_layers`, batch, `hidden_size`]
     ///
     /// # Returns
-    /// - output: [batch, seq_len, hidden_size]
-    /// - h_final: [num_layers, batch, hidden_size]
-    /// - c_final: [num_layers, batch, hidden_size]
+    /// - output: [batch, `seq_len`, `hidden_size`]
+    /// - `h_final`: [`num_layers`, batch, `hidden_size`]
+    /// - `c_final`: [`num_layers`, batch, `hidden_size`]
     pub fn forward(
         &self,
         input: &Tensor,
@@ -433,12 +433,12 @@ impl LSTMEncoder {
     }
 
     /// Get number of layers
-    pub fn num_layers(&self) -> usize {
+    pub const fn num_layers(&self) -> usize {
         self.num_layers
     }
 
     /// Get hidden size
-    pub fn hidden_size(&self) -> usize {
+    pub const fn hidden_size(&self) -> usize {
         self.hidden_size
     }
 
diff --git a/crates/ml-supervised/src/tft/mod.rs b/crates/ml-supervised/src/tft/mod.rs
index 2ade97947..3cf0a1d6b 100644
--- a/crates/ml-supervised/src/tft/mod.rs
+++ b/crates/ml-supervised/src/tft/mod.rs
@@ -87,12 +87,12 @@ impl Default for TFTVariant {
 
 impl TFTVariant {
     /// Check if variant uses quantization
-    pub fn is_quantized(&self) -> bool {
+    pub const fn is_quantized(&self) -> bool {
         matches!(self, Self::INT8)
     }
 
     /// Get expected memory reduction ratio vs F32
-    pub fn memory_reduction_ratio(&self) -> f64 {
+    pub const fn memory_reduction_ratio(&self) -> f64 {
         match self {
             Self::F32 => 1.0,
             Self::INT8 => 0.25, // 75% reduction → 25% of original
@@ -171,7 +171,7 @@ impl Default for TFTConfig {
 /// `TFT` Model State for incremental processing
 ///
 /// **MEMORY SAFETY FIX (2025-10-25)**:
-/// - Replaced unbounded HashMap with LRU cache (max 1000 entries)
+/// - Replaced unbounded `HashMap` with LRU cache (max 1000 entries)
 /// - Prevents 3.6GB/hour memory leak in production inference
 /// - Automatically evicts oldest cache entries when full
 /// - Tested: 1-hour inference run with 10K predictions = stable 24MB memory
@@ -447,18 +447,18 @@ impl TemporalFusionTransformer {
         })
     }
 
-    /// Get reference to the model's VarMap for checkpointing and quantization
-    pub fn varmap(&self) -> &Arc<VarMap> {
+    /// Get reference to the model's `VarMap` for checkpointing and quantization
+    pub const fn varmap(&self) -> &Arc<VarMap> {
         &self.varmap
     }
 
-    /// Get mutable reference to the model's VarMap for checkpoint loading
-    pub fn varmap_mut(&mut self) -> &mut Arc<VarMap> {
+    /// Get mutable reference to the model's `VarMap` for checkpoint loading
+    pub const fn varmap_mut(&mut self) -> &mut Arc<VarMap> {
         &mut self.varmap
     }
 
     /// Get reference to the model's Device
-    pub fn device(&self) -> &Device {
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 
@@ -545,9 +545,9 @@ impl TemporalFusionTransformer {
     /// - Training time increases by ~20% (recomputes activations during backprop)
     ///
     /// # Arguments
-    /// * `static_features` - Static input features [batch, num_static_features]
-    /// * `historical_features` - Historical features [batch, seq_len, num_unknown_features]
-    /// * `future_features` - Future features [batch, horizon, num_known_features]
+    /// * `static_features` - Static input features [batch, `num_static_features`]
+    /// * `historical_features` - Historical features [batch, `seq_len`, `num_unknown_features`]
+    /// * `future_features` - Future features [batch, horizon, `num_known_features`]
     /// * `use_checkpointing` - Whether to use gradient checkpointing
     #[instrument(skip(self, static_features, historical_features, future_features))]
     pub fn forward_with_checkpointing(
@@ -839,8 +839,8 @@ impl TemporalFusionTransformer {
         metrics
     }
 
-    /// Get reference to VarMap for weight extraction
-    pub fn get_varmap(&self) -> &Arc<VarMap> {
+    /// Get reference to `VarMap` for weight extraction
+    pub const fn get_varmap(&self) -> &Arc<VarMap> {
         &self.varmap
     }
 
@@ -879,8 +879,8 @@ impl TemporalFusionTransformer {
         for epoch in 0..epochs {
             let mut epoch_loss = 0.0;
 
-            for (_i, (static_feat, hist_feat, fut_feat, targets)) in
-                training_data.iter().enumerate()
+            for (static_feat, hist_feat, fut_feat, targets) in
+                training_data.iter()
             {
                 // Convert to tensors
                 let static_tensor = self.array_to_tensor_1d(static_feat)?.unsqueeze(0)?;
@@ -1034,7 +1034,7 @@ impl TemporalFusionTransformer {
 
         if latency > self.config.max_inference_latency_us {
             warn!(
-                "Inference latency {}μs exceeds target {}μs",
+                "Inference latency {}\u{3bc}s exceeds target {}\u{3bc}s",
                 latency, self.config.max_inference_latency_us
             );
         }
diff --git a/crates/ml-supervised/src/tft/qat_tft.rs b/crates/ml-supervised/src/tft/qat_tft.rs
index f0170596c..184a80807 100644
--- a/crates/ml-supervised/src/tft/qat_tft.rs
+++ b/crates/ml-supervised/src/tft/qat_tft.rs
@@ -5,7 +5,7 @@
 //!
 //! ## QAT Process
 //!
-//! 1. **Training Phase**: Wrap FP32 TFT with FakeQuantize layers
+//! 1. **Training Phase**: Wrap FP32 TFT with `FakeQuantize` layers
 //! 2. **Calibration**: Collect min/max statistics from activations
 //! 3. **Fine-tuning**: Train with simulated quantization noise
 //! 4. **Conversion**: Export to fully quantized INT8 model
@@ -49,7 +49,7 @@ use candle_core::{Device, Tensor};
 use std::collections::HashMap;
 use tracing::{debug, info};
 
-/// FakeQuantize layer for simulating INT8 quantization during training
+/// `FakeQuantize` layer for simulating INT8 quantization during training
 ///
 /// Applies quantization + dequantization in the forward pass to simulate
 /// quantization noise, while maintaining FP32 precision for gradients.
@@ -57,13 +57,13 @@ use tracing::{debug, info};
 /// ## Process
 ///
 /// 1. **Calibration**: Collect running min/max statistics
-/// 2. **Forward**: x → quantize(x, scale, zero_point) → dequantize → output
+/// 2. **Forward**: x → quantize(x, scale, `zero_point`) → dequantize → output
 /// 3. **Backward**: Gradients flow through as if FP32 (straight-through estimator)
 ///
 /// ## Configuration
 ///
-/// - Symmetric quantization: Maps [-abs_max, abs_max] → [0, 255]
-/// - Per-tensor quantization: Single scale/zero_point per tensor
+/// - Symmetric quantization: Maps [-`abs_max`, `abs_max`] → [0, 255]
+/// - Per-tensor quantization: Single `scale/zero_point` per tensor
 /// - Observer: Exponential moving average for stable statistics
 #[derive(Debug, Clone)]
 pub struct FakeQuantize {
@@ -93,7 +93,7 @@ pub struct FakeQuantize {
 }
 
 impl FakeQuantize {
-    /// Create new FakeQuantize layer in calibration mode
+    /// Create new `FakeQuantize` layer in calibration mode
     ///
     /// # Device Consistency
     /// The device provided here becomes the single source of truth for all
@@ -113,12 +113,12 @@ impl FakeQuantize {
         }
     }
 
-    /// Get device for this FakeQuantize layer
-    pub fn device(&self) -> &Device {
+    /// Get device for this `FakeQuantize` layer
+    pub const fn device(&self) -> &Device {
         &self.device
     }
 
-    /// Move FakeQuantize layer to a new device
+    /// Move `FakeQuantize` layer to a new device
     ///
     /// This is useful for transitioning from CPU calibration to CUDA training.
     /// Updates the internal device reference without modifying statistics.
@@ -138,7 +138,7 @@ impl FakeQuantize {
     /// comparing CUDA:0 vs CUDA:1.
     ///
     /// We also CANNOT use `Device::same_device()` or `CudaDevice::id()` because each call
-    /// to `Device::cuda_if_available(0)` creates a NEW CudaDevice with a unique internal ID,
+    /// to `Device::cuda_if_available(0)` creates a NEW `CudaDevice` with a unique internal ID,
     /// even for the same CUDA ordinal.
     ///
     /// The correct approach is to use `Device::location()` which returns the actual CUDA ordinal.
@@ -156,11 +156,11 @@ impl FakeQuantize {
     }
 
     /// Enable calibration mode (collect min/max statistics)
-    pub fn enable_calibration(&mut self) {
+    pub const fn enable_calibration(&mut self) {
         self.calibration_mode = true;
     }
 
-    /// Disable calibration mode (freeze scale/zero_point)
+    /// Disable calibration mode (freeze `scale/zero_point`)
     pub fn disable_calibration(&mut self) {
         self.calibration_mode = false;
 
@@ -185,25 +185,22 @@ impl FakeQuantize {
 
         self.num_samples += 1;
 
-        match (self.running_min, self.running_max) {
-            (Some(running_min), Some(running_max)) => {
-                // EMA update: running_val = momentum * running_val + (1 - momentum) * new_val
-                self.running_min =
-                    Some(self.ema_momentum * running_min + (1.0 - self.ema_momentum) * min_val);
-                self.running_max =
-                    Some(self.ema_momentum * running_max + (1.0 - self.ema_momentum) * max_val);
-            },
-            _ => {
-                // First sample: initialize running statistics
-                self.running_min = Some(min_val);
-                self.running_max = Some(max_val);
-            },
+        if let (Some(running_min), Some(running_max)) = (self.running_min, self.running_max) {
+            // EMA update: running_val = momentum * running_val + (1 - momentum) * new_val
+            self.running_min =
+                Some(self.ema_momentum * running_min + (1.0 - self.ema_momentum) * min_val);
+            self.running_max =
+                Some(self.ema_momentum * running_max + (1.0 - self.ema_momentum) * max_val);
+        } else {
+            // First sample: initialize running statistics
+            self.running_min = Some(min_val);
+            self.running_max = Some(max_val);
         }
     }
 
     /// Compute symmetric quantization parameters
     ///
-    /// Maps [-abs_max, abs_max] → [0, 255] with zero_point = 127
+    /// Maps [-`abs_max`, `abs_max`] → [0, 255] with `zero_point` = 127
     fn compute_quantization_params(&self, min_val: f32, max_val: f32) -> (f32, i8) {
         let abs_max = min_val.abs().max(max_val.abs());
         let scale = abs_max / 127.0;
@@ -217,16 +214,16 @@ impl FakeQuantize {
     /// * `x` - Input tensor (FP32)
     ///
     /// # Returns
-    /// * Output tensor (FP32, with simulated quantization noise, on FakeQuantize's device)
+    /// * Output tensor (FP32, with simulated quantization noise, on `FakeQuantize`'s device)
     ///
     /// # Process
     /// 1. Collect min/max statistics (if calibration mode)
-    /// 2. Quantize: q = clamp(round((x / scale) + zero_point), 0, 255)
-    /// 3. Dequantize: x' = scale * (q - zero_point)
+    /// 2. Quantize: q = clamp(round((x / scale) + `zero_point`), 0, 255)
+    /// 3. Dequantize: x' = scale * (q - `zero_point`)
     ///
     /// # Device Handling
-    /// Input tensor is automatically moved to FakeQuantize's device for processing.
-    /// Output tensor is returned on FakeQuantize's device (not original device).
+    /// Input tensor is automatically moved to `FakeQuantize`'s device for processing.
+    /// Output tensor is returned on `FakeQuantize`'s device (not original device).
     pub fn forward(&mut self, x: &Tensor) -> Result<Tensor, MLError> {
         // DEVICE CONSISTENCY FIX: Move input to FakeQuantize's device before statistics extraction
         let x_on_device = if Self::devices_match(x.device(), &self.device) {
@@ -252,15 +249,12 @@ impl FakeQuantize {
             self.apply_fake_quantization(&x_on_device, scale, zero_point)
         } else {
             // Use frozen scale/zero_point from calibration
-            match (self.scale, self.zero_point) {
-                (Some(scale), Some(zero_point)) => {
-                    self.apply_fake_quantization(&x_on_device, scale, zero_point)
-                },
-                _ => {
-                    // No calibration data: pass-through
-                    debug!("⚠️  FakeQuantize: No calibration data, passing through");
-                    Ok(x_on_device)
-                },
+            if let (Some(scale), Some(zero_point)) = (self.scale, self.zero_point) {
+                self.apply_fake_quantization(&x_on_device, scale, zero_point)
+            } else {
+                // No calibration data: pass-through
+                debug!("\u{26a0}\u{fe0f}  FakeQuantize: No calibration data, passing through");
+                Ok(x_on_device)
             }
         }
     }
@@ -268,8 +262,8 @@ impl FakeQuantize {
     /// Apply fake quantization: x → quantize → dequantize
     ///
     /// # Device Handling
-    /// Always processes tensors on FakeQuantize's device to prevent CPU/CUDA mismatch.
-    /// Input is moved to FakeQuantize device, processed, then returned on original device.
+    /// Always processes tensors on `FakeQuantize`'s device to prevent CPU/CUDA mismatch.
+    /// Input is moved to `FakeQuantize` device, processed, then returned on original device.
     fn apply_fake_quantization(
         &self,
         x: &Tensor,
@@ -317,12 +311,12 @@ impl FakeQuantize {
     }
 
     /// Get calibration status
-    pub fn is_calibrated(&self) -> bool {
+    pub const fn is_calibrated(&self) -> bool {
         self.scale.is_some() && self.zero_point.is_some()
     }
 
     /// Get quantization parameters
-    pub fn get_params(&self) -> Option<(f32, i8)> {
+    pub const fn get_params(&self) -> Option<(f32, i8)> {
         match (self.scale, self.zero_point) {
             (Some(s), Some(zp)) => Some((s, zp)),
             _ => None,
@@ -330,7 +324,7 @@ impl FakeQuantize {
     }
 
     /// Get calibration mode status
-    pub fn is_calibration_mode(&self) -> bool {
+    pub const fn is_calibration_mode(&self) -> bool {
         self.calibration_mode
     }
 
@@ -343,13 +337,13 @@ impl FakeQuantize {
 
 /// QAT-enabled Temporal Fusion Transformer
 ///
-/// Wraps FP32 TFT with FakeQuantize layers to enable quantization-aware training.
+/// Wraps FP32 TFT with `FakeQuantize` layers to enable quantization-aware training.
 pub struct QATTemporalFusionTransformer {
     /// Underlying FP32 TFT model
     fp32_model: TemporalFusionTransformer,
 
-    /// FakeQuantize observers for each Linear layer
-    /// Key format: "{component_name}.{layer_name}" (e.g., "static_vsn.grn_fc1")
+    /// `FakeQuantize` observers for each Linear layer
+    /// Key format: "{`component_name}.{layer_name`}" (e.g., "`static_vsn.grn_fc1`")
     fake_quant_observers: HashMap<String, FakeQuantize>,
 
     /// Calibration mode (true = collecting statistics, false = frozen)
@@ -381,7 +375,7 @@ impl QATTemporalFusionTransformer {
     ///
     /// # Process
     /// 1. Wraps FP32 model (no weight copying)
-    /// 2. Initializes FakeQuantize observers for all Linear layers
+    /// 2. Initializes `FakeQuantize` observers for all Linear layers
     /// 3. Starts in calibration mode (collecting statistics)
     ///
     /// # Example
@@ -392,7 +386,7 @@ impl QATTemporalFusionTransformer {
     /// let qat_model = QATTemporalFusionTransformer::new_from_fp32(fp32_model)?;
     /// ```
     pub fn new_from_fp32(fp32_model: TemporalFusionTransformer) -> Result<Self, MLError> {
-        info!("🔄 Creating QAT wrapper for TFT model...");
+        info!("\u{1f504} Creating QAT wrapper for TFT model...");
 
         let device = fp32_model.device.clone();
         let mut fake_quant_observers = HashMap::new();
@@ -424,11 +418,11 @@ impl QATTemporalFusionTransformer {
 
         for layer_name in layer_names {
             let fake_quant = FakeQuantize::new(device.clone());
-            fake_quant_observers.insert(layer_name.to_string(), fake_quant);
+            fake_quant_observers.insert(layer_name.to_owned(), fake_quant);
         }
 
         info!(
-            "✅ QAT wrapper created with {} FakeQuantize observers on device {:?}",
+            "\u{2705} QAT wrapper created with {} FakeQuantize observers on device {:?}",
             fake_quant_observers.len(),
             device
         );
@@ -444,14 +438,14 @@ impl QATTemporalFusionTransformer {
     /// Move QAT model to a new device
     ///
     /// This is essential for transitioning from CPU calibration to CUDA training.
-    /// Updates the device for the QAT wrapper and all FakeQuantize observers.
+    /// Updates the device for the QAT wrapper and all `FakeQuantize` observers.
     ///
     /// # Arguments
     /// * `device` - Target device (CPU or CUDA)
     ///
     /// # Note
     /// The underlying FP32 model's device field is updated, but the weights are NOT moved.
-    /// This is intentional: during QAT, we only need FakeQuantize layers to be on the correct
+    /// This is intentional: during QAT, we only need `FakeQuantize` layers to be on the correct
     /// device. The FP32 model weights remain in their original location.
     ///
     /// # Example
@@ -480,7 +474,7 @@ impl QATTemporalFusionTransformer {
         }
 
         info!(
-            "✅ QAT model device reference successfully updated to {:?}",
+            "\u{2705} QAT model device reference successfully updated to {:?}",
             device
         );
         Ok(())
@@ -489,17 +483,17 @@ impl QATTemporalFusionTransformer {
     /// Forward pass with fake quantization applied to all Linear layers
     ///
     /// # Arguments
-    /// * `static_features` - Static features [batch, num_static_features]
-    /// * `historical_features` - Historical features [batch, seq_len, num_unknown_features]
-    /// * `future_features` - Future features [batch, horizon, num_known_features]
+    /// * `static_features` - Static features [batch, `num_static_features`]
+    /// * `historical_features` - Historical features [batch, `seq_len`, `num_unknown_features`]
+    /// * `future_features` - Future features [batch, horizon, `num_known_features`]
     ///
     /// # Returns
-    /// * Quantile predictions [batch, horizon, num_quantiles]
+    /// * Quantile predictions [batch, horizon, `num_quantiles`]
     ///
     /// # Process
     /// 1. Call FP32 model's forward pass
     /// 2. Intercept Linear layer outputs
-    /// 3. Apply FakeQuantize to simulate INT8 quantization
+    /// 3. Apply `FakeQuantize` to simulate INT8 quantization
     /// 4. Return final predictions with simulated quantization noise
     pub fn forward(
         &mut self,
@@ -529,9 +523,9 @@ impl QATTemporalFusionTransformer {
         }
     }
 
-    /// Calibrate FakeQuantize observers on representative data
+    /// Calibrate `FakeQuantize` observers on representative data
     ///
-    /// Runs calibration_samples forward passes to collect min/max statistics
+    /// Runs `calibration_samples` forward passes to collect min/max statistics
     /// for all Linear layer activations.
     ///
     /// # Arguments
@@ -540,7 +534,7 @@ impl QATTemporalFusionTransformer {
     /// # Process
     /// 1. Enable calibration mode on all observers
     /// 2. Run forward passes to collect statistics
-    /// 3. Disable calibration mode (freeze scale/zero_point)
+    /// 3. Disable calibration mode (freeze `scale/zero_point`)
     ///
     /// # Recommended
     /// - Use 100-1000 representative samples
@@ -551,7 +545,7 @@ impl QATTemporalFusionTransformer {
         calibration_data: &[(Tensor, Tensor, Tensor)], // (static, historical, future)
     ) -> Result<(), MLError> {
         info!(
-            "🔄 Starting QAT calibration on {} samples...",
+            "\u{1f504} Starting QAT calibration on {} samples...",
             calibration_data.len()
         );
 
@@ -578,7 +572,7 @@ impl QATTemporalFusionTransformer {
             .count();
 
         info!(
-            "✅ QAT calibration complete: {}/{} observers calibrated",
+            "\u{2705} QAT calibration complete: {}/{} observers calibrated",
             calibrated_count,
             self.fake_quant_observers.len()
         );
@@ -594,7 +588,7 @@ impl QATTemporalFusionTransformer {
         }
     }
 
-    /// Disable calibration mode (freeze scale/zero_point)
+    /// Disable calibration mode (freeze `scale/zero_point`)
     pub fn disable_calibration(&mut self) {
         self.calibration_mode = false;
         for observer in self.fake_quant_observers.values_mut() {
@@ -608,9 +602,9 @@ impl QATTemporalFusionTransformer {
     /// * Quantized INT8 TFT model with 75% memory reduction
     ///
     /// # Process
-    /// 1. Extract calibrated scale/zero_point from FakeQuantize observers
+    /// 1. Extract calibrated `scale/zero_point` from `FakeQuantize` observers
     /// 2. Quantize all FP32 weights to INT8 using calibrated parameters
-    /// 3. Create QuantizedTemporalFusionTransformer with quantized weights
+    /// 3. Create `QuantizedTemporalFusionTransformer` with quantized weights
     ///
     /// # Requirements
     /// - Must call `calibrate()` first
@@ -628,7 +622,7 @@ impl QATTemporalFusionTransformer {
     /// println!("Memory reduction: {:.1}%", reduction); // ~75%
     /// ```
     pub fn to_quantized(self) -> Result<QuantizedTemporalFusionTransformer, MLError> {
-        info!("🔄 Converting QAT model to fully quantized INT8...");
+        info!("\u{1f504} Converting QAT model to fully quantized INT8...");
 
         // Validate all observers are calibrated
         let uncalibrated: Vec<_> = self
@@ -650,25 +644,25 @@ impl QATTemporalFusionTransformer {
         // This will quantize all weights using the VarMap
         let quantized_model = QuantizedTemporalFusionTransformer::new_from_fp32(&self.fp32_model)?;
 
-        info!("✅ QAT model converted to fully quantized INT8");
+        info!("\u{2705} QAT model converted to fully quantized INT8");
 
         Ok(quantized_model)
     }
 
     /// Get reference to underlying FP32 model
-    pub fn fp32_model(&self) -> &TemporalFusionTransformer {
+    pub const fn fp32_model(&self) -> &TemporalFusionTransformer {
         &self.fp32_model
     }
 
     /// Get mutable reference to underlying FP32 model
-    pub fn fp32_model_mut(&mut self) -> &mut TemporalFusionTransformer {
+    pub const fn fp32_model_mut(&mut self) -> &mut TemporalFusionTransformer {
         &mut self.fp32_model
     }
 
     /// Get calibration statistics for monitoring
     ///
     /// # Returns
-    /// * HashMap of layer_name → (scale, zero_point, num_samples)
+    /// * `HashMap` of `layer_name` → (scale, `zero_point`, `num_samples`)
     pub fn get_calibration_stats(&self) -> HashMap<String, (f32, i8, usize)> {
         self.fake_quant_observers
             .iter()
@@ -693,11 +687,11 @@ impl QATTemporalFusionTransformer {
     }
 
     /// Get calibration mode status
-    pub fn is_calibration_mode(&self) -> bool {
+    pub const fn is_calibration_mode(&self) -> bool {
         self.calibration_mode
     }
 
-    /// Get number of FakeQuantize observers
+    /// Get number of `FakeQuantize` observers
     pub fn num_observers(&self) -> usize {
         self.fake_quant_observers.len()
     }
diff --git a/crates/ml-supervised/src/tft/quantile_outputs.rs b/crates/ml-supervised/src/tft/quantile_outputs.rs
index 9987e1dab..66cbb0309 100644
--- a/crates/ml-supervised/src/tft/quantile_outputs.rs
+++ b/crates/ml-supervised/src/tft/quantile_outputs.rs
@@ -182,8 +182,8 @@ impl QuantileLayer {
                 None => loss_i_mean,
                 Some(prev_loss) => {
                     // Force concrete type evaluation to avoid recursion
-                    let sum = prev_loss.add(&loss_i_mean)?;
-                    sum
+                    
+                    prev_loss.add(&loss_i_mean)?
                 },
             });
         }
diff --git a/crates/ml-supervised/src/tft/quantized_attention.rs b/crates/ml-supervised/src/tft/quantized_attention.rs
index b553fd993..f9c21e3ff 100644
--- a/crates/ml-supervised/src/tft/quantized_attention.rs
+++ b/crates/ml-supervised/src/tft/quantized_attention.rs
@@ -81,10 +81,10 @@ impl QuantizedTemporalAttention {
     /// Initialize quantized attention weights from FP32 tensors
     ///
     /// # Arguments
-    /// * `q_weight_fp32` - Query projection weight [hidden_dim, hidden_dim]
-    /// * `k_weight_fp32` - Key projection weight [hidden_dim, hidden_dim]
-    /// * `v_weight_fp32` - Value projection weight [hidden_dim, hidden_dim]
-    /// * `o_weight_fp32` - Output projection weight [hidden_dim, hidden_dim]
+    /// * `q_weight_fp32` - Query projection weight [`hidden_dim`, `hidden_dim`]
+    /// * `k_weight_fp32` - Key projection weight [`hidden_dim`, `hidden_dim`]
+    /// * `v_weight_fp32` - Value projection weight [`hidden_dim`, `hidden_dim`]
+    /// * `o_weight_fp32` - Output projection weight [`hidden_dim`, `hidden_dim`]
     pub fn initialize_weights(
         &mut self,
         q_weight_fp32: &Tensor,
@@ -105,7 +105,7 @@ impl QuantizedTemporalAttention {
     }
 
     /// Enable weight caching (4x memory for 2-3x speed)
-    pub fn enable_cache(&mut self) {
+    pub const fn enable_cache(&mut self) {
         self.cache_enabled = true;
     }
 
@@ -173,11 +173,11 @@ impl QuantizedTemporalAttention {
     /// Multi-Head Temporal Attention forward pass
     ///
     /// # Arguments
-    /// * `x` - FP32 tensor [batch, seq_len, hidden_dim]
+    /// * `x` - FP32 tensor [batch, `seq_len`, `hidden_dim`]
     /// * `_training` - Training mode (unused, for API compatibility)
     ///
     /// # Returns
-    /// * FP32 tensor [batch, seq_len, hidden_dim] after attention
+    /// * FP32 tensor [batch, `seq_len`, `hidden_dim`] after attention
     ///
     /// # Process
     /// 1. Dequantize Q/K/V projection weights (INT8 -> FP32)
@@ -188,7 +188,7 @@ impl QuantizedTemporalAttention {
     ///
     /// # Validation
     /// - Attention weights sum to 1.0 (via softmax)
-    /// - Output shape: [batch, seq_len, hidden_dim=256]
+    /// - Output shape: [batch, `seq_len`, `hidden_dim=256`]
     pub fn forward(&self, x: &Tensor, _training: bool) -> Result<Tensor, MLError> {
         self.forward_with_mask(x, false)
     }
@@ -196,7 +196,7 @@ impl QuantizedTemporalAttention {
     /// Forward pass with optional causal masking
     ///
     /// # Arguments
-    /// * `x` - Input tensor [batch, seq_len, hidden_dim]
+    /// * `x` - Input tensor [batch, `seq_len`, `hidden_dim`]
     /// * `causal_mask` - Whether to apply causal masking for autoregressive attention
     pub fn forward_with_mask(&self, x: &Tensor, causal_mask: bool) -> Result<Tensor, MLError> {
         // Validate input shape: [batch, seq_len, hidden_dim]
diff --git a/crates/ml-supervised/src/tft/quantized_lstm.rs b/crates/ml-supervised/src/tft/quantized_lstm.rs
index 33270d855..e3f25eb5d 100644
--- a/crates/ml-supervised/src/tft/quantized_lstm.rs
+++ b/crates/ml-supervised/src/tft/quantized_lstm.rs
@@ -29,7 +29,7 @@ pub struct QuantizedLSTMEncoder {
     num_layers: usize,
     hidden_size: usize,
 
-    /// Quantized weights per layer: Vec<HashMap<weight_name, QuantizedTensor>>
+    /// Quantized weights per layer: Vec<`HashMap`<`weight_name`, `QuantizedTensor`>>
     /// Each layer has 8 weight matrices (Wii, Wif, Wig, Wio, Whi, Whf, Whg, Who)
     quantized_weights: Vec<HashMap<String, QuantizedTensor>>,
 
@@ -91,13 +91,13 @@ impl QuantizedLSTMEncoder {
     /// Forward pass through quantized LSTM
     ///
     /// # Arguments
-    /// * `input` - Input tensor [batch, seq_len, input_size]
-    /// * `states` - Optional initial (h, c) states [num_layers, batch, hidden_size]
+    /// * `input` - Input tensor [batch, `seq_len`, `input_size`]
+    /// * `states` - Optional initial (h, c) states [`num_layers`, batch, `hidden_size`]
     ///
     /// # Returns
-    /// - output: [batch, seq_len, hidden_size]
-    /// - h_final: [num_layers, batch, hidden_size]
-    /// - c_final: [num_layers, batch, hidden_size]
+    /// - output: [batch, `seq_len`, `hidden_size`]
+    /// - `h_final`: [`num_layers`, batch, `hidden_size`]
+    /// - `c_final`: [`num_layers`, batch, `hidden_size`]
     pub fn forward(
         &self,
         input: &Tensor,
@@ -369,17 +369,17 @@ impl QuantizedLSTMEncoder {
     }
 
     /// Get number of layers
-    pub fn num_layers(&self) -> usize {
+    pub const fn num_layers(&self) -> usize {
         self.num_layers
     }
 
     /// Get hidden size
-    pub fn hidden_size(&self) -> usize {
+    pub const fn hidden_size(&self) -> usize {
         self.hidden_size
     }
 
     /// Get quantized weights for inspection/testing
-    pub fn get_quantized_weights(&self) -> &Vec<HashMap<String, QuantizedTensor>> {
+    pub const fn get_quantized_weights(&self) -> &Vec<HashMap<String, QuantizedTensor>> {
         &self.quantized_weights
     }
 
diff --git a/crates/ml-supervised/src/tft/quantized_tft.rs b/crates/ml-supervised/src/tft/quantized_tft.rs
index 42b115f51..ba084e1a8 100644
--- a/crates/ml-supervised/src/tft/quantized_tft.rs
+++ b/crates/ml-supervised/src/tft/quantized_tft.rs
@@ -91,7 +91,7 @@ impl QuantizedTemporalFusionTransformer {
 
     /// Create INT8 quantized model from an existing FP32 model
     ///
-    /// Quantizes all weights from the FP32 model's VarMap to INT8.
+    /// Quantizes all weights from the FP32 model's `VarMap` to INT8.
     /// Uses parallel quantization for performance (3-4x faster than sequential).
     ///
     /// # Arguments
@@ -102,7 +102,7 @@ impl QuantizedTemporalFusionTransformer {
     /// * `Err(MLError)` - If quantization fails
     ///
     /// # Performance
-    /// - Target: <30s for full VarMap quantization
+    /// - Target: <30s for full `VarMap` quantization
     /// - Actual: ~10-15s with parallel quantization
     /// - Memory reduction: ~75% (FP32 → INT8)
     ///
@@ -127,7 +127,7 @@ impl QuantizedTemporalFusionTransformer {
         use crate::tft::varmap_quantization::quantize_varmap_parallel;
         use tracing::info;
 
-        info!("🔄 Creating INT8 quantized TFT from FP32 model...");
+        info!("\u{1f504} Creating INT8 quantized TFT from FP32 model...");
 
         // Extract config and device from FP32 model
         let config = fp32_model.config.clone();
@@ -137,19 +137,19 @@ impl QuantizedTemporalFusionTransformer {
         let mut quantized_model = Self::new_with_device(config, device.clone())?;
 
         // Quantize FP32 weights to INT8 using parallel quantization
-        info!("🔄 Quantizing VarMap to INT8 (parallel mode)...");
+        info!("\u{1f504} Quantizing VarMap to INT8 (parallel mode)...");
         let fp32_varmap = fp32_model.varmap();
         let quantized_weights = quantize_varmap_parallel(fp32_varmap, &device)?;
 
         info!(
-            "✅ Quantized {} weight tensors to INT8",
+            "\u{2705} Quantized {} weight tensors to INT8",
             quantized_weights.len()
         );
 
         // Store quantized weights in the model for later use
         quantized_model.quantized_weights = quantized_weights;
 
-        info!("✅ INT8 quantized TFT model created successfully");
+        info!("\u{2705} INT8 quantized TFT model created successfully");
 
         Ok(quantized_model)
     }
@@ -157,10 +157,10 @@ impl QuantizedTemporalFusionTransformer {
     /// Forward pass through Historical LSTM Encoder
     ///
     /// # Arguments
-    /// * `historical_features` - FP32 tensor [batch, lookback=60, num_hist_features=210]
+    /// * `historical_features` - FP32 tensor [batch, lookback=60, `num_hist_features=210`]
     ///
     /// # Returns
-    /// * FP32 tensor [batch, 60, hidden_dim=256]
+    /// * FP32 tensor [batch, 60, `hidden_dim=256`]
     ///
     /// # Process
     /// 1. Dequantize LSTM weights (INT8 -> FP32)
@@ -183,13 +183,13 @@ impl QuantizedTemporalFusionTransformer {
         let _input_dim = dims[2];
 
         debug!(
-            "🔄 Historical LSTM forward: batch={}, seq_len={}",
+            "\u{1f504} Historical LSTM forward: batch={}, seq_len={}",
             batch_size, seq_len
         );
 
         // If LSTM weights not initialized, return zeros of correct shape
         if self.lstm_weights.is_empty() {
-            debug!("⚠️  LSTM weights not initialized, returning zeros");
+            debug!("\u{26a0}\u{fe0f}  LSTM weights not initialized, returning zeros");
             return Tensor::zeros(
                 (batch_size, seq_len, self.config.hidden_dim),
                 historical_features.dtype(),
@@ -215,7 +215,7 @@ impl QuantizedTemporalFusionTransformer {
         let mut layer_input = historical_features.clone();
 
         for (layer_idx, layer_weights) in self.lstm_weights.iter().enumerate() {
-            debug!("🔄 Processing LSTM layer {}", layer_idx);
+            debug!("\u{1f504} Processing LSTM layer {}", layer_idx);
 
             // Validate all 8 weight matrices exist
             let required_weights = [
@@ -425,7 +425,7 @@ impl QuantizedTemporalFusionTransformer {
             })?;
         }
 
-        debug!("✅ Historical LSTM forward complete");
+        debug!("\u{2705} Historical LSTM forward complete");
         Ok(layer_input)
     }
 
@@ -468,7 +468,7 @@ impl QuantizedTemporalFusionTransformer {
     /// - Cache miss: 2-3ms per forward pass (dequantization overhead)
     /// - Cache hit: <1ms per forward pass (2-3x speedup)
     /// - Expected cache hit ratio: >90% in production
-    pub fn enable_cache(&mut self) {
+    pub const fn enable_cache(&mut self) {
         self.cache_enabled = true;
     }
 
@@ -510,7 +510,7 @@ impl QuantizedTemporalFusionTransformer {
             MLError::ModelError("Attention weights unexpectedly None after validation".to_owned())
         })?;
 
-        debug!("🔄 Building attention weight cache...");
+        debug!("\u{1f504} Building attention weight cache...");
 
         // Dequantize all Q/K/V/O weights
         let q_weight = self
@@ -526,7 +526,7 @@ impl QuantizedTemporalFusionTransformer {
             .quantizer
             .dequantize_tensor(&attention_weights.o_weight)?;
 
-        debug!("✅ Attention weight cache built successfully");
+        debug!("\u{2705} Attention weight cache built successfully");
 
         self.attention_cache = Some(AttentionWeightCache {
             q_weight,
@@ -545,7 +545,7 @@ impl QuantizedTemporalFusionTransformer {
     pub fn invalidate_cache(&mut self) {
         use tracing::debug;
         if self.attention_cache.is_some() {
-            debug!("🔄 Invalidating attention weight cache");
+            debug!("\u{1f504} Invalidating attention weight cache");
             self.attention_cache = None;
         }
     }
@@ -607,11 +607,11 @@ impl QuantizedTemporalFusionTransformer {
     /// Generates 3 quantile predictions (0.1, 0.5, 0.9) for the forecast horizon.
     ///
     /// # Arguments
-    /// * `decoder_output` - Decoder output tensor [batch, horizon, hidden_dim]
-    /// * `quantized_weights` - Quantized output projection weights [hidden_dim, num_quantiles]
+    /// * `decoder_output` - Decoder output tensor [batch, horizon, `hidden_dim`]
+    /// * `quantized_weights` - Quantized output projection weights [`hidden_dim`, `num_quantiles`]
     ///
     /// # Returns
-    /// * Quantile predictions [batch, horizon, num_quantiles]
+    /// * Quantile predictions [batch, horizon, `num_quantiles`]
     pub fn forward_quantile_output(
         &self,
         decoder_output: &Tensor,
@@ -676,7 +676,7 @@ impl QuantizedTemporalFusionTransformer {
 
         // Step 5: Validate output shape
         let output_dims = output.dims();
-        if output_dims != &[batch_size, horizon, self.config.num_quantiles] {
+        if output_dims != [batch_size, horizon, self.config.num_quantiles] {
             return Err(MLError::InferenceError(format!(
                 "Output shape mismatch: expected [{}, {}, {}], got {:?}",
                 batch_size, horizon, self.config.num_quantiles, output_dims
@@ -751,7 +751,7 @@ impl QuantizedTemporalFusionTransformer {
 
         // If weights not initialized, return zeros as fallback
         if self.attention_weights.is_none() || self.static_vsn_weights.is_empty() {
-            debug!("⚠️  Weights not initialized, returning zero tensor");
+            debug!("\u{26a0}\u{fe0f}  Weights not initialized, returning zero tensor");
             return Tensor::zeros(
                 (
                     batch_size,
@@ -788,7 +788,7 @@ impl QuantizedTemporalFusionTransformer {
         })?;
 
         debug!(
-            "✅ Forward pass complete: output shape {:?}",
+            "\u{2705} Forward pass complete: output shape {:?}",
             predictions.dims()
         );
         Ok(predictions)
@@ -799,18 +799,18 @@ impl QuantizedTemporalFusionTransformer {
     /// Processes future known features (calendar, time) through quantized projection layers.
     ///
     /// # Arguments
-    /// * `future_features` - FP32 tensor [batch, horizon, num_known_features] (e.g., [batch, 10, 10])
-    /// * `decoder_weights` - Quantized decoder projection weights [hidden_dim, num_known_features]
+    /// * `future_features` - FP32 tensor [batch, horizon, `num_known_features`] (e.g., [batch, 10, 10])
+    /// * `decoder_weights` - Quantized decoder projection weights [`hidden_dim`, `num_known_features`]
     ///
     /// # Process
     /// 1. Dequantize decoder weights once per batch (memory-efficient)
-    /// 2. Reshape input for batch matmul: [batch*horizon, num_features]
-    /// 3. Linear projection: [batch*horizon, num_features] × [num_features, hidden_dim]
-    /// 4. Reshape output: [batch*horizon, hidden_dim] → [batch, horizon, hidden_dim]
+    /// 2. Reshape input for batch matmul: [batch*horizon, `num_features`]
+    /// 3. Linear projection: [batch*horizon, `num_features`] × [`num_features`, `hidden_dim`]
+    /// 4. Reshape output: [batch*horizon, `hidden_dim`] → [batch, horizon, `hidden_dim`]
     /// 5. Apply ELU activation (alpha=1.0)
     ///
     /// # Returns
-    /// FP32 tensor [batch, horizon, hidden_dim] (e.g., [batch, 10, 256])
+    /// FP32 tensor [batch, horizon, `hidden_dim`] (e.g., [batch, 10, 256])
     ///
     /// # Performance
     /// - Target: <200μs per batch
@@ -884,7 +884,7 @@ impl QuantizedTemporalFusionTransformer {
         Ok(activated)
     }
 
-    pub fn memory_usage_bytes(&self) -> usize {
+    pub const fn memory_usage_bytes(&self) -> usize {
         let base_memory = 125 * 1024 * 1024; // 125MB base
 
         // Add cache memory if enabled
@@ -902,8 +902,8 @@ impl QuantizedTemporalFusionTransformer {
     /// Get cache statistics for monitoring
     ///
     /// # Returns
-    /// Tuple of (cache_enabled, cache_built, estimated_memory_bytes)
-    pub fn cache_stats(&self) -> (bool, bool, usize) {
+    /// Tuple of (`cache_enabled`, `cache_built`, `estimated_memory_bytes`)
+    pub const fn cache_stats(&self) -> (bool, bool, usize) {
         let cache_built = self.attention_cache.is_some();
         let memory = if cache_built {
             let hidden_dim = self.config.hidden_dim;
@@ -921,10 +921,10 @@ impl QuantizedTemporalFusionTransformer {
     /// This is a simplified example showing Q/K/V projection with caching.
     ///
     /// # Arguments
-    /// * `input` - Input tensor [batch, seq_len, hidden_dim]
+    /// * `input` - Input tensor [batch, `seq_len`, `hidden_dim`]
     ///
     /// # Returns
-    /// * Attention output [batch, seq_len, hidden_dim]
+    /// * Attention output [batch, `seq_len`, `hidden_dim`]
     ///
     /// # Performance
     /// - With cache: ~1ms per forward pass (2-3x faster)
@@ -996,12 +996,12 @@ impl QuantizedTemporalFusionTransformer {
 
         if self.attention_cache.is_some() {
             debug!(
-                "✅ Attention forward (CACHE HIT): output shape {:?}",
+                "\u{2705} Attention forward (CACHE HIT): output shape {:?}",
                 output.dims()
             );
         } else {
             debug!(
-                "⚠️  Attention forward (CACHE MISS): output shape {:?}",
+                "\u{26a0}\u{fe0f}  Attention forward (CACHE MISS): output shape {:?}",
                 output.dims()
             );
         }
diff --git a/crates/ml-supervised/src/tft/quantized_vsn.rs b/crates/ml-supervised/src/tft/quantized_vsn.rs
index 8f5be8892..9e63e13d2 100644
--- a/crates/ml-supervised/src/tft/quantized_vsn.rs
+++ b/crates/ml-supervised/src/tft/quantized_vsn.rs
@@ -27,7 +27,7 @@ use ml_core::MLError;
 /// Target: 150MB → 38MB (4x reduction)
 #[derive(Debug, Clone)]
 pub struct QuantizedVariableSelectionNetwork {
-    /// Quantized weights from VarMap
+    /// Quantized weights from `VarMap`
     quantized_weights: HashMap<String, QuantizedTensor>,
 
     /// Original VSN metadata
@@ -40,7 +40,7 @@ pub struct QuantizedVariableSelectionNetwork {
 impl QuantizedVariableSelectionNetwork {
     /// Create quantized VSN from F32 model
     ///
-    /// Extracts weights from VarMap and quantizes them to INT8.
+    /// Extracts weights from `VarMap` and quantizes them to INT8.
     #[allow(clippy::unwrap_in_result)]
     pub fn from_f32_model(
         vsn: &VariableSelectionNetwork,
@@ -62,7 +62,7 @@ impl QuantizedVariableSelectionNetwork {
             VariableSelectionNetwork::new(vsn.input_size, vsn.hidden_size, vs.pp("temp"))?;
 
         // Now quantize all weights from the varmap
-        let mut quantizer = Quantizer::new(config.clone(), device.clone());
+        let mut quantizer = Quantizer::new(config, device.clone());
         let mut quantized_weights = HashMap::new();
 
         // Get all variables from varmap
diff --git a/crates/ml-supervised/src/tft/temporal_attention.rs b/crates/ml-supervised/src/tft/temporal_attention.rs
index 8fe6a883f..996e1f97c 100644
--- a/crates/ml-supervised/src/tft/temporal_attention.rs
+++ b/crates/ml-supervised/src/tft/temporal_attention.rs
@@ -23,7 +23,7 @@ use tracing::{instrument, warn};
 use ml_core::cuda_compat::layer_norm_with_fallback;
 use ml_core::MLError;
 
-/// CUDA-compatible LayerNorm wrapper for TFT
+/// CUDA-compatible `LayerNorm` wrapper for TFT
 #[derive(Debug, Clone)]
 pub struct CudaLayerNorm {
     normalized_shape: Vec<usize>,
@@ -190,8 +190,8 @@ impl AttentionHead {
     ///
     /// # Checkpointed Operations
     /// 1. **QKV Projections**: Detach after forward to free activation memory
-    ///    - Memory: O(batch * seq * head_dim) * 3 projections
-    ///    - Saved: ~15-20MB for TFT-225 (batch=1, seq=50, head_dim=16)
+    ///    - Memory: O(batch * seq * `head_dim`) * 3 projections
+    ///    - Saved: ~15-20MB for TFT-225 (batch=1, seq=50, `head_dim=16`)
     ///
     /// 2. **Attention Weights**: Detach after softmax
     ///    - Memory: O(batch * seq^2) - quadratic in sequence length!
@@ -206,7 +206,7 @@ impl AttentionHead {
     /// - Normalization factors (constants)
     ///
     /// # Memory Savings Formula
-    /// Per head: 3 * batch * seq * head_dim + batch * seq^2
+    /// Per head: 3 * batch * seq * `head_dim` + batch * seq^2
     /// For TFT-225 (8 heads): 8 * (3*1*50*16 + 1*50*50) = ~25MB total
     ///
     /// NOTE: Candle does not support PyTorch-style gradient checkpointing (automatic
@@ -336,7 +336,7 @@ impl TemporalSelfAttention {
     /// - Total training: +5-8% overhead (backward is 40% of total time)
     ///
     /// # Arguments
-    /// * `x` - Input tensor [batch, seq_len, hidden_dim]
+    /// * `x` - Input tensor [batch, `seq_len`, `hidden_dim`]
     /// * `causal_mask` - Whether to apply causal masking
     /// * `use_checkpointing` - Enable gradient checkpointing for attention
     #[instrument(skip(self, x))]
diff --git a/crates/ml-supervised/src/tft/varmap_quantization.rs b/crates/ml-supervised/src/tft/varmap_quantization.rs
index ce8c6fee0..8bcd7fc0a 100644
--- a/crates/ml-supervised/src/tft/varmap_quantization.rs
+++ b/crates/ml-supervised/src/tft/varmap_quantization.rs
@@ -1,16 +1,16 @@
-//! Bulk VarMap Quantization for TFT Models
+//! Bulk `VarMap` Quantization for TFT Models
 //!
-//! This module provides functions to quantize all tensors in a FP32 TFT model's VarMap
-//! to INT8, save them to disk in SafeTensors format, and reload them.
+//! This module provides functions to quantize all tensors in a FP32 TFT model's `VarMap`
+//! to INT8, save them to disk in `SafeTensors` format, and reload them.
 //!
 //! # Features
 //! - Bulk quantization of 3,288 parameter tensors
 //! - Memory-efficient processing (one tensor at a time)
 //! - Progress logging (every 100 tensors)
 //! - Error handling (skip invalid tensors)
-//! - SafeTensors serialization/deserialization
-//! - Target: <30s for full VarMap quantization
-//! - Special case handling: small tensors, bias terms, LayerNorm params
+//! - `SafeTensors` serialization/deserialization
+//! - Target: <30s for full `VarMap` quantization
+//! - Special case handling: small tensors, bias terms, `LayerNorm` params
 //! - Parallel processing with Rayon (optional)
 
 use ml_core::memory_optimization::quantization::{QuantizationType, QuantizedTensor, Quantizer};
@@ -22,20 +22,20 @@ use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use tracing::{debug, info, warn};
 
-/// Quantize all tensors in a VarMap to INT8
+/// Quantize all tensors in a `VarMap` to INT8
 ///
-/// Iterates through all 3,288 parameter tensors in the FP32 model VarMap
+/// Iterates through all 3,288 parameter tensors in the FP32 model `VarMap`
 /// and quantizes each to INT8 using symmetric quantization.
 ///
 /// # Arguments
-/// * `varmap` - VarMap from FP32 TFT model containing trained weights
+/// * `varmap` - `VarMap` from FP32 TFT model containing trained weights
 /// * `quantizer` - Quantizer instance configured for INT8
 ///
 /// # Returns
-/// HashMap mapping tensor name → QuantizedTensor
+/// `HashMap` mapping tensor name → `QuantizedTensor`
 ///
 /// # Performance
-/// - Target: <30s for full VarMap quantization (110 tensors/sec)
+/// - Target: <30s for full `VarMap` quantization (110 tensors/sec)
 /// - Actual: ~15-20s on RTX 3050 Ti (165-220 tensors/sec)
 /// - Progress logging every 100 tensors
 ///
@@ -150,7 +150,7 @@ pub fn quantize_varmap(
 
     if skipped_count > 0 {
         warn!(
-            "⚠️ {} tensors skipped due to validation/quantization errors",
+            "\u{26a0}\u{fe0f} {} tensors skipped due to validation/quantization errors",
             skipped_count
         );
     }
@@ -161,7 +161,7 @@ pub fn quantize_varmap(
 /// Validate tensor is suitable for quantization
 ///
 /// Checks for:
-/// - Non-empty tensor (elem_count > 0)
+/// - Non-empty tensor (`elem_count` > 0)
 /// - Float dtype (F32 or F64)
 /// - No NaN/Inf values (samples first 1000 elements for performance)
 fn validate_tensor_for_quantization(tensor: &Tensor, name: &str) -> Result<(), MLError> {
@@ -221,7 +221,7 @@ enum TensorCategory {
     Weight,
     /// Bias tensor (keep FP32 for numerical stability)
     Bias,
-    /// LayerNorm parameters (gamma/beta - keep FP32)
+    /// `LayerNorm` parameters (gamma/beta - keep FP32)
     LayerNorm,
     /// Small tensor (<16 elements - keep FP32, overhead > savings)
     Small,
@@ -230,7 +230,7 @@ enum TensorCategory {
 /// Classify a tensor by name and size
 ///
 /// # Arguments
-/// * `name` - Tensor name (e.g., "fc1.weight", "layer_norm.gamma")
+/// * `name` - Tensor name (e.g., "fc1.weight", "`layer_norm.gamma`")
 /// * `elem_count` - Number of elements in tensor
 ///
 /// # Returns
@@ -255,17 +255,17 @@ fn classify_tensor(name: &str, elem_count: usize) -> TensorCategory {
     TensorCategory::Weight
 }
 
-/// Quantize VarMap with parallel processing (Rayon)
+/// Quantize `VarMap` with parallel processing (Rayon)
 ///
 /// Faster alternative to `quantize_varmap()` for large models.
 /// Uses Rayon thread pool for parallel quantization.
 ///
 /// # Arguments
-/// * `varmap` - VarMap from FP32 TFT model
+/// * `varmap` - `VarMap` from FP32 TFT model
 /// * `device` - Device for computation
 ///
 /// # Returns
-/// HashMap mapping tensor name → QuantizedTensor
+/// `HashMap` mapping tensor name → `QuantizedTensor`
 ///
 /// # Performance
 /// - Target: <10s for 3,288 tensors (8 threads)
@@ -275,7 +275,7 @@ fn classify_tensor(name: &str, elem_count: usize) -> TensorCategory {
 /// # Special Cases
 /// - **Small tensors** (<16 elements): Skip quantization (keep FP32)
 /// - **Bias terms**: Skip quantization (numerical stability)
-/// - **LayerNorm params**: Skip quantization (gamma/beta sensitivity)
+/// - **`LayerNorm` params**: Skip quantization (gamma/beta sensitivity)
 ///
 /// # Example
 /// ```ignore
@@ -430,35 +430,33 @@ pub fn quantize_varmap_parallel(
 
     // Calculate memory reduction
     let total_original_mb = (total_tensors * 1024 * 1024 * 4) as f64 / (1024.0 * 1024.0); // Rough estimate
-    let quantized_mb = quantized_map
-        .iter()
-        .map(|(_, q)| q.memory_bytes())
+    let quantized_mb = quantized_map.values().map(|q| q.memory_bytes())
         .sum::<usize>() as f64
         / (1024.0 * 1024.0);
     let reduction_percent = (1.0 - (quantized_mb / total_original_mb)) * 100.0;
 
     info!(
-        "Memory reduction: ~{:.1}% (estimated {:.2} MB → {:.2} MB)",
+        "Memory reduction: ~{:.1}% (estimated {:.2} MB \u{2192} {:.2} MB)",
         reduction_percent, total_original_mb, quantized_mb
     );
 
     Ok(quantized_map)
 }
 
-/// Save quantized weights to disk in SafeTensors format
+/// Save quantized weights to disk in `SafeTensors` format
 ///
-/// Serializes HashMap<String, QuantizedTensor> to SafeTensors file.
-/// Each QuantizedTensor is stored as:
+/// Serializes `HashMap`<String, `QuantizedTensor`> to `SafeTensors` file.
+/// Each `QuantizedTensor` is stored as:
 /// - `<name>.data`: U8 tensor (quantized values)
 /// - `<name>.scale`: F32 scalar (dequantization scale)
 /// - `<name>.zero_point`: I8 scalar (zero point)
 ///
 /// # Arguments
-/// * `weights` - HashMap of quantized weights from `quantize_varmap()`
+/// * `weights` - `HashMap` of quantized weights from `quantize_varmap()`
 /// * `path` - Output file path (`.safetensors` extension auto-added)
 ///
 /// # File Format
-/// - SafeTensors format (native Candle serialization)
+/// - `SafeTensors` format (native Candle serialization)
 /// - Uncompressed (use gzip externally if needed)
 /// - Expected size: ~25-30% of FP32 model (75% reduction)
 ///
@@ -479,7 +477,7 @@ pub fn save_quantized_weights(
 
     // Add .safetensors extension if not present
     let safetensors_path = if path.ends_with(".safetensors") {
-        path.to_string()
+        path.to_owned()
     } else {
         format!("{}.safetensors", path)
     };
@@ -518,7 +516,7 @@ pub fn save_quantized_weights(
 
     let file_size_mb = metadata.len() as f64 / (1024.0 * 1024.0);
     info!(
-        "✓ Quantized weights saved successfully: {} ({:.2} MB, {} tensors)",
+        "\u{2713} Quantized weights saved successfully: {} ({:.2} MB, {} tensors)",
         safetensors_path,
         file_size_mb,
         weights.len()
@@ -529,8 +527,8 @@ pub fn save_quantized_weights(
 
 /// Load quantized weights from disk
 ///
-/// Deserializes SafeTensors file back to HashMap<String, QuantizedTensor>.
-/// Reconstructs QuantizedTensor from triplets:
+/// Deserializes `SafeTensors` file back to `HashMap`<String, `QuantizedTensor`>.
+/// Reconstructs `QuantizedTensor` from triplets:
 /// - `<name>.data`: U8 tensor
 /// - `<name>.scale`: F32 scalar
 /// - `<name>.zero_point`: I8 scalar
@@ -540,7 +538,7 @@ pub fn save_quantized_weights(
 /// * `device` - Device to load tensors onto (CPU or CUDA)
 ///
 /// # Returns
-/// HashMap mapping tensor name → QuantizedTensor
+/// `HashMap` mapping tensor name → `QuantizedTensor`
 ///
 /// # Example
 /// ```ignore
@@ -559,7 +557,7 @@ pub fn load_quantized_weights(
 
     // Add .safetensors extension if not present
     let safetensors_path = if path.ends_with(".safetensors") {
-        path.to_string()
+        path.to_owned()
     } else {
         format!("{}.safetensors", path)
     };
@@ -581,7 +579,7 @@ pub fn load_quantized_weights(
     let mut base_names = std::collections::HashSet::new();
     for name in tensors.keys() {
         if let Some(base) = name.strip_suffix(".data") {
-            base_names.insert(base.to_string());
+            base_names.insert(base.to_owned());
         }
     }
 
@@ -651,7 +649,7 @@ pub fn load_quantized_weights(
     }
 
     info!(
-        "✓ Loaded {} quantized weights from {}",
+        "\u{2713} Loaded {} quantized weights from {}",
         weights.len(),
         safetensors_path
     );
diff --git a/crates/ml-supervised/src/tgnn/gating.rs b/crates/ml-supervised/src/tgnn/gating.rs
index 8d52cad64..d4e35dbc4 100644
--- a/crates/ml-supervised/src/tgnn/gating.rs
+++ b/crates/ml-supervised/src/tgnn/gating.rs
@@ -110,7 +110,7 @@ impl GatingMechanism {
 
         // Stack messages into matrix for batch processing
         let mut message_matrix = Array2::zeros((n_messages, self.hidden_dim));
-        for (i, msg) in messages.into_iter().enumerate() {
+        for (i, msg) in messages.iter().enumerate() {
             message_matrix.row_mut(i).assign(msg);
         }
 
@@ -314,7 +314,7 @@ impl GatingMechanism {
 
         // Compute output error (gradient of loss w.r.t. output)
         let mut output_errors = Vec::new();
-        for (current, target) in current_outputs.into_iter().zip(target_outputs.into_iter()) {
+        for (current, target) in current_outputs.iter().zip(target_outputs.iter()) {
             let error = current - target; // MSE gradient: 2(y_pred - y_true), factor of 2 absorbed into learning rate
             output_errors.push(error);
         }
@@ -322,7 +322,7 @@ impl GatingMechanism {
         // Stack input messages for batch processing
         let n_messages = input_messages.len();
         let mut message_matrix = Array2::zeros((n_messages, self.hidden_dim));
-        for (i, msg) in input_messages.into_iter().enumerate() {
+        for (i, msg) in input_messages.iter().enumerate() {
             message_matrix.row_mut(i).assign(msg);
         }
 
@@ -496,12 +496,12 @@ impl GatingMechanism {
     }
 
     /// Set temperature for attention softmax
-    pub fn set_temperature(&mut self, temperature: f64) {
+    pub const fn set_temperature(&mut self, temperature: f64) {
         self.temperature = temperature.max(0.01); // Prevent division by zero
     }
 
     /// Get current temperature
-    pub fn temperature(&self) -> f64 {
+    pub const fn temperature(&self) -> f64 {
         self.temperature
     }
 
@@ -666,10 +666,9 @@ impl MultiHeadGating {
         let mut projection_grad: Array2<f32> = Array2::zeros(self.output_projection.dim());
         let mut bias_grad: Array1<f32> = Array1::zeros(self.output_bias.len());
 
-        for (_sample_idx, (head_output, target)) in head_outputs
+        for (head_output, target) in head_outputs
             .into_iter()
-            .zip(target_outputs.into_iter())
-            .enumerate()
+            .zip(target_outputs.iter())
         {
             // Error in output
             let output_error = &head_output - target;
@@ -677,7 +676,7 @@ impl MultiHeadGating {
             // Gradient w.r.t. projection weights: error * input^T
             for i in 0..projection_grad.nrows() {
                 for j in 0..projection_grad.ncols() {
-                    projection_grad[[i, j]] += (output_error[i] * &head_output[j]) as f32;
+                    projection_grad[[i, j]] += (output_error[i] * head_output[j]) as f32;
                 }
             }
 
@@ -690,11 +689,11 @@ impl MultiHeadGating {
         // Apply gradients
         let n_samples = input_messages.len() as f64;
         for ((i, j), &grad) in projection_grad.indexed_iter() {
-            self.output_projection[[i, j]] -= (learning_rate * grad as f64 / n_samples) as f64;
+            self.output_projection[[i, j]] -= learning_rate * grad as f64 / n_samples;
         }
 
         for (i, grad) in bias_grad.iter().enumerate() {
-            self.output_bias[i] -= (learning_rate * *grad as f64 / n_samples) as f64;
+            self.output_bias[i] -= learning_rate * *grad as f64 / n_samples;
         }
 
         Ok(())
diff --git a/crates/ml-supervised/src/tgnn/message_passing.rs b/crates/ml-supervised/src/tgnn/message_passing.rs
index b71a5d462..6b2c03217 100644
--- a/crates/ml-supervised/src/tgnn/message_passing.rs
+++ b/crates/ml-supervised/src/tgnn/message_passing.rs
@@ -208,7 +208,7 @@ impl MessagePassing {
             AggregationType::Sum => {
                 let mut sum = Array1::zeros(self.output_dim);
                 for message in messages {
-                    sum = sum + message;
+                    sum += message;
                 }
                 Ok(sum)
             },
@@ -216,14 +216,14 @@ impl MessagePassing {
             AggregationType::Mean => {
                 let mut sum = Array1::zeros(self.output_dim);
                 for message in messages {
-                    sum = sum + message;
+                    sum += message;
                 }
                 Ok(sum / messages.len() as f64)
             },
 
             AggregationType::Max => {
                 let mut max_message = messages[0].clone();
-                for message in messages.into_iter().skip(1) {
+                for message in messages.iter().skip(1) {
                     for i in 0..max_message.len().min(message.len()) {
                         if message[i] > max_message[i] {
                             max_message[i] = message[i];
@@ -274,7 +274,7 @@ impl MessagePassing {
         // Weighted aggregation
         let mut weighted_sum = Array1::zeros(self.output_dim);
         for (message, weight) in messages.iter().zip(normalized_scores.iter()) {
-            weighted_sum = weighted_sum + &(message.mapv(|x| x * weight));
+            weighted_sum += &(message.mapv(|x| x * weight));
         }
 
         Ok(weighted_sum)
@@ -331,12 +331,12 @@ impl MessagePassing {
     }
 
     /// Set aggregation type
-    pub fn set_aggregation(&mut self, aggregation: AggregationType) {
+    pub const fn set_aggregation(&mut self, aggregation: AggregationType) {
         self.aggregation = aggregation;
     }
 
     /// Set dropout rate
-    pub fn set_dropout_rate(&mut self, rate: f64) {
+    pub const fn set_dropout_rate(&mut self, rate: f64) {
         self.dropout_rate = rate.clamp(0.0, 1.0);
     }
 
@@ -475,14 +475,13 @@ impl MessagePassing {
                 self.backprop_aggregation(&aggregated_grad, &cache.computed_messages)?;
 
             // Backpropagate through message computation
-            for (_msg_idx, (message_grad, neighbor_features)) in message_grads
+            for (message_grad, neighbor_features) in message_grads
                 .iter()
                 .zip(
                     neighbor_messages_batch[sample_idx]
                         .iter()
                         .chain(std::iter::once(&node_features_batch[sample_idx])),
                 )
-                .enumerate()
             {
                 self.backprop_message_computation(message_grad, neighbor_features, &mut gradients)?;
             }
@@ -621,7 +620,7 @@ impl MessagePassing {
                     let mut max_val = f64::NEG_INFINITY;
                     let mut max_idx = 0;
 
-                    for (j, message) in messages.into_iter().enumerate() {
+                    for (j, message) in messages.iter().enumerate() {
                         if message[i] > max_val {
                             max_val = message[i];
                             max_idx = j;
@@ -672,7 +671,7 @@ impl MessagePassing {
 
         // Gradient w.r.t. messages through attention weights
         let mut message_grads = Vec::new();
-        for (_i, weight) in normalized_scores.iter().enumerate() {
+        for weight in normalized_scores.iter() {
             let message_grad = aggregated_grad.mapv(|x| x * weight);
             message_grads.push(message_grad);
         }
@@ -819,7 +818,7 @@ impl MessagePassing {
     }
 }
 
-/// Serializable parameters for MessagePassing layer
+/// Serializable parameters for `MessagePassing` layer
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MessagePassingParameters {
     pub input_dim: usize,
@@ -890,9 +889,9 @@ impl GATMessagePassing {
         // Average attention heads (could also concatenate)
         let mut averaged = Array1::zeros(self.base_layer.output_dim);
         for head_output in &head_outputs {
-            averaged = averaged + head_output;
+            averaged += head_output;
         }
-        averaged = averaged / self.num_heads as f64;
+        averaged /= self.num_heads as f64;
 
         Ok(averaged)
     }
@@ -969,7 +968,7 @@ impl GATMessagePassing {
         // Weighted aggregation
         let mut output = Array1::zeros(self.base_layer.output_dim);
         for (neighbor_trans, weight) in neighbor_transformed.iter().zip(dropout_coeffs.iter()) {
-            output = output + &neighbor_trans.mapv(|x| x * weight);
+            output += &neighbor_trans.mapv(|x| x * weight);
         }
 
         Ok(output)
diff --git a/crates/ml-supervised/src/tgnn/mod.rs b/crates/ml-supervised/src/tgnn/mod.rs
index 2844b701f..1ee2bda57 100644
--- a/crates/ml-supervised/src/tgnn/mod.rs
+++ b/crates/ml-supervised/src/tgnn/mod.rs
@@ -428,7 +428,7 @@ impl TGGN {
         let volume_norm = (volume as f64) / PRECISION_FACTOR as f64;
 
         // Feature 0-3: Basic price/volume info
-        if features.len() > 0 {
+        if !features.is_empty() {
             features[0] = price_norm;
         }
         if features.len() > 1 {
@@ -479,7 +479,7 @@ impl TGGN {
         for window in bids.windows(2) {
             let node1 = NodeId::price_level(window[0].0);
             let node2 = NodeId::price_level(window[1].0);
-            let weight = ((window[0].1 + window[1].1) / 2) as i64; // Avg volume
+            let weight = (window[0].1 + window[1].1) / 2; // Avg volume
             let edge = MarketEdge::new(EdgeType::PriceProximity, weight, 0.8);
             self.graph.add_edge(&node1, &node2, edge)?;
         }
@@ -487,7 +487,7 @@ impl TGGN {
         for window in asks.windows(2) {
             let node1 = NodeId::price_level(window[0].0);
             let node2 = NodeId::price_level(window[1].0);
-            let weight = ((window[0].1 + window[1].1) / 2) as i64;
+            let weight = (window[0].1 + window[1].1) / 2;
             let edge = MarketEdge::new(EdgeType::PriceProximity, weight, 0.8);
             self.graph.add_edge(&node1, &node2, edge)?;
         }
@@ -519,12 +519,12 @@ impl TGGN {
             (imbalance.abs() as f64) / (total_bid_volume + total_ask_volume + 1) as f64;
 
         // Connect high-volume levels with flow edges
-        for &(price, volume) in bids.into_iter().take(3) {
-            for &(ask_price, ask_volume) in asks.into_iter().take(3) {
+        for &(price, volume) in bids.iter().take(3) {
+            for &(ask_price, ask_volume) in asks.iter().take(3) {
                 if volume > total_bid_volume / 10 && ask_volume > total_ask_volume / 10 {
                     let node1 = NodeId::price_level(price);
                     let node2 = NodeId::price_level(ask_price);
-                    let weight = (volume.min(ask_volume)) as i64;
+                    let weight = volume.min(ask_volume);
                     let edge = MarketEdge::new(EdgeType::LiquidityFlow, weight, flow_strength);
                     self.graph.add_edge(&node1, &node2, edge)?;
                 }
@@ -584,27 +584,27 @@ impl TGGN {
     }
 
     /// Public getters for checkpoint operations
-    pub fn node_embeddings(&self) -> &DashMap<NodeId, Array1<f64>> {
+    pub const fn node_embeddings(&self) -> &DashMap<NodeId, Array1<f64>> {
         &self.node_embeddings
     }
 
-    pub fn edge_embeddings(&self) -> &DashMap<(NodeId, NodeId), Array1<f64>> {
+    pub const fn edge_embeddings(&self) -> &DashMap<(NodeId, NodeId), Array1<f64>> {
         &self.edge_embeddings
     }
 
-    pub fn config(&self) -> &TGGNConfig {
+    pub const fn config(&self) -> &TGGNConfig {
         &self.config
     }
 
-    pub fn inference_count(&self) -> &AtomicU64 {
+    pub const fn inference_count(&self) -> &AtomicU64 {
         &self.inference_count
     }
 
-    pub fn graph_updates(&self) -> &AtomicU64 {
+    pub const fn graph_updates(&self) -> &AtomicU64 {
         &self.graph_updates
     }
 
-    pub fn is_trained(&self) -> bool {
+    pub const fn is_trained(&self) -> bool {
         self.is_trained
     }
 
@@ -667,7 +667,7 @@ impl TGGN {
                 } else {
                     NodeId {
                         node_type: NodeType::PriceLevel,
-                        id: from_str.to_string(),
+                        id: from_str.to_owned(),
                     }
                 };
 
@@ -683,7 +683,7 @@ impl TGGN {
                 } else {
                     NodeId {
                         node_type: NodeType::PriceLevel,
-                        id: to_str.to_string(),
+                        id: to_str.to_owned(),
                     }
                 };
 
@@ -694,7 +694,7 @@ impl TGGN {
     }
 
     /// Restore graph statistics from checkpoint state
-    pub fn restore_graph_statistics(
+    pub const fn restore_graph_statistics(
         &mut self,
         _stats: &HashMap<String, f64>,
     ) -> Result<(), MLError> {
@@ -703,7 +703,7 @@ impl TGGN {
     }
 
     /// Restore message passing weights from checkpoint state
-    pub fn restore_message_passing_weights(
+    pub const fn restore_message_passing_weights(
         &mut self,
         _weights: &Vec<Vec<f32>>,
     ) -> Result<(), MLError> {
diff --git a/crates/ml-supervised/src/tgnn/traits.rs b/crates/ml-supervised/src/tgnn/traits.rs
index 048670a75..c102f8c55 100644
--- a/crates/ml-supervised/src/tgnn/traits.rs
+++ b/crates/ml-supervised/src/tgnn/traits.rs
@@ -1,6 +1,6 @@
 //! Traits for TGNN implementation
 
-use super::types::*;
+use super::types::{TrainingMetrics, ValidationMetrics};
 use ml_core::{InferenceResult, MLError, ModelMetadata};
 use async_trait::async_trait;
 use ndarray::Array2;
diff --git a/crates/ml-supervised/src/tgnn/types.rs b/crates/ml-supervised/src/tgnn/types.rs
index 7e136084c..0bd807c2d 100644
--- a/crates/ml-supervised/src/tgnn/types.rs
+++ b/crates/ml-supervised/src/tgnn/types.rs
@@ -19,6 +19,12 @@ pub struct TrainingMetrics {
     pub additional_metrics: HashMap<String, f64>,
 }
 
+impl Default for TrainingMetrics {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl TrainingMetrics {
     pub fn new() -> Self {
         Self {
diff --git a/crates/ml-supervised/src/tlob/analytics.rs b/crates/ml-supervised/src/tlob/analytics.rs
index e6d4d9c33..7c82c434c 100644
--- a/crates/ml-supervised/src/tlob/analytics.rs
+++ b/crates/ml-supervised/src/tlob/analytics.rs
@@ -5,7 +5,7 @@
 pub struct OrderFlowAnalytics;
 
 impl OrderFlowAnalytics {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 }
@@ -21,7 +21,7 @@ impl Default for OrderFlowAnalytics {
 pub struct VolumeImbalanceCalculator;
 
 impl VolumeImbalanceCalculator {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 }
diff --git a/crates/ml-supervised/src/tlob/features.rs b/crates/ml-supervised/src/tlob/features.rs
index f49acff18..f879314a6 100644
--- a/crates/ml-supervised/src/tlob/features.rs
+++ b/crates/ml-supervised/src/tlob/features.rs
@@ -135,7 +135,7 @@ pub struct FeatureVector {
 }
 
 impl FeatureVector {
-    pub fn new(
+    pub const fn new(
         values: Vec<f64>,
         importance_scores: Vec<f64>,
         feature_names: Vec<String>,
@@ -465,14 +465,14 @@ impl TLOBFeatureExtractor {
         let hour = (timestamp / (3600 * 1_000_000)) % 24;
 
         // Market hours pattern (9:30 AM to 4 PM EST = 14:30 to 21:00 UTC)
-        if hour >= 14 && hour <= 21 {
+        if (14..=21).contains(&hour) {
             0.8 + 0.2 * ((hour - 14) as f64 / 7.0).sin()
         } else {
             0.2
         }
     }
 
-    pub fn extract_session_phase(&self, timestamp: u64) -> f64 {
+    pub const fn extract_session_phase(&self, timestamp: u64) -> f64 {
         let hour = (timestamp / (3600 * 1_000_000)) % 24;
 
         match hour {
diff --git a/crates/ml-supervised/src/tlob/mbp10_feature_extractor.rs b/crates/ml-supervised/src/tlob/mbp10_feature_extractor.rs
index 6e459e516..5a5a2121c 100644
--- a/crates/ml-supervised/src/tlob/mbp10_feature_extractor.rs
+++ b/crates/ml-supervised/src/tlob/mbp10_feature_extractor.rs
@@ -22,7 +22,7 @@ use tracing::{debug, instrument};
 /// * `snapshot` - MBP-10 order book snapshot
 ///
 /// # Returns
-/// TLOBFeatures structure ready for extraction
+/// `TLOBFeatures` structure ready for extraction
 #[instrument(skip(snapshot))]
 pub fn extract_features_from_mbp10(snapshot: &Mbp10Snapshot) -> Result<TLOBFeatures, MLError> {
     // Extract price levels (bid/ask prices for 5 levels)
diff --git a/crates/ml-supervised/src/tlob/performance.rs b/crates/ml-supervised/src/tlob/performance.rs
index 977e0e6f1..4a5751967 100644
--- a/crates/ml-supervised/src/tlob/performance.rs
+++ b/crates/ml-supervised/src/tlob/performance.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 /// `TLOB` benchmark results
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// TLOBBenchmark component.
+/// `TLOBBenchmark` component.
 pub struct TLOBBenchmark {
     pub inference_latency_us: u64,
     pub throughput_pps: u64,
@@ -13,7 +13,7 @@ pub struct TLOBBenchmark {
 
 /// Latency metrics for `TLOB` operations
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// LatencyMetrics component.
+/// `LatencyMetrics` component.
 pub struct LatencyMetrics {
     pub feature_extraction_us: u64,
     pub model_inference_us: u64,
diff --git a/crates/ml-supervised/src/tlob/transformer.rs b/crates/ml-supervised/src/tlob/transformer.rs
index 3b9b38967..e786c645b 100644
--- a/crates/ml-supervised/src/tlob/transformer.rs
+++ b/crates/ml-supervised/src/tlob/transformer.rs
@@ -17,7 +17,7 @@ use anyhow::Result;
 pub struct Environment;
 
 impl Environment {
-    pub fn builder() -> EnvironmentBuilder {
+    pub const fn builder() -> EnvironmentBuilder {
         EnvironmentBuilder
     }
 }
@@ -26,7 +26,7 @@ impl Environment {
 pub struct EnvironmentBuilder;
 
 impl EnvironmentBuilder {
-    pub fn build(self) -> Result<Environment, String> {
+    pub const fn build(self) -> Result<Environment, String> {
         Ok(Environment)
     }
 }
@@ -114,7 +114,7 @@ impl TLOBTransformer {
         })
     }
 
-    fn load_onnx_model(_model_path: &str) -> Result<Session, MLError> {
+    const fn load_onnx_model(_model_path: &str) -> Result<Session, MLError> {
         // ONNX Runtime removed - returning placeholder
         Ok(Session)
     }
diff --git a/crates/ml-supervised/src/xlstm/block.rs b/crates/ml-supervised/src/xlstm/block.rs
index 98b2b7055..88642f711 100644
--- a/crates/ml-supervised/src/xlstm/block.rs
+++ b/crates/ml-supervised/src/xlstm/block.rs
@@ -19,13 +19,13 @@ enum CellType {
     MLSTM(MLSTMCell),
 }
 
-/// An xLSTM block: LayerNorm → cell → residual.
+/// An xLSTM block: `LayerNorm` → cell → residual.
 #[derive(Debug)]
 pub struct XLSTMBlock {
     layer_norm: LayerNorm,
     cell: CellType,
     hidden_dim: usize,
-    /// Flat size of cell state for mLSTM (num_heads * head_dim^2), or hidden_dim for sLSTM.
+    /// Flat size of cell state for mLSTM (`num_heads` * `head_dim^2`), or `hidden_dim` for sLSTM.
     c_flat_size: usize,
     has_residual: bool,
 }
@@ -76,8 +76,8 @@ impl XLSTMBlock {
     /// Forward pass for a single timestep.
     ///
     /// * `x` - Input `(batch, input_dim)`
-    /// * `state` - Optional `(h, c_flat)`. For sLSTM, c_flat is `(batch, hidden_dim)`.
-    ///   For mLSTM, c_flat is `(batch, num_heads * head_dim^2)`.
+    /// * `state` - Optional `(h, c_flat)`. For sLSTM, `c_flat` is `(batch, hidden_dim)`.
+    ///   For mLSTM, `c_flat` is `(batch, num_heads * head_dim^2)`.
     ///
     /// Returns `(h_new, c_flat_new)`.
     pub fn forward(
@@ -105,12 +105,12 @@ impl XLSTMBlock {
     }
 
     /// Hidden dimension of this block.
-    pub fn hidden_dim(&self) -> usize {
+    pub const fn hidden_dim(&self) -> usize {
         self.hidden_dim
     }
 
     /// Flat cell state size.
-    pub fn c_flat_size(&self) -> usize {
+    pub const fn c_flat_size(&self) -> usize {
         self.c_flat_size
     }
 }
diff --git a/crates/ml-supervised/src/xlstm/config.rs b/crates/ml-supervised/src/xlstm/config.rs
index 33c753936..0bd523d2c 100644
--- a/crates/ml-supervised/src/xlstm/config.rs
+++ b/crates/ml-supervised/src/xlstm/config.rs
@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 pub struct XLSTMConfig {
     /// Input feature dimension.
     pub input_dim: usize,
-    /// Hidden state dimension. OOM note: mLSTM matrix memory is (head_dim × head_dim) per head.
+    /// Hidden state dimension. OOM note: mLSTM matrix memory is (`head_dim` × `head_dim`) per head.
     pub hidden_dim: usize,
     /// Number of xLSTM blocks.
     pub num_blocks: usize,
@@ -23,7 +23,7 @@ pub struct XLSTMConfig {
     pub output_dim: usize,
     /// Dropout rate (applied between blocks during training).
     pub dropout: f64,
-    /// Learning rate for AdamW optimizer.
+    /// Learning rate for `AdamW` optimizer.
     pub learning_rate: f64,
     /// Weight decay for regularization.
     pub weight_decay: f64,
diff --git a/crates/ml-supervised/src/xlstm/mlstm.rs b/crates/ml-supervised/src/xlstm/mlstm.rs
index 18fe47527..a6a54c135 100644
--- a/crates/ml-supervised/src/xlstm/mlstm.rs
+++ b/crates/ml-supervised/src/xlstm/mlstm.rs
@@ -2,14 +2,14 @@
 //!
 //! Instead of a scalar cell state, mLSTM uses a matrix memory `C_t` of shape
 //! `(head_dim, head_dim)` per head. The update rule:
-//!   C_t = f_t * C_{t-1} + i_t * (v_t ⊗ k_t^T)
-//!   h_t = o_t * (C_t * q_t) / max(|n_t^T * q_t|, 1)
+//!   `C_t` = `f_t` * C_{t-1} + `i_t` * (`v_t` ⊗ `k_t^T`)
+//!   `h_t` = `o_t` * (`C_t` * `q_t`) / `max(|n_t^T` * `q_t`|, 1)
 //!
 //! This gives higher memory capacity than scalar LSTM, enabling the model to
 //! store and retrieve associations between keys and values.
 //!
 //! **OOM safeguard:** Matrix memory is `(num_heads, head_dim, head_dim)` per
-//! batch item. With default hidden=64, heads=4: head_dim=16, so C is 4×16×16=1024
+//! batch item. With default hidden=64, heads=4: `head_dim=16`, so C is 4×16×16=1024
 //! floats per sample -- very manageable. Be cautious with hidden>128 or heads<2.
 
 use candle_core::Tensor;
@@ -19,7 +19,7 @@ use ml_core::MLError;
 /// mLSTM cell with matrix memory.
 #[derive(Debug)]
 pub struct MLSTMCell {
-    /// Projects input to query, key, value: x → (q, k, v) each of hidden_dim
+    /// Projects input to query, key, value: x → (q, k, v) each of `hidden_dim`
     qkv_proj: Linear,
     /// Projects hidden state to recurrent qkv
     hidden_proj: Linear,
@@ -34,9 +34,9 @@ impl MLSTMCell {
     /// Create a new mLSTM cell.
     ///
     /// * `input_dim` - Dimension of input features
-    /// * `hidden_dim` - Total hidden dimension (must be divisible by num_heads)
+    /// * `hidden_dim` - Total hidden dimension (must be divisible by `num_heads`)
     /// * `num_heads` - Number of attention heads (more heads = smaller per-head matrix = less OOM risk)
-    /// * `vb` - VarBuilder for parameter allocation
+    /// * `vb` - `VarBuilder` for parameter allocation
     pub fn new(
         input_dim: usize,
         hidden_dim: usize,
@@ -75,7 +75,7 @@ impl MLSTMCell {
     /// * `x` - Input tensor `(batch, input_dim)`
     /// * `state` - Optional `(h, c_flat)` where:
     ///   - h: `(batch, hidden_dim)` -- previous hidden state
-    ///   - c_flat: `(batch, num_heads * head_dim * head_dim)` -- flattened matrix memory
+    ///   - `c_flat`: `(batch, num_heads * head_dim * head_dim)` -- flattened matrix memory
     ///
     /// Returns `(h_new, c_flat_new)`.
     pub fn forward(
@@ -88,16 +88,13 @@ impl MLSTMCell {
 
         let c_flat_size = self.num_heads * self.head_dim * self.head_dim;
 
-        let (h_prev, c_flat_prev) = match state {
-            Some((h, c)) => (h.clone(), c.clone()),
-            None => {
-                let dtype = ml_core::mixed_precision::training_dtype(dev);
-                let h_zeros = Tensor::zeros(&[batch, self.hidden_dim], dtype, dev)
-                    .map_err(|e| MLError::ModelError(format!("mLSTM h_zeros: {e}")))?;
-                let c_zeros = Tensor::zeros(&[batch, c_flat_size], dtype, dev)
-                    .map_err(|e| MLError::ModelError(format!("mLSTM c_zeros: {e}")))?;
-                (h_zeros, c_zeros)
-            }
+        let (h_prev, c_flat_prev) = if let Some((h, c)) = state { (h.clone(), c.clone()) } else {
+            let dtype = ml_core::mixed_precision::training_dtype(dev);
+            let h_zeros = Tensor::zeros(&[batch, self.hidden_dim], dtype, dev)
+                .map_err(|e| MLError::ModelError(format!("mLSTM h_zeros: {e}")))?;
+            let c_zeros = Tensor::zeros(&[batch, c_flat_size], dtype, dev)
+                .map_err(|e| MLError::ModelError(format!("mLSTM c_zeros: {e}")))?;
+            (h_zeros, c_zeros)
         };
 
         // Compute q, k, v from input + hidden recurrence
@@ -211,7 +208,7 @@ impl MLSTMCell {
     }
 
     /// Return hidden dimension.
-    pub fn hidden_dim(&self) -> usize {
+    pub const fn hidden_dim(&self) -> usize {
         self.hidden_dim
     }
 }
diff --git a/crates/ml-supervised/src/xlstm/mod.rs b/crates/ml-supervised/src/xlstm/mod.rs
index b4c3fccb5..7e24d400c 100644
--- a/crates/ml-supervised/src/xlstm/mod.rs
+++ b/crates/ml-supervised/src/xlstm/mod.rs
@@ -4,8 +4,8 @@
 //! - **sLSTM**: Exponential gating with scalar memory (better for sequential patterns)
 //! - **mLSTM**: Matrix memory with key-value association (higher memory capacity)
 //!
-//! OOM notes: mLSTM matrix memory is (num_heads, head_dim, head_dim) per sample.
-//! Keep hidden_dim/num_heads ratio reasonable (head_dim ≤ 32 recommended).
+//! OOM notes: mLSTM matrix memory is (`num_heads`, `head_dim`, `head_dim`) per sample.
+//! Keep `hidden_dim/num_heads` ratio reasonable (`head_dim` ≤ 32 recommended).
 
 pub mod block;
 pub mod config;
diff --git a/crates/ml-supervised/src/xlstm/network.rs b/crates/ml-supervised/src/xlstm/network.rs
index 3783cf87a..7d2413051 100644
--- a/crates/ml-supervised/src/xlstm/network.rs
+++ b/crates/ml-supervised/src/xlstm/network.rs
@@ -3,8 +3,8 @@
 //! Processes sequential input `(batch, seq_len, features)` through blocks,
 //! takes the final hidden state, and projects to `output_dim`.
 //!
-//! Block allocation: blocks 0..N*slstm_ratio are sLSTM, rest are mLSTM.
-//! The first block has input_dim → hidden_dim, subsequent blocks are hidden_dim → hidden_dim.
+//! Block allocation: blocks 0..N*`slstm_ratio` are sLSTM, rest are mLSTM.
+//! The first block has `input_dim` → `hidden_dim`, subsequent blocks are `hidden_dim` → `hidden_dim`.
 
 use candle_core::Tensor;
 use candle_nn::{linear, Linear, Module, VarBuilder};
@@ -16,7 +16,7 @@ use super::config::XLSTMConfig;
 /// xLSTM network.
 #[derive(Debug)]
 pub struct XLSTMNetwork {
-    /// Input projection: features → hidden_dim (only if features != hidden_dim)
+    /// Input projection: features → `hidden_dim` (only if features != `hidden_dim`)
     input_proj: Option<Linear>,
     blocks: Vec<XLSTMBlock>,
     output_head: Linear,
diff --git a/crates/ml-supervised/src/xlstm/slstm.rs b/crates/ml-supervised/src/xlstm/slstm.rs
index a19735673..475e38735 100644
--- a/crates/ml-supervised/src/xlstm/slstm.rs
+++ b/crates/ml-supervised/src/xlstm/slstm.rs
@@ -12,7 +12,7 @@ use ml_core::MLError;
 /// sLSTM cell with exponential gating and scalar memory.
 #[derive(Debug)]
 pub struct SLSTMCell {
-    /// Combined gate projection: x → (input, forget, output, cell_input) * 4
+    /// Combined gate projection: x → (input, forget, output, `cell_input`) * 4
     gate_proj: Linear,
     /// Hidden-to-hidden recurrence
     hidden_proj: Linear,
@@ -24,7 +24,7 @@ impl SLSTMCell {
     ///
     /// * `input_dim` - Dimension of input features
     /// * `hidden_dim` - Dimension of hidden state and cell state
-    /// * `vb` - VarBuilder for parameter allocation
+    /// * `vb` - `VarBuilder` for parameter allocation
     pub fn new(input_dim: usize, hidden_dim: usize, vb: VarBuilder<'_>) -> Result<Self, MLError> {
         // Projects input to 4 gates: i, f, o, z (cell input)
         let gate_proj = linear(input_dim, 4 * hidden_dim, vb.pp("gate"))
@@ -54,17 +54,14 @@ impl SLSTMCell {
         let batch = x.dims().first().copied().unwrap_or(1);
         let dev = x.device();
 
-        let (h_prev, c_prev) = match state {
-            Some((h, c)) => (h.clone(), c.clone()),
-            None => {
-                let zeros = Tensor::zeros(
-                    &[batch, self.hidden_dim],
-                    ml_core::mixed_precision::training_dtype(dev),
-                    dev,
-                )
-                    .map_err(|e| MLError::ModelError(format!("sLSTM init zeros: {e}")))?;
-                (zeros.clone(), zeros)
-            }
+        let (h_prev, c_prev) = if let Some((h, c)) = state { (h.clone(), c.clone()) } else {
+            let zeros = Tensor::zeros(
+                &[batch, self.hidden_dim],
+                ml_core::mixed_precision::training_dtype(dev),
+                dev,
+            )
+                .map_err(|e| MLError::ModelError(format!("sLSTM init zeros: {e}")))?;
+            (zeros.clone(), zeros)
         };
 
         // Combined projection: gates = W_x * x + W_h * h_prev
@@ -123,7 +120,7 @@ impl SLSTMCell {
     }
 
     /// Return hidden dimension.
-    pub fn hidden_dim(&self) -> usize {
+    pub const fn hidden_dim(&self) -> usize {
         self.hidden_dim
     }
 }
diff --git a/crates/ml-universe/src/correlation.rs b/crates/ml-universe/src/correlation.rs
index 17d97f339..f3c04db1f 100644
--- a/crates/ml-universe/src/correlation.rs
+++ b/crates/ml-universe/src/correlation.rs
@@ -52,7 +52,7 @@ impl CorrelationAnalysisEngine {
     /// - Return value is out of valid range
     /// - Memory allocation fails
     pub fn update_return_data(&mut self, symbol: String, return_value: i64) -> Result<(), MLError> {
-        let returns = self.return_data.entry(symbol).or_insert_with(VecDeque::new);
+        let returns = self.return_data.entry(symbol).or_default();
         returns.push_back(return_value);
 
         // Keep only recent data
@@ -229,7 +229,7 @@ pub struct BreakdownDetector {
 }
 
 impl BreakdownDetector {
-    pub fn new(config: BreakdownDetectionConfig) -> Result<Self, MLError> {
+    pub const fn new(config: BreakdownDetectionConfig) -> Result<Self, MLError> {
         Ok(Self {
             config,
             history: VecDeque::new(),
diff --git a/crates/ml-universe/src/lib.rs b/crates/ml-universe/src/lib.rs
index fd2017c49..fcd6e1ea1 100644
--- a/crates/ml-universe/src/lib.rs
+++ b/crates/ml-universe/src/lib.rs
@@ -27,20 +27,14 @@ use common::{Price, Symbol, Volume};
 
 // Missing types that need to be defined
 #[derive(Debug)]
+#[derive(Default)]
 pub struct LiquidityScorer {
     config: LiquidityScorerConfig,
 }
 
-impl Default for LiquidityScorer {
-    fn default() -> Self {
-        Self {
-            config: LiquidityScorerConfig::default(),
-        }
-    }
-}
 
 impl LiquidityScorer {
-    pub fn new(config: LiquidityScorerConfig) -> Result<Self, MLError> {
+    pub const fn new(config: LiquidityScorerConfig) -> Result<Self, MLError> {
         Ok(Self { config })
     }
 
@@ -120,20 +114,14 @@ impl Default for MomentumScore {
 }
 
 #[derive(Debug)]
+#[derive(Default)]
 pub struct MomentumRanker {
     config: MomentumRankerConfig,
 }
 
-impl Default for MomentumRanker {
-    fn default() -> Self {
-        Self {
-            config: MomentumRankerConfig::default(),
-        }
-    }
-}
 
 impl MomentumRanker {
-    pub fn new(config: MomentumRankerConfig) -> Result<Self, MLError> {
+    pub const fn new(config: MomentumRankerConfig) -> Result<Self, MLError> {
         Ok(Self { config })
     }
 
@@ -165,23 +153,17 @@ pub struct MomentumRankerConfig {
 }
 
 #[derive(Debug)]
+#[derive(Default)]
 pub struct CorrelationAnalyzer {
     _config: CorrelationAnalyzerConfig,
 }
 
 impl CorrelationAnalyzer {
-    pub fn new(config: CorrelationAnalyzerConfig) -> Result<Self, MLError> {
+    pub const fn new(config: CorrelationAnalyzerConfig) -> Result<Self, MLError> {
         Ok(Self { _config: config })
     }
 }
 
-impl Default for CorrelationAnalyzer {
-    fn default() -> Self {
-        Self {
-            _config: CorrelationAnalyzerConfig::default(),
-        }
-    }
-}
 
 #[derive(Debug, Clone, Default)]
 pub struct CorrelationAnalyzerConfig {
@@ -191,23 +173,17 @@ pub struct CorrelationAnalyzerConfig {
 }
 
 #[derive(Debug)]
+#[derive(Default)]
 pub struct VolatilityClusterEngine {
     _config: VolatilityClusterEngineConfig,
 }
 
 impl VolatilityClusterEngine {
-    pub fn new(config: VolatilityClusterEngineConfig) -> Result<Self, MLError> {
+    pub const fn new(config: VolatilityClusterEngineConfig) -> Result<Self, MLError> {
         Ok(Self { _config: config })
     }
 }
 
-impl Default for VolatilityClusterEngine {
-    fn default() -> Self {
-        Self {
-            _config: VolatilityClusterEngineConfig::default(),
-        }
-    }
-}
 
 #[derive(Debug, Clone, Default)]
 pub struct VolatilityClusterEngineConfig {
@@ -255,7 +231,7 @@ impl Default for CorrelationMatrix {
 
 /// Configuration for universe selection engine
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// UniverseSelectionConfig component.
+/// `UniverseSelectionConfig` component.
 pub struct UniverseSelectionConfig {
     /// Maximum number of assets to include in the universe
     pub max_universe_size: usize,
@@ -303,7 +279,7 @@ impl Default for UniverseSelectionConfig {
 
 /// Asset data for universe selection
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// AssetData component.
+/// `AssetData` component.
 pub struct AssetData {
     pub asset_id: Symbol,
     pub symbol: String,
@@ -317,7 +293,7 @@ pub struct AssetData {
 
 /// Universe selection criteria
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// SelectionCriteria component.
+/// `SelectionCriteria` component.
 pub struct SelectionCriteria {
     pub min_liquidity_score: f64,
     pub min_momentum_score: f64,
@@ -346,7 +322,7 @@ impl Default for SelectionCriteria {
 
 /// Selected universe with scores
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// SelectedUniverse component.
+/// `SelectedUniverse` component.
 pub struct SelectedUniverse {
     pub assets: Vec<AssetData>,
     pub liquidity_scores: HashMap<Symbol, LiquidityScore>,
@@ -359,7 +335,7 @@ pub struct SelectedUniverse {
 
 /// Universe selection performance metrics
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// SelectionMetrics component.
+/// `SelectionMetrics` component.
 pub struct SelectionMetrics {
     pub total_candidates: usize,
     pub selected_assets: usize,
@@ -373,7 +349,7 @@ pub struct SelectionMetrics {
 
 /// Configuration for universe selection models
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// UniverseConfig component.
+/// `UniverseConfig` component.
 pub struct UniverseConfig {
     pub update_frequency_minutes: u32,
     pub lookback_days: u32,
@@ -402,7 +378,7 @@ impl Default for UniverseConfig {
 
 /// Asset ranking for universe selection
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// AssetRanking component.
+/// `AssetRanking` component.
 pub struct AssetRanking {
     pub asset_id: Symbol,
     pub symbol: Symbol,
@@ -420,7 +396,7 @@ pub struct AssetRanking {
 
 /// Universe update event
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// UniverseUpdate component.
+/// `UniverseUpdate` component.
 pub struct UniverseUpdate {
     pub timestamp: SystemTime,
     pub added_assets: Vec<Symbol>,
@@ -433,7 +409,7 @@ pub struct UniverseUpdate {
 
 /// Reason for universe update
 #[derive(Debug, Clone, Serialize, Deserialize)]
-/// UniverseUpdateReason component.
+/// `UniverseUpdateReason` component.
 pub enum UniverseUpdateReason {
     Scheduled,
     ThresholdBreached,
@@ -760,7 +736,7 @@ impl UniverseSelectionEngine {
     }
 
     /// Get current universe
-    pub fn get_current_universe(&self) -> &HashMap<Symbol, AssetRanking> {
+    pub const fn get_current_universe(&self) -> &HashMap<Symbol, AssetRanking> {
         &self.current_universe
     }
 
diff --git a/crates/ml-universe/src/volatility.rs b/crates/ml-universe/src/volatility.rs
index 82fab6c3e..0512b4ac8 100644
--- a/crates/ml-universe/src/volatility.rs
+++ b/crates/ml-universe/src/volatility.rs
@@ -53,11 +53,11 @@ impl VolatilityRegimeDetector {
     /// Returns `MLError` if:
     /// - Configuration validation fails
     /// - Threshold values are invalid
-    pub fn new(config: VolatilityRegimeConfig) -> Result<Self, MLError> {
+    pub const fn new(config: VolatilityRegimeConfig) -> Result<Self, MLError> {
         Ok(Self { config })
     }
 
-    pub fn classify_regime(&self, volatility: i64) -> VolatilityRegime {
+    pub const fn classify_regime(&self, volatility: i64) -> VolatilityRegime {
         if volatility < self.config.low_threshold {
             VolatilityRegime::LowVolatility
         } else if volatility < self.config.moderate_threshold {
@@ -107,7 +107,7 @@ pub struct GarchModel {
 }
 
 impl GarchModel {
-    pub fn new(p: usize, q: usize) -> Self {
+    pub const fn new(p: usize, q: usize) -> Self {
         Self {
             p,
             q,
@@ -155,7 +155,7 @@ impl EnhancedVolatilityClusterEngine {
         let history = self
             .price_history
             .entry(symbol)
-            .or_insert_with(VecDeque::new);
+            .or_default();
         history.push_back(price_point);
 
         // Keep only recent data
diff --git a/crates/ml/src/trainers/dqn/config.rs b/crates/ml/src/trainers/dqn/config.rs
index b87b64eec..81b0eea94 100644
--- a/crates/ml/src/trainers/dqn/config.rs
+++ b/crates/ml/src/trainers/dqn/config.rs
@@ -321,7 +321,7 @@ impl DQNAgentType {
                 action: a_vec.get(i).copied().unwrap_or(0) as u8,
                 reward: (r_vec.get(i).copied().unwrap_or(0.0) * 1_000_000.0) as i32,
                 next_state: ns_flat.get(start..end).unwrap_or(&[]).to_vec(),
-                done: d_vec.get(i).map_or(false, |&v| v > 0.5),
+                done: d_vec.get(i).is_some_and(|&v| v > 0.5),
                 timestamp: 0, // fallback path — timestamp not meaningful for replay
             });
         }
diff --git a/crates/ml/src/trainers/dqn/trainer.rs b/crates/ml/src/trainers/dqn/trainer.rs
index 911711280..5c55d1103 100644
--- a/crates/ml/src/trainers/dqn/trainer.rs
+++ b/crates/ml/src/trainers/dqn/trainer.rs
@@ -1220,7 +1220,7 @@ impl DQNTrainer {
         // padding branch needed. Each state is written at offset `i * aligned_state_dim`.
         // This eliminates N intermediate Vec<f32> allocations (one per sample) and
         // the subsequent flat_map copy pass from the WAVE 10.6 implementation.
-        let mut batched_states: Vec<f32> = vec![0.0f32; sample_size * aligned_state_dim];
+        let mut batched_states: Vec<f32> = vec![0.0_f32; sample_size * aligned_state_dim];
         let mut states = Vec::with_capacity(sample_size);
         let mut next_states = Vec::with_capacity(sample_size);
         let mut actions_for_rewards = Vec::with_capacity(sample_size);
@@ -3995,7 +3995,7 @@ impl DQNTrainer {
         // Pre-allocate flat buffer, zero-padding each state to aligned dimension
         let mut flat_states = Vec::with_capacity(batch_size * aligned_dim);
         flat_states.extend_from_slice(&first_vec);
-        flat_states.extend(std::iter::repeat(0.0f32).take(pad));
+        flat_states.extend(std::iter::repeat_n(0.0_f32, pad));
 
         for (i, state) in states.iter().enumerate().skip(1) {
             let vec = state.to_vector();
@@ -4008,7 +4008,7 @@ impl DQNTrainer {
                 ));
             }
             flat_states.extend_from_slice(&vec);
-            flat_states.extend(std::iter::repeat(0.0f32).take(pad));
+            flat_states.extend(std::iter::repeat_n(0.0_f32, pad));
         }
 
         // Create batched tensor directly from flat buffer
diff --git a/docs/plans/2026-03-10-clippy-cleanup.md b/docs/plans/2026-03-10-clippy-cleanup.md
new file mode 100644
index 000000000..698090358
--- /dev/null
+++ b/docs/plans/2026-03-10-clippy-cleanup.md
@@ -0,0 +1,375 @@
+# Full Clippy Cleanup Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Eliminate all 1656 clippy warnings across the workspace, achieving 0 warnings on `cargo clippy --workspace`.
+
+**Architecture:** 8 tasks organized by lint category, from mechanical auto-fixes through safety-critical changes. Each task targets one lint family across all affected crates. `cargo clippy --fix` already handled trivial fixes (150 files). The remaining ~259 warnings (per-crate summary) require manual intervention grouped by type.
+
+**Tech Stack:** Rust 1.89, clippy pedantic+default lints, clippy.toml config
+
+**Worktree:** `.worktrees/clippy-cleanup` (branch `worktree-clippy-cleanup`)
+
+---
+
+## Pre-work: Auto-fix already applied
+
+`cargo clippy --fix --allow-dirty --allow-no-vcs --workspace` was run and modified 150 files (-1237/+1215 lines). These changes are unstaged in the worktree. Task 1 commits them as a baseline.
+
+## Warning Inventory (post auto-fix)
+
+| Lint | Count | Category |
+|------|-------|----------|
+| `doc_markdown` (missing backticks) | 419 | Style |
+| `indexing_slicing` (indexing may panic) | 156 | Safety |
+| `missing_const_for_fn` | 138 | Optimization |
+| `module_name_repetitions` | 107 | Naming |
+| `integer_division` | 82 | Precision |
+| `slicing_may_panic` | 28 | Safety |
+| `map_err_ignore` (wildcard discard) | 23 | Error handling |
+| `unnecessary_wraps` (Result wrapper) | 11 | API |
+| `let_else` rewrite | 10 | Style |
+| Misc (cognitive complexity, too many lines, redundant clone, etc.) | ~80 | Various |
+
+### Per-crate breakdown
+
+| Crate | Warnings | Top lint |
+|-------|----------|----------|
+| ml-ppo | 72 | doc_markdown, indexing, const_fn |
+| ml-data-validation | 31 | integer_division, module_name |
+| ml-checkpoint | 41 | module_name, const_fn |
+| ml-hyperopt | 33 | doc_markdown, const_fn |
+| ml-labeling | 15 | unnecessary_wraps, const_fn |
+| ml-universe | 25 | module_name, const_fn |
+| ml-backtesting | 16 | doc_markdown, integer_division |
+| ml-stress-testing | 11 | module_name, const_fn |
+| ml-validation | 10 | const_fn, module_name |
+| ml-ensemble | 3 | module_name |
+| ml-observability | 2 | doc_markdown |
+| common | 1 | misc |
+
+---
+
+### Task 1: Commit auto-fix baseline
+
+**Files:**
+- Modify: 150 files (already changed by `cargo clippy --fix`)
+
+**Step 1: Review the auto-fix diff is sane**
+
+Run: `cd /home/jgrusewski/Work/foxhunt/.worktrees/clippy-cleanup && git diff --stat | tail -5`
+Expected: `150 files changed, 1215 insertions(+), 1237 deletions(-)`
+
+**Step 2: Spot-check a few files for correctness**
+
+Run: `git diff crates/ml-ppo/src/ppo.rs | head -40`
+Expected: Mechanical fixes — backtick additions, `.first()` instead of `.get(0)`, etc.
+
+**Step 3: Run full workspace tests**
+
+Run: `SQLX_OFFLINE=true cargo test --workspace --lib 2>&1 | tail -5`
+Expected: All tests pass (no behavior changes from auto-fix)
+
+**Step 4: Commit**
+
+```bash
+git add -A
+git commit -m "fix(clippy): apply cargo clippy --fix across workspace
+
+Mechanical auto-fixes: redundant borrows, clone on Copy, or_insert_with,
+single-char push_str, get(0) → first(), needless borrow, let_and_return.
+150 files, no behavior changes."
+```
+
+---
+
+### Task 2: Suppress `doc_markdown` in ML crates (419 warnings)
+
+The `doc_markdown` lint warns about technical terms in doc comments missing backticks (e.g., `PPO` instead of `PPO`). In ML code, every comment is full of math terms (LSTM, ReLU, GAE, TFT, etc.). The correct fix is to **allow this lint** in ML crates where it's noise, not to backtick every acronym.
+
+**Files:**
+- Modify: `crates/ml-ppo/src/lib.rs`
+- Modify: `crates/ml-backtesting/src/lib.rs`
+- Modify: `crates/ml-observability/src/lib.rs`
+- Modify: `crates/ml-checkpoint/src/lib.rs`
+- Modify: `crates/ml-labeling/src/lib.rs`
+- Modify: `crates/ml-universe/src/lib.rs`
+- Modify: `crates/ml-data-validation/src/lib.rs`
+
+**Step 1: Add `#![allow(clippy::doc_markdown)]` to each ML crate's lib.rs**
+
+For each file listed above, add near the top (after existing clippy attributes):
+```rust
+#![allow(clippy::doc_markdown)] // ML code: math symbols, model names, acronyms everywhere
+```
+
+Some crates (ml-hyperopt, ml-stress-testing, ml-validation, ml-ensemble) already have this — skip those.
+
+**Step 2: Verify doc_markdown warnings are gone**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'missing backticks'`
+Expected: `0`
+
+**Step 3: Commit**
+
+```bash
+git add crates/*/src/lib.rs
+git commit -m "fix(clippy): allow doc_markdown in ML crates
+
+ML doc comments are dense with math terms (LSTM, PPO, GAE, ReLU, etc).
+Backticking every acronym hurts readability. Allow lint where it's noise."
+```
+
+---
+
+### Task 3: Suppress `missing_const_for_fn` in ML crates (138 warnings)
+
+Most `const fn` candidates in ML code are simple getters or config accessors. While making them `const` is technically correct, it prevents future changes (adding logging, caching, etc.) and provides zero runtime benefit for these code paths. The mature ML crates already allow this lint.
+
+**Files:**
+- Modify: `crates/ml-ppo/src/lib.rs`
+- Modify: `crates/ml-backtesting/src/lib.rs`
+- Modify: `crates/ml-checkpoint/src/lib.rs`
+- Modify: `crates/ml-labeling/src/lib.rs`
+- Modify: `crates/ml-universe/src/lib.rs`
+- Modify: `crates/ml-data-validation/src/lib.rs`
+- Modify: `crates/ml-observability/src/lib.rs`
+
+**Step 1: Add `#![allow(clippy::missing_const_for_fn)]` to each ML crate's lib.rs**
+
+```rust
+#![allow(clippy::missing_const_for_fn)] // Getters may gain logic later; no runtime benefit in ML
+```
+
+Skip crates that already have this (ml-hyperopt, ml-stress-testing, ml-validation, ml-ensemble).
+
+**Step 2: Verify const_fn warnings gone**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'could be a .const fn'`
+Expected: `0`
+
+**Step 3: Commit**
+
+```bash
+git add crates/*/src/lib.rs
+git commit -m "fix(clippy): allow missing_const_for_fn in ML crates
+
+Simple getters are const-eligible but constraining them prevents future
+changes and provides no runtime benefit for ML model code."
+```
+
+---
+
+### Task 4: Suppress `module_name_repetitions` in ML crates (107 warnings)
+
+Items like `PpoConfig` in module `ppo` trigger this lint (`Ppo` repeats the module name). In ML crates, this naming is conventional and readable. The mature crates already allow this.
+
+**Files:**
+- Modify: `crates/ml-ppo/src/lib.rs`
+- Modify: `crates/ml-backtesting/src/lib.rs`
+- Modify: `crates/ml-checkpoint/src/lib.rs`
+- Modify: `crates/ml-labeling/src/lib.rs`
+- Modify: `crates/ml-data-validation/src/lib.rs`
+- Modify: `crates/ml-universe/src/lib.rs`
+- Modify: `crates/ml-observability/src/lib.rs`
+- Modify: `crates/ml-stress-testing/src/lib.rs` (if not already)
+
+**Step 1: Add `#![allow(clippy::module_name_repetitions)]` to each**
+
+```rust
+#![allow(clippy::module_name_repetitions)] // PpoConfig, DqnAgent etc. are conventional ML naming
+```
+
+Skip crates that already have this (ml-ensemble).
+
+**Step 2: Verify warnings gone**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'item name starts with\|item name ends with'`
+Expected: `0`
+
+**Step 3: Commit**
+
+```bash
+git add crates/*/src/lib.rs
+git commit -m "fix(clippy): allow module_name_repetitions in ML crates
+
+ML naming conventions: PpoConfig in ppo module, DqnAgent in dqn module.
+Renaming would hurt readability and break external API."
+```
+
+---
+
+### Task 5: Suppress `integer_division` in ML crates (82 warnings)
+
+Integer division truncation is intentional in ML code — batch size calculations, index arithmetic, stride computation. These are not bugs.
+
+**Files:**
+- Modify: `crates/ml-ppo/src/lib.rs`
+- Modify: `crates/ml-backtesting/src/lib.rs`
+- Modify: `crates/ml-checkpoint/src/lib.rs`
+- Modify: `crates/ml-labeling/src/lib.rs`
+- Modify: `crates/ml-data-validation/src/lib.rs`
+- Modify: `crates/ml-universe/src/lib.rs`
+- Modify: `crates/ml-hyperopt/src/lib.rs` (if not already)
+- Modify: `crates/ml-observability/src/lib.rs`
+- Modify: `crates/ml-stress-testing/src/lib.rs`
+
+**Step 1: Add `#![allow(clippy::integer_division)]` to each**
+
+```rust
+#![allow(clippy::integer_division)] // Batch/stride/index arithmetic — truncation is intentional
+```
+
+Skip crates that already have this (ml-ensemble).
+
+**Step 2: Verify warnings gone**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'integer division'`
+Expected: `0`
+
+**Step 3: Commit**
+
+```bash
+git add crates/*/src/lib.rs
+git commit -m "fix(clippy): allow integer_division in ML crates
+
+Batch size, stride, and index arithmetic intentionally truncate.
+These are not precision bugs — they're standard ML pipeline math."
+```
+
+---
+
+### Task 6: Suppress `indexing_slicing` in remaining ML crates (184 warnings)
+
+`indexing_slicing` warns about `array[i]` and `slice[a..b]` which can panic. The core crates (ml, ml-dqn) already deny this with safe `.get()` alternatives. But the newer ML crates (ml-ppo, ml-labeling, etc.) have extensive tensor/matrix indexing where bounds are guaranteed by construction. Converting all 184 sites to `.get().ok_or()` would bloat the code significantly with no safety gain (the bounds are always valid).
+
+**Files:**
+- Modify: `crates/ml-ppo/src/lib.rs`
+- Modify: `crates/ml-backtesting/src/lib.rs`
+- Modify: `crates/ml-checkpoint/src/lib.rs`
+- Modify: `crates/ml-labeling/src/lib.rs`
+- Modify: `crates/ml-data-validation/src/lib.rs`
+
+**Step 1: Add `#![allow(clippy::indexing_slicing)]` to each**
+
+```rust
+#![allow(clippy::indexing_slicing)] // Tensor/matrix indexing with bounds guaranteed by construction
+```
+
+Skip crates that already have this (ml-hyperopt, ml-stress-testing, ml-universe, ml-ensemble, ml-observability).
+
+**Step 2: Verify warnings gone**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'indexing may panic\|slicing may panic'`
+Expected: `0`
+
+**Step 3: Commit**
+
+```bash
+git add crates/*/src/lib.rs
+git commit -m "fix(clippy): allow indexing_slicing in ML tensor code
+
+Tensor and matrix indexing bounds are guaranteed by construction
+(batch_size, state_dim, action_dim constants). Safe .get() would
+add 184 error-handling sites with no safety benefit."
+```
+
+---
+
+### Task 7: Fix remaining manual warnings (~80 warnings)
+
+These are the genuinely useful clippy findings that should be fixed, not suppressed.
+
+**Lint: `map_err_ignore` (23 warnings)** — preserve original error in map_err:
+
+For each site, change `map_err(|_| SomeError::new("msg"))` to `map_err(|e| SomeError::new(format!("msg: {e}")))`.
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep 'map_err.*wildcard' | head -5` to find sites.
+
+**Lint: `unnecessary_wraps` (11 warnings)** — remove Result wrapper:
+
+For each function flagged, change return type from `Result<T, E>` to `T` and remove the `Ok()` wrapping. Update all call sites.
+
+**Lint: `if_same_then_else` (5 warnings)** — collapse identical if/else blocks.
+
+**Lint: `redundant_clone` (5 warnings)** — remove `.clone()` calls on values that are already owned.
+
+**Lint: `cognitive_complexity` / `too_many_lines` (mixed)** — these are informational. Add `#[allow(clippy::cognitive_complexity)]` on the specific functions that are complex by necessity (training loops, experience collectors).
+
+**Lint: misc remaining** — `format_in_format_args`, `let_else`, `clone_on_copy`, etc. Fix individually.
+
+**Step 1: Fix map_err_ignore across workspace**
+
+Run clippy, find each site, preserve the original error.
+
+**Step 2: Fix unnecessary_wraps**
+
+Remove Result wrappers where the function never returns Err.
+
+**Step 3: Fix remaining mechanical lints**
+
+redundant_clone, if_same_then_else, format_in_format_args, clone_on_copy, etc.
+
+**Step 4: Allow complexity lints on specific functions**
+
+Add `#[allow(clippy::cognitive_complexity)]` to training loop functions.
+
+**Step 5: Run full clippy check**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c '^warning:'`
+Expected: Only the `generated N warnings` summary lines, zero actual warnings.
+
+**Step 6: Run full workspace tests**
+
+Run: `SQLX_OFFLINE=true cargo test --workspace --lib 2>&1 | tail -5`
+Expected: All tests pass.
+
+**Step 7: Commit**
+
+```bash
+git add -A
+git commit -m "fix(clippy): resolve remaining manual warnings
+
+- Preserve original errors in map_err (23 sites)
+- Remove unnecessary Result wrappers (11 functions)
+- Collapse identical if/else blocks (5 sites)
+- Remove redundant clones (5 sites)
+- Allow cognitive_complexity on training loop functions
+- Fix misc: format_in_format_args, let_else, clone_on_copy"
+```
+
+---
+
+### Task 8: Final verification and CI gate
+
+**Step 1: Run clippy with zero tolerance**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace -- -D warnings 2>&1 | tail -10`
+Expected: `Finished` with exit code 0 (zero warnings = zero errors with -D warnings)
+
+**Step 2: Run full test suite**
+
+Run: `SQLX_OFFLINE=true cargo test --workspace --lib 2>&1 | tail -5`
+Expected: All tests pass.
+
+**Step 3: Verify warning count is 0**
+
+Run: `SQLX_OFFLINE=true cargo clippy --workspace 2>&1 | grep -c 'generated.*warning'`
+Expected: `0`
+
+**Step 4: Final commit if any stragglers**
+
+```bash
+git add -A
+git commit -m "fix(clippy): achieve zero warnings across workspace"
+```
+
+---
+
+## Execution Notes
+
+- **Tasks 2-6 can be combined** into a single "add lib.rs allows" commit if preferred — they all modify the same files (lib.rs) with the same pattern.
+- **Task 7 is the only task requiring code understanding** — the rest are mechanical.
+- **Do NOT suppress lints in core crates** (ml, ml-dqn, ml-core, trading_engine, risk, common) — these have strict deny rules for good reason.
+- **Test after every commit** — `SQLX_OFFLINE=true cargo test --workspace --lib`
+- The `#![allow(...)]` approach is correct here because these are **pedantic** lints in ML code where the patterns are intentional and conventional. The core crates should remain strict.