23 changed files with 2223 additions and 2801 deletions
--- 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
@ -327,16 +377,9 @@ Storage:
  ├─ ● Data_2: GGA04461 T: 28°C
  └─ ● Parity: WDZS8RY0 T: 29°C
 Backup:
 ● Repo: 4
  ├─ getea
  ├─ vaultwarden
  ├─ mysql
  └─ immich
 ● W800639Y W: 2%
  ├─ ● Backup: 2025-11-29T04:00:01.324623
  └─ ● Usage: 8% 70GB/916GB
 ● WD-WCC7K1234567 T: 32°C W: 12%
-  ├─ ● Backup: 2025-11-29T04:00:01.324623
+  ├─ Last: 2h ago (12.3GB)
  ├─ Next: in 22h
  └─ ● Usage: 45% 678GB/1.5TB
 ```
--- 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]]
@ -104,6 +103,137 @@ dependencies = [
 "object",
 ]
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
 dependencies = [
 "event-listener",
 "event-listener-strategy",
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-channel"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
 "concurrent-queue",
 "event-listener-strategy",
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-executor"
 version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "497c00e0fd83a72a79a39fcbd8e3e2f055d6f6c7e025f3b3d91f4f8e76527fb8"
 dependencies = [
 "async-task",
 "concurrent-queue",
 "fastrand",
 "futures-lite",
 "pin-project-lite",
 "slab",
 ]
 [[package]]
 name = "async-fs"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
 dependencies = [
 "async-lock",
 "blocking",
 "futures-lite",
 ]
 [[package]]
 name = "async-io"
 version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 dependencies = [
 "autocfg",
 "cfg-if",
 "concurrent-queue",
 "futures-io",
 "futures-lite",
 "parking",
 "polling",
 "rustix",
 "slab",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "async-lock"
 version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
 dependencies = [
 "event-listener",
 "event-listener-strategy",
 "pin-project-lite",
 ]
 [[package]]
 name = "async-process"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
 dependencies = [
 "async-channel",
 "async-io",
 "async-lock",
 "async-signal",
 "async-task",
 "blocking",
 "cfg-if",
 "event-listener",
 "futures-lite",
 "rustix",
 ]
 [[package]]
 name = "async-recursion"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "async-signal"
 version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
 dependencies = [
 "async-io",
 "async-lock",
 "atomic-waker",
 "cfg-if",
 "futures-core",
 "futures-io",
 "rustix",
 "signal-hook-registry",
 "slab",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "async-task"
 version = "4.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 [[package]]
 name = "async-trait"
 version = "0.1.89"
@ -115,6 +245,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 +281,84 @@ version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
 "generic-array",
 ]
 [[package]]
 name = "blocking"
 version = "1.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
 dependencies = [
 "async-channel",
 "async-task",
 "futures-io",
 "futures-lite",
 "piper",
 ]
 [[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 +373,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 +399,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 +453,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 +463,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 +493,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 [[package]]
 name = "cm-dashboard"
-version = "0.1.274"
+version = "0.1.197"
 dependencies = [
 "anyhow",
 "chrono",
@ -290,7 +504,7 @@ dependencies = [
 "ratatui",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 "tokio",
 "toml",
 "tracing",
@ -301,10 +515,11 @@ dependencies = [
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.274"
+version = "0.1.197"
 dependencies = [
 "anyhow",
 "async-trait",
 "bollard",
 "chrono",
 "chrono-tz",
 "clap",
@ -312,25 +527,30 @@ dependencies = [
 "futures",
 "gethostname",
 "lettre",
 "libc",
 "netlink-packet-route",
 "nix 0.29.0",
 "reqwest",
 "rtnetlink",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 "tokio",
 "toml",
 "tracing",
 "tracing-subscriber",
 "zbus",
 "zmq",
 ]
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.274"
+version = "0.1.197"
 dependencies = [
 "chrono",
 "serde",
 "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 [[package]]
@ -339,6 +559,15 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
 "crossbeam-utils",
 ]
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@ -355,6 +584,15 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "crossbeam"
 version = "0.8.4"
@ -436,6 +674,36 @@ dependencies = [
 "winapi",
 ]
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
 "generic-array",
 "typenum",
 ]
 [[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 = "digest"
 version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
 "block-buffer",
 "crypto-common",
 ]
 [[package]]
 name = "dircpy"
 version = "0.3.19"
@ -458,6 +726,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"
@ -489,6 +763,33 @@ dependencies = [
 "cfg-if",
 ]
 [[package]]
 name = "endi"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
 dependencies = [
 "enumflags2_derive",
 "serde",
 ]
 [[package]]
 name = "enumflags2_derive"
 version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@ -505,6 +806,27 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "event-listener"
 version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
 dependencies = [
 "concurrent-queue",
 "parking",
 "pin-project-lite",
 ]
 [[package]]
 name = "event-listener-strategy"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
 dependencies = [
 "event-listener",
 "pin-project-lite",
 ]
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@ -601,6 +923,19 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 [[package]]
 name = "futures-lite"
 version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
 dependencies = [
 "fastrand",
 "futures-core",
 "futures-io",
 "parking",
 "pin-project-lite",
 ]
 [[package]]
 name = "futures-macro"
 version = "0.3.31"
@ -642,6 +977,16 @@ dependencies = [
 "slab",
 ]
 [[package]]
 name = "generic-array"
 version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
 "typenum",
 "version_check",
 ]
 [[package]]
 name = "gethostname"
 version = "0.4.3"
@ -652,6 +997,17 @@ dependencies = [
 "windows-targets 0.48.5",
 ]
 [[package]]
 name = "getrandom"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
 "cfg-if",
 "libc",
 "wasi",
 ]
 [[package]]
 name = "getrandom"
 version = "0.3.4"
@ -675,14 +1031,20 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "futures-util",
- "http",
+ "http 0.2.12",
- "indexmap",
+ "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"
@ -706,9 +1068,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"
@ -722,6 +1084,18 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 [[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"
@ -733,6 +1107,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"
@ -740,7 +1124,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",
 ]
@ -767,8 +1174,8 @@ dependencies = [
 "futures-core",
 "futures-util",
 "h2",
- "http",
+ "http 0.2.12",
- "http-body",
+ "http-body 0.4.6",
 "httparse",
 "httpdate",
 "itoa",
@ -780,6 +1187,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"
@ -787,12 +1231,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"
@ -921,12 +1401,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]]
@ -971,7 +1464,7 @@ version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
- "getrandom",
+ "getrandom 0.3.4",
 "libc",
 ]
@ -1080,6 +1573,15 @@ version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 [[package]]
 name = "memoffset"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
 dependencies = [
 "autocfg",
 ]
 [[package]]
 name = "mime"
 version = "0.3.17"
@ -1126,6 +1628,94 @@ 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",
 "memoffset",
 ]
 [[package]]
 name = "nom"
 version = "8.0.0"
@ -1144,6 +1734,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"
@ -1218,6 +1814,22 @@ dependencies = [
 "vcpkg",
 ]
 [[package]]
 name = "ordered-stream"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
 dependencies = [
 "futures-core",
 "pin-project-lite",
 ]
 [[package]]
 name = "parking"
 version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@ -1312,12 +1924,37 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 [[package]]
 name = "piper"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
 dependencies = [
 "atomic-waker",
 "fastrand",
 "futures-io",
 ]
 [[package]]
 name = "pkg-config"
 version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 [[package]]
 name = "polling"
 version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
 dependencies = [
 "cfg-if",
 "concurrent-queue",
 "hermit-abi",
 "pin-project-lite",
 "rustix",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@ -1327,6 +1964,30 @@ dependencies = [
 "zerovec",
 ]
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
 "zerocopy",
 ]
 [[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
 "toml_edit 0.23.7",
 ]
 [[package]]
 name = "proc-macro2"
 version = "1.0.103"
@ -1373,6 +2034,18 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
 "libc",
 "rand_chacha",
 "rand_core",
 ]
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
 "ppv-lite86",
 "rand_core",
 ]
@ -1381,6 +2054,9 @@ name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
 "getrandom 0.2.16",
 ]
 [[package]]
 name = "ratatui"
@ -1429,6 +2105,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"
@ -1470,9 +2166,9 @@ dependencies = [
 "futures-core",
 "futures-util",
 "h2",
- "http",
+ "http 0.2.12",
- "http-body",
+ "http-body 0.4.6",
- "hyper",
+ "hyper 0.14.32",
 "hyper-tls",
 "ipnet",
 "js-sys",
@ -1498,6 +2194,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"
@ -1550,6 +2264,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"
@ -1622,6 +2360,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"
@ -1643,6 +2392,35 @@ 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 = "sha1"
 version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
 "cfg-if",
 "cpufeatures",
 "digest",
 ]
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@ -1681,9 +2459,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",
 ]
@ -1745,6 +2523,12 @@ dependencies = [
 "windows-sys 0.59.0",
 ]
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 [[package]]
 name = "strsim"
 version = "0.11.1"
@ -1775,9 +2559,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",
@ -1848,7 +2632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
 "fastrand",
- "getrandom",
+ "getrandom 0.3.4",
 "once_cell",
 "rustix",
 "windows-sys 0.61.2",
@ -1860,7 +2644,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]]
@ -1874,6 +2667,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"
@ -1883,6 +2687,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"
@ -1952,8 +2787,8 @@ checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
 "serde",
 "serde_spanned",
- "toml_datetime",
+ "toml_datetime 0.6.11",
- "toml_edit",
+ "toml_edit 0.22.27",
 ]
 [[package]]
@ -1965,20 +2800,50 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "toml_datetime"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
 dependencies = [
 "serde_core",
 ]
 [[package]]
 name = "toml_edit"
 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",
+ "toml_datetime 0.6.11",
 "toml_write",
 "winnow",
 ]
 [[package]]
 name = "toml_edit"
 version = "0.23.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
 dependencies = [
 "indexmap 2.12.1",
 "toml_datetime 0.7.3",
 "toml_parser",
 "winnow",
 ]
 [[package]]
 name = "toml_parser"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
 dependencies = [
 "winnow",
 ]
 [[package]]
 name = "toml_write"
 version = "0.1.2"
@ -2004,9 +2869,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",
@ -2015,9 +2880,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",
@ -2058,6 +2923,23 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 [[package]]
 name = "typenum"
 version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 [[package]]
 name = "uds_windows"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89daebc3e6fd160ac4aa9fc8b3bf71e1f74fbf92367ae71fb83a037e8bf164b9"
 dependencies = [
 "memoffset",
 "tempfile",
 "winapi",
 ]
 [[package]]
 name = "unicode-ident"
 version = "1.0.22"
@ -2555,9 +3437,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",
 ]
@ -2584,6 +3466,16 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 [[package]]
 name = "xdg-home"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6"
 dependencies = [
 "libc",
 "windows-sys 0.59.0",
 ]
 [[package]]
 name = "yoke"
 version = "0.8.1"
@ -2608,19 +3500,81 @@ dependencies = [
 ]
 [[package]]
-name = "zerocopy"
+name = "zbus"
-version = "0.8.27"
+version = "4.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"
 dependencies = [
 "async-broadcast",
 "async-executor",
 "async-fs",
 "async-io",
 "async-lock",
 "async-process",
 "async-recursion",
 "async-task",
 "async-trait",
 "blocking",
 "enumflags2",
 "event-listener",
 "futures-core",
 "futures-sink",
 "futures-util",
 "hex",
 "nix 0.29.0",
 "ordered-stream",
 "rand",
 "serde",
 "serde_repr",
 "sha1",
 "static_assertions",
 "tracing",
 "uds_windows",
 "windows-sys 0.52.0",
 "xdg-home",
 "zbus_macros",
 "zbus_names",
 "zvariant",
 ]
 [[package]]
 name = "zbus_macros"
 version = "4.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
 "syn",
 "zvariant_utils",
 ]
 [[package]]
 name = "zbus_names"
 version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"
 dependencies = [
 "serde",
 "static_assertions",
 "zvariant",
 ]
 [[package]]
 name = "zerocopy"
 version = "0.8.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 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",
@ -2712,3 +3666,40 @@ dependencies = [
 "system-deps",
 "zeromq-src",
 ]
 [[package]]
 name = "zvariant"
 version = "4.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe"
 dependencies = [
 "endi",
 "enumflags2",
 "serde",
 "static_assertions",
 "zvariant_derive",
 ]
 [[package]]
 name = "zvariant_derive"
 version = "4.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
 "syn",
 "zvariant_utils",
 ]
 [[package]]
 name = "zvariant_utils"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
--- a/agent/Cargo.toml
+++ b/agent/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.275"
+version = "0.1.197"
 edition = "2021"
 [dependencies]
@ -21,4 +21,16 @@ chrono-tz = "0.8"
 toml = { workspace = true }
 async-trait = "0.1"
 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"
 # D-Bus client for systemd
 zbus = "4.0"
--- a/agent/src/agent.rs
+++ b/agent/src/agent.rs
@ -1,6 +1,6 @@
 use anyhow::Result;
 use gethostname::gethostname;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use tokio::time::interval;
 use tracing::{debug, error, info};
@ -19,22 +19,13 @@ use crate::collectors::{
 use crate::notifications::NotificationManager;
 use cm_dashboard_shared::AgentData;
 /// Wrapper for collectors with timing information
 struct TimedCollector {
    collector: Box<dyn Collector>,
    interval: Duration,
    last_collection: Option<Instant>,
    name: String,
 }
 pub struct Agent {
    hostname: String,
    config: AgentConfig,
    zmq_handler: ZmqHandler,
-    collectors: Vec<TimedCollector>,
+    collectors: Vec<Box<dyn Collector>>,
    notification_manager: NotificationManager,
    previous_status: Option<SystemStatus>,
    cached_agent_data: AgentData,
 }
 /// Track system component status for change detection
@ -64,78 +55,36 @@ impl Agent {
            config.zmq.publisher_port
        );
-        // Initialize collectors with timing information
+        // Initialize collectors
-        let mut collectors: Vec<TimedCollector> = Vec::new();
+        let mut collectors: Vec<Box<dyn Collector>> = Vec::new();
        // Add enabled collectors
        if config.collectors.cpu.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(CpuCollector::new(config.collectors.cpu.clone())));
                collector: Box::new(CpuCollector::new(config.collectors.cpu.clone())),
                interval: Duration::from_secs(config.collectors.cpu.interval_seconds),
                last_collection: None,
                name: "CPU".to_string(),
            });
            info!("CPU collector initialized with {}s interval", config.collectors.cpu.interval_seconds);
        }
        if config.collectors.memory.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(MemoryCollector::new(config.collectors.memory.clone())));
                collector: Box::new(MemoryCollector::new(config.collectors.memory.clone())),
                interval: Duration::from_secs(config.collectors.memory.interval_seconds),
                last_collection: None,
                name: "Memory".to_string(),
            });
            info!("Memory collector initialized with {}s interval", config.collectors.memory.interval_seconds);
        }
        if config.collectors.disk.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(DiskCollector::new(config.collectors.disk.clone())));
                collector: Box::new(DiskCollector::new(config.collectors.disk.clone())),
                interval: Duration::from_secs(config.collectors.disk.interval_seconds),
                last_collection: None,
                name: "Disk".to_string(),
            });
            info!("Disk collector initialized with {}s interval", config.collectors.disk.interval_seconds);
        }
        if config.collectors.systemd.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(SystemdCollector::new(config.collectors.systemd.clone())));
                collector: Box::new(SystemdCollector::new(config.collectors.systemd.clone())),
                interval: Duration::from_secs(config.collectors.systemd.interval_seconds),
                last_collection: None,
                name: "Systemd".to_string(),
            });
            info!("Systemd collector initialized with {}s interval", config.collectors.systemd.interval_seconds);
        }
        if config.collectors.backup.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(BackupCollector::new()));
                collector: Box::new(BackupCollector::new()),
                interval: Duration::from_secs(config.collectors.backup.interval_seconds),
                last_collection: None,
                name: "Backup".to_string(),
            });
            info!("Backup collector initialized with {}s interval", config.collectors.backup.interval_seconds);
        }
        if config.collectors.network.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(NetworkCollector::new(config.collectors.network.clone())));
                collector: Box::new(NetworkCollector::new(config.collectors.network.clone())),
                interval: Duration::from_secs(config.collectors.network.interval_seconds),
                last_collection: None,
                name: "Network".to_string(),
            });
            info!("Network collector initialized with {}s interval", config.collectors.network.interval_seconds);
        }
        if config.collectors.nixos.enabled {
-            collectors.push(TimedCollector {
+            collectors.push(Box::new(NixOSCollector::new(config.collectors.nixos.clone())));
                collector: Box::new(NixOSCollector::new(config.collectors.nixos.clone())),
                interval: Duration::from_secs(config.collectors.nixos.interval_seconds),
                last_collection: None,
                name: "NixOS".to_string(),
            });
            info!("NixOS collector initialized with {}s interval", config.collectors.nixos.interval_seconds);
        }
        info!("Initialized {} collectors", collectors.len());
@ -144,9 +93,6 @@ impl Agent {
        let notification_manager = NotificationManager::new(&config.notifications, &hostname)?;
        info!("Notification manager initialized");
        // Initialize cached agent data
        let cached_agent_data = AgentData::new(hostname.clone(), env!("CARGO_PKG_VERSION").to_string());
        Ok(Self {
            hostname,
            config,
@ -154,7 +100,6 @@ impl Agent {
            collectors,
            notification_manager,
            previous_status: None,
            cached_agent_data,
        })
    }
@ -169,7 +114,7 @@ impl Agent {
        // Set up intervals
        let mut transmission_interval = interval(Duration::from_secs(
-            self.config.zmq.transmission_interval_seconds,
+            self.config.collection_interval_seconds,
        ));
        let mut notification_interval = interval(Duration::from_secs(30)); // Check notifications every 30s
@ -204,47 +149,24 @@ impl Agent {
    async fn collect_and_broadcast(&mut self) -> Result<()> {
        debug!("Starting structured data collection");
-        // Collect data from collectors whose intervals have elapsed
+        // Initialize empty AgentData
-        // Update cached_agent_data with new data
+        let mut agent_data = AgentData::new(self.hostname.clone(), env!("CARGO_PKG_VERSION").to_string());
        let now = Instant::now();
        for timed_collector in &mut self.collectors {
            let should_collect = match timed_collector.last_collection {
                None => true, // First collection
                Some(last_time) => now.duration_since(last_time) >= timed_collector.interval,
            };
-            if should_collect {
+        // Collect data from all collectors
-                if let Err(e) = timed_collector.collector.collect_structured(&mut self.cached_agent_data).await {
+        for collector in &self.collectors {
-                    error!("Collector {} failed: {}", timed_collector.name, e);
+            if let Err(e) = collector.collect_structured(&mut agent_data).await {
-                    // Update last_collection time even on failure to prevent immediate retries
+                error!("Collector failed: {}", e);
-                    timed_collector.last_collection = Some(now);
+                // Continue with other collectors even if one fails
                } else {
                    timed_collector.last_collection = Some(now);
                    debug!(
                        "Collected from {} ({}s interval)",
                        timed_collector.name,
                        timed_collector.interval.as_secs()
                    );
                }
            }
        }
        // Update timestamp on cached data
        self.cached_agent_data.timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        // Clone for notification check (to avoid borrow issues)
        let agent_data_snapshot = self.cached_agent_data.clone();
        // Check for status changes and send notifications
-        if let Err(e) = self.check_status_changes_and_notify(&agent_data_snapshot).await {
+        if let Err(e) = self.check_status_changes_and_notify(&agent_data).await {
            error!("Failed to check status changes: {}", e);
        }
-        // Broadcast the cached structured data via ZMQ
+        // Broadcast the structured data via ZMQ
-        if let Err(e) = self.zmq_handler.publish_agent_data(&agent_data_snapshot).await {
+        if let Err(e) = self.zmq_handler.publish_agent_data(&agent_data).await {
            error!("Failed to broadcast agent data: {}", e);
        } else {
            debug!("Successfully broadcast structured agent data");
--- a/agent/src/collectors/backup.rs
+++ b/agent/src/collectors/backup.rs
@ -1,51 +1,36 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, BackupData, BackupRepositoryData, Status};
+use cm_dashboard_shared::{AgentData, BackupData, BackupDiskData};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
-use tracing::{debug, warn};
+use tracing::debug;
 use super::{Collector, CollectorError};
 /// Backup collector that reads backup status from TOML files with structured data output
 pub struct BackupCollector {
-    /// Directory containing backup status files
+    /// Path to backup status file
-    status_dir: String,
+    status_file_path: String,
 }
 impl BackupCollector {
    pub fn new() -> Self {
        Self {
-            status_dir: "/var/lib/backup/status".to_string(),
+            status_file_path: "/var/lib/backup/backup-status.toml".to_string(),
        }
    }
-    /// Scan directory for backup status file (nfs-backup.toml)
+    /// Read backup status from TOML file
-    async fn scan_status_files(&self) -> Result<Vec<PathBuf>, CollectorError> {
+    async fn read_backup_status(&self) -> Result<Option<BackupStatusToml>, CollectorError> {
-        let status_path = Path::new(&self.status_dir);
+        if !Path::new(&self.status_file_path).exists() {
-
+            debug!("Backup status file not found: {}", self.status_file_path);
-        if !status_path.exists() {
+            return Ok(None);
            debug!("Backup status directory not found: {}", self.status_dir);
            return Ok(Vec::new());
        }
-        // Look for nfs-backup.toml (new NFS-based backup)
+        let content = fs::read_to_string(&self.status_file_path)
        let nfs_backup_file = status_path.join("nfs-backup.toml");
        if nfs_backup_file.exists() {
            return Ok(vec![nfs_backup_file]);
        }
        // No backup status file found
        debug!("No nfs-backup.toml found in {}", self.status_dir);
        Ok(Vec::new())
    }
    /// Read a single backup status file
    async fn read_status_file(&self, path: &Path) -> Result<BackupStatusToml, CollectorError> {
        let content = fs::read_to_string(path)
            .map_err(|e| CollectorError::SystemRead {
-                path: path.to_string_lossy().to_string(),
+                path: self.status_file_path.clone(),
                error: e.to_string(),
            })?;
@ -55,84 +40,66 @@ impl BackupCollector {
                error: format!("Failed to parse backup status TOML: {}", e),
            })?;
-        Ok(status)
+        Ok(Some(status))
    }
    /// Calculate backup status from TOML status field
    fn calculate_backup_status(status_str: &str) -> Status {
        match status_str.to_lowercase().as_str() {
            "success" | "completed" => Status::Ok,
            "warning" => Status::Warning,
            "failed" | "error" => Status::Critical,
            _ => Status::Unknown,
        }
    }
    /// Convert BackupStatusToml to BackupData and populate AgentData
    async fn populate_backup_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        let status_files = self.scan_status_files().await?;
+        if let Some(backup_status) = self.read_backup_status().await? {
            // Use raw start_time string from TOML
-        if status_files.is_empty() {
+            // Extract disk information
-            debug!("No backup status files found");
+            let repository_disk = if let Some(disk_space) = &backup_status.disk_space {
-            agent_data.backup = BackupData {
+                Some(BackupDiskData {
-                last_backup_time: None,
+                    serial: backup_status.disk_serial_number.clone().unwrap_or_else(|| "Unknown".to_string()),
-                backup_status: Status::Unknown,
+                    usage_percent: disk_space.usage_percent as f32,
-                repositories: Vec::new(),
+                    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,
                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;
        } else {
            // No backup status available - set default values
            agent_data.backup = BackupData {
                status: "unavailable".to_string(),
                total_size_gb: None,
                repository_health: None,
                repository_disk: None,
                last_backup_size_gb: None,
                start_time_raw: None,
            };
            return Ok(());
        }
        // Aggregate repository data across all backup status files
        let mut repo_map: HashMap<String, BackupRepositoryData> = HashMap::new();
        let mut worst_status = Status::Ok;
        let mut latest_backup_time: Option<String> = None;
        for status_file in status_files {
            match self.read_status_file(&status_file).await {
                Ok(backup_status) => {
                    // Calculate backup status
                    let backup_status_enum = Self::calculate_backup_status(&backup_status.status);
                    worst_status = worst_status.max(backup_status_enum);
                    // Track latest backup time
                    if latest_backup_time.is_none() || Some(&backup_status.start_time) > latest_backup_time.as_ref() {
                        latest_backup_time = Some(backup_status.start_time.clone());
                    }
                    // Process each service in this backup
                    for (service_name, service_status) in backup_status.services {
                        // Convert bytes to GB
                        let repo_size_gb = service_status.repo_size_bytes as f32 / 1_073_741_824.0;
                        // Calculate service status
                        let service_status_enum = Self::calculate_backup_status(&service_status.status);
                        worst_status = worst_status.max(service_status_enum);
                        // Update or insert repository data
                        repo_map.insert(service_name.clone(), BackupRepositoryData {
                            name: service_name,
                            archive_count: service_status.archive_count,
                            repo_size_gb,
                            status: service_status_enum,
                        });
                    }
                }
                Err(e) => {
                    warn!("Failed to read backup status file {:?}: {}", status_file, e);
                }
            }
        }
        // Convert HashMap to sorted Vec
        let mut repositories: Vec<BackupRepositoryData> = repo_map.into_values().collect();
        repositories.sort_by(|a, b| a.name.cmp(&b.name));
        agent_data.backup = BackupData {
            last_backup_time: latest_backup_time,
            backup_status: worst_status,
            repositories,
        };
        Ok(())
    }
 }
--- 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
+/// Extremely efficient CPU metrics collector with interval-based caching
 ///
 /// 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
 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 {
@ -35,6 +38,30 @@ impl CpuCollector {
        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
            }
        }
    }
@ -119,134 +146,36 @@ impl CpuCollector {
        utils::parse_u64(content.trim())
    }
-    /// Collect static CPU information from /proc/cpuinfo (only once at startup)
+    /// Collect CPU frequency and populate AgentData
-    async fn collect_cpu_info(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+    async fn collect_frequency(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        let content = utils::read_proc_file("/proc/cpuinfo")?;
+        // Try scaling frequency first (more accurate for current frequency)
-
+        if let Ok(freq) =
-        let mut model_name: Option<String> = None;
+            utils::read_proc_file("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
-        let mut core_count: u32 = 0;
+        {
-
+            if let Ok(freq_khz) = utils::parse_u64(freq.trim()) {
-        for line in content.lines() {
+                let freq_mhz = freq_khz as f32 / 1000.0;
-            if line.starts_with("model name") {
+                agent_data.system.cpu.frequency_mhz = freq_mhz;
-                if let Some(colon_pos) = line.find(':') {
+                return Ok(());
                    let full_name = line[colon_pos + 1..].trim();
                    // Extract just the model number (e.g., "i7-9700" from "Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz")
                    let model = Self::extract_cpu_model(full_name);
                    if model_name.is_none() {
                        model_name = Some(model);
                    }
                }
            } else if line.starts_with("processor") {
                core_count += 1;
            }
        }
-        agent_data.system.cpu.model_name = model_name;
+        // Fallback: parse /proc/cpuinfo for base frequency
-        if core_count > 0 {
+        if let Ok(content) = utils::read_proc_file("/proc/cpuinfo") {
-            agent_data.system.cpu.core_count = Some(core_count);
+            for line in content.lines() {
-        }
+                if line.starts_with("cpu MHz") {
-
+                    if let Some(freq_str) = line.split(':').nth(1) {
-        Ok(())
+                        if let Ok(freq_mhz) = utils::parse_f32(freq_str) {
-    }
+                            agent_data.system.cpu.frequency_mhz = freq_mhz;
-
+                            return Ok(());
    /// Extract CPU model number from full model name
    /// Examples:
    /// - "Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz" -> "i7-9700"
    /// - "12th Gen Intel(R) Core(TM) i7-12700K" -> "i7-12700K"
    /// - "AMD Ryzen 9 5950X 16-Core Processor" -> "Ryzen 9 5950X"
    fn extract_cpu_model(full_name: &str) -> String {
        // Look for Intel Core patterns (both old and new gen): i3, i5, i7, i9
        // Match pattern like "i7-12700K" or "i7-9700"
        for prefix in &["i3-", "i5-", "i7-", "i9-"] {
            if let Some(pos) = full_name.find(prefix) {
                // Find end of model number (until space or end of string)
                let after_prefix = &full_name[pos..];
                let end = after_prefix.find(' ').unwrap_or(after_prefix.len());
                return after_prefix[..end].to_string();
            }
        }
        // Look for AMD Ryzen pattern
        if let Some(pos) = full_name.find("Ryzen") {
            // Extract "Ryzen X XXXX" pattern
            let after_ryzen = &full_name[pos..];
            let parts: Vec<&str> = after_ryzen.split_whitespace().collect();
            if parts.len() >= 3 {
                return format!("{} {} {}", parts[0], parts[1], parts[2]);
            }
        }
        // Fallback: return first 15 characters or full name if shorter
        if full_name.len() > 15 {
            full_name[..15].to_string()
        } else {
            full_name.to_string()
        }
    }
    /// Collect CPU C-state (idle depth) and populate AgentData with top 3 C-states by usage
    async fn collect_cstate(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
        // Read C-state usage from first CPU (representative of overall system)
        // C-states indicate CPU idle depth: C1=light sleep, C6=deep sleep, C10=deepest
        let mut cstate_times: Vec<(String, u64)> = Vec::new();
        let mut total_time: u64 = 0;
        // Collect all C-state times from CPU0
        for state_num in 0..=10 {
            let time_path = format!("/sys/devices/system/cpu/cpu0/cpuidle/state{}/time", state_num);
            let name_path = format!("/sys/devices/system/cpu/cpu0/cpuidle/state{}/name", state_num);
            if let Ok(time_str) = utils::read_proc_file(&time_path) {
                if let Ok(time) = utils::parse_u64(time_str.trim()) {
                    if let Ok(name) = utils::read_proc_file(&name_path) {
                        let state_name = name.trim();
                        // Skip POLL state (not real idle)
                        if state_name != "POLL" && time > 0 {
                            // Extract "C" + digits pattern (C3, C10, etc.) to reduce JSON size
                            // Handles formats like "C3_ACPI", "C10_MWAIT", etc.
                            let clean_name = if let Some(c_pos) = state_name.find('C') {
                                let rest = &state_name[c_pos + 1..];
                                let digit_count = rest.chars().take_while(|c| c.is_ascii_digit()).count();
                                if digit_count > 0 {
                                    state_name[c_pos..c_pos + 1 + digit_count].to_string()
                                } else {
                                    state_name.to_string()
                                }
                            } else {
                                state_name.to_string()
                            };
                            cstate_times.push((clean_name, time));
                            total_time += time;
                        }
                    }
                    break; // Only need first CPU entry
                }
            } else {
                // No more states available
                break;
            }
        }
-        // Sort by time descending to get top 3
+        debug!("CPU frequency not available");
-        cstate_times.sort_by(|a, b| b.1.cmp(&a.1));
+        // Leave frequency as 0.0 if not available
        // Calculate percentages for top 3 and populate AgentData
        agent_data.system.cpu.cstates = cstate_times
            .iter()
            .take(3)
            .map(|(name, time)| {
                let percent = if total_time > 0 {
                    (*time as f32 / total_time as f32) * 100.0
                } else {
                    0.0
                };
                cm_dashboard_shared::CStateInfo {
                    name: name.clone(),
                    percent,
                }
            })
            .collect();
        Ok(())
    }
 }
@ -254,22 +183,25 @@ 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();
        // Collect static CPU info (only once at startup)
        if agent_data.system.cpu.model_name.is_none() || agent_data.system.cpu.core_count.is_none() {
            self.collect_cpu_info(agent_data).await?;
        }
        // Collect load averages (always available)
        self.collect_load_averages(agent_data).await?;
        // Collect temperature (optional)
        self.collect_temperature(agent_data).await?;
-        // Collect C-state (CPU idle depth)
+        // Collect frequency (optional)
-        self.collect_cstate(agent_data).await?;
+        self.collect_frequency(agent_data).await?;
        let duration = start.elapsed();
        debug!("CPU collection completed in {:?}", duration);
@ -282,14 +214,19 @@ impl Collector for CpuCollector {
            );
        }
-        // Calculate status using thresholds (use 5-minute average for stability)
+        // Calculate status using thresholds
-        agent_data.system.cpu.load_status = self.calculate_load_status(agent_data.system.cpu.load_5min);
+        agent_data.system.cpu.load_status = self.calculate_load_status(agent_data.system.cpu.load_1min);
        agent_data.system.cpu.temperature_status = if let Some(temp) = agent_data.system.cpu.temperature_celsius {
            self.calculate_temperature_status(temp)
        } else {
            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
@ -3,9 +3,11 @@ use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData, DriveData, FilesystemData, PoolData, HysteresisThresholds, Status};
 use crate::config::DiskConfig;
-use tokio::process::Command as TokioCommand;
+use std::process::Command;
-use std::process::Command as StdCommand;
+use std::time::Instant;
 use std::collections::HashMap;
 use std::sync::RwLock;
 use tracing::debug;
 use super::{Collector, CollectorError};
@ -13,6 +15,19 @@ 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
@ -58,17 +73,23 @@ impl DiskCollector {
            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),
        }
    }
    /// Collect all storage data and populate AgentData
    async fn collect_storage_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        // Clear drives and pools to prevent duplicates when updating cached data
+        let start_time = Instant::now();
-        agent_data.system.storage.drives.clear();
+        debug!("Starting clean storage collection");
        agent_data.system.storage.pools.clear();
        // Step 1: Get mount points and their backing devices
        let mount_devices = self.get_mount_devices().await?;
@ -104,40 +125,74 @@ 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> {
-        use super::run_command_with_timeout;
+        let content = std::fs::read_to_string("/proc/mounts")
        let mut cmd = TokioCommand::new("lsblk");
        cmd.args(&["-rn", "-o", "NAME,MOUNTPOINT"]);
        let output = run_command_with_timeout(cmd, 10).await
            .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() {
            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() >= 2 {
                let device_name = parts[0];
                let mount_point = parts[1];
-                // Skip swap partitions and unmounted devices
+        for line in content.lines() {
-                if mount_point == "[SWAP]" || mount_point.is_empty() {
+            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() >= 3 {
                let device = parts[0];
                let mount_point = parts[1];
                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
+                mount_devices.insert(mount_point.to_string(), device.to_string());
                let device_path = format!("/dev/{}", device_name);
                mount_devices.insert(mount_point.to_string(), device_path);
            }
        }
        debug!("Found {} mounted block devices", mount_devices.len());
        Ok(mount_devices)
    }
@ -150,8 +205,8 @@ impl DiskCollector {
                Ok((total, used)) => {
                    filesystem_usage.insert(mount_point.clone(), (total, used));
                }
-                Err(_e) => {
+                Err(e) => {
-                    // Silently skip filesystems we can't read
+                    debug!("Failed to get filesystem info for {}: {}", mount_point, e);
                }
            }
        }
@ -172,6 +227,8 @@ impl DiskCollector {
                // 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));
                    }
                }
@ -181,44 +238,20 @@ impl DiskCollector {
        Ok(())
    }
-    /// Get filesystem info for a single mount point
+    /// Get filesystem info for a single mount point using statvfs syscall
    fn get_filesystem_info(&self, mount_point: &str) -> Result<(u64, u64), CollectorError> {
-        let output = StdCommand::new("timeout")
+        use nix::sys::statvfs::statvfs;
            .args(&["10", "df", "--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 stat = statvfs(mount_point).map_err(|e| CollectorError::SystemRead {
-        let lines: Vec<&str> = output_str.lines().collect();
+            path: mount_point.to_string(),
-        
+            error: format!("statvfs failed: {}", 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(),
            });
        }
        // 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(),
            });
        }
        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 used_bytes: u64 = parts[2].parse().map_err(|e| CollectorError::Parse {
+        // Calculate total and used bytes
-            value: parts[2].to_string(),
+        let block_size = stat.fragment_size() as u64;
-            error: format!("Failed to parse used bytes: {}", e),
+        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))
    }
@ -248,6 +281,7 @@ impl DiskCollector {
                };
                if pool_name.is_empty() {
                    debug!("Skipping mergerfs pool with empty name: {}", mount_point);
                    continue;
                }
@ -275,7 +309,8 @@ impl DiskCollector {
                // Categorize as data vs parity drives
                let (data_drives, parity_drives) = match self.categorize_pool_drives(&all_member_paths) {
                    Ok(drives) => drives,
-                    Err(_e) => {
+                    Err(e) => {
                        debug!("Failed to categorize drives for pool {}: {}. Skipping.", mount_point, e);
                        continue;
                    }
                };
@ -291,6 +326,7 @@ impl DiskCollector {
            }
        }
        debug!("Found {} mergerfs pools", pools.len());
        Ok(pools)
    }
@ -377,9 +413,9 @@ impl DiskCollector {
        device.to_string()
    }
-    /// Get SMART data for drives in parallel
+    /// Get SMART data for drives
    async fn get_smart_data_for_drives(&self, physical_drives: &[PhysicalDrive], mergerfs_pools: &[MergerfsPool]) -> HashMap<String, SmartData> {
-        use futures::future::join_all;
+        let mut smart_data = HashMap::new();
        // Collect all drive names
        let mut all_drives = std::collections::HashSet::new();
@ -395,24 +431,9 @@ impl DiskCollector {
            }
        }
-        // Collect SMART data for all drives in parallel
+        // Get SMART data for each drive
-        let futures: Vec<_> = all_drives
+        for drive_name in all_drives {
-            .iter()
+            if let Ok(data) = self.get_smart_data(&drive_name).await {
            .map(|drive_name| {
                let drive = drive_name.clone();
                async move {
                    let result = self.get_smart_data(&drive).await;
                    (drive, result)
                }
            })
            .collect();
        let results = join_all(futures).await;
        // Build HashMap from results
        let mut smart_data = HashMap::new();
        for (drive_name, result) in results {
            if let Ok(data) = result {
                smart_data.insert(drive_name, data);
            }
        }
@ -426,14 +447,14 @@ impl DiskCollector {
        // 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 = TokioCommand::new("smartctl");
+        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, 15).await
+        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(),
@ -441,10 +462,8 @@ impl DiskCollector {
        let output_str = String::from_utf8_lossy(&output.stdout);
-        // Note: smartctl returns non-zero exit codes for warnings (like exit code 32
+        if !output.status.success() {
-        // for "temperature was high in the past"), but the output data is still valid.
+            // Return unknown data rather than failing completely
        // Only check if we got any output at all, don't reject based on exit code.
        if output_str.is_empty() {
            return Ok(SmartData {
                health: "UNKNOWN".to_string(),
                serial_number: None,
@ -768,18 +787,15 @@ impl DiskCollector {
        Ok((data_drives, parity_drives))
    }
-    /// Get drive information for a mount path
+    /// Get drive information for a mount path by reading /proc/mounts
    fn get_drive_info_for_path(&self, path: &str) -> anyhow::Result<PoolDrive> {
-        // Use lsblk to find the backing device with timeout
+        // Read /proc/mounts to find the backing device
-        let output = StdCommand::new("timeout")
+        let content = std::fs::read_to_string("/proc/mounts")
-            .args(&["10", "lsblk", "-rn", "-o", "NAME,MOUNTPOINT"])
+            .map_err(|e| anyhow::anyhow!("Failed to read /proc/mounts: {}", e))?;
            .output()
            .map_err(|e| anyhow::anyhow!("Failed to run lsblk: {}", e))?;
        let output_str = String::from_utf8_lossy(&output.stdout);
        let mut device = String::new();
-        for line in output_str.lines() {
+        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();
@ -791,15 +807,22 @@ impl DiskCollector {
            return Err(anyhow::anyhow!("Could not find device for path {}", path));
        }
-        // Extract base device name (e.g., "sda1" -> "sda")
+        // Extract base device name (e.g., "/dev/sda1" -> "sda")
-        let base_device = self.extract_base_device(&format!("/dev/{}", device));
+        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
        };
        // Temperature will be filled in later from parallel SMART collection
        // Don't collect it here to avoid sequential blocking with problematic async nesting
        Ok(PoolDrive {
            name: base_device,
            mount_point: path.to_string(),
-            temperature_celsius: None,
+            temperature_celsius: temperature,
        })
    }
@ -839,7 +862,15 @@ impl DiskCollector {
 #[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
        }
    }
 }
--- a/agent/src/collectors/memory.rs
+++ b/agent/src/collectors/memory.rs
@ -95,8 +95,10 @@ 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()?;
@ -105,52 +107,35 @@ impl MemoryCollector {
            return Ok(());
        }
-        // Get usage data for all tmpfs mounts at once using df (with 2 second timeout)
+        // Get usage data for each tmpfs mount using statvfs syscall
-        let mut df_args = vec!["2", "df", "--output=target,size,used", "--block-size=1"];
+        for mount_point in tmpfs_mounts {
-        df_args.extend(tmpfs_mounts.iter().map(|s| s.as_str()));
+            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("timeout")
+                    if total_bytes == 0 {
-            .args(&df_args[..])
+                        continue;
-            .output()
+                    }
            .map_err(|e| CollectorError::SystemRead {
                path: "tmpfs mounts".to_string(),
                error: e.to_string(),
            })?;
-        let df_str = String::from_utf8_lossy(&df_output.stdout);
+                    let total_gb = total_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
-        let df_lines: Vec<&str> = df_str.lines().skip(1).collect(); // Skip header
+                    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
+                    // Add to tmpfs list
-        for (i, mount_point) in tmpfs_mounts.iter().enumerate() {
+                    agent_data.system.memory.tmpfs.push(TmpfsData {
-            if i >= df_lines.len() {
+                        mount: mount_point.clone(),
-                debug!("Not enough df output lines for tmpfs mount: {}", mount_point);
+                        usage_percent,
-                continue;
+                        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
@ -200,9 +185,6 @@ impl Collector for MemoryCollector {
        debug!("Collecting memory metrics");
        let start = std::time::Instant::now();
        // Clear tmpfs list to prevent duplicates when updating cached data
        agent_data.system.memory.tmpfs.clear();
        // Parse memory info from /proc/meminfo
        let info = self.parse_meminfo().await?;
--- a/agent/src/collectors/mod.rs
+++ b/agent/src/collectors/mod.rs
@ -1,7 +1,8 @@
 use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData};
-use std::process::Output;
+use std::process::{Command, Output};
 use std::time::Duration;
 use tokio::time::timeout;
 pub mod backup;
 pub mod cpu;
@ -15,34 +16,16 @@ pub mod systemd;
 pub use error::CollectorError;
 /// Run a command with a timeout to prevent blocking
-/// Properly kills the process if timeout is exceeded
+pub async fn run_command_with_timeout(mut cmd: Command, timeout_secs: u64) -> std::io::Result<Output> {
 pub async fn run_command_with_timeout(mut cmd: tokio::process::Command, timeout_secs: u64) -> std::io::Result<Output> {
    use tokio::time::timeout;
    use std::process::Stdio;
    let timeout_duration = Duration::from_secs(timeout_secs);
-    // Configure stdio to capture output
+    match timeout(timeout_duration, tokio::task::spawn_blocking(move || cmd.output())).await {
-    cmd.stdout(Stdio::piped());
+        Ok(Ok(result)) => result,
-    cmd.stderr(Stdio::piped());
+        Ok(Err(e)) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
-
+        Err(_) => Err(std::io::Error::new(
-    let child = cmd.spawn()?;
+            std::io::ErrorKind::TimedOut,
-    let pid = child.id();
+            format!("Command timed out after {} seconds", timeout_secs)
-
+        )),
    match timeout(timeout_duration, child.wait_with_output()).await {
        Ok(result) => result,
        Err(_) => {
            // Timeout - force kill the process using system kill command
            if let Some(process_id) = pid {
                let _ = tokio::process::Command::new("kill")
                    .args(&["-9", &process_id.to_string()])
                    .output()
                    .await;
            }
            Err(std::io::Error::new(
                std::io::ErrorKind::TimedOut,
                format!("Command timed out after {} seconds", timeout_secs)
            ))
        }
    }
 }
--- a/agent/src/collectors/network.rs
+++ b/agent/src/collectors/network.rs
@ -1,7 +1,12 @@
 use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData, NetworkInterfaceData, Status};
 use std::process::Command;
 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;
@ -49,36 +54,52 @@ impl NetworkCollector {
        }
    }
-    /// Get the primary physical interface (the one with default route)
+    /// Get the primary physical interface (the one with default route) using rtnetlink
-    fn get_primary_physical_interface() -> Option<String> {
+    async fn get_primary_physical_interface() -> Option<String> {
-        match Command::new("timeout").args(["2", "ip", "route", "show", "default"]).output() {
+        let (connection, handle, _) = match new_connection() {
-            Ok(output) if output.status.success() => {
+            Ok(conn) => conn,
-                let output_str = String::from_utf8_lossy(&output.stdout);
+            Err(e) => {
-                // Parse: "default via 192.168.1.1 dev eno1 ..."
+                debug!("Failed to create netlink connection: {}", e);
-                for line in output_str.lines() {
+                return None;
-                    if line.starts_with("default") {
+            }
-                        if let Some(dev_pos) = line.find(" dev ") {
+        };
-                            let after_dev = &line[dev_pos + 5..];
+
-                            if let Some(space_pos) = after_dev.find(' ') {
+        tokio::spawn(connection);
-                                let interface = &after_dev[..space_pos];
+
-                                // Only return if it's a physical interface
+        // Get default route
-                                if Self::is_physical_interface(interface) {
+        let mut routes = handle.route().get(IpVersion::V4).execute();
-                                    return Some(interface.to_string());
+
-                                }
+        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 {
-                                // No space after interface name (end of line)
+                                None
-                                let interface = after_dev.trim();
+                            }
-                                if Self::is_physical_interface(interface) {
+                        }) {
-                                    return Some(interface.to_string());
+                            if Self::is_physical_interface(&name) {
-                                }
+                                return Some(name);
                            }
                        }
                    }
                }
                None
            }
            _ => None,
        }
        None
    }
    /// Parse VLAN configuration from /proc/net/vlan/config
@ -103,103 +124,105 @@ impl NetworkCollector {
        vlan_map
    }
-    /// Collect network interfaces using ip command
+    /// 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();
-        match Command::new("timeout").args(["2", "ip", "-j", "addr"]).output() {
+        // Create netlink connection
-            Ok(output) if output.status.success() => {
+        let (connection, handle, _) = match new_connection() {
-                let json_str = String::from_utf8_lossy(&output.stdout);
+            Ok(conn) => conn,
            Err(e) => {
                debug!("Failed to create netlink connection: {}", e);
                return interfaces;
            }
        };
-                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
+        tokio::spawn(connection);
                    if let Some(ifaces) = json_data.as_array() {
                        for iface in ifaces {
                            let name = iface["ifname"].as_str().unwrap_or("").to_string();
-                            // Skip loopback, empty names, and ifb* interfaces
+        // Get all links
-                            if name.is_empty() || name == "lo" || name.starts_with("ifb") {
+        let mut links = handle.link().get().execute();
                                continue;
                            }
-                            // Parse parent interface from @parent notation (e.g., lan@enp0s31f6)
+        while let Ok(Some(link)) = links.try_next().await {
-                            let (interface_name, parent_interface) = if let Some(at_pos) = name.find('@') {
+            // Get interface name
-                                let (child, parent) = name.split_at(at_pos);
+            let name = match link.attributes.iter().find_map(|attr| {
-                                (child.to_string(), Some(parent[1..].to_string()))
+                if let LinkAttribute::IfName(n) = attr {
-                            } else {
+                    Some(n.to_string())
-                                (name.clone(), None)
+                } else {
-                            };
+                    None
                }
            }) {
                Some(n) => n,
                None => continue,
            };
-                            let mut ipv4_addresses = Vec::new();
+            // Skip loopback and ifb interfaces
-                            let mut ipv6_addresses = Vec::new();
+            if name == "lo" || name.starts_with("ifb") {
                continue;
            }
-                            // Extract IP addresses
+            // Parse parent interface from @parent notation (e.g., lan@enp0s31f6)
-                            if let Some(addr_info) = iface["addr_info"].as_array() {
+            let (interface_name, parent_interface) = if let Some(at_pos) = name.find('@') {
-                                for addr in addr_info {
+                let (child, parent) = name.split_at(at_pos);
-                                    if let Some(family) = addr["family"].as_str() {
+                (child.to_string(), Some(parent[1..].to_string()))
-                                        if let Some(local) = addr["local"].as_str() {
+            } else {
-                                            match family {
+                (name.clone(), None)
-                                                "inet" => ipv4_addresses.push(local.to_string()),
+            };
-                                                "inet6" => {
+
-                                                    // Skip link-local IPv6 addresses (fe80::)
+            // Get IP addresses for this interface
-                                                    if !local.starts_with("fe80:") {
+            let mut ipv4_addresses = Vec::new();
-                                                        ipv6_addresses.push(local.to_string());
+            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 and get status
                            let is_physical = Self::is_physical_interface(&interface_name);
                            // Only filter out virtual interfaces without IPs
                            // Physical interfaces should always be shown even if down/no 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  // Virtual interfaces don't have meaningful link status
                            };
                            // Look up VLAN ID from the map (use original name before @ parsing)
                            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,
                                connection_method: None,
                            });
                        }
                    }
                }
            }
-            Err(e) => {
+
-                debug!("Failed to execute ip command: {}", e);
+            // Determine if physical
-            }
+            let is_physical = Self::is_physical_interface(&interface_name);
-            Ok(output) => {
+
-                debug!("ip command failed with status: {}", output.status);
+            // 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 without explicit parent
+        // Assign primary physical interface as parent to virtual interfaces
-        let primary_interface = Self::get_primary_physical_interface();
+        if let Some(primary) = Self::get_primary_physical_interface().await {
        if let Some(primary) = primary_interface {
            for interface in interfaces.iter_mut() {
                // Only assign parent to virtual interfaces that don't already have one
                if !interface.is_physical && interface.parent_interface.is_none() {
                    interface.parent_interface = Some(primary.clone());
                }
--- a/agent/src/collectors/systemd.rs
+++ b/agent/src/collectors/systemd.rs
@ -4,7 +4,10 @@ use cm_dashboard_shared::{AgentData, ServiceData, SubServiceData, SubServiceMetr
 use std::process::Command;
 use std::sync::RwLock;
 use std::time::Instant;
-use tracing::{debug, info};
+use tracing::{debug, warn};
 use bollard::Docker;
 use bollard::container::ListContainersOptions;
 use zbus::Connection;
 use super::{Collector, CollectorError};
 use crate::config::SystemdConfig;
@ -43,10 +46,9 @@ struct ServiceCacheState {
 /// Cached service status information from systemctl list-units
 #[derive(Debug, Clone)]
 struct ServiceStatusInfo {
    load_state: String,
    active_state: String,
-    memory_bytes: Option<u64>,
+    sub_state: String,
    restart_count: Option<u32>,
    start_timestamp: Option<u64>,
 }
 impl SystemdCollector {
@ -75,7 +77,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);
@ -87,20 +89,14 @@ impl SystemdCollector {
        let mut complete_service_data = Vec::new();
        for service_name in &monitored_services {
            match self.get_service_status(service_name) {
-                Ok(status_info) => {
+                Ok((active_status, _detailed_info)) => {
                    let memory_mb = self.get_service_memory_usage(service_name).await.unwrap_or(0.0);
                    let disk_gb = self.get_service_disk_usage(service_name).await.unwrap_or(0.0);
                    let mut sub_services = Vec::new();
                    // Calculate uptime if we have start timestamp
                    let uptime_seconds = status_info.start_timestamp.and_then(|start| {
                        let now = std::time::SystemTime::now()
                            .duration_since(std::time::UNIX_EPOCH)
                            .ok()?
                            .as_secs();
                        Some(now.saturating_sub(start))
                    });
                    // Sub-service metrics for specific services (always include cached results)
-                    if service_name.contains("nginx") && status_info.active_state == "active" {
+                    if service_name.contains("nginx") && active_status == "active" {
                        let nginx_sites = self.get_nginx_site_metrics();
                        for (site_name, latency_ms) in nginx_sites {
                            let site_status = if latency_ms >= 0.0 && latency_ms < self.config.nginx_latency_critical_ms {
@ -125,8 +121,8 @@ impl SystemdCollector {
                        }
                    }
-                    if service_name.contains("docker") && status_info.active_state == "active" {
+                    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.
@ -141,136 +137,32 @@ impl SystemdCollector {
                        }
                        // Add Docker images
-                        let docker_images = self.get_docker_images();
+                        let docker_images = self.get_docker_images().await;
-                        for (image_name, _image_status, image_size_mb) in docker_images {
+                        for (image_name, image_status, image_size_mb) in docker_images {
-                            let metrics = Vec::new();
+                            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: format!("{} size: {:.1} MB", image_name, image_size_mb),
+                                name: image_name.to_string(),
-                                service_status: Status::Info,  // Informational only, no status icon
+                                service_status: self.calculate_service_status(&image_name, &image_status),
                                metrics,
                                service_type: "image".to_string(),
                            });
                        }
                    }
                    if service_name == "openvpn-vpn-download" && status_info.active_state == "active" {
                        // Add VPN route
                        if let Some(external_ip) = self.get_vpn_external_ip() {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("route: {}", external_ip),
                                service_status: Status::Info,
                                metrics,
                                service_type: "vpn_route".to_string(),
                            });
                        }
                        // Add torrent stats
                        if let Some((active_count, download_mbps, upload_mbps)) = self.get_qbittorrent_stats() {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("{} active, ↓ {:.1} MB/s, ↑ {:.1} MB/s", active_count, download_mbps, upload_mbps),
                                service_status: Status::Info,
                                metrics,
                                service_type: "torrent_stats".to_string(),
                            });
                        }
                        // Add active torrent copy status for each copy operation
                        for torrent_name in self.get_active_torrent_copies() {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("Copy: {}", torrent_name),
                                service_status: Status::Info,
                                metrics,
                                service_type: "torrent_copy".to_string(),
                            });
                        }
                    }
                    if service_name == "nftables" && status_info.active_state == "active" {
                        let (tcp_ports, udp_ports) = self.get_nftables_open_ports();
                        if !tcp_ports.is_empty() {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("wan tcp: {}", tcp_ports),
                                service_status: Status::Info,
                                metrics,
                                service_type: "firewall_port".to_string(),
                            });
                        }
                        if !udp_ports.is_empty() {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("wan udp: {}", udp_ports),
                                service_status: Status::Info,
                                metrics,
                                service_type: "firewall_port".to_string(),
                            });
                        }
                    }
                    if service_name == "tailscaled" && status_info.active_state == "active" {
                        // Add Tailscale peers with their connection methods as sub-services
                        let peers = self.get_tailscale_peers();
                        for (peer_name, conn_method) in peers {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("{}: {}", peer_name, conn_method),
                                service_status: Status::Info,
                                metrics,
                                service_type: "tailscale_peer".to_string(),
                            });
                        }
                    }
                    if service_name == "nfs-server" && status_info.active_state == "active" {
                        // Add NFS exports as sub-services
                        let exports = self.get_nfs_exports();
                        for (export_path, info) in exports {
                            let display = if !info.is_empty() {
                                format!("{} {}", export_path, info)
                            } else {
                                export_path
                            };
                            sub_services.push(SubServiceData {
                                name: display,
                                service_status: Status::Info,
                                metrics: Vec::new(),
                                service_type: "nfs_export".to_string(),
                            });
                        }
                    }
                    if (service_name == "smbd" || service_name == "samba-smbd") && status_info.active_state == "active" {
                        // Add SMB shares as sub-services
                        let shares = self.get_smb_shares();
                        for (share_name, share_path) in shares {
                            let metrics = Vec::new();
                            sub_services.push(SubServiceData {
                                name: format!("{}: {}", share_name, share_path),
                                service_status: Status::Info,
                                metrics,
                                service_type: "smb_share".to_string(),
                            });
                        }
                    }
                    // 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, &status_info.active_state),
+                        service_status: self.calculate_service_status(service_name, &active_status),
                        sub_services,
                        memory_bytes: status_info.memory_bytes,
                        restart_count: status_info.restart_count,
                        uptime_seconds,
                    };
                    // Add to AgentData and cache
@ -301,7 +193,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();
@ -316,7 +208,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();
@ -363,72 +255,46 @@ impl SystemdCollector {
        state.nginx_site_metrics.clone()
    }
-    /// Auto-discover interesting services to monitor
+    /// Auto-discover interesting services to monitor using D-Bus
-    fn discover_services_internal(&self) -> Result<(Vec<String>, std::collections::HashMap<String, ServiceStatusInfo>)> {
+    async fn discover_services_internal(&self) -> Result<(Vec<String>, std::collections::HashMap<String, ServiceStatusInfo>)> {
-        // First: Get all service unit files (with 3 second timeout)
+        // Connect to system D-Bus
-        let unit_files_output = Command::new("timeout")
+        let connection = Connection::system().await?;
            .args(&["3", "systemctl", "list-unit-files", "--type=service", "--no-pager", "--plain"])
            .output()?;
-        if !unit_files_output.status.success() {
+        // Get systemd manager proxy
-            return Err(anyhow::anyhow!("systemctl list-unit-files command failed"));
+        let proxy = zbus::Proxy::new(
            &connection,
            "org.freedesktop.systemd1",
            "/org/freedesktop/systemd1",
            "org.freedesktop.systemd1.Manager",
        ).await?;
        // List all units via D-Bus
        let units: Vec<(String, String, String, String, String, String, zbus::zvariant::OwnedObjectPath, u32, String, zbus::zvariant::OwnedObjectPath)> =
            proxy.call("ListUnits", &()).await?;
        let mut all_service_names = std::collections::HashSet::new();
        let mut service_status_cache = std::collections::HashMap::new();
        // Parse D-Bus response for services only
        for unit in units {
            let (unit_name, _description, load_state, active_state, sub_state, _followed, _unit_path, _job_id, _job_type, _job_path) = unit;
            if unit_name.ends_with(".service") {
                let service_name = unit_name.trim_end_matches(".service");
                all_service_names.insert(service_name.to_string());
                service_status_cache.insert(service_name.to_string(), ServiceStatusInfo {
                    load_state: load_state.clone(),
                    active_state: active_state.clone(),
                    sub_state: sub_state.clone(),
                });
            }
        }
        // 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() {
            return Err(anyhow::anyhow!("systemctl list-units command failed"));
        }
        let unit_files_str = String::from_utf8(unit_files_output.stdout)?;
        let units_status_str = String::from_utf8(units_status_output.stdout)?;
        let mut services = Vec::new();
        let excluded_services = &self.config.excluded_services;
        let service_name_filters = &self.config.service_name_filters;
        // Parse all service unit files
        let mut all_service_names = std::collections::HashSet::new();
        for line in unit_files_str.lines() {
            let fields: Vec<&str> = line.split_whitespace().collect();
            if fields.len() >= 2 && fields[0].ends_with(".service") {
                let service_name = fields[0].trim_end_matches(".service");
                all_service_names.insert(service_name.to_string());
            }
        }
        // Parse runtime status for all units
        let mut status_cache = std::collections::HashMap::new();
        for line in units_status_str.lines() {
            let fields: Vec<&str> = line.split_whitespace().collect();
            if fields.len() >= 4 && fields[0].ends_with(".service") {
                let service_name = fields[0].trim_end_matches(".service");
                let active_state = fields.get(2).unwrap_or(&"unknown").to_string();
                status_cache.insert(service_name.to_string(), ServiceStatusInfo {
                    active_state,
                    memory_bytes: None,
                    restart_count: None,
                    start_timestamp: None,
                });
            }
        }
        // For services found in unit files but not in runtime status, set default inactive status
        for service_name in &all_service_names {
            if !status_cache.contains_key(service_name) {
                status_cache.insert(service_name.to_string(), ServiceStatusInfo {
                    active_state: "inactive".to_string(),
                    memory_bytes: None,
                    restart_count: None,
                    start_timestamp: None,
                });
            }
        }
        // Process all discovered services and apply filters
        for service_name in &all_service_names {
            // Skip excluded services first
@ -453,63 +319,39 @@ impl SystemdCollector {
            }
        }
-        Ok((services, status_cache))
+        Ok((services, service_status_cache))
    }
-    /// Get service status with detailed metrics from systemctl
+    /// Get service status from cache (if available) or fallback to systemctl
-    fn get_service_status(&self, service: &str) -> Result<ServiceStatusInfo> {
+    fn get_service_status(&self, service: &str) -> Result<(String, String)> {
-        // Always fetch fresh data to get detailed metrics (memory, restarts, uptime)
+        // Try to get status from cache first
-        // Note: Cache in service_status_cache only has basic active_state from discovery,
+        if let Ok(state) = self.state.read() {
-        // with all detailed metrics set to None. We need fresh systemctl show data.
+            if let Some(cached_info) = state.service_status_cache.get(service) {
-
+                let active_status = cached_info.active_state.clone();
-        let output = Command::new("timeout")
+                let detailed_info = format!(
-            .args(&[
+                    "LoadState={}\nActiveState={}\nSubState={}",
-                "2",
+                    cached_info.load_state,
-                "systemctl",
+                    cached_info.active_state,
-                "show",
+                    cached_info.sub_state
-                &format!("{}.service", service),
+                );
-                "--property=LoadState,ActiveState,SubState,MemoryCurrent,NRestarts,ExecMainStartTimestamp"
+                return Ok((active_status, detailed_info));
            ])
            .output()?;
        let output_str = String::from_utf8(output.stdout)?;
        // Parse properties
        let mut active_state = String::new();
        let mut memory_bytes = None;
        let mut restart_count = None;
        let mut start_timestamp = None;
        for line in output_str.lines() {
            if let Some(value) = line.strip_prefix("ActiveState=") {
                active_state = value.to_string();
            } else if let Some(value) = line.strip_prefix("MemoryCurrent=") {
                if value != "[not set]" {
                    memory_bytes = value.parse().ok();
                }
            } else if let Some(value) = line.strip_prefix("NRestarts=") {
                restart_count = value.parse().ok();
            } else if let Some(value) = line.strip_prefix("ExecMainStartTimestamp=") {
                if value != "[not set]" && !value.is_empty() {
                    // Parse timestamp to seconds since epoch
                    if let Ok(output) = Command::new("date")
                        .args(&["+%s", "-d", value])
                        .output()
                    {
                        if let Ok(timestamp_str) = String::from_utf8(output.stdout) {
                            start_timestamp = timestamp_str.trim().parse().ok();
                        }
                    }
                }
            }
        }
-        Ok(ServiceStatusInfo {
+        // Fallback to systemctl if not in cache (with 2 second timeout)
-            active_state,
+        let output = Command::new("timeout")
-            memory_bytes,
+            .args(&["2", "systemctl", "is-active", &format!("{}.service", service)])
-            restart_count,
+            .output()?;
-            start_timestamp,
+
-        })
+        let active_status = String::from_utf8(output.stdout)?.trim().to_string();
        // Get more detailed info (with 2 second timeout)
        let output = Command::new("timeout")
            .args(&["2", "systemctl", "show", &format!("{}.service", service), "--property=LoadState,ActiveState,SubState"])
            .output()?;
        let detailed_info = String::from_utf8(output.stdout)?;
        Ok((active_status, detailed_info))
    }
    /// Check if service name matches pattern (supports wildcards like nginx*)
@ -551,6 +393,80 @@ impl SystemdCollector {
        true
    }
    /// Get disk usage for a specific service
    async fn get_service_disk_usage(&self, service_name: &str) -> Result<f32, CollectorError> {
        // Check if this service has configured directory paths
        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).await {
                    return Ok(size);
                }
            }
            // If configured paths failed, return 0
            return Ok(0.0);
        }
        // No configured path - try to get WorkingDirectory from systemctl (with 2 second timeout)
        let output = Command::new("timeout")
            .args(&["2", "systemctl", "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).await.unwrap_or(0.0));
                }
            }
        }
        Ok(0.0)
    }
    /// 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);
            }
            return None;
        }
        let output_str = String::from_utf8(output.stdout).ok()?;
        let size_str = output_str.split_whitespace().next()?;
        if let Ok(size_bytes) = size_str.parse::<u64>() {
            let size_gb = size_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
            // Return size even if very small (minimum 0.001 GB = 1MB for visibility)
            if size_gb > 0.0 {
                Some(size_gb.max(0.001))
            } else {
                None
            }
        } else {
            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() {
@ -568,6 +484,33 @@ impl SystemdCollector {
        }
    }
    /// Get memory usage for a specific service
    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
                        }
                    }
                }
            }
        }
        Ok(0.0)
    }
    /// Check if service collection cache should be updated
    fn should_update_cache(&self) -> bool {
        let state = self.state.read().unwrap();
@ -575,7 +518,7 @@ impl SystemdCollector {
        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
            }
        }
@ -815,94 +758,91 @@ impl SystemdCollector {
        }
    }
-    /// Get docker containers as sub-services
+    /// Get docker containers as sub-services using bollard API
-    fn get_docker_containers(&self) -> Vec<(String, String)> {
+    async fn get_docker_containers(&self) -> Vec<(String, String)> {
        let mut containers = Vec::new();
-        // Check if docker is available (cm-agent user is in docker group)
+        // Connect to Docker daemon
-        // Use -a to show ALL containers (running and stopped) with 3 second timeout
+        let docker = match Docker::connect_with_local_defaults() {
-        let output = Command::new("timeout")
+            Ok(d) => d,
-            .args(&["3", "docker", "ps", "-a", "--format", "{{.Names}},{{.Status}}"])
+            Err(e) => {
-            .output();
+                debug!("Failed to connect to Docker daemon: {}", e);
-
+                return containers;
-        let output = match output {
+            }
            Ok(out) if out.status.success() => out,
            _ => return containers, // Docker not available or failed
        };
-        let output_str = match String::from_utf8(output.stdout) {
+        // List all containers (running and stopped)
-            Ok(s) => s,
+        let list_options = Some(ListContainersOptions::<String> {
-            Err(_) => return containers,
+            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() {
+        for container in container_list {
-            if line.trim().is_empty() {
+            // Get container name (remove leading slash if present)
-                continue;
+            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();
+            // Map container state to service status
-            if parts.len() >= 2 {
+            let container_status = match container.state.as_deref() {
-                let container_name = parts[0].trim();
+                Some("running") => "active",
-                let status_str = parts[1].trim();
+                Some("exited") | Some("created") => "inactive",
                _ => "failed", // restarting, paused, dead, etc.
            };
-                let container_status = if status_str.contains("Up") {
+            containers.push((format!("docker_{}", container_name), container_status.to_string()));
                    "active"
                } else if status_str.contains("Exited") || status_str.contains("Created") {
                    "inactive" // Stopped/created containers are inactive
                } else {
                    "failed" // Other states (restarting, paused, dead) → failed
                };
                containers.push((format!("docker_{}", container_name), container_status.to_string()));
            }
        }
        containers
    }
-    /// Get docker images as sub-services
+    /// Get docker images as sub-services using bollard API
-    fn get_docker_images(&self) -> Vec<(String, String, f32)> {
+    async fn get_docker_images(&self) -> Vec<(String, String, f32)> {
        let mut images = Vec::new();
        // Check if docker is available (cm-agent user is in docker group) with 3 second timeout
        let output = Command::new("timeout")
            .args(&["3", "docker", "images", "--format", "{{.Repository}}:{{.Tag}},{{.Size}}"])
            .output();
-        let output = match output {
+        // Connect to Docker daemon
-            Ok(out) if out.status.success() => out,
+        let docker = match Docker::connect_with_local_defaults() {
-            Ok(_) => {
+            Ok(d) => d,
-                return images;
+            Err(e) => {
-            }
+                debug!("Failed to connect to Docker daemon: {}", e);
            Err(_) => {
                return images;
            }
        };
-        let output_str = match String::from_utf8(output.stdout) {
+        // List all images
-            Ok(s) => s,
+        let image_list = match docker.list_images::<String>(None).await {
-            Err(_) => return images,
+            Ok(list) => list,
            Err(e) => {
                debug!("Failed to list Docker images: {}", e);
                return images;
            }
        };
-        for line in output_str.lines() {
+        for image in image_list {
-            if line.trim().is_empty() {
+            // Get image name from repo tags
-                continue;
+            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
            }
-            let parts: Vec<&str> = line.split(',').collect();
+            // Get size in MB
-            if parts.len() >= 2 {
+            let size_mb = image.size as f32 / (1024.0 * 1024.0);
                let image_name = parts[0].trim();
                let size_str = parts[1].trim();
                // Skip <none>:<none> images (dangling images)
                if image_name.contains("<none>") {
                    continue;
                }
                // Parse size to MB (sizes come as "142MB", "1.5GB", "512kB", etc.)
                let size_mb = self.parse_docker_size(size_str);
            for image_name in image_names {
                images.push((
-                    image_name.to_string(),
+                    image_name,
                    "inactive".to_string(), // Images are informational - use inactive for neutral display
                    size_mb
                ));
@ -911,490 +851,11 @@ impl SystemdCollector {
        images
    }
    /// Parse Docker size string to MB
    fn parse_docker_size(&self, size_str: &str) -> f32 {
        let size_upper = size_str.to_uppercase();
        // Extract numeric part and unit
        let mut num_str = String::new();
        let mut unit = String::new();
        for ch in size_upper.chars() {
            if ch.is_ascii_digit() || ch == '.' {
                num_str.push(ch);
            } else if ch.is_alphabetic() {
                unit.push(ch);
            }
        }
        let value: f32 = num_str.parse().unwrap_or(0.0);
        // Convert to MB
        match unit.as_str() {
            "KB" | "K" => value / 1024.0,
            "MB" | "M" => value,
            "GB" | "G" => value * 1024.0,
            "TB" | "T" => value * 1024.0 * 1024.0,
            _ => value, // Assume bytes if no unit
        }
    }
    /// Get VPN external IP by querying through the vpn namespace
    fn get_vpn_external_ip(&self) -> Option<String> {
        let output = Command::new("timeout")
            .args(&[
                "5",
                "sudo",
                "ip",
                "netns",
                "exec",
                "vpn",
                "curl",
                "-s",
                "--max-time",
                "4",
                "https://ifconfig.me"
            ])
            .output()
            .ok()?;
        if output.status.success() {
            let ip = String::from_utf8_lossy(&output.stdout).trim().to_string();
            if !ip.is_empty() && ip.contains('.') {
                return Some(ip);
            }
        }
        None
    }
    /// Get Tailscale connected peers with their connection methods
    /// Returns a list of (device_name, connection_method) tuples
    fn get_tailscale_peers(&self) -> Vec<(String, String)> {
        match Command::new("timeout")
            .args(["2", "tailscale", "status"])
            .output()
        {
            Ok(output) if output.status.success() => {
                let status_output = String::from_utf8_lossy(&output.stdout);
                let mut peers = Vec::new();
                // Get current hostname to filter it out
                let current_hostname = gethostname::gethostname()
                    .to_string_lossy()
                    .to_string();
                // Parse tailscale status output
                // Format: IP  hostname  user  os  status
                // Example: 100.110.98.3    wslbox               cm@          linux   active; direct 192.168.30.227:53757
                // Note: First line is always the current host, skip it
                for (idx, line) in status_output.lines().enumerate() {
                    if idx == 0 {
                        continue; // Skip first line (current host)
                    }
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    if parts.len() < 5 {
                        continue; // Skip invalid lines
                    }
                    // parts[0] = IP
                    // parts[1] = hostname
                    // parts[2] = user
                    // parts[3] = OS
                    // parts[4+] = status (e.g., "active;", "direct", "192.168.30.227:53757" or "idle;" or "offline")
                    let hostname = parts[1];
                    // Skip if this is the current host (double-check in case format changes)
                    if hostname == current_hostname {
                        continue;
                    }
                    let status_parts = &parts[4..];
                    // Determine connection method from status
                    let connection_method = if status_parts.is_empty() {
                        continue; // Skip if no status
                    } else {
                        let status_str = status_parts.join(" ");
                        if status_str.contains("offline") {
                            continue; // Skip offline peers
                        } else if status_str.contains("direct") {
                            "direct"
                        } else if status_str.contains("relay") {
                            "relay"
                        } else if status_str.contains("idle") {
                            "idle"
                        } else if status_str.contains("active") {
                            "active"
                        } else {
                            continue; // Skip unknown status
                        }
                    };
                    peers.push((hostname.to_string(), connection_method.to_string()));
                }
                peers
            }
            _ => Vec::new(),
        }
    }
    /// Get NFS exports from exportfs
    /// Returns a list of (export_path, info_string) tuples
    fn get_nfs_exports(&self) -> Vec<(String, String)> {
        let output = match Command::new("timeout")
            .args(["2", "exportfs", "-v"])
            .output()
        {
            Ok(output) if output.status.success() => output,
            _ => return Vec::new(),
        };
        let exports_output = String::from_utf8_lossy(&output.stdout);
        let mut exports_map: std::collections::HashMap<String, Vec<(String, String)>> =
            std::collections::HashMap::new();
        let mut current_path: Option<String> = None;
        for line in exports_output.lines() {
            let trimmed = line.trim();
            if trimmed.is_empty() || trimmed.starts_with('#') {
                continue;
            }
            if trimmed.starts_with('/') {
                // Export path line - may have network on same line or continuation
                let parts: Vec<&str> = trimmed.splitn(2, char::is_whitespace).collect();
                let path = parts[0].to_string();
                current_path = Some(path.clone());
                // Check if network info is on the same line
                if parts.len() > 1 {
                    let rest = parts[1].trim();
                    if let Some(paren_pos) = rest.find('(') {
                        let network = rest[..paren_pos].trim();
                        if let Some(end_paren) = rest.find(')') {
                            let options = &rest[paren_pos+1..end_paren];
                            let mode = if options.contains(",rw,") || options.ends_with(",rw") {
                                "rw"
                            } else {
                                "ro"
                            };
                            exports_map.entry(path)
                                .or_insert_with(Vec::new)
                                .push((network.to_string(), mode.to_string()));
                        }
                    }
                }
            } else if let Some(ref path) = current_path {
                // Continuation line with network and options
                if let Some(paren_pos) = trimmed.find('(') {
                    let network = trimmed[..paren_pos].trim();
                    if let Some(end_paren) = trimmed.find(')') {
                        let options = &trimmed[paren_pos+1..end_paren];
                        let mode = if options.contains(",rw,") || options.ends_with(",rw") {
                            "rw"
                        } else {
                            "ro"
                        };
                        exports_map.entry(path.clone())
                            .or_insert_with(Vec::new)
                            .push((network.to_string(), mode.to_string()));
                    }
                }
            }
        }
        // Build display strings: "path: mode [networks]"
        let mut exports: Vec<(String, String)> = exports_map
            .into_iter()
            .map(|(path, mut entries)| {
                if entries.is_empty() {
                    return (path, String::new());
                }
                let mode = entries[0].1.clone();
                let networks: Vec<String> = entries.drain(..).map(|(n, _)| n).collect();
                let info = format!("{} [{}]", mode, networks.join(", "));
                (path, info)
            })
            .collect();
        exports.sort_by(|a, b| a.0.cmp(&b.0));
        exports
    }
    /// Get SMB shares from smb.conf
    /// Returns a list of (share_name, share_path) tuples
    fn get_smb_shares(&self) -> Vec<(String, String)> {
        match std::fs::read_to_string("/etc/samba/smb.conf") {
            Ok(config) => {
                let mut shares = Vec::new();
                let mut current_share: Option<String> = None;
                let mut current_path: Option<String> = None;
                for line in config.lines() {
                    let line = line.trim();
                    // Skip comments and empty lines
                    if line.is_empty() || line.starts_with('#') || line.starts_with(';') {
                        continue;
                    }
                    // Detect share section [sharename]
                    if line.starts_with('[') && line.ends_with(']') {
                        // Save previous share if we have both name and path
                        if let (Some(name), Some(path)) = (current_share.take(), current_path.take()) {
                            // Skip special sections
                            if name != "global" && name != "homes" && name != "printers" {
                                shares.push((name, path));
                            }
                        }
                        // Start new share
                        let share_name = line[1..line.len()-1].trim().to_string();
                        current_share = Some(share_name);
                        current_path = None;
                    }
                    // Look for path = /some/path
                    else if line.starts_with("path") && line.contains('=') {
                        if let Some(path_value) = line.split('=').nth(1) {
                            current_path = Some(path_value.trim().to_string());
                        }
                    }
                }
                // Don't forget the last share
                if let (Some(name), Some(path)) = (current_share, current_path) {
                    if name != "global" && name != "homes" && name != "printers" {
                        shares.push((name, path));
                    }
                }
                shares
            }
            _ => Vec::new(),
        }
    }
    /// Get nftables open ports grouped by protocol
    /// Returns: (tcp_ports_string, udp_ports_string)
    fn get_nftables_open_ports(&self) -> (String, String) {
        let output = Command::new("sudo")
            .args(&["/run/current-system/sw/bin/nft", "list", "ruleset"])
            .output();
        let output = match output {
            Ok(out) if out.status.success() => out,
            Ok(out) => {
                info!("nft command failed with status: {:?}, stderr: {}",
                    out.status, String::from_utf8_lossy(&out.stderr));
                return (String::new(), String::new());
            }
            Err(e) => {
                info!("Failed to execute nft command: {}", e);
                return (String::new(), String::new());
            }
        };
        let output_str = match String::from_utf8(output.stdout) {
            Ok(s) => s,
            Err(_) => {
                info!("Failed to parse nft output as UTF-8");
                return (String::new(), String::new());
            }
        };
        let mut tcp_ports = std::collections::HashSet::new();
        let mut udp_ports = std::collections::HashSet::new();
        // Parse nftables output for WAN incoming accept rules with dport
        // Looking for patterns like: tcp dport 22 accept or tcp dport { 22, 80, 443 } accept
        // Only include rules in input_wan chain
        let mut in_wan_chain = false;
        for line in output_str.lines() {
            let line = line.trim();
            // Track if we're in the input_wan chain
            if line.contains("chain input_wan") {
                in_wan_chain = true;
                continue;
            }
            // Reset when exiting chain (closing brace) or entering other chains
            if line == "}" || (line.starts_with("chain ") && !line.contains("input_wan")) {
                in_wan_chain = false;
                continue;
            }
            // Only process rules in input_wan chain
            if !in_wan_chain {
                continue;
            }
            // Skip if not an accept rule
            if !line.contains("accept") {
                continue;
            }
            // Parse TCP ports
            if line.contains("tcp dport") {
                for port in self.extract_ports_from_nft_rule(line) {
                    tcp_ports.insert(port);
                }
            }
            // Parse UDP ports
            if line.contains("udp dport") {
                for port in self.extract_ports_from_nft_rule(line) {
                    udp_ports.insert(port);
                }
            }
        }
        // Sort and format
        let mut tcp_vec: Vec<u16> = tcp_ports.into_iter().collect();
        let mut udp_vec: Vec<u16> = udp_ports.into_iter().collect();
        tcp_vec.sort();
        udp_vec.sort();
        let tcp_str = tcp_vec.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(", ");
        let udp_str = udp_vec.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(", ");
        info!("nftables WAN ports - TCP: '{}', UDP: '{}'", tcp_str, udp_str);
        (tcp_str, udp_str)
    }
    /// Extract port numbers from nftables rule line
    /// Returns vector of ports (handles both single ports and sets)
    fn extract_ports_from_nft_rule(&self, line: &str) -> Vec<u16> {
        let mut ports = Vec::new();
        // Pattern: "tcp dport 22 accept" or "tcp dport { 22, 80, 443 } accept"
        if let Some(dport_pos) = line.find("dport") {
            let after_dport = &line[dport_pos + 5..].trim();
            // Handle port sets like { 22, 80, 443 }
            if after_dport.starts_with('{') {
                if let Some(end_brace) = after_dport.find('}') {
                    let ports_str = &after_dport[1..end_brace];
                    // Parse each port in the set
                    for port_str in ports_str.split(',') {
                        if let Ok(port) = port_str.trim().parse::<u16>() {
                            ports.push(port);
                        }
                    }
                }
            } else {
                // Single port
                if let Some(port_str) = after_dport.split_whitespace().next() {
                    if let Ok(port) = port_str.parse::<u16>() {
                        ports.push(port);
                    }
                }
            }
        }
        ports
    }
    /// Get aggregate qBittorrent torrent statistics
    /// Returns: (active_count, download_mbps, upload_mbps)
    fn get_qbittorrent_stats(&self) -> Option<(u32, f32, f32)> {
        // Query qBittorrent API through VPN namespace
        let output = Command::new("timeout")
            .args(&[
                "5",
                "sudo",
                "ip",
                "netns",
                "exec",
                "vpn",
                "curl",
                "-s",
                "--max-time",
                "4",
                "http://localhost:8080/api/v2/torrents/info"
            ])
            .output()
            .ok()?;
        if !output.status.success() {
            return None;
        }
        let output_str = String::from_utf8_lossy(&output.stdout);
        let torrents: Vec<serde_json::Value> = serde_json::from_str(&output_str).ok()?;
        let mut active_count = 0u32;
        let mut total_download_bps = 0.0f64;
        let mut total_upload_bps = 0.0f64;
        for torrent in torrents {
            let state = torrent["state"].as_str().unwrap_or("");
            let dlspeed = torrent["dlspeed"].as_f64().unwrap_or(0.0);
            let upspeed = torrent["upspeed"].as_f64().unwrap_or(0.0);
            // States: downloading, uploading, stalledDL, stalledUP, queuedDL, queuedUP, pausedDL, pausedUP
            // Count as active if downloading or uploading (seeding)
            if state.contains("downloading") || state.contains("uploading") ||
               state == "stalledDL" || state == "stalledUP" {
                active_count += 1;
            }
            total_download_bps += dlspeed;
            total_upload_bps += upspeed;
        }
        // qBittorrent returns bytes/s, convert to MB/s
        let download_mbps = (total_download_bps / 1024.0 / 1024.0) as f32;
        let upload_mbps = (total_upload_bps / 1024.0 / 1024.0) as f32;
        Some((active_count, download_mbps, upload_mbps))
    }
    /// Check for active torrent copy operations
    /// Returns: Vec of filenames currently being copied
    fn get_active_torrent_copies(&self) -> Vec<String> {
        let marker_dir = "/tmp/torrent-copy";
        let mut active_copies = Vec::new();
        // Read all marker files from directory
        if let Ok(entries) = std::fs::read_dir(marker_dir) {
            for entry in entries.flatten() {
                if let Ok(file_type) = entry.file_type() {
                    if file_type.is_file() {
                        // Filename is the marker (sanitized torrent name)
                        if let Some(filename) = entry.file_name().to_str() {
                            // Convert sanitized name back (replace _ with /)
                            let display_name = filename.replace('_', "/");
                            active_copies.push(display_name);
                        }
                    }
                }
            }
        }
        active_copies
    }
 }
 #[async_trait]
 impl Collector for SystemdCollector {
    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
        // Clear services to prevent duplicates when updating cached data
        agent_data.services.clear();
        // 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 {
--- a/agent/src/config/mod.rs
+++ b/agent/src/config/mod.rs
@ -13,6 +13,7 @@ pub struct AgentConfig {
    pub collectors: CollectorConfig,
    pub cache: CacheConfig,
    pub notifications: NotificationConfig,
    pub collection_interval_seconds: u64,
 }
 /// ZMQ communication configuration
--- a/agent/src/config/validation.rs
+++ b/agent/src/config/validation.rs
@ -11,9 +11,9 @@ pub fn validate_config(config: &AgentConfig) -> Result<()> {
        bail!("ZMQ bind address cannot be empty");
    }
-    // Validate ZMQ transmission interval
+    // Validate collection interval
-    if config.zmq.transmission_interval_seconds == 0 {
+    if config.collection_interval_seconds == 0 {
-        bail!("ZMQ transmission interval cannot be 0");
+        bail!("Collection interval cannot be 0");
    }
    // Validate CPU thresholds
--- a/dashboard/Cargo.toml
+++ b/dashboard/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.275"
+version = "0.1.197"
 edition = "2021"
 [dependencies]
--- a/dashboard/src/app.rs
+++ b/dashboard/src/app.rs
@ -1,10 +1,10 @@
 use anyhow::Result;
 use crossterm::{
-    event::{self, EnableMouseCapture, DisableMouseCapture, Event, MouseEvent, MouseEventKind, MouseButton},
+    event::{self},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use ratatui::{backend::CrosstermBackend, Terminal, layout::Rect};
+use ratatui::{backend::CrosstermBackend, Terminal};
 use std::io;
 use std::time::{Duration, Instant};
 use tracing::{debug, error, info, warn};
@ -22,9 +22,6 @@ pub struct Dashboard {
    headless: bool,
    initial_commands_sent: std::collections::HashSet<String>,
    config: DashboardConfig,
    title_area: Rect, // Store title area for mouse event handling
    system_area: Rect, // Store system area for mouse event handling
    services_area: Rect, // Store services area for mouse event handling
 }
 impl Dashboard {
@ -95,7 +92,7 @@ impl Dashboard {
            }
            let mut stdout = io::stdout();
-            if let Err(e) = execute!(stdout, EnterAlternateScreen, EnableMouseCapture) {
+            if let Err(e) = execute!(stdout, EnterAlternateScreen) {
                error!("Failed to enter alternate screen: {}", e);
                let _ = disable_raw_mode();
                return Err(e.into());
@ -124,9 +121,6 @@ impl Dashboard {
            headless,
            initial_commands_sent: std::collections::HashSet::new(),
            config,
            title_area: Rect::default(),
            system_area: Rect::default(),
            services_area: Rect::default(),
        })
    }
@ -138,45 +132,27 @@ impl Dashboard {
        let metrics_check_interval = Duration::from_millis(100); // Check for metrics every 100ms
        let mut last_heartbeat_check = Instant::now();
        let heartbeat_check_interval = Duration::from_secs(1); // Check for host connectivity every 1 second
        let mut needs_render = true; // Track if we need to render
        loop {
-            // Handle terminal events (keyboard and mouse input) only if not headless
+            // Handle terminal events (keyboard input) only if not headless
            if !self.headless {
-                match event::poll(Duration::from_millis(200)) {
+                match event::poll(Duration::from_millis(50)) {
                    Ok(true) => {
                        match event::read() {
                            Ok(event) => {
                                if let Some(ref mut tui_app) = self.tui_app {
-                                    match event {
+                                    // Handle input
-                                        Event::Key(_) => {
+                                    match tui_app.handle_input(event) {
-                                            // Handle keyboard input
+                                        Ok(_) => {
-                                            match tui_app.handle_input(event) {
+                                            // Check if we should quit
-                                                Ok(_) => {
+                                            if tui_app.should_quit() {
-                                                    needs_render = true;
+                                                info!("Quit requested, exiting dashboard");
-                                                    // Check if we should quit
+                                                break;
                                                    if tui_app.should_quit() {
                                                        info!("Quit requested, exiting dashboard");
                                                        break;
                                                    }
                                                }
                                                Err(e) => {
                                                    error!("Error handling input: {}", e);
                                                }
                                            }
                                        }
-                                        Event::Mouse(mouse_event) => {
+                                        Err(e) => {
-                                            // Handle mouse events
+                                            error!("Error handling input: {}", e);
                                            if let Err(e) = self.handle_mouse_event(mouse_event) {
                                                error!("Error handling mouse event: {}", e);
                                            }
                                            needs_render = true;
                                        }
                                        Event::Resize(_width, _height) => {
                                            // Terminal was resized - mark for re-render
                                            needs_render = true;
                                        }
                                        _ => {}
                                    }
                                }
                            }
@ -192,6 +168,17 @@ impl Dashboard {
                        break;
                    }
                }
                // Render UI immediately after handling input for responsive feedback
                if let Some(ref mut terminal) = self.terminal {
                    if let Some(ref mut tui_app) = self.tui_app {
                        if let Err(e) = terminal.draw(|frame| {
                            tui_app.render(frame, &self.metric_store);
                        }) {
                            error!("Error rendering TUI after input: {}", e);
                        }
                    }
                }
            }
            // Check for new metrics
@ -230,8 +217,6 @@ impl Dashboard {
                    if let Some(ref mut tui_app) = self.tui_app {
                        tui_app.update_metrics(&mut self.metric_store);
                    }
                    needs_render = true; // New metrics received, need to render
                }
                // Also check for command output messages
@ -260,416 +245,31 @@ impl Dashboard {
                    tui_app.update_hosts(connected_hosts);
                }
                last_heartbeat_check = Instant::now();
                needs_render = true; // Heartbeat check happened, may have changed hosts
            }
-            // Render TUI only when needed (not headless and something changed)
+            // Render TUI (only if not headless)
-            if !self.headless && needs_render {
+            if !self.headless {
                if let Some(ref mut terminal) = self.terminal {
                    if let Some(ref mut tui_app) = self.tui_app {
-                        // Clear and autoresize terminal to handle any resize events
+                        if let Err(e) = terminal.draw(|frame| {
-                        if let Err(e) = terminal.autoresize() {
+                            tui_app.render(frame, &self.metric_store);
                            warn!("Error autoresizing terminal: {}", e);
                        }
                        // Check minimum terminal size to prevent panics
                        let size = terminal.size().unwrap_or_default();
                        if size.width < 90 || size.height < 15 {
                            // Terminal too small, show error message
                            let msg_text = format!("Terminal too small\n\nMinimum: 90x15\nCurrent: {}x{}", size.width, size.height);
                            let _ = terminal.draw(|frame| {
                                use ratatui::widgets::{Paragraph, Block, Borders};
                                use ratatui::layout::Alignment;
                                let msg = Paragraph::new(msg_text.clone())
                                    .alignment(Alignment::Center)
                                    .block(Block::default().borders(Borders::ALL));
                                frame.render_widget(msg, frame.size());
                            });
                        } else if let Err(e) = terminal.draw(|frame| {
                            let (title_area, system_area, services_area) = tui_app.render(frame, &self.metric_store);
                            self.title_area = title_area;
                            self.system_area = system_area;
                            self.services_area = services_area;
                        }) {
                            error!("Error rendering TUI: {}", e);
                            break;
                        }
                    }
                }
                needs_render = false; // Reset flag after rendering
            }
            // Small sleep to prevent excessive CPU usage
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
        info!("Dashboard main loop ended");
        Ok(())
    }
    /// Handle mouse events
    fn handle_mouse_event(&mut self, mouse: MouseEvent) -> Result<()> {
        let x = mouse.column;
        let y = mouse.row;
        // Handle popup menu if open
        let popup_info = if let Some(ref tui_app) = self.tui_app {
            tui_app.popup_menu.clone().map(|popup| {
                let hostname = tui_app.current_host.clone();
                (popup, hostname)
            })
        } else {
            None
        };
        if let Some((popup, hostname)) = popup_info {
            // Calculate popup bounds using screen coordinates
            let popup_width = 20;
            let popup_height = 5; // 3 items + 2 borders
            // Get terminal size
            let (screen_width, screen_height) = if let Some(ref terminal) = self.terminal {
                let size = terminal.size().unwrap_or_default();
                (size.width, size.height)
            } else {
                (80, 24) // fallback
            };
            let popup_x = if popup.x + popup_width < screen_width {
                popup.x
            } else {
                screen_width.saturating_sub(popup_width)
            };
            let popup_y = if popup.y + popup_height < screen_height {
                popup.y
            } else {
                screen_height.saturating_sub(popup_height)
            };
            let popup_area = Rect {
                x: popup_x,
                y: popup_y,
                width: popup_width,
                height: popup_height,
            };
            // Update selected index on mouse move
            if matches!(mouse.kind, MouseEventKind::Moved) {
                if is_in_area(x, y, &popup_area) {
                    let relative_y = y.saturating_sub(popup_y + 1) as usize; // +1 for top border
                    if relative_y < 3 {
                        if let Some(ref mut tui_app) = self.tui_app {
                            if let Some(ref mut popup) = tui_app.popup_menu {
                                popup.selected_index = relative_y;
                            }
                        }
                    }
                }
                return Ok(());
            }
            if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
                if is_in_area(x, y, &popup_area) {
                    // Click inside popup - execute action
                    let relative_y = y.saturating_sub(popup_y + 1) as usize; // +1 for top border
                    if relative_y < 3 {
                        // Execute the selected action
                        self.execute_service_action(relative_y, &popup.service_name, hostname.as_deref())?;
                    }
                    // Close popup after action
                    if let Some(ref mut tui_app) = self.tui_app {
                        tui_app.popup_menu = None;
                    }
                    return Ok(());
                } else {
                    // Click outside popup - close it
                    if let Some(ref mut tui_app) = self.tui_app {
                        tui_app.popup_menu = None;
                    }
                    return Ok(());
                }
            }
            // Any other event while popup is open - don't process panels
            return Ok(());
        }
        // Check for title bar clicks (host selection)
        if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
            if is_in_area(x, y, &self.title_area) {
                // Click in title bar - check if it's on a hostname
                // The title bar has "cm-dashboard vX.X.X" on the left (22 chars)
                // Then hostnames start at position 22
                if x >= 22 {
                    let hostname = self.find_hostname_at_position(x);
                    if let Some(host) = hostname {
                        if let Some(ref mut tui_app) = self.tui_app {
                            tui_app.switch_to_host(&host);
                        }
                    }
                }
                return Ok(());
            }
        }
        // Determine which panel the mouse is over
        let in_system_area = is_in_area(x, y, &self.system_area);
        let in_services_area = is_in_area(x, y, &self.services_area);
        if !in_system_area && !in_services_area {
            return Ok(());
        }
        // Handle mouse events
        match mouse.kind {
            MouseEventKind::ScrollDown => {
                if in_system_area {
                    // Scroll down in system panel
                    if let Some(ref mut tui_app) = self.tui_app {
                        if let Some(hostname) = tui_app.current_host.clone() {
                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
                            let visible_height = self.system_area.height as usize;
                            let total_lines = host_widgets.system_widget.get_total_lines();
                            host_widgets.system_widget.scroll_down(visible_height, total_lines);
                        }
                    }
                } else if in_services_area {
                    // Scroll down in services panel
                    if let Some(ref mut tui_app) = self.tui_app {
                        if let Some(hostname) = tui_app.current_host.clone() {
                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
                            // Calculate visible height (panel height - borders and header)
                            let visible_height = self.services_area.height.saturating_sub(3) as usize;
                            host_widgets.services_widget.scroll_down(visible_height);
                        }
                    }
                }
            }
            MouseEventKind::ScrollUp => {
                if in_system_area {
                    // Scroll up in system panel
                    if let Some(ref mut tui_app) = self.tui_app {
                        if let Some(hostname) = tui_app.current_host.clone() {
                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
                            host_widgets.system_widget.scroll_up();
                        }
                    }
                } else if in_services_area {
                    // Scroll up in services panel
                    if let Some(ref mut tui_app) = self.tui_app {
                        if let Some(hostname) = tui_app.current_host.clone() {
                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
                            host_widgets.services_widget.scroll_up();
                        }
                    }
                }
            }
            MouseEventKind::Down(button) => {
                // Only handle clicks in services area (not system area)
                if !in_services_area {
                    return Ok(());
                }
                // Calculate which service was clicked
                // The services area includes a border, so we need to account for that
                let relative_y = y.saturating_sub(self.services_area.y + 2) as usize; // +2 for border and header
                if let Some(ref mut tui_app) = self.tui_app {
                    if let Some(hostname) = tui_app.current_host.clone() {
                        let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
                        // Account for scroll offset - the clicked line is relative to viewport
                        let display_line_index = host_widgets.services_widget.scroll_offset + relative_y;
                        // Map display line to parent service index
                        if let Some(parent_index) = host_widgets.services_widget.display_line_to_parent_index(display_line_index) {
                            // Set the selected index to the clicked parent service
                            host_widgets.services_widget.selected_index = parent_index;
                            match button {
                                MouseButton::Left => {
                                    // Left click just selects the service
                                    debug!("Left-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
                                }
                                MouseButton::Right => {
                                    // Right click opens context menu
                                    debug!("Right-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
                                    // Get the service name for the popup
                                    if let Some(service_name) = host_widgets.services_widget.get_selected_service() {
                                        tui_app.popup_menu = Some(crate::ui::PopupMenu {
                                            service_name,
                                            x,
                                            y,
                                            selected_index: 0,
                                        });
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        Ok(())
    }
    /// Execute service action from popup menu
    fn execute_service_action(&self, action_index: usize, service_name: &str, hostname: Option<&str>) -> Result<()> {
        let Some(hostname) = hostname else {
            return Ok(());
        };
        let connection_ip = self.get_connection_ip(hostname);
        match action_index {
            0 => {
                // Start Service
                let service_start_command = format!(
                    "echo 'Starting service: {} on {}' && ssh -tt {}@{} \"bash -ic '{} start {}'\"",
                    service_name,
                    hostname,
                    self.config.ssh.rebuild_user,
                    connection_ip,
                    self.config.ssh.service_manage_cmd,
                    service_name
                );
                std::process::Command::new("tmux")
                    .arg("split-window")
                    .arg("-v")
                    .arg("-p")
                    .arg("30")
                    .arg(&service_start_command)
                    .spawn()
                    .ok();
            }
            1 => {
                // Stop Service
                let service_stop_command = format!(
                    "echo 'Stopping service: {} on {}' && ssh -tt {}@{} \"bash -ic '{} stop {}'\"",
                    service_name,
                    hostname,
                    self.config.ssh.rebuild_user,
                    connection_ip,
                    self.config.ssh.service_manage_cmd,
                    service_name
                );
                std::process::Command::new("tmux")
                    .arg("split-window")
                    .arg("-v")
                    .arg("-p")
                    .arg("30")
                    .arg(&service_stop_command)
                    .spawn()
                    .ok();
            }
            2 => {
                // View Logs
                let logs_command = format!(
                    "ssh -tt {}@{} '{} logs {}'",
                    self.config.ssh.rebuild_user,
                    connection_ip,
                    self.config.ssh.service_manage_cmd,
                    service_name
                );
                std::process::Command::new("tmux")
                    .arg("split-window")
                    .arg("-v")
                    .arg("-p")
                    .arg("30")
                    .arg(&logs_command)
                    .spawn()
                    .ok();
            }
            _ => {}
        }
        Ok(())
    }
    /// Get connection IP for a host
    fn get_connection_ip(&self, hostname: &str) -> String {
        self.config
            .hosts
            .get(hostname)
            .and_then(|h| h.ip.clone())
            .unwrap_or_else(|| hostname.to_string())
    }
    /// Find which hostname is at a given x position in the title bar
    fn find_hostname_at_position(&self, x: u16) -> Option<String> {
        if let Some(ref tui_app) = self.tui_app {
            // The hosts are RIGHT-ALIGNED in chunks[1]!
            // Need to calculate total width first, then right-align
            // Get terminal width
            let terminal_width = if let Some(ref terminal) = self.terminal {
                terminal.size().unwrap_or_default().width
            } else {
                80
            };
            // Calculate total width of all host text
            let mut total_width = 0_u16;
            for (i, host) in tui_app.get_available_hosts().iter().enumerate() {
                if i > 0 {
                    total_width += 1; // space between hosts
                }
                total_width += 2; // icon + space
                let is_selected = Some(host) == tui_app.current_host.as_ref();
                if is_selected {
                    total_width += 1 + host.len() as u16 + 1; // [hostname]
                } else {
                    total_width += host.len() as u16;
                }
            }
            total_width += 1; // right padding
            // chunks[1] starts at 22, has width of (terminal_width - 22)
            let chunk_width = terminal_width - 22;
            // Right-aligned position
            let hosts_start_x = if total_width < chunk_width {
                22 + (chunk_width - total_width)
            } else {
                22
            };
            // Now calculate positions starting from hosts_start_x
            let mut pos = hosts_start_x;
            for (i, host) in tui_app.get_available_hosts().iter().enumerate() {
                if i > 0 {
                    pos += 1; // " "
                }
                let host_start = pos;
                pos += 2; // "● "
                let is_selected = Some(host) == tui_app.current_host.as_ref();
                if is_selected {
                    pos += 1 + host.len() as u16 + 1; // [hostname]
                } else {
                    pos += host.len() as u16;
                }
                if x >= host_start && x < pos {
                    return Some(host.clone());
                }
            }
        }
        None
    }
 }
 /// Check if a point is within a rectangular area
 fn is_in_area(x: u16, y: u16, area: &Rect) -> bool {
    x >= area.x && x < area.x + area.width
        && y >= area.y && y < area.y + area.height
 }
 impl Drop for Dashboard {
@ -678,7 +278,7 @@ impl Drop for Dashboard {
        if !self.headless {
            let _ = disable_raw_mode();
            if let Some(ref mut terminal) = self.terminal {
-                let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture);
+                let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen);
                let _ = terminal.show_cursor();
            }
        }
--- a/dashboard/src/metrics/store.rs
+++ b/dashboard/src/metrics/store.rs
@ -86,6 +86,16 @@ 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> {
        let now = Instant::now();
--- a/dashboard/src/ui/mod.rs
+++ b/dashboard/src/ui/mod.rs
@ -17,7 +17,7 @@ pub mod widgets;
 use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
 use cm_dashboard_shared::Status;
-use theme::{Components, Layout as ThemeLayout, Theme};
+use theme::{Components, Layout as ThemeLayout, Theme, Typography};
 use widgets::{ServicesWidget, SystemWidget, Widget};
@ -47,21 +47,12 @@ impl HostWidgets {
 }
 /// Popup menu state
 #[derive(Clone)]
 pub struct PopupMenu {
    pub service_name: String,
    pub x: u16,
    pub y: u16,
    pub selected_index: usize,
 }
 /// Main TUI application
 pub struct TuiApp {
    /// Widget states per host (hostname -> HostWidgets)
    host_widgets: HashMap<String, HostWidgets>,
    /// Current active host
-    pub current_host: Option<String>,
+    current_host: Option<String>,
    /// Available hosts
    available_hosts: Vec<String>,
    /// Host index for navigation
@ -74,8 +65,6 @@ pub struct TuiApp {
    config: DashboardConfig,
    /// Cached localhost hostname to avoid repeated system calls
    localhost: String,
    /// Active popup menu (if any)
    pub popup_menu: Option<PopupMenu>,
 }
 impl TuiApp {
@ -90,7 +79,6 @@ impl TuiApp {
            user_navigated_away: false,
            config,
            localhost,
            popup_menu: None,
        };
        // Sort predefined hosts
@ -105,7 +93,7 @@ impl TuiApp {
    }
    /// Get or create host widgets for the given hostname
-    pub fn get_or_create_host_widgets(&mut self, hostname: &str) -> &mut HostWidgets {
+    fn get_or_create_host_widgets(&mut self, hostname: &str) -> &mut HostWidgets {
        self.host_widgets
            .entry(hostname.to_string())
            .or_insert_with(HostWidgets::new)
@ -122,6 +110,14 @@ impl TuiApp {
                host_widgets.system_widget.update_from_agent_data(agent_data);
                host_widgets.services_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());
            }
        }
@ -171,14 +167,6 @@ impl TuiApp {
    /// Handle keyboard input
    pub fn handle_input(&mut self, event: Event) -> Result<()> {
        if let Event::Key(key) = event {
            // Close popup on Escape
            if matches!(key.code, KeyCode::Esc) {
                if self.popup_menu.is_some() {
                    self.popup_menu = None;
                    return Ok(());
                }
            }
            match key.code {
                KeyCode::Char('q') => {
                    self.should_quit = true;
@ -383,23 +371,6 @@ impl TuiApp {
        Ok(())
    }
    /// Switch to a specific host by name
    pub fn switch_to_host(&mut self, hostname: &str) {
        if let Some(index) = self.available_hosts.iter().position(|h| h == hostname) {
            self.host_index = index;
            self.current_host = Some(hostname.to_string());
            // Check if user navigated away from localhost
            if hostname != &self.localhost {
                self.user_navigated_away = true;
            } else {
                self.user_navigated_away = false; // User navigated back to localhost
            }
            info!("Switched to host: {}", hostname);
        }
    }
    /// Navigate between hosts
    fn navigate_host(&mut self, direction: i32) {
        if self.available_hosts.is_empty() {
@ -445,10 +416,6 @@ impl TuiApp {
        None
    }
    /// Get the list of available hosts
    pub fn get_available_hosts(&self) -> &Vec<String> {
        &self.available_hosts
    }
    /// Should quit application
    pub fn should_quit(&self) -> bool {
@ -462,7 +429,7 @@ impl TuiApp {
    /// Render the dashboard (real btop-style multi-panel layout)
-    pub fn render(&mut self, frame: &mut Frame, metric_store: &MetricStore) -> (Rect, Rect, Rect) {
+    pub fn render(&mut self, frame: &mut Frame, metric_store: &MetricStore) {
        let size = frame.size();
        // Clear background to true black like btop
@ -502,8 +469,8 @@ impl TuiApp {
        if current_host_offline {
            self.render_offline_host_message(frame, main_chunks[1]);
            self.render_btop_title(frame, main_chunks[0], metric_store);
-            self.render_statusbar(frame, main_chunks[2], metric_store);
+            self.render_statusbar(frame, main_chunks[2]);
-            return (main_chunks[0], Rect::default(), Rect::default()); // Return title area and empty areas when offline
+            return;
        }
        // Left side: system panel only (full height)
@ -516,29 +483,20 @@ impl TuiApp {
        self.render_btop_title(frame, main_chunks[0], metric_store);
        // Render system panel
-        let system_area = left_chunks[0];
+        self.render_system_panel(frame, left_chunks[0], metric_store);
        self.render_system_panel(frame, system_area, metric_store);
        // Render services widget for current host
        let services_area = content_chunks[1];
        if let Some(hostname) = self.current_host.clone() {
            let is_focused = true; // Always show service selection
            let host_widgets = self.get_or_create_host_widgets(&hostname);
            host_widgets
                .services_widget
-                .render(frame, services_area, is_focused); // Services takes full right side
+                .render(frame, content_chunks[1], is_focused); // Services takes full right side
        }
        // Render statusbar at the bottom
-        self.render_statusbar(frame, main_chunks[2], metric_store);
+        self.render_statusbar(frame, main_chunks[2]); // main_chunks[2] is the statusbar area
        // Render popup menu on top of everything if active
        if let Some(ref popup) = self.popup_menu {
            self.render_popup_menu(frame, popup);
        }
        // Return all areas for mouse event handling
        (main_chunks[0], system_area, services_area)
    }
    /// Render btop-style minimal title with host status colors
@ -606,14 +564,7 @@ impl TuiApp {
            ));
            if Some(host) == self.current_host.as_ref() {
-                // Selected host with brackets in bold background color against status background
+                // Selected host in bold background color against status background
                host_spans.push(Span::styled(
                    "[",
                    Style::default()
                        .fg(Theme::background())
                        .bg(background_color)
                        .add_modifier(Modifier::BOLD),
                ));
                host_spans.push(Span::styled(
                    host.clone(),
                    Style::default()
@ -621,13 +572,6 @@ impl TuiApp {
                        .bg(background_color)
                        .add_modifier(Modifier::BOLD),
                ));
                host_spans.push(Span::styled(
                    "]",
                    Style::default()
                        .fg(Theme::background())
                        .bg(background_color)
                        .add_modifier(Modifier::BOLD),
                ));
            } else {
                // Other hosts in normal background color against status background
                host_spans.push(Span::styled(
@ -661,137 +605,36 @@ impl TuiApp {
        }
    }
-    /// Render popup menu for service actions
+    /// Render dynamic statusbar with context-aware shortcuts
-    fn render_popup_menu(&self, frame: &mut Frame, popup: &PopupMenu) {
+    fn render_statusbar(&self, frame: &mut Frame, area: Rect) {
-        use ratatui::widgets::{Block, Borders, Clear, List, ListItem};
+        let shortcuts = self.get_context_shortcuts();
-        use ratatui::style::{Color, Modifier};
+        let statusbar_text = shortcuts.join(" • ");
-        // Menu items
+        let statusbar = Paragraph::new(statusbar_text)
-        let items = vec![
+            .style(Typography::secondary())
-            "Start Service",
+            .alignment(ratatui::layout::Alignment::Center);
            "Stop Service",
            "View Logs",
        ];
        // Calculate popup size
        let width = 20;
        let height = items.len() as u16 + 2; // +2 for borders
        // Position popup near click location, but keep it on screen
        let screen_width = frame.size().width;
        let screen_height = frame.size().height;
        let x = if popup.x + width < screen_width {
            popup.x
        } else {
            screen_width.saturating_sub(width)
        };
        let y = if popup.y + height < screen_height {
            popup.y
        } else {
            screen_height.saturating_sub(height)
        };
        let popup_area = Rect {
            x,
            y,
            width,
            height,
        };
        // Create menu items with selection highlight
        let menu_items: Vec<ListItem> = items
            .iter()
            .enumerate()
            .map(|(i, item)| {
                let style = if i == popup.selected_index {
                    Style::default()
                        .fg(Color::Black)
                        .bg(Color::White)
                        .add_modifier(Modifier::BOLD)
                } else {
                    Style::default().fg(Theme::primary_text())
                };
                ListItem::new(*item).style(style)
            })
            .collect();
        let menu_list = List::new(menu_items)
            .block(
                Block::default()
                    .borders(Borders::ALL)
                    .style(Style::default().bg(Theme::background()).fg(Theme::primary_text()))
            );
        // Clear the area and render menu
        frame.render_widget(Clear, popup_area);
        frame.render_widget(menu_list, popup_area);
    }
    /// Render statusbar with host and client IPs
    fn render_statusbar(&self, frame: &mut Frame, area: Rect, _metric_store: &MetricStore) {
        use ratatui::text::{Line, Span};
        use ratatui::widgets::Paragraph;
        // Get current host info
        let (hostname_str, host_ip, build_version, agent_version) = if let Some(hostname) = &self.current_host {
            // Get the connection IP (the IP dashboard uses to connect to the agent)
            let ip = if let Some(host_details) = self.config.hosts.get(hostname) {
                host_details.get_connection_ip(hostname)
            } else {
                hostname.clone()
            };
            // Get build and agent versions from system widget
            let (build, agent) = if let Some(host_widgets) = self.host_widgets.get(hostname) {
                let build = host_widgets.system_widget.get_build_version().unwrap_or("N/A".to_string());
                let agent = host_widgets.system_widget.get_agent_version().unwrap_or("N/A".to_string());
                (build, agent)
            } else {
                ("N/A".to_string(), "N/A".to_string())
            };
            (hostname.clone(), ip, build, agent)
        } else {
            ("None".to_string(), "N/A".to_string(), "N/A".to_string(), "N/A".to_string())
        };
        let left_text = format!("Host: {} | {} | Build:{} | Agent:{}", hostname_str, host_ip, build_version, agent_version);
        // Get dashboard local IP
        let dashboard_ip = Self::get_local_ip();
        let right_text = format!("Dashboard: {}", dashboard_ip);
        // Calculate spacing to push right text to the right (accounting for 1 char left padding)
        let spacing = area.width as usize - left_text.len() - right_text.len() - 2; // -2 for left padding
        let spacing_str = " ".repeat(spacing.max(1));
        let line = Line::from(vec![
            Span::raw(" "), // 1 char left padding
            Span::styled(left_text, Style::default().fg(Theme::border())),
            Span::raw(spacing_str),
            Span::styled(right_text, Style::default().fg(Theme::border())),
        ]);
        let statusbar = Paragraph::new(line);
        frame.render_widget(statusbar, area);
    }
-    /// Get local IP address of the dashboard
+    /// Get context-aware shortcuts based on focused panel
-    fn get_local_ip() -> String {
+    fn get_context_shortcuts(&self) -> Vec<String> {
-        use std::net::UdpSocket;
+        let mut shortcuts = Vec::new();
-        // Try to get local IP by creating a UDP socket
+        // Global shortcuts
-        // This doesn't actually send data, just determines routing
+        shortcuts.push("Tab: Host".to_string());
-        if let Ok(socket) = UdpSocket::bind("0.0.0.0:0") {
+        shortcuts.push("↑↓/jk: Select".to_string());
-            if socket.connect("8.8.8.8:80").is_ok() {
+        shortcuts.push("r: Rebuild".to_string());
-                if let Ok(addr) = socket.local_addr() {
+        shortcuts.push("B: Backup".to_string());
-                    return addr.ip().to_string();
+        shortcuts.push("s/S: Start/Stop".to_string());
-                }
+        shortcuts.push("L: Logs".to_string());
-            }
+        shortcuts.push("t: Terminal".to_string());
-        }
+        shortcuts.push("w: Wake".to_string());
-        "N/A".to_string()
+        
        // Always show quit
        shortcuts.push("q: Quit".to_string());
        shortcuts
    }
    fn render_system_panel(&mut self, frame: &mut Frame, area: Rect, _metric_store: &MetricStore) {
--- a/dashboard/src/ui/theme.rs
+++ b/dashboard/src/ui/theme.rs
@ -142,7 +142,6 @@ impl Theme {
    /// Get color for status level
    pub fn status_color(status: Status) -> Color {
        match status {
            Status::Info => Self::muted_text(), // Gray for informational data
            Status::Ok => Self::success(),
            Status::Inactive => Self::muted_text(), // Gray for inactive services in service list
            Status::Pending => Self::highlight(), // Blue for pending
@ -241,7 +240,6 @@ impl StatusIcons {
    /// Get status icon symbol
    pub fn get_icon(status: Status) -> &'static str {
        match status {
            Status::Info => "",  // No icon for informational data
            Status::Ok => "●",
            Status::Inactive => "○", // Empty circle for inactive services
            Status::Pending => "◉", // Hollow circle for pending
@ -256,7 +254,6 @@ impl StatusIcons {
    pub fn create_status_spans(status: Status, text: &str) -> Vec<ratatui::text::Span<'static>> {
        let icon = Self::get_icon(status);
        let status_color = match status {
            Status::Info => Theme::muted_text(),     // Gray for info
            Status::Ok => Theme::success(),         // Green
            Status::Inactive => Theme::muted_text(), // Gray for inactive services
            Status::Pending => Theme::highlight(),       // Blue
--- a/dashboard/src/ui/widgets/services.rs
+++ b/dashboard/src/ui/widgets/services.rs
@ -11,74 +11,6 @@ use tracing::debug;
 use crate::ui::theme::{Components, StatusIcons, Theme, Typography};
 use ratatui::style::Style;
 /// Column visibility configuration based on terminal width
 #[derive(Debug, Clone, Copy)]
 struct ColumnVisibility {
    show_name: bool,
    show_status: bool,
    show_ram: bool,
    show_uptime: bool,
    show_restarts: bool,
 }
 impl ColumnVisibility {
    /// Calculate actual width needed for all columns
    const NAME_WIDTH: u16 = 23;
    const STATUS_WIDTH: u16 = 10;
    const RAM_WIDTH: u16 = 8;
    const UPTIME_WIDTH: u16 = 8;
    const RESTARTS_WIDTH: u16 = 5;
    const COLUMN_SPACING: u16 = 1; // Space between columns
    /// Determine which columns to show based on available width
    /// Priority order: Name > Status > RAM > Uptime > Restarts
    fn from_width(width: u16) -> Self {
        // Calculate cumulative widths for each configuration
        let minimal = Self::NAME_WIDTH + Self::COLUMN_SPACING + Self::STATUS_WIDTH; // 34
        let with_ram = minimal + Self::COLUMN_SPACING + Self::RAM_WIDTH; // 43
        let with_uptime = with_ram + Self::COLUMN_SPACING + Self::UPTIME_WIDTH; // 52
        let full = with_uptime + Self::COLUMN_SPACING + Self::RESTARTS_WIDTH; // 58
        if width >= full {
            // Show all columns
            Self {
                show_name: true,
                show_status: true,
                show_ram: true,
                show_uptime: true,
                show_restarts: true,
            }
        } else if width >= with_uptime {
            // Hide restarts
            Self {
                show_name: true,
                show_status: true,
                show_ram: true,
                show_uptime: true,
                show_restarts: false,
            }
        } else if width >= with_ram {
            // Hide uptime and restarts
            Self {
                show_name: true,
                show_status: true,
                show_ram: true,
                show_uptime: false,
                show_restarts: false,
            }
        } else {
            // Minimal: Name + Status only
            Self {
                show_name: true,
                show_status: true,
                show_ram: false,
                show_uptime: false,
                show_restarts: false,
            }
        }
    }
 }
 /// Services widget displaying hierarchical systemd service statuses
 #[derive(Clone)]
 pub struct ServicesWidget {
@ -91,20 +23,16 @@ pub struct ServicesWidget {
    /// Last update indicator
    has_data: bool,
    /// Currently selected service index (for navigation cursor)
-    pub selected_index: usize,
+    selected_index: usize,
    /// Scroll offset for viewport (which display line is at the top)
    pub scroll_offset: usize,
    /// Last rendered viewport height (for accurate scroll bounds)
    last_viewport_height: usize,
 }
 #[derive(Clone)]
 struct ServiceInfo {
    memory_mb: Option<f32>,
    disk_gb: Option<f32>,
    metrics: Vec<(String, f32, Option<String>)>, // (label, value, unit)
    widget_status: Status,
-    memory_bytes: Option<u64>,
+    service_type: String, // "nginx_site", "container", "image", or empty for parent services
    restart_count: Option<u32>,
    uptime_seconds: Option<u64>,
 }
 impl ServicesWidget {
@ -115,8 +43,6 @@ impl ServicesWidget {
            status: Status::Unknown,
            has_data: false,
            selected_index: 0,
            scroll_offset: 0,
            last_viewport_height: 0,
        }
    }
@ -126,6 +52,8 @@ impl ServicesWidget {
        if metric_name.starts_with("service_") {
            if let Some(end_pos) = metric_name
                .rfind("_status")
                .or_else(|| metric_name.rfind("_memory_mb"))
                .or_else(|| metric_name.rfind("_disk_gb"))
                .or_else(|| metric_name.rfind("_latency_ms"))
            {
                let service_part = &metric_name[8..end_pos]; // Remove "service_" prefix
@ -148,20 +76,45 @@ impl ServicesWidget {
        None
    }
    /// Format disk size with appropriate units (kB/MB/GB)
    fn format_disk_size(size_gb: f32) -> String {
        let size_mb = size_gb * 1024.0; // Convert GB to MB
        if size_mb >= 1024.0 {
            // Show as GB
            format!("{:.1}GB", size_gb)
        } else if size_mb >= 1.0 {
            // Show as MB
            format!("{:.0}MB", size_mb)
        } else if size_mb >= 0.001 {
            // Convert to kB
            let size_kb = size_mb * 1024.0;
            format!("{:.0}kB", size_kb)
        } else {
            // Show very small sizes as bytes
            let size_bytes = size_mb * 1024.0 * 1024.0;
            format!("{:.0}B", size_bytes)
        }
    }
    /// Format parent service line - returns text without icon for span formatting
-    fn format_parent_service_line(&self, name: &str, info: &ServiceInfo, columns: ColumnVisibility) -> String {
+    fn format_parent_service_line(&self, name: &str, info: &ServiceInfo) -> String {
-        // Truncate long service names to fit layout
+        let memory_str = info
-        // NAME_WIDTH - 3 chars for "..." = max displayable chars
+            .memory_mb
-        let max_name_len = (ColumnVisibility::NAME_WIDTH - 3) as usize;
+            .map_or("0M".to_string(), |m| format!("{:.0}M", m));
-        let short_name = if name.len() > max_name_len {
+        let disk_str = info
-            format!("{}...", &name[..max_name_len.saturating_sub(3)])
+            .disk_gb
            .map_or("0".to_string(), |d| Self::format_disk_size(d));
        // Truncate long service names to fit layout (account for icon space)
        let short_name = if name.len() > 22 {
            format!("{}...", &name[..19])
        } else {
            name.to_string()
        };
        // Convert Status enum to display text
        let status_str = match info.widget_status {
            Status::Info => "", // Shouldn't happen for parent services
            Status::Ok => "active",
            Status::Inactive => "inactive", 
            Status::Critical => "failed",
@ -171,59 +124,10 @@ impl ServicesWidget {
            Status::Offline => "offline",
        };
-        // Format memory
+        format!(
-        let memory_str = info.memory_bytes.map_or("-".to_string(), |bytes| {
+            "{:<23} {:<10} {:<8} {:<8}",
-            let mb = bytes as f64 / (1024.0 * 1024.0);
+            short_name, status_str, memory_str, disk_str
-            if mb >= 1000.0 {
+        )
                format!("{:.1}G", mb / 1024.0)
            } else {
                format!("{:.0}M", mb)
            }
        });
        // Format uptime
        let uptime_str = info.uptime_seconds.map_or("-".to_string(), |secs| {
            let days = secs / 86400;
            let hours = (secs % 86400) / 3600;
            let mins = (secs % 3600) / 60;
            if days > 0 {
                format!("{}d{}h", days, hours)
            } else if hours > 0 {
                format!("{}h{}m", hours, mins)
            } else {
                format!("{}m", mins)
            }
        });
        // Format restarts (show "!" if > 0 to indicate instability)
        let restart_str = info.restart_count.map_or("-".to_string(), |count| {
            if count > 0 {
                format!("!{}", count)
            } else {
                "0".to_string()
            }
        });
        // Build format string based on column visibility
        let mut parts = Vec::new();
        if columns.show_name {
            parts.push(format!("{:<width$}", short_name, width = ColumnVisibility::NAME_WIDTH as usize));
        }
        if columns.show_status {
            parts.push(format!("{:<width$}", status_str, width = ColumnVisibility::STATUS_WIDTH as usize));
        }
        if columns.show_ram {
            parts.push(format!("{:<width$}", memory_str, width = ColumnVisibility::RAM_WIDTH as usize));
        }
        if columns.show_uptime {
            parts.push(format!("{:<width$}", uptime_str, width = ColumnVisibility::UPTIME_WIDTH as usize));
        }
        if columns.show_restarts {
            parts.push(format!("{:<width$}", restart_str, width = ColumnVisibility::RESTARTS_WIDTH as usize));
        }
        parts.join(" ")
    }
@ -235,12 +139,9 @@ impl ServicesWidget {
        info: &ServiceInfo,
        is_last: bool,
    ) -> Vec<ratatui::text::Span<'static>> {
        // Informational sub-services (Status::Info) can use more width since they don't show columns
        let max_width = if info.widget_status == Status::Info { 50 } else { 18 };
        // Truncate long sub-service names to fit layout (accounting for indentation)
-        let short_name = if name.len() > max_width {
+        let short_name = if name.len() > 18 {
-            format!("{}...", &name[..(max_width.saturating_sub(3))])
+            format!("{}...", &name[..15])
        } else {
            name.to_string()
        };
@ -248,7 +149,6 @@ impl ServicesWidget {
        // Get status icon and text
        let icon = StatusIcons::get_icon(info.widget_status);
        let status_color = match info.widget_status {
            Status::Info => Theme::muted_text(),
            Status::Ok => Theme::success(),
            Status::Inactive => Theme::muted_text(),
            Status::Pending => Theme::highlight(),
@ -269,7 +169,6 @@ impl ServicesWidget {
        } else {
            // Convert Status enum to display text for sub-services
            match info.widget_status {
                Status::Info => "",
                Status::Ok => "active",
                Status::Inactive => "inactive",
                Status::Critical => "failed",
@ -281,34 +180,34 @@ impl ServicesWidget {
        };
        let tree_symbol = if is_last { "└─" } else { "├─" };
-        if info.widget_status == Status::Info {
+        // Docker images use docker whale icon
-            // Informational data - no status icon, show metrics if available
+        if info.service_type == "image" {
-            let mut spans = vec![
+            vec![
                // Indentation and tree prefix
                ratatui::text::Span::styled(
                    format!("  {} ", tree_symbol),
                    Typography::tree(),
                ),
-                // Service name (no icon) - no fixed width padding for Info status
+                // Docker icon (simple character for performance)
                ratatui::text::Span::styled(
-                    short_name,
+                    "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(
            // Add metrics if available (e.g., Docker image size)
            if !status_str.is_empty() {
                spans.push(ratatui::text::Span::styled(
                    status_str,
                    Style::default()
                        .fg(Theme::secondary_text())
                        .bg(Theme::background()),
-                ));
+                ),
-            }
+            ]
            spans
        } else {
            vec![
                // Indentation and tree prefix
@ -343,7 +242,6 @@ impl ServicesWidget {
    pub fn select_previous(&mut self) {
        if self.selected_index > 0 {
            self.selected_index -= 1;
            self.ensure_selected_visible();
        }
        debug!("Service selection moved up to: {}", self.selected_index);
    }
@ -352,77 +250,10 @@ impl ServicesWidget {
    pub fn select_next(&mut self, total_services: usize) {
        if total_services > 0 && self.selected_index < total_services.saturating_sub(1) {
            self.selected_index += 1;
            self.ensure_selected_visible();
        }
        debug!("Service selection: {}/{}", self.selected_index, total_services);
    }
    /// Convert parent service index to display line index
    fn parent_index_to_display_line(&self, parent_index: usize) -> usize {
        let mut parent_services: Vec<_> = self.parent_services.iter().collect();
        parent_services.sort_by(|(a, _), (b, _)| a.cmp(b));
        let mut display_line = 0;
        for (idx, (parent_name, _)) in parent_services.iter().enumerate() {
            if idx == parent_index {
                return display_line;
            }
            display_line += 1; // Parent service line
            // Add sub-service lines
            if let Some(sub_list) = self.sub_services.get(*parent_name) {
                display_line += sub_list.len();
            }
        }
        display_line
    }
    /// Ensure the currently selected service is visible in the viewport
    fn ensure_selected_visible(&mut self) {
        if self.last_viewport_height == 0 {
            return; // Can't adjust without knowing viewport size
        }
        let display_line = self.parent_index_to_display_line(self.selected_index);
        let total_display_lines = self.get_total_display_lines();
        let viewport_height = self.last_viewport_height;
        // Check if selected line is above visible area
        if display_line < self.scroll_offset {
            self.scroll_offset = display_line;
            return;
        }
        // Calculate current effective viewport (accounting for "more below" if present)
        let current_remaining = total_display_lines.saturating_sub(self.scroll_offset);
        let current_has_more = current_remaining > viewport_height;
        let current_effective = if current_has_more {
            viewport_height.saturating_sub(1)
        } else {
            viewport_height
        };
        // Check if selected line is below current visible area
        if display_line >= self.scroll_offset + current_effective {
            // Need to scroll down. Position selected line so there's room for "more below" if needed
            // Strategy: if there are lines below the selected line, don't put it at the very bottom
            let has_content_below = display_line < total_display_lines - 1;
            if has_content_below {
                // Leave room for "... X more below" message by positioning selected line
                // one position higher than the last line
                let target_position = viewport_height.saturating_sub(2);
                self.scroll_offset = display_line.saturating_sub(target_position);
            } else {
                // This is the last line, can put it at the bottom
                self.scroll_offset = display_line.saturating_sub(viewport_height - 1);
            }
        }
        debug!("Auto-scroll: selected={}, display_line={}, scroll_offset={}, viewport={}, total={}",
            self.selected_index, display_line, self.scroll_offset, viewport_height, total_display_lines);
    }
    /// Get currently selected service name (for actions)
    /// Only returns parent service names since only parent services can be selected
    pub fn get_selected_service(&self) -> Option<String> {
@ -439,81 +270,6 @@ impl ServicesWidget {
        self.parent_services.len()
    }
    /// Get total display lines (parent services + sub-services)
    pub fn get_total_display_lines(&self) -> usize {
        let mut total = self.parent_services.len();
        for sub_list in self.sub_services.values() {
            total += sub_list.len();
        }
        total
    }
    /// Scroll down by one line
    pub fn scroll_down(&mut self, _visible_height: usize) {
        let total_lines = self.get_total_display_lines();
        // Use last_viewport_height if available (more accurate), otherwise can't scroll
        let viewport_height = if self.last_viewport_height > 0 {
            self.last_viewport_height
        } else {
            return; // Can't scroll without knowing viewport size
        };
        // Calculate exact max scroll to match render logic
        // Stop scrolling when all remaining content fits in viewport
        // At scroll_offset N: remaining = total_lines - N
        // We can show all when: remaining <= viewport_height
        // So max_scroll is when: total_lines - max_scroll = viewport_height
        // Therefore: max_scroll = total_lines - viewport_height (but at least 0)
        let max_scroll = total_lines.saturating_sub(viewport_height);
        debug!("Scroll down: total={}, viewport={}, offset={}, max={}", total_lines, viewport_height, self.scroll_offset, max_scroll);
        if self.scroll_offset < max_scroll {
            self.scroll_offset += 1;
        }
    }
    /// Scroll up by one line
    pub fn scroll_up(&mut self) {
        if self.scroll_offset > 0 {
            self.scroll_offset -= 1;
        }
    }
    /// Map a display line index to a parent service index (returns None if clicked on sub-service)
    pub fn display_line_to_parent_index(&self, display_line_index: usize) -> Option<usize> {
        // Build the same display list to map line index to parent service index
        let mut parent_index = 0;
        let mut line_index = 0;
        let mut parent_services: Vec<_> = self.parent_services.iter().collect();
        parent_services.sort_by(|(a, _), (b, _)| a.cmp(b));
        for (parent_name, _) in parent_services {
            // Check if this line index matches a parent service
            if line_index == display_line_index {
                return Some(parent_index);
            }
            line_index += 1;
            // Add sub-services for this parent (if any)
            if let Some(sub_list) = self.sub_services.get(parent_name) {
                for _ in sub_list {
                    if line_index == display_line_index {
                        // Clicked on a sub-service - return None (can't select sub-services)
                        return None;
                    }
                    line_index += 1;
                }
            }
            parent_index += 1;
        }
        None
    }
    /// Calculate which parent service index corresponds to a display line index
    fn calculate_parent_service_index(&self, display_line_index: &usize) -> usize {
@ -553,11 +309,11 @@ impl Widget for ServicesWidget {
        for service in &agent_data.services {
            // Store parent service
            let parent_info = ServiceInfo {
                memory_mb: Some(service.memory_mb),
                disk_gb: Some(service.disk_gb),
                metrics: Vec::new(), // Parent services don't have custom metrics
                widget_status: service.service_status,
-                memory_bytes: service.memory_bytes,
+                service_type: String::new(), // Parent services have no type
                restart_count: service.restart_count,
                uptime_seconds: service.uptime_seconds,
            };
            self.parent_services.insert(service.name.clone(), parent_info);
@ -571,11 +327,11 @@ impl Widget for ServicesWidget {
                        .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,
-                        memory_bytes: None, // Sub-services don't have individual metrics yet
+                        service_type: sub_service.service_type.clone(),
                        restart_count: None,
                        uptime_seconds: None,
                    };
                    sub_list.push((sub_service.name.clone(), sub_info));
                }
@ -615,15 +371,23 @@ impl ServicesWidget {
                            self.parent_services
                                .entry(parent_service)
                                .or_insert(ServiceInfo {
                                    memory_mb: None,
                                    disk_gb: None,
                                    metrics: Vec::new(),
                                    widget_status: Status::Unknown,
-                                    memory_bytes: None,
+                                    service_type: String::new(),
                                    restart_count: None,
                                    uptime_seconds: None,
                                });
                        if metric.name.ends_with("_status") {
                            service_info.widget_status = metric.status;
                        } else if metric.name.ends_with("_memory_mb") {
                            if let Some(memory) = metric.value.as_f32() {
                                service_info.memory_mb = Some(memory);
                            }
                        } else if metric.name.ends_with("_disk_gb") {
                            if let Some(disk) = metric.value.as_f32() {
                                service_info.disk_gb = Some(disk);
                            }
                        }
                    }
                    Some(sub_name) => {
@ -643,11 +407,11 @@ impl ServicesWidget {
                            sub_service_list.push((
                                sub_name.clone(),
                                ServiceInfo {
                                    memory_mb: None,
                                    disk_gb: None,
                                    metrics: Vec::new(),
                                    widget_status: Status::Unknown,
-                                    memory_bytes: None,
+                                    service_type: String::new(), // Unknown type in legacy path
                                    restart_count: None,
                                    uptime_seconds: None,
                                },
                            ));
                            &mut sub_service_list.last_mut().unwrap().1
@ -655,6 +419,14 @@ impl ServicesWidget {
                        if metric.name.ends_with("_status") {
                            sub_service_info.widget_status = metric.status;
                        } else if metric.name.ends_with("_memory_mb") {
                            if let Some(memory) = metric.value.as_f32() {
                                sub_service_info.memory_mb = Some(memory);
                            }
                        } else if metric.name.ends_with("_disk_gb") {
                            if let Some(disk) = metric.value.as_f32() {
                                sub_service_info.disk_gb = Some(disk);
                            }
                        }
                    }
                }
@ -686,23 +458,12 @@ impl ServicesWidget {
            self.selected_index = total_count - 1;
        }
        // Clamp scroll offset to valid range after update
        // This prevents scroll issues when switching between hosts or when service count changes
        let total_display_lines = self.get_total_display_lines();
        if total_display_lines == 0 {
            self.scroll_offset = 0;
        } else if self.scroll_offset >= total_display_lines {
            // Clamp to max valid value, not reset to 0
            self.scroll_offset = total_display_lines.saturating_sub(1);
        }
        debug!(
-            "Services widget updated: {} parent services, {} sub-service groups, total={}, selected={}, scroll={}, status={:?}",
+            "Services widget updated: {} parent services, {} sub-service groups, total={}, selected={}, status={:?}",
            self.parent_services.len(),
            self.sub_services.len(),
            total_count,
            self.selected_index,
            self.scroll_offset,
            self.status
        );
    }
@ -722,28 +483,11 @@ impl ServicesWidget {
            .constraints([Constraint::Length(1), Constraint::Min(0)])
            .split(inner_area);
-        // Determine which columns to show based on available width
+        // Header
-        let columns = ColumnVisibility::from_width(inner_area.width);
+        let header = format!(
-
+            "{:<25} {:<10} {:<8} {:<8}",
-        // Build header based on visible columns
+            "Service:", "Status:", "RAM:", "Disk:"
-        let mut header_parts = Vec::new();
+        );
        if columns.show_name {
            header_parts.push(format!("{:<width$}", "Service:", width = ColumnVisibility::NAME_WIDTH as usize));
        }
        if columns.show_status {
            header_parts.push(format!("{:<width$}", "Status:", width = ColumnVisibility::STATUS_WIDTH as usize));
        }
        if columns.show_ram {
            header_parts.push(format!("{:<width$}", "RAM:", width = ColumnVisibility::RAM_WIDTH as usize));
        }
        if columns.show_uptime {
            header_parts.push(format!("{:<width$}", "Uptime:", width = ColumnVisibility::UPTIME_WIDTH as usize));
        }
        if columns.show_restarts {
            header_parts.push(format!("{:<width$}", "↻:", width = ColumnVisibility::RESTARTS_WIDTH as usize));
        }
        let header = header_parts.join(" ");
        let header_para = Paragraph::new(header).style(Typography::muted());
        frame.render_widget(header_para, content_chunks[0]);
@ -755,11 +499,11 @@ impl ServicesWidget {
        }
        // Render the services list
-        self.render_services(frame, content_chunks[1], is_focused, columns);
+        self.render_services(frame, content_chunks[1], is_focused);
    }
    /// Render services list
-    fn render_services(&mut self, frame: &mut Frame, area: Rect, is_focused: bool, columns: ColumnVisibility) {
+    fn render_services(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
        // Build hierarchical service list for display
        let mut display_lines: Vec<(String, Status, bool, Option<(ServiceInfo, bool)>)> = Vec::new();
@ -769,7 +513,7 @@ impl ServicesWidget {
        for (parent_name, parent_info) in parent_services {
            // Add parent service line
-            let parent_line = self.format_parent_service_line(parent_name, parent_info, columns);
+            let parent_line = self.format_parent_service_line(parent_name, parent_info);
            display_lines.push((parent_line, parent_info.widget_status, false, None));
            // Add sub-services for this parent (if any)
@ -795,45 +539,19 @@ impl ServicesWidget {
        let available_lines = area.height as usize;
        let total_lines = display_lines.len();
-        // Store viewport height for accurate scroll calculations
+        // Reserve one line for "X more below" if needed
-        self.last_viewport_height = available_lines;
+        let lines_for_content = if total_lines > available_lines {
        // Clamp scroll_offset to valid range based on current viewport and content
        // This handles dynamic viewport size changes
        let max_valid_scroll = total_lines.saturating_sub(available_lines);
        if self.scroll_offset > max_valid_scroll {
            self.scroll_offset = max_valid_scroll;
        }
        // Calculate how many lines remain after scroll offset
        let remaining_lines = total_lines.saturating_sub(self.scroll_offset);
        debug!("Render: total={}, viewport={}, offset={}, max={}, remaining={}",
            total_lines, available_lines, self.scroll_offset, max_valid_scroll, remaining_lines);
        // Check if all remaining content fits in viewport
        let will_show_more_below = remaining_lines > available_lines;
        // Reserve one line for "X more below" only if we can't fit everything
        let lines_for_content = if will_show_more_below {
            available_lines.saturating_sub(1)
        } else {
-            available_lines.min(remaining_lines)
+            available_lines
        };
        // Apply scroll offset
        let visible_lines: Vec<_> = display_lines
            .iter()
            .skip(self.scroll_offset)
            .take(lines_for_content)
            .collect();
-        // Only calculate hidden_below if we actually reserved space for the message
+        let hidden_below = total_lines.saturating_sub(lines_for_content);
        let hidden_below = if will_show_more_below {
            remaining_lines.saturating_sub(lines_for_content)
        } else {
            0
        };
        let lines_to_show = visible_lines.len();
@ -847,7 +565,7 @@ impl ServicesWidget {
            for (i, (line_text, line_status, is_sub, sub_info)) in visible_lines.iter().enumerate()
            {
-                let actual_index = self.scroll_offset + i; // Account for scroll offset
+                let actual_index = i; // Simple index since we're not scrolling
                // Only parent services can be selected - calculate parent service index
                let is_selected = if !*is_sub {
@ -893,7 +611,7 @@ impl ServicesWidget {
            // Show "X more below" message if content was truncated
            if hidden_below > 0 {
                let more_text = format!("... {} more below", hidden_below);
-                let more_para = Paragraph::new(more_text).style(Style::default().fg(Theme::border()));
+                let more_para = Paragraph::new(more_text).style(Typography::muted());
                frame.render_widget(more_para, service_chunks[lines_to_show]);
            }
        }
--- a/dashboard/src/ui/widgets/system.rs
+++ b/dashboard/src/ui/widgets/system.rs
@ -1,13 +1,12 @@
 use cm_dashboard_shared::Status;
 use ratatui::{
    layout::Rect,
    style::Style,
    text::{Line, Span, Text},
    widgets::Paragraph,
    Frame,
 };
-use crate::ui::theme::{StatusIcons, Theme, Typography};
+use crate::ui::theme::{StatusIcons, Typography};
 /// System widget displaying NixOS info, Network, CPU, RAM, and Storage in unified layout
 #[derive(Clone)]
@ -16,6 +15,10 @@ pub struct SystemWidget {
    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>,
@ -23,9 +26,7 @@ pub struct SystemWidget {
    cpu_load_1min: Option<f32>,
    cpu_load_5min: Option<f32>,
    cpu_load_15min: Option<f32>,
-    cpu_cstates: Vec<cm_dashboard_shared::CStateInfo>,
+    cpu_frequency: Option<f32>,
    cpu_model_name: Option<String>,
    cpu_core_count: Option<u32>,
    cpu_status: Status,
    // Memory metrics
@ -44,17 +45,18 @@ pub struct SystemWidget {
    storage_pools: Vec<StoragePool>,
    // Backup metrics
-    backup_last_time: Option<String>,
+    backup_status: String,
-    backup_status: Status,
+    backup_start_time_raw: Option<String>,
-    backup_repositories: Vec<cm_dashboard_shared::BackupRepositoryData>,
+    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,
    // Scroll offset for viewport
    pub scroll_offset: usize,
    /// Last rendered viewport height (for accurate scroll bounds)
    last_viewport_height: usize,
 }
 #[derive(Clone)]
@ -94,13 +96,13 @@ 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,
-            cpu_cstates: Vec::new(),
+            cpu_frequency: None,
            cpu_model_name: None,
            cpu_core_count: None,
            cpu_status: Status::Unknown,
            memory_usage_percent: None,
            memory_used_gb: None,
@ -112,12 +114,16 @@ impl SystemWidget {
            tmp_status: Status::Unknown,
            tmpfs_mounts: Vec::new(),
            storage_pools: Vec::new(),
-            backup_last_time: None,
+            backup_status: "unknown".to_string(),
-            backup_status: Status::Unknown,
+            backup_start_time_raw: None,
-            backup_repositories: Vec::new(),
+            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,
            scroll_offset: 0,
            last_viewport_height: 0,
        }
    }
@ -131,19 +137,12 @@ impl SystemWidget {
        }
    }
-    /// Format CPU C-states (idle depth) with percentages
+    /// Format CPU frequency
-    fn format_cpu_cstate(&self) -> String {
+    fn format_cpu_frequency(&self) -> String {
-        if self.cpu_cstates.is_empty() {
+        match self.cpu_frequency {
-            return "—".to_string();
+            Some(freq) => format!("{:.0} MHz", freq),
            None => "— MHz".to_string(),
        }
        // Format top 3 C-states with percentages: "C10:79% C8:10% C6:8%"
        // Agent already sends clean names (C3, C10, etc.)
        self.cpu_cstates
            .iter()
            .map(|cs| format!("{}:{:.0}%", cs.name, cs.percent))
            .collect::<Vec<_>>()
            .join(" ")
    }
    /// Format memory usage
@ -162,14 +161,10 @@ impl SystemWidget {
        self.agent_hash.as_ref()
    }
-    /// Get the build version
+    /// Update ZMQ communication statistics
-    pub fn get_build_version(&self) -> Option<String> {
+    pub fn update_zmq_stats(&mut self, packets_received: u64, last_packet_age_secs: f64) {
-        self.nixos_build.clone()
+        self.zmq_packets_received = Some(packets_received);
-    }
+        self.zmq_last_packet_age = Some(last_packet_age_secs);
    /// Get the agent version
    pub fn get_agent_version(&self) -> Option<String> {
        self.agent_hash.clone()
    }
 }
@ -193,9 +188,7 @@ impl Widget for SystemWidget {
        self.cpu_load_1min = Some(cpu.load_1min);
        self.cpu_load_5min = Some(cpu.load_5min);
        self.cpu_load_15min = Some(cpu.load_15min);
-        self.cpu_cstates = cpu.cstates.clone();
+        self.cpu_frequency = Some(cpu.frequency_mhz);
        self.cpu_model_name = cpu.model_name.clone();
        self.cpu_core_count = cpu.core_count;
        self.cpu_status = Status::Ok;
        // Extract memory data directly
@ -221,18 +214,24 @@ impl Widget for SystemWidget {
        // Extract backup data
        let backup = &agent_data.backup;
-        self.backup_last_time = backup.last_backup_time.clone();
+        self.backup_status = backup.status.clone();
-        self.backup_status = backup.backup_status;
+        self.backup_start_time_raw = backup.start_time_raw.clone();
-        self.backup_repositories = backup.repositories.clone();
+        self.backup_last_size_gb = backup.last_backup_size_gb;
-        // Clamp scroll offset to valid range after update
+        if let Some(disk) = &backup.repository_disk {
-        // This prevents scroll issues when switching between hosts
+            self.backup_disk_serial = Some(disk.serial.clone());
-        let total_lines = self.get_total_lines();
+            self.backup_disk_usage_percent = Some(disk.usage_percent);
-        if total_lines == 0 {
+            self.backup_disk_used_gb = Some(disk.used_gb);
-            self.scroll_offset = 0;
+            self.backup_disk_total_gb = Some(disk.total_gb);
-        } else if self.scroll_offset >= total_lines {
+            self.backup_disk_wear_percent = disk.wear_percent;
-            // Clamp to max valid value, not reset to 0
+            self.backup_disk_temperature = disk.temperature_celsius;
-            self.scroll_offset = total_lines.saturating_sub(1);
+        } 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;
        }
    }
 }
@ -533,42 +532,61 @@ impl SystemWidget {
    fn render_backup(&self) -> Vec<Line<'_>> {
        let mut lines = Vec::new();
-        if self.backup_repositories.is_empty() {
+        // First line: serial number with temperature and wear
-            return lines;
+        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));
            }
-        // Format backup time (use complete timestamp)
+            let disk_text = if !details.is_empty() {
-        let time_display = if let Some(ref time_str) = self.backup_last_time {
+                format!("{} {}", truncated_serial, details.join(" "))
            time_str.clone()
        } else {
            "unknown".to_string()
        };
        // Header: just the timestamp
        let repo_spans = StatusIcons::create_status_spans(self.backup_status, &time_display);
        lines.push(Line::from(repo_spans));
        // List all repositories with archive count and size
        let repo_count = self.backup_repositories.len();
        for (idx, repo) in self.backup_repositories.iter().enumerate() {
            let tree_char = if idx == repo_count - 1 { "└─" } else { "├─" };
            // Format size: use kB for < 1MB, MB for < 1GB, otherwise GB
            let size_display = if repo.repo_size_gb < 0.001 {
                format!("{:.0}kB", repo.repo_size_gb * 1024.0 * 1024.0)
            } else if repo.repo_size_gb < 1.0 {
                format!("{:.0}MB", repo.repo_size_gb * 1024.0)
            } else {
-                format!("{:.1}GB", repo.repo_size_gb)
+                truncated_serial
            };
-            let repo_text = format!("{} ({}) {}", repo.name, repo.archive_count, size_display);
+            let backup_status = match self.backup_status.as_str() {
                "completed" | "success" => Status::Ok,
                "running" => Status::Pending,
                "failed" => Status::Critical,
                _ => Status::Unknown,
            };
-            let mut repo_spans = vec![
+            let disk_spans = StatusIcons::create_status_spans(backup_status, &disk_text);
-                Span::styled(format!("  {} ", tree_char), Typography::tree()),
+            lines.push(Line::from(disk_spans));
-            ];
+
-            repo_spans.extend(StatusIcons::create_status_spans(repo.status, &repo_text));
+            // Show backup time from TOML if available
-            lines.push(Line::from(repo_spans));
+            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
@ -772,88 +790,36 @@ impl SystemWidget {
    }
    /// Render system widget
-    /// Scroll down by one line
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
    pub fn scroll_down(&mut self, _visible_height: usize, _total_lines: usize) {
        let total_lines = self.get_total_lines();
        // Use last_viewport_height if available (more accurate), otherwise can't scroll
        let viewport_height = if self.last_viewport_height > 0 {
            self.last_viewport_height
        } else {
            return; // Can't scroll without knowing viewport size
        };
        // Max scroll should allow us to see all remaining content
        // When scroll_offset + viewport_height >= total_lines, we can see everything
        let max_scroll = if total_lines > viewport_height {
            total_lines - viewport_height
        } else {
            0
        };
        if self.scroll_offset < max_scroll {
            self.scroll_offset += 1;
        }
    }
    /// Scroll up by one line
    pub fn scroll_up(&mut self) {
        if self.scroll_offset > 0 {
            self.scroll_offset -= 1;
        }
    }
    /// Get total line count (needs to be calculated before rendering)
    pub fn get_total_lines(&self) -> usize {
        let mut count = 0;
        // CPU section (2+ lines for load/cstate, +1 if has model/cores)
        count += 2;
        if self.cpu_model_name.is_some() || self.cpu_core_count.is_some() {
            count += 1;
        }
        // RAM section (1 + tmpfs mounts)
        count += 2;
        count += self.tmpfs_mounts.len();
        // Network section
        if !self.network_interfaces.is_empty() {
            count += 1; // Header
            // Count network lines (would need to mirror render_network logic)
            for iface in &self.network_interfaces {
                count += 1; // Interface name
                count += iface.ipv4_addresses.len();
                count += iface.ipv6_addresses.len();
            }
        }
        // Storage section
        count += 1; // Header
        for pool in &self.storage_pools {
            count += 1; // Pool header
            count += pool.drives.len();
            count += pool.data_drives.len();
            count += pool.parity_drives.len();
            count += pool.filesystems.len();
        }
        // Backup section
        if !self.backup_repositories.is_empty() {
            count += 1; // Header: "Backup:"
            count += 1; // Repo count and timestamp header
            count += self.backup_repositories.len(); // Individual repos
        }
        count
    }
    pub fn render(&mut self, frame: &mut Frame, area: Rect, _hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
        // Store viewport height for accurate scroll calculations
        self.last_viewport_height = area.height as usize;
        let mut lines = Vec::new();
        // NixOS section
        lines.push(Line::from(vec![
            Span::styled(format!("NixOS {}:", hostname), Typography::widget_title())
        ]));
        let build_text = self.nixos_build.as_deref().unwrap_or("unknown");
        lines.push(Line::from(vec![
            Span::styled(format!("Build: {}", build_text), Typography::secondary())
        ]));
        let agent_version_text = self.agent_hash.as_deref().unwrap_or("unknown");
        lines.push(Line::from(vec![
            Span::styled(format!("Agent: {}", agent_version_text), 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())
@ -866,32 +832,12 @@ impl SystemWidget {
        );
        lines.push(Line::from(cpu_spans));
-        let cstate_text = self.format_cpu_cstate();
+        let freq_text = self.format_cpu_frequency();
        let has_cpu_info = self.cpu_model_name.is_some() || self.cpu_core_count.is_some();
        let cstate_tree = if has_cpu_info { "  ├─ " } else { "  └─ " };
        lines.push(Line::from(vec![
-            Span::styled(cstate_tree, Typography::tree()),
+            Span::styled("  └─ ", Typography::tree()),
-            Span::styled(format!("C-state: {}", cstate_text), Typography::secondary())
+            Span::styled(format!("Freq: {}", freq_text), Typography::secondary())
        ]));
        // CPU model and core count (if available)
        if let (Some(model), Some(cores)) = (&self.cpu_model_name, self.cpu_core_count) {
            lines.push(Line::from(vec![
                Span::styled("  └─ ", Typography::tree()),
                Span::styled(format!("{} ({} cores)", model, cores), Typography::secondary())
            ]));
        } else if let Some(model) = &self.cpu_model_name {
            lines.push(Line::from(vec![
                Span::styled("  └─ ", Typography::tree()),
                Span::styled(model.clone(), Typography::secondary())
            ]));
        } else if let Some(cores) = self.cpu_core_count {
            lines.push(Line::from(vec![
                Span::styled("  └─ ", Typography::tree()),
                Span::styled(format!("{} cores", cores), Typography::secondary())
            ]));
        }
        // RAM section
        lines.push(Line::from(vec![
            Span::styled("RAM:", Typography::widget_title())
@ -948,7 +894,7 @@ impl SystemWidget {
        lines.extend(storage_lines);
        // Backup section (if available)
-        if !self.backup_repositories.is_empty() {
+        if self.backup_status != "unavailable" && self.backup_status != "unknown" {
            lines.push(Line::from(vec![
                Span::styled("Backup:", Typography::widget_title())
            ]));
@ -961,50 +907,28 @@ impl SystemWidget {
        let total_lines = lines.len();
        let available_height = area.height as usize;
-        // Clamp scroll_offset to valid range based on current viewport and content
+        // Show only what fits, with "X more below" if needed
-        // This handles dynamic viewport size changes
+        if total_lines > available_height {
-        let max_valid_scroll = total_lines.saturating_sub(available_height);
+            let lines_for_content = available_height.saturating_sub(1); // Reserve one line for "more below"
-        let clamped_scroll = self.scroll_offset.min(max_valid_scroll);
+            let mut visible_lines: Vec<Line> = lines
                .into_iter()
                .take(lines_for_content)
                .collect();
-        // Calculate how many lines remain after scroll offset
+            let hidden_below = total_lines.saturating_sub(lines_for_content);
-        let remaining_lines = total_lines.saturating_sub(clamped_scroll);
+            if hidden_below > 0 {
                let more_line = Line::from(vec![
                    Span::styled(format!("... {} more below", hidden_below), Typography::muted())
                ]);
                visible_lines.push(more_line);
            }
-        // Check if all remaining content fits in viewport
+            let paragraph = Paragraph::new(Text::from(visible_lines));
-        let will_show_more_below = remaining_lines > available_height;
+            frame.render_widget(paragraph, area);
        // Reserve one line for "X more below" only if we can't fit everything
        let lines_for_content = if will_show_more_below {
            available_height.saturating_sub(1)
        } else {
-            available_height.min(remaining_lines)
+            // All content fits and no scroll offset, render normally
-        };
+            let paragraph = Paragraph::new(Text::from(lines));
-
+            frame.render_widget(paragraph, area);
        // Apply clamped scroll offset and take only what fits
        let mut visible_lines: Vec<Line> = lines
            .into_iter()
            .skip(clamped_scroll)
            .take(lines_for_content)
            .collect();
        // Note: we don't update self.scroll_offset here due to borrow checker constraints
        // It will be clamped on next render if still out of bounds
        // Only calculate hidden_below if we actually reserved space for the message
        let hidden_below = if will_show_more_below {
            remaining_lines.saturating_sub(lines_for_content)
        } else {
            0
        };
        // Add "more below" message if needed
        if hidden_below > 0 {
            let more_line = Line::from(vec![
                Span::styled(format!("... {} more below", hidden_below), Style::default().fg(Theme::border()))
            ]);
            visible_lines.push(more_line);
        }
        let paragraph = Paragraph::new(Text::from(visible_lines));
        frame.render_widget(paragraph, area);
    }
 }
--- a/shared/Cargo.toml
+++ b/shared/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.275"
+version = "0.1.197"
 edition = "2021"
 [dependencies]
--- a/shared/src/agent_data.rs
+++ b/shared/src/agent_data.rs
@ -38,14 +38,6 @@ pub struct NetworkInterfaceData {
    pub link_status: Status,
    pub parent_interface: Option<String>,
    pub vlan_id: Option<u16>,
    pub connection_method: Option<String>, // For Tailscale: "direct", "relay", or "proxy"
 }
 /// CPU C-state usage information
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CStateInfo {
    pub name: String,
    pub percent: f32,
 }
 /// CPU monitoring data
@ -54,15 +46,10 @@ pub struct CpuData {
    pub load_1min: f32,
    pub load_5min: f32,
    pub load_15min: f32,
-    pub cstates: Vec<CStateInfo>, // C-state usage percentages (C1, C6, C10, etc.) - indicates CPU idle depth distribution
+    pub frequency_mhz: f32,
    pub temperature_celsius: Option<f32>,
    pub load_status: Status,
    pub temperature_status: Status,
    // Static CPU information (collected once at startup)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub core_count: Option<u32>,
 }
 /// Memory monitoring data
@ -149,15 +136,11 @@ pub struct PoolDriveData {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ServiceData {
    pub name: String,
    pub memory_mb: f32,
    pub disk_gb: f32,
    pub user_stopped: bool,
    pub service_status: Status,
    pub sub_services: Vec<SubServiceData>,
    /// Memory usage in bytes (from MemoryCurrent)
    pub memory_bytes: Option<u64>,
    /// Number of service restarts (from NRestarts)
    pub restart_count: Option<u32>,
    /// Uptime in seconds (calculated from ExecMainStartTimestamp)
    pub uptime_seconds: Option<u64>,
 }
 /// Sub-service data (nginx sites, docker containers, etc.)
@ -182,18 +165,23 @@ pub struct SubServiceMetric {
 /// Backup system data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackupData {
-    pub last_backup_time: Option<String>,
+    pub status: String,
-    pub backup_status: Status,
+    pub total_size_gb: Option<f32>,
-    pub repositories: Vec<BackupRepositoryData>,
+    pub repository_health: Option<String>,
    pub repository_disk: Option<BackupDiskData>,
    pub last_backup_size_gb: Option<f32>,
    pub start_time_raw: Option<String>,
 }
-/// Individual backup repository information
+/// Backup repository disk information
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BackupRepositoryData {
+pub struct BackupDiskData {
-    pub name: String,
+    pub serial: String,
-    pub archive_count: i64,
+    pub usage_percent: f32,
-    pub repo_size_gb: f32,
+    pub used_gb: f32,
-    pub status: Status,
+    pub total_gb: f32,
    pub wear_percent: Option<f32>,
    pub temperature_celsius: Option<f32>,
 }
 impl AgentData {
@ -212,12 +200,10 @@ impl AgentData {
                    load_1min: 0.0,
                    load_5min: 0.0,
                    load_15min: 0.0,
-                    cstates: Vec::new(),
+                    frequency_mhz: 0.0,
                    temperature_celsius: None,
                    load_status: Status::Unknown,
                    temperature_status: Status::Unknown,
                    model_name: None,
                    core_count: None,
                },
                memory: MemoryData {
                    usage_percent: 0.0,
@ -236,9 +222,12 @@ impl AgentData {
            },
            services: Vec::new(),
            backup: BackupData {
-                last_backup_time: None,
+                status: "unknown".to_string(),
-                backup_status: Status::Unknown,
+                total_size_gb: None,
-                repositories: Vec::new(),
+                repository_health: None,
                repository_disk: None,
                last_backup_size_gb: None,
                start_time_raw: None,
            },
        }
    }
--- a/shared/src/metrics.rs
+++ b/shared/src/metrics.rs
@ -82,12 +82,11 @@ impl MetricValue {
 /// Health status for metrics
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Status {
-    Info,     // Lowest priority - informational data with no status (no icon)
+    Inactive, // Lowest priority
    Inactive, //
    Unknown,  // 
    Offline,  // 
    Pending,  // 
-    Ok,       // Good status has higher priority than unknown states
+    Ok,       // 5th place - good status has higher priority than unknown states
    Warning,  // 
    Critical, // Highest priority
 }
@ -224,17 +223,6 @@ impl HysteresisThresholds {
                    Status::Ok
                }
            }
            Status::Info => {
                // Informational data shouldn't be used with hysteresis calculations
                // Treat like Unknown if it somehow ends up here
                if value >= self.critical_high {
                    Status::Critical
                } else if value >= self.warning_high {
                    Status::Warning
                } else {
                    Status::Ok
                }
            }
        }
    }
 }