Fix storage display issues and use dynamic versioning

Phase 1 fixes for storage display:
- Replace findmnt with lsblk to eliminate bind mount issues (/nix/store)
- Add sudo to smartctl commands for permission access
- Fix NVMe SMART parsing for Temperature: and Percentage Used: fields
- Use dynamic version from CARGO_PKG_VERSION instead of hardcoded strings

Storage display should now show correct mount points and temperature/wear.
Status evaluation and notifications still need restoration in subsequent phases.

agent/src/collectors/disk.rs

@@ -105,13 +105,13 @@ impl DiskCollector {
         Ok(())
     }
 
-    /// Get mount devices mapping from /proc/mounts
+    /// Get block devices and their mount points using lsblk
     async fn get_mount_devices(&self) -> Result<HashMap<String, String>, CollectorError> {
-        let output = Command::new("findmnt")
-            .args(&["-rn", "-o", "TARGET,SOURCE"])
+        let output = Command::new("lsblk")
+            .args(&["-rn", "-o", "NAME,MOUNTPOINT"])
             .output()
             .map_err(|e| CollectorError::SystemRead {
-                path: "mount points".to_string(),
+                path: "block devices".to_string(),
                 error: e.to_string(),
             })?;
 
@@ -119,18 +119,21 @@ impl DiskCollector {
         for line in String::from_utf8_lossy(&output.stdout).lines() {
             let parts: Vec<&str> = line.split_whitespace().collect();
             if parts.len() >= 2 {
-                let mount_point = parts[0];
-                let device = parts[1];
+                let device_name = parts[0];
+                let mount_point = parts[1];
                 
-                // Skip special filesystems
-                if !device.starts_with('/') || device.contains("loop") {
+                // Skip swap partitions and unmounted devices
+                if mount_point == "[SWAP]" || mount_point.is_empty() {
                     continue;
                 }
                 
-                mount_devices.insert(mount_point.to_string(), device.to_string());
+                // Convert device name to full path
+                let device_path = format!("/dev/{}", device_name);
+                mount_devices.insert(mount_point.to_string(), device_path);
             }
         }
 
+        debug!("Found {} mounted block devices", mount_devices.len());
         Ok(mount_devices)
     }
 
@@ -319,8 +322,8 @@ impl DiskCollector {
 
     /// Get SMART data for a single drive
     async fn get_smart_data(&self, drive_name: &str) -> Result<SmartData, CollectorError> {
-        let output = Command::new("smartctl")
-            .args(&["-a", &format!("/dev/{}", drive_name)])
+        let output = Command::new("sudo")
+            .args(&["smartctl", "-a", &format!("/dev/{}", drive_name)])
             .output()
             .map_err(|e| CollectorError::SystemRead {
                 path: format!("SMART data for {}", drive_name),
@@ -328,6 +331,21 @@ impl DiskCollector {
             })?;
 
         let output_str = String::from_utf8_lossy(&output.stdout);
+        let error_str = String::from_utf8_lossy(&output.stderr);
+        
+        // Debug logging for SMART command results
+        debug!("SMART output for {}: status={}, stdout_len={}, stderr={}", 
+            drive_name, output.status, output_str.len(), error_str);
+        
+        if !output.status.success() {
+            debug!("SMART command failed for {}: {}", drive_name, error_str);
+            // Return unknown data rather than failing completely
+            return Ok(SmartData {
+                health: "UNKNOWN".to_string(),
+                temperature_celsius: None,
+                wear_percent: None,
+            });
+        }
         
         let mut health = "UNKNOWN".to_string();
         let mut temperature = None;
@@ -342,13 +360,22 @@ impl DiskCollector {
                 }
             }
             
-            // Temperature parsing
+            // Temperature parsing for different drive types
             if line.contains("Temperature_Celsius") || line.contains("Airflow_Temperature_Cel") {
+                // Traditional SATA drives: attribute table format
                 if let Some(temp_str) = line.split_whitespace().nth(9) {
                     if let Ok(temp) = temp_str.parse::<f32>() {
                         temperature = Some(temp);
                     }
                 }
+            } else if line.starts_with("Temperature:") {
+                // NVMe drives: simple "Temperature: 27 Celsius" format
+                let parts: Vec<&str> = line.split_whitespace().collect();
+                if parts.len() >= 2 {
+                    if let Ok(temp) = parts[1].parse::<f32>() {
+                        temperature = Some(temp);
+                    }
+                }
             }
             
             // Wear level parsing for SSDs
@@ -359,6 +386,18 @@ impl DiskCollector {
                     }
                 }
             }
+            // NVMe wear parsing: "Percentage Used: 1%"
+            if line.contains("Percentage Used:") {
+                if let Some(percent_part) = line.split("Percentage Used:").nth(1) {
+                    if let Some(percent_str) = percent_part.split_whitespace().next() {
+                        if let Some(percent_clean) = percent_str.strip_suffix('%') {
+                            if let Ok(wear) = percent_clean.parse::<f32>() {
+                                wear_percent = Some(wear);
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         Ok(SmartData {