Revert D-Bus usage, use systemctl commands only

- Remove zbus dependency from agent - Replace D-Bus Connection calls with systemctl show commands - Fix agent hang by eliminating blocking D-Bus operations - get_unit_property now uses systemctl show with property flags - Memory, disk usage, and nginx config queries use systemctl - Simpler, more reliable service monitoring
Fix agent hang by reverting service discovery to systemctl
2025-11-28 12:15:04 +01:00 · 2025-11-28 11:57:31 +01:00 · 2025-11-28 11:46:28 +01:00 · 2025-11-28 11:27:33 +01:00 · 2025-11-27 23:16:40 +01:00 · 2025-11-27 23:12:08 +01:00
34 changed files with 2457 additions and 2415 deletions
--- a/.gitea/workflows/release.yml
+++ b/.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/services/cm-dashboard.nix
-          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/services/cm-dashboard.nix
-          
+          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" services/cm-dashboard.nix
+          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" 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/services/cm-dashboard.nix
+          git add services/cm-dashboard.nix
          git commit -m "Auto-update cm-dashboard to $VERSION

          - Update version to $VERSION with automated release
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -156,6 +156,56 @@ Complete migration from string-based metrics to structured JSON data. Eliminates
 - ✅ Backward compatibility via bridge conversion to existing UI widgets
 - ✅ All string parsing bugs eliminated

+### Cached Collector Architecture (🚧 PLANNED)
+
+**Problem:** Blocking collectors prevent timely ZMQ transmission, causing false "host offline" alerts.
+
+**Previous (Sequential Blocking):**
+```
+Every 1 second:
+  └─ collect_all_data() [BLOCKS for 2-10+ seconds]
+      ├─ CPU (fast: 10ms)
+      ├─ Memory (fast: 20ms)
+      ├─ Disk SMART (slow: 3s per drive × 4 drives = 12s)
+      ├─ Service disk usage (slow: 2-8s per service)
+      └─ Docker (medium: 500ms)
+  └─ send_via_zmq()  [Only after ALL collection completes]
+
+Result: If any collector takes >10s → "host offline" false alert
+```
+
+**New (Cached Independent Collectors):**
+```
+Shared Cache: Arc<RwLock<AgentData>>
+
+Background Collectors (independent async tasks):
+├─ Fast collectors (CPU, RAM, Network)
+│   └─ Update cache every 1 second
+├─ Medium collectors (Services, Docker)
+│   └─ Update cache every 5 seconds
+└─ Slow collectors (Disk usage, SMART data)
+    └─ Update cache every 60 seconds
+
+ZMQ Sender (separate async task):
+Every 1 second:
+  └─ Read current cache
+  └─ Send via ZMQ [Always instant, never blocked]
+```
+
+**Benefits:**
+- ✅ ZMQ sends every 1 second regardless of collector speed
+- ✅ No false "host offline" alerts from slow collectors
+- ✅ Different update rates for different metrics (CPU=1s, SMART=60s)
+- ✅ System stays responsive even with slow operations
+- ✅ Slow collectors can use longer timeouts without blocking
+
+**Implementation:**
+- Shared `AgentData` cache wrapped in `Arc<RwLock<>>`
+- Each collector spawned as independent tokio task
+- Collectors update their section of cache at their own rate
+- ZMQ sender reads cache every 1s and transmits
+- Stale data acceptable for slow-changing metrics (disk usage, SMART)
+
 ### Maintenance Mode

 - Agent checks for `/tmp/cm-maintenance` file before sending notifications
@@ -304,27 +354,33 @@ exclude_fs_types = ["tmpfs", "devtmpfs", "sysfs", "proc"]
 ### Display Format

 ```
+Network:
+● eno1:
+  ├─ ip: 192.168.30.105
+  └─ tailscale0: 100.125.108.16
+● eno2:
+  └─ ip: 192.168.32.105
 CPU:
 ● Load: 0.23 0.21 0.13
  └─ Freq: 1048 MHz
-
 RAM:
 ● Usage: 25% 5.8GB/23.3GB
  ├─ ● /tmp: 2% 0.5GB/2GB
  └─ ● /var/tmp: 0% 0GB/1.0GB
-
 Storage:
-● mergerfs (2+1):
-  ├─ Total: ● 63% 2355.2GB/3686.4GB
-  ├─ Data Disks:
-  │  ├─ ● sdb T: 24°C W: 5%
-  │  └─ ● sdd T: 27°C W: 5%
-  ├─ Parity: ● sdc T: 24°C W: 5%
-  └─ Mount: /srv/media
-
-● nvme0n1 T: 25C W: 4%
+● 844B9A25 T: 25C W: 4%
  ├─ ● /: 55% 250.5GB/456.4GB
  └─ ● /boot: 26% 0.3GB/1.0GB
+● mergerfs /srv/media:
+  ├─ ● 63% 2355.2GB/3686.4GB
+  ├─ ● Data_1: WDZQ8H8D T: 28°C
+  ├─ ● Data_2: GGA04461 T: 28°C
+  └─ ● Parity: WDZS8RY0 T: 29°C
+Backup:
+● WD-WCC7K1234567 T: 32°C W: 12%
+  ├─ Last: 2h ago (12.3GB)
+  ├─ Next: in 22h
+  └─ ● Usage: 45% 678GB/1.5TB
 ```

 ## Important Communication Guidelines
@@ -355,98 +411,6 @@ Keep responses concise and focused. Avoid extensive implementation summaries unl
 - ✅ "Restructure storage widget with improved layout"
 - ✅ "Update CPU thresholds to production values"

-## Completed Architecture Migration (v0.1.131)
-
-## ✅ COMPLETE MONITORING SYSTEM RESTORATION (v0.1.141)
-
-**🎉 SUCCESS: All Issues Fixed - Complete Functional Monitoring System**
-
-### ✅ Completed Implementation (v0.1.141)
-
-**All Major Issues Resolved:**
-```
-✅ Data Collection: Agent collects structured data correctly
-✅ Storage Display: Perfect format with correct mount points and temperature/wear
-✅ Status Evaluation: All metrics properly evaluated against thresholds  
-✅ Notifications: Working email alerts on status changes
-✅ Thresholds: All collectors using configured thresholds for status calculation
-✅ Build Information: NixOS version displayed correctly
-✅ Mount Point Consistency: Stable, sorted display order
-```
-
-### ✅ All Phases Completed Successfully
-
-#### ✅ Phase 1: Storage Display - COMPLETED
- ✅ Use `lsblk` instead of `findmnt` (eliminated `/nix/store` bind mount issue)
- ✅ Add `sudo smartctl` for permissions (SMART data collection working)
- ✅ Fix NVMe SMART parsing (`Temperature:` and `Percentage Used:` fields)
- ✅ Consistent filesystem/tmpfs sorting (no more random order swapping)
- ✅ **VERIFIED**: Dashboard shows `● nvme0n1 T: 28°C W: 1%` correctly
-
-#### ✅ Phase 2: Status Evaluation System - COMPLETED
- ✅ **CPU Status**: Load averages and temperature evaluated against `HysteresisThresholds`
- ✅ **Memory Status**: Usage percentage evaluated against thresholds
- ✅ **Storage Status**: Drive temperature, health, and filesystem usage evaluated
- ✅ **Service Status**: Service states properly tracked and evaluated
- ✅ **Status Fields**: All AgentData structures include status information
- ✅ **Threshold Integration**: All collectors use their configured thresholds
-
-#### ✅ Phase 3: Notification System - COMPLETED  
- ✅ **Status Change Detection**: Agent tracks status between collection cycles
- ✅ **Email Notifications**: Alerts sent on degradation (OK→Warning/Critical, Warning→Critical)
- ✅ **Notification Content**: Detailed alerts with metric values and timestamps
- ✅ **NotificationManager Integration**: Fully restored and operational
- ✅ **Maintenance Mode**: `/tmp/cm-maintenance` file support maintained
-
-#### ✅ Phase 4: Integration & Testing - COMPLETED
- ✅ **AgentData Status Fields**: All structured data includes status evaluation
- ✅ **Status Processing**: Agent applies thresholds at collection time
- ✅ **End-to-End Flow**: Collection → Evaluation → Notification → Display
- ✅ **Dynamic Versioning**: Agent version from `CARGO_PKG_VERSION` 
- ✅ **Build Information**: NixOS generation display restored
-
-### ✅ Final Architecture - WORKING
-
-**Complete Operational Flow:**
-```
-Collectors → AgentData (with Status) → NotificationManager → Email Alerts
-                                    ↘                        ↗  
-                                     ZMQ → Dashboard → Perfect Display
-```
-
-**Operational Components:**
-1. ✅ **Collectors**: Populate AgentData with metrics AND status evaluation
-2. ✅ **Status Evaluation**: `HysteresisThresholds.evaluate()` applied per collector
-3. ✅ **Notifications**: Email alerts on status change detection
-4. ✅ **Display**: Correct mount points, temperature, wear, and build information
-
-### ✅ Success Criteria - ALL MET
-
-**Display Requirements:**
- ✅ Dashboard shows `● nvme0n1 T: 28°C W: 1%` format perfectly
- ✅ Mount points show `/` and `/boot` (not `root`/`boot`)
- ✅ Build information shows actual NixOS version (not "unknown")
- ✅ Consistent sorting eliminates random order changes
-
-**Monitoring Requirements:**  
- ✅ High CPU load triggers Warning/Critical status and email alert
- ✅ High memory usage triggers Warning/Critical status and email alert
- ✅ High disk temperature triggers Warning/Critical status and email alert
- ✅ Failed services trigger Warning/Critical status and email alert
- ✅ Maintenance mode suppresses notifications as expected
-
-### 🚀 Production Ready
-
-**CM Dashboard v0.1.141 is a complete, functional infrastructure monitoring system:**
-
- **Real-time Monitoring**: All system components with 1-second intervals
- **Intelligent Alerting**: Email notifications on threshold violations
- **Perfect Display**: Accurate mount points, temperatures, and system information
- **Status-Aware**: All metrics evaluated against configurable thresholds
- **Production Ready**: Full monitoring capabilities restored
-
-**The monitoring system is fully operational and ready for production use.**
-
 ## Implementation Rules

 1. **Agent Status Authority**: Agent calculates status for each metric using thresholds
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,5 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-# This file is automatically generated by Cargo.
 version = 4

 [[package]]
@@ -115,6 +114,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -145,12 +150,62 @@ version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"

