Fix real-time log streaming by simplifying service start command

- Remove complex background process monitoring that was buffering output
- Use direct journalctl -fu command for immediate real-time log streaming
- Eliminate monitoring loop that was killing log stream when service became active
- User now controls log following duration with Ctrl+C
- Fixes buffering issues that prevented seeing ark server startup logs in real-time

.gitea/workflows/release.yml

@@ -113,13 +113,13 @@ jobs:
           NIX_HASH="sha256-$(python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('$NEW_HASH')).decode())")"
           
           # Update the NixOS configuration
-          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" hosts/common/cm-dashboard.nix
+          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" hosts/services/cm-dashboard.nix
-          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/common/cm-dashboard.nix
+          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/services/cm-dashboard.nix
           
           # Commit and push changes
           git config user.name "Gitea Actions"
           git config user.email "actions@gitea.cmtec.se"
-          git add hosts/common/cm-dashboard.nix
+          git add hosts/services/cm-dashboard.nix
           git commit -m "Auto-update cm-dashboard to $VERSION
 
           - Update version to $VERSION with automated release

CLAUDE.md

@@ -20,12 +20,28 @@ A high-performance Rust-based TUI dashboard for monitoring CMTEC infrastructure.
 - Persistent storage survives agent restarts
 - Automatic flag clearing when services are restarted via dashboard
 
+### Custom Service Logs
+- Configure service-specific log file paths per host in dashboard config
+- Press `L` on any service to view custom log files via `tail -f`
+- Configuration format in dashboard config:
+```toml
+[service_logs]
+hostname1 = [
+  { service_name = "nginx", log_file_path = "/var/log/nginx/access.log" },
+  { service_name = "app", log_file_path = "/var/log/myapp/app.log" }
+]
+hostname2 = [
+  { service_name = "database", log_file_path = "/var/log/postgres/postgres.log" }
+]
+```
+
 ### Service Management
 - **Direct Control**: Arrow keys (↑↓) or vim keys (j/k) navigate services
 - **Service Actions**: 
   - `s` - Start service (sends UserStart command)
   - `S` - Stop service (sends UserStop command)
   - `J` - Show service logs (journalctl in tmux popup)
+  - `L` - Show custom log files (tail -f custom paths in tmux popup)
   - `R` - Rebuild current host
 - **Visual Status**: Green ● (active), Yellow ◐ (inactive), Red ◯ (failed)
 - **Transitional Icons**: Blue arrows during operations
@@ -33,7 +49,12 @@ A high-performance Rust-based TUI dashboard for monitoring CMTEC infrastructure.
 ### Navigation
 - **Tab**: Switch between hosts
 - **↑↓ or j/k**: Select services
+- **s**: Start selected service (UserStart)
+- **S**: Stop selected service (UserStop)
 - **J**: Show service logs (journalctl)
+- **L**: Show custom log files
+- **R**: Rebuild current host
+- **B**: Run backup on current host
 - **q**: Quit dashboard
 
 ## Core Architecture Principles
@@ -98,7 +119,7 @@ This automatically:
 - Uploads binaries via Gitea API
 
 ### NixOS Configuration Updates
-Edit `~/projects/nixosbox/hosts/common/cm-dashboard.nix`:
+Edit `~/projects/nixosbox/hosts/services/cm-dashboard.nix`:
 
 ```nix
 version = "v0.1.X";

Cargo.lock

@@ -270,7 +270,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.46"
+version = "0.1.80"
 dependencies = [
  "anyhow",
  "chrono",
@@ -286,12 +286,13 @@ dependencies = [
  "toml",
  "tracing",
  "tracing-subscriber",
+ "wake-on-lan",
  "zmq",
 ]
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.46"
+version = "0.1.80"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -314,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.46"
+version = "0.1.80"
 dependencies = [
  "chrono",
  "serde",
@@ -2064,6 +2065,12 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "wake-on-lan"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ccf60b60ad7e5b1b37372c5134cbcab4db0706c231d212e0c643a077462bc8f"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"

README.md

@@ -88,7 +88,9 @@ cm-dashboard • ● cmbox ● srv01 ● srv02 ● steambox
 - **s**: Start selected service (UserStart)  
 - **S**: Stop selected service (UserStop)
 - **J**: Show service logs (journalctl in tmux popup)
+- **L**: Show custom log files (tail -f custom paths in tmux popup)
 - **R**: Rebuild current host
+- **B**: Run backup on current host
 - **q**: Quit
 
 ### Status Indicators
@@ -173,9 +175,10 @@ subscriber_ports = [6130]
 [hosts]
 predefined_hosts = ["cmbox", "srv01", "srv02"]
 
-[ui]
+[ssh]
-ssh_user = "cm"
+rebuild_user = "cm"
 rebuild_alias = "nixos-rebuild-cmtec"
+backup_alias = "cm-backup-run"
 ```
 
 ## Technical Implementation
@@ -329,7 +332,7 @@ This triggers automated:
 - Tarball upload to Gitea
 
 ### NixOS Integration
