fix(ai): resolve import errors and test ordering in performance tracker

- Add missing PerformanceTracker import in factory.rs tests
- Fix unused variable warning in adaptive_timeout.rs tests
- Sort adapters by name in performance report for consistent ordering
- All 108 AI unit tests + 9 integration tests passing
- Release build clean

Author: LyeZinho

crates/mimi-cli/src/ai/adaptive_timeout.rs

@@ -117,7 +117,7 @@ mod tests {
             metrics.record_success(50 + i as u32);
         }
 
-        if let Some(p95) = metrics.percentile(95.0) {
+        if let Some(_p95) = metrics.percentile(95.0) {
             let old_timeout = timeout.current_timeout_ms;
             timeout.adjust_based_on_metrics(&metrics);
 

crates/mimi-cli/src/ai/factory.rs

@@ -82,6 +82,7 @@ impl AdapterFactory {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ai::PerformanceTracker;
 
     #[tokio::test]
     async fn test_factory_create_gemini() {

crates/mimi-cli/src/ai/performance_tracker.rs

@@ -120,6 +120,9 @@ impl PerformanceTracker {
             });
         }
 
+        // Sort adapters by name for consistent ordering
+        report_adapters.sort_by(|a, b| a.name.cmp(&b.name));
+
         let mut overall_health = SystemHealth::Healthy;
         let mut degraded_count = 0;
 

docs/M1.5.5-PERFORMANCE-MONITORING.md

@@ -0,0 +1,251 @@
+# M1.5.5: Adapter Performance Monitoring
+
+## Overview
+
+M1.5.5 extends the AI adapter system with comprehensive performance tracking and adaptive timeout adjustment. This enables the system to:
+
+- Track per-adapter latency percentiles (p50, p95, p99)
+- Detect performance degradation automatically
+- Adjust timeouts based on actual performance metrics
+- Recommend best-performing adapters
+- Report system-wide health status
+
+## Architecture
+
+### Components
+
+#### 1. **PerformanceMetrics** (`performance.rs`)
+Tracks real-time metrics for individual adapters:
+- Maintains a ringbuffer of last 100 latencies
+- Calculates success rate (successes / total requests)
+- Computes latency percentiles
+- Detects performance degradation (50%+ latency increase)
+- Tracks throughput (requests per second)
+
+```rust
+pub struct PerformanceMetrics {
+    pub adapter_name: String,
+    pub latencies: VecDeque<u32>,          // ringbuffer of last 100 latencies
+    pub successful_requests: u32,
+    pub failed_requests: u32,
+    pub last_recorded: chrono::DateTime<chrono::Utc>,
+    pub throughput_rps: f32,
+}
+```
+
+#### 2. **AdaptiveTimeout** (`adaptive_timeout.rs`)
+Adjusts timeout values based on performance metrics:
+- Baseline timeout (default 30000ms)
+- Calculates new timeout from p95 latency + margin (default 120%)
+- Respects min adjustment interval (default 5 seconds) to prevent thrashing
+- Never goes below baseline
+
+```rust
+pub struct AdaptiveTimeout {
+    pub adapter_name: String,
+    pub baseline_ms: u32,
+    pub current_timeout_ms: u32,
+    pub p95_margin_percent: f32,           // e.g., 120%
+    pub last_adjusted: chrono::DateTime<chrono::Utc>,
+    pub adjustment_interval_secs: u64,
+}
+```
+
+#### 3. **PerformanceTracker** (`performance_tracker.rs`)
+Aggregates metrics across all adapters and provides high-level insights:
+- Manages metrics + timeout for each adapter
+- Recommends best-performing adapter
+- Generates performance reports with system health status
+- Updates all timeouts based on current metrics
+
+```rust
+pub struct PerformanceTracker {
+    adapters: RwLock<HashMap<String, (Arc<RwLock<PerformanceMetrics>>, Arc<RwLock<AdaptiveTimeout>>)>>,
+}
+```
+
+#### 4. **PerformanceReport**
+Aggregated view of system performance:
+
+```rust
+pub struct PerformanceReport {
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+    pub adapters: Vec<AdapterPerformance>,
+    pub overall_health: SystemHealth,
+}
+
+pub enum SystemHealth {
+    Healthy,
+    Degraded,
+    Critical,
+}
+```
+
+### Registry Integration
+
+`AdapterRegistry` now optionally includes a `PerformanceTracker`:
+
+```rust
+pub struct AdapterRegistry {
+    pub adapters: RwLock<HashMap<String, (SharedAdapter, Arc<RwLock<AdapterHealth>>)>>,
+    pub priority: Vec<String>,
+    pub performance_tracker: Option<Arc<PerformanceTracker>>,
+}
+```
+
+New constructors:
+- `new_with_tracker(tracker: Arc<PerformanceTracker>)` - Create registry with tracker
+- `with_priority_and_tracker(priority, tracker)` - Custom priority + tracker
+
+New methods:
+- `get_timeout(adapter_name: &str) -> Result<u32>` - Get current timeout
+- `get_performance_report() -> Result<PerformanceReport>` - Get system report
+
+## Usage Flow
+
+### Basic Performance Tracking
+
+```rust
+let tracker = Arc::new(PerformanceTracker::new());
+
+tracker.register("gemini".to_string(), 30000);   // 30s baseline
+tracker.register("ollama".to_string(), 20000);   // 20s baseline
+
+tracker.record_success("gemini", 150).ok();      // 150ms latency
+tracker.record_success("ollama", 120).ok();
+tracker.record_failure("ollama").ok();           // failed request
+
+let report = tracker.get_performance_report();
+println!("{:?}", report.overall_health);
+```
+
+### Adapter Selection with Performance
+
+```rust
+let recommended = tracker.recommend_adapter().unwrap();
+println!("Use adapter: {}", recommended);  // Returns best performer
+```
+
+### Timeout Adjustment
+
+```rust
+tracker.update_all_timeouts().ok();         // Adjust based on metrics
+
+let new_timeout = tracker.get_timeout("gemini").unwrap();
+```
+
+### Registry Integration
+
+```rust
+let tracker = Arc::new(PerformanceTracker::new());
+let registry = AdapterRegistry::new_with_tracker(tracker.clone());
+
+tracker.register("gemini".to_string(), 30000);
+let timeout = registry.get_timeout("gemini")?;
+let report = registry.get_performance_report()?;
+```
+
+## Algorithm Details
+
+### Success Rate Calculation
+```
+success_rate = (successful_requests / (successful_requests + failed_requests)) * 100
+```
+
+### Latency Percentile Calculation
+1. Sort all recorded latencies
+2. Find value at (p / 100) * length position
+
+### Adaptive Timeout Calculation
+```
+new_timeout = max(
+    (p95_latency * p95_margin_percent) / 100,
+    baseline_ms
+)
+```
+
+### Degradation Detection
+- Compares p95 latency of recent half vs older half
+- Flags if recent > older by 50%+
+- Requires minimum 20 recorded latencies
+
+### Adapter Recommendation Score
+```
+score = success_rate - (average_latency / 100)
+```
+Recommends adapter with highest score.
+
+### System Health Status
+- **Healthy**: All adapters healthy, success rates > 50%
+- **Degraded**: More than 50% of adapters degraded
+- **Critical**: Any adapter with success rate < 50%
+
+## Data Flow
+
+```
+User Request
+    ↓
+Record Success/Failure
+    ↓
+Update Metrics (latency, counts)
+    ↓
+(Every 5+ seconds) Adjust Timeout based on p95
+    ↓
+(Query) Get Performance Report
+    ↓
+Recommend Best Adapter
+    ↓
+Return Metrics
+```
+
+## Test Coverage
+
+**Unit Tests** (30):
+- PerformanceMetrics: 10 tests
+- AdaptiveTimeout: 8 tests
+- PerformanceTracker: 12 tests
+
+**Integration Tests** (17):
+- Registry + Performance Tracker: 5 tests
+- Factory + Performance Tracker: 3 tests
+
+**Full Integration Tests** (9):
+- End-to-end flows with all components
+
+**Total: 56+ tests**
+
+## Configuration
+
+### PerformanceMetrics
+- Latency ringbuffer: 100 entries
+- Percentiles calculated on demand
+
+### AdaptiveTimeout
+- Baseline timeout: configurable per adapter
+- P95 margin: 120% (configurable)
+- Min adjustment interval: 5 seconds
+- Never goes below baseline
+
+### PerformanceTracker
+- Auto-cleanup on update_all_timeouts()
+- Recommends based on success_rate - latency score
+
+## Error Handling
+
+All operations return `AdapterResult<T>`:
+- `AdapterNotFound`: Adapter not registered
+- `AllAdaptersFailed`: No adapters available / tracker not initialized
+
+## Future Enhancements
+
+1. **Persistence**: Save metrics to storage between sessions
+2. **Thresholds**: Configurable degradation detection thresholds
+3. **Alerts**: Notify when adapter performance drops below threshold
+4. **Metrics Export**: Prometheus/Grafana integration
+5. **Per-Model Metrics**: Track performance per model type
+6. **Cost Tracking**: Integrate with PerformanceTracker for cost optimization
+
+## Related Milestones
+
+- **M1.5.1-M1.5.4**: AI adapter infrastructure
+- **M1.6**: Integration & CLI integration of adapters with monitoring