Implement real-time process monitoring and fix UI hardcoded data

This commit addresses several key issues identified during development:

Major Changes:
- Replace hardcoded top CPU/RAM process display with real system data
- Add intelligent process monitoring to CpuCollector using ps command
- Fix disk metrics permission issues in systemd collector
- Optimize service collection to focus on status, memory, and disk only
- Update dashboard widgets to display live process information

Process Monitoring Implementation:
- Added collect_top_cpu_process() and collect_top_ram_process() methods
- Implemented ps-based monitoring with accurate CPU percentages
- Added filtering to prevent self-monitoring artifacts (ps commands)
- Enhanced error handling and validation for process data
- Dashboard now shows realistic values like "claude (PID 2974) 11.0%"

Service Collection Optimization:
- Removed CPU monitoring from systemd collector for efficiency
- Enhanced service directory permission error logging
- Simplified services widget to show essential metrics only
- Fixed service-to-directory mapping accuracy

UI and Dashboard Improvements:
- Reorganized dashboard layout with btop-inspired multi-panel design
- Updated system panel to include real top CPU/RAM process display
- Enhanced widget formatting and data presentation
- Removed placeholder/hardcoded data throughout the interface

Technical Details:
- Updated agent/src/collectors/cpu.rs with process monitoring
- Modified dashboard/src/ui/mod.rs for real-time process display
- Enhanced systemd collector error handling and disk metrics
- Updated CLAUDE.md documentation with implementation details

shared/src/protocol.rs

@@ -0,0 +1,116 @@
+use serde::{Deserialize, Serialize};
+use crate::metrics::Metric;
+
+/// Message sent from agent to dashboard via ZMQ
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MetricMessage {
+    pub hostname: String,
+    pub timestamp: u64,
+    pub metrics: Vec<Metric>,
+}
+
+impl MetricMessage {
+    pub fn new(hostname: String, metrics: Vec<Metric>) -> Self {
+        Self {
+            hostname,
+            timestamp: chrono::Utc::now().timestamp() as u64,
+            metrics,
+        }
+    }
+}
+
+/// Commands that can be sent from dashboard to agent
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Command {
+    /// Request immediate metric refresh
+    RefreshMetrics,
+    /// Request specific metrics by name
+    RequestMetrics { metric_names: Vec<String> },
+    /// Ping command for connection testing
+    Ping,
+}
+
+/// Response from agent to dashboard commands
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CommandResponse {
+    /// Acknowledgment of command
+    Ack,
+    /// Metrics response
+    Metrics(Vec<Metric>),
+    /// Pong response to ping
+    Pong,
+    /// Error response
+    Error { message: String },
+}
+
+/// ZMQ message envelope for routing
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MessageEnvelope {
+    pub message_type: MessageType,
+    pub payload: Vec<u8>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum MessageType {
+    Metrics,
+    Command,
+    CommandResponse,
+    Heartbeat,
+}
+
+impl MessageEnvelope {
+    pub fn metrics(message: MetricMessage) -> Result<Self, crate::SharedError> {
+        Ok(Self {
+            message_type: MessageType::Metrics,
+            payload: serde_json::to_vec(&message)?,
+        })
+    }
+    
+    pub fn command(command: Command) -> Result<Self, crate::SharedError> {
+        Ok(Self {
+            message_type: MessageType::Command,
+            payload: serde_json::to_vec(&command)?,
+        })
+    }
+    
+    pub fn command_response(response: CommandResponse) -> Result<Self, crate::SharedError> {
+        Ok(Self {
+            message_type: MessageType::CommandResponse,
+            payload: serde_json::to_vec(&response)?,
+        })
+    }
+    
+    pub fn heartbeat() -> Result<Self, crate::SharedError> {
+        Ok(Self {
+            message_type: MessageType::Heartbeat,
+            payload: Vec::new(),
+        })
+    }
+    
+    pub fn decode_metrics(&self) -> Result<MetricMessage, crate::SharedError> {
+        match self.message_type {
+            MessageType::Metrics => Ok(serde_json::from_slice(&self.payload)?),
+            _ => Err(crate::SharedError::Protocol {
+                message: "Expected metrics message".to_string(),
+            }),
+        }
+    }
+    
+    pub fn decode_command(&self) -> Result<Command, crate::SharedError> {
+        match self.message_type {
+            MessageType::Command => Ok(serde_json::from_slice(&self.payload)?),
+            _ => Err(crate::SharedError::Protocol {
+                message: "Expected command message".to_string(),
+            }),
+        }
+    }
+    
+    pub fn decode_command_response(&self) -> Result<CommandResponse, crate::SharedError> {
+        match self.message_type {
+            MessageType::CommandResponse => Ok(serde_json::from_slice(&self.payload)?),
+            _ => Err(crate::SharedError::Protocol {
+                message: "Expected command response message".to_string(),
+            }),
+        }
+    }
+}