-Update `~/projects/nixosbox/hosts/common/cm-dashboard.nix`:
+Update `~/projects/nixosbox/hosts/services/cm-dashboard.nix`:
 
 ```nix
 version = "v0.1.43";

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.47"
+version = "0.1.81"
 edition = "2021"
 
 [dependencies]

agent/src/agent.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 use tokio::time::interval;
 use tracing::{debug, error, info};
 
-use crate::communication::{AgentCommand, ServiceAction, ZmqHandler};
+use crate::communication::{AgentCommand, ZmqHandler};
 use crate::config::AgentConfig;
 use crate::metrics::MetricCollectionManager;
 use crate::notifications::NotificationManager;
@@ -78,10 +78,11 @@ impl Agent {
             info!("Initial metric collection completed - all data cached and ready");
         }
 
-        // Separate intervals for collection, transmission, and email notifications
+        // Separate intervals for collection, transmission, heartbeat, and email notifications
         let mut collection_interval =
             interval(Duration::from_secs(self.config.collection_interval_seconds));
         let mut transmission_interval = interval(Duration::from_secs(self.config.zmq.transmission_interval_seconds));
+        let mut heartbeat_interval = interval(Duration::from_secs(self.config.zmq.heartbeat_interval_seconds));
         let mut notification_interval = interval(Duration::from_secs(self.config.notifications.aggregation_interval_seconds));
 
         loop {
@@ -98,6 +99,12 @@ impl Agent {
                         error!("Failed to broadcast metrics: {}", e);
                     }
                 }
+                _ = heartbeat_interval.tick() => {
+                    // Send standalone heartbeat for host connectivity detection
+                    if let Err(e) = self.send_heartbeat().await {
+                        error!("Failed to send heartbeat: {}", e);
+                    }
+                }
                 _ = notification_interval.tick() => {
                     // Process batched email notifications (separate from dashboard updates)
                     if let Err(e) = self.host_status_manager.process_pending_notifications(&mut self.notification_manager).await {
@@ -180,6 +187,10 @@ impl Agent {
         let version_metric = self.get_agent_version_metric();
         metrics.push(version_metric);
 
+        // Add heartbeat metric for host connectivity detection
+        let heartbeat_metric = self.get_heartbeat_metric();
+        metrics.push(heartbeat_metric);
+
         // Check for user-stopped services that are now active and clear their flags
         self.clear_user_stopped_flags_for_active_services(&metrics);
 
@@ -201,6 +212,12 @@ impl Agent {
     async fn process_metrics(&mut self, metrics: &[Metric]) -> bool {
         let mut status_changed = false;
         for metric in metrics {
+            // Filter excluded metrics from email notification processing only
+            if self.config.notifications.exclude_email_metrics.contains(&metric.name) {
+                debug!("Excluding metric '{}' from email notification processing", metric.name);
+                continue;
+            }
+            
             if self.host_status_manager.process_metric(metric, &mut self.notification_manager).await {
                 status_changed = true;
             }
@@ -226,6 +243,35 @@ impl Agent {
         format!("v{}", env!("CARGO_PKG_VERSION"))
     }
 
+    /// Create heartbeat metric for host connectivity detection
+    fn get_heartbeat_metric(&self) -> Metric {
+        use std::time::{SystemTime, UNIX_EPOCH};
+        
+        let timestamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        
+        Metric::new(
+            "agent_heartbeat".to_string(),
+            MetricValue::Integer(timestamp as i64),
+            Status::Ok,
+        )
+    }
+
+    /// Send standalone heartbeat for connectivity detection
+    async fn send_heartbeat(&mut self) -> Result<()> {
+        let heartbeat_metric = self.get_heartbeat_metric();
+        let message = MetricMessage::new(
+            self.hostname.clone(),
+            vec![heartbeat_metric],
+        );
+
+        self.zmq_handler.publish_metrics(&message).await?;
+        debug!("Sent standalone heartbeat for connectivity detection");
+        Ok(())
+    }
+
     async fn handle_commands(&mut self) -> Result<()> {
         // Try to receive commands (non-blocking)
         match self.zmq_handler.try_receive_command() {
@@ -269,75 +315,10 @@ impl Agent {
                 info!("Processing Ping command - agent is alive");
                 // Could send a response back via ZMQ if needed
             }
-            AgentCommand::ServiceControl { service_name, action } => {
-                info!("Processing ServiceControl command: {} {:?}", service_name, action);
-                if let Err(e) = self.handle_service_control(&service_name, &action).await {
-                    error!("Failed to execute service control: {}", e);
-                }
-            }
         }
         Ok(())
     }
 
-    /// Handle systemd service control commands
-    async fn handle_service_control(&mut self, service_name: &str, action: &ServiceAction) -> Result<()> {
-        let (action_str, is_user_action) = match action {
-            ServiceAction::Start => ("start", false),
-            ServiceAction::Stop => ("stop", false), 
-            ServiceAction::Status => ("status", false),
-            ServiceAction::UserStart => ("start", true),
-            ServiceAction::UserStop => ("stop", true),
-        };
-
-        info!("Executing systemctl {} {} (user action: {})", action_str, service_name, is_user_action);
-
-        // Handle user-stopped service tracking before systemctl execution (stop only)
-        match action {
-            ServiceAction::UserStop => {
-                info!("Marking service '{}' as user-stopped", service_name);
-                if let Err(e) = self.service_tracker.mark_user_stopped(service_name) {
-                    error!("Failed to mark service as user-stopped: {}", e);
-                } else {
-                    // Sync to global tracker
-                    UserStoppedServiceTracker::update_global(&self.service_tracker);
-                }
-            }
-            _ => {}
-        }
-
-        let output = tokio::process::Command::new("sudo")
-            .arg("systemctl")
-            .arg(action_str)
-            .arg(format!("{}.service", service_name))
-            .output()
-            .await?;
-
-        if output.status.success() {
-            info!("Service {} {} completed successfully", service_name, action_str);
-            if !output.stdout.is_empty() {
-                debug!("stdout: {}", String::from_utf8_lossy(&output.stdout));
-            }
-            
-            // Note: User-stopped flag will be cleared by systemd collector 
-            // when service actually reaches 'active' state, not here
-        } else {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("Service {} {} failed: {}", service_name, action_str, stderr);
-            return Err(anyhow::anyhow!("systemctl {} {} failed: {}", action_str, service_name, stderr));
-        }
-
-        // Force refresh metrics after service control to update service status
-        if matches!(action, ServiceAction::Start | ServiceAction::Stop | ServiceAction::UserStart | ServiceAction::UserStop) {
-            info!("Triggering immediate metric refresh after service control");
-            if let Err(e) = self.collect_metrics_only().await {
-                error!("Failed to refresh metrics after service control: {}", e);
-            } else {
-                info!("Service status refreshed immediately after {} {}", action_str, service_name);
-            }
-        }
-
-        Ok(())
-    }
 
     /// Check metrics for user-stopped services that are now active and clear their flags
     fn clear_user_stopped_flags_for_active_services(&mut self, metrics: &[Metric]) {

agent/src/collectors/backup.rs

@@ -136,10 +136,12 @@ impl Collector for BackupCollector {
             name: "backup_overall_status".to_string(),
             value: MetricValue::String(match overall_status {
                 Status::Ok => "ok".to_string(),
+                Status::Inactive => "inactive".to_string(),
                 Status::Pending => "pending".to_string(),
                 Status::Warning => "warning".to_string(),
                 Status::Critical => "critical".to_string(),
                 Status::Unknown => "unknown".to_string(),
+                Status::Offline => "offline".to_string(),
             }),
             status: overall_status,
             timestamp,
@@ -198,10 +200,12 @@ impl Collector for BackupCollector {
                 name: format!("backup_service_{}_status", service_name),
                 value: MetricValue::String(match service_status {
                     Status::Ok => "ok".to_string(),
+                    Status::Inactive => "inactive".to_string(),
                     Status::Pending => "pending".to_string(),
                     Status::Warning => "warning".to_string(),
                     Status::Critical => "critical".to_string(),
                     Status::Unknown => "unknown".to_string(),
+                    Status::Offline => "offline".to_string(),
                 }),
                 status: service_status,
                 timestamp,

agent/src/collectors/systemd.rs

@@ -8,7 +8,6 @@ use tracing::debug;
 
 use super::{Collector, CollectorError};
 use crate::config::SystemdConfig;
-use crate::service_tracker::UserStoppedServiceTracker;
 
 /// Systemd collector for monitoring systemd services
 pub struct SystemdCollector {
@@ -357,33 +356,15 @@ impl SystemdCollector {
     /// Calculate service status, taking user-stopped services into account
     fn calculate_service_status(&self, service_name: &str, active_status: &str) -> Status {
         match active_status.to_lowercase().as_str() {
-            "active" => {
+            "active" => Status::Ok,
-                // If service is now active and was marked as user-stopped, clear the flag
-                if UserStoppedServiceTracker::is_service_user_stopped(service_name) {
-                    debug!("Service '{}' is now active - clearing user-stopped flag", service_name);
-                    // Note: We can't directly clear here because this is a read-only context
-                    // The agent will need to handle this differently
-                }
-                Status::Ok
-            },
             "inactive" | "dead" => {
-                // Check if this service was stopped by user action
+                debug!("Service '{}' is inactive - treating as Inactive status", service_name);
-                if UserStoppedServiceTracker::is_service_user_stopped(service_name) {
+                Status::Inactive
-                    debug!("Service '{}' is inactive but marked as user-stopped - treating as OK", service_name);
-                    Status::Ok
-                } else {
-                    Status::Warning
-                }
             },
             "failed" | "error" => Status::Critical,
             "activating" | "deactivating" | "reloading" | "start" | "stop" | "restart" => {
-                // For user-stopped services that are transitioning, keep them as OK during transition
+                debug!("Service '{}' is transitioning - treating as Pending", service_name);
-                if UserStoppedServiceTracker::is_service_user_stopped(service_name) {
+                Status::Pending
-                    debug!("Service '{}' is transitioning but was user-stopped - treating as OK", service_name);
-                    Status::Ok
-                } else {
-                    Status::Pending
-                }
             },
             _ => Status::Unknown,
         }

agent/src/communication/mod.rs

@@ -66,8 +66,6 @@ impl ZmqHandler {
     }
 
 
-    /// Send heartbeat (placeholder for future use)
-
     /// Try to receive a command (non-blocking)
     pub fn try_receive_command(&self) -> Result<Option<AgentCommand>> {
         match self.command_receiver.recv_bytes(zmq::DONTWAIT) {
@@ -100,19 +98,4 @@ pub enum AgentCommand {
     ToggleCollector { name: String, enabled: bool },
     /// Request status/health check
     Ping,
-    /// Control systemd service
-    ServiceControl {
-        service_name: String,
-        action: ServiceAction,
-    },
-}
-
-/// Service control actions
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-pub enum ServiceAction {
-    Start,
-    Stop,
-    Status,
-    UserStart,  // User-initiated start (clears user-stopped flag)
-    UserStop,   // User-initiated stop (marks as user-stopped)
 }

agent/src/config/mod.rs

@@ -25,9 +25,10 @@ pub struct ZmqConfig {
     pub publisher_port: u16,
     pub command_port: u16,
     pub bind_address: String,
-    pub timeout_ms: u64,
-    pub heartbeat_interval_ms: u64,
     pub transmission_interval_seconds: u64,
+    /// Heartbeat transmission interval in seconds for host connectivity detection
+    #[serde(default = "default_heartbeat_interval_seconds")]
+    pub heartbeat_interval_seconds: u64,
 }
 
 /// Collector configuration
@@ -146,9 +147,23 @@ pub struct NotificationConfig {
     pub rate_limit_minutes: u64,
     /// Email notification batching interval in seconds (default: 60)
     pub aggregation_interval_seconds: u64,
+    /// List of metric names to exclude from email notifications
+    #[serde(default)]
+    pub exclude_email_metrics: Vec<String>,
+    /// Path to maintenance mode file that suppresses email notifications when present
+    #[serde(default = "default_maintenance_mode_file")]
+    pub maintenance_mode_file: String,
 }
 
 
+fn default_heartbeat_interval_seconds() -> u64 {
+    5
+}
+
+fn default_maintenance_mode_file() -> String {
+    "/tmp/cm-maintenance".to_string()
+}
+
 impl AgentConfig {
     pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
         loader::load_config(path)

agent/src/config/validation.rs

@@ -19,10 +19,6 @@ pub fn validate_config(config: &AgentConfig) -> Result<()> {
         bail!("ZMQ bind address cannot be empty");
     }
 
-    if config.zmq.timeout_ms == 0 {
-        bail!("ZMQ timeout cannot be 0");
-    }
-
     // Validate collection interval
     if config.collection_interval_seconds == 0 {
         bail!("Collection interval cannot be 0");

agent/src/notifications/mod.rs

@@ -59,6 +59,6 @@ impl NotificationManager {
     }
 
     fn is_maintenance_mode(&self) -> bool {
-        std::fs::metadata("/tmp/cm-maintenance").is_ok()
+        std::fs::metadata(&self.config.maintenance_mode_file).is_ok()
     }
 }

agent/src/service_tracker.rs

@@ -90,14 +90,6 @@ impl UserStoppedServiceTracker {
         tracker
     }
 
-    /// Mark a service as user-stopped
-    pub fn mark_user_stopped(&mut self, service_name: &str) -> Result<()> {
-        info!("Marking service '{}' as user-stopped", service_name);
-        self.user_stopped_services.insert(service_name.to_string());
-        self.save_to_storage()?;
-        debug!("Service '{}' marked as user-stopped and saved to storage", service_name);
-        Ok(())
-    }
 
     /// Clear user-stopped flag for a service (when user starts it)
     pub fn clear_user_stopped(&mut self, service_name: &str) -> Result<()> {

agent/src/status/mod.rs

@@ -272,11 +272,13 @@ impl HostStatusManager {
     /// Check if a status change is significant enough for notification
     fn is_significant_change(&self, old_status: Status, new_status: Status) -> bool {
         match (old_status, new_status) {
-            // Always notify on problems
+            // Don't notify on transitions from Unknown (startup/restart scenario)
+            (Status::Unknown, _) => false,
+            // Always notify on problems (but not from Unknown)
             (_, Status::Warning) | (_, Status::Critical) => true,
             // Only notify on recovery if it's from a problem state to OK and all services are OK
             (Status::Warning | Status::Critical, Status::Ok) => self.current_host_status == Status::Ok,
-            // Don't notify on startup or other transitions
+            // Don't notify on other transitions
             _ => false,
         }
     }
@@ -374,8 +376,8 @@ impl HostStatusManager {
             details.push('\n');
         }
 
-        // Show recoveries
+        // Show recoveries only if host status is now OK (all services recovered)
-        if !recovery_changes.is_empty() {
+        if !recovery_changes.is_empty() && aggregated.host_status_final == Status::Ok {
             details.push_str(&format!("✅ RECOVERIES ({}):\n", recovery_changes.len()));
             for change in recovery_changes {
                 details.push_str(&format!("  {}\n", change));

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.47"
+version = "0.1.81"
 edition = "2021"
 
 [dependencies]
@@ -18,4 +18,5 @@ tracing-subscriber = { workspace = true }
 ratatui = { workspace = true }
 crossterm = { workspace = true }
 toml = { workspace = true }
-gethostname = { workspace = true }
+gethostname = { workspace = true }
+wake-on-lan = "0.2"

dashboard/src/app.rs

@@ -9,20 +9,19 @@ use std::io;
 use std::time::{Duration, Instant};
 use tracing::{debug, error, info, warn};
 
-use crate::communication::{AgentCommand, ServiceAction, ZmqCommandSender, ZmqConsumer};
+use crate::communication::{ZmqConsumer};
 use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
-use crate::ui::{TuiApp, UiCommand};
+use crate::ui::TuiApp;
 
 pub struct Dashboard {
     zmq_consumer: ZmqConsumer,
-    zmq_command_sender: ZmqCommandSender,
     metric_store: MetricStore,
     tui_app: Option<TuiApp>,
     terminal: Option<Terminal<CrosstermBackend<io::Stdout>>>,
     headless: bool,
     initial_commands_sent: std::collections::HashSet<String>,
-    _config: DashboardConfig,
+    config: DashboardConfig,
 }
 
 impl Dashboard {
@@ -58,20 +57,9 @@ impl Dashboard {
             }
         };
 
-        // Initialize ZMQ command sender
-        let zmq_command_sender = match ZmqCommandSender::new(&config.zmq) {
-            Ok(sender) => sender,
-            Err(e) => {
-                error!("Failed to initialize ZMQ command sender: {}", e);
-                return Err(e);
-            }
-        };
-
-        // Connect to predefined hosts from configuration
-        let hosts = config.hosts.predefined_hosts.clone();
 
         // Try to connect to hosts but don't fail if none are available
-        match zmq_consumer.connect_to_predefined_hosts(&hosts).await {
+        match zmq_consumer.connect_to_predefined_hosts(&config.hosts).await {
             Ok(_) => info!("Successfully connected to ZMQ hosts"),
             Err(e) => {
                 warn!(
@@ -127,28 +115,23 @@ impl Dashboard {
 
         Ok(Self {
             zmq_consumer,
-            zmq_command_sender,
             metric_store,
             tui_app,
             terminal,
             headless,
             initial_commands_sent: std::collections::HashSet::new(),
-            _config: config,
+            config,
         })
     }
 
-    /// Send a command to a specific agent
-    pub async fn send_command(&mut self, hostname: &str, command: AgentCommand) -> Result<()> {
-        self.zmq_command_sender
-            .send_command(hostname, command)
-            .await
-    }
 
     pub async fn run(&mut self) -> Result<()> {
         info!("Starting dashboard main loop");
 
         let mut last_metrics_check = Instant::now();
         let metrics_check_interval = Duration::from_millis(100); // Check for metrics every 100ms
+        let mut last_heartbeat_check = Instant::now();
+        let heartbeat_check_interval = Duration::from_secs(1); // Check for host connectivity every 1 second
 
         loop {
             // Handle terminal events (keyboard input) only if not headless
@@ -158,16 +141,10 @@ impl Dashboard {
                         match event::read() {
                             Ok(event) => {
                                 if let Some(ref mut tui_app) = self.tui_app {
-                                    // Handle input and check for commands
+                                    // Handle input
                                     match tui_app.handle_input(event) {
-                                        Ok(Some(command)) => {
+                                        Ok(_) => {
-                                            // Execute the command
+                                            // Check if we should quit
-                                            if let Err(e) = self.execute_ui_command(command).await {
-                                                error!("Failed to execute UI command: {}", e);
-                                            }
-                                        }
-                                        Ok(None) => {
-                                            // No command, check if we should quit
                                             if tui_app.should_quit() {
                                                 info!("Quit requested, exiting dashboard");
                                                 break;
@@ -191,6 +168,17 @@ impl Dashboard {
                         break;
                     }
                 }
+
+                // Render UI immediately after handling input for responsive feedback
+                if let Some(ref mut terminal) = self.terminal {
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        if let Err(e) = terminal.draw(|frame| {
+                            tui_app.render(frame, &self.metric_store);
+                        }) {
+                            error!("Error rendering TUI after input: {}", e);
+                        }
+                    }
+                }
             }
 
             // Check for new metrics
@@ -202,34 +190,18 @@ impl Dashboard {
                         metric_message.metrics.len()
                     );
 
-                    // Check if this is the first time we've seen this host
+                    // Track first contact with host (no command needed - agent sends data every 2s)
                     let is_new_host = !self
                         .initial_commands_sent
                         .contains(&metric_message.hostname);
 
                     if is_new_host {
                         info!(
-                            "First contact with host {}, sending initial CollectNow command",
+                            "First contact with host {} - data will update automatically",
                             metric_message.hostname
                         );
-
+                        self.initial_commands_sent
-                        // Send CollectNow command for immediate refresh
+                            .insert(metric_message.hostname.clone());
-                        if let Err(e) = self
-                            .send_command(&metric_message.hostname, AgentCommand::CollectNow)
-                            .await
-                        {
-                            error!(
-                                "Failed to send initial CollectNow command to {}: {}",
-                                metric_message.hostname, e
-                            );
-                        } else {
-                            info!(
-                                "✓ Sent initial CollectNow command to {}",
-                                metric_message.hostname
-                            );
-                            self.initial_commands_sent
-                                .insert(metric_message.hostname.clone());
-                        }
                     }
 
                     // Update metric store
@@ -243,14 +215,8 @@ impl Dashboard {
                         }
                     }
 
-                    // Update TUI with new hosts and metrics (only if not headless)
+                    // Update TUI with new metrics (only if not headless)
                     if let Some(ref mut tui_app) = self.tui_app {
-                        let connected_hosts = self
-                            .metric_store
-                            .get_connected_hosts(Duration::from_secs(30));
-                        
-                        
-                        tui_app.update_hosts(connected_hosts);
                         tui_app.update_metrics(&self.metric_store);
                     }
                 }
@@ -269,6 +235,20 @@ impl Dashboard {
                 last_metrics_check = Instant::now();
             }
 
+            // Check for host connectivity changes (heartbeat timeouts) periodically
+            if last_heartbeat_check.elapsed() >= heartbeat_check_interval {
+                let timeout = Duration::from_secs(self.config.zmq.heartbeat_timeout_seconds);
+                
+                // Clean up metrics for offline hosts
+                self.metric_store.cleanup_offline_hosts(timeout);
+                
+                if let Some(ref mut tui_app) = self.tui_app {
+                    let connected_hosts = self.metric_store.get_connected_hosts(timeout);
+                    tui_app.update_hosts(connected_hosts);
+                }
+                last_heartbeat_check = Instant::now();
+            }
+
             // Render TUI (only if not headless)
             if !self.headless {
                 if let Some(ref mut terminal) = self.terminal {
@@ -291,33 +271,6 @@ impl Dashboard {
         Ok(())
     }
 
-    /// Execute a UI command by sending it to the appropriate agent
-    async fn execute_ui_command(&self, command: UiCommand) -> Result<()> {
-        match command {
-            UiCommand::ServiceStart { hostname, service_name } => {
-                info!("Sending user start command for service {} on {}", service_name, hostname);
-                let agent_command = AgentCommand::ServiceControl {
-                    service_name: service_name.clone(),
-                    action: ServiceAction::UserStart,
-                };
-                self.zmq_command_sender.send_command(&hostname, agent_command).await?;
-            }
-            UiCommand::ServiceStop { hostname, service_name } => {
-                info!("Sending user stop command for service {} on {}", service_name, hostname);
-                let agent_command = AgentCommand::ServiceControl {
-                    service_name: service_name.clone(),
-                    action: ServiceAction::UserStop,
-                };
-                self.zmq_command_sender.send_command(&hostname, agent_command).await?;
-            }
-            UiCommand::TriggerBackup { hostname } => {
-                info!("Trigger backup requested for {}", hostname);
-                // TODO: Implement backup trigger command
-                info!("Backup trigger not yet implemented");
-            }
-        }
-        Ok(())
-    }
 
 }
 

dashboard/src/communication/mod.rs

@@ -5,40 +5,6 @@ use zmq::{Context, Socket, SocketType};
 
 use crate::config::ZmqConfig;
 
-/// Commands that can be sent to agents
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-pub enum AgentCommand {
-    /// Request immediate metric collection
-    CollectNow,
-    /// Change collection interval
-    SetInterval { seconds: u64 },
-    /// Enable/disable a collector
-    ToggleCollector { name: String, enabled: bool },
-    /// Request status/health check
-    Ping,
-    /// Control systemd service
-    ServiceControl {
-        service_name: String,
-        action: ServiceAction,
-    },
-    /// Rebuild NixOS system
-    SystemRebuild {
-        git_url: String,
-        git_branch: String,
-        working_dir: String,
-        api_key_file: Option<String>,
-    },
-}
-
-/// Service control actions
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-pub enum ServiceAction {
-    Start,
-    Stop,
-    Status,
-    UserStart,  // User-initiated start (clears user-stopped flag)
-    UserStop,   // User-initiated stop (marks as user-stopped)
-}
 
 /// ZMQ consumer for receiving metrics from agents
 pub struct ZmqConsumer {
@@ -84,13 +50,14 @@ impl ZmqConsumer {
         }
     }
 
-    /// Connect to predefined hosts
+
-    pub async fn connect_to_predefined_hosts(&mut self, hosts: &[String]) -> Result<()> {
+    /// Connect to predefined hosts using their configuration
+    pub async fn connect_to_predefined_hosts(&mut self, hosts: &std::collections::HashMap<String, crate::config::HostDetails>) -> Result<()> {
         let default_port = self.config.subscriber_ports[0];
 
-        for hostname in hosts {
+        for (hostname, host_details) in hosts {
-            // Try to connect, but don't fail if some hosts are unreachable
+            // Try to connect using configured IP, but don't fail if some hosts are unreachable
-            if let Err(e) = self.connect_to_host(hostname, default_port).await {
+            if let Err(e) = self.connect_to_host_with_details(hostname, host_details, default_port).await {
                 warn!("Could not connect to {}: {}", hostname, e);
             }
         }
@@ -104,6 +71,15 @@ impl ZmqConsumer {
         Ok(())
     }
 
+    /// Connect to a host using its configuration details
+    pub async fn connect_to_host_with_details(&mut self, hostname: &str, host_details: &crate::config::HostDetails, port: u16) -> Result<()> {
+        // Get primary connection IP only - no fallbacks
+        let primary_ip = host_details.get_connection_ip(hostname);
+        
+        // Connect directly without fallback attempts
+        self.connect_to_host(&primary_ip, port).await
+    }
+
     /// Receive command output from any connected agent (non-blocking)  
     pub async fn receive_command_output(&mut self) -> Result<Option<CommandOutputMessage>> {
         match self.subscriber.recv_bytes(zmq::DONTWAIT) {
@@ -192,42 +168,3 @@ impl ZmqConsumer {
     }
 }
 
-/// ZMQ command sender for sending commands to agents
-pub struct ZmqCommandSender {
-    context: Context,
-}
-
-impl ZmqCommandSender {
-    pub fn new(_config: &ZmqConfig) -> Result<Self> {
-        let context = Context::new();
-
-        info!("ZMQ command sender initialized");
-
-        Ok(Self { context })
-    }
-
-    /// Send a command to a specific agent
-    pub async fn send_command(&self, hostname: &str, command: AgentCommand) -> Result<()> {
-        // Create a new PUSH socket for this command (ZMQ best practice)
-        let socket = self.context.socket(SocketType::PUSH)?;
-
-        // Set socket options
-        socket.set_linger(1000)?; // Wait up to 1 second on close
-        socket.set_sndtimeo(5000)?; // 5 second send timeout
-
-        // Connect to agent's command port (6131)
-        let address = format!("tcp://{}:6131", hostname);
-        socket.connect(&address)?;
-
-        // Serialize command
-        let serialized = serde_json::to_vec(&command)?;
-
-        // Send command
-        socket.send(&serialized, 0)?;
-
-        info!("Sent command {:?} to agent at {}", command, hostname);
-
-        // Socket will be automatically closed when dropped
-        Ok(())
-    }
-}

dashboard/src/config/mod.rs

@@ -6,21 +6,40 @@ use std::path::Path;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DashboardConfig {
     pub zmq: ZmqConfig,
-    pub hosts: HostsConfig,
+    pub hosts: std::collections::HashMap<String, HostDetails>,
     pub system: SystemConfig,
     pub ssh: SshConfig,
+    pub service_logs: std::collections::HashMap<String, Vec<ServiceLogConfig>>,
 }
 
 /// ZMQ consumer configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ZmqConfig {
     pub subscriber_ports: Vec<u16>,
+    /// Heartbeat timeout in seconds - hosts considered offline if no heartbeat received within this time
+    #[serde(default = "default_heartbeat_timeout_seconds")]
+    pub heartbeat_timeout_seconds: u64,
 }
 
-/// Hosts configuration
+fn default_heartbeat_timeout_seconds() -> u64 {
+    10 // Default to 10 seconds - allows for multiple missed heartbeats
+}
+
+/// Individual host configuration details
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HostsConfig {
+pub struct HostDetails {
-    pub predefined_hosts: Vec<String>,
+    pub mac_address: Option<String>,
+    /// Primary IP address (local network)
+    pub ip: Option<String>,
+}
+
+
+impl HostDetails {
+    /// Get the IP address for connection (uses ip field or hostname as fallback)
+    pub fn get_connection_ip(&self, hostname: &str) -> String {
+        self.ip.as_ref().unwrap_or(&hostname.to_string()).clone()
+    }
+
 }
 
 /// System configuration
@@ -32,11 +51,19 @@ pub struct SystemConfig {
     pub nixos_config_api_key_file: Option<String>,
 }
 
-/// SSH configuration for rebuild operations
+/// SSH configuration for rebuild and backup operations
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SshConfig {
     pub rebuild_user: String,
     pub rebuild_alias: String,
+    pub backup_alias: String,
+}
+
+/// Service log file configuration per host
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServiceLogConfig {
+    pub service_name: String,
+    pub log_file_path: String,
 }
 
 impl DashboardConfig {
@@ -60,8 +87,3 @@ impl Default for ZmqConfig {
     }
 }
 
-impl Default for HostsConfig {
-    fn default() -> Self {
-        panic!("Dashboard configuration must be loaded from file - no hardcoded defaults allowed")
-    }
-}

dashboard/src/metrics/store.rs

@@ -11,8 +11,8 @@ pub struct MetricStore {
     current_metrics: HashMap<String, HashMap<String, Metric>>,
     /// Historical metrics for trending
     historical_metrics: HashMap<String, Vec<MetricDataPoint>>,
-    /// Last update timestamp per host
+    /// Last heartbeat timestamp per host
-    last_update: HashMap<String, Instant>,
+    last_heartbeat: HashMap<String, Instant>,
     /// Configuration
     max_metrics_per_host: usize,
     history_retention: Duration,
@@ -23,7 +23,7 @@ impl MetricStore {
         Self {
             current_metrics: HashMap::new(),
             historical_metrics: HashMap::new(),
-            last_update: HashMap::new(),
+            last_heartbeat: HashMap::new(),
             max_metrics_per_host,
             history_retention: Duration::from_secs(history_retention_hours * 3600),
         }
@@ -56,10 +56,13 @@ impl MetricStore {
 
             // Add to history
             host_history.push(MetricDataPoint { received_at: now });
-        }
 
-        // Update last update timestamp
+            // Track heartbeat metrics for connectivity detection
-        self.last_update.insert(hostname.to_string(), now);
+            if metric_name == "agent_heartbeat" {
+                self.last_heartbeat.insert(hostname.to_string(), now);
+                debug!("Updated heartbeat for host {}", hostname);
+            }
+        }
 
         // Get metrics count before cleanup
         let metrics_count = host_metrics.len();
@@ -88,22 +91,46 @@ impl MetricStore {
         }
     }
 
-    /// Get connected hosts (hosts with recent updates)
+    /// Get connected hosts (hosts with recent heartbeats)
     pub fn get_connected_hosts(&self, timeout: Duration) -> Vec<String> {
         let now = Instant::now();
 
-        self.last_update
+        self.last_heartbeat
             .iter()
-            .filter_map(|(hostname, &last_update)| {
+            .filter_map(|(hostname, &last_heartbeat)| {
-                if now.duration_since(last_update) <= timeout {
+                if now.duration_since(last_heartbeat) <= timeout {
                     Some(hostname.clone())
                 } else {
+                    debug!("Host {} considered offline - last heartbeat was {:?} ago", 
+                           hostname, now.duration_since(last_heartbeat));
                     None
                 }
             })
             .collect()
     }
 
+    /// Clean up data for offline hosts
+    pub fn cleanup_offline_hosts(&mut self, timeout: Duration) {
+        let now = Instant::now();
+        let mut hosts_to_cleanup = Vec::new();
+
+        // Find hosts that are offline (no recent heartbeat)
+        for (hostname, &last_heartbeat) in &self.last_heartbeat {
+            if now.duration_since(last_heartbeat) > timeout {
+                hosts_to_cleanup.push(hostname.clone());
+            }
+        }
+
+        // Clear metrics for offline hosts
+        for hostname in hosts_to_cleanup {
+            if let Some(metrics) = self.current_metrics.remove(&hostname) {
+                info!("Cleared {} metrics for offline host: {}", metrics.len(), hostname);
+            }
+            // Keep heartbeat timestamp for reconnection detection
+            // Don't remove from last_heartbeat to track when host was last seen
+        }
+    }
+
     /// Cleanup old data and enforce limits
     fn cleanup_host_data(&mut self, hostname: &str) {
         let now = Instant::now();

dashboard/src/ui/mod.rs

@@ -9,32 +9,19 @@ use ratatui::{
 use std::collections::HashMap;
 use std::time::Instant;
 use tracing::info;
+use wake_on_lan::MagicPacket;
 
 pub mod theme;
 pub mod widgets;
 
 use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
-use cm_dashboard_shared::{Metric, Status};
+use cm_dashboard_shared::Status;
 use theme::{Components, Layout as ThemeLayout, Theme, Typography};
 use widgets::{BackupWidget, ServicesWidget, SystemWidget, Widget};
 
-/// Commands that can be triggered from the UI
-#[derive(Debug, Clone)]
-pub enum UiCommand {
-    ServiceStart { hostname: String, service_name: String },
-    ServiceStop { hostname: String, service_name: String },
-    TriggerBackup { hostname: String },
-}
 
 
-/// Types of commands for status tracking
-#[derive(Debug, Clone)]
-pub enum CommandType {
-    ServiceStart,
-    ServiceStop,
-    BackupTrigger,
-}
 
 /// Panel types for focus management
 
@@ -47,14 +34,8 @@ pub struct HostWidgets {
     pub services_widget: ServicesWidget,
     /// Backup widget state
     pub backup_widget: BackupWidget,
-    /// Scroll offsets for each panel
-    pub system_scroll_offset: usize,
-    pub services_scroll_offset: usize,
-    pub backup_scroll_offset: usize,
     /// Last update time for this host
     pub last_update: Option<Instant>,
-    /// Pending service transitions for immediate visual feedback
-    pub pending_service_transitions: HashMap<String, (CommandType, String, Instant)>, // service_name -> (command_type, original_status, start_time)
 }
 
 impl HostWidgets {
@@ -63,11 +44,7 @@ impl HostWidgets {
             system_widget: SystemWidget::new(),
             services_widget: ServicesWidget::new(),
             backup_widget: BackupWidget::new(),
-            system_scroll_offset: 0,
-            services_scroll_offset: 0,
-            backup_scroll_offset: 0,
             last_update: None,
-            pending_service_transitions: HashMap::new(),
         }
     }
 }
@@ -89,19 +66,33 @@ pub struct TuiApp {
     user_navigated_away: bool,
     /// Dashboard configuration
     config: DashboardConfig,
+    /// Cached localhost hostname to avoid repeated system calls
+    localhost: String,
 }
 
 impl TuiApp {
     pub fn new(config: DashboardConfig) -> Self {
-        Self {
+        let localhost = gethostname::gethostname().to_string_lossy().to_string();
+        let mut app = Self {
             host_widgets: HashMap::new(),
             current_host: None,
-            available_hosts: Vec::new(),
+            available_hosts: config.hosts.keys().cloned().collect(),
             host_index: 0,
             should_quit: false,
             user_navigated_away: false,
             config,
+            localhost,
+        };
+        
+        // Sort predefined hosts
+        app.available_hosts.sort();
+        
+        // Initialize with first host if available
+        if !app.available_hosts.is_empty() {
+            app.current_host = Some(app.available_hosts[0].clone());
         }
+        
+        app
     }
 
     /// Get or create host widgets for the given hostname
@@ -120,34 +111,32 @@ impl TuiApp {
             // Only update widgets if we have metrics for this host
             let all_metrics = metric_store.get_metrics_for_host(&hostname);
             if !all_metrics.is_empty() {
-                // Get metrics first while hostname is borrowed
+                // Single pass metric categorization for better performance
-                let cpu_metrics: Vec<&Metric> = all_metrics
+                let mut cpu_metrics = Vec::new();
-                    .iter()
+                let mut memory_metrics = Vec::new();
-                    .filter(|m| {
+                let mut service_metrics = Vec::new();
-                        m.name.starts_with("cpu_")
+                let mut backup_metrics = Vec::new();
-                            || m.name.contains("c_state_")
+                let mut nixos_metrics = Vec::new();
-                            || m.name.starts_with("process_top_")
+                let mut disk_metrics = Vec::new();
-                    })
+                
-                    .copied()
+                for metric in all_metrics {
-                    .collect();
+                    if metric.name.starts_with("cpu_") 
-                let memory_metrics: Vec<&Metric> = all_metrics
+                        || metric.name.contains("c_state_") 
-                    .iter()
+                        || metric.name.starts_with("process_top_") {
-                    .filter(|m| m.name.starts_with("memory_") || m.name.starts_with("disk_tmp_"))
+                        cpu_metrics.push(metric);
-                    .copied()
+                    } else if metric.name.starts_with("memory_") || metric.name.starts_with("disk_tmp_") {
-                    .collect();
+                        memory_metrics.push(metric);
-                let service_metrics: Vec<&Metric> = all_metrics
+                    } else if metric.name.starts_with("service_") {
-                    .iter()
+                        service_metrics.push(metric);
-                    .filter(|m| m.name.starts_with("service_"))
+                    } else if metric.name.starts_with("backup_") {
-                    .copied()
+                        backup_metrics.push(metric);
-                    .collect();
+                    } else if metric.name == "system_nixos_build" || metric.name == "system_active_users" || metric.name == "agent_version" {
-                let all_backup_metrics: Vec<&Metric> = all_metrics
+                        nixos_metrics.push(metric);
-                    .iter()
+                    } else if metric.name.starts_with("disk_") {
-                    .filter(|m| m.name.starts_with("backup_"))
+                        disk_metrics.push(metric);
-                    .copied()
+                    }
-                    .collect();
+                }
 
-                // Clear completed transitions first
-                self.clear_completed_transitions(&hostname, &service_metrics);
 
                 // Now get host widgets and update them
                 let host_widgets = self.get_or_create_host_widgets(&hostname);
@@ -155,21 +144,7 @@ impl TuiApp {
                 // Collect all system metrics (CPU, memory, NixOS, disk/storage)
                 let mut system_metrics = cpu_metrics;
                 system_metrics.extend(memory_metrics);
-                
-                // Add NixOS metrics - using exact matching for build display fix
-                let nixos_metrics: Vec<&Metric> = all_metrics
-                    .iter()
-                    .filter(|m| m.name == "system_nixos_build" || m.name == "system_active_users" || m.name == "agent_version")
-                    .copied()
-                    .collect();
                 system_metrics.extend(nixos_metrics);
-                
-                // Add disk/storage metrics
-                let disk_metrics: Vec<&Metric> = all_metrics
-                    .iter()
-                    .filter(|m| m.name.starts_with("disk_"))
-                    .copied()
-                    .collect();
                 system_metrics.extend(disk_metrics);
 
                 host_widgets.system_widget.update_from_metrics(&system_metrics);
@@ -178,7 +153,7 @@ impl TuiApp {
                     .update_from_metrics(&service_metrics);
                 host_widgets
                     .backup_widget
-                    .update_from_metrics(&all_backup_metrics);
+                    .update_from_metrics(&backup_metrics);
 
                 host_widgets.last_update = Some(Instant::now());
             }
@@ -186,30 +161,28 @@ impl TuiApp {
     }
 
     /// Update available hosts with localhost prioritization
-    pub fn update_hosts(&mut self, hosts: Vec<String>) {
+    pub fn update_hosts(&mut self, discovered_hosts: Vec<String>) {
-        // Sort hosts alphabetically
+        // Start with configured hosts (always visible)
-        let mut sorted_hosts = hosts.clone();
+        let mut all_hosts: Vec<String> = self.config.hosts.keys().cloned().collect();
         
-        // Keep hosts that have pending transitions even if they're offline
+        // Add any discovered hosts that aren't already configured
-        for (hostname, host_widgets) in &self.host_widgets {
+        for host in discovered_hosts {
-            if !host_widgets.pending_service_transitions.is_empty() {
+            if !all_hosts.contains(&host) {
-                if !sorted_hosts.contains(hostname) {
+                all_hosts.push(host);
-                    sorted_hosts.push(hostname.clone());
-                }
             }
         }
         
-        sorted_hosts.sort();
+        
-        self.available_hosts = sorted_hosts;
+        all_hosts.sort();
+        self.available_hosts = all_hosts;
         
         // Get the current hostname (localhost) for auto-selection
-        let localhost = gethostname::gethostname().to_string_lossy().to_string();
         if !self.available_hosts.is_empty() {
-            if self.available_hosts.contains(&localhost) && !self.user_navigated_away {
+            if self.available_hosts.contains(&self.localhost) && !self.user_navigated_away {
                 // Localhost is available and user hasn't navigated away - switch to it
-                self.current_host = Some(localhost.clone());
+                self.current_host = Some(self.localhost.clone());
                 // Find the actual index of localhost in the sorted list
-                self.host_index = self.available_hosts.iter().position(|h| h == &localhost).unwrap_or(0);
+                self.host_index = self.available_hosts.iter().position(|h| h == &self.localhost).unwrap_or(0);
             } else if self.current_host.is_none() {
                 // No current host - select first available (which is localhost if available)
                 self.current_host = Some(self.available_hosts[0].clone());
@@ -229,7 +202,7 @@ impl TuiApp {
     }
 
     /// Handle keyboard input
-    pub fn handle_input(&mut self, event: Event) -> Result<Option<UiCommand>> {
+    pub fn handle_input(&mut self, event: Event) -> Result<()> {
         if let Event::Key(key) = event {
             match key.code {
                 KeyCode::Char('q') => {
@@ -244,75 +217,194 @@ impl TuiApp {
                 KeyCode::Char('r') => {
                     // System rebuild command - works on any panel for current host
                     if let Some(hostname) = self.current_host.clone() {
-                        // Create command that shows CM Dashboard logo and then rebuilds
+                        let connection_ip = self.get_connection_ip(&hostname);
+                        // Create command that shows logo, rebuilds, and waits for user input
                         let logo_and_rebuild = format!(
-                            r"cat << 'EOF'
+                            "bash -c 'cat << \"EOF\"\nNixOS System Rebuild\nTarget: {} ({})\n\nEOF\nssh -tt {}@{} \"bash -ic {}\"\necho\necho \"========================================\"\necho \"Rebuild completed. Press any key to close...\"\necho \"========================================\"\nread -n 1 -s\nexit'",
-NixOS System Rebuild
-Target: {}
-
-EOF
-ssh -tt {}@{} 'bash -ic {}'",
                             hostname,
+                            connection_ip,
                             self.config.ssh.rebuild_user,
-                            hostname,
+                            connection_ip,
                             self.config.ssh.rebuild_alias
                         );
                         
                         std::process::Command::new("tmux")
-                            .arg("display-popup")
+                            .arg("split-window")
-                            .arg("-w")
+                            .arg("-v")
-                            .arg("80%")
+                            .arg("-p")
-                            .arg("-h") 
+                            .arg("30")
-                            .arg("80%")
                             .arg(&logo_and_rebuild)
                             .spawn()
                             .ok(); // Ignore errors, tmux will handle them
                     }
                 }
-                KeyCode::Char('s') => {
+                KeyCode::Char('B') => {
-                    // Service start command
+                    // Backup command - works on any panel for current host
-                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
+                    if let Some(hostname) = self.current_host.clone() {
-                        if self.start_command(&hostname, CommandType::ServiceStart, service_name.clone()) {
+                        let connection_ip = self.get_connection_ip(&hostname);
-                            return Ok(Some(UiCommand::ServiceStart { hostname, service_name }));
+                        // Create command that shows logo, runs backup, and waits for user input
-                        }
+                        let logo_and_backup = format!(
-                    }
+                            "bash -c 'cat << \"EOF\"\nBackup Operation\nTarget: {} ({})\n\nEOF\nssh -tt {}@{} \"bash -ic {}\"\necho\necho \"========================================\"\necho \"Backup completed. Press any key to close...\"\necho \"========================================\"\nread -n 1 -s\nexit'",
-                }
-                KeyCode::Char('S') => {
-                    // Service stop command
-                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
-                        if self.start_command(&hostname, CommandType::ServiceStop, service_name.clone()) {
-                            return Ok(Some(UiCommand::ServiceStop { hostname, service_name }));
-                        }
-                    }
-                }
-                KeyCode::Char('J') => {
-                    // Show service logs via journalctl in tmux popup
-                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
-                        let journalctl_command = format!(
-                            "ssh -tt {}@{} 'journalctl -u {}.service -f --no-pager -n 50'",
-                            self.config.ssh.rebuild_user,
                             hostname,
+                            connection_ip,
+                            self.config.ssh.rebuild_user,
+                            connection_ip,
+                            self.config.ssh.backup_alias
+                        );
+                        
+                        std::process::Command::new("tmux")
+                            .arg("split-window")
+                            .arg("-v")
+                            .arg("-p")
+                            .arg("30")
+                            .arg(&logo_and_backup)
+                            .spawn()
+                            .ok(); // Ignore errors, tmux will handle them
+                    }
+                }
+                KeyCode::Char('s') => {
+                    // Service start command via SSH with progress display
+                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
+                        let connection_ip = self.get_connection_ip(&hostname);
+                        let service_start_command = format!(
+                            "bash -c 'cat << \"EOF\"\nService Start: {}\nTarget: {} ({})\n\nEOF\nssh -tt {}@{} \"echo \\\"Starting service...\\\" && sudo systemctl start {} && echo \\\"Following logs (Ctrl+C to stop):\\\" && echo \\\"========================================\\\" && sudo journalctl -fu {} --no-pager\"\necho\necho \"========================================\"\necho \"Operation completed. Press any key to close...\"\necho \"========================================\"\nread -n 1 -s\nexit'",
+                            service_name,
+                            hostname,
+                            connection_ip,
+                            self.config.ssh.rebuild_user,
+                            connection_ip,
+                            service_name,
                             service_name
                         );
                         
                         std::process::Command::new("tmux")
-                            .arg("display-popup")
+                            .arg("split-window")
-                            .arg("-w")
+                            .arg("-v")
-                            .arg("80%")
+                            .arg("-p")
-                            .arg("-h") 
+                            .arg("30")
-                            .arg("80%")
+                            .arg(&service_start_command)
-                            .arg("-t")
+                            .spawn()
-                            .arg(format!("Logs: {}", service_name))
+                            .ok(); // Ignore errors, tmux will handle them
+                    }
+                }
+                KeyCode::Char('S') => {
+                    // Service stop command via SSH with progress display
+                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
+                        let connection_ip = self.get_connection_ip(&hostname);
+                        let service_stop_command = format!(
+                            "bash -c 'cat << \"EOF\"\nService Stop: {}.service\nTarget: {} ({})\n\nEOF\nssh -tt {}@{} \"echo \\\"Stopping service...\\\" && sudo systemctl stop {}.service && echo \\\"Service stopped! Final logs:\\\" && echo \\\"========================================\\\" && sudo journalctl -u {}.service --no-pager -n 10 && echo \\\"========================================\\\" && sudo systemctl status {}.service --no-pager -l\"\necho\necho \"========================================\"\necho \"Operation completed. Press any key to close...\"\necho \"========================================\"\nread -n 1 -s\nexit'",
+                            service_name,
+                            hostname,
+                            connection_ip,
+                            self.config.ssh.rebuild_user,
+                            connection_ip,
+                            service_name,
+                            service_name,
+                            service_name
+                        );
+                        
+                        std::process::Command::new("tmux")
+                            .arg("split-window")
+                            .arg("-v")
+                            .arg("-p")
+                            .arg("30")
+                            .arg(&service_stop_command)
+                            .spawn()
+                            .ok(); // Ignore errors, tmux will handle them
+                    }
+                }
+                KeyCode::Char('J') => {
+                    // Show service logs via journalctl in tmux split window
+                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
+                        let connection_ip = self.get_connection_ip(&hostname);
+                        let journalctl_command = format!(
+                            "bash -c \"ssh -tt {}@{} 'sudo journalctl -u {}.service -f --no-pager -n 50'; exit\"",
+                            self.config.ssh.rebuild_user,
+                            connection_ip,
+                            service_name
+                        );
+                        
+                        std::process::Command::new("tmux")
+                            .arg("split-window")
+                            .arg("-v")
+                            .arg("-p")
+                            .arg("30")
                             .arg(&journalctl_command)
                             .spawn()
                             .ok(); // Ignore errors, tmux will handle them
                     }
                 }
-                KeyCode::Char('b') => {
+                KeyCode::Char('L') => {
-                    // Trigger backup
+                    // Show custom service log file in tmux split window
+                    if let (Some(service_name), Some(hostname)) = (self.get_selected_service(), self.current_host.clone()) {
+                        // Check if this service has a custom log file configured
+                        if let Some(host_logs) = self.config.service_logs.get(&hostname) {
+                            if let Some(log_config) = host_logs.iter().find(|config| config.service_name == service_name) {
+                                let connection_ip = self.get_connection_ip(&hostname);
+                                let tail_command = format!(
+                                    "bash -c \"ssh -tt {}@{} 'sudo tail -n 50 -f {}'; exit\"",
+                                    self.config.ssh.rebuild_user,
+                                    connection_ip,
+                                    log_config.log_file_path
+                                );
+                                
+                                std::process::Command::new("tmux")
+                                    .arg("split-window")
+                                    .arg("-v")
+                                    .arg("-p")
+                                    .arg("30")
+                                    .arg(&tail_command)
+                                    .spawn()
+                                    .ok(); // Ignore errors, tmux will handle them
+                            }
+                        }
+                    }
+                }
+                KeyCode::Char('w') => {
+                    // Wake on LAN for offline hosts
                     if let Some(hostname) = self.current_host.clone() {
-                        self.start_command(&hostname, CommandType::BackupTrigger, hostname.clone());
+                        // Check if host has MAC address configured
-                        return Ok(Some(UiCommand::TriggerBackup { hostname }));
+                        if let Some(host_details) = self.config.hosts.get(&hostname) {
+                            if let Some(mac_address) = &host_details.mac_address {
+                                // Parse MAC address and send WoL packet
+                                let mac_bytes = Self::parse_mac_address(mac_address);
+                                match mac_bytes {
+                                    Ok(mac) => {
+                                        match MagicPacket::new(&mac).send() {
+                                            Ok(_) => {
+                                                info!("WakeOnLAN packet sent successfully to {} ({})", hostname, mac_address);
+                                            }
+                                            Err(e) => {
+                                                tracing::error!("Failed to send WakeOnLAN packet to {}: {}", hostname, e);
+                                            }
+                                        }
+                                    }
+                                    Err(_) => {
+                                        tracing::error!("Invalid MAC address format for {}: {}", hostname, mac_address);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                KeyCode::Char('t') => {
+                    // Open SSH terminal session in tmux window
+                    if let Some(hostname) = self.current_host.clone() {
+                        let connection_ip = self.get_connection_ip(&hostname);
+                        let ssh_command = format!(
+                            "ssh -tt {}@{}",
+                            self.config.ssh.rebuild_user,
+                            connection_ip
+                        );
+                        
+                        std::process::Command::new("tmux")
+                            .arg("split-window")
+                            .arg("-v")
+                            .arg("-p")
+                            .arg("30") // Use 30% like other commands
+                            .arg(&ssh_command)
+                            .spawn()
+                            .ok(); // Ignore errors, tmux will handle them
                     }
                 }
                 KeyCode::Tab => {
@@ -340,7 +432,7 @@ ssh -tt {}@{} 'bash -ic {}'",
                 _ => {}
             }
         }
-        Ok(None)
+        Ok(())
     }
 
     /// Navigate between hosts
@@ -363,9 +455,8 @@ ssh -tt {}@{} 'bash -ic {}'",
         self.current_host = Some(self.available_hosts[self.host_index].clone());
         
         // Check if user navigated away from localhost
-        let localhost = gethostname::gethostname().to_string_lossy().to_string();
         if let Some(ref current) = self.current_host {
-            if current != &localhost {
+            if current != &self.localhost {
                 self.user_navigated_away = true;
             } else {
                 self.user_navigated_away = false; // User navigated back to localhost
@@ -395,86 +486,8 @@ ssh -tt {}@{} 'bash -ic {}'",
         self.should_quit
     }
 
-    /// Get current service status for state-aware command validation
-    fn get_current_service_status(&self, hostname: &str, service_name: &str) -> Option<String> {
-        if let Some(host_widgets) = self.host_widgets.get(hostname) {
-            return host_widgets.services_widget.get_service_status(service_name);
-        }
-        None
-    }
 
-    /// Start command execution with immediate visual feedback 
-    pub fn start_command(&mut self, hostname: &str, command_type: CommandType, target: String) -> bool {
-        // Get current service status to validate command
-        let current_status = self.get_current_service_status(hostname, &target);
-        
-        // Validate if command makes sense for current state
-        let should_execute = match (&command_type, current_status.as_deref()) {
-            (CommandType::ServiceStart, Some("inactive") | Some("failed") | Some("dead")) => true,
-            (CommandType::ServiceStop, Some("active")) => true,
-            (CommandType::ServiceStart, Some("active")) => {
-                // Already running - don't execute
-                false
-            },
-            (CommandType::ServiceStop, Some("inactive") | Some("failed") | Some("dead")) => {
-                // Already stopped - don't execute  
-                false
-            },
-            (_, None) => {
-                // Unknown service state - allow command to proceed
-                true
-            },
-            _ => true, // Default: allow other combinations
-        };
-        
-        // ALWAYS store the pending transition for immediate visual feedback, even if we don't execute
-        if let Some(host_widgets) = self.host_widgets.get_mut(hostname) {
-            host_widgets.pending_service_transitions.insert(
-                target.clone(), 
-                (command_type, current_status.unwrap_or_else(|| "unknown".to_string()), Instant::now())
-            );
-        }
-        
-        should_execute
-    }
 
-    /// Clear pending transitions when real status updates arrive or timeout
-    fn clear_completed_transitions(&mut self, hostname: &str, service_metrics: &[&Metric]) {
-        if let Some(host_widgets) = self.host_widgets.get_mut(hostname) {
-            let mut completed_services = Vec::new();
-            
-            // Check each pending transition to see if real status has changed
-            for (service_name, (command_type, original_status, _start_time)) in &host_widgets.pending_service_transitions {
-                
-                // Look for status metric for this service
-                for metric in service_metrics {
-                    if metric.name == format!("service_{}_status", service_name) {
-                        let new_status = metric.value.as_string();
-                        
-                        // Check if status has changed from original (command completed)
-                        if &new_status != original_status {
-                            // Verify it changed in the expected direction
-                            let expected_change = match command_type {
-                                CommandType::ServiceStart => &new_status == "active",
-                                CommandType::ServiceStop => &new_status != "active",
-                                _ => false,
-                            };
-                            
-                            if expected_change {
-                                completed_services.push(service_name.clone());
-                            }
-                        }
-                        break;
-                    }
-                }
-            }
-            
-            // Remove completed transitions
-            for service_name in completed_services {
-                host_widgets.pending_service_transitions.remove(&service_name);
-            }
-        }
-    }
 
 
 
@@ -509,6 +522,21 @@ ssh -tt {}@{} 'bash -ic {}'",
             ])
             .split(main_chunks[1]); // main_chunks[1] is now the content area (between title and statusbar)
 
+        // Check if current host is offline
+        let current_host_offline = if let Some(hostname) = self.current_host.clone() {
+            self.calculate_host_status(&hostname, metric_store) == Status::Offline
+        } else {
+            true // No host selected is considered offline
+        };
+
+        // If host is offline, render wake-up message instead of panels
+        if current_host_offline {
+            self.render_offline_host_message(frame, main_chunks[1]);
+            self.render_btop_title(frame, main_chunks[0], metric_store);
+            self.render_statusbar(frame, main_chunks[2]);
+            return;
+        }
+
         // Check if backup panel should be shown
         let show_backup = if let Some(hostname) = self.current_host.clone() {
             let host_widgets = self.get_or_create_host_widgets(&hostname);
@@ -547,14 +575,10 @@ ssh -tt {}@{} 'bash -ic {}'",
         // Render services widget for current host
         if let Some(hostname) = self.current_host.clone() {
             let is_focused = true; // Always show service selection
-            let (scroll_offset, pending_transitions) = {
-                let host_widgets = self.get_or_create_host_widgets(&hostname);
-                (host_widgets.services_scroll_offset, host_widgets.pending_service_transitions.clone())
-            };
             let host_widgets = self.get_or_create_host_widgets(&hostname);
             host_widgets
                 .services_widget
-                .render_with_transitions(frame, content_chunks[1], is_focused, scroll_offset, &pending_transitions); // Services takes full right side
+                .render(frame, content_chunks[1], is_focused); // Services takes full right side
         }
 
         // Render statusbar at the bottom
@@ -576,11 +600,14 @@ ssh -tt {}@{} 'bash -ic {}'",
             return;
         }
 
-        // Calculate worst-case status across all hosts
+        // Calculate worst-case status across all hosts (excluding offline)
         let mut worst_status = Status::Ok;
         for host in &self.available_hosts {
             let host_status = self.calculate_host_status(host, metric_store);
-            worst_status = Status::aggregate(&[worst_status, host_status]);
+            // Don't include offline hosts in status aggregation
+            if host_status != Status::Offline {
+                worst_status = Status::aggregate(&[worst_status, host_status]);
+            }
         }
 
         // Use the worst status color as background
@@ -658,7 +685,7 @@ ssh -tt {}@{} 'bash -ic {}'",
         let metrics = metric_store.get_metrics_for_host(hostname);
 
         if metrics.is_empty() {
-            return Status::Unknown;
+            return Status::Offline;
         }
 
         // First check if we have the aggregated host status summary from the agent
@@ -678,7 +705,9 @@ ssh -tt {}@{} 'bash -ic {}'",
                 Status::Warning => has_warning = true,
                 Status::Pending => has_pending = true,
                 Status::Ok => ok_count += 1,
-                Status::Unknown => {} // Ignore unknown for aggregation
+                Status::Inactive => ok_count += 1, // Treat inactive as OK for aggregation
+                Status::Unknown => {}, // Ignore unknown for aggregation
+                Status::Offline => {}, // Ignore offline for aggregation
             }
         }
 
@@ -718,6 +747,8 @@ ssh -tt {}@{} 'bash -ic {}'",
         shortcuts.push("r: Rebuild".to_string());
         shortcuts.push("s/S: Start/Stop".to_string());
         shortcuts.push("J: Logs".to_string());
+        shortcuts.push("L: Custom".to_string());
+        shortcuts.push("w: Wake".to_string());
         
         // Always show quit
         shortcuts.push("q: Quit".to_string());
@@ -731,12 +762,10 @@ ssh -tt {}@{} 'bash -ic {}'",
         frame.render_widget(system_block, area);
         // Get current host widgets, create if none exist
         if let Some(hostname) = self.current_host.clone() {
-            let scroll_offset = {
+            // Clone the config to avoid borrowing issues
-                let host_widgets = self.get_or_create_host_widgets(&hostname);
+            let config = self.config.clone();
-                host_widgets.system_scroll_offset
-            };
             let host_widgets = self.get_or_create_host_widgets(&hostname);
-            host_widgets.system_widget.render_with_scroll(frame, inner_area, scroll_offset, &hostname);
+            host_widgets.system_widget.render(frame, inner_area, &hostname, Some(&config));
         }
     }
 
@@ -747,14 +776,105 @@ ssh -tt {}@{} 'bash -ic {}'",
 
         // Get current host widgets for backup widget
         if let Some(hostname) = self.current_host.clone() {
-            let scroll_offset = {
-                let host_widgets = self.get_or_create_host_widgets(&hostname);
-                host_widgets.backup_scroll_offset
-            };
             let host_widgets = self.get_or_create_host_widgets(&hostname);
-            host_widgets.backup_widget.render_with_scroll(frame, inner_area, scroll_offset);
+            host_widgets.backup_widget.render(frame, inner_area);
         }
     }
 
+    /// Render offline host message with wake-up option
+    fn render_offline_host_message(&self, frame: &mut Frame, area: Rect) {
+        use ratatui::layout::Alignment;
+        use ratatui::style::Modifier;
+        use ratatui::text::{Line, Span};
+        use ratatui::widgets::{Block, Borders, Paragraph};
 
+        // Get hostname for message
+        let hostname = self.current_host.as_ref()
+            .map(|h| h.as_str())
+            .unwrap_or("Unknown");
+
+        // Check if host has MAC address for wake-on-LAN
+        let has_mac = self.current_host.as_ref()
+            .and_then(|hostname| self.config.hosts.get(hostname))
+            .and_then(|details| details.mac_address.as_ref())
+            .is_some();
+
+        // Create message content
+        let mut lines = vec![
+            Line::from(Span::styled(
+                format!("Host '{}' is offline", hostname),
+                Style::default().fg(Theme::muted_text()).add_modifier(Modifier::BOLD),
+            )),
+            Line::from(""),
+        ];
+
+        if has_mac {
+            lines.push(Line::from(Span::styled(
+                "Press 'w' to wake up host",
+                Style::default().fg(Theme::primary_text()).add_modifier(Modifier::BOLD),
+            )));
+        } else {
+            lines.push(Line::from(Span::styled(
+                "No MAC address configured - cannot wake up",
+                Style::default().fg(Theme::muted_text()),
+            )));
+        }
+
+        // Create centered message
+        let message = Paragraph::new(lines)
+            .block(Block::default()
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(Theme::muted_text()))
+                .title(" Offline Host ")
+                .title_style(Style::default().fg(Theme::muted_text()).add_modifier(Modifier::BOLD)))
+            .style(Style::default().bg(Theme::background()).fg(Theme::primary_text()))
+            .alignment(Alignment::Center);
+
+        // Center the message in the available area
+        let popup_area = ratatui::layout::Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Percentage(40),
+                Constraint::Length(6),
+                Constraint::Percentage(40),
+            ])
+            .split(area)[1];
+
+        let popup_area = ratatui::layout::Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([
+                Constraint::Percentage(25),
+                Constraint::Percentage(50),
+                Constraint::Percentage(25),
+            ])
+            .split(popup_area)[1];
+
+        frame.render_widget(message, popup_area);
+    }
+
+    /// Parse MAC address string (e.g., "AA:BB:CC:DD:EE:FF") to [u8; 6]
+    /// Get the connection IP for a hostname based on host configuration
+    fn get_connection_ip(&self, hostname: &str) -> String {
+        if let Some(host_details) = self.config.hosts.get(hostname) {
+            host_details.get_connection_ip(hostname)
+        } else {
+            hostname.to_string()
+        }
+    }
+
+    fn parse_mac_address(mac_str: &str) -> Result<[u8; 6], &'static str> {
+        let parts: Vec<&str> = mac_str.split(':').collect();
+        if parts.len() != 6 {
+            return Err("MAC address must have 6 parts separated by colons");
+        }
+
+        let mut mac = [0u8; 6];
+        for (i, part) in parts.iter().enumerate() {
+            match u8::from_str_radix(part, 16) {
+                Ok(byte) => mac[i] = byte,
+                Err(_) => return Err("Invalid hexadecimal byte in MAC address"),
+            }
+        }
+        Ok(mac)
+    }
 }

dashboard/src/ui/theme.rs

@@ -143,10 +143,12 @@ impl Theme {
     pub fn status_color(status: Status) -> Color {
         match status {
             Status::Ok => Self::success(),
+            Status::Inactive => Self::muted_text(), // Gray for inactive services in service list
             Status::Pending => Self::highlight(), // Blue for pending
             Status::Warning => Self::warning(),
             Status::Critical => Self::error(),
             Status::Unknown => Self::muted_text(),
+            Status::Offline => Self::muted_text(), // Dark gray for offline
         }
     }
 
@@ -242,10 +244,12 @@ impl StatusIcons {
     pub fn get_icon(status: Status) -> &'static str {
         match status {
             Status::Ok => "●",
+            Status::Inactive => "○", // Empty circle for inactive services
             Status::Pending => "◉", // Hollow circle for pending
             Status::Warning => "◐",
-            Status::Critical => "◯",
+            Status::Critical => "!",
             Status::Unknown => "?",
+            Status::Offline => "○", // Empty circle for offline
         }
     }
 
@@ -254,10 +258,12 @@ impl StatusIcons {
         let icon = Self::get_icon(status);
         let status_color = match status {
             Status::Ok => Theme::success(),         // Green
+            Status::Inactive => Theme::muted_text(), // Gray for inactive services
             Status::Pending => Theme::highlight(),       // Blue
             Status::Warning => Theme::warning(),    // Yellow
             Status::Critical => Theme::error(),     // Red
             Status::Unknown => Theme::muted_text(), // Gray
+            Status::Offline => Theme::muted_text(), // Dark gray for offline
         };
 
         vec![

dashboard/src/ui/widgets/backup.rs

@@ -285,8 +285,8 @@ impl Widget for BackupWidget {
 }
 
 impl BackupWidget {
-    /// Render with scroll offset support
+    /// Render backup widget
-    pub fn render_with_scroll(&mut self, frame: &mut Frame, area: Rect, scroll_offset: usize) {
+    pub fn render(&mut self, frame: &mut Frame, area: Rect) {
         let mut lines = Vec::new();
 
         // Latest backup section
@@ -366,42 +366,20 @@ impl BackupWidget {
         let total_lines = lines.len();
         let available_height = area.height as usize;
         
-        // Calculate scroll boundaries
+        // Show only what fits, with "X more below" if needed
-        let max_scroll = if total_lines > available_height {
+        if total_lines > available_height {
-            total_lines - available_height
+            let lines_for_content = available_height.saturating_sub(1); // Reserve one line for "more below"
-        } else {
-            total_lines.saturating_sub(1)
-        };
-        let effective_scroll = scroll_offset.min(max_scroll);
-        
-        // Apply scrolling if needed
-        if scroll_offset > 0 || total_lines > available_height {
             let mut visible_lines: Vec<_> = lines
                 .into_iter()
-                .skip(effective_scroll)
+                .take(lines_for_content)
-                .take(available_height)
                 .collect();
             
-            // Add scroll indicator if there are hidden lines
+            let hidden_below = total_lines.saturating_sub(lines_for_content);
-            if total_lines > available_height {
+            if hidden_below > 0 {
-                let hidden_above = effective_scroll;
+                let more_line = ratatui::text::Line::from(vec![
-                let hidden_below = total_lines.saturating_sub(effective_scroll + available_height);
+                    ratatui::text::Span::styled(format!("... {} more below", hidden_below), Typography::muted())
-                
+                ]);
-                if (hidden_above > 0 || hidden_below > 0) && !visible_lines.is_empty() {
+                visible_lines.push(more_line);
-                    let scroll_text = if hidden_above > 0 && hidden_below > 0 {
-                        format!("... {} above, {} below", hidden_above, hidden_below)
-                    } else if hidden_above > 0 {
-                        format!("... {} more above", hidden_above)
-                    } else {
-                        format!("... {} more below", hidden_below)
-                    };
-                    
-                    // Replace last line with scroll indicator
-                    visible_lines.pop();
-                    visible_lines.push(ratatui::text::Line::from(vec![
-                        ratatui::text::Span::styled(scroll_text, Typography::muted())
-                    ]));
-                }
             }
             
             let paragraph = Paragraph::new(ratatui::text::Text::from(visible_lines));

dashboard/src/ui/widgets/services.rs

@@ -9,7 +9,6 @@ use tracing::debug;
 
 use super::Widget;
 use crate::ui::theme::{Components, StatusIcons, Theme, Typography};
-use crate::ui::CommandType;
 use ratatui::style::Style;
 
 /// Services widget displaying hierarchical systemd service statuses
@@ -125,40 +124,14 @@ impl ServicesWidget {
         )
     }
 
-    /// Get status icon for service, considering pending transitions for visual feedback
-    fn get_service_icon_and_status(&self, service_name: &str, info: &ServiceInfo, pending_transitions: &HashMap<String, (CommandType, String, std::time::Instant)>) -> (String, String, ratatui::prelude::Color) {
-        // Check if this service has a pending transition
-        if let Some((command_type, _original_status, _start_time)) = pending_transitions.get(service_name) {
-            // Show transitional icons for pending commands
-            let (icon, status_text) = match command_type {
-                CommandType::ServiceStart => ("↑", "starting"), 
-                CommandType::ServiceStop => ("↓", "stopping"),
-                _ => return (StatusIcons::get_icon(info.widget_status).to_string(), info.status.clone(), Theme::status_color(info.widget_status)), // Not a service command
-            };
-            return (icon.to_string(), status_text.to_string(), Theme::highlight());
-        }
-        
-        // Normal status display
-        let icon = StatusIcons::get_icon(info.widget_status);
-        let status_color = match info.widget_status {
-            Status::Ok => Theme::success(),
-            Status::Pending => Theme::highlight(),
-            Status::Warning => Theme::warning(),
-            Status::Critical => Theme::error(),
-            Status::Unknown => Theme::muted_text(),
-        };
-        
-        (icon.to_string(), info.status.clone(), status_color)
-    }
 
 
-    /// Create spans for sub-service with icon next to name, considering pending transitions
+    /// Create spans for sub-service with icon next to name
-    fn create_sub_service_spans_with_transitions(
+    fn create_sub_service_spans(
         &self,
         name: &str,
         info: &ServiceInfo,
         is_last: bool,
-        pending_transitions: &HashMap<String, (CommandType, String, std::time::Instant)>,
     ) -> Vec<ratatui::text::Span<'static>> {
         // Truncate long sub-service names to fit layout (accounting for indentation)
         let short_name = if name.len() > 18 {
@@ -167,19 +140,28 @@ impl ServicesWidget {
             name.to_string()
         };
 
-        // Get status icon and text, considering pending transitions
+        // Get status icon and text
-        let (icon, mut status_str, status_color) = self.get_service_icon_and_status(name, info, pending_transitions);
+        let icon = StatusIcons::get_icon(info.widget_status);
+        let status_color = match info.widget_status {
+            Status::Ok => Theme::success(),
+            Status::Inactive => Theme::muted_text(),
+            Status::Pending => Theme::highlight(),
+            Status::Warning => Theme::warning(),
+            Status::Critical => Theme::error(),
+            Status::Unknown => Theme::muted_text(),
+            Status::Offline => Theme::muted_text(),
+        };
 
-        // For sub-services, prefer latency if available (unless transition is pending)
+        // For sub-services, prefer latency if available
-        if !pending_transitions.contains_key(name) {
+        let status_str = if let Some(latency) = info.latency_ms {
-            if let Some(latency) = info.latency_ms {
+            if latency < 0.0 {
-                status_str = if latency < 0.0 {
+                "timeout".to_string()
-                    "timeout".to_string()
+            } else {
-                } else {
+                format!("{:.0}ms", latency)
-                    format!("{:.0}ms", latency)
-                };
             }
-        }
+        } else {
+            info.status.clone()
+        };
         let tree_symbol = if is_last { "└─" } else { "├─" };
 
         vec![
@@ -265,25 +247,6 @@ impl ServicesWidget {
         self.parent_services.len()
     }
 
-    /// Get current status of a specific service by name
-    pub fn get_service_status(&self, service_name: &str) -> Option<String> {
-        // Check if it's a parent service
-        if let Some(parent_info) = self.parent_services.get(service_name) {
-            return Some(parent_info.status.clone());
-        }
-        
-        // Check sub-services (format: parent_sub)
-        for (parent_name, sub_list) in &self.sub_services {
-            for (sub_name, sub_info) in sub_list {
-                let full_sub_name = format!("{}_{}", parent_name, sub_name);
-                if full_sub_name == service_name {
-                    return Some(sub_info.status.clone());
-                }
-            }
-        }
-        
-        None
-    }
 
     /// Calculate which parent service index corresponds to a display line index
     fn calculate_parent_service_index(&self, display_line_index: &usize) -> usize {
@@ -438,8 +401,8 @@ impl Widget for ServicesWidget {
 
 impl ServicesWidget {
 
-    /// Render with focus, scroll, and pending transitions for visual feedback
+    /// Render with focus
-    pub fn render_with_transitions(&mut self, frame: &mut Frame, area: Rect, is_focused: bool, scroll_offset: usize, pending_transitions: &HashMap<String, (CommandType, String, std::time::Instant)>) {
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
         let services_block = Components::widget_block("services");
         let inner_area = services_block.inner(area);
         frame.render_widget(services_block, area);
@@ -464,14 +427,14 @@ impl ServicesWidget {
             return;
         }
 
-        // Use the existing render logic but with pending transitions
+        // Render the services list
-        self.render_services_with_transitions(frame, content_chunks[1], is_focused, scroll_offset, pending_transitions);
+        self.render_services(frame, content_chunks[1], is_focused);
     }
 
-    /// Render services list with pending transitions awareness
+    /// Render services list
-    fn render_services_with_transitions(&mut self, frame: &mut Frame, area: Rect, is_focused: bool, scroll_offset: usize, pending_transitions: &HashMap<String, (CommandType, String, std::time::Instant)>) {
+    fn render_services(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
-        // Build hierarchical service list for display - include raw service name for pending transition lookups
+        // Build hierarchical service list for display
-        let mut display_lines: Vec<(String, Status, bool, Option<(ServiceInfo, bool)>, String)> = Vec::new(); // Added raw service name
+        let mut display_lines: Vec<(String, Status, bool, Option<(ServiceInfo, bool)>)> = Vec::new();
 
         // Sort parent services alphabetically for consistent order
         let mut parent_services: Vec<_> = self.parent_services.iter().collect();
@@ -480,7 +443,7 @@ impl ServicesWidget {
         for (parent_name, parent_info) in parent_services {
             // Add parent service line
             let parent_line = self.format_parent_service_line(parent_name, parent_info);
-            display_lines.push((parent_line, parent_info.widget_status, false, None, parent_name.clone())); // Include raw name
+            display_lines.push((parent_line, parent_info.widget_status, false, None));
 
             // Add sub-services for this parent (if any)
             if let Some(sub_list) = self.sub_services.get(parent_name) {
@@ -490,49 +453,48 @@ impl ServicesWidget {
 
                 for (i, (sub_name, sub_info)) in sorted_subs.iter().enumerate() {
                     let is_last_sub = i == sorted_subs.len() - 1;
-                    let full_sub_name = format!("{}_{}", parent_name, sub_name);
                     // Store sub-service info for custom span rendering
                     display_lines.push((
                         sub_name.clone(),
                         sub_info.widget_status,
                         true,
                         Some((sub_info.clone(), is_last_sub)),
-                        full_sub_name, // Raw service name for pending transition lookup
                     )); // true = sub-service, with is_last info
                 }
             }
         }
 
-        // Apply scroll offset and render visible lines (same as existing logic)
+        // Show only what fits, with "X more below" if needed
         let available_lines = area.height as usize;
         let total_lines = display_lines.len();
         
-        // Calculate scroll boundaries
+        // Reserve one line for "X more below" if needed
-        let max_scroll = if total_lines > available_lines {
+        let lines_for_content = if total_lines > available_lines {
-            total_lines - available_lines
+            available_lines.saturating_sub(1)
         } else {
-            total_lines.saturating_sub(1)
+            available_lines
         };
-        let effective_scroll = scroll_offset.min(max_scroll);
         
-        // Get visible lines after scrolling
         let visible_lines: Vec<_> = display_lines
             .iter()
-            .skip(effective_scroll)
+            .take(lines_for_content)
-            .take(available_lines)
             .collect();
         
+        let hidden_below = total_lines.saturating_sub(lines_for_content);
+        
         let lines_to_show = visible_lines.len();
 
         if lines_to_show > 0 {
+            // Add space for "X more below" message if needed
+            let total_chunks_needed = if hidden_below > 0 { lines_to_show + 1 } else { lines_to_show };
             let service_chunks = Layout::default()
                 .direction(Direction::Vertical)
-                .constraints(vec![Constraint::Length(1); lines_to_show])
+                .constraints(vec![Constraint::Length(1); total_chunks_needed])
                 .split(area);
 
-            for (i, (line_text, line_status, is_sub, sub_info, raw_service_name)) in visible_lines.iter().enumerate()
+            for (i, (line_text, line_status, is_sub, sub_info)) in visible_lines.iter().enumerate()
             {
-                let actual_index = effective_scroll + i; // Real index in the full list
+                let actual_index = i; // Simple index since we're not scrolling
                 
                 // Only parent services can be selected - calculate parent service index
                 let is_selected = if !*is_sub {
@@ -544,41 +506,16 @@ impl ServicesWidget {
                 };
                 
                 let mut spans = if *is_sub && sub_info.is_some() {
-                    // Use custom sub-service span creation WITH pending transitions
+                    // Use custom sub-service span creation
                     let (service_info, is_last) = sub_info.as_ref().unwrap();
-                    self.create_sub_service_spans_with_transitions(line_text, service_info, *is_last, pending_transitions)
+                    self.create_sub_service_spans(line_text, service_info, *is_last)
                 } else {
-                    // Parent services - check if this parent service has a pending transition using RAW service name
+                    // Parent services - use normal status spans
-                    if pending_transitions.contains_key(raw_service_name) {
+                    StatusIcons::create_status_spans(*line_status, line_text)
-                        // Create spans with transitional status
-                        let (icon, status_text, _) = self.get_service_icon_and_status(raw_service_name, &ServiceInfo { 
-                            status: "".to_string(), 
-                            memory_mb: None, 
-                            disk_gb: None, 
-                            latency_ms: None, 
-                            widget_status: *line_status 
-                        }, pending_transitions);
-                        
-                        // Use blue for transitional icons when not selected, background color when selected
-                        let icon_color = if is_selected && !*is_sub && is_focused {
-                            Theme::background() // Dark background color for visibility against blue selection
-                        } else {
-                            Theme::highlight() // Blue for normal case
-                        };
-                        
-                        vec![
-                            ratatui::text::Span::styled(format!("{} ", icon), Style::default().fg(icon_color)),
-                            ratatui::text::Span::styled(line_text.clone(), Style::default().fg(Theme::primary_text())),
-                            ratatui::text::Span::styled(format!(" {}", status_text), Style::default().fg(icon_color)),
-                        ]
-                    } else {
-                        StatusIcons::create_status_spans(*line_status, line_text)
-                    }
                 };
                 
-                // Apply selection highlighting to parent services only, making icons background color when selected
+                // Apply selection highlighting to parent services only
                 // Only show selection when Services panel is focused
-                // Show selection highlighting even when transitional icons are present
                 if is_selected && !*is_sub && is_focused {
                     for (i, span) in spans.iter_mut().enumerate() {
                         if i == 0 {
@@ -599,33 +536,12 @@ impl ServicesWidget {
                 
                 frame.render_widget(service_para, service_chunks[i]);
             }
-        }
-
-        // Show scroll indicator if there are more services than we can display (same as existing)
-        if total_lines > available_lines {
-            let hidden_above = effective_scroll;
-            let hidden_below = total_lines.saturating_sub(effective_scroll + available_lines);
             
-            if hidden_above > 0 || hidden_below > 0 {
+            // Show "X more below" message if content was truncated
-                let scroll_text = if hidden_above > 0 && hidden_below > 0 {
+            if hidden_below > 0 {
-                    format!("... {} above, {} below", hidden_above, hidden_below)
+                let more_text = format!("... {} more below", hidden_below);
-                } else if hidden_above > 0 {
+                let more_para = Paragraph::new(more_text).style(Typography::muted());
-                    format!("... {} more above", hidden_above)
+                frame.render_widget(more_para, service_chunks[lines_to_show]);
-                } else {
-                    format!("... {} more below", hidden_below)
-                };
-                
-                if available_lines > 0 && lines_to_show > 0 {
-                    let last_line_area = Rect {
-                        x: area.x,
-                        y: area.y + (lines_to_show - 1) as u16,
-                        width: area.width,
-                        height: 1,
-                    };
-                    
-                    let scroll_para = Paragraph::new(scroll_text).style(Typography::muted());
-                    frame.render_widget(scroll_para, last_line_area);
-                }
             }
         }
     }

dashboard/src/ui/widgets/system.rs

@@ -438,8 +438,8 @@ impl Widget for SystemWidget {
 }
 
 impl SystemWidget {
-    /// Render with scroll offset support
+    /// Render system widget  
-    pub fn render_with_scroll(&mut self, frame: &mut Frame, area: Rect, scroll_offset: usize, hostname: &str) {
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, config: Option<&crate::config::DashboardConfig>) {
         let mut lines = Vec::new();
 
         // NixOS section
@@ -457,6 +457,16 @@ impl SystemWidget {
             Span::styled(format!("Agent: {}", agent_version_text), Typography::secondary())
         ]));
         
+        // Display detected connection IP
+        if let Some(config) = config {
+            if let Some(host_details) = config.hosts.get(hostname) {
+                let detected_ip = host_details.get_connection_ip(hostname);
+                lines.push(Line::from(vec![
+                    Span::styled(format!("IP: {}", detected_ip), Typography::secondary())
+                ]));
+            }
+        }
+        
 
         // CPU section
         lines.push(Line::from(vec![
@@ -550,22 +560,22 @@ impl SystemWidget {
         let total_lines = lines.len();
         let available_height = area.height as usize;
         
-        // Always apply scrolling if scroll_offset > 0, even if content fits
+        // Show only what fits, with "X more below" if needed
-        if scroll_offset > 0 || total_lines > available_height {
+        if total_lines > available_height {
-            let max_scroll = if total_lines > available_height {
+            let lines_for_content = available_height.saturating_sub(1); // Reserve one line for "more below"
-                total_lines - available_height
+            let mut visible_lines: Vec<Line> = lines
-            } else {
-                total_lines.saturating_sub(1)
-            };
-            let effective_scroll = scroll_offset.min(max_scroll);
-            
-            // Take only the visible portion after scrolling
-            let visible_lines: Vec<Line> = lines
                 .into_iter()
-                .skip(effective_scroll)
+                .take(lines_for_content)
-                .take(available_height)
                 .collect();
-                
+            
+            let hidden_below = total_lines.saturating_sub(lines_for_content);
+            if hidden_below > 0 {
+                let more_line = Line::from(vec![
+                    Span::styled(format!("... {} more below", hidden_below), Typography::muted())
+                ]);
+                visible_lines.push(more_line);
+            }
+            
             let paragraph = Paragraph::new(Text::from(visible_lines));
             frame.render_widget(paragraph, area);
         } else {

shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.47"
+version = "0.1.81"
 edition = "2021"
 
 [dependencies]

shared/src/metrics.rs

@@ -82,11 +82,13 @@ impl MetricValue {
 /// Health status for metrics
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Status {
-    Ok,
+    Inactive, // Lowest priority - treated as good
+    Ok,       // Second lowest - also good
+    Unknown,
+    Offline,
     Pending,
     Warning,
     Critical,
-    Unknown,
 }
 
 impl Status {
@@ -180,6 +182,16 @@ impl HysteresisThresholds {
                     Status::Ok
                 }
             }
+            Status::Inactive => {
+                // Inactive services use normal thresholds like first measurement
+                if value >= self.critical_high {
+                    Status::Critical
+                } else if value >= self.warning_high {
+                    Status::Warning
+                } else {
+                    Status::Ok
+                }
+            }
             Status::Pending => {
                 // Service transitioning, use normal thresholds like first measurement
                 if value >= self.critical_high {
@@ -190,6 +202,16 @@ impl HysteresisThresholds {
                     Status::Ok
                 }
             }
+            Status::Offline => {
+                // Host coming back online, use normal thresholds like first measurement
+                if value >= self.critical_high {
+                    Status::Critical
+                } else if value >= self.warning_high {
+                    Status::Warning
+                } else {
+                    Status::Ok
+                }
+            }
         }
     }
 }