harmony/src/domain/hardware/mod.rs

@@ -108,11 +108,18 @@ impl PhysicalHost {
             };
 
             let storage_summary = if drive_count > 1 {
+                let drive_sizes = self
+                    .storage
+                    .iter()
+                    .map(|d| format_storage(d.size_bytes))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
                 format!(
-                    "{} Storage ({}x {})",
+                    "{} Storage ({} Disks [{}])",
                     format_storage(total_storage_bytes),
                     drive_count,
-                    first_drive_model
+                    drive_sizes
                 )
             } else {
                 format!(

harmony/src/modules/inventory/discovery.rs

@@ -82,17 +82,40 @@ impl<T: Topology> Interpret<T> for DiscoverHostForRoleInterpret {
                         self.score.role,
                         choice.summary()
                     );
-                    let disk_names: Vec<String> =
-                        choice.storage.iter().map(|s| s.name.clone()).collect();
+                    let mut disk_choices: Vec<(String, String)> = vec![];
+
+                    for s in choice.storage.iter() {
+                        let size_gb: f64 = s.size_bytes as f64 / 1_000_000_000.0;
+                        let (size, unit) = if size_gb >= 1000.0 {
+                            (size_gb / 1000.0, "TB")
+                        } else {
+                            (size_gb, "GB")
+                        };
+                        let drive_type = if s.rotational { "rotational" } else { "SSD" };
+                        let smart_str = s.smart_status.as_deref().unwrap_or("N/A");
+                        let display = format!(
+                            "{} : [{}] - {:.0} {} ({}) - {} - Smart: {}",
+                            s.name, s.model, size, unit, drive_type, s.interface_type, smart_str
+                        );
+                        disk_choices.push((display, s.name.clone()));
+                    }
+
+                    let display_refs: Vec<&str> =
+                        disk_choices.iter().map(|(d, _)| d.as_str()).collect();
 
                     let disk_choice = inquire::Select::new(
                         &format!("Select the disk to use on host {}:", choice.summary()),
-                        disk_names,
+                        display_refs,
                     )
                     .prompt();
 
                     match disk_choice {
-                        Ok(disk_name) => {
+                        Ok(selected_display) => {
+                            let disk_name = disk_choices
+                                .iter()
+                                .find(|(d, _)| d.as_str() == selected_display)
+                                .map(|(_, name)| name.clone())
+                                .unwrap();
                             info!("Selected disk {} for node {}", disk_name, choice.summary());
                             host_repo
                                 .save_role_mapping(&self.score.role, &choice, &disk_name)