+[[package]]
+name = "bollard"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d41711ad46fda47cd701f6908e59d1bd6b9a2b7464c0d0aeab95c6d37096ff8a"
+dependencies = [
+ "base64 0.22.1",
+ "bollard-stubs",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "hex",
+ "http 1.4.0",
+ "http-body-util",
+ "hyper 1.8.1",
+ "hyper-named-pipe",
+ "hyper-util",
+ "hyperlocal",
+ "log",
+ "pin-project-lite",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_repr",
+ "serde_urlencoded",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "winapi",
+]
+
+[[package]]
+name = "bollard-stubs"
+version = "1.45.0-rc.26.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d7c5415e3a6bc6d3e99eff6268e488fd4ee25e7b28c10f08fa6760bd9de16e4"
+dependencies = [
+ "serde",
+ "serde_repr",
+ "serde_with",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"

+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "bytes"
 version = "1.11.0"
@@ -165,9 +220,9 @@ checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"

 [[package]]
 name = "cc"
-version = "1.2.46"
+version = "1.2.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97463e1064cb1b1c1384ad0a0b9c8abd0988e2a91f52606c80ef14aadb63e36"
+checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
 dependencies = [
 "find-msvc-tools",
 "jobserver",
@@ -191,6 +246,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"

+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chrono"
 version = "0.4.42"
@@ -239,9 +300,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.5.52"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa8120877db0e5c011242f96806ce3c94e0737ab8108532a76a3300a01db2ab8"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -249,9 +310,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.52"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02576b399397b659c26064fbc92a75fede9d18ffd5f80ca1cd74ddab167016e1"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
 "anstream",
 "anstyle",
@@ -279,7 +340,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"

 [[package]]
 name = "cm-dashboard"
-version = "0.1.146"
+version = "0.1.200"
 dependencies = [
 "anyhow",
 "chrono",
@@ -290,7 +351,7 @@ dependencies = [
 "ratatui",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 "tokio",
 "toml",
 "tracing",
@@ -301,20 +362,26 @@ dependencies = [

 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.146"
+version = "0.1.200"
 dependencies = [
 "anyhow",
 "async-trait",
+ "bollard",
 "chrono",
 "chrono-tz",
 "clap",
 "cm-dashboard-shared",
+ "futures",
 "gethostname",
 "lettre",
+ "libc",
+ "netlink-packet-route",
+ "nix 0.29.0",
 "reqwest",
+ "rtnetlink",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 "tokio",
 "toml",
 "tracing",
@@ -324,12 +391,12 @@ dependencies = [

 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.146"
+version = "0.1.200"
 dependencies = [
 "chrono",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]

 [[package]]
@@ -435,6 +502,16 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "deranged"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
 [[package]]
 name = "dircpy"
 version = "0.3.19"
@@ -457,6 +534,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -552,6 +635,21 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -559,6 +657,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
 "futures-core",
+ "futures-sink",
 ]

 [[package]]
@@ -567,12 +666,34 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"

+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"

+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "futures-sink"
 version = "0.3.31"
@@ -591,8 +712,11 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
+ "futures-channel",
 "futures-core",
 "futures-io",
+ "futures-macro",
+ "futures-sink",
 "futures-task",
 "memchr",
 "pin-project-lite",
@@ -633,14 +757,20 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "futures-util",
- "http",
- "indexmap",
+ "http 0.2.12",
+ "indexmap 2.12.1",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -664,9 +794,9 @@ dependencies = [

 [[package]]
 name = "hashbrown"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

 [[package]]
 name = "heck"
@@ -680,6 +810,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "http"
 version = "0.2.12"
@@ -691,6 +827,16 @@ dependencies = [
 "itoa",
 ]

+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
 [[package]]
 name = "http-body"
 version = "0.4.6"
@@ -698,7 +844,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
 "bytes",
- "http",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http 1.4.0",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http 1.4.0",
+ "http-body 1.0.1",
 "pin-project-lite",
 ]

@@ -725,8 +894,8 @@ dependencies = [
 "futures-core",
 "futures-util",
 "h2",
- "http",
- "http-body",
+ "http 0.2.12",
+ "http-body 0.4.6",
 "httparse",
 "httpdate",
 "itoa",
@@ -738,6 +907,43 @@ dependencies = [
 "want",
 ]

+[[package]]
+name = "hyper"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-named-pipe"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b7d8abf35697b81a825e386fc151e0d503e8cb5fcb93cc8669c376dfd6f278"
+dependencies = [
+ "hex",
+ "hyper 1.8.1",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+ "winapi",
+]
+
 [[package]]
 name = "hyper-tls"
 version = "0.5.0"
@@ -745,12 +951,48 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 dependencies = [
 "bytes",
- "hyper",
+ "hyper 0.14.32",
 "native-tls",
 "tokio",
 "tokio-native-tls",
 ]

+[[package]]
+name = "hyper-util"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "hyper 1.8.1",
+ "libc",
+ "pin-project-lite",
+ "socket2 0.6.1",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "hyperlocal"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "986c5ce3b994526b3cd75578e62554abd09f0899d6206de48b3e96ab34ccc8c7"
+dependencies = [
+ "hex",
+ "http-body-util",
+ "hyper 1.8.1",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.64"
@@ -879,12 +1121,25 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.12.0"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
 "equivalent",
- "hashbrown 0.16.0",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
 ]

 [[package]]
@@ -1084,6 +1339,93 @@ dependencies = [
 "tempfile",
 ]

+[[package]]
+name = "netlink-packet-core"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72724faf704479d67b388da142b186f916188505e7e0b26719019c525882eda4"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74c171cd77b4ee8c7708da746ce392440cb7bcf618d122ec9ecc607b12938bf4"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "libc",
+ "log",
+ "netlink-packet-core",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-utils"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ede8a08c71ad5a95cdd0e4e52facd37190977039a4704eb82a283f713747d34"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "paste",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "netlink-proto"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72452e012c2f8d612410d89eea01e2d9b56205274abb35d53f60200b2ec41d60"
+dependencies = [
+ "bytes",
+ "futures",
+ "log",
+ "netlink-packet-core",
+ "netlink-sys",
+ "thiserror 2.0.17",
+]
+
+[[package]]
+name = "netlink-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16c903aa70590cb93691bf97a767c8d1d6122d2cc9070433deb3bbf36ce8bd23"
+dependencies = [
+ "bytes",
+ "futures",
+ "libc",
+ "log",
+ "tokio",
+]
+
+[[package]]
+name = "nix"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
+dependencies = [
+ "bitflags 2.10.0",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.10.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "nom"
 version = "8.0.0"
@@ -1102,6 +1444,12 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1285,6 +1633,12 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.103"
@@ -1387,6 +1741,26 @@ dependencies = [
 "bitflags 2.10.0",
 ]

+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "regex"
 version = "1.12.2"
@@ -1428,9 +1802,9 @@ dependencies = [
 "futures-core",
 "futures-util",
 "h2",
- "http",
- "http-body",
- "hyper",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "hyper 0.14.32",
 "hyper-tls",
 "ipnet",
 "js-sys",
@@ -1456,6 +1830,24 @@ dependencies = [
 "winreg",
 ]

+[[package]]
+name = "rtnetlink"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b684475344d8df1859ddb2d395dd3dac4f8f3422a1aa0725993cb375fc5caba5"
+dependencies = [
+ "futures",
+ "log",
+ "netlink-packet-core",
+ "netlink-packet-route",
+ "netlink-packet-utils",
+ "netlink-proto",
+ "netlink-sys",
+ "nix 0.27.1",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
 [[package]]
 name = "rustix"
 version = "1.1.2"
@@ -1508,6 +1900,30 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9558e172d4e8533736ba97870c4b2cd63f84b382a3d6eb063da41b91cce17289"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -1580,6 +1996,17 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "0.6.9"
@@ -1601,6 +2028,24 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "serde_with"
+version = "3.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.12.1",
+ "schemars 0.9.0",
+ "schemars 1.1.0",
+ "serde_core",
+ "serde_json",
+ "time",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -1639,9 +2084,9 @@ dependencies = [

 [[package]]
 name = "signal-hook-registry"
-version = "1.4.6"
+version = "1.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
 dependencies = [
 "libc",
 ]
@@ -1733,9 +2178,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.110"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1818,7 +2263,16 @@ version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
 ]

 [[package]]
@@ -1832,6 +2286,17 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "thread_local"
 version = "1.1.9"
@@ -1841,6 +2306,37 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "time-macros"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.2"
@@ -1929,7 +2425,7 @@ version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap",
+ "indexmap 2.12.1",
 "serde",
 "serde_spanned",
 "toml_datetime",
@@ -1962,9 +2458,9 @@ dependencies = [

 [[package]]
 name = "tracing-attributes"
-version = "0.1.30"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1973,9 +2469,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.34"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
 dependencies = [
 "once_cell",
 "valuable",
@@ -2513,9 +3009,9 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"

 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 dependencies = [
 "memchr",
 ]
@@ -2567,18 +3063,18 @@ dependencies = [

 [[package]]
 name = "zerocopy"
-version = "0.8.27"
+version = "0.8.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c"
 dependencies = [
 "zerocopy-derive",
 ]

 [[package]]
 name = "zerocopy-derive"
-version = "0.8.27"
+version = "0.8.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/agent/Cargo.toml
+++ b/agent/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.147"
+version = "0.1.200"
 edition = "2021"

 [dependencies]
@@ -20,4 +20,14 @@ gethostname = { workspace = true }
 chrono-tz = "0.8"
 toml = { workspace = true }
 async-trait = "0.1"
-reqwest = { version = "0.11", features = ["json", "blocking"] }
+reqwest = { version = "0.11", features = ["json", "blocking"] }
+
+# Native system APIs
+nix = { version = "0.29", features = ["fs"] }
+rtnetlink = "0.14"
+netlink-packet-route = "0.19"
+futures = "0.3"
+libc = "0.2"
+
+# Docker API client
+bollard = "0.17"
--- a/agent/src/agent.rs
+++ b/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, ZmqHandler};
+use crate::communication::ZmqHandler;
 use crate::config::AgentConfig;
 use crate::collectors::{
    Collector,
@@ -12,11 +12,11 @@ use crate::collectors::{
    cpu::CpuCollector,
    disk::DiskCollector,
    memory::MemoryCollector,
+    network::NetworkCollector,
    nixos::NixOSCollector,
    systemd::SystemdCollector,
 };
 use crate::notifications::NotificationManager;
-use crate::service_tracker::UserStoppedServiceTracker;
 use cm_dashboard_shared::AgentData;

 pub struct Agent {
@@ -25,7 +25,6 @@ pub struct Agent {
    zmq_handler: ZmqHandler,
    collectors: Vec<Box<dyn Collector>>,
    notification_manager: NotificationManager,
-    service_tracker: UserStoppedServiceTracker,
    previous_status: Option<SystemStatus>,
 }

@@ -79,7 +78,11 @@ impl Agent {
        if config.collectors.backup.enabled {
            collectors.push(Box::new(BackupCollector::new()));
        }
-        
+
+        if config.collectors.network.enabled {
+            collectors.push(Box::new(NetworkCollector::new(config.collectors.network.clone())));
+        }
+
        if config.collectors.nixos.enabled {
            collectors.push(Box::new(NixOSCollector::new(config.collectors.nixos.clone())));
        }
@@ -90,17 +93,12 @@ impl Agent {
        let notification_manager = NotificationManager::new(&config.notifications, &hostname)?;
        info!("Notification manager initialized");

-        // Initialize service tracker
-        let service_tracker = UserStoppedServiceTracker::new();
-        info!("Service tracker initialized");
-
        Ok(Self {
            hostname,
            config,
            zmq_handler,
            collectors,
            notification_manager,
-            service_tracker,
            previous_status: None,
        })
    }
@@ -136,12 +134,6 @@ impl Agent {
                    // NOTE: With structured data, we might need to implement status tracking differently
                    // For now, we skip this until status evaluation is migrated
                }
-                // Handle incoming commands (check periodically)
-                _ = tokio::time::sleep(Duration::from_millis(100)) => {
-                    if let Err(e) = self.handle_commands().await {
-                        error!("Error handling commands: {}", e);
-                    }
-                }
                _ = &mut shutdown_rx => {
                    info!("Shutdown signal received, stopping agent loop");
                    break;
@@ -261,36 +253,4 @@ impl Agent {
        Ok(())
    }

-    /// Handle incoming commands from dashboard
-    async fn handle_commands(&mut self) -> Result<()> {
-        // Try to receive a command (non-blocking)
-        if let Ok(Some(command)) = self.zmq_handler.try_receive_command() {
-            info!("Received command: {:?}", command);
-
-            match command {
-                AgentCommand::CollectNow => {
-                    info!("Received immediate collection request");
-                    if let Err(e) = self.collect_and_broadcast().await {
-                        error!("Failed to collect on demand: {}", e);
-                    }
-                }
-                AgentCommand::SetInterval { seconds } => {
-                    info!("Received interval change request: {}s", seconds);
-                    // Note: This would require more complex handling to update the interval
-                    // For now, just acknowledge
-                }
-                AgentCommand::ToggleCollector { name, enabled } => {
-                    info!("Received collector toggle request: {} -> {}", name, enabled);
-                    // Note: This would require more complex handling to enable/disable collectors
-                    // For now, just acknowledge
-                }
-                AgentCommand::Ping => {
-                    info!("Received ping command");
-                    // Maybe send back a pong or status
-                }
-            }
-        }
-        Ok(())
-    }
-
 }
--- a/agent/src/collectors/backup.rs
+++ b/agent/src/collectors/backup.rs
@@ -1,13 +1,14 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, BackupData};
+use cm_dashboard_shared::{AgentData, BackupData, BackupDiskData};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
 use tracing::debug;

 use super::{Collector, CollectorError};

-/// Backup collector that reads backup status from JSON files with structured data output
+/// Backup collector that reads backup status from TOML files with structured data output
 pub struct BackupCollector {
    /// Path to backup status file
    status_file_path: String,
@@ -16,12 +17,12 @@ pub struct BackupCollector {
 impl BackupCollector {
    pub fn new() -> Self {
        Self {
-            status_file_path: "/var/lib/backup/status.json".to_string(),
+            status_file_path: "/var/lib/backup/backup-status.toml".to_string(),
        }
    }

-    /// Read backup status from JSON file
-    async fn read_backup_status(&self) -> Result<Option<BackupStatus>, CollectorError> {
+    /// Read backup status from TOML file
+    async fn read_backup_status(&self) -> Result<Option<BackupStatusToml>, CollectorError> {
        if !Path::new(&self.status_file_path).exists() {
            debug!("Backup status file not found: {}", self.status_file_path);
            return Ok(None);
@@ -33,24 +34,57 @@ impl BackupCollector {
                error: e.to_string(),
            })?;

-        let status: BackupStatus = serde_json::from_str(&content)
+        let status: BackupStatusToml = toml::from_str(&content)
            .map_err(|e| CollectorError::Parse {
                value: content.clone(),
-                error: format!("Failed to parse backup status JSON: {}", e),
+                error: format!("Failed to parse backup status TOML: {}", e),
            })?;

        Ok(Some(status))
    }

-    /// Convert BackupStatus to BackupData and populate AgentData
+    /// Convert BackupStatusToml to BackupData and populate AgentData
    async fn populate_backup_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
        if let Some(backup_status) = self.read_backup_status().await? {
+            // Use raw start_time string from TOML
+
+            // Extract disk information
+            let repository_disk = if let Some(disk_space) = &backup_status.disk_space {
+                Some(BackupDiskData {
+                    serial: backup_status.disk_serial_number.clone().unwrap_or_else(|| "Unknown".to_string()),
+                    usage_percent: disk_space.usage_percent as f32,
+                    used_gb: disk_space.used_gb as f32,
+                    total_gb: disk_space.total_gb as f32,
+                    wear_percent: backup_status.disk_wear_percent,
+                    temperature_celsius: None, // Not available in current TOML
+                })
+            } else if let Some(serial) = &backup_status.disk_serial_number {
+                // Fallback: create minimal disk info if we have serial but no disk_space
+                Some(BackupDiskData {
+                    serial: serial.clone(),
+                    usage_percent: 0.0,
+                    used_gb: 0.0,
+                    total_gb: 0.0,
+                    wear_percent: backup_status.disk_wear_percent,
+                    temperature_celsius: None,
+                })
+            } else {
+                None
+            };
+
+            // Calculate total repository size from services
+            let total_size_gb = backup_status.services
+                .values()
+                .map(|service| service.repo_size_bytes as f32 / (1024.0 * 1024.0 * 1024.0))
+                .sum::<f32>();
+
            let backup_data = BackupData {
                status: backup_status.status,
-                last_run: Some(backup_status.last_run),
-                next_scheduled: Some(backup_status.next_scheduled),
-                total_size_gb: Some(backup_status.total_size_gb),
-                repository_health: Some(backup_status.repository_health),
+                total_size_gb: Some(total_size_gb),
+                repository_health: Some("ok".to_string()), // Derive from status if needed
+                repository_disk,
+                last_backup_size_gb: None, // Not available in current TOML format
+                start_time_raw: Some(backup_status.start_time),
            };

            agent_data.backup = backup_data;
@@ -58,10 +92,11 @@ impl BackupCollector {
            // No backup status available - set default values
            agent_data.backup = BackupData {
                status: "unavailable".to_string(),
-                last_run: None,
-                next_scheduled: None,
                total_size_gb: None,
                repository_health: None,
+                repository_disk: None,
+                last_backup_size_gb: None,
+                start_time_raw: None,
            };
        }

@@ -77,12 +112,38 @@ impl Collector for BackupCollector {
    }
 }

-/// Backup status structure from JSON file
+/// TOML structure for backup status file
 #[derive(Debug, Clone, Serialize, Deserialize)]
-struct BackupStatus {
-    pub status: String,            // "completed", "running", "failed", etc.
-    pub last_run: u64,            // Unix timestamp
-    pub next_scheduled: u64,      // Unix timestamp  
-    pub total_size_gb: f32,       // Total backup size in GB
-    pub repository_health: String, // "ok", "warning", "error"
+struct BackupStatusToml {
+    pub backup_name: String,
+    pub start_time: String,
+    pub current_time: String,
+    pub duration_seconds: i64,
+    pub status: String,
+    pub last_updated: String,
+    pub disk_space: Option<DiskSpace>,
+    pub disk_product_name: Option<String>,
+    pub disk_serial_number: Option<String>,
+    pub disk_wear_percent: Option<f32>,
+    pub services: HashMap<String, ServiceStatus>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct DiskSpace {
+    pub total_bytes: u64,
+    pub used_bytes: u64,
+    pub available_bytes: u64,
+    pub total_gb: f64,
+    pub used_gb: f64,
+    pub available_gb: f64,
+    pub usage_percent: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ServiceStatus {
+    pub status: String,
+    pub exit_code: i64,
+    pub repo_path: String,
+    pub archive_count: i64,
+    pub repo_size_bytes: u64,
 }
--- a/agent/src/collectors/cpu.rs
+++ b/agent/src/collectors/cpu.rs
@@ -1,22 +1,25 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, Status, HysteresisThresholds};
+use cm_dashboard_shared::{AgentData, Status, HysteresisThresholds, CpuData};
+use std::sync::RwLock;
+use std::time::Instant;

 use tracing::debug;

 use super::{utils, Collector, CollectorError};
 use crate::config::CpuConfig;

-/// Extremely efficient CPU metrics collector
-///
-/// EFFICIENCY OPTIMIZATIONS:
-/// - Single /proc/loadavg read for all load metrics
-/// - Single /proc/stat read for CPU usage
-/// - Minimal string allocations
-/// - No process spawning
-/// - <0.1ms collection time target
+/// Extremely efficient CPU metrics collector with interval-based caching
 pub struct CpuCollector {
    load_thresholds: HysteresisThresholds,
    temperature_thresholds: HysteresisThresholds,
+    config: CpuConfig,
+    state: RwLock<CpuCacheState>,
+}
+
+#[derive(Debug, Clone)]
+struct CpuCacheState {
+    last_collection: Option<Instant>,
+    cached_data: CpuData,
 }

 impl CpuCollector {
@@ -26,15 +29,39 @@ impl CpuCollector {
            config.load_warning_threshold,
            config.load_critical_threshold,
        );
-        
+
        let temperature_thresholds = HysteresisThresholds::new(
            config.temperature_warning_threshold,
            config.temperature_critical_threshold,
        );
-        
+
        Self {
            load_thresholds,
            temperature_thresholds,
+            config,
+            state: RwLock::new(CpuCacheState {
+                last_collection: None,
+                cached_data: CpuData {
+                    load_1min: 0.0,
+                    load_5min: 0.0,
+                    load_15min: 0.0,
+                    frequency_mhz: 0.0,
+                    temperature_celsius: None,
+                    load_status: Status::Unknown,
+                    temperature_status: Status::Unknown,
+                },
+            }),
+        }
+    }
+
+    fn should_update_cache(&self) -> bool {
+        let state = self.state.read().unwrap();
+        match state.last_collection {
+            None => true,
+            Some(last) => {
+                let cache_duration = std::time::Duration::from_secs(self.config.interval_seconds);
+                last.elapsed() > cache_duration
+            }
        }
    }

@@ -156,6 +183,14 @@ impl CpuCollector {
 #[async_trait]
 impl Collector for CpuCollector {
    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+        // Check if cache is valid
+        if !self.should_update_cache() {
+            let state = self.state.read().unwrap();
+            agent_data.system.cpu = state.cached_data.clone();
+            debug!("Using cached CPU data (interval: {}s)", self.config.interval_seconds);
+            return Ok(());
+        }
+
        debug!("Collecting CPU metrics");
        let start = std::time::Instant::now();

@@ -187,6 +222,11 @@ impl Collector for CpuCollector {
            Status::Unknown
        };

+        // Update cache
+        let mut state = self.state.write().unwrap();
+        state.last_collection = Some(Instant::now());
+        state.cached_data = agent_data.system.cpu.clone();
+
        Ok(())
    }
 }
--- a/agent/src/collectors/disk.rs
+++ b/agent/src/collectors/disk.rs
@@ -6,6 +6,7 @@ use crate::config::DiskConfig;
 use std::process::Command;
 use std::time::Instant;
 use std::collections::HashMap;
+use std::sync::RwLock;
 use tracing::debug;

 use super::{Collector, CollectorError};
@@ -14,15 +15,26 @@ use super::{Collector, CollectorError};
 pub struct DiskCollector {
    config: DiskConfig,
    temperature_thresholds: HysteresisThresholds,
+    /// Cached state with thread-safe interior mutability
+    state: RwLock<DiskCacheState>,
+}
+
+/// Internal state for disk caching
+#[derive(Debug, Clone)]
+struct DiskCacheState {
+    /// Last collection time for performance tracking
+    last_collection: Option<Instant>,
+    /// Cached drive data
+    cached_drives: Vec<DriveData>,
+    /// Cached pool data
+    cached_pools: Vec<PoolData>,
 }

 /// A physical drive with its filesystems
 #[derive(Debug, Clone)]
 struct PhysicalDrive {
-    name: String,                        // e.g., "nvme0n1", "sda" 
+    name: String,                        // e.g., "nvme0n1", "sda"
    health: String,                      // SMART health status
-    temperature_celsius: Option<f32>,    // Drive temperature
-    wear_percent: Option<f32>,           // SSD wear level
    filesystems: Vec<Filesystem>,        // mounted filesystems on this drive
 }

@@ -50,6 +62,7 @@ struct MergerfsPool {
 #[derive(Debug, Clone)]
 struct PoolDrive {
    name: String,                    // Drive name
+    mount_point: String,             // e.g., "/mnt/disk1"
    temperature_celsius: Option<f32>, // Drive temperature
 }

@@ -59,10 +72,17 @@ impl DiskCollector {
            config.temperature_warning_celsius,
            config.temperature_critical_celsius,
        );
-        
+
+        let state = DiskCacheState {
+            last_collection: None,
+            cached_drives: Vec::new(),
+            cached_pools: Vec::new(),
+        };
+
        Self {
            config,
            temperature_thresholds,
+            state: RwLock::new(state),
        }
    }

@@ -75,11 +95,17 @@ impl DiskCollector {
        let mount_devices = self.get_mount_devices().await?;
        
        // Step 2: Get filesystem usage for each mount point using df
-        let filesystem_usage = self.get_filesystem_usage(&mount_devices).map_err(|e| CollectorError::Parse {
+        let mut filesystem_usage = self.get_filesystem_usage(&mount_devices).map_err(|e| CollectorError::Parse {
            value: "filesystem usage".to_string(),
            error: format!("Failed to get filesystem usage: {}", e),
        })?;
        
+        // Step 2.5: Add MergerFS mount points that weren't in lsblk output
+        self.add_mergerfs_filesystem_usage(&mut filesystem_usage).map_err(|e| CollectorError::Parse {
+            value: "mergerfs filesystem usage".to_string(),
+            error: format!("Failed to get mergerfs filesystem usage: {}", e),
+        })?;
+        
        // Step 3: Detect MergerFS pools
        let mergerfs_pools = self.detect_mergerfs_pools(&filesystem_usage).map_err(|e| CollectorError::Parse {
            value: "mergerfs pools".to_string(),
@@ -99,37 +125,70 @@ impl DiskCollector {
        self.populate_drives_data(&physical_drives, &smart_data, agent_data)?;
        self.populate_pools_data(&mergerfs_pools, &smart_data, agent_data)?;

+        // Step 7: Update cache with fresh data
+        {
+            let mut state = self.state.write().unwrap();
+            state.cached_drives = agent_data.system.storage.drives.clone();
+            state.cached_pools = agent_data.system.storage.pools.clone();
+            state.last_collection = Some(Instant::now());
+        }
+
        let elapsed = start_time.elapsed();
        debug!("Storage collection completed in {:?}", elapsed);

        Ok(())
    }

-    /// Get block devices and their mount points using lsblk
+    /// Check if disk collection cache should be updated
+    fn should_update_cache(&self) -> bool {
+        let state = self.state.read().unwrap();
+
+        match state.last_collection {
+            None => true,
+            Some(last) => {
+                let cache_duration = std::time::Duration::from_secs(self.config.interval_seconds);
+                last.elapsed() > cache_duration
+            }
+        }
+    }
+
+    /// Get cached disk data if available and fresh
+    fn get_cached_data(&self) -> Option<(Vec<DriveData>, Vec<PoolData>)> {
+        if !self.should_update_cache() {
+            let state = self.state.read().unwrap();
+            Some((state.cached_drives.clone(), state.cached_pools.clone()))
+        } else {
+            None
+        }
+    }
+
+    /// Get block devices and their mount points by reading /proc/mounts
    async fn get_mount_devices(&self) -> Result<HashMap<String, String>, CollectorError> {
-        let output = Command::new("lsblk")
-            .args(&["-rn", "-o", "NAME,MOUNTPOINT"])
-            .output()
+        let content = std::fs::read_to_string("/proc/mounts")
            .map_err(|e| CollectorError::SystemRead {
-                path: "block devices".to_string(),
+                path: "/proc/mounts".to_string(),
                error: e.to_string(),
            })?;

        let mut mount_devices = HashMap::new();
-        for line in String::from_utf8_lossy(&output.stdout).lines() {
+
+        for line in content.lines() {
            let parts: Vec<&str> = line.split_whitespace().collect();
-            if parts.len() >= 2 {
-                let device_name = parts[0];
+            if parts.len() >= 3 {
+                let device = parts[0];
                let mount_point = parts[1];
-                
-                // Skip swap partitions and unmounted devices
-                if mount_point == "[SWAP]" || mount_point.is_empty() {
+                let fs_type = parts[2];
+
+                // Skip pseudo filesystems and fuse mounts
+                if fs_type.starts_with("fuse") ||
+                   matches!(fs_type, "proc" | "sysfs" | "tmpfs" | "devtmpfs" |
+                           "devpts" | "cgroup" | "cgroup2" | "pstore" | "bpf" |
+                           "tracefs" | "debugfs" | "securityfs" | "hugetlbfs" |
+                           "mqueue" | "configfs" | "autofs") {
                    continue;
                }
-                
-                // Convert device name to full path
-                let device_path = format!("/dev/{}", device_name);
-                mount_devices.insert(mount_point.to_string(), device_path);
+
+                mount_devices.insert(mount_point.to_string(), device.to_string());
            }
        }

@@ -155,59 +214,123 @@ impl DiskCollector {
        Ok(filesystem_usage)
    }

-    /// Get filesystem info for a single mount point
-    fn get_filesystem_info(&self, mount_point: &str) -> Result<(u64, u64), CollectorError> {
-        let output = Command::new("df")
-            .args(&["--block-size=1", mount_point])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: format!("df {}", mount_point),
-                error: e.to_string(),
-            })?;
-
-        let output_str = String::from_utf8_lossy(&output.stdout);
-        let lines: Vec<&str> = output_str.lines().collect();
+    /// Add filesystem usage for MergerFS mount points that aren't in lsblk
+    fn add_mergerfs_filesystem_usage(&self, filesystem_usage: &mut HashMap<String, (u64, u64)>) -> anyhow::Result<()> {
+        let mounts_content = std::fs::read_to_string("/proc/mounts")
+            .map_err(|e| anyhow::anyhow!("Failed to read /proc/mounts: {}", e))?;
        
-        if lines.len() < 2 {
-            return Err(CollectorError::Parse {
-                value: output_str.to_string(),
-                error: "Expected at least 2 lines from df output".to_string(),
-            });
+        for line in mounts_content.lines() {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() >= 3 && parts[2] == "fuse.mergerfs" {
+                let mount_point = parts[1].to_string();
+                
+                // Only add if we don't already have usage data for this mount point
+                if !filesystem_usage.contains_key(&mount_point) {
+                    if let Ok((total, used)) = self.get_filesystem_info(&mount_point) {
+                        debug!("Added MergerFS filesystem usage for {}: {}GB total, {}GB used", 
+                            mount_point, total as f32 / (1024.0 * 1024.0 * 1024.0), used as f32 / (1024.0 * 1024.0 * 1024.0));
+                        filesystem_usage.insert(mount_point, (total, used));
+                    }
+                }
+            }
        }
+        
+        Ok(())
+    }

-        // Parse the data line (skip header)
-        let parts: Vec<&str> = lines[1].split_whitespace().collect();
-        if parts.len() < 4 {
-            return Err(CollectorError::Parse {
-                value: lines[1].to_string(),
-                error: "Expected at least 4 fields in df output".to_string(),
-            });
-        }
+    /// Get filesystem info for a single mount point using statvfs syscall
+    fn get_filesystem_info(&self, mount_point: &str) -> Result<(u64, u64), CollectorError> {
+        use nix::sys::statvfs::statvfs;

-        let total_bytes: u64 = parts[1].parse().map_err(|e| CollectorError::Parse {
-            value: parts[1].to_string(),
-            error: format!("Failed to parse total bytes: {}", e),
+        let stat = statvfs(mount_point).map_err(|e| CollectorError::SystemRead {
+            path: mount_point.to_string(),
+            error: format!("statvfs failed: {}", e),
        })?;

-        let used_bytes: u64 = parts[2].parse().map_err(|e| CollectorError::Parse {
-            value: parts[2].to_string(),
-            error: format!("Failed to parse used bytes: {}", e),
-        })?;
+        // Calculate total and used bytes
+        let block_size = stat.fragment_size() as u64;
+        let total_bytes = stat.blocks() as u64 * block_size;
+        let available_bytes = stat.blocks_available() as u64 * block_size;
+        let used_bytes = total_bytes - available_bytes;

        Ok((total_bytes, used_bytes))
    }

    /// Detect MergerFS pools from mount data
-    fn detect_mergerfs_pools(&self, _filesystem_usage: &HashMap<String, (u64, u64)>) -> anyhow::Result<Vec<MergerfsPool>> {
-        let pools = Vec::new();
+    fn detect_mergerfs_pools(&self, filesystem_usage: &HashMap<String, (u64, u64)>) -> anyhow::Result<Vec<MergerfsPool>> {
+        let mounts_content = std::fs::read_to_string("/proc/mounts")
+            .map_err(|e| anyhow::anyhow!("Failed to read /proc/mounts: {}", e))?;
+        let mut pools = Vec::new();
        
-        // For now, return empty pools - full mergerfs detection would require parsing /proc/mounts for fuse.mergerfs
-        // This ensures we don't break existing functionality
+        for line in mounts_content.lines() {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() >= 3 && parts[2] == "fuse.mergerfs" {
+                let mount_point = parts[1].to_string();
+                let device_sources = parts[0]; // e.g., "/mnt/disk1:/mnt/disk2"
+                
+                // Get pool usage
+                let (total_bytes, used_bytes) = filesystem_usage.get(&mount_point)
+                    .copied()
+                    .unwrap_or((0, 0));
+                
+                // Extract pool name from mount point (e.g., "/srv/media" -> "srv_media")
+                let pool_name = if mount_point == "/" {
+                    "root".to_string()
+                } else {
+                    mount_point.trim_start_matches('/').replace('/', "_")
+                };
+                
+                if pool_name.is_empty() {
+                    debug!("Skipping mergerfs pool with empty name: {}", mount_point);
+                    continue;
+                }
+                
+                // Parse member paths - handle both full paths and numeric references
+                let raw_paths: Vec<String> = device_sources
+                    .split(':')
+                    .map(|s| s.trim().to_string())
+                    .filter(|s| !s.is_empty())
+                    .collect();
+                
+                // Convert numeric references to actual mount points if needed
+                let member_paths = if raw_paths.iter().any(|path| !path.starts_with('/')) {
+                    // Handle numeric format like "1:2" by finding corresponding /mnt/disk* paths
+                    self.resolve_numeric_mergerfs_paths(&raw_paths)?
+                } else {
+                    // Already full paths
+                    raw_paths
+                };
+                
+                // For SnapRAID setups, include parity drives that are related to this pool's data drives
+                let mut all_member_paths = member_paths.clone();
+                let related_parity_paths = self.discover_related_parity_drives(&member_paths)?;
+                all_member_paths.extend(related_parity_paths);
+                
+                // Categorize as data vs parity drives
+                let (data_drives, parity_drives) = match self.categorize_pool_drives(&all_member_paths) {
+                    Ok(drives) => drives,
+                    Err(e) => {
+                        debug!("Failed to categorize drives for pool {}: {}. Skipping.", mount_point, e);
+                        continue;
+                    }
+                };
+                
+                pools.push(MergerfsPool {
+                    name: pool_name,
+                    mount_point,
+                    total_bytes,
+                    used_bytes,
+                    data_drives,
+                    parity_drives,
+                });
+            }
+        }
        
+        debug!("Found {} mergerfs pools", pools.len());
        Ok(pools)
    }

-    /// Group filesystems by physical drive (excluding mergerfs members)
+    /// Group filesystems by physical drive (excluding mergerfs members) - exact old logic
    fn group_by_physical_drive(
        &self, 
        mount_devices: &HashMap<String, String>,
@@ -216,14 +339,14 @@ impl DiskCollector {
    ) -> anyhow::Result<Vec<PhysicalDrive>> {
        let mut drive_groups: HashMap<String, Vec<Filesystem>> = HashMap::new();
        
-        // Get all mergerfs member paths to exclude them
+        // Get all mergerfs member paths to exclude them - exactly like old code
        let mut mergerfs_members = std::collections::HashSet::new();
        for pool in mergerfs_pools {
            for drive in &pool.data_drives {
-                mergerfs_members.insert(drive.name.clone());
+                mergerfs_members.insert(drive.mount_point.clone());
            }
            for drive in &pool.parity_drives {
-                mergerfs_members.insert(drive.name.clone());
+                mergerfs_members.insert(drive.mount_point.clone());
            }
        }
        
@@ -256,8 +379,6 @@ impl DiskCollector {
            let physical_drive = PhysicalDrive {
                name: drive_name,
                health: "UNKNOWN".to_string(), // Will be updated with SMART data
-                temperature_celsius: None,
-                wear_percent: None,
                filesystems,
            };
            physical_drives.push(physical_drive);
@@ -295,7 +416,7 @@ impl DiskCollector {
    /// Get SMART data for drives
    async fn get_smart_data_for_drives(&self, physical_drives: &[PhysicalDrive], mergerfs_pools: &[MergerfsPool]) -> HashMap<String, SmartData> {
        let mut smart_data = HashMap::new();
-        
+
        // Collect all drive names
        let mut all_drives = std::collections::HashSet::new();
        for drive in physical_drives {
@@ -322,32 +443,37 @@ impl DiskCollector {

    /// Get SMART data for a single drive
    async fn get_smart_data(&self, drive_name: &str) -> Result<SmartData, CollectorError> {
-        let output = Command::new("sudo")
-            .args(&["smartctl", "-a", &format!("/dev/{}", drive_name)])
-            .output()
+        use super::run_command_with_timeout;
+
+        // Use direct smartctl (no sudo) - service has CAP_SYS_RAWIO and CAP_SYS_ADMIN capabilities
+        // For NVMe drives, specify device type explicitly
+        let mut cmd = Command::new("smartctl");
+        if drive_name.starts_with("nvme") {
+            cmd.args(&["-d", "nvme", "-a", &format!("/dev/{}", drive_name)]);
+        } else {
+            cmd.args(&["-a", &format!("/dev/{}", drive_name)]);
+        }
+
+        let output = run_command_with_timeout(cmd, 3).await
            .map_err(|e| CollectorError::SystemRead {
                path: format!("SMART data for {}", drive_name),
                error: e.to_string(),
            })?;

        let output_str = String::from_utf8_lossy(&output.stdout);
-        let error_str = String::from_utf8_lossy(&output.stderr);
-        
-        // Debug logging for SMART command results
-        debug!("SMART output for {}: status={}, stdout_len={}, stderr={}", 
-            drive_name, output.status, output_str.len(), error_str);
-        
+
        if !output.status.success() {
-            debug!("SMART command failed for {}: {}", drive_name, error_str);
            // Return unknown data rather than failing completely
            return Ok(SmartData {
                health: "UNKNOWN".to_string(),
+                serial_number: None,
                temperature_celsius: None,
                wear_percent: None,
            });
        }
        
        let mut health = "UNKNOWN".to_string();
+        let mut serial_number = None;
        let mut temperature = None;
        let mut wear_percent = None;

@@ -360,8 +486,21 @@ impl DiskCollector {
                }
            }
            
+            // Serial number parsing (both SATA and NVMe)
+            if line.contains("Serial Number:") {
+                if let Some(serial_part) = line.split("Serial Number:").nth(1) {
+                    let serial_str = serial_part.trim();
+                    if !serial_str.is_empty() {
+                        // Take first whitespace-separated token
+                        if let Some(serial) = serial_str.split_whitespace().next() {
+                            serial_number = Some(serial.to_string());
+                        }
+                    }
+                }
+            }
+            
            // Temperature parsing for different drive types
-            if line.contains("Temperature_Celsius") || line.contains("Airflow_Temperature_Cel") {
+            if line.contains("Temperature_Celsius") || line.contains("Airflow_Temperature_Cel") || line.contains("Temperature_Case") {
                // Traditional SATA drives: attribute table format
                if let Some(temp_str) = line.split_whitespace().nth(9) {
                    if let Ok(temp) = temp_str.parse::<f32>() {
@@ -379,7 +518,15 @@ impl DiskCollector {
            }
            
            // Wear level parsing for SSDs
-            if line.contains("Wear_Leveling_Count") || line.contains("SSD_Life_Left") {
+            if line.contains("Media_Wearout_Indicator") {
+                // Media_Wearout_Indicator stores remaining life % in column 3 (VALUE)
+                if let Some(wear_str) = line.split_whitespace().nth(3) {
+                    if let Ok(remaining) = wear_str.parse::<f32>() {
+                        wear_percent = Some(100.0 - remaining); // Convert remaining life to wear
+                    }
+                }
+            } else if line.contains("Wear_Leveling_Count") || line.contains("SSD_Life_Left") {
+                // Other wear attributes store value in column 9 (RAW_VALUE)
                if let Some(wear_str) = line.split_whitespace().nth(9) {
                    if let Ok(wear) = wear_str.parse::<f32>() {
                        wear_percent = Some(100.0 - wear); // Convert remaining life to wear
@@ -402,6 +549,7 @@ impl DiskCollector {

        Ok(SmartData {
            health,
+            serial_number,
            temperature_celsius: temperature,
            wear_percent,
        })
@@ -427,6 +575,7 @@ impl DiskCollector {

            agent_data.system.storage.drives.push(DriveData {
                name: drive.name.clone(),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
                health: smart.map(|s| s.health.clone()).unwrap_or_else(|| drive.health.clone()),
                temperature_celsius: smart.and_then(|s| s.temperature_celsius),
                wear_percent: smart.and_then(|s| s.wear_percent),
@@ -444,28 +593,25 @@ impl DiskCollector {
    }

    /// Populate pools data into AgentData
-    fn populate_pools_data(&self, mergerfs_pools: &[MergerfsPool], _smart_data: &HashMap<String, SmartData>, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+    fn populate_pools_data(&self, mergerfs_pools: &[MergerfsPool], smart_data: &HashMap<String, SmartData>, agent_data: &mut AgentData) -> Result<(), CollectorError> {
        for pool in mergerfs_pools {
+            // Calculate pool health and statuses based on member drive health
+            let (pool_health, health_status, usage_status, data_drive_data, parity_drive_data) = self.calculate_pool_health(pool, smart_data);
+            
            let pool_data = PoolData {
                name: pool.name.clone(),
                mount: pool.mount_point.clone(),
-                pool_type: "mergerfs".to_string(),
-                health: "healthy".to_string(), // TODO: Calculate based on member drives
-                usage_percent: (pool.used_bytes as f32 / pool.total_bytes as f32) * 100.0,
+                pool_type: format!("mergerfs ({}+{})", pool.data_drives.len(), pool.parity_drives.len()),
+                health: pool_health,
+                usage_percent: if pool.total_bytes > 0 {
+                    (pool.used_bytes as f32 / pool.total_bytes as f32) * 100.0
+                } else { 0.0 },
                used_gb: pool.used_bytes as f32 / (1024.0 * 1024.0 * 1024.0),
                total_gb: pool.total_bytes as f32 / (1024.0 * 1024.0 * 1024.0),
-                data_drives: pool.data_drives.iter().map(|d| cm_dashboard_shared::PoolDriveData {
-                    name: d.name.clone(),
-                    temperature_celsius: d.temperature_celsius,
-                    health: "unknown".to_string(),
-                    wear_percent: None,
-                }).collect(),
-                parity_drives: pool.parity_drives.iter().map(|d| cm_dashboard_shared::PoolDriveData {
-                    name: d.name.clone(),
-                    temperature_celsius: d.temperature_celsius,
-                    health: "unknown".to_string(),
-                    wear_percent: None,
-                }).collect(),
+                data_drives: data_drive_data,
+                parity_drives: parity_drive_data,
+                health_status,
+                usage_status,
            };

            agent_data.system.storage.pools.push(pool_data);
@@ -474,6 +620,93 @@ impl DiskCollector {
        Ok(())
    }

+    /// Calculate pool health based on member drive status
+    fn calculate_pool_health(&self, pool: &MergerfsPool, smart_data: &HashMap<String, SmartData>) -> (String, cm_dashboard_shared::Status, cm_dashboard_shared::Status, Vec<cm_dashboard_shared::PoolDriveData>, Vec<cm_dashboard_shared::PoolDriveData>) {
+        let mut failed_data = 0;
+        let mut failed_parity = 0;
+        
+        // Process data drives
+        let data_drive_data: Vec<cm_dashboard_shared::PoolDriveData> = pool.data_drives.iter().map(|d| {
+            let smart = smart_data.get(&d.name);
+            let health = smart.map(|s| s.health.clone()).unwrap_or_else(|| "UNKNOWN".to_string());
+            let temperature = smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius);
+            
+            if health == "FAILED" {
+                failed_data += 1;
+            }
+            
+            // Calculate drive statuses using config thresholds
+            let health_status = self.calculate_health_status(&health);
+            let temperature_status = temperature.map(|t| self.temperature_thresholds.evaluate(t)).unwrap_or(cm_dashboard_shared::Status::Unknown);
+            
+            cm_dashboard_shared::PoolDriveData {
+                name: d.name.clone(),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
+                temperature_celsius: temperature,
+                health,
+                wear_percent: smart.and_then(|s| s.wear_percent),
+                health_status,
+                temperature_status,
+            }
+        }).collect();
+        
+        // Process parity drives
+        let parity_drive_data: Vec<cm_dashboard_shared::PoolDriveData> = pool.parity_drives.iter().map(|d| {
+            let smart = smart_data.get(&d.name);
+            let health = smart.map(|s| s.health.clone()).unwrap_or_else(|| "UNKNOWN".to_string());
+            let temperature = smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius);
+            
+            if health == "FAILED" {
+                failed_parity += 1;
+            }
+            
+            // Calculate drive statuses using config thresholds
+            let health_status = self.calculate_health_status(&health);
+            let temperature_status = temperature.map(|t| self.temperature_thresholds.evaluate(t)).unwrap_or(cm_dashboard_shared::Status::Unknown);
+            
+            cm_dashboard_shared::PoolDriveData {
+                name: d.name.clone(),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
+                temperature_celsius: temperature,
+                health,
+                wear_percent: smart.and_then(|s| s.wear_percent),
+                health_status,
+                temperature_status,
+            }
+        }).collect();
+        
+        // Calculate overall pool health string and status
+        // SnapRAID logic: can tolerate up to N parity drive failures (where N = number of parity drives)
+        // If data drives fail AND we've lost parity protection, that's critical
+        let (pool_health, health_status) = if failed_data == 0 && failed_parity == 0 {
+            ("healthy".to_string(), cm_dashboard_shared::Status::Ok)
+        } else if failed_data == 0 && failed_parity > 0 {
+            // Parity failed but no data loss - degraded (reduced protection)
+            ("degraded".to_string(), cm_dashboard_shared::Status::Warning)
+        } else if failed_data == 1 && failed_parity == 0 {
+            // One data drive failed, parity intact - degraded (recoverable)
+            ("degraded".to_string(), cm_dashboard_shared::Status::Warning)
+        } else {
+            // Multiple data drives failed OR data+parity failed = data loss risk
+            ("critical".to_string(), cm_dashboard_shared::Status::Critical)
+        };
+        
+        // Calculate pool usage status using config thresholds
+        let usage_percent = if pool.total_bytes > 0 {
+            (pool.used_bytes as f32 / pool.total_bytes as f32) * 100.0
+        } else { 0.0 };
+        
+        let usage_status = if usage_percent >= self.config.usage_critical_percent {
+            cm_dashboard_shared::Status::Critical
+        } else if usage_percent >= self.config.usage_warning_percent {
+            cm_dashboard_shared::Status::Warning
+        } else {
+            cm_dashboard_shared::Status::Ok
+        };
+        
+        (pool_health, health_status, usage_status, data_drive_data, parity_drive_data)
+    }
+
    /// Calculate filesystem usage status
    fn calculate_filesystem_usage_status(&self, usage_percent: f32) -> Status {
        // Use standard filesystem warning/critical thresholds
@@ -499,12 +732,145 @@ impl DiskCollector {
            _ => Status::Unknown,
        }
    }
+
+    /// Discover parity drives that are related to the given data drives
+    fn discover_related_parity_drives(&self, data_drives: &[String]) -> anyhow::Result<Vec<String>> {
+        let mount_devices = tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(self.get_mount_devices())
+        }).map_err(|e| anyhow::anyhow!("Failed to get mount devices: {}", e))?;
+        
+        let mut related_parity = Vec::new();
+        
+        // Find parity drives that share the same parent directory as the data drives
+        for data_path in data_drives {
+            if let Some(parent_dir) = self.get_parent_directory(data_path) {
+                // Look for parity drives in the same parent directory
+                for (mount_point, _device) in &mount_devices {
+                    if mount_point.contains("parity") && mount_point.starts_with(&parent_dir) {
+                        if !related_parity.contains(mount_point) {
+                            related_parity.push(mount_point.clone());
+                        }
+                    }
+                }
+            }
+        }
+        
+        Ok(related_parity)
+    }
+    
+    /// Get parent directory of a mount path (e.g., "/mnt/disk1" -> "/mnt")
+    fn get_parent_directory(&self, path: &str) -> Option<String> {
+        if let Some(last_slash) = path.rfind('/') {
+            if last_slash > 0 {
+                return Some(path[..last_slash].to_string());
+            }
+        }
+        None
+    }
+
+    /// Categorize pool member drives as data vs parity
+    fn categorize_pool_drives(&self, member_paths: &[String]) -> anyhow::Result<(Vec<PoolDrive>, Vec<PoolDrive>)> {
+        let mut data_drives = Vec::new();
+        let mut parity_drives = Vec::new();
+        
+        for path in member_paths {
+            let drive_info = self.get_drive_info_for_path(path)?;
+            
+            // Heuristic: if path contains "parity", it's parity
+            if path.to_lowercase().contains("parity") {
+                parity_drives.push(drive_info);
+            } else {
+                data_drives.push(drive_info);
+            }
+        }
+        
+        Ok((data_drives, parity_drives))
+    }
+
+    /// Get drive information for a mount path by reading /proc/mounts
+    fn get_drive_info_for_path(&self, path: &str) -> anyhow::Result<PoolDrive> {
+        // Read /proc/mounts to find the backing device
+        let content = std::fs::read_to_string("/proc/mounts")
+            .map_err(|e| anyhow::anyhow!("Failed to read /proc/mounts: {}", e))?;
+
+        let mut device = String::new();
+
+        for line in content.lines() {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() >= 2 && parts[1] == path {
+                device = parts[0].to_string();
+                break;
+            }
+        }
+
+        if device.is_empty() {
+            return Err(anyhow::anyhow!("Could not find device for path {}", path));
+        }
+
+        // Extract base device name (e.g., "/dev/sda1" -> "sda")
+        let base_device = self.extract_base_device(&device);
+
+        // Get temperature from SMART data if available
+        let temperature = if let Ok(smart_data) = tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(self.get_smart_data(&base_device))
+        }) {
+            smart_data.temperature_celsius
+        } else {
+            None
+        };
+
+        Ok(PoolDrive {
+            name: base_device,
+            mount_point: path.to_string(),
+            temperature_celsius: temperature,
+        })
+    }
+
+    /// Resolve numeric mergerfs references like "1:2" to actual mount paths
+    fn resolve_numeric_mergerfs_paths(&self, numeric_refs: &[String]) -> anyhow::Result<Vec<String>> {
+        let mut resolved_paths = Vec::new();
+        
+        // Get all mount points that look like /mnt/disk* or /mnt/parity*
+        let mount_devices = tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(self.get_mount_devices())
+        }).map_err(|e| anyhow::anyhow!("Failed to get mount devices: {}", e))?;
+        
+        let mut disk_mounts: Vec<String> = mount_devices.keys()
+            .filter(|path| path.starts_with("/mnt/disk") || path.starts_with("/mnt/parity"))
+            .cloned()
+            .collect();
+        disk_mounts.sort(); // Ensure consistent ordering
+        
+        for num_ref in numeric_refs {
+            if let Ok(index) = num_ref.parse::<usize>() {
+                // Convert 1-based index to 0-based
+                if index > 0 && index <= disk_mounts.len() {
+                    resolved_paths.push(disk_mounts[index - 1].clone());
+                }
+            }
+        }
+        
+        // Fallback: if we couldn't resolve, return the original paths
+        if resolved_paths.is_empty() {
+            resolved_paths = numeric_refs.to_vec();
+        }
+        
+        Ok(resolved_paths)
+    }
 }

 #[async_trait]
 impl Collector for DiskCollector {
    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        self.collect_storage_data(agent_data).await
+        // Use cached data if available and fresh
+        if let Some((cached_drives, cached_pools)) = self.get_cached_data() {
+            agent_data.system.storage.drives = cached_drives;
+            agent_data.system.storage.pools = cached_pools;
+            Ok(())
+        } else {
+            // Collect fresh data
+            self.collect_storage_data(agent_data).await
+        }
    }
 }

@@ -512,6 +878,7 @@ impl Collector for DiskCollector {
 #[derive(Debug, Clone)]
 struct SmartData {
    health: String,
+    serial_number: Option<String>,
    temperature_celsius: Option<f32>,
    wear_percent: Option<f32>,
 }
--- a/agent/src/collectors/memory.rs
+++ b/agent/src/collectors/memory.rs
@@ -95,62 +95,47 @@ impl MemoryCollector {
        Ok(())
    }

-    /// Populate tmpfs data into AgentData
+    /// Populate tmpfs data into AgentData using statvfs syscall
    async fn populate_tmpfs_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+        use nix::sys::statvfs::statvfs;
+
        // Discover all tmpfs mount points
        let tmpfs_mounts = self.discover_tmpfs_mounts()?;
-        
+
        if tmpfs_mounts.is_empty() {
            debug!("No tmpfs mounts found to monitor");
            return Ok(());
        }

-        // Get usage data for all tmpfs mounts at once using df
-        let mut df_args = vec!["df", "--output=target,size,used", "--block-size=1"];
-        df_args.extend(tmpfs_mounts.iter().map(|s| s.as_str()));
+        // Get usage data for each tmpfs mount using statvfs syscall
+        for mount_point in tmpfs_mounts {
+            match statvfs(mount_point.as_str()) {
+                Ok(stat) => {
+                    let block_size = stat.fragment_size() as u64;
+                    let total_bytes = stat.blocks() as u64 * block_size;
+                    let available_bytes = stat.blocks_available() as u64 * block_size;
+                    let used_bytes = total_bytes - available_bytes;

-        let df_output = std::process::Command::new(df_args[0])
-            .args(&df_args[1..])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: "tmpfs mounts".to_string(),
-                error: e.to_string(),
-            })?;
+                    if total_bytes == 0 {
+                        continue;
+                    }

-        let df_str = String::from_utf8_lossy(&df_output.stdout);
-        let df_lines: Vec<&str> = df_str.lines().skip(1).collect(); // Skip header
+                    let total_gb = total_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
+                    let used_gb = used_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
+                    let usage_percent = (used_bytes as f32 / total_bytes as f32) * 100.0;

-        // Process each tmpfs mount
-        for (i, mount_point) in tmpfs_mounts.iter().enumerate() {
-            if i >= df_lines.len() {
-                debug!("Not enough df output lines for tmpfs mount: {}", mount_point);
-                continue;
+                    // Add to tmpfs list
+                    agent_data.system.memory.tmpfs.push(TmpfsData {
+                        mount: mount_point.clone(),
+                        usage_percent,
+                        used_gb,
+                        total_gb,
+                    });
+                }
+                Err(e) => {
+                    debug!("Failed to get stats for tmpfs mount {}: {}", mount_point, e);
+                }
            }
-
-            let parts: Vec<&str> = df_lines[i].split_whitespace().collect();
-            if parts.len() < 3 {
-                debug!("Invalid df output for tmpfs mount: {}", mount_point);
-                continue;
-            }
-
-            let total_bytes: u64 = parts[1].parse().unwrap_or(0);
-            let used_bytes: u64 = parts[2].parse().unwrap_or(0);
-
-            if total_bytes == 0 {
-                continue;
-            }
-
-            let total_gb = total_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
-            let used_gb = used_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
-            let usage_percent = (used_bytes as f32 / total_bytes as f32) * 100.0;
-
-            // Add to tmpfs list
-            agent_data.system.memory.tmpfs.push(TmpfsData {
-                mount: mount_point.clone(),
-                usage_percent,
-                used_gb,
-                total_gb,
-            });
        }

        // Sort tmpfs mounts by mount point for consistent display order
--- a/agent/src/collectors/mod.rs
+++ b/agent/src/collectors/mod.rs
@@ -1,17 +1,34 @@
 use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData};
-
+use std::process::{Command, Output};
+use std::time::Duration;
+use tokio::time::timeout;

 pub mod backup;
 pub mod cpu;
 pub mod disk;
 pub mod error;
 pub mod memory;
+pub mod network;
 pub mod nixos;
 pub mod systemd;

 pub use error::CollectorError;

+/// Run a command with a timeout to prevent blocking
+pub async fn run_command_with_timeout(mut cmd: Command, timeout_secs: u64) -> std::io::Result<Output> {
+    let timeout_duration = Duration::from_secs(timeout_secs);
+
+    match timeout(timeout_duration, tokio::task::spawn_blocking(move || cmd.output())).await {
+        Ok(Ok(result)) => result,
+        Ok(Err(e)) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
+        Err(_) => Err(std::io::Error::new(
+            std::io::ErrorKind::TimedOut,
+            format!("Command timed out after {} seconds", timeout_secs)
+        )),
+    }
+}
+

 /// Base trait for all collectors with direct structured data output
 #[async_trait]
--- a/agent/src/collectors/network.rs
+++ b/agent/src/collectors/network.rs
@@ -0,0 +1,248 @@
+use async_trait::async_trait;
+use cm_dashboard_shared::{AgentData, NetworkInterfaceData, Status};
+use tracing::debug;
+use futures::stream::TryStreamExt;
+use rtnetlink::{new_connection, IpVersion};
+use netlink_packet_route::link::LinkAttribute;
+use netlink_packet_route::address::AddressAttribute;
+use netlink_packet_route::route::RouteAttribute;
+use std::net::IpAddr;
+
+use super::{Collector, CollectorError};
+use crate::config::NetworkConfig;
+
+/// Network interface collector with physical/virtual classification and link status
+pub struct NetworkCollector {
+    _config: NetworkConfig,
+}
+
+impl NetworkCollector {
+    pub fn new(config: NetworkConfig) -> Self {
+        Self { _config: config }
+    }
+
+    /// Check if interface is physical (not virtual)
+    fn is_physical_interface(name: &str) -> bool {
+        // Physical interface patterns
+        matches!(
+            &name[..],
+            s if s.starts_with("eth")
+                || s.starts_with("ens")
+                || s.starts_with("enp")
+                || s.starts_with("wlan")
+                || s.starts_with("wlp")
+                || s.starts_with("eno")
+                || s.starts_with("enx")
+        )
+    }
+
+    /// Get link status for an interface
+    fn get_link_status(interface: &str) -> Status {
+        let operstate_path = format!("/sys/class/net/{}/operstate", interface);
+
+        match std::fs::read_to_string(&operstate_path) {
+            Ok(state) => {
+                let state = state.trim();
+                match state {
+                    "up" => Status::Ok,
+                    "down" => Status::Inactive,
+                    "unknown" => Status::Warning,
+                    _ => Status::Unknown,
+                }
+            }
+            Err(_) => Status::Unknown,
+        }
+    }
+
+    /// Get the primary physical interface (the one with default route) using rtnetlink
+    async fn get_primary_physical_interface() -> Option<String> {
+        let (connection, handle, _) = match new_connection() {
+            Ok(conn) => conn,
+            Err(e) => {
+                debug!("Failed to create netlink connection: {}", e);
+                return None;
+            }
+        };
+
+        tokio::spawn(connection);
+
+        // Get default route
+        let mut routes = handle.route().get(IpVersion::V4).execute();
+
+        while let Ok(Some(route)) = routes.try_next().await {
+            // Check if this is a default route (destination is 0.0.0.0/0)
+            if route.header.destination_prefix_length == 0 {
+                // Find the output interface (OIF) attribute
+                if let Some(oif) = route.attributes.iter().find_map(|attr| {
+                    if let RouteAttribute::Oif(index) = attr {
+                        Some(*index)
+                    } else {
+                        None
+                    }
+                }) {
+                    // Get interface name from index
+                    let mut link = handle.link().get().match_index(oif).execute();
+                    if let Ok(Some(link_msg)) = link.try_next().await {
+                        if let Some(name) = link_msg.attributes.iter().find_map(|attr| {
+                            if let LinkAttribute::IfName(n) = attr {
+                                Some(n.to_string())
+                            } else {
+                                None
+                            }
+                        }) {
+                            if Self::is_physical_interface(&name) {
+                                return Some(name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    /// Parse VLAN configuration from /proc/net/vlan/config
+    /// Returns a map of interface name -> VLAN ID
+    fn parse_vlan_config() -> std::collections::HashMap<String, u16> {
+        let mut vlan_map = std::collections::HashMap::new();
+
+        if let Ok(contents) = std::fs::read_to_string("/proc/net/vlan/config") {
+            for line in contents.lines().skip(2) {  // Skip header lines
+                let parts: Vec<&str> = line.split('|').collect();
+                if parts.len() >= 2 {
+                    let interface_name = parts[0].trim();
+                    let vlan_id_str = parts[1].trim();
+
+                    if let Ok(vlan_id) = vlan_id_str.parse::<u16>() {
+                        vlan_map.insert(interface_name.to_string(), vlan_id);
+                    }
+                }
+            }
+        }
+
+        vlan_map
+    }
+
+    /// Collect network interfaces using rtnetlink
+    async fn collect_interfaces(&self) -> Vec<NetworkInterfaceData> {
+        let mut interfaces = Vec::new();
+
+        // Parse VLAN configuration
+        let vlan_map = Self::parse_vlan_config();
+
+        // Create netlink connection
+        let (connection, handle, _) = match new_connection() {
+            Ok(conn) => conn,
+            Err(e) => {
+                debug!("Failed to create netlink connection: {}", e);
+                return interfaces;
+            }
+        };
+
+        tokio::spawn(connection);
+
+        // Get all links
+        let mut links = handle.link().get().execute();
+
+        while let Ok(Some(link)) = links.try_next().await {
+            // Get interface name
+            let name = match link.attributes.iter().find_map(|attr| {
+                if let LinkAttribute::IfName(n) = attr {
+                    Some(n.to_string())
+                } else {
+                    None
+                }
+            }) {
+                Some(n) => n,
+                None => continue,
+            };
+
+            // Skip loopback and ifb interfaces
+            if name == "lo" || name.starts_with("ifb") {
+                continue;
+            }
+
+            // Parse parent interface from @parent notation (e.g., lan@enp0s31f6)
+            let (interface_name, parent_interface) = if let Some(at_pos) = name.find('@') {
+                let (child, parent) = name.split_at(at_pos);
+                (child.to_string(), Some(parent[1..].to_string()))
+            } else {
+                (name.clone(), None)
+            };
+
+            // Get IP addresses for this interface
+            let mut ipv4_addresses = Vec::new();
+            let mut ipv6_addresses = Vec::new();
+
+            let mut addrs = handle.address().get().set_link_index_filter(link.header.index).execute();
+            while let Ok(Some(addr)) = addrs.try_next().await {
+                for nla in &addr.attributes {
+                    if let AddressAttribute::Address(ip) = nla {
+                        match ip {
+                            IpAddr::V4(ipv4) => ipv4_addresses.push(ipv4.to_string()),
+                            IpAddr::V6(ipv6) => {
+                                // Skip link-local IPv6 addresses (fe80::)
+                                if !ipv6.to_string().starts_with("fe80:") {
+                                    ipv6_addresses.push(ipv6.to_string());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Determine if physical
+            let is_physical = Self::is_physical_interface(&interface_name);
+
+            // Only filter out virtual interfaces without IPs
+            if !is_physical && ipv4_addresses.is_empty() && ipv6_addresses.is_empty() {
+                continue;
+            }
+
+            let link_status = if is_physical {
+                Self::get_link_status(&name)
+            } else {
+                Status::Unknown
+            };
+
+            // Look up VLAN ID
+            let vlan_id = vlan_map.get(&name).copied();
+
+            interfaces.push(NetworkInterfaceData {
+                name: interface_name,
+                ipv4_addresses,
+                ipv6_addresses,
+                is_physical,
+                link_status,
+                parent_interface,
+                vlan_id,
+            });
+        }
+
+        // Assign primary physical interface as parent to virtual interfaces
+        if let Some(primary) = Self::get_primary_physical_interface().await {
+            for interface in interfaces.iter_mut() {
+                if !interface.is_physical && interface.parent_interface.is_none() {
+                    interface.parent_interface = Some(primary.clone());
+                }
+            }
+        }
+
+        interfaces
+    }
+}
+
+#[async_trait]
+impl Collector for NetworkCollector {
+    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+        debug!("Collecting network interface data");
+
+        // Collect all network interfaces
+        let interfaces = self.collect_interfaces().await;
+
+        agent_data.system.network.interfaces = interfaces;
+
+        Ok(())
+    }
+}
--- a/agent/src/collectors/nixos.rs
+++ b/agent/src/collectors/nixos.rs
@@ -5,21 +5,18 @@ use std::process::Command;
 use tracing::debug;

 use super::{Collector, CollectorError};
-use crate::config::NixOSConfig;

 /// NixOS system information collector with structured data output
-/// 
+///
 /// This collector gathers NixOS-specific information like:
 /// - System generation/build information
 /// - Version information
 /// - Agent version from Nix store path
-pub struct NixOSCollector {
-    config: NixOSConfig,
-}
+pub struct NixOSCollector;

 impl NixOSCollector {
-    pub fn new(config: NixOSConfig) -> Self {
-        Self { config }
+    pub fn new(_config: crate::config::NixOSConfig) -> Self {
+        Self
    }

    /// Collect NixOS system information and populate AgentData
@@ -46,8 +43,8 @@ impl NixOSCollector {
        match fs::read_to_string("/etc/hostname") {
            Ok(hostname) => Some(hostname.trim().to_string()),
            Err(_) => {
-                // Fallback to hostname command
-                match Command::new("hostname").output() {
+                // Fallback to hostname command (with 2 second timeout)
+                match Command::new("timeout").args(["2", "hostname"]).output() {
                    Ok(output) => Some(String::from_utf8_lossy(&output.stdout).trim().to_string()),
                    Err(_) => None,
                }
@@ -83,14 +80,25 @@ impl NixOSCollector {
        std::env::var("CM_DASHBOARD_VERSION").unwrap_or_else(|_| "unknown".to_string())
    }

-    /// Get NixOS system generation (build) information
+    /// Get NixOS system generation (build) information from git commit
    async fn get_nixos_generation(&self) -> Option<String> {
-        match Command::new("nixos-version").output() {
-            Ok(output) => {
-                let version_str = String::from_utf8_lossy(&output.stdout);
-                Some(version_str.trim().to_string())
+        // Try to read git commit hash from file written during rebuild
+        let commit_file = "/var/lib/cm-dashboard/git-commit";
+        match fs::read_to_string(commit_file) {
+            Ok(content) => {
+                let commit_hash = content.trim();
+                if commit_hash.len() >= 7 {
+                    debug!("Found git commit hash: {}", commit_hash);
+                    Some(commit_hash.to_string())
+                } else {
+                    debug!("Git commit hash too short: {}", commit_hash);
+                    None
+                }
+            }
+            Err(e) => {
+                debug!("Failed to read git commit file {}: {}", commit_file, e);
+                None
            }
-            Err(_) => None,
        }
    }
 }
--- a/agent/src/collectors/systemd.rs
+++ b/agent/src/collectors/systemd.rs
@@ -4,7 +4,9 @@ use cm_dashboard_shared::{AgentData, ServiceData, SubServiceData, SubServiceMetr
 use std::process::Command;
 use std::sync::RwLock;
 use std::time::Instant;
-use tracing::debug;
+use tracing::{debug, warn};
+use bollard::Docker;
+use bollard::container::ListContainersOptions;

 use super::{Collector, CollectorError};
 use crate::config::SystemdConfig;
@@ -22,8 +24,8 @@ pub struct SystemdCollector {
 struct ServiceCacheState {
    /// Last collection time for performance tracking
    last_collection: Option<Instant>,
-    /// Cached service data
-    services: Vec<ServiceInfo>,
+    /// Cached complete service data with sub-services
+    cached_service_data: Vec<ServiceData>,
    /// Interesting services to monitor (cached after discovery)
    monitored_services: Vec<String>,
    /// Cached service status information from discovery
@@ -48,20 +50,11 @@ struct ServiceStatusInfo {
    sub_state: String,
 }

-/// Internal service information
-#[derive(Debug, Clone)]
-struct ServiceInfo {
-    name: String,
-    status: String,           // "active", "inactive", "failed", etc.
-    memory_mb: f32,          // Memory usage in MB
-    disk_gb: f32,            // Disk usage in GB
-}
-
 impl SystemdCollector {
    pub fn new(config: SystemdConfig) -> Self {
        let state = ServiceCacheState {
            last_collection: None,
-            services: Vec::new(),
+            cached_service_data: Vec::new(),
            monitored_services: Vec::new(),
            service_status_cache: std::collections::HashMap::new(),
            last_discovery_time: None,
@@ -70,7 +63,7 @@ impl SystemdCollector {
            last_nginx_check_time: None,
            nginx_check_interval_seconds: config.nginx_check_interval_seconds,
        };
-        
+
        Self {
            state: RwLock::new(state),
            config,
@@ -83,7 +76,7 @@ impl SystemdCollector {
        debug!("Collecting systemd services metrics");

        // Get cached services (discovery only happens when needed)
-        let monitored_services = match self.get_monitored_services() {
+        let monitored_services = match self.get_monitored_services().await {
            Ok(services) => services,
            Err(e) => {
                debug!("Failed to get monitored services: {}", e);
@@ -92,7 +85,7 @@ impl SystemdCollector {
        };

        // Collect service data for each monitored service
-        let mut services = Vec::new();
+        let mut complete_service_data = Vec::new();
        for service_name in &monitored_services {
            match self.get_service_status(service_name) {
                Ok((active_status, _detailed_info)) => {
@@ -103,7 +96,7 @@ impl SystemdCollector {

                    // Sub-service metrics for specific services (always include cached results)
                    if service_name.contains("nginx") && active_status == "active" {
-                        let nginx_sites = self.get_nginx_site_metrics();
+                        let nginx_sites = self.get_nginx_site_metrics().await;
                        for (site_name, latency_ms) in nginx_sites {
                            let site_status = if latency_ms >= 0.0 && latency_ms < self.config.nginx_latency_critical_ms {
                                "active"
@@ -122,54 +115,74 @@ impl SystemdCollector {
                                name: site_name.clone(),
                                service_status: self.calculate_service_status(&site_name, &site_status),
                                metrics,
+                                service_type: "nginx_site".to_string(),
                            });
                        }
                    }

                    if service_name.contains("docker") && active_status == "active" {
-                        let docker_containers = self.get_docker_containers();
+                        let docker_containers = self.get_docker_containers().await;
                        for (container_name, container_status) in docker_containers {
                            // For now, docker containers have no additional metrics
                            // Future: could add memory_mb, cpu_percent, restart_count, etc.
                            let metrics = Vec::new();
-                            
+
                            sub_services.push(SubServiceData {
                                name: container_name.clone(),
                                service_status: self.calculate_service_status(&container_name, &container_status),
                                metrics,
+                                service_type: "container".to_string(),
+                            });
+                        }
+
+                        // Add Docker images
+                        let docker_images = self.get_docker_images().await;
+                        for (image_name, image_status, image_size_mb) in docker_images {
+                            let mut metrics = Vec::new();
+                            metrics.push(SubServiceMetric {
+                                label: "size".to_string(),
+                                value: image_size_mb,
+                                unit: Some("MB".to_string()),
+                            });
+
+                            sub_services.push(SubServiceData {
+                                name: image_name.to_string(),
+                                service_status: self.calculate_service_status(&image_name, &image_status),
+                                metrics,
+                                service_type: "image".to_string(),
                            });
                        }
                    }

-                    let service_info = ServiceInfo {
-                        name: service_name.clone(),
-                        status: active_status.clone(),
-                        memory_mb,
-                        disk_gb,
-                    };
-                    services.push(service_info);
-
-                    // Add to AgentData with hierarchical structure
-                    agent_data.services.push(ServiceData {
+                    // Create complete service data
+                    let service_data = ServiceData {
                        name: service_name.clone(),
                        memory_mb,
                        disk_gb,
                        user_stopped: false, // TODO: Integrate with service tracker
                        service_status: self.calculate_service_status(service_name, &active_status),
                        sub_services,
-                    });
+                    };
+
+                    // Add to AgentData and cache
+                    agent_data.services.push(service_data.clone());
+                    complete_service_data.push(service_data);
                }
                Err(e) => {
                    debug!("Failed to get status for service {}: {}", service_name, e);
                }
            }
        }
-        
+
+        // Sort services alphabetically by name
+        agent_data.services.sort_by(|a, b| a.name.cmp(&b.name));
+        complete_service_data.sort_by(|a, b| a.name.cmp(&b.name));
+
        // Update cached state
        {
            let mut state = self.state.write().unwrap();
            state.last_collection = Some(start_time);
-            state.services = services;
+            state.cached_service_data = complete_service_data;
        }

        let elapsed = start_time.elapsed();
@@ -179,7 +192,7 @@ impl SystemdCollector {
    }

    /// Get monitored services, discovering them if needed or cache is expired
-    fn get_monitored_services(&self) -> Result<Vec<String>> {
+    async fn get_monitored_services(&self) -> Result<Vec<String>> {
        // Check if we need discovery without holding the lock
        let needs_discovery = {
            let state = self.state.read().unwrap();
@@ -194,7 +207,7 @@ impl SystemdCollector {

        if needs_discovery {
            debug!("Discovering systemd services (cache expired or first run)");
-            match self.discover_services_internal() {
+            match self.discover_services_internal().await {
                Ok((services, status_cache)) => {
                    if let Ok(mut state) = self.state.write() {
                        state.monitored_services = services.clone();
@@ -217,48 +230,52 @@ impl SystemdCollector {
    }

    /// Get nginx site metrics, checking them if cache is expired (like old working version)
-    fn get_nginx_site_metrics(&self) -> Vec<(String, f32)> {
-        let mut state = self.state.write().unwrap();
-
-        // Check if we need to refresh nginx site metrics
-        let needs_refresh = match state.last_nginx_check_time {
-            None => true, // First time
-            Some(last_time) => {
-                let elapsed = last_time.elapsed().as_secs();
-                elapsed >= state.nginx_check_interval_seconds
+    async fn get_nginx_site_metrics(&self) -> Vec<(String, f32)> {
+        // Check if we need to refresh (read lock)
+        let needs_refresh = {
+            let state = self.state.read().unwrap();
+            match state.last_nginx_check_time {
+                None => true,
+                Some(last_time) => {
+                    let elapsed = last_time.elapsed().as_secs();
+                    elapsed >= state.nginx_check_interval_seconds
+                }
            }
        };

        if needs_refresh {
-            // Only check nginx sites if nginx service is active
-            if state.monitored_services.iter().any(|s| s.contains("nginx")) {
-                debug!(
-                    "Refreshing nginx site latency metrics (interval: {}s)",
-                    state.nginx_check_interval_seconds
-                );
-                let fresh_metrics = self.get_nginx_sites_internal();
+            // Check if nginx is active (read lock)
+            let has_nginx = {
+                let state = self.state.read().unwrap();
+                state.monitored_services.iter().any(|s| s.contains("nginx"))
+            };
+
+            if has_nginx {
+                let fresh_metrics = self.get_nginx_sites_internal().await;
+                let mut state = self.state.write().unwrap();
                state.nginx_site_metrics = fresh_metrics;
                state.last_nginx_check_time = Some(Instant::now());
            }
        }

+        let state = self.state.read().unwrap();
        state.nginx_site_metrics.clone()
    }

-    /// Auto-discover interesting services to monitor
-    fn discover_services_internal(&self) -> Result<(Vec<String>, std::collections::HashMap<String, ServiceStatusInfo>)> {
-        // First: Get all service unit files
-        let unit_files_output = Command::new("systemctl")
-            .args(&["list-unit-files", "--type=service", "--no-pager", "--plain"])
+    /// Auto-discover interesting services to monitor using systemctl
+    async fn discover_services_internal(&self) -> Result<(Vec<String>, std::collections::HashMap<String, ServiceStatusInfo>)> {
+        // First: Get all service unit files (with 3 second timeout)
+        let unit_files_output = Command::new("timeout")
+            .args(&["3", "systemctl", "list-unit-files", "--type=service", "--no-pager", "--plain"])
            .output()?;

        if !unit_files_output.status.success() {
            return Err(anyhow::anyhow!("systemctl list-unit-files command failed"));
        }

-        // Second: Get runtime status of all units
-        let units_status_output = Command::new("systemctl")
-            .args(&["list-units", "--type=service", "--all", "--no-pager", "--plain"])
+        // Second: Get runtime status of all units (with 3 second timeout)
+        let units_status_output = Command::new("timeout")
+            .args(&["3", "systemctl", "list-units", "--type=service", "--all", "--no-pager", "--plain"])
            .output()?;

        if !units_status_output.status.success() {
@@ -338,9 +355,9 @@ impl SystemdCollector {
        Ok((services, status_cache))
    }

-    /// Get service status from cache (if available) or fallback to systemctl
+    /// Get service status from D-Bus cache
    fn get_service_status(&self, service: &str) -> Result<(String, String)> {
-        // Try to get status from cache first
+        // Get status from D-Bus cache (populated by discover_services_internal)
        if let Ok(state) = self.state.read() {
            if let Some(cached_info) = state.service_status_cache.get(service) {
                let active_status = cached_info.active_state.clone();
@@ -354,20 +371,25 @@ impl SystemdCollector {
            }
        }

-        // Fallback to systemctl if not in cache
+        // Service not found in D-Bus cache - treat as inactive
+        Ok(("inactive".to_string(), "LoadState=not-found\nActiveState=inactive\nSubState=dead".to_string()))
+    }
+
+    /// Get a unit property via systemctl show
+    fn get_unit_property(&self, service_name: &str, property: &str) -> Option<String> {
        let output = Command::new("systemctl")
-            .args(&["is-active", &format!("{}.service", service)])
-            .output()?;
+            .args(&["show", &format!("{}.service", service_name), &format!("--property={}", property)])
+            .output()
+            .ok()?;

-        let active_status = String::from_utf8(output.stdout)?.trim().to_string();
+        if !output.status.success() {
+            return None;
+        }

-        // Get more detailed info
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service), "--property=LoadState,ActiveState,SubState"])
-            .output()?;
-
-        let detailed_info = String::from_utf8(output.stdout)?;
-        Ok((active_status, detailed_info))
+        let output_str = String::from_utf8(output.stdout).ok()?;
+        // Parse "PropertyName=value" format
+        let value = output_str.trim().strip_prefix(&format!("{}=", property))?;
+        Some(value.to_string())
    }

    /// Check if service name matches pattern (supports wildcards like nginx*)
@@ -415,7 +437,7 @@ impl SystemdCollector {
        if let Some(dirs) = self.config.service_directories.get(service_name) {
            // Service has configured paths - use the first accessible one
            for dir in dirs {
-                if let Some(size) = self.get_directory_size(dir) {
+                if let Some(size) = self.get_directory_size(dir).await {
                    return Ok(size);
                }
            }
@@ -424,39 +446,32 @@ impl SystemdCollector {
        }

        // No configured path - try to get WorkingDirectory from systemctl
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service_name), "--property=WorkingDirectory"])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: format!("WorkingDirectory for {}", service_name),
-                error: e.to_string(),
-            })?;
-
-        let output_str = String::from_utf8_lossy(&output.stdout);
-        for line in output_str.lines() {
-            if line.starts_with("WorkingDirectory=") && !line.contains("[not set]") {
-                let dir = line.strip_prefix("WorkingDirectory=").unwrap_or("");
-                if !dir.is_empty() && dir != "/" {
-                    return Ok(self.get_directory_size(dir).unwrap_or(0.0));
-                }
+        if let Some(dir_str) = self.get_unit_property(service_name, "WorkingDirectory") {
+            if !dir_str.is_empty() && dir_str != "/" && dir_str != "[not set]" {
+                return Ok(self.get_directory_size(&dir_str).await.unwrap_or(0.0));
            }
        }

        Ok(0.0)
    }
    
-    /// Get size of a directory in GB
-    fn get_directory_size(&self, path: &str) -> Option<f32> {
-        let output = Command::new("sudo")
-            .args(&["du", "-sb", path])
-            .output()
-            .ok()?;
+    /// Get size of a directory in GB (with 2 second timeout)
+    async fn get_directory_size(&self, path: &str) -> Option<f32> {
+        use super::run_command_with_timeout;
+
+        // Use -s (summary) and --apparent-size for speed, 2 second timeout
+        let mut cmd = Command::new("sudo");
+        cmd.args(&["du", "-s", "--apparent-size", "--block-size=1", path]);
+
+        let output = run_command_with_timeout(cmd, 2).await.ok()?;

        if !output.status.success() {
            // Log permission errors for debugging but don't spam logs
            let stderr = String::from_utf8_lossy(&output.stderr);
            if stderr.contains("Permission denied") {
                debug!("Permission denied accessing directory: {}", path);
+            } else if stderr.contains("timed out") {
+                warn!("Directory size check timed out for {}", path);
            } else {
                debug!("Failed to get size for directory {}: {}", path, stderr);
            }
@@ -478,25 +493,6 @@ impl SystemdCollector {
        }
    }

-    /// Get service memory usage (if available) 
-    fn get_service_memory(&self, service: &str) -> Option<f32> {
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service), "--property=MemoryCurrent"])
-            .output()
-            .ok()?;
-
-        let output_str = String::from_utf8(output.stdout).ok()?;
-        for line in output_str.lines() {
-            if line.starts_with("MemoryCurrent=") {
-                let memory_str = line.strip_prefix("MemoryCurrent=")?;
-                if let Ok(memory_bytes) = memory_str.parse::<u64>() {
-                    return Some(memory_bytes as f32 / (1024.0 * 1024.0)); // Convert to MB
-                }
-            }
-        }
-        None
-    }
-
    /// 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() {
@@ -514,27 +510,13 @@ impl SystemdCollector {
        }
    }

-    /// Get memory usage for a specific service
+    /// Get memory usage for a specific service via systemctl
    async fn get_service_memory_usage(&self, service_name: &str) -> Result<f32, CollectorError> {
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service_name), "--property=MemoryCurrent"])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: format!("memory usage for {}", service_name),
-                error: e.to_string(),
-            })?;
-
-        let output_str = String::from_utf8_lossy(&output.stdout);
-        
-        for line in output_str.lines() {
-            if line.starts_with("MemoryCurrent=") {
-                if let Some(mem_str) = line.strip_prefix("MemoryCurrent=") {
-                    if mem_str != "[not set]" {
-                        if let Ok(memory_bytes) = mem_str.parse::<u64>() {
-                            return Ok(memory_bytes as f32 / (1024.0 * 1024.0)); // Convert to MB
-                        }
-                    }
-                }
+        // Get MemoryCurrent property from systemctl
+        if let Some(value_str) = self.get_unit_property(service_name, "MemoryCurrent") {
+            // MemoryCurrent is in bytes or could be "[not set]"
+            if let Ok(memory_bytes) = value_str.parse::<u64>() {
+                return Ok(memory_bytes as f32 / (1024.0 * 1024.0)); // Convert to MB
            }
        }

@@ -544,40 +526,41 @@ impl SystemdCollector {
    /// Check if service collection cache should be updated
    fn should_update_cache(&self) -> bool {
        let state = self.state.read().unwrap();
-        
+
        match state.last_collection {
            None => true,
            Some(last) => {
-                let cache_duration = std::time::Duration::from_secs(30);
+                let cache_duration = std::time::Duration::from_secs(self.config.interval_seconds);
                last.elapsed() > cache_duration
            }
        }
    }

-    /// Get cached service data if available and fresh
-    fn get_cached_services(&self) -> Option<Vec<ServiceInfo>> {
+    /// Get cached complete service data with sub-services if available and fresh
+    fn get_cached_complete_services(&self) -> Option<Vec<ServiceData>> {
        if !self.should_update_cache() {
            let state = self.state.read().unwrap();
-            Some(state.services.clone())
+            Some(state.cached_service_data.clone())
        } else {
            None
        }
    }

    /// Get nginx sites with latency checks (internal - no caching)
-    fn get_nginx_sites_internal(&self) -> Vec<(String, f32)> {
+    async fn get_nginx_sites_internal(&self) -> Vec<(String, f32)> {
        let mut sites = Vec::new();

        // Discover nginx sites from configuration
-        let discovered_sites = self.discover_nginx_sites();
+        let discovered_sites = self.discover_nginx_sites().await;

+        // Always add all discovered sites, even if checks fail (like old version)
        for (site_name, url) in &discovered_sites {
            match self.check_site_latency(url) {
                Ok(latency_ms) => {
                    sites.push((site_name.clone(), latency_ms));
                }
                Err(_) => {
-                    // Site is unreachable - use -1.0 to indicate error
+                    // Site is unreachable - use -1.0 to indicate error (like old version)
                    sites.push((site_name.clone(), -1.0));
                }
            }
@@ -587,9 +570,9 @@ impl SystemdCollector {
    }

    /// Discover nginx sites from configuration
-    fn discover_nginx_sites(&self) -> Vec<(String, String)> {
+    async fn discover_nginx_sites(&self) -> Vec<(String, String)> {
        // Use the same approach as the old working agent: get nginx config from systemd
-        let config_content = match self.get_nginx_config_from_systemd() {
+        let config_content = match self.get_nginx_config_from_systemd().await {
            Some(content) => content,
            None => {
                debug!("Could not get nginx config from systemd, trying nginx -T fallback");
@@ -622,30 +605,16 @@ impl SystemdCollector {
        Some(String::from_utf8_lossy(&output.stdout).to_string())
    }

-    /// Get nginx config from systemd service definition (NixOS compatible)
-    fn get_nginx_config_from_systemd(&self) -> Option<String> {
-        let output = Command::new("systemctl")
-            .args(&["show", "nginx", "--property=ExecStart", "--no-pager"])
-            .output()
-            .ok()?;
+    /// Get nginx config from systemd service definition via systemctl (NixOS compatible)
+    async fn get_nginx_config_from_systemd(&self) -> Option<String> {
+        // Get ExecStart property from systemctl
+        let exec_start_str = self.get_unit_property("nginx", "ExecStart")?;
+        debug!("nginx ExecStart from systemctl: {}", exec_start_str);

-        if !output.status.success() {
-            debug!("Failed to get nginx ExecStart from systemd");
-            return None;
-        }
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        debug!("systemctl show nginx output: {}", stdout);
-
-        // Parse ExecStart to extract -c config path
-        for line in stdout.lines() {
-            if line.starts_with("ExecStart=") {
-                debug!("Found ExecStart line: {}", line);
-                if let Some(config_path) = self.extract_config_path_from_exec_start(line) {
-                    debug!("Extracted config path: {}", config_path);
-                    return std::fs::read_to_string(&config_path).ok();
-                }
-            }
+        // Extract config path from ExecStart structure
+        if let Some(config_path) = self.extract_config_path_from_exec_start(&exec_start_str) {
+            debug!("Extracted config path: {}", config_path);
+            return std::fs::read_to_string(&config_path).ok();
        }

        None
@@ -787,66 +756,108 @@ impl SystemdCollector {
        }
    }

-    /// Get docker containers as sub-services
-    fn get_docker_containers(&self) -> Vec<(String, String)> {
+    /// Get docker containers as sub-services using bollard API
+    async fn get_docker_containers(&self) -> Vec<(String, String)> {
        let mut containers = Vec::new();

-        // Check if docker is available
-        let output = Command::new("docker")
-            .args(&["ps", "--format", "{{.Names}},{{.Status}}"])
-            .output();
-
-        let output = match output {
-            Ok(out) if out.status.success() => out,
-            _ => return containers, // Docker not available or failed
+        // Connect to Docker daemon
+        let docker = match Docker::connect_with_local_defaults() {
+            Ok(d) => d,
+            Err(e) => {
+                debug!("Failed to connect to Docker daemon: {}", e);
+                return containers;
+            }
        };

-        let output_str = match String::from_utf8(output.stdout) {
-            Ok(s) => s,
-            Err(_) => return containers,
+        // List all containers (running and stopped)
+        let list_options = Some(ListContainersOptions::<String> {
+            all: true,
+            ..Default::default()
+        });
+
+        let container_list = match docker.list_containers(list_options).await {
+            Ok(list) => list,
+            Err(e) => {
+                debug!("Failed to list Docker containers: {}", e);
+                return containers;
+            }
        };

-        for line in output_str.lines() {
-            if line.trim().is_empty() {
-                continue;
-            }
+        for container in container_list {
+            // Get container name (remove leading slash if present)
+            let container_name = container.names
+                .and_then(|names| names.first().map(|n| n.trim_start_matches('/').to_string()))
+                .unwrap_or_else(|| container.id.clone().unwrap_or_default());

-            let parts: Vec<&str> = line.split(',').collect();
-            if parts.len() >= 2 {
-                let container_name = parts[0].trim();
-                let status_str = parts[1].trim();
+            // Map container state to service status
+            let container_status = match container.state.as_deref() {
+                Some("running") => "active",
+                Some("exited") | Some("created") => "inactive",
+                _ => "failed", // restarting, paused, dead, etc.
+            };

-                let container_status = if status_str.contains("Up") {
-                    "active"
-                } else if status_str.contains("Exited") {
-                    "warning" // Match original: Exited → Warning, not inactive
-                } else {
-                    "failed" // Other states → failed
-                };
-                
-                containers.push((format!("docker_{}", container_name), container_status.to_string()));
-            }
+            containers.push((format!("docker_{}", container_name), container_status.to_string()));
        }

        containers
    }
+
+    /// Get docker images as sub-services using bollard API
+    async fn get_docker_images(&self) -> Vec<(String, String, f32)> {
+        let mut images = Vec::new();
+
+        // Connect to Docker daemon
+        let docker = match Docker::connect_with_local_defaults() {
+            Ok(d) => d,
+            Err(e) => {
+                debug!("Failed to connect to Docker daemon: {}", e);
+                return images;
+            }
+        };
+
+        // List all images
+        let image_list = match docker.list_images::<String>(None).await {
+            Ok(list) => list,
+            Err(e) => {
+                debug!("Failed to list Docker images: {}", e);
+                return images;
+            }
+        };
+
+        for image in image_list {
+            // Get image name from repo tags
+            let image_names: Vec<String> = image.repo_tags
+                .into_iter()
+                .filter(|tag| !tag.contains("<none>"))
+                .collect();
+
+            if image_names.is_empty() {
+                continue; // Skip untagged images
+            }
+
+            // Get size in MB
+            let size_mb = image.size as f32 / (1024.0 * 1024.0);
+
+            for image_name in image_names {
+                images.push((
+                    image_name,
+                    "inactive".to_string(), // Images are informational - use inactive for neutral display
+                    size_mb
+                ));
+            }
+        }
+
+        images
+    }
 }

 #[async_trait]
 impl Collector for SystemdCollector {
    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        // Use cached data if available and fresh
-        if let Some(cached_services) = self.get_cached_services() {
-            debug!("Using cached systemd services data");
-            for service in cached_services {
-                agent_data.services.push(ServiceData {
-                    name: service.name.clone(),
-                    memory_mb: service.memory_mb,
-                    disk_gb: service.disk_gb,
-                    user_stopped: false, // TODO: Integrate with service tracker
-                    service_status: self.calculate_service_status(&service.name, &service.status),
-                    sub_services: Vec::new(), // Cached services don't have sub-services
-                });
+        // Use cached complete data if available and fresh
+        if let Some(cached_complete_services) = self.get_cached_complete_services() {
+            for service_data in cached_complete_services {
+                agent_data.services.push(service_data);
            }
            Ok(())
        } else {
--- a/agent/src/communication/mod.rs
+++ b/agent/src/communication/mod.rs
@@ -5,10 +5,9 @@ use zmq::{Context, Socket, SocketType};

 use crate::config::ZmqConfig;

-/// ZMQ communication handler for publishing metrics and receiving commands
+/// ZMQ communication handler for publishing metrics
 pub struct ZmqHandler {
    publisher: Socket,
-    command_receiver: Socket,
 }

 impl ZmqHandler {
@@ -26,20 +25,8 @@ impl ZmqHandler {
        publisher.set_sndhwm(1000)?; // High water mark for outbound messages
        publisher.set_linger(1000)?; // Linger time on close

-        // Create command receiver socket (PULL socket to receive commands from dashboard)
-        let command_receiver = context.socket(SocketType::PULL)?;
-        let cmd_bind_address = format!("tcp://{}:{}", config.bind_address, config.command_port);
-        command_receiver.bind(&cmd_bind_address)?;
-
-        info!("ZMQ command receiver bound to {}", cmd_bind_address);
-
-        // Set non-blocking mode for command receiver
-        command_receiver.set_rcvtimeo(0)?; // Non-blocking receive
-        command_receiver.set_linger(1000)?;
-
        Ok(Self {
            publisher,
-            command_receiver,
        })
    }

@@ -65,36 +52,4 @@ impl ZmqHandler {
        Ok(())
    }

-    /// Try to receive a command (non-blocking)
-    pub fn try_receive_command(&self) -> Result<Option<AgentCommand>> {
-        match self.command_receiver.recv_bytes(zmq::DONTWAIT) {
-            Ok(bytes) => {
-                debug!("Received command message ({} bytes)", bytes.len());
-
-                let command: AgentCommand = serde_json::from_slice(&bytes)
-                    .map_err(|e| anyhow::anyhow!("Failed to deserialize command: {}", e))?;
-
-                debug!("Parsed command: {:?}", command);
-                Ok(Some(command))
-            }
-            Err(zmq::Error::EAGAIN) => {
-                // No message available (non-blocking)
-                Ok(None)
-            }
-            Err(e) => Err(anyhow::anyhow!("ZMQ receive error: {}", e)),
-        }
-    }
-}
-
-/// Commands that can be sent to the agent
-#[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,
 }
--- a/agent/src/config/defaults.rs
+++ b/agent/src/config/defaults.rs
@@ -1,2 +0,0 @@
-// This file is now empty - all configuration values come from config files
-// No hardcoded defaults are used
--- a/agent/src/config/mod.rs
+++ b/agent/src/config/mod.rs
@@ -20,7 +20,6 @@ pub struct AgentConfig {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ZmqConfig {
    pub publisher_port: u16,
-    pub command_port: u16,
    pub bind_address: String,
    pub transmission_interval_seconds: u64,
    /// Heartbeat transmission interval in seconds for host connectivity detection
--- a/agent/src/config/validation.rs
+++ b/agent/src/config/validation.rs
@@ -7,14 +7,6 @@ pub fn validate_config(config: &AgentConfig) -> Result<()> {
        bail!("ZMQ publisher port cannot be 0");
    }

-    if config.zmq.command_port == 0 {
-        bail!("ZMQ command port cannot be 0");
-    }
-
-    if config.zmq.publisher_port == config.zmq.command_port {
-        bail!("ZMQ publisher and command ports cannot be the same");
-    }
-
    if config.zmq.bind_address.is_empty() {
        bail!("ZMQ bind address cannot be empty");
    }
--- a/agent/src/main.rs
+++ b/agent/src/main.rs
@@ -8,7 +8,6 @@ mod collectors;
 mod communication;
 mod config;
 mod notifications;
-mod service_tracker;

 use agent::Agent;

--- a/agent/src/service_tracker.rs
+++ b/agent/src/service_tracker.rs
@@ -1,164 +0,0 @@
-use anyhow::Result;
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-use std::fs;
-use std::path::Path;
-use std::sync::{Arc, Mutex, OnceLock};
-use tracing::{debug, info, warn};
-
-/// Shared instance for global access
-static GLOBAL_TRACKER: OnceLock<Arc<Mutex<UserStoppedServiceTracker>>> = OnceLock::new();
-
-/// Tracks services that have been stopped by user action
-/// These services should be treated as OK status instead of Warning
-#[derive(Debug)]
-pub struct UserStoppedServiceTracker {
-    /// Set of services stopped by user action
-    user_stopped_services: HashSet<String>,
-    /// Path to persistent storage file
-    storage_path: String,
-}
-
-/// Serializable data structure for persistence
-#[derive(Debug, Serialize, Deserialize)]
-struct UserStoppedData {
-    services: Vec<String>,
-}
-
-impl UserStoppedServiceTracker {
-    /// Create new tracker with default storage path
-    pub fn new() -> Self {
-        Self::with_storage_path("/var/lib/cm-dashboard/user-stopped-services.json")
-    }
-
-    /// Initialize global instance (called by agent)
-    pub fn init_global() -> Result<Self> {
-        let tracker = Self::new();
-        
-        // Set global instance
-        let global_instance = Arc::new(Mutex::new(tracker));
-        if GLOBAL_TRACKER.set(global_instance).is_err() {
-            warn!("Global service tracker was already initialized");
-        }
-        
-        // Return a new instance for the agent to use
-        Ok(Self::new())
-    }
-
-    /// Check if a service is user-stopped (global access for collectors)
-    pub fn is_service_user_stopped(service_name: &str) -> bool {
-        if let Some(global) = GLOBAL_TRACKER.get() {
-            if let Ok(tracker) = global.lock() {
-                tracker.is_user_stopped(service_name)
-            } else {
-                debug!("Failed to lock global service tracker");
-                false
-            }
-        } else {
-            debug!("Global service tracker not initialized");
-            false
-        }
-    }
-
-    /// Update global tracker (called by agent when tracker state changes)
-    pub fn update_global(updated_tracker: &UserStoppedServiceTracker) {
-        if let Some(global) = GLOBAL_TRACKER.get() {
-            if let Ok(mut tracker) = global.lock() {
-                tracker.user_stopped_services = updated_tracker.user_stopped_services.clone();
-            } else {
-                debug!("Failed to lock global service tracker for update");
-            }
-        } else {
-            debug!("Global service tracker not initialized for update");
-        }
-    }
-
-    /// Create new tracker with custom storage path
-    pub fn with_storage_path<P: AsRef<Path>>(storage_path: P) -> Self {
-        let storage_path = storage_path.as_ref().to_string_lossy().to_string();
-        let mut tracker = Self {
-            user_stopped_services: HashSet::new(),
-            storage_path,
-        };
-
-        // Load existing data from storage
-        if let Err(e) = tracker.load_from_storage() {
-            warn!("Failed to load user-stopped services from storage: {}", e);
-            info!("Starting with empty user-stopped services list");
-        }
-
-        tracker
-    }
-
-
-    /// Clear user-stopped flag for a service (when user starts it)
-    pub fn clear_user_stopped(&mut self, service_name: &str) -> Result<()> {
-        if self.user_stopped_services.remove(service_name) {
-            info!("Cleared user-stopped flag for service '{}'", service_name);
-            self.save_to_storage()?;
-            debug!("Service '{}' user-stopped flag cleared and saved to storage", service_name);
-        } else {
-            debug!("Service '{}' was not marked as user-stopped", service_name);
-        }
-        Ok(())
-    }
-
-    /// Check if a service is marked as user-stopped
-    pub fn is_user_stopped(&self, service_name: &str) -> bool {
-        let is_stopped = self.user_stopped_services.contains(service_name);
-        debug!("Service '{}' user-stopped status: {}", service_name, is_stopped);
-        is_stopped
-    }
-
-
-    /// Save current state to persistent storage
-    fn save_to_storage(&self) -> Result<()> {
-        // Create parent directory if it doesn't exist
-        if let Some(parent_dir) = Path::new(&self.storage_path).parent() {
-            if !parent_dir.exists() {
-                fs::create_dir_all(parent_dir)?;
-                debug!("Created parent directory: {}", parent_dir.display());
-            }
-        }
-
-        let data = UserStoppedData {
-            services: self.user_stopped_services.iter().cloned().collect(),
-        };
-
-        let json_data = serde_json::to_string_pretty(&data)?;
-        fs::write(&self.storage_path, json_data)?;
-
-        debug!(
-            "Saved {} user-stopped services to {}",
-            data.services.len(),
-            self.storage_path
-        );
-        Ok(())
-    }
-
-    /// Load state from persistent storage
-    fn load_from_storage(&mut self) -> Result<()> {
-        if !Path::new(&self.storage_path).exists() {
-            debug!("Storage file {} does not exist, starting fresh", self.storage_path);
-            return Ok(());
-        }
-
-        let json_data = fs::read_to_string(&self.storage_path)?;
-        let data: UserStoppedData = serde_json::from_str(&json_data)?;
-
-        self.user_stopped_services = data.services.into_iter().collect();
-
-        info!(
-            "Loaded {} user-stopped services from {}",
-            self.user_stopped_services.len(),
-            self.storage_path
-        );
-
-        if !self.user_stopped_services.is_empty() {
-            debug!("User-stopped services: {:?}", self.user_stopped_services);
-        }
-
-        Ok(())
-    }
-}
-
--- a/agent_stream.log
+++ b/agent_stream.log
@@ -1,1001 +0,0 @@
-warning: fields `total_services`, `backup_disk_filesystem_label`, `services_completed_count`, `services_failed_count`, and `services_disabled_count` are never read
-  --> dashboard/src/ui/widgets/backup.rs:22:5
-   |
-14 | pub struct BackupWidget {
-   |            ------------ fields in this struct
-...
-22 |     total_services: Option<i64>,
-   |     ^^^^^^^^^^^^^^
-...
-36 |     backup_disk_filesystem_label: Option<String>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-37 |     /// Number of completed services
-38 |     services_completed_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-39 |     /// Number of failed services
-40 |     services_failed_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^
-41 |     /// Number of disabled services
-42 |     services_disabled_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `BackupWidget` has a derived impl for the trait `Clone`, but this is intentionally ignored during dead code analysis
-   = note: `#[warn(dead_code)]` on by default
-
-warning: field `exit_code` is never read
-  --> dashboard/src/ui/widgets/backup.rs:53:5
-   |
-50 | struct ServiceMetricData {
-   |        ----------------- field in this struct
-...
-53 |     exit_code: Option<i64>,
-   |     ^^^^^^^^^
-   |
-   = note: `ServiceMetricData` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
-
-warning: associated function `extract_service_name` is never used
-   --> dashboard/src/ui/widgets/backup.rs:115:8
-    |
- 58 | impl BackupWidget {
-    | ----------------- associated function in this implementation
-...
-115 |     fn extract_service_name(metric_name: &str) -> Option<String> {
-    |        ^^^^^^^^^^^^^^^^^^^^
-
-warning: method `update_from_metrics` is never used
-   --> dashboard/src/ui/widgets/backup.rs:157:8
-    |
-156 | impl BackupWidget {
-    | ----------------- method in this implementation
-157 |     fn update_from_metrics(&mut self, metrics: &[&Metric]) {
-    |        ^^^^^^^^^^^^^^^^^^^
-
-warning: associated function `extract_service_info` is never used
-  --> dashboard/src/ui/widgets/services.rs:50:8
-   |
-38 | impl ServicesWidget {
-   | ------------------- associated function in this implementation
-...
-50 |     fn extract_service_info(metric_name: &str) -> Option<(String, Option<String>)> {
-   |        ^^^^^^^^^^^^^^^^^^^^
-
-warning: method `update_from_metrics` is never used
-   --> dashboard/src/ui/widgets/services.rs:285:8
-    |
-284 | impl ServicesWidget {
-    | ------------------- method in this implementation
-285 |     fn update_from_metrics(&mut self, metrics: &[&Metric]) {
-    |        ^^^^^^^^^^^^^^^^^^^
-
-warning: field `health_status` is never read
-  --> dashboard/src/ui/widgets/system.rs:53:5
-   |
-43 | struct StoragePool {
-   |        ----------- field in this struct
-...
-53 |     health_status: Status, // Separate status for pool health vs usage
-   |     ^^^^^^^^^^^^^
-   |
-   = note: `StoragePool` has a derived impl for the trait `Clone`, but this is intentionally ignored during dead code analysis
-
-warning: `cm-dashboard` (bin "cm-dashboard") generated 7 warnings
-    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.16s
-     Running `target/debug/cm-dashboard --headless --raw-data`
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936501,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936502,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936503,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936505,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936506,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936507,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936508,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936509,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936509,
-  "system": {
-    "cpu": {
-      "load_1min": 0.0,
-      "load_5min": 0.0,
-      "load_15min": 0.0,
-      "frequency_mhz": 0.0,
-      "temperature_celsius": null
-    },
-    "memory": {
-      "usage_percent": 0.0,
-      "total_gb": 0.0,
-      "used_gb": 0.0,
-      "available_gb": 0.0,
-      "swap_total_gb": 0.0,
-      "swap_used_gb": 0.0,
-      "tmpfs": []
-    },
-    "storage": {
-      "drives": [],
-      "pools": []
-    }
-  },
-  "services": [],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936510,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936511,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936512,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-Terminated
--- a/dashboard/Cargo.toml
+++ b/dashboard/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.147"
+version = "0.1.200"
 edition = "2021"

 [dependencies]
--- a/dashboard/src/app.rs
+++ b/dashboard/src/app.rs
@@ -20,13 +20,12 @@ pub struct Dashboard {
    tui_app: Option<TuiApp>,
    terminal: Option<Terminal<CrosstermBackend<io::Stdout>>>,
    headless: bool,
-    raw_data: bool,
    initial_commands_sent: std::collections::HashSet<String>,
    config: DashboardConfig,
 }

 impl Dashboard {
-    pub async fn new(config_path: Option<String>, headless: bool, raw_data: bool) -> Result<Self> {
+    pub async fn new(config_path: Option<String>, headless: bool) -> Result<Self> {
        info!("Initializing dashboard");

        // Load configuration - try default path if not specified
@@ -120,7 +119,6 @@ impl Dashboard {
            tui_app,
            terminal,
            headless,
-            raw_data,
            initial_commands_sent: std::collections::HashSet::new(),
            config,
        })
@@ -205,13 +203,6 @@ impl Dashboard {
                            .insert(agent_data.hostname.clone());
                    }

-                    // Show raw data if requested (before processing)
-                    if self.raw_data {
-                        println!("RAW AGENT DATA FROM {}:", agent_data.hostname);
-                        println!("{}", serde_json::to_string_pretty(&agent_data).unwrap_or_else(|e| format!("Serialization error: {}", e)));
-                        println!("{}", "─".repeat(80));
-                    }
-
                    // Store structured data directly
                    self.metric_store.store_agent_data(agent_data);

@@ -224,7 +215,7 @@ impl Dashboard {

                    // Update TUI with new metrics (only if not headless)
                    if let Some(ref mut tui_app) = self.tui_app {
-                        tui_app.update_metrics(&self.metric_store);
+                        tui_app.update_metrics(&mut self.metric_store);
                    }
                }
                
--- a/dashboard/src/main.rs
+++ b/dashboard/src/main.rs
@@ -51,10 +51,6 @@ struct Cli {
    /// Run in headless mode (no TUI, just logging)
    #[arg(long)]
    headless: bool,
-
-    /// Show raw agent data in headless mode
-    #[arg(long)]
-    raw_data: bool,
 }

 #[tokio::main]
@@ -90,7 +86,7 @@ async fn main() -> Result<()> {
    }

    // Create and run dashboard
-    let mut dashboard = Dashboard::new(cli.config, cli.headless, cli.raw_data).await?;
+    let mut dashboard = Dashboard::new(cli.config, cli.headless).await?;

    // Setup graceful shutdown
    let ctrl_c = async {
--- a/dashboard/src/metrics/store.rs
+++ b/dashboard/src/metrics/store.rs
@@ -5,6 +5,14 @@ use tracing::{debug, info, warn};

 use super::MetricDataPoint;

+/// ZMQ communication statistics per host
+#[derive(Debug, Clone)]
+pub struct ZmqStats {
+    pub packets_received: u64,
+    pub last_packet_time: Instant,
+    pub last_packet_age_secs: f64,
+}
+
 /// Central metric storage for the dashboard
 pub struct MetricStore {
    /// Current structured data: hostname -> AgentData
@@ -13,6 +21,8 @@ pub struct MetricStore {
    historical_metrics: HashMap<String, Vec<MetricDataPoint>>,
    /// Last heartbeat timestamp per host
    last_heartbeat: HashMap<String, Instant>,
+    /// ZMQ communication statistics per host
+    zmq_stats: HashMap<String, ZmqStats>,
    /// Configuration
    max_metrics_per_host: usize,
    history_retention: Duration,
@@ -24,6 +34,7 @@ impl MetricStore {
            current_agent_data: HashMap::new(),
            historical_metrics: HashMap::new(),
            last_heartbeat: HashMap::new(),
+            zmq_stats: HashMap::new(),
            max_metrics_per_host,
            history_retention: Duration::from_secs(history_retention_hours * 3600),
        }
@@ -44,6 +55,16 @@ impl MetricStore {
        self.last_heartbeat.insert(hostname.clone(), now);
        debug!("Updated heartbeat for host {}", hostname);

+        // Update ZMQ stats
+        let stats = self.zmq_stats.entry(hostname.clone()).or_insert(ZmqStats {
+            packets_received: 0,
+            last_packet_time: now,
+            last_packet_age_secs: 0.0,
+        });
+        stats.packets_received += 1;
+        stats.last_packet_time = now;
+        stats.last_packet_age_secs = 0.0; // Just received
+
        // Add to history
        let host_history = self
            .historical_metrics
@@ -65,6 +86,15 @@ impl MetricStore {
        self.current_agent_data.get(hostname)
    }

+    /// Get ZMQ communication statistics for a host
+    pub fn get_zmq_stats(&mut self, hostname: &str) -> Option<ZmqStats> {
+        let now = Instant::now();
+        self.zmq_stats.get_mut(hostname).map(|stats| {
+            // Update packet age
+            stats.last_packet_age_secs = now.duration_since(stats.last_packet_time).as_secs_f64();
+            stats.clone()
+        })
+    }

    /// Get connected hosts (hosts with recent heartbeats)
    pub fn get_connected_hosts(&self, timeout: Duration) -> Vec<String> {
--- a/dashboard/src/ui/mod.rs
+++ b/dashboard/src/ui/mod.rs
@@ -18,7 +18,7 @@ use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
 use cm_dashboard_shared::Status;
 use theme::{Components, Layout as ThemeLayout, Theme, Typography};
-use widgets::{BackupWidget, ServicesWidget, SystemWidget, Widget};
+use widgets::{ServicesWidget, SystemWidget, Widget};



@@ -32,8 +32,6 @@ pub struct HostWidgets {
    pub system_widget: SystemWidget,
    /// Services widget state
    pub services_widget: ServicesWidget,
-    /// Backup widget state
-    pub backup_widget: BackupWidget,
    /// Last update time for this host
    pub last_update: Option<Instant>,
 }
@@ -43,7 +41,6 @@ impl HostWidgets {
        Self {
            system_widget: SystemWidget::new(),
            services_widget: ServicesWidget::new(),
-            backup_widget: BackupWidget::new(),
            last_update: None,
        }
    }
@@ -103,7 +100,7 @@ impl TuiApp {
    }

    /// Update widgets with structured data from store (only for current host)
-    pub fn update_metrics(&mut self, metric_store: &MetricStore) {
+    pub fn update_metrics(&mut self, metric_store: &mut MetricStore) {
        if let Some(hostname) = self.current_host.clone() {
            // Get structured data for this host
            if let Some(agent_data) = metric_store.get_agent_data(&hostname) {
@@ -112,7 +109,14 @@ impl TuiApp {
                // Update all widgets with structured data directly
                host_widgets.system_widget.update_from_agent_data(agent_data);
                host_widgets.services_widget.update_from_agent_data(agent_data);
-                host_widgets.backup_widget.update_from_agent_data(agent_data);
+
+                // Update ZMQ stats
+                if let Some(zmq_stats) = metric_store.get_zmq_stats(&hostname) {
+                    host_widgets.system_widget.update_zmq_stats(
+                        zmq_stats.packets_received,
+                        zmq_stats.last_packet_age_secs
+                    );
+                }

                host_widgets.last_update = Some(Instant::now());
            }
@@ -469,40 +473,17 @@ impl TuiApp {
            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);
-            host_widgets.backup_widget.has_data()
-        } else {
-            false
-        };
-
-        // Left side: dynamic layout based on backup data availability
-        let left_chunks = if show_backup {
-            // Show both system and backup panels
-            ratatui::layout::Layout::default()
-                .direction(Direction::Vertical)
-                .constraints([
-                    Constraint::Percentage(ThemeLayout::SYSTEM_PANEL_HEIGHT), // System section
-                    Constraint::Percentage(ThemeLayout::BACKUP_PANEL_HEIGHT), // Backup section
-                ])
-                .split(content_chunks[0])
-        } else {
-            // Show only system panel (full height)
-            ratatui::layout::Layout::default()
-                .direction(Direction::Vertical)
-                .constraints([Constraint::Percentage(100)]) // System section takes full height
-                .split(content_chunks[0])
-        };
+        // Left side: system panel only (full height)
+        let left_chunks = ratatui::layout::Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Percentage(100)]) // System section takes full height
+            .split(content_chunks[0]);

        // Render title bar
        self.render_btop_title(frame, main_chunks[0], metric_store);

-        // Render new panel layout
+        // Render system panel
        self.render_system_panel(frame, left_chunks[0], metric_store);
-        if show_backup && left_chunks.len() > 1 {
-            self.render_backup_panel(frame, left_chunks[1]);
-        }

        // Render services widget for current host
        if let Some(hostname) = self.current_host.clone() {
@@ -669,17 +650,6 @@ impl TuiApp {
        }
    }

-    fn render_backup_panel(&mut self, frame: &mut Frame, area: Rect) {
-        let backup_block = Components::widget_block("backup");
-        let inner_area = backup_block.inner(area);
-        frame.render_widget(backup_block, area);
-
-        // Get current host widgets for backup widget
-        if let Some(hostname) = self.current_host.clone() {
-            let host_widgets = self.get_or_create_host_widgets(&hostname);
-            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) {
--- a/dashboard/src/ui/theme.rs
+++ b/dashboard/src/ui/theme.rs
@@ -225,9 +225,6 @@ impl Layout {
    pub const LEFT_PANEL_WIDTH: u16 = 45;
    /// Right panel percentage (services)
    pub const RIGHT_PANEL_WIDTH: u16 = 55;
-    /// System vs backup split (equal)
-    pub const SYSTEM_PANEL_HEIGHT: u16 = 50;
-    pub const BACKUP_PANEL_HEIGHT: u16 = 50;
 }

 /// Typography system
--- a/dashboard/src/ui/widgets/backup.rs
+++ b/dashboard/src/ui/widgets/backup.rs
@@ -1,418 +0,0 @@
-use cm_dashboard_shared::{Metric, Status};
-use super::Widget;
-use ratatui::{
-    layout::Rect,
-    widgets::Paragraph,
-    Frame,
-};
-use tracing::debug;
-
-use crate::ui::theme::{StatusIcons, Typography};
-
-/// Backup widget displaying backup status, services, and repository information
-#[derive(Clone)]
-pub struct BackupWidget {
-    /// Overall backup status
-    overall_status: Status,
-    /// Last backup duration in seconds
-    duration_seconds: Option<i64>,
-    /// Last backup timestamp
-    last_run_timestamp: Option<i64>,
-    /// Total repository size in GB
-    total_repo_size_gb: Option<f32>,
-    /// Total disk space for backups in GB
-    backup_disk_total_gb: Option<f32>,
-    /// Used disk space for backups in GB
-    backup_disk_used_gb: Option<f32>,
-    /// Backup disk product name from SMART data
-    backup_disk_product_name: Option<String>,
-    /// Backup disk serial number from SMART data
-    backup_disk_serial_number: Option<String>,
-    /// Backup disk wear percentage from SMART data
-    backup_disk_wear_percent: Option<f32>,
-    /// All individual service metrics for detailed display
-    service_metrics: Vec<ServiceMetricData>,
-    /// Last update indicator
-    has_data: bool,
-}
-
-#[derive(Debug, Clone)]
-struct ServiceMetricData {
-    name: String,
-    status: Status,
-    archive_count: Option<i64>,
-    repo_size_gb: Option<f32>,
-}
-
-impl BackupWidget {
-    pub fn new() -> Self {
-        Self {
-            overall_status: Status::Unknown,
-            duration_seconds: None,
-            last_run_timestamp: None,
-            total_repo_size_gb: None,
-            backup_disk_total_gb: None,
-            backup_disk_used_gb: None,
-            backup_disk_product_name: None,
-            backup_disk_serial_number: None,
-            backup_disk_wear_percent: None,
-            service_metrics: Vec::new(),
-            has_data: false,
-        }
-    }
-
-    /// Check if the backup widget has any data to display
-    pub fn has_data(&self) -> bool {
-        self.has_data
-    }
-
-
-
-
-
-    /// Format size with proper units (xxxkB/MB/GB/TB)
-    fn format_size_with_proper_units(size_gb: f32) -> String {
-        if size_gb >= 1000.0 {
-            // TB range
-            format!("{:.1}TB", size_gb / 1000.0)
-        } else if size_gb >= 1.0 {
-            // GB range
-            format!("{:.1}GB", size_gb)
-        } else if size_gb >= 0.001 {
-            // MB range (size_gb * 1024 = MB)
-            let size_mb = size_gb * 1024.0;
-            format!("{:.1}MB", size_mb)
-        } else if size_gb >= 0.000001 {
-            // kB range (size_gb * 1024 * 1024 = kB)
-            let size_kb = size_gb * 1024.0 * 1024.0;
-            format!("{:.0}kB", size_kb)
-        } else {
-            // B range (size_gb * 1024^3 = bytes)
-            let size_bytes = size_gb * 1024.0 * 1024.0 * 1024.0;
-            format!("{:.0}B", size_bytes)
-        }
-    }
-
-
-
-    /// Extract service name from metric name (e.g., "backup_service_gitea_status" -> "gitea")
-    #[allow(dead_code)]
-    fn extract_service_name(metric_name: &str) -> Option<String> {
-        if metric_name.starts_with("backup_service_") {
-            let name_part = &metric_name[15..]; // Remove "backup_service_" prefix
-
-            // Try to extract service name by removing known suffixes
-            if let Some(service_name) = name_part.strip_suffix("_status") {
-                Some(service_name.to_string())
-            } else if let Some(service_name) = name_part.strip_suffix("_archive_count") {
-                Some(service_name.to_string())
-            } else if let Some(service_name) = name_part.strip_suffix("_repo_size_gb") {
-                Some(service_name.to_string())
-            } else if let Some(service_name) = name_part.strip_suffix("_repo_path") {
-                Some(service_name.to_string())
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-}
-
-impl Widget for BackupWidget {
-    fn update_from_agent_data(&mut self, agent_data: &cm_dashboard_shared::AgentData) {
-        self.has_data = true;
-        
-        let backup = &agent_data.backup;
-        self.overall_status = Status::Ok;
-        
-        if let Some(size) = backup.total_size_gb {
-            self.total_repo_size_gb = Some(size);
-        }
-        
-        if let Some(last_run) = backup.last_run {
-            self.last_run_timestamp = Some(last_run as i64);
-        }
-    }
-}
-
-impl BackupWidget {
-    #[allow(dead_code)]
-    fn update_from_metrics(&mut self, metrics: &[&Metric]) {
-        debug!("Backup widget updating with {} metrics", metrics.len());
-        for metric in metrics {
-            debug!(
-                "Backup metric: {} = {:?} (status: {:?})",
-                metric.name, metric.value, metric.status
-            );
-        }
-
-        // Also debug the service_data after processing
-        debug!("Processing individual service metrics...");
-
-        // Log how many metrics are backup service metrics
-        let service_metric_count = metrics
-            .iter()
-            .filter(|m| m.name.starts_with("backup_service_"))
-            .count();
-        debug!(
-            "Found {} backup_service_ metrics out of {} total backup metrics",
-            service_metric_count,
-            metrics.len()
-        );
-
-        // Reset service metrics
-        self.service_metrics.clear();
-        let mut service_data: std::collections::HashMap<String, ServiceMetricData> =
-            std::collections::HashMap::new();
-
-        for metric in metrics {
-            match metric.name.as_str() {
-                "backup_overall_status" => {
-                    let status_str = metric.value.as_string();
-                    self.overall_status = match status_str.as_str() {
-                        "ok" => Status::Ok,
-                        "warning" => Status::Warning,
-                        "critical" => Status::Critical,
-                        _ => Status::Unknown,
-                    };
-                }
-                "backup_duration_seconds" => {
-                    self.duration_seconds = metric.value.as_i64();
-                }
-                "backup_last_run_timestamp" => {
-                    self.last_run_timestamp = metric.value.as_i64();
-                }
-                "backup_total_repo_size_gb" => {
-                    self.total_repo_size_gb = metric.value.as_f32();
-                }
-                "backup_disk_total_gb" => {
-                    self.backup_disk_total_gb = metric.value.as_f32();
-                }
-                "backup_disk_used_gb" => {
-                    self.backup_disk_used_gb = metric.value.as_f32();
-                }
-                "backup_disk_product_name" => {
-                    self.backup_disk_product_name = Some(metric.value.as_string());
-                }
-                "backup_disk_serial_number" => {
-                    self.backup_disk_serial_number = Some(metric.value.as_string());
-                }
-                "backup_disk_wear_percent" => {
-                    self.backup_disk_wear_percent = metric.value.as_f32();
-                }
-                _ => {
-                    // Handle individual service metrics
-                    if let Some(service_name) = Self::extract_service_name(&metric.name) {
-                        debug!(
-                            "Extracted service name '{}' from metric '{}'",
-                            service_name, metric.name
-                        );
-                        let entry = service_data.entry(service_name.clone()).or_insert_with(|| {
-                            ServiceMetricData {
-                                name: service_name,
-                                status: Status::Unknown,
-                                    archive_count: None,
-                                repo_size_gb: None,
-                            }
-                        });
-
-                        if metric.name.ends_with("_status") {
-                            entry.status = metric.status;
-                            debug!("Set status for {}: {:?}", entry.name, entry.status);
-                        } else if metric.name.ends_with("_archive_count") {
-                            entry.archive_count = metric.value.as_i64();
-                            debug!(
-                                "Set archive_count for {}: {:?}",
-                                entry.name, entry.archive_count
-                            );
-                        } else if metric.name.ends_with("_repo_size_gb") {
-                            entry.repo_size_gb = metric.value.as_f32();
-                            debug!(
-                                "Set repo_size_gb for {}: {:?}",
-                                entry.name, entry.repo_size_gb
-                            );
-                        }
-                    } else {
-                        debug!(
-                            "Could not extract service name from metric: {}",
-                            metric.name
-                        );
-                    }
-                }
-            }
-        }
-
-        // Convert service data to sorted vector
-        let mut services: Vec<ServiceMetricData> = service_data.into_values().collect();
-        services.sort_by(|a, b| a.name.cmp(&b.name));
-        self.service_metrics = services;
-
-        // Only show backup panel if we have meaningful backup data
-        self.has_data = !metrics.is_empty() && (
-            self.last_run_timestamp.is_some() ||
-            self.total_repo_size_gb.is_some() ||
-            !self.service_metrics.is_empty()
-        );
-
-        debug!(
-            "Backup widget updated: status={:?}, services={}, total_size={:?}GB",
-            self.overall_status,
-            self.service_metrics.len(),
-            self.total_repo_size_gb
-        );
-
-        // Debug individual service data
-        for service in &self.service_metrics {
-            debug!(
-                "Service {}: status={:?}, archives={:?}, size={:?}GB",
-                service.name, service.status, service.archive_count, service.repo_size_gb
-            );
-        }
-    }
-
-}
-
-impl BackupWidget {
-    /// Render backup widget
-    pub fn render(&mut self, frame: &mut Frame, area: Rect) {
-        let mut lines = Vec::new();
-
-        // Latest backup section
-        lines.push(ratatui::text::Line::from(vec![
-            ratatui::text::Span::styled("Latest backup:", Typography::widget_title())
-        ]));
-        
-        // Timestamp with status icon
-        let timestamp_text = if let Some(timestamp) = self.last_run_timestamp {
-            self.format_timestamp(timestamp)
-        } else {
-            "Unknown".to_string()
-        };
-        let timestamp_spans = StatusIcons::create_status_spans(
-            self.overall_status,
-            &timestamp_text
-        );
-        lines.push(ratatui::text::Line::from(timestamp_spans));
-
-        // Duration as sub-item
-        if let Some(duration) = self.duration_seconds {
-            let duration_text = self.format_duration(duration);
-            lines.push(ratatui::text::Line::from(vec![
-                ratatui::text::Span::styled("  └─ ", Typography::tree()),
-                ratatui::text::Span::styled(format!("Duration: {}", duration_text), Typography::secondary())
-            ]));
-        }
-
-        // Disk section
-        lines.push(ratatui::text::Line::from(vec![
-            ratatui::text::Span::styled("Disk:", Typography::widget_title())
-        ]));
-
-        // Disk product name with status
-        if let Some(product) = &self.backup_disk_product_name {
-            let disk_spans = StatusIcons::create_status_spans(
-                Status::Ok, // Assuming disk is OK if we have data
-                product
-            );
-            lines.push(ratatui::text::Line::from(disk_spans));
-
-            // Collect sub-items to determine tree structure
-            let mut sub_items = Vec::new();
-            
-            if let Some(serial) = &self.backup_disk_serial_number {
-                sub_items.push(format!("S/N: {}", serial));
-            }
-            
-            if let Some(wear) = self.backup_disk_wear_percent {
-                sub_items.push(format!("Wear: {:.0}%", wear));
-            }
-            
-            if let (Some(used), Some(total)) = (self.backup_disk_used_gb, self.backup_disk_total_gb) {
-                let used_str = Self::format_size_with_proper_units(used);
-                let total_str = Self::format_size_with_proper_units(total);
-                sub_items.push(format!("Usage: {}/{}", used_str, total_str));
-            }
-            
-            // Render sub-items with proper tree structure
-            let num_items = sub_items.len();
-            for (i, item) in sub_items.into_iter().enumerate() {
-                let is_last = i == num_items - 1;
-                let tree_char = if is_last { "  └─ " } else { "  ├─ " };
-                lines.push(ratatui::text::Line::from(vec![
-                    ratatui::text::Span::styled(tree_char, Typography::tree()),
-                    ratatui::text::Span::styled(item, Typography::secondary())
-                ]));
-            }
-        }
-
-        // Repos section
-        lines.push(ratatui::text::Line::from(vec![
-            ratatui::text::Span::styled("Repos:", Typography::widget_title())
-        ]));
-
-        // Add all repository lines (no truncation here - scroll will handle display)
-        for service in &self.service_metrics {
-            if let (Some(archives), Some(size_gb)) = (service.archive_count, service.repo_size_gb) {
-                let size_str = Self::format_size_with_proper_units(size_gb);
-                let repo_text = format!("{} ({}) {}", service.name, archives, size_str);
-                let repo_spans = StatusIcons::create_status_spans(service.status, &repo_text);
-                lines.push(ratatui::text::Line::from(repo_spans));
-            }
-        }
-
-        // Apply scroll offset
-        let total_lines = lines.len();
-        let available_height = area.height as usize;
-        
-        // Show only what fits, with "X more below" if needed
-        if total_lines > available_height {
-            let lines_for_content = available_height.saturating_sub(1); // Reserve one line for "more below"
-            let mut visible_lines: Vec<_> = lines
-                .into_iter()
-                .take(lines_for_content)
-                .collect();
-            
-            let hidden_below = total_lines.saturating_sub(lines_for_content);
-            if hidden_below > 0 {
-                let more_line = ratatui::text::Line::from(vec![
-                    ratatui::text::Span::styled(format!("... {} more below", hidden_below), Typography::muted())
-                ]);
-                visible_lines.push(more_line);
-            }
-            
-            let paragraph = Paragraph::new(ratatui::text::Text::from(visible_lines));
-            frame.render_widget(paragraph, area);
-        } else {
-            let paragraph = Paragraph::new(ratatui::text::Text::from(lines));
-            frame.render_widget(paragraph, area);
-        }
-    }
-}
-
-impl BackupWidget {
-    /// Format timestamp for display
-    fn format_timestamp(&self, timestamp: i64) -> String {
-        let datetime = chrono::DateTime::from_timestamp(timestamp, 0)
-            .unwrap_or_else(|| chrono::Utc::now());
-        datetime.format("%Y-%m-%d %H:%M:%S").to_string()
-    }
-
-    /// Format duration in seconds to human readable format
-    fn format_duration(&self, duration_seconds: i64) -> String {
-        let minutes = duration_seconds / 60;
-        let seconds = duration_seconds % 60;
-        
-        if minutes > 0 {
-            format!("{}.{}m", minutes, seconds / 6) // Show 1 decimal for minutes
-        } else {
-            format!("{}s", seconds)
-        }
-    }
-}
-
-impl Default for BackupWidget {
-    fn default() -> Self {
-        Self::new()
-    }
-}
--- a/dashboard/src/ui/widgets/cpu.rs
+++ b/dashboard/src/ui/widgets/cpu.rs
@@ -1 +0,0 @@
-// This file is intentionally left minimal - CPU functionality is handled by the SystemWidget
--- a/dashboard/src/ui/widgets/memory.rs
+++ b/dashboard/src/ui/widgets/memory.rs
@@ -1 +0,0 @@
-// This file is intentionally left minimal - Memory functionality is handled by the SystemWidget
--- a/dashboard/src/ui/widgets/mod.rs
+++ b/dashboard/src/ui/widgets/mod.rs
@@ -1,12 +1,8 @@
 use cm_dashboard_shared::AgentData;

-pub mod backup;
-pub mod cpu;
-pub mod memory;
 pub mod services;
 pub mod system;

-pub use backup::BackupWidget;
 pub use services::ServicesWidget;
 pub use system::SystemWidget;

--- a/dashboard/src/ui/widgets/services.rs
+++ b/dashboard/src/ui/widgets/services.rs
@@ -32,6 +32,7 @@ struct ServiceInfo {
    disk_gb: Option<f32>,
    metrics: Vec<(String, f32, Option<String>)>, // (label, value, unit)
    widget_status: Status,
+    service_type: String, // "nginx_site", "container", "image", or empty for parent services
 }

 impl ServicesWidget {
@@ -169,7 +170,7 @@ impl ServicesWidget {
            // Convert Status enum to display text for sub-services
            match info.widget_status {
                Status::Ok => "active",
-                Status::Inactive => "inactive", 
+                Status::Inactive => "inactive",
                Status::Critical => "failed",
                Status::Pending => "pending",
                Status::Warning => "warning",
@@ -179,32 +180,62 @@ impl ServicesWidget {
        };
        let tree_symbol = if is_last { "└─" } else { "├─" };

-        vec![
-            // Indentation and tree prefix
-            ratatui::text::Span::styled(
-                format!("  {} ", tree_symbol),
-                Typography::tree(),
-            ),
-            // Status icon
-            ratatui::text::Span::styled(
-                format!("{} ", icon),
-                Style::default().fg(status_color).bg(Theme::background()),
-            ),
-            // Service name
-            ratatui::text::Span::styled(
-                format!("{:<18} ", short_name),
-                Style::default()
-                    .fg(Theme::secondary_text())
-                    .bg(Theme::background()),
-            ),
-            // Status/latency text
-            ratatui::text::Span::styled(
-                status_str,
-                Style::default()
-                    .fg(Theme::secondary_text())
-                    .bg(Theme::background()),
-            ),
-        ]
+        // Docker images use docker whale icon
+        if info.service_type == "image" {
+            vec![
+                // Indentation and tree prefix
+                ratatui::text::Span::styled(
+                    format!("  {} ", tree_symbol),
+                    Typography::tree(),
+                ),
+                // Docker icon (simple character for performance)
+                ratatui::text::Span::styled(
+                    "D ".to_string(),
+                    Style::default().fg(Theme::highlight()).bg(Theme::background()),
+                ),
+                // Service name
+                ratatui::text::Span::styled(
+                    format!("{:<18} ", short_name),
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+                // Status/metrics text
+                ratatui::text::Span::styled(
+                    status_str,
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+            ]
+        } else {
+            vec![
+                // Indentation and tree prefix
+                ratatui::text::Span::styled(
+                    format!("  {} ", tree_symbol),
+                    Typography::tree(),
+                ),
+                // Status icon
+                ratatui::text::Span::styled(
+                    format!("{} ", icon),
+                    Style::default().fg(status_color).bg(Theme::background()),
+                ),
+                // Service name
+                ratatui::text::Span::styled(
+                    format!("{:<18} ", short_name),
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+                // Status/latency text
+                ratatui::text::Span::styled(
+                    status_str,
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+            ]
+        }
    }

    /// Move selection up
@@ -282,9 +313,10 @@ impl Widget for ServicesWidget {
                disk_gb: Some(service.disk_gb),
                metrics: Vec::new(), // Parent services don't have custom metrics
                widget_status: service.service_status,
+                service_type: String::new(), // Parent services have no type
            };
            self.parent_services.insert(service.name.clone(), parent_info);
-            
+
            // Process sub-services if any
            if !service.sub_services.is_empty() {
                let mut sub_list = Vec::new();
@@ -293,12 +325,13 @@ impl Widget for ServicesWidget {
                    let metrics: Vec<(String, f32, Option<String>)> = sub_service.metrics.iter()
                        .map(|m| (m.label.clone(), m.value, m.unit.clone()))
                        .collect();
-                    
+
                    let sub_info = ServiceInfo {
                        memory_mb: None, // Not used for sub-services
                        disk_gb: None,   // Not used for sub-services
                        metrics,
                        widget_status: sub_service.service_status,
+                        service_type: sub_service.service_type.clone(),
                    };
                    sub_list.push((sub_service.name.clone(), sub_info));
                }
@@ -342,6 +375,7 @@ impl ServicesWidget {
                                    disk_gb: None,
                                    metrics: Vec::new(),
                                    widget_status: Status::Unknown,
+                                    service_type: String::new(),
                                });

                        if metric.name.ends_with("_status") {
@@ -377,6 +411,7 @@ impl ServicesWidget {
                                    disk_gb: None,
                                    metrics: Vec::new(),
                                    widget_status: Status::Unknown,
+                                    service_type: String::new(), // Unknown type in legacy path
                                },
                            ));
                            &mut sub_service_list.last_mut().unwrap().1
--- a/dashboard/src/ui/widgets/system.rs
+++ b/dashboard/src/ui/widgets/system.rs
@@ -8,13 +8,20 @@ use ratatui::{

 use crate::ui::theme::{StatusIcons, Typography};

-/// System widget displaying NixOS info, CPU, RAM, and Storage in unified layout
+/// System widget displaying NixOS info, Network, CPU, RAM, and Storage in unified layout
 #[derive(Clone)]
 pub struct SystemWidget {
    // NixOS information
    nixos_build: Option<String>,
    agent_hash: Option<String>,
-    
+
+    // ZMQ communication stats
+    zmq_packets_received: Option<u64>,
+    zmq_last_packet_age: Option<f64>,
+
+    // Network interfaces
+    network_interfaces: Vec<cm_dashboard_shared::NetworkInterfaceData>,
+
    // CPU metrics
    cpu_load_1min: Option<f32>,
    cpu_load_5min: Option<f32>,
@@ -37,6 +44,17 @@ pub struct SystemWidget {
    // Storage metrics (collected from disk metrics)
    storage_pools: Vec<StoragePool>,
    
+    // Backup metrics
+    backup_status: String,
+    backup_start_time_raw: Option<String>,
+    backup_disk_serial: Option<String>,
+    backup_disk_usage_percent: Option<f32>,
+    backup_disk_used_gb: Option<f32>,
+    backup_disk_total_gb: Option<f32>,
+    backup_disk_wear_percent: Option<f32>,
+    backup_disk_temperature: Option<f32>,
+    backup_last_size_gb: Option<f32>,
+    
    // Overall status
    has_data: bool,
 }
@@ -46,7 +64,9 @@ struct StoragePool {
    name: String,
    mount_point: String,
    pool_type: String, // "single", "mergerfs (2+1)", "RAID5 (3+1)", etc.
-    drives: Vec<StorageDrive>,
+    drives: Vec<StorageDrive>, // For physical drives
+    data_drives: Vec<StorageDrive>, // For MergerFS pools
+    parity_drives: Vec<StorageDrive>, // For MergerFS pools
    filesystems: Vec<FileSystem>, // For physical drive pools: individual filesystem children
    usage_percent: Option<f32>,
    used_gb: Option<f32>,
@@ -76,6 +96,9 @@ impl SystemWidget {
        Self {
            nixos_build: None,
            agent_hash: None,
+            zmq_packets_received: None,
+            zmq_last_packet_age: None,
+            network_interfaces: Vec::new(),
            cpu_load_1min: None,
            cpu_load_5min: None,
            cpu_load_15min: None,
@@ -91,6 +114,15 @@ impl SystemWidget {
            tmp_status: Status::Unknown,
            tmpfs_mounts: Vec::new(),
            storage_pools: Vec::new(),
+            backup_status: "unknown".to_string(),
+            backup_start_time_raw: None,
+            backup_disk_serial: None,
+            backup_disk_usage_percent: None,
+            backup_disk_used_gb: None,
+            backup_disk_total_gb: None,
+            backup_disk_wear_percent: None,
+            backup_disk_temperature: None,
+            backup_last_size_gb: None,
            has_data: false,
        }
    }
@@ -128,6 +160,12 @@ impl SystemWidget {
    pub fn _get_agent_hash(&self) -> Option<&String> {
        self.agent_hash.as_ref()
    }
+
+    /// Update ZMQ communication statistics
+    pub fn update_zmq_stats(&mut self, packets_received: u64, last_packet_age_secs: f64) {
+        self.zmq_packets_received = Some(packets_received);
+        self.zmq_last_packet_age = Some(last_packet_age_secs);
+    }
 }

 use super::Widget;
@@ -142,6 +180,9 @@ impl Widget for SystemWidget {
        // Extract build version
        self.nixos_build = agent_data.build_version.clone();

+        // Extract network interfaces
+        self.network_interfaces = agent_data.system.network.interfaces.clone();
+
        // Extract CPU data directly
        let cpu = &agent_data.system.cpu;
        self.cpu_load_1min = Some(cpu.load_1min);
@@ -170,6 +211,28 @@ impl Widget for SystemWidget {

        // Convert storage data to internal format
        self.update_storage_from_agent_data(agent_data);
+
+        // Extract backup data
+        let backup = &agent_data.backup;
+        self.backup_status = backup.status.clone();
+        self.backup_start_time_raw = backup.start_time_raw.clone();
+        self.backup_last_size_gb = backup.last_backup_size_gb;
+
+        if let Some(disk) = &backup.repository_disk {
+            self.backup_disk_serial = Some(disk.serial.clone());
+            self.backup_disk_usage_percent = Some(disk.usage_percent);
+            self.backup_disk_used_gb = Some(disk.used_gb);
+            self.backup_disk_total_gb = Some(disk.total_gb);
+            self.backup_disk_wear_percent = disk.wear_percent;
+            self.backup_disk_temperature = disk.temperature_celsius;
+        } else {
+            self.backup_disk_serial = None;
+            self.backup_disk_usage_percent = None;
+            self.backup_disk_used_gb = None;
+            self.backup_disk_total_gb = None;
+            self.backup_disk_wear_percent = None;
+            self.backup_disk_temperature = None;
+        }
    }
 }

@@ -185,6 +248,8 @@ impl SystemWidget {
                mount_point: drive.name.clone(),
                pool_type: "drive".to_string(),
                drives: Vec::new(),
+                data_drives: Vec::new(),
+                parity_drives: Vec::new(),
                filesystems: Vec::new(),
                usage_percent: None,
                used_gb: None,
@@ -193,8 +258,11 @@ impl SystemWidget {
            };

            // Add drive info
+            let display_name = drive.serial_number.as_ref()
+                .map(|s| truncate_serial(s))
+                .unwrap_or(drive.name.clone());
            let storage_drive = StorageDrive {
-                name: drive.name.clone(),
+                name: display_name,
                temperature: drive.temperature_celsius,
                wear_percent: drive.wear_percent,
                status: Status::Ok,
@@ -225,7 +293,85 @@ impl SystemWidget {
            pools.insert(drive.name.clone(), pool);
        }

-        // Convert pools
+        // Convert pools (MergerFS, RAID, etc.)
+        for pool in &agent_data.system.storage.pools {
+            // Use agent-calculated status (combined health and usage status)
+            let pool_status = if pool.health_status == Status::Critical || pool.usage_status == Status::Critical {
+                Status::Critical
+            } else if pool.health_status == Status::Warning || pool.usage_status == Status::Warning {
+                Status::Warning
+            } else if pool.health_status == Status::Ok && pool.usage_status == Status::Ok {
+                Status::Ok
+            } else {
+                Status::Unknown
+            };
+            
+            let mut storage_pool = StoragePool {
+                name: pool.name.clone(),
+                mount_point: pool.mount.clone(),
+                pool_type: pool.pool_type.clone(),
+                drives: Vec::new(),
+                data_drives: Vec::new(),
+                parity_drives: Vec::new(),
+                filesystems: Vec::new(),
+                usage_percent: Some(pool.usage_percent),
+                used_gb: Some(pool.used_gb),
+                total_gb: Some(pool.total_gb),
+                status: pool_status,
+            };
+
+            // Add data drives - use agent-calculated status
+            for drive in &pool.data_drives {
+                // Use combined health and temperature status
+                let drive_status = if drive.health_status == Status::Critical || drive.temperature_status == Status::Critical {
+                    Status::Critical
+                } else if drive.health_status == Status::Warning || drive.temperature_status == Status::Warning {
+                    Status::Warning
+                } else if drive.health_status == Status::Ok && drive.temperature_status == Status::Ok {
+                    Status::Ok
+                } else {
+                    Status::Unknown
+                };
+
+                let display_name = drive.serial_number.as_ref()
+                    .map(|s| truncate_serial(s))
+                    .unwrap_or(drive.name.clone());
+                let storage_drive = StorageDrive {
+                    name: display_name,
+                    temperature: drive.temperature_celsius,
+                    wear_percent: drive.wear_percent,
+                    status: drive_status,
+                };
+                storage_pool.data_drives.push(storage_drive);
+            }
+
+            // Add parity drives - use agent-calculated status
+            for drive in &pool.parity_drives {
+                // Use combined health and temperature status
+                let drive_status = if drive.health_status == Status::Critical || drive.temperature_status == Status::Critical {
+                    Status::Critical
+                } else if drive.health_status == Status::Warning || drive.temperature_status == Status::Warning {
+                    Status::Warning
+                } else if drive.health_status == Status::Ok && drive.temperature_status == Status::Ok {
+                    Status::Ok
+                } else {
+                    Status::Unknown
+                };
+
+                let display_name = drive.serial_number.as_ref()
+                    .map(|s| truncate_serial(s))
+                    .unwrap_or(drive.name.clone());
+                let storage_drive = StorageDrive {
+                    name: display_name,
+                    temperature: drive.temperature_celsius,
+                    wear_percent: drive.wear_percent,
+                    status: drive_status,
+                };
+                storage_pool.parity_drives.push(storage_drive);
+            }
+
+            pools.insert(pool.name.clone(), storage_pool);
+        }

        // Store pools
        let mut pool_list: Vec<StoragePool> = pools.into_values().collect();
@@ -241,12 +387,8 @@ impl SystemWidget {
            // Pool header line with type and health
            let pool_label = if pool.pool_type == "drive" {
                // For physical drives, show the drive name with temperature and wear percentage if available
-                // Look for any drive with temp/wear data (physical drives may have drives named after the pool)
-                let drive_info = pool.drives.iter()
-                    .find(|d| d.name == pool.name)
-                    .or_else(|| pool.drives.first());
-
-                if let Some(drive) = drive_info {
+                // Physical drives only have one drive entry
+                if let Some(drive) = pool.drives.first() {
                    let mut drive_details = Vec::new();
                    if let Some(temp) = drive.temperature {
                        drive_details.push(format!("T: {}°C", temp as i32));
@@ -254,18 +396,18 @@ impl SystemWidget {
                    if let Some(wear) = drive.wear_percent {
                        drive_details.push(format!("W: {}%", wear as i32));
                    }
-                    
+
                    if !drive_details.is_empty() {
-                        format!("{} {}", pool.name, drive_details.join(" "))
+                        format!("{} {}", drive.name, drive_details.join(" "))
                    } else {
-                        pool.name.clone()
+                        drive.name.clone()
                    }
                } else {
                    pool.name.clone()
                }
            } else {
-                // For mergerfs pools, show pool name with format
-                format!("{} ({})", pool.mount_point, pool.pool_type)
+                // For mergerfs pools, show pool type with mount point
+                format!("mergerfs {}:", pool.mount_point)
            };

            let pool_spans = StatusIcons::create_status_spans(pool.status.clone(), &pool_label);
@@ -294,28 +436,78 @@ impl SystemWidget {
                    lines.push(Line::from(fs_spans));
                }
            } else {
-                // For mergerfs pools, show data drives and parity drives in tree structure
-                if !pool.drives.is_empty() {
-                    // Group drives by type based on naming conventions or show all as data drives
-                    let (data_drives, parity_drives): (Vec<_>, Vec<_>) = pool.drives.iter()
-                        .partition(|d| !d.name.contains("parity") && !d.name.starts_with("sdc"));
+                // For mergerfs pools, show structure matching CLAUDE.md format:
+                // ● mergerfs (2+1):
+                //   ├─ Total: ● 63% 2355.2GB/3686.4GB
+                //   ├─ Data Disks:
+                //   │  ├─ ● sdb T: 24°C W: 5%
+                //   │  └─ ● sdd T: 27°C W: 5%
+                //   ├─ Parity: ● sdc T: 24°C W: 5%
+                //   └─ Mount: /srv/media
+                
+                // Pool total usage
+                let total_text = format!("{:.0}% {:.1}GB/{:.1}GB",
+                    pool.usage_percent.unwrap_or(0.0),
+                    pool.used_gb.unwrap_or(0.0),
+                    pool.total_gb.unwrap_or(0.0)
+                );
+                let mut total_spans = vec![
+                    Span::styled("  ├─ ", Typography::tree()),
+                ];
+                total_spans.extend(StatusIcons::create_status_spans(Status::Ok, &total_text));
+                lines.push(Line::from(total_spans));

-                    if !data_drives.is_empty() {
-                        lines.push(Line::from(vec![
-                            Span::styled("  ├─ Data Disks:", Typography::secondary())
-                        ]));
-                        for (i, drive) in data_drives.iter().enumerate() {
-                            render_pool_drive(drive, i == data_drives.len() - 1 && parity_drives.is_empty(), &mut lines);
-                        }
+                // Data drives - at same level as parity
+                let has_parity = !pool.parity_drives.is_empty();
+                for (i, drive) in pool.data_drives.iter().enumerate() {
+                    let is_last_data = i == pool.data_drives.len() - 1;
+                    let mut drive_details = Vec::new();
+                    if let Some(temp) = drive.temperature {
+                        drive_details.push(format!("T: {}°C", temp as i32));
+                    }
+                    if let Some(wear) = drive.wear_percent {
+                        drive_details.push(format!("W: {}%", wear as i32));
                    }

-                    if !parity_drives.is_empty() {
-                        lines.push(Line::from(vec![
-                            Span::styled("  └─ Parity:", Typography::secondary())
-                        ]));
-                        for (i, drive) in parity_drives.iter().enumerate() {
-                            render_pool_drive(drive, i == parity_drives.len() - 1, &mut lines);
+                    let drive_text = if !drive_details.is_empty() {
+                        format!("Data_{}: {} {}", i + 1, drive.name, drive_details.join(" "))
+                    } else {
+                        format!("Data_{}: {}", i + 1, drive.name)
+                    };
+
+                    // Last data drive uses └─ if there's no parity, otherwise ├─
+                    let tree_symbol = if is_last_data && !has_parity { "  └─ " } else { "  ├─ " };
+                    let mut data_spans = vec![
+                        Span::styled(tree_symbol, Typography::tree()),
+                    ];
+                    data_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                    lines.push(Line::from(data_spans));
+                }
+
+                // Parity drives - last item(s)
+                if !pool.parity_drives.is_empty() {
+                    for (i, drive) in pool.parity_drives.iter().enumerate() {
+                        let is_last = i == pool.parity_drives.len() - 1;
+                        let mut drive_details = Vec::new();
+                        if let Some(temp) = drive.temperature {
+                            drive_details.push(format!("T: {}°C", temp as i32));
                        }
+                        if let Some(wear) = drive.wear_percent {
+                            drive_details.push(format!("W: {}%", wear as i32));
+                        }
+
+                        let drive_text = if !drive_details.is_empty() {
+                            format!("Parity: {} {}", drive.name, drive_details.join(" "))
+                        } else {
+                            format!("Parity: {}", drive.name)
+                        };
+
+                        let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+                        let mut parity_spans = vec![
+                            Span::styled(tree_symbol, Typography::tree()),
+                        ];
+                        parity_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                        lines.push(Line::from(parity_spans));
                    }
                }
            }
@@ -325,35 +517,280 @@ impl SystemWidget {
    }
 }

-/// Helper function to render a drive in a storage pool
-fn render_pool_drive(drive: &StorageDrive, is_last: bool, lines: &mut Vec<Line<'_>>) {
-    let tree_symbol = if is_last { "    └─" } else { "    ├─" };
-    
-    let mut drive_details = Vec::new();
-    if let Some(temp) = drive.temperature {
-        drive_details.push(format!("T: {}°C", temp as i32));
-    }
-    if let Some(wear) = drive.wear_percent {
-        drive_details.push(format!("W: {}%", wear as i32));
-    }
-    
-    let drive_text = if !drive_details.is_empty() {
-        format!("● {} {}", drive.name, drive_details.join(" "))
+/// Truncate serial number to last 8 characters
+fn truncate_serial(serial: &str) -> String {
+    let len = serial.len();
+    if len > 8 {
+        serial[len - 8..].to_string()
    } else {
-        format!("● {}", drive.name)
-    };
-    
-    let mut drive_spans = vec![
-        Span::styled(tree_symbol, Typography::tree()),
-        Span::raw(" "),
-    ];
-    drive_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
-    lines.push(Line::from(drive_spans));
+        serial.to_string()
+    }
 }

 impl SystemWidget {
-    /// Render system widget  
-    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, config: Option<&crate::config::DashboardConfig>) {
+    /// Render backup section for display
+    fn render_backup(&self) -> Vec<Line<'_>> {
+        let mut lines = Vec::new();
+
+        // First line: serial number with temperature and wear
+        if let Some(serial) = &self.backup_disk_serial {
+            let truncated_serial = truncate_serial(serial);
+            let mut details = Vec::new();
+            if let Some(temp) = self.backup_disk_temperature {
+                details.push(format!("T: {}°C", temp as i32));
+            }
+            if let Some(wear) = self.backup_disk_wear_percent {
+                details.push(format!("W: {}%", wear as i32));
+            }
+
+            let disk_text = if !details.is_empty() {
+                format!("{} {}", truncated_serial, details.join(" "))
+            } else {
+                truncated_serial
+            };
+
+            let backup_status = match self.backup_status.as_str() {
+                "completed" | "success" => Status::Ok,
+                "running" => Status::Pending,
+                "failed" => Status::Critical,
+                _ => Status::Unknown,
+            };
+
+            let disk_spans = StatusIcons::create_status_spans(backup_status, &disk_text);
+            lines.push(Line::from(disk_spans));
+
+            // Show backup time from TOML if available
+            if let Some(start_time) = &self.backup_start_time_raw {
+                let time_text = if let Some(size) = self.backup_last_size_gb {
+                    format!("Time: {} ({:.1}GB)", start_time, size)
+                } else {
+                    format!("Time: {}", start_time)
+                };
+                
+                lines.push(Line::from(vec![
+                    Span::styled("  ├─ ", Typography::tree()),
+                    Span::styled(time_text, Typography::secondary())
+                ]));
+            }
+
+            // Usage information
+            if let (Some(used), Some(total), Some(usage_percent)) = (
+                self.backup_disk_used_gb, 
+                self.backup_disk_total_gb,
+                self.backup_disk_usage_percent
+            ) {
+                let usage_text = format!("Usage: {:.0}% {:.0}GB/{:.0}GB", usage_percent, used, total);
+                let usage_spans = StatusIcons::create_status_spans(Status::Ok, &usage_text);
+                let mut full_spans = vec![
+                    Span::styled("  └─ ", Typography::tree()),
+                ];
+                full_spans.extend(usage_spans);
+                lines.push(Line::from(full_spans));
+            }
+        }
+
+        lines
+    }
+
+    /// Compress IPv4 addresses from same subnet
+    /// Example: "192.168.30.1, 192.168.30.100" -> "192.168.30.1, 100"
+    fn compress_ipv4_addresses(addresses: &[String]) -> String {
+        if addresses.is_empty() {
+            return String::new();
+        }
+
+        if addresses.len() == 1 {
+            return addresses[0].clone();
+        }
+
+        let mut result = Vec::new();
+        let mut last_prefix = String::new();
+
+        for addr in addresses {
+            let parts: Vec<&str> = addr.split('.').collect();
+            if parts.len() == 4 {
+                let prefix = format!("{}.{}.{}", parts[0], parts[1], parts[2]);
+
+                if prefix == last_prefix {
+                    // Same subnet, show only last octet
+                    result.push(parts[3].to_string());
+                } else {
+                    // Different subnet, show full IP
+                    result.push(addr.clone());
+                    last_prefix = prefix;
+                }
+            } else {
+                // Invalid IP format, show as-is
+                result.push(addr.clone());
+            }
+        }
+
+        result.join(", ")
+    }
+
+    /// Render network section for display with physical/virtual grouping
+    fn render_network(&self) -> Vec<Line<'_>> {
+        let mut lines = Vec::new();
+
+        if self.network_interfaces.is_empty() {
+            return lines;
+        }
+
+        // Separate physical and virtual interfaces
+        let physical: Vec<_> = self.network_interfaces.iter().filter(|i| i.is_physical).collect();
+        let virtual_interfaces: Vec<_> = self.network_interfaces.iter().filter(|i| !i.is_physical).collect();
+
+        // Find standalone virtual interfaces (those without a parent)
+        let mut standalone_virtual: Vec<_> = virtual_interfaces.iter()
+            .filter(|i| i.parent_interface.is_none())
+            .collect();
+
+        // Sort standalone virtual: VLANs first (by VLAN ID), then others alphabetically
+        standalone_virtual.sort_by(|a, b| {
+            match (a.vlan_id, b.vlan_id) {
+                (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                (Some(_), None) => std::cmp::Ordering::Less,
+                (None, Some(_)) => std::cmp::Ordering::Greater,
+                (None, None) => a.name.cmp(&b.name),
+            }
+        });
+
+        // Render physical interfaces with their children
+        for (phy_idx, interface) in physical.iter().enumerate() {
+            let is_last_physical = phy_idx == physical.len() - 1 && standalone_virtual.is_empty();
+
+            // Physical interface header with status icon
+            let mut header_spans = vec![];
+            header_spans.extend(StatusIcons::create_status_spans(
+                interface.link_status.clone(),
+                &format!("{}:", interface.name)
+            ));
+            lines.push(Line::from(header_spans));
+
+            // Find child interfaces for this physical interface
+            let mut children: Vec<_> = virtual_interfaces.iter()
+                .filter(|vi| {
+                    if let Some(parent) = &vi.parent_interface {
+                        parent == &interface.name
+                    } else {
+                        false
+                    }
+                })
+                .collect();
+
+            // Sort children: VLANs first (by VLAN ID), then others alphabetically
+            children.sort_by(|a, b| {
+                match (a.vlan_id, b.vlan_id) {
+                    (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => a.name.cmp(&b.name),
+                }
+            });
+
+            // Count total items under this physical interface (IPs + children)
+            let ip_count = interface.ipv4_addresses.len() + interface.ipv6_addresses.len();
+            let total_children = ip_count + children.len();
+            let mut child_index = 0;
+
+            // IPv4 addresses on the physical interface itself
+            for ipv4 in &interface.ipv4_addresses {
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(format!("ip: {}", ipv4), Typography::secondary()),
+                ]));
+            }
+
+            // IPv6 addresses on the physical interface itself
+            for ipv6 in &interface.ipv6_addresses {
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(format!("ip: {}", ipv6), Typography::secondary()),
+                ]));
+            }
+
+            // Child virtual interfaces (VLANs, etc.)
+            for child in children {
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+                let ip_text = if !child.ipv4_addresses.is_empty() {
+                    Self::compress_ipv4_addresses(&child.ipv4_addresses)
+                } else if !child.ipv6_addresses.is_empty() {
+                    child.ipv6_addresses.join(", ")
+                } else {
+                    String::new()
+                };
+
+                // Format: "name (vlan X): IP" or "name: IP"
+                let child_text = if let Some(vlan_id) = child.vlan_id {
+                    if !ip_text.is_empty() {
+                        format!("{} (vlan {}): {}", child.name, vlan_id, ip_text)
+                    } else {
+                        format!("{} (vlan {}):", child.name, vlan_id)
+                    }
+                } else {
+                    if !ip_text.is_empty() {
+                        format!("{}: {}", child.name, ip_text)
+                    } else {
+                        format!("{}:", child.name)
+                    }
+                };
+
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(child_text, Typography::secondary()),
+                ]));
+            }
+        }
+
+        // Render standalone virtual interfaces (those without a parent)
+        for (virt_idx, interface) in standalone_virtual.iter().enumerate() {
+            let is_last = virt_idx == standalone_virtual.len() - 1;
+            let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+            // Virtual interface with IPs
+            let ip_text = if !interface.ipv4_addresses.is_empty() {
+                Self::compress_ipv4_addresses(&interface.ipv4_addresses)
+            } else if !interface.ipv6_addresses.is_empty() {
+                interface.ipv6_addresses.join(", ")
+            } else {
+                String::new()
+            };
+
+            // Format: "name (vlan X): IP" or "name: IP"
+            let interface_text = if let Some(vlan_id) = interface.vlan_id {
+                if !ip_text.is_empty() {
+                    format!("{} (vlan {}): {}", interface.name, vlan_id, ip_text)
+                } else {
+                    format!("{} (vlan {}):", interface.name, vlan_id)
+                }
+            } else {
+                if !ip_text.is_empty() {
+                    format!("{}: {}", interface.name, ip_text)
+                } else {
+                    format!("{}:", interface.name)
+                }
+            };
+
+            lines.push(Line::from(vec![
+                Span::styled(tree_symbol, Typography::tree()),
+                Span::styled(interface_text, Typography::secondary()),
+            ]));
+        }
+
+        lines
+    }
+
+    /// Render system widget
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
        let mut lines = Vec::new();

        // NixOS section
@@ -370,30 +807,31 @@ impl SystemWidget {
        lines.push(Line::from(vec![
            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())
-                ]));
-            }
+
+        // ZMQ communication stats
+        if let (Some(packets), Some(age)) = (self.zmq_packets_received, self.zmq_last_packet_age) {
+            let age_text = if age < 1.0 {
+                format!("{:.0}ms ago", age * 1000.0)
+            } else {
+                format!("{:.1}s ago", age)
+            };
+            lines.push(Line::from(vec![
+                Span::styled(format!("ZMQ: {} pkts, last {}", packets, age_text), Typography::secondary())
+            ]));
        }
-        

        // CPU section
        lines.push(Line::from(vec![
            Span::styled("CPU:", Typography::widget_title())
        ]));
-        
+
        let load_text = self.format_cpu_load();
        let cpu_spans = StatusIcons::create_status_spans(
            self.cpu_status.clone(),
            &format!("Load: {}", load_text)
        );
        lines.push(Line::from(cpu_spans));
-        
+
        let freq_text = self.format_cpu_frequency();
        lines.push(Line::from(vec![
            Span::styled("  └─ ", Typography::tree()),
@@ -404,7 +842,7 @@ impl SystemWidget {
        lines.push(Line::from(vec![
            Span::styled("RAM:", Typography::widget_title())
        ]));
-        
+
        let memory_text = self.format_memory_usage();
        let memory_spans = StatusIcons::create_status_spans(
            self.memory_status.clone(),
@@ -416,16 +854,16 @@ impl SystemWidget {
        for (i, tmpfs) in self.tmpfs_mounts.iter().enumerate() {
            let is_last = i == self.tmpfs_mounts.len() - 1;
            let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
-            
+
            let usage_text = if tmpfs.total_gb > 0.0 {
-                format!("{:.0}% {:.1}GB/{:.1}GB", 
-                    tmpfs.usage_percent, 
-                    tmpfs.used_gb, 
+                format!("{:.0}% {:.1}GB/{:.1}GB",
+                    tmpfs.usage_percent,
+                    tmpfs.used_gb,
                    tmpfs.total_gb)
            } else {
                "— —/—".to_string()
            };
-            
+
            let mut tmpfs_spans = vec![
                Span::styled(tree_symbol, Typography::tree()),
            ];
@@ -436,6 +874,16 @@ impl SystemWidget {
            lines.push(Line::from(tmpfs_spans));
        }

+        // Network section
+        if !self.network_interfaces.is_empty() {
+            lines.push(Line::from(vec![
+                Span::styled("Network:", Typography::widget_title())
+            ]));
+
+            let network_lines = self.render_network();
+            lines.extend(network_lines);
+        }
+
        // Storage section
        lines.push(Line::from(vec![
            Span::styled("Storage:", Typography::widget_title())
@@ -445,6 +893,16 @@ impl SystemWidget {
        let storage_lines = self.render_storage();
        lines.extend(storage_lines);

+        // Backup section (if available)
+        if self.backup_status != "unavailable" && self.backup_status != "unknown" {
+            lines.push(Line::from(vec![
+                Span::styled("Backup:", Typography::widget_title())
+            ]));
+
+            let backup_lines = self.render_backup();
+            lines.extend(backup_lines);
+        }
+
        // Apply scroll offset
        let total_lines = lines.len();
        let available_height = area.height as usize;
--- a/shared/Cargo.toml
+++ b/shared/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.147"
+version = "0.1.200"
 edition = "2021"

 [dependencies]
--- a/shared/src/agent_data.rs
+++ b/shared/src/agent_data.rs
@@ -16,11 +16,30 @@ pub struct AgentData {
 /// System-level monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SystemData {
+    pub network: NetworkData,
    pub cpu: CpuData,
    pub memory: MemoryData,
    pub storage: StorageData,
 }

+/// Network interface monitoring data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkData {
+    pub interfaces: Vec<NetworkInterfaceData>,
+}
+
+/// Individual network interface data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkInterfaceData {
+    pub name: String,
+    pub ipv4_addresses: Vec<String>,
+    pub ipv6_addresses: Vec<String>,
+    pub is_physical: bool,
+    pub link_status: Status,
+    pub parent_interface: Option<String>,
+    pub vlan_id: Option<u16>,
+}
+
 /// CPU monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CpuData {
@@ -66,6 +85,7 @@ pub struct StorageData {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DriveData {
    pub name: String,
+    pub serial_number: Option<String>,
    pub health: String,
    pub temperature_celsius: Option<f32>,
    pub wear_percent: Option<f32>,
@@ -96,15 +116,20 @@ pub struct PoolData {
    pub total_gb: f32,
    pub data_drives: Vec<PoolDriveData>,
    pub parity_drives: Vec<PoolDriveData>,
+    pub health_status: Status,
+    pub usage_status: Status,
 }

 /// Drive in a storage pool
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PoolDriveData {
    pub name: String,
+    pub serial_number: Option<String>,
    pub temperature_celsius: Option<f32>,
    pub wear_percent: Option<f32>,
    pub health: String,
+    pub health_status: Status,
+    pub temperature_status: Status,
 }

 /// Service monitoring data
@@ -124,6 +149,9 @@ pub struct SubServiceData {
    pub name: String,
    pub service_status: Status,
    pub metrics: Vec<SubServiceMetric>,
+    /// Type of sub-service: "nginx_site", "container", "image"
+    #[serde(default)]
+    pub service_type: String,
 }

 /// Individual metric for a sub-service
@@ -138,10 +166,22 @@ pub struct SubServiceMetric {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackupData {
    pub status: String,
-    pub last_run: Option<u64>,
-    pub next_scheduled: Option<u64>,
    pub total_size_gb: Option<f32>,
    pub repository_health: Option<String>,
+    pub repository_disk: Option<BackupDiskData>,
+    pub last_backup_size_gb: Option<f32>,
+    pub start_time_raw: Option<String>,
+}
+
+/// Backup repository disk information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BackupDiskData {
+    pub serial: String,
+    pub usage_percent: f32,
+    pub used_gb: f32,
+    pub total_gb: f32,
+    pub wear_percent: Option<f32>,
+    pub temperature_celsius: Option<f32>,
 }

 impl AgentData {
@@ -153,6 +193,9 @@ impl AgentData {
            build_version: None,
            timestamp: chrono::Utc::now().timestamp() as u64,
            system: SystemData {
+                network: NetworkData {
+                    interfaces: Vec::new(),
+                },
                cpu: CpuData {
                    load_1min: 0.0,
                    load_5min: 0.0,
@@ -180,10 +223,11 @@ impl AgentData {
            services: Vec::new(),
            backup: BackupData {
                status: "unknown".to_string(),
-                last_run: None,
-                next_scheduled: None,
                total_size_gb: None,
                repository_health: None,
+                repository_disk: None,
+                last_backup_size_gb: None,
+                start_time_raw: None,
            },
        }
    }
				`@@ -1 +0,0 @@`
				`// This file is intentionally left minimal - CPU functionality is handled by the SystemWidget`