group related scores together

rename a few scores & interprets
fix: improve usage of indicatif for tracking progress
2025-08-09 23:20:45 -04:00 · 2025-08-09 23:18:15 -04:00 · 2025-08-09 23:18:15 -04:00
37 changed files with 379 additions and 1738 deletions
--- a/.gitea/workflows/check.yml
+++ b/.gitea/workflows/check.yml
@@ -9,7 +9,7 @@ jobs:
  check:
    runs-on: docker
    container:
-      image: hub.nationtech.io/harmony/harmony_composer:latest
+      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
--- a/.gitea/workflows/harmony_composer.yaml
+++ b/.gitea/workflows/harmony_composer.yaml
@@ -7,7 +7,7 @@ on:
 jobs:
  package_harmony_composer:
    container:
-      image: hub.nationtech.io/harmony/harmony_composer:latest
+      image: hub.nationtech.io/harmony/harmony_composer:latest@sha256:eb0406fcb95c63df9b7c4b19bc50ad7914dd8232ce98e9c9abef628e07c69386
    runs-on: dind
    steps:
      - name: Checkout code
@@ -45,14 +45,14 @@ jobs:
            -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
            "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases/tags/snapshot-latest" \
            | jq -r '.id // empty')
-
+          
          if [ -n "$RELEASE_ID" ]; then
            # Delete existing release
            curl -X DELETE \
              -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
              "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases/$RELEASE_ID"
          fi
-
+          
          # Create new release
          RESPONSE=$(curl -X POST \
            -H "Authorization: token ${{ secrets.GITEATOKEN }}" \
@@ -65,7 +65,7 @@ jobs:
              "prerelease": true
            }' \
            "https://git.nationtech.io/api/v1/repos/nationtech/harmony/releases")
-
+          
          echo "RELEASE_ID=$(echo $RESPONSE | jq -r '.id')" >> $GITHUB_ENV

      - name: Upload Linux binary
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,189 +2,6 @@
 # It is not intended for manual editing.
 version = 4

-[[package]]
-name = "actix-codec"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f7b0a21988c1bf877cf4759ef5ddaac04c1c9fe808c9142ecb78ba97d97a28a"
-dependencies = [
- "bitflags 2.9.1",
- "bytes",
- "futures-core",
- "futures-sink",
- "memchr",
- "pin-project-lite",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
-[[package]]
-name = "actix-http"
-version = "3.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44dfe5c9e0004c623edc65391dfd51daa201e7e30ebd9c9bedf873048ec32bc2"
-dependencies = [
- "actix-codec",
- "actix-rt",
- "actix-service",
- "actix-utils",
- "base64 0.22.1",
- "bitflags 2.9.1",
- "brotli",
- "bytes",
- "bytestring",
- "derive_more",
- "encoding_rs",
- "flate2",
- "foldhash",
- "futures-core",
- "h2 0.3.26",
- "http 0.2.12",
- "httparse",
- "httpdate",
- "itoa",
- "language-tags",
- "local-channel",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rand 0.9.1",
- "sha1",
- "smallvec",
- "tokio",
- "tokio-util",
- "tracing",
- "zstd",
-]
-
-[[package]]
-name = "actix-macros"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb"
-dependencies = [
- "quote",
- "syn",
-]
-
-[[package]]
-name = "actix-router"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13d324164c51f63867b57e73ba5936ea151b8a41a1d23d1031eeb9f70d0236f8"
-dependencies = [
- "bytestring",
- "cfg-if",
- "http 0.2.12",
- "regex",
- "regex-lite",
- "serde",
- "tracing",
-]
-
-[[package]]
-name = "actix-rt"
-version = "2.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eda4e2a6e042aa4e55ac438a2ae052d3b5da0ecf83d7411e1a368946925208"
-dependencies = [
- "futures-core",
- "tokio",
-]
-
-[[package]]
-name = "actix-server"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a65064ea4a457eaf07f2fba30b4c695bf43b721790e9530d26cb6f9019ff7502"
-dependencies = [
- "actix-rt",
- "actix-service",
- "actix-utils",
- "futures-core",
- "futures-util",
- "mio 1.0.4",
- "socket2",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "actix-service"
-version = "2.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e46f36bf0e5af44bdc4bdb36fbbd421aa98c79a9bce724e1edeb3894e10dc7f"
-dependencies = [
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "actix-utils"
-version = "3.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88a1dcdff1466e3c2488e1cb5c36a71822750ad43839937f85d2f4d9f8b705d8"
-dependencies = [
- "local-waker",
- "pin-project-lite",
-]
-
-[[package]]
-name = "actix-web"
-version = "4.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a597b77b5c6d6a1e1097fddde329a83665e25c5437c696a3a9a4aa514a614dea"
-dependencies = [
- "actix-codec",
- "actix-http",
- "actix-macros",
- "actix-router",
- "actix-rt",
- "actix-server",
- "actix-service",
- "actix-utils",
- "actix-web-codegen",
- "bytes",
- "bytestring",
- "cfg-if",
- "cookie",
- "derive_more",
- "encoding_rs",
- "foldhash",
- "futures-core",
- "futures-util",
- "impl-more",
- "itoa",
- "language-tags",
- "log",
- "mime",
- "once_cell",
- "pin-project-lite",
- "regex",
- "regex-lite",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "smallvec",
- "socket2",
- "time",
- "tracing",
- "url",
-]
-
-[[package]]
-name = "actix-web-codegen"
-version = "4.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f591380e2e68490b5dfaf1dd1aa0ebe78d84ba7067078512b4ea6e4492d622b8"
-dependencies = [
- "actix-router",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "addr2line"
 version = "0.24.2"
@@ -258,21 +75,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "alloc-no-stdlib"
-version = "2.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
-
-[[package]]
-name = "alloc-stdlib"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
-dependencies = [
- "alloc-no-stdlib",
-]
-
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -596,27 +398,6 @@ dependencies = [
 "serde_with",
 ]

-[[package]]
-name = "brotli"
-version = "8.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
- "brotli-decompressor",
-]
-
-[[package]]
-name = "brotli-decompressor"
-version = "5.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
-dependencies = [
- "alloc-no-stdlib",
- "alloc-stdlib",
-]
-
 [[package]]
 name = "bstr"
 version = "1.12.0"
@@ -646,15 +427,6 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"

-[[package]]
-name = "bytestring"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e465647ae23b2823b0753f50decb2d5a86d2bb2cac04788fafd1f80e45378e5f"
-dependencies = [
- "bytes",
-]
-
 [[package]]
 name = "camino"
 version = "1.1.10"
@@ -734,8 +506,6 @@ version = "1.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d487aa071b5f64da6f19a3e848e3578944b726ee5a4854b82172f02aa876bfdc"
 dependencies = [
- "jobserver",
- "libc",
 "shlex",
 ]

@@ -934,17 +704,6 @@ dependencies = [
 "unicode-segmentation",
 ]

-[[package]]
-name = "cookie"
-version = "0.16.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e859cd57d0710d9e06c381b550c06e76992472a8c6d527aecd2fc673dcc231fb"
-dependencies = [
- "percent-encoding",
- "time",
- "version_check",
-]
-
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -998,25 +757,6 @@ dependencies = [
 "crossbeam-utils",
 ]

-[[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
@@ -1227,7 +967,6 @@ dependencies = [
 "proc-macro2",
 "quote",
 "syn",
- "unicode-xid",
 ]

 [[package]]
@@ -2095,7 +1834,6 @@ name = "harmony_cli"
 version = "0.1.0"
 dependencies = [
 "assert_cmd",
- "chrono",
 "clap",
 "console",
 "env_logger",
@@ -2130,19 +1868,6 @@ dependencies = [
 "tokio",
 ]

-[[package]]
-name = "harmony_inventory_agent"
-version = "0.1.0"
-dependencies = [
- "actix-web",
- "env_logger",
- "log",
- "serde",
- "serde_json",
- "sysinfo",
- "uuid",
-]
-
 [[package]]
 name = "harmony_macros"
 version = "0.1.0"
@@ -2581,7 +2306,7 @@ dependencies = [
 "js-sys",
 "log",
 "wasm-bindgen",
- "windows-core 0.61.2",
+ "windows-core",
 ]

 [[package]]
@@ -2706,12 +2431,6 @@ dependencies = [
 "icu_properties",
 ]

-[[package]]
-name = "impl-more"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a5a9a0ff0086c7a148acb942baaabeadf9504d10400b5a05645853729b9cd2"
-
 [[package]]
 name = "indenter"
 version = "0.3.3"
@@ -2870,16 +2589,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "jobserver"
-version = "0.1.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
-dependencies = [
- "getrandom 0.3.3",
- "libc",
-]
-
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -3082,12 +2791,6 @@ dependencies = [
 "tracing",
 ]

-[[package]]
-name = "language-tags"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4345964bb142484797b161f473a503a434de77149dd8c7427788c6e13379388"
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -3151,23 +2854,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"

-[[package]]
-name = "local-channel"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6cbc85e69b8df4b8bb8b89ec634e7189099cea8927a276b7384ce5488e53ec8"
-dependencies = [
- "futures-core",
- "futures-sink",
- "local-waker",
-]
-
-[[package]]
-name = "local-waker"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d873d7c67ce09b42110d801813efbc9364414e356be9935700d368351657487"
-
 [[package]]
 name = "lock_api"
 version = "0.4.13"
@@ -3297,15 +2983,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "ntapi"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.4.6"
@@ -4026,26 +3703,6 @@ dependencies = [
 "unicode-width 0.2.0",
 ]

-[[package]]
-name = "rayon"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.13"
@@ -4109,12 +3766,6 @@ dependencies = [
 "regex-syntax",
 ]

-[[package]]
-name = "regex-lite"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -5147,21 +4798,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "sysinfo"
-version = "0.30.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5b4ddaee55fb2bea2bf0e5000747e5f5c0de765e5a5ff87f4cd106439f4bb3"
-dependencies = [
- "cfg-if",
- "core-foundation-sys",
- "libc",
- "ntapi",
- "once_cell",
- "rayon",
- "windows",
-]
-
 [[package]]
 name = "system-configuration"
 version = "0.5.1"
@@ -5361,7 +4997,6 @@ dependencies = [
 "bytes",
 "libc",
 "mio 1.0.4",
- "parking_lot",
 "pin-project-lite",
 "signal-hook-registry",
 "socket2",
@@ -5939,25 +5574,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

-[[package]]
-name = "windows"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
-dependencies = [
- "windows-core 0.52.0",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -6441,31 +6057,3 @@ dependencies = [
 "quote",
 "syn",
 ]
-
-[[package]]
-name = "zstd"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
-dependencies = [
- "zstd-safe",
-]
-
-[[package]]
-name = "zstd-safe"
-version = "7.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
-dependencies = [
- "zstd-sys",
-]
-
-[[package]]
-name = "zstd-sys"
-version = "2.0.15+zstd.1.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
-dependencies = [
- "cc",
- "pkg-config",
-]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,6 @@ members = [
  "harmony_cli",
  "k3d",
  "harmony_composer",
-  "harmony_inventory_agent",
 ]

 [workspace.package]
@@ -21,7 +20,7 @@ readme = "README.md"
 license = "GNU AGPL v3"

 [workspace.dependencies]
-log = { version = "0.4", features = ["kv"] }
+log = "0.4"
 env_logger = "0.11"
 derive-new = "0.7"
 async-trait = "0.1"
@@ -57,8 +56,3 @@ pretty_assertions = "1.4.1"
 bollard = "0.19.1"
 base64 = "0.22.1"
 tar = "0.4.44"
-lazy_static = "1.5.0"
-directories = "6.0.0"
-thiserror = "2.0.14"
-serde = { version = "1.0.209", features = ["derive", "rc"] }
-serde_json = "1.0.127"
--- a/examples/application_monitoring_with_tenant/harmony
+++ b/examples/application_monitoring_with_tenant/harmony
--- a/examples/nanodc/src/main.rs
+++ b/examples/nanodc/src/main.rs
@@ -8,6 +8,7 @@ use harmony::{
    hardware::{FirewallGroup, HostCategory, Location, PhysicalHost, SwitchGroup},
    infra::opnsense::OPNSenseManagementInterface,
    inventory::Inventory,
+    maestro::Maestro,
    modules::{
        http::StaticFilesHttpScore,
        ipxe::IpxeScore,
@@ -129,21 +130,16 @@ async fn main() {
        "./data/watchguard/pxe-http-files".to_string(),
    ));
    let ipxe_score = IpxeScore::new();
-
-    harmony_tui::run(
-        inventory,
-        topology,
-        vec![
-            Box::new(dns_score),
-            Box::new(bootstrap_dhcp_score),
-            Box::new(bootstrap_load_balancer_score),
-            Box::new(load_balancer_score),
-            Box::new(tftp_score),
-            Box::new(http_score),
-            Box::new(ipxe_score),
-            Box::new(dhcp_score),
-        ],
-    )
-    .await
-    .unwrap();
+    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+    maestro.register_all(vec![
+        Box::new(dns_score),
+        Box::new(bootstrap_dhcp_score),
+        Box::new(bootstrap_load_balancer_score),
+        Box::new(load_balancer_score),
+        Box::new(tftp_score),
+        Box::new(http_score),
+        Box::new(ipxe_score),
+        Box::new(dhcp_score),
+    ]);
+    harmony_tui::init(maestro).await.unwrap();
 }
--- a/examples/opnsense/src/main.rs
+++ b/examples/opnsense/src/main.rs
@@ -8,6 +8,7 @@ use harmony::{
    hardware::{FirewallGroup, HostCategory, Location, PhysicalHost, SwitchGroup},
    infra::opnsense::OPNSenseManagementInterface,
    inventory::Inventory,
+    maestro::Maestro,
    modules::{
        dummy::{ErrorScore, PanicScore, SuccessScore},
        http::StaticFilesHttpScore,
@@ -83,25 +84,20 @@ async fn main() {
    let http_score = StaticFilesHttpScore::new(Url::LocalFolder(
        "./data/watchguard/pxe-http-files".to_string(),
    ));
-
-    harmony_tui::run(
-        inventory,
-        topology,
-        vec![
-            Box::new(dns_score),
-            Box::new(dhcp_score),
-            Box::new(load_balancer_score),
-            Box::new(tftp_score),
-            Box::new(http_score),
-            Box::new(OPNsenseShellCommandScore {
-                opnsense: opnsense.get_opnsense_config(),
-                command: "touch /tmp/helloharmonytouching".to_string(),
-            }),
-            Box::new(SuccessScore {}),
-            Box::new(ErrorScore {}),
-            Box::new(PanicScore {}),
-        ],
-    )
-    .await
-    .unwrap();
+    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+    maestro.register_all(vec![
+        Box::new(dns_score),
+        Box::new(dhcp_score),
+        Box::new(load_balancer_score),
+        Box::new(tftp_score),
+        Box::new(http_score),
+        Box::new(OPNsenseShellCommandScore {
+            opnsense: opnsense.get_opnsense_config(),
+            command: "touch /tmp/helloharmonytouching".to_string(),
+        }),
+        Box::new(SuccessScore {}),
+        Box::new(ErrorScore {}),
+        Box::new(PanicScore {}),
+    ]);
+    harmony_tui::init(maestro).await.unwrap();
 }
--- a/examples/tui/src/main.rs
+++ b/examples/tui/src/main.rs
@@ -2,6 +2,7 @@ use std::net::{SocketAddr, SocketAddrV4};

 use harmony::{
    inventory::Inventory,
+    maestro::Maestro,
    modules::{
        dns::DnsScore,
        dummy::{ErrorScore, PanicScore, SuccessScore},
@@ -15,19 +16,18 @@ use harmony_macros::ipv4;

 #[tokio::main]
 async fn main() {
-    harmony_tui::run(
-        Inventory::autoload(),
-        DummyInfra {},
-        vec![
-            Box::new(SuccessScore {}),
-            Box::new(ErrorScore {}),
-            Box::new(PanicScore {}),
-            Box::new(DnsScore::new(vec![], None)),
-            Box::new(build_large_score()),
-        ],
-    )
-    .await
-    .unwrap();
+    let inventory = Inventory::autoload();
+    let topology = DummyInfra {};
+    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
+
+    maestro.register_all(vec![
+        Box::new(SuccessScore {}),
+        Box::new(ErrorScore {}),
+        Box::new(PanicScore {}),
+        Box::new(DnsScore::new(vec![], None)),
+        Box::new(build_large_score()),
+    ]);
+    harmony_tui::init(maestro).await.unwrap();
 }

 fn build_large_score() -> LoadBalancerScore {
--- a/harmony/Cargo.toml
+++ b/harmony/Cargo.toml
@@ -5,9 +5,6 @@ version.workspace = true
 readme.workspace = true
 license.workspace = true

-[features]
-testing = []
-
 [dependencies]
 rand = "0.9"
 hex = "0.4"
@@ -16,8 +13,8 @@ reqwest = { version = "0.11", features = ["blocking", "json"] }
 russh = "0.45.0"
 rust-ipmi = "0.1.1"
 semver = "1.0.23"
-serde.workspace = true
-serde_json.workspace = true
+serde = { version = "1.0.209", features = ["derive", "rc"] }
+serde_json = "1.0.127"
 tokio.workspace = true
 derive-new.workspace = true
 log.workspace = true
--- a/harmony/src/domain/instrumentation.rs
+++ b/harmony/src/domain/instrumentation.rs
@@ -2,8 +2,6 @@ use log::debug;
 use once_cell::sync::Lazy;
 use tokio::sync::broadcast;

-use crate::modules::application::ApplicationFeatureStatus;
-
 use super::{
    interpret::{InterpretError, Outcome},
    topology::TopologyStatus,
@@ -32,12 +30,6 @@ pub enum HarmonyEvent {
        status: TopologyStatus,
        message: Option<String>,
    },
-    ApplicationFeatureStateChanged {
-        topology: String,
-        application: String,
-        feature: String,
-        status: ApplicationFeatureStatus,
-    },
 }

 static HARMONY_EVENT_BUS: Lazy<broadcast::Sender<HarmonyEvent>> = Lazy::new(|| {
@@ -47,14 +39,9 @@ static HARMONY_EVENT_BUS: Lazy<broadcast::Sender<HarmonyEvent>> = Lazy::new(|| {
 });

 pub fn instrument(event: HarmonyEvent) -> Result<(), &'static str> {
-    if cfg!(any(test, feature = "testing")) {
-        let _ = event; // Suppress the "unused variable" warning for `event`
-        Ok(())
-    } else {
-        match HARMONY_EVENT_BUS.send(event) {
-            Ok(_) => Ok(()),
-            Err(_) => Err("send error: no subscribers"),
-        }
+    match HARMONY_EVENT_BUS.send(event) {
+        Ok(_) => Ok(()),
+        Err(_) => Err("send error: no subscribers"),
    }
 }

--- a/harmony/src/domain/topology/ha_cluster.rs
+++ b/harmony/src/domain/topology/ha_cluster.rs
@@ -241,7 +241,7 @@ pub struct DummyInfra;
 #[async_trait]
 impl Topology for DummyInfra {
    fn name(&self) -> &str {
-        "DummyInfra"
+        todo!()
    }

    async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {
--- a/harmony/src/domain/topology/k8s.rs
+++ b/harmony/src/domain/topology/k8s.rs
@@ -120,7 +120,7 @@ impl K8sClient {
                    .expect("Couldn't unwrap status");

                if let Some(s) = status.status {
-                    debug!("Status: {} - {:?}", s, status.details);
+                    debug!("Status: {}", s);
                    if s == "Success" { Ok(()) } else { Err(s) }
                } else {
                    Err("Couldn't get inner status of pod exec".to_string())
--- a/harmony/src/domain/topology/k8s_anywhere.rs
+++ b/harmony/src/domain/topology/k8s_anywhere.rs
@@ -28,13 +28,7 @@ use super::{
    PreparationOutcome, Topology,
    k8s::K8sClient,
    oberservability::monitoring::AlertReceiver,
-    tenant::{
-        TenantConfig, TenantManager,
-        k8s::K8sTenantManager,
-        network_policy::{
-            K3dNetworkPolicyStrategy, NetworkPolicyStrategy, NoopNetworkPolicyStrategy,
-        },
-    },
+    tenant::{TenantConfig, TenantManager, k8s::K8sTenantManager},
 };

 #[derive(Clone, Debug)]
@@ -256,21 +250,16 @@ impl K8sAnywhereTopology {
        Ok(Some(state))
    }

-    async fn ensure_k8s_tenant_manager(&self, k8s_state: &K8sState) -> Result<(), String> {
+    async fn ensure_k8s_tenant_manager(&self) -> Result<(), String> {
        if self.tenant_manager.get().is_some() {
            return Ok(());
        }

        self.tenant_manager
            .get_or_try_init(async || -> Result<K8sTenantManager, String> {
+                // TOOD: checker si K8s ou K3d/s tenant manager (ref. issue https://git.nationtech.io/NationTech/harmony/issues/94)
                let k8s_client = self.k8s_client().await?;
-                let network_policy_strategy: Box<dyn NetworkPolicyStrategy> = match k8s_state.source
-                {
-                    K8sSource::LocalK3d => Box::new(K3dNetworkPolicyStrategy::new()),
-                    K8sSource::Kubeconfig => Box::new(NoopNetworkPolicyStrategy::new()),
-                };
-
-                Ok(K8sTenantManager::new(k8s_client, network_policy_strategy))
+                Ok(K8sTenantManager::new(k8s_client))
            })
            .await?;

@@ -401,7 +390,7 @@ impl Topology for K8sAnywhereTopology {
            "no K8s client could be found or installed".to_string(),
        ))?;

-        self.ensure_k8s_tenant_manager(k8s_state)
+        self.ensure_k8s_tenant_manager()
            .await
            .map_err(PreparationError::new)?;

--- a/harmony/src/domain/topology/tenant/k8s.rs
+++ b/harmony/src/domain/topology/tenant/k8s.rs
@@ -20,27 +20,24 @@ use serde::de::DeserializeOwned;
 use serde_json::json;
 use tokio::sync::OnceCell;

-use super::{TenantConfig, TenantManager, network_policy::NetworkPolicyStrategy};
+use super::{TenantConfig, TenantManager};

-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct K8sTenantManager {
    k8s_client: Arc<K8sClient>,
    k8s_tenant_config: Arc<OnceCell<TenantConfig>>,
-    network_policy_strategy: Box<dyn NetworkPolicyStrategy>,
 }

 impl K8sTenantManager {
-    pub fn new(
-        client: Arc<K8sClient>,
-        network_policy_strategy: Box<dyn NetworkPolicyStrategy>,
-    ) -> Self {
+    pub fn new(client: Arc<K8sClient>) -> Self {
        Self {
            k8s_client: client,
            k8s_tenant_config: Arc::new(OnceCell::new()),
-            network_policy_strategy,
        }
    }
+}

+impl K8sTenantManager {
    fn get_namespace_name(&self, config: &TenantConfig) -> String {
        config.name.clone()
    }
@@ -221,6 +218,29 @@ impl K8sTenantManager {
                  }
                ]
              },
+              {
+                "to": [
+                  {
+                "ipBlock": {
+                    "cidr": "10.43.0.1/32",
+                    }
+                  }
+                ]
+              },
+              {
+                "to": [
+                  {
+                      //TODO this ip is from the docker network that k3d is running on
+                      //since k3d does not deploy kube-api-server as a pod it needs to ahve the ip
+                      //address opened up
+                      //need to find a way to automatically detect the ip address from the docker
+                      //network
+                "ipBlock": {
+                    "cidr": "172.18.0.0/16",
+                    }
+                  }
+                ]
+              },
              {
                "to": [
                  {
@@ -390,27 +410,12 @@ impl K8sTenantManager {
    }
 }

-impl Clone for K8sTenantManager {
-    fn clone(&self) -> Self {
-        Self {
-            k8s_client: self.k8s_client.clone(),
-            k8s_tenant_config: self.k8s_tenant_config.clone(),
-            network_policy_strategy: self.network_policy_strategy.clone_box(),
-        }
-    }
-}
-
 #[async_trait]
 impl TenantManager for K8sTenantManager {
    async fn provision_tenant(&self, config: &TenantConfig) -> Result<(), ExecutorError> {
        let namespace = self.build_namespace(config)?;
        let resource_quota = self.build_resource_quota(config)?;
-
        let network_policy = self.build_network_policy(config)?;
-        let network_policy = self
-            .network_policy_strategy
-            .adjust_policy(network_policy, config);
-
        let resource_limit_range = self.build_limit_range(config)?;

        self.ensure_constraints(&namespace)?;
--- a/harmony/src/domain/topology/tenant/mod.rs
+++ b/harmony/src/domain/topology/tenant/mod.rs
@@ -1,11 +1,11 @@
 pub mod k8s;
 mod manager;
-pub mod network_policy;
+use std::str::FromStr;

-use crate::data::Id;
 pub use manager::*;
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
+
+use crate::data::Id;

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] // Assuming serde for Scores
 pub struct TenantConfig {
--- a/harmony/src/domain/topology/tenant/network_policy.rs
+++ b/harmony/src/domain/topology/tenant/network_policy.rs
@@ -1,120 +0,0 @@
-use k8s_openapi::api::networking::v1::{
-    IPBlock, NetworkPolicy, NetworkPolicyEgressRule, NetworkPolicyPeer, NetworkPolicySpec,
-};
-
-use super::TenantConfig;
-
-pub trait NetworkPolicyStrategy: Send + Sync + std::fmt::Debug {
-    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy>;
-
-    fn adjust_policy(&self, policy: NetworkPolicy, config: &TenantConfig) -> NetworkPolicy;
-}
-
-#[derive(Clone, Debug)]
-pub struct NoopNetworkPolicyStrategy {}
-
-impl NoopNetworkPolicyStrategy {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Default for NoopNetworkPolicyStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl NetworkPolicyStrategy for NoopNetworkPolicyStrategy {
-    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy> {
-        Box::new(self.clone())
-    }
-
-    fn adjust_policy(&self, policy: NetworkPolicy, _config: &TenantConfig) -> NetworkPolicy {
-        policy
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct K3dNetworkPolicyStrategy {}
-
-impl K3dNetworkPolicyStrategy {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Default for K3dNetworkPolicyStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl NetworkPolicyStrategy for K3dNetworkPolicyStrategy {
-    fn clone_box(&self) -> Box<dyn NetworkPolicyStrategy> {
-        Box::new(self.clone())
-    }
-
-    fn adjust_policy(&self, policy: NetworkPolicy, _config: &TenantConfig) -> NetworkPolicy {
-        let mut egress = policy
-            .spec
-            .clone()
-            .unwrap_or_default()
-            .egress
-            .clone()
-            .unwrap_or_default();
-        egress.push(NetworkPolicyEgressRule {
-            to: Some(vec![NetworkPolicyPeer {
-                ip_block: Some(IPBlock {
-                    cidr: "172.18.0.0/16".into(), // TODO: query the IP range https://git.nationtech.io/NationTech/harmony/issues/108
-                    ..Default::default()
-                }),
-                ..Default::default()
-            }]),
-            ..Default::default()
-        });
-
-        NetworkPolicy {
-            spec: Some(NetworkPolicySpec {
-                egress: Some(egress),
-                ..policy.spec.unwrap_or_default()
-            }),
-            ..policy
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use k8s_openapi::api::networking::v1::{
-        IPBlock, NetworkPolicy, NetworkPolicyEgressRule, NetworkPolicyPeer, NetworkPolicySpec,
-    };
-
-    use super::{K3dNetworkPolicyStrategy, NetworkPolicyStrategy};
-
-    #[test]
-    pub fn should_add_ip_block_for_k3d_harmony_server() {
-        let strategy = K3dNetworkPolicyStrategy::new();
-
-        let policy =
-            strategy.adjust_policy(NetworkPolicy::default(), &super::TenantConfig::default());
-
-        let expected_policy = NetworkPolicy {
-            spec: Some(NetworkPolicySpec {
-                egress: Some(vec![NetworkPolicyEgressRule {
-                    to: Some(vec![NetworkPolicyPeer {
-                        ip_block: Some(IPBlock {
-                            cidr: "172.18.0.0/16".into(),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }]),
-                    ..Default::default()
-                }]),
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-        assert_eq!(expected_policy, policy);
-    }
-}
--- a/harmony/src/modules/application/features/continuous_delivery.rs
+++ b/harmony/src/modules/application/features/continuous_delivery.rs
@@ -1,7 +1,7 @@
 use std::{io::Write, process::Command, sync::Arc};

 use async_trait::async_trait;
-use log::info;
+use log::{debug, error};
 use serde_yaml::Value;
 use tempfile::NamedTempFile;

@@ -56,11 +56,14 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
        chart_url: String,
        image_name: String,
    ) -> Result<(), String> {
-        // TODO: This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
-        // https://git.nationtech.io/NationTech/harmony/issues/106
+        error!(
+            "FIXME This works only with local k3d installations, which is fine only for current demo purposes. We assume usage of K8sAnywhereTopology"
+        );
+
+        error!("TODO hardcoded k3d bin path is wrong");
        let k3d_bin_path = (*HARMONY_DATA_DIR).join("k3d").join("k3d");
        // --- 1. Import the container image into the k3d cluster ---
-        info!(
+        debug!(
            "Importing image '{}' into k3d cluster 'harmony'",
            image_name
        );
@@ -77,7 +80,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
        }

        // --- 2. Get the kubeconfig for the k3d cluster and write it to a temp file ---
-        info!("Retrieving kubeconfig for k3d cluster 'harmony'");
+        debug!("Retrieving kubeconfig for k3d cluster 'harmony'");
        let kubeconfig_output = Command::new(&k3d_bin_path)
            .args(["kubeconfig", "get", "harmony"])
            .output()
@@ -98,7 +101,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
        let kubeconfig_path = temp_kubeconfig.path().to_str().unwrap();

        // --- 3. Install or upgrade the Helm chart in the cluster ---
-        info!(
+        debug!(
            "Deploying Helm chart '{}' to namespace '{}'",
            chart_url, app_name
        );
@@ -128,7 +131,7 @@ impl<A: OCICompliant + HelmPackage> ContinuousDelivery<A> {
            ));
        }

-        info!("Successfully deployed '{}' to local k3d cluster.", app_name);
+        debug!("Successfully deployed '{}' to local k3d cluster.", app_name);
        Ok(())
    }
 }
@@ -148,12 +151,14 @@ impl<
        // Or ask for it when unknown

        let helm_chart = self.application.build_push_helm_package(&image).await?;
+        debug!("Pushed new helm chart {helm_chart}");

-        // TODO: Make building image configurable/skippable if image already exists (prompt)")
-        // https://git.nationtech.io/NationTech/harmony/issues/104
+        error!("TODO Make building image configurable/skippable if image already exists (prompt)");
        let image = self.application.build_push_oci_image().await?;
+        debug!("Pushed new docker image {image}");

-        // TODO: this is a temporary hack for demo purposes, the deployment target should be driven
+        debug!("Installing ContinuousDelivery feature");
+        // TODO this is a temporary hack for demo purposes, the deployment target should be driven
        // by the topology only and we should not have to know how to perform tasks like this for
        // which the topology should be responsible.
        //
@@ -166,20 +171,17 @@ impl<
        // access it. This forces every Topology to understand the concept of targets though... So
        // instead I'll create a new Capability which is MultiTargetTopology and we'll see how it
        // goes. It still does not feel right though.
-        //
-        // https://git.nationtech.io/NationTech/harmony/issues/106
        match topology.current_target() {
            DeploymentTarget::LocalDev => {
-                info!("Deploying {} locally...", self.application.name());
                self.deploy_to_local_k3d(self.application.name(), helm_chart, image)
                    .await?;
            }
            target => {
-                info!("Deploying {} to target {target:?}", self.application.name());
+                debug!("Deploying to target {target:?}");
                let score = ArgoHelmScore {
-                    namespace: "harmony-example-rust-webapp".to_string(),
-                    openshift: true,
-                    domain: "argo.harmonydemo.apps.ncd0.harmony.mcd".to_string(),
+                    namespace: "harmonydemo-staging".to_string(),
+                    openshift: false,
+                    domain: "argo.harmonydemo.apps.st.mcd".to_string(),
                    argo_apps: vec![ArgoApplication::from(CDApplicationConfig {
                        // helm pull oci://hub.nationtech.io/harmony/harmony-example-rust-webapp-chart --version 0.1.0
                        version: Version::from("0.1.0").unwrap(),
@@ -187,7 +189,7 @@ impl<
                        helm_chart_name: "harmony-example-rust-webapp-chart".to_string(),
                        values_overrides: None,
                        name: "harmony-demo-rust-webapp".to_string(),
-                        namespace: "harmony-example-rust-webapp".to_string(),
+                        namespace: "harmonydemo-staging".to_string(),
                    })],
                };
                score
--- a/harmony/src/modules/application/features/helm_argocd_score.rs
+++ b/harmony/src/modules/application/features/helm_argocd_score.rs
@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use log::error;
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
 use std::str::FromStr;
@@ -49,6 +50,7 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for ArgoInterpret {
        inventory: &Inventory,
        topology: &T,
    ) -> Result<Outcome, InterpretError> {
+        error!("Uncomment below, only disabled for debugging");
        self.score.interpret(inventory, topology).await?;

        let k8s_client = topology.k8s_client().await?;
@@ -56,14 +58,9 @@ impl<T: Topology + K8sclient + HelmCommand> Interpret<T> for ArgoInterpret {
            .apply_yaml_many(&self.argo_apps.iter().map(|a| a.to_yaml()).collect(), None)
            .await
            .unwrap();
-
        Ok(Outcome::success(format!(
-            "ArgoCD installed with {} {}",
-            self.argo_apps.len(),
-            match self.argo_apps.len() {
-                1 => "application",
-                _ => "applications",
-            }
+            "ArgoCD installed with {} applications",
+            self.argo_apps.len()
        )))
    }

--- a/harmony/src/modules/application/features/monitoring.rs
+++ b/harmony/src/modules/application/features/monitoring.rs
@@ -4,7 +4,6 @@ use crate::modules::application::{Application, ApplicationFeature};
 use crate::modules::monitoring::application_monitoring::application_monitoring_score::ApplicationMonitoringScore;
 use crate::modules::monitoring::kube_prometheus::crd::crd_alertmanager_config::CRDPrometheus;

-use crate::topology::MultiTargetTopology;
 use crate::{
    inventory::Inventory,
    modules::monitoring::{
@@ -34,7 +33,6 @@ impl<
        + 'static
        + TenantManager
        + K8sclient
-        + MultiTargetTopology
        + std::fmt::Debug
        + PrometheusApplicationMonitoring<CRDPrometheus>,
 > ApplicationFeature<T> for Monitoring
@@ -57,11 +55,11 @@ impl<
        };
        let ntfy = NtfyScore {
            namespace: namespace.clone(),
-            host: "ntfy.harmonydemo.apps.ncd0.harmony.mcd".to_string(),
+            host: "localhost".to_string(),
        };
        ntfy.interpret(&Inventory::empty(), topology)
            .await
-            .map_err(|e| e.to_string())?;
+            .expect("couldn't create interpret for ntfy");

        let ntfy_default_auth_username = "harmony";
        let ntfy_default_auth_password = "harmony";
@@ -98,7 +96,7 @@ impl<
        alerting_score
            .interpret(&Inventory::empty(), topology)
            .await
-            .map_err(|e| e.to_string())?;
+            .unwrap();
        Ok(())
    }
    fn name(&self) -> String {
--- a/harmony/src/modules/application/mod.rs
+++ b/harmony/src/modules/application/mod.rs
@@ -14,19 +14,11 @@ use serde::Serialize;

 use crate::{
    data::{Id, Version},
-    instrumentation::{self, HarmonyEvent},
    interpret::{Interpret, InterpretError, InterpretName, InterpretStatus, Outcome},
    inventory::Inventory,
    topology::Topology,
 };

-#[derive(Clone, Debug)]
-pub enum ApplicationFeatureStatus {
-    Installing,
-    Installed,
-    Failed { details: String },
-}
-
 pub trait Application: std::fmt::Debug + Send + Sync {
    fn name(&self) -> String;
 }
@@ -55,34 +47,13 @@ impl<A: Application, T: Topology + std::fmt::Debug> Interpret<T> for Application
                .join(", ")
        );
        for feature in self.features.iter() {
-            instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
-                topology: topology.name().into(),
-                application: self.application.name(),
-                feature: feature.name(),
-                status: ApplicationFeatureStatus::Installing,
-            })
-            .unwrap();
-
+            debug!(
+                "Installing feature {} for application {app_name}",
+                feature.name()
+            );
            let _ = match feature.ensure_installed(topology).await {
-                Ok(()) => {
-                    instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
-                        topology: topology.name().into(),
-                        application: self.application.name(),
-                        feature: feature.name(),
-                        status: ApplicationFeatureStatus::Installed,
-                    })
-                    .unwrap();
-                }
+                Ok(()) => (),
                Err(msg) => {
-                    instrumentation::instrument(HarmonyEvent::ApplicationFeatureStateChanged {
-                        topology: topology.name().into(),
-                        application: self.application.name(),
-                        feature: feature.name(),
-                        status: ApplicationFeatureStatus::Failed {
-                            details: msg.clone(),
-                        },
-                    })
-                    .unwrap();
                    return Err(InterpretError::new(format!(
                        "Application Interpret failed to install feature : {msg}"
                    )));
--- a/harmony/src/modules/application/rust.rs
+++ b/harmony/src/modules/application/rust.rs
@@ -10,7 +10,7 @@ use dockerfile_builder::Dockerfile;
 use dockerfile_builder::instruction::{CMD, COPY, ENV, EXPOSE, FROM, RUN, USER, WORKDIR};
 use dockerfile_builder::instruction_builder::CopyBuilder;
 use futures_util::StreamExt;
-use log::{debug, info, log_enabled};
+use log::{debug, error, log_enabled};
 use serde::Serialize;
 use tar::Archive;

@@ -73,19 +73,19 @@ impl Application for RustWebapp {
 #[async_trait]
 impl HelmPackage for RustWebapp {
    async fn build_push_helm_package(&self, image_url: &str) -> Result<String, String> {
-        info!("Starting Helm chart build and push for '{}'", self.name);
+        debug!("Starting Helm chart build and push for '{}'", self.name);

        // 1. Create the Helm chart files on disk.
        let chart_dir = self
            .create_helm_chart_files(image_url)
            .map_err(|e| format!("Failed to create Helm chart files: {}", e))?;
-        info!("Successfully created Helm chart files in {:?}", chart_dir);
+        debug!("Successfully created Helm chart files in {:?}", chart_dir);

        // 2. Package the chart into a .tgz archive.
        let packaged_chart_path = self
            .package_helm_chart(&chart_dir)
            .map_err(|e| format!("Failed to package Helm chart: {}", e))?;
-        info!(
+        debug!(
            "Successfully packaged Helm chart: {}",
            packaged_chart_path.to_string_lossy()
        );
@@ -94,7 +94,7 @@ impl HelmPackage for RustWebapp {
        let oci_chart_url = self
            .push_helm_chart(&packaged_chart_path)
            .map_err(|e| format!("Failed to push Helm chart: {}", e))?;
-        info!("Successfully pushed Helm chart to: {}", oci_chart_url);
+        debug!("Successfully pushed Helm chart to: {}", oci_chart_url);

        Ok(oci_chart_url)
    }
@@ -107,20 +107,20 @@ impl OCICompliant for RustWebapp {
    async fn build_push_oci_image(&self) -> Result<String, String> {
        // This function orchestrates the build and push process.
        // It's async to match the trait definition, though the underlying docker commands are blocking.
-        info!("Starting OCI image build and push for '{}'", self.name);
+        debug!("Starting OCI image build and push for '{}'", self.name);

        // 1. Build the image by calling the synchronous helper function.
        let image_tag = self.image_name();
        self.build_docker_image(&image_tag)
            .await
            .map_err(|e| format!("Failed to build Docker image: {}", e))?;
-        info!("Successfully built Docker image: {}", image_tag);
+        debug!("Successfully built Docker image: {}", image_tag);

        // 2. Push the image to the registry.
        self.push_docker_image(&image_tag)
            .await
            .map_err(|e| format!("Failed to push Docker image: {}", e))?;
-        info!("Successfully pushed Docker image to: {}", image_tag);
+        debug!("Successfully pushed Docker image to: {}", image_tag);

        Ok(image_tag)
    }
@@ -195,7 +195,7 @@ impl RustWebapp {
        );

        while let Some(msg) = image_build_stream.next().await {
-            debug!("Message: {msg:?}");
+            println!("Message: {msg:?}");
        }

        Ok(image_name.to_string())
@@ -219,7 +219,7 @@ impl RustWebapp {
        );

        while let Some(msg) = push_image_stream.next().await {
-            debug!("Message: {msg:?}");
+            println!("Message: {msg:?}");
        }

        Ok(image_tag.to_string())
@@ -288,8 +288,9 @@ impl RustWebapp {
                        .unwrap(),
                );
                // Copy the compiled binary from the builder stage.
-                // TODO: Should not be using score name here, instead should use name from Cargo.toml
-                // https://git.nationtech.io/NationTech/harmony/issues/105
+                error!(
+                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                );
                let binary_path_in_builder = format!("/app/target/release/{}", self.name);
                let binary_path_in_final = format!("/home/appuser/{}", self.name);
                dockerfile.push(
@@ -327,8 +328,9 @@ impl RustWebapp {
                ));

                // Copy only the compiled binary from the builder stage.
-                // TODO: Should not be using score name here, instead should use name from Cargo.toml
-                // https://git.nationtech.io/NationTech/harmony/issues/105
+                error!(
+                    "FIXME Should not be using score name here, instead should use name from Cargo.toml"
+                );
                let binary_path_in_builder = format!("/app/target/release/{}", self.name);
                let binary_path_in_final = format!("/usr/local/bin/{}", self.name);
                dockerfile.push(
--- a/harmony/src/modules/k3d/install.rs
+++ b/harmony/src/modules/k3d/install.rs
@@ -29,7 +29,7 @@ impl Default for K3DInstallationScore {
 }

 impl<T: Topology> Score<T> for K3DInstallationScore {
-    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
+    fn create_interpret(&self) -> Box<dyn crate::interpret::Interpret<T>> {
        Box::new(K3dInstallationInterpret {
            score: self.clone(),
        })
--- a/harmony/src/modules/monitoring/ntfy/helm/ntfy_helm_chart.rs
+++ b/harmony/src/modules/monitoring/ntfy/helm/ntfy_helm_chart.rs
@@ -1,25 +1,9 @@
 use non_blank_string_rs::NonBlankString;
 use std::str::FromStr;

-use crate::{modules::helm::chart::HelmChartScore, topology::DeploymentTarget};
-
-pub fn ntfy_helm_chart_score(
-    namespace: String,
-    host: String,
-    target: DeploymentTarget,
-) -> HelmChartScore {
-    // TODO not actually the correct logic, this should be fixed by using an ingresss which is the
-    // correct k8s standard.
-    //
-    // Another option is to delegate to the topology the ingress technology it wants to use Route,
-    // Ingress or other
-    let route_enabled = match target {
-        DeploymentTarget::LocalDev => false,
-        DeploymentTarget::Staging => true,
-        DeploymentTarget::Production => true,
-    };
-    let ingress_enabled = !route_enabled;
+use crate::modules::helm::chart::{HelmChartScore, HelmRepository};

+pub fn ntfy_helm_chart_score(namespace: String, host: String) -> HelmChartScore {
    let values = format!(
        r#"
 replicaCount: 1
@@ -41,14 +25,23 @@ serviceAccount:

 service:
  type: ClusterIP
-  port: 8080
+  port: 80

 ingress:
-  enabled: {ingress_enabled}
+  enabled: true
+#  annotations:
+    # kubernetes.io/ingress.class: nginx
+    # kubernetes.io/tls-acme: "true"
+  hosts:
+    - host: {host}
+      paths:
+        - path: /
+          pathType: ImplementationSpecific
+  tls: []
+  #  - secretName: chart-example-tls
+  #    hosts:
+  #      - chart-example.local

-route:
-  enabled: {route_enabled}
-  host: {host}

 autoscaling:
  enabled: false
@@ -56,7 +49,7 @@ autoscaling:
 config:
  enabled: true
  data:
-    base-url: "https://{host}"
+#    base-url: "https://ntfy.something.com"
    auth-file: "/var/cache/ntfy/user.db"
    auth-default-access: "deny-all"
    cache-file: "/var/cache/ntfy/cache.db"
@@ -66,7 +59,6 @@ config:
    enable-signup: false
    enable-login: "true"
    enable-metrics: "true"
-    listen-http: ":8080"

 persistence:
  enabled: true
@@ -77,12 +69,16 @@ persistence:
    HelmChartScore {
        namespace: Some(NonBlankString::from_str(&namespace).unwrap()),
        release_name: NonBlankString::from_str("ntfy").unwrap(),
-        chart_name: NonBlankString::from_str("oci://hub.nationtech.io/harmony/ntfy").unwrap(),
-        chart_version: Some(NonBlankString::from_str("0.1.7-nationtech.1").unwrap()),
+        chart_name: NonBlankString::from_str("sarab97/ntfy").unwrap(),
+        chart_version: Some(NonBlankString::from_str("0.1.7").unwrap()),
        values_overrides: None,
        values_yaml: Some(values.to_string()),
        create_namespace: true,
        install_only: false,
-        repository: None,
+        repository: Some(HelmRepository::new(
+            "sarab97".to_string(),
+            url::Url::parse("https://charts.sarabsingh.com").unwrap(),
+            true,
+        )),
    }
 }
--- a/harmony/src/modules/monitoring/ntfy/ntfy.rs
+++ b/harmony/src/modules/monitoring/ntfy/ntfy.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;

 use async_trait::async_trait;
-use log::info;
+use log::debug;
 use serde::Serialize;
 use strum::{Display, EnumString};

@@ -11,7 +11,7 @@ use crate::{
    inventory::Inventory,
    modules::monitoring::ntfy::helm::ntfy_helm_chart::ntfy_helm_chart_score,
    score::Score,
-    topology::{HelmCommand, K8sclient, MultiTargetTopology, Topology, k8s::K8sClient},
+    topology::{HelmCommand, K8sclient, Topology, k8s::K8sClient},
 };

 #[derive(Debug, Clone, Serialize)]
@@ -20,7 +20,7 @@ pub struct NtfyScore {
    pub host: String,
 }

-impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Score<T> for NtfyScore {
+impl<T: Topology + HelmCommand + K8sclient> Score<T> for NtfyScore {
    fn create_interpret(&self) -> Box<dyn Interpret<T>> {
        Box::new(NtfyInterpret {
            score: self.clone(),
@@ -77,7 +77,7 @@ impl NtfyInterpret {
                vec![
                    "sh",
                    "-c",
-                    format!("NTFY_PASSWORD={password} ntfy user add --role={role} --ignore-exists {username}")
+                    format!("NTFY_PASSWORD={password} ntfy user add --role={role} {username}")
                        .as_str(),
                ],
            )
@@ -89,27 +89,22 @@ impl NtfyInterpret {

 /// We need a ntfy interpret to wrap the HelmChartScore in order to run the score, and then bootstrap the config inside ntfy
 #[async_trait]
-impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Interpret<T> for NtfyInterpret {
+impl<T: Topology + HelmCommand + K8sclient> Interpret<T> for NtfyInterpret {
    async fn execute(
        &self,
        inventory: &Inventory,
        topology: &T,
    ) -> Result<Outcome, InterpretError> {
-        ntfy_helm_chart_score(
-            self.score.namespace.clone(),
-            self.score.host.clone(),
-            topology.current_target(),
-        )
-        .interpret(inventory, topology)
-        .await?;
+        ntfy_helm_chart_score(self.score.namespace.clone(), self.score.host.clone())
+            .interpret(inventory, topology)
+            .await?;

-        info!("installed ntfy helm chart");
+        debug!("installed ntfy helm chart");
        let client = topology
            .k8s_client()
            .await
            .expect("couldn't get k8s client");

-        info!("deploying ntfy...");
        client
            .wait_until_deployment_ready(
                "ntfy".to_string(),
@@ -117,12 +112,12 @@ impl<T: Topology + HelmCommand + K8sclient + MultiTargetTopology> Interpret<T> f
                None,
            )
            .await?;
-        info!("ntfy deployed");
+        debug!("created k8s client");

-        info!("adding user harmony");
        self.add_user(client, "harmony", "harmony", Some(NtfyRole::Admin))
            .await?;
-        info!("user added");
+
+        debug!("exec into pod done");

        Ok(Outcome::success("Ntfy installed".to_string()))
    }
--- a/harmony/src/modules/prometheus/k8s_prometheus_alerting_score.rs
+++ b/harmony/src/modules/prometheus/k8s_prometheus_alerting_score.rs
@@ -166,8 +166,7 @@ impl K8sPrometheusCRDAlertingInterpret {

        let install_output = Command::new("helm")
            .args([
-                "upgrade",
-                "--install",
+                "install",
                &chart_name,
                tgz_path.to_str().unwrap(),
                "--namespace",
--- a/harmony_cli/Cargo.toml
+++ b/harmony_cli/Cargo.toml
@@ -5,10 +5,6 @@ version.workspace = true
 readme.workspace = true
 license.workspace = true

-[features]
-default = ["tui"]
-tui = ["dep:harmony_tui"]
-
 [dependencies]
 assert_cmd = "2.0.17"
 clap = { version = "4.5.35", features = ["derive"] }
@@ -22,7 +18,8 @@ indicatif = "0.18.0"
 lazy_static = "1.5.0"
 log.workspace = true
 indicatif-log-bridge = "0.2.3"
-chrono.workspace = true

-[dev-dependencies]
-harmony = { path = "../harmony", features = ["testing"] }
+
+[features]
+default = ["tui"]
+tui = ["dep:harmony_tui"]
--- a/harmony_cli/src/cli_logger.rs
+++ b/harmony_cli/src/cli_logger.rs
@@ -1,17 +1,16 @@
-use chrono::Local;
-use console::style;
 use harmony::{
    instrumentation::{self, HarmonyEvent},
-    modules::application::ApplicationFeatureStatus,
    topology::TopologyStatus,
 };
-use log::{error, info, log_enabled};
-use std::io::Write;
+use indicatif::MultiProgress;
+use indicatif_log_bridge::LogWrapper;
 use std::sync::{Arc, Mutex};

+use crate::progress::{IndicatifProgressTracker, ProgressTracker};
+
 pub fn init() -> tokio::task::JoinHandle<()> {
-    configure_logger();
-    let handle = tokio::spawn(handle_events());
+    let base_progress = configure_logger();
+    let handle = tokio::spawn(handle_events(base_progress));

    loop {
        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
@@ -22,76 +21,28 @@ pub fn init() -> tokio::task::JoinHandle<()> {
    handle
 }

-fn configure_logger() {
-    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
-        .format(|buf, record| {
-            let debug_mode = log_enabled!(log::Level::Debug);
-            let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S");
+fn configure_logger() -> MultiProgress {
+    let logger =
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
+    let level = logger.filter();
+    let progress = MultiProgress::new();

-            let level = match record.level() {
-                log::Level::Error => style("ERROR").red(),
-                log::Level::Warn => style("WARN").yellow(),
-                log::Level::Info => style("INFO").green(),
-                log::Level::Debug => style("DEBUG").blue(),
-                log::Level::Trace => style("TRACE").magenta(),
-            };
-            if let Some(status) = record.key_values().get(log::kv::Key::from("status")) {
-                let status = status.to_borrowed_str().unwrap();
-                let emoji = match status {
-                    "finished" => style(crate::theme::EMOJI_SUCCESS.to_string()).green(),
-                    "skipped" => style(crate::theme::EMOJI_SKIP.to_string()).yellow(),
-                    "failed" => style(crate::theme::EMOJI_ERROR.to_string()).red(),
-                    _ => style("".into()),
-                };
-                if debug_mode {
-                    writeln!(
-                        buf,
-                        "[{} {:<5} {}] {} {}",
-                        timestamp,
-                        level,
-                        record.target(),
-                        emoji,
-                        record.args()
-                    )
-                } else {
-                    writeln!(buf, "[{:<5}] {} {}", level, emoji, record.args())
-                }
-            } else if let Some(emoji) = record.key_values().get(log::kv::Key::from("emoji")) {
-                if debug_mode {
-                    writeln!(
-                        buf,
-                        "[{} {:<5} {}] {} {}",
-                        timestamp,
-                        level,
-                        record.target(),
-                        emoji,
-                        record.args()
-                    )
-                } else {
-                    writeln!(buf, "[{:<5}] {} {}", level, emoji, record.args())
-                }
-            } else if debug_mode {
-                writeln!(
-                    buf,
-                    "[{} {:<5} {}] {}",
-                    timestamp,
-                    level,
-                    record.target(),
-                    record.args()
-                )
-            } else {
-                writeln!(buf, "[{:<5}] {}", level, record.args())
-            }
-        })
-        .init();
+    LogWrapper::new(progress.clone(), logger)
+        .try_init()
+        .unwrap();
+    log::set_max_level(level);
+
+    progress
 }

-async fn handle_events() {
+async fn handle_events(base_progress: MultiProgress) {
+    let progress_tracker = Arc::new(IndicatifProgressTracker::new(base_progress.clone()));
    let preparing_topology = Arc::new(Mutex::new(false));
    let current_score: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));

    instrumentation::subscribe("Harmony CLI Logger", {
        move |event| {
+            let progress_tracker = Arc::clone(&progress_tracker);
            let preparing_topology = Arc::clone(&preparing_topology);
            let current_score = Arc::clone(&current_score);

@@ -102,57 +53,89 @@ async fn handle_events() {
                match event {
                    HarmonyEvent::HarmonyStarted => {}
                    HarmonyEvent::HarmonyFinished => {
-                        let emoji = crate::theme::EMOJI_HARMONY.to_string();
-                        info!(emoji = emoji.as_str(); "Harmony completed");
+                        progress_tracker.add_section(
+                            "harmony-summary",
+                            &format!("\n{} Harmony completed\n\n", crate::theme::EMOJI_HARMONY),
+                        );
+                        progress_tracker.add_section("harmony-finished", "\n\n");
                        return false;
                    }
                    HarmonyEvent::TopologyStateChanged {
                        topology,
                        status,
                        message,
-                    } => match status {
-                        TopologyStatus::Queued => {}
-                        TopologyStatus::Preparing => {
-                            let emoji = format!("{}", style(crate::theme::EMOJI_TOPOLOGY.to_string()).yellow());
-                            info!(emoji = emoji.as_str(); "Preparing environment: {topology}...");
-                            (*preparing_topology) = true;
-                        }
-                        TopologyStatus::Success => {
-                            (*preparing_topology) = false;
-                            if let Some(message) = message {
-                                info!(status = "finished"; "{message}");
+                    } => {
+                        let section_key = topology_key(&topology);
+
+                        match status {
+                            TopologyStatus::Queued => {}
+                            TopologyStatus::Preparing => {
+                                progress_tracker.add_section(
+                                    &section_key,
+                                    &format!(
+                                        "\n{} Preparing environment: {topology}...",
+                                        crate::theme::EMOJI_TOPOLOGY
+                                    ),
+                                );
+                                (*preparing_topology) = true;
+                            }
+                            TopologyStatus::Success => {
+                                (*preparing_topology) = false;
+                                progress_tracker.add_task(&section_key, "topology-success", "");
+                                progress_tracker
+                                    .finish_task("topology-success", &message.unwrap_or("".into()));
+                            }
+                            TopologyStatus::Noop => {
+                                (*preparing_topology) = false;
+                                progress_tracker.add_task(&section_key, "topology-skip", "");
+                                progress_tracker
+                                    .skip_task("topology-skip", &message.unwrap_or("".into()));
+                            }
+                            TopologyStatus::Error => {
+                                progress_tracker.add_task(&section_key, "topology-error", "");
+                                (*preparing_topology) = false;
+                                progress_tracker
+                                    .fail_task("topology-error", &message.unwrap_or("".into()));
                            }
                        }
-                        TopologyStatus::Noop => {
-                            (*preparing_topology) = false;
-                            if let Some(message) = message {
-                                info!(status = "skipped"; "{message}");
-                            }
-                        }
-                        TopologyStatus::Error => {
-                            (*preparing_topology) = false;
-                            if let Some(message) = message {
-                                error!(status = "failed"; "{message}");
-                            }
-                        }
-                    },
+                    }
                    HarmonyEvent::InterpretExecutionStarted {
-                        execution_id: _,
-                        topology: _,
+                        execution_id: task_key,
+                        topology,
                        interpret: _,
                        score,
                        message,
                    } => {
-                        if *preparing_topology || current_score.is_some() {
-                            info!("{message}");
+                        let is_key_topology = (*preparing_topology)
+                            && progress_tracker.contains_section(&topology_key(&topology));
+                        let is_key_current_score = current_score.is_some()
+                            && progress_tracker
+                                .contains_section(&score_key(&current_score.clone().unwrap()));
+                        let is_key_score = progress_tracker.contains_section(&score_key(&score));
+
+                        let section_key = if is_key_topology {
+                            topology_key(&topology)
+                        } else if is_key_current_score {
+                            score_key(&current_score.clone().unwrap())
+                        } else if is_key_score {
+                            score_key(&score)
                        } else {
                            (*current_score) = Some(score.clone());
-                            let emoji = format!("{}", style(crate::theme::EMOJI_SCORE).blue());
-                            info!(emoji = emoji.as_str(); "Interpreting score: {score}...");
-                        }
+                            let key = score_key(&score);
+                            progress_tracker.add_section(
+                                &key,
+                                &format!(
+                                    "{} Interpreting score: {score}...",
+                                    crate::theme::EMOJI_SCORE
+                                ),
+                            );
+                            key
+                        };
+
+                        progress_tracker.add_task(&section_key, &task_key, &message);
                    }
                    HarmonyEvent::InterpretExecutionFinished {
-                        execution_id: _,
+                        execution_id: task_key,
                        topology: _,
                        interpret: _,
                        score,
@@ -165,36 +148,18 @@ async fn handle_events() {
                        match outcome {
                            Ok(outcome) => match outcome.status {
                                harmony::interpret::InterpretStatus::SUCCESS => {
-                                    info!(status = "finished"; "{}", outcome.message);
+                                    progress_tracker.finish_task(&task_key, &outcome.message);
                                }
                                harmony::interpret::InterpretStatus::NOOP => {
-                                    info!(status = "skipped"; "{}", outcome.message);
-                                }
-                                _ => {
-                                    error!(status = "failed"; "{}", outcome.message);
+                                    progress_tracker.skip_task(&task_key, &outcome.message);
                                }
+                                _ => progress_tracker.fail_task(&task_key, &outcome.message),
                            },
                            Err(err) => {
-                                error!(status = "failed"; "{}", err);
+                                progress_tracker.fail_task(&task_key, &err.to_string());
                            }
                        }
                    }
-                    HarmonyEvent::ApplicationFeatureStateChanged {
-                        topology: _,
-                        application,
-                        feature,
-                        status,
-                    } => match status {
-                        ApplicationFeatureStatus::Installing => {
-                            info!("Installing feature '{}' for '{}'...", feature, application);
-                        }
-                        ApplicationFeatureStatus::Installed => {
-                            info!(status = "finished"; "Feature '{}' installed", feature);
-                        }
-                        ApplicationFeatureStatus::Failed { details } => {
-                            error!(status = "failed"; "Feature '{}' installation failed: {}", feature, details);
-                        }
-                    },
                }
                true
            }
@@ -202,3 +167,11 @@ async fn handle_events() {
    })
    .await;
 }
+
+fn topology_key(topology: &str) -> String {
+    format!("topology-{topology}")
+}
+
+fn score_key(score: &str) -> String {
+    format!("score-{score}")
+}
--- a/harmony_cli/src/lib.rs
+++ b/harmony_cli/src/lib.rs
@@ -90,37 +90,13 @@ pub async fn run<T: Topology + Send + Sync + 'static>(
    topology: T,
    scores: Vec<Box<dyn Score<T>>>,
    args_struct: Option<Args>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let args = match args_struct {
-        Some(args) => args,
-        None => Args::parse(),
-    };
-
-    #[cfg(not(feature = "tui"))]
-    if args.interactive {
-        return Err("Not compiled with interactive support".into());
-    }
-
-    #[cfg(feature = "tui")]
-    if args.interactive {
-        return harmony_tui::run(inventory, topology, scores).await;
-    }
-
-    run_cli(inventory, topology, scores, args).await
-}
-
-pub async fn run_cli<T: Topology + Send + Sync + 'static>(
-    inventory: Inventory,
-    topology: T,
-    scores: Vec<Box<dyn Score<T>>>,
-    args: Args,
 ) -> Result<(), Box<dyn std::error::Error>> {
    let cli_logger_handle = cli_logger::init();

    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
    maestro.register_all(scores);

-    let result = init(maestro, args).await;
+    let result = init(maestro, args_struct).await;

    instrumentation::instrument(instrumentation::HarmonyEvent::HarmonyFinished).unwrap();
    let _ = tokio::try_join!(cli_logger_handle);
@@ -129,8 +105,23 @@ pub async fn run_cli<T: Topology + Send + Sync + 'static>(

 async fn init<T: Topology + Send + Sync + 'static>(
    maestro: harmony::maestro::Maestro<T>,
-    args: Args,
+    args_struct: Option<Args>,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    let args = match args_struct {
+        Some(args) => args,
+        None => Args::parse(),
+    };
+
+    #[cfg(feature = "tui")]
+    if args.interactive {
+        return harmony_tui::init(maestro).await;
+    }
+
+    #[cfg(not(feature = "tui"))]
+    if args.interactive {
+        return Err("Not compiled with interactive support".into());
+    }
+
    let _ = env_logger::builder().try_init();

    let scores_vec = maestro_scores_filter(&maestro, args.all, args.filter, args.number);
@@ -141,9 +132,8 @@ async fn init<T: Topology + Send + Sync + 'static>(

    // if list option is specified, print filtered list and exit
    if args.list {
-        let num_scores = scores_vec.len();
-        println!("Available scores {num_scores}:");
-        println!("{}\n\n", list_scores_with_index(&scores_vec));
+        println!("Available scores:");
+        println!("{}", list_scores_with_index(&scores_vec));
        return Ok(());
    }

@@ -175,7 +165,7 @@ async fn init<T: Topology + Send + Sync + 'static>(
 }

 #[cfg(test)]
-mod tests {
+mod test {
    use harmony::{
        inventory::Inventory,
        maestro::Maestro,
@@ -202,14 +192,14 @@ mod tests {
        let maestro = init_test_maestro();
        let res = crate::init(
            maestro,
-            crate::Args {
+            Some(crate::Args {
                yes: true,
                filter: Some("SuccessScore".to_owned()),
                interactive: false,
                all: true,
                number: 0,
                list: false,
-            },
+            }),
        )
        .await;

@@ -222,14 +212,14 @@ mod tests {

        let res = crate::init(
            maestro,
-            crate::Args {
+            Some(crate::Args {
                yes: true,
                filter: Some("ErrorScore".to_owned()),
                interactive: false,
                all: true,
                number: 0,
                list: false,
-            },
+            }),
        )
        .await;

@@ -242,14 +232,14 @@ mod tests {

        let res = crate::init(
            maestro,
-            crate::Args {
+            Some(crate::Args {
                yes: true,
                filter: None,
                interactive: false,
                all: false,
                number: 0,
                list: false,
-            },
+            }),
        )
        .await;

--- a/harmony_cli/src/progress.rs
+++ b/harmony_cli/src/progress.rs
@@ -33,13 +33,29 @@ pub struct IndicatifProgressTracker {

 impl IndicatifProgressTracker {
    pub fn new(base: MultiProgress) -> Self {
-        let sections = HashMap::new();
-        let tasks = HashMap::new();
+        // The indicatif log bridge will insert a progress bar at the top.
+        // To prevent our first section from being erased, we need to create
+        // a dummy progress bar as our first progress bar.
+        let _ = base.clear();
+        let log_pb = base.add(ProgressBar::new(1));
+
+        let mut sections = HashMap::new();
+        sections.insert(
+            "__log__".into(),
+            Section {
+                header_index: 0,
+                task_count: 0,
+                pb: log_pb.clone(),
+            },
+        );
+
+        let mut tasks = HashMap::new();
+        tasks.insert("__log__".into(), log_pb);

        let state = Arc::new(Mutex::new(IndicatifProgressTrackerState {
            sections,
            tasks,
-            pb_count: 0,
+            pb_count: 1,
        }));

        Self { mp: base, state }
--- a/harmony_cli/src/theme.rs
+++ b/harmony_cli/src/theme.rs
@@ -21,14 +21,10 @@ lazy_static! {
    pub static ref SUCCESS_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
        .clone()
        .tick_strings(&[format!("{}", EMOJI_SUCCESS).as_str()]);
-    pub static ref SKIP_SPINNER_STYLE: ProgressStyle = ProgressStyle::default_spinner()
-        .template("    {spinner:.orange} {wide_msg}")
-        .unwrap()
+    pub static ref SKIP_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
        .clone()
        .tick_strings(&[format!("{}", EMOJI_SKIP).as_str()]);
-    pub static ref ERROR_SPINNER_STYLE: ProgressStyle = ProgressStyle::default_spinner()
-        .template("    {spinner:.red} {wide_msg}")
-        .unwrap()
+    pub static ref ERROR_SPINNER_STYLE: ProgressStyle = SPINNER_STYLE
        .clone()
        .tick_strings(&[format!("{}", EMOJI_ERROR).as_str()]);
 }
--- a/harmony_composer/src/harmony_composer_logger.rs
+++ b/harmony_composer/src/harmony_composer_logger.rs
@@ -1,5 +1,6 @@
 use harmony_cli::progress::{IndicatifProgressTracker, ProgressTracker};
 use indicatif::MultiProgress;
+use log::error;
 use std::sync::Arc;

 use crate::instrumentation::{self, HarmonyComposerEvent};
@@ -52,13 +53,15 @@ pub async fn handle_events() {
                        progress_tracker.finish_task(COMPILTATION_TASK, "project compiled");
                    }
                    HarmonyComposerEvent::ProjectCompilationFailed { details } => {
-                        progress_tracker.fail_task(COMPILTATION_TASK, &format!("failed to compile project:\n{details}"));
+                        progress_tracker.fail_task(COMPILTATION_TASK, "failed to compile project");
+
+                        error!("{details}");
                    }
-                    HarmonyComposerEvent::DeploymentStarted { target, profile } => {
+                    HarmonyComposerEvent::DeploymentStarted { target } => {
                        progress_tracker.add_section(
                            PROGRESS_DEPLOYMENT,
                            &format!(
-                                "\n{} Deploying project on target '{target}' with profile '{profile}'...\n",
+                                "\n{} Deploying project to {target}...\n",
                                harmony_cli::theme::EMOJI_DEPLOY,
                            ),
                        );
@@ -66,10 +69,6 @@ pub async fn handle_events() {
                    HarmonyComposerEvent::DeploymentCompleted => {
                        progress_tracker.clear();
                    }
-                    HarmonyComposerEvent::DeploymentFailed { details } => {
-                        progress_tracker.add_task(PROGRESS_DEPLOYMENT, "deployment-failed", "");
-                        progress_tracker.fail_task("deployment-failed", &details);
-                    },
                    HarmonyComposerEvent::Shutdown => {
                        return false;
                    }
--- a/harmony_composer/src/instrumentation.rs
+++ b/harmony_composer/src/instrumentation.rs
@@ -2,28 +2,16 @@ use log::debug;
 use once_cell::sync::Lazy;
 use tokio::sync::broadcast;

-use crate::{HarmonyProfile, HarmonyTarget};
-
 #[derive(Debug, Clone)]
 pub enum HarmonyComposerEvent {
    HarmonyComposerStarted,
    ProjectInitializationStarted,
    ProjectInitialized,
-    ProjectCompilationStarted {
-        details: String,
-    },
+    ProjectCompilationStarted { details: String },
    ProjectCompiled,
-    ProjectCompilationFailed {
-        details: String,
-    },
-    DeploymentStarted {
-        target: HarmonyTarget,
-        profile: HarmonyProfile,
-    },
+    ProjectCompilationFailed { details: String },
+    DeploymentStarted { target: String },
    DeploymentCompleted,
-    DeploymentFailed {
-        details: String,
-    },
    Shutdown,
 }

@@ -35,18 +23,9 @@ static HARMONY_COMPOSER_EVENT_BUS: Lazy<broadcast::Sender<HarmonyComposerEvent>>
    });

 pub fn instrument(event: HarmonyComposerEvent) -> Result<(), &'static str> {
-    #[cfg(not(test))]
-    {
-        match HARMONY_COMPOSER_EVENT_BUS.send(event) {
-            Ok(_) => Ok(()),
-            Err(_) => Err("send error: no subscribers"),
-        }
-    }
-
-    #[cfg(test)]
-    {
-        let _ = event; // Suppress the "unused variable" warning for `event`
-        Ok(())
+    match HARMONY_COMPOSER_EVENT_BUS.send(event) {
+        Ok(_) => Ok(()),
+        Err(_) => Err("send error: no subscribers"),
    }
 }

--- a/harmony_composer/src/main.rs
+++ b/harmony_composer/src/main.rs
@@ -49,11 +49,14 @@ struct CheckArgs {

 #[derive(Args, Clone, Debug)]
 struct DeployArgs {
-    #[arg(long = "target", short = 't', default_value = "local")]
-    harmony_target: HarmonyTarget,
+    #[arg(long, default_value_t = false)]
+    staging: bool,

-    #[arg(long = "profile", short = 'p', default_value = "dev")]
-    harmony_profile: HarmonyProfile,
+    #[arg(long, default_value_t = false)]
+    prod: bool,
+
+    #[arg(long, default_value_t = false)]
+    smoke_test: bool,
 }

 #[derive(Args, Clone, Debug)]
@@ -65,38 +68,6 @@ struct AllArgs {
    deploy: DeployArgs,
 }

-#[derive(Clone, Debug, clap::ValueEnum)]
-enum HarmonyTarget {
-    Local,
-    Remote,
-}
-
-impl std::fmt::Display for HarmonyTarget {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            HarmonyTarget::Local => f.write_str("local"),
-            HarmonyTarget::Remote => f.write_str("remote"),
-        }
-    }
-}
-
-#[derive(Clone, Debug, clap::ValueEnum)]
-enum HarmonyProfile {
-    Dev,
-    Staging,
-    Production,
-}
-
-impl std::fmt::Display for HarmonyProfile {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            HarmonyProfile::Dev => f.write_str("dev"),
-            HarmonyProfile::Staging => f.write_str("staging"),
-            HarmonyProfile::Production => f.write_str("production"),
-        }
-    }
-}
-
 #[tokio::main]
 async fn main() {
    let hc_logger_handle = harmony_composer_logger::init();
@@ -151,39 +122,26 @@ async fn main() {
                );
            }
            Commands::Deploy(args) => {
-                instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
-                    target: args.harmony_target.clone(),
-                    profile: args.harmony_profile.clone(),
-                })
-                .unwrap();
-
-                if matches!(args.harmony_profile, HarmonyProfile::Dev)
-                    && !matches!(args.harmony_target, HarmonyTarget::Local)
-                {
-                    instrumentation::instrument(HarmonyComposerEvent::DeploymentFailed {
-                        details: format!(
-                            "Cannot run profile '{}' on target '{}'. Profile '{}' can run locally only.",
-                            args.harmony_profile, args.harmony_target, args.harmony_profile
-                        ),
-                    }).unwrap();
-                    return;
+                let deploy = if args.staging {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "staging".to_string(),
+                    })
+                    .unwrap();
+                    todo!("implement staging deployment")
+                } else if args.prod {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "prod".to_string(),
+                    })
+                    .unwrap();
+                    todo!("implement prod deployment")
+                } else {
+                    instrumentation::instrument(HarmonyComposerEvent::DeploymentStarted {
+                        target: "dev".to_string(),
+                    })
+                    .unwrap();
+                    Command::new(harmony_bin_path).arg("-y").arg("-a").spawn()
                }
-
-                let use_local_k3d = match args.harmony_target {
-                    HarmonyTarget::Local => true,
-                    HarmonyTarget::Remote => false,
-                };
-
-                let mut command = Command::new(harmony_bin_path);
-                command
-                    .env("HARMONY_USE_LOCAL_K3D", format!("{use_local_k3d}"))
-                    .env("HARMONY_PROFILE", format!("{}", args.harmony_profile))
-                    .arg("-y")
-                    .arg("-a");
-
-                info!("{:?}", command);
-
-                let deploy = command.spawn().expect("failed to run harmony deploy");
+                .expect("failed to run harmony deploy");

                let deploy_output = deploy.wait_with_output().unwrap();
                debug!("{}", String::from_utf8(deploy_output.stdout).unwrap());
--- a/harmony_inventory_agent/Cargo.toml
+++ b/harmony_inventory_agent/Cargo.toml
@@ -1,13 +0,0 @@
-[package]
-name = "harmony_inventory_agent"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-actix-web = "4.4"
-sysinfo = "0.30"
-serde.workspace = true
-serde_json.workspace = true
-log.workspace = true
-env_logger.workspace = true
-uuid.workspace = true
--- a/harmony_inventory_agent/src/hwinfo.rs
+++ b/harmony_inventory_agent/src/hwinfo.rs
@@ -1,571 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::fs;
-use std::path::Path;
-use std::process::Command;
-use sysinfo::System;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PhysicalHost {
-    pub storage_drives: Vec<StorageDrive>,
-    pub storage_controller: StorageController,
-    pub memory_modules: Vec<MemoryModule>,
-    pub cpus: Vec<CPU>,
-    pub chipset: Chipset,
-    pub network_interfaces: Vec<NetworkInterface>,
-    pub management_interface: Option<ManagementInterface>,
-    pub host_uuid: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StorageDrive {
-    pub name: String,
-    pub model: String,
-    pub serial: String,
-    pub size_bytes: u64,
-    pub logical_block_size: u32,
-    pub physical_block_size: u32,
-    pub rotational: bool,
-    pub wwn: Option<String>,
-    pub interface_type: String,
-    pub smart_status: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StorageController {
-    pub name: String,
-    pub driver: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct MemoryModule {
-    pub size_bytes: u64,
-    pub speed_mhz: Option<u32>,
-    pub manufacturer: Option<String>,
-    pub part_number: Option<String>,
-    pub serial_number: Option<String>,
-    pub rank: Option<u8>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct CPU {
-    pub model: String,
-    pub vendor: String,
-    pub cores: u32,
-    pub threads: u32,
-    pub frequency_mhz: u64,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Chipset {
-    pub name: String,
-    pub vendor: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct NetworkInterface {
-    pub name: String,
-    pub mac_address: String,
-    pub speed_mbps: Option<u32>,
-    pub is_up: bool,
-    pub mtu: u32,
-    pub ipv4_addresses: Vec<String>,
-    pub ipv6_addresses: Vec<String>,
-    pub driver: String,
-    pub firmware_version: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ManagementInterface {
-    pub kind: String,
-    pub address: Option<String>,
-    pub firmware: Option<String>,
-}
-
-impl PhysicalHost {
-    pub fn gather() -> Self {
-        let mut sys = System::new_all();
-        sys.refresh_all();
-
-        Self {
-            storage_drives: Self::gather_storage_drives(),
-            storage_controller: Self::gather_storage_controller(),
-            memory_modules: Self::gather_memory_modules(),
-            cpus: Self::gather_cpus(&sys),
-            chipset: Self::gather_chipset(),
-            network_interfaces: Self::gather_network_interfaces(),
-            management_interface: Self::gather_management_interface(),
-            host_uuid: Self::get_host_uuid(),
-        }
-    }
-
-    fn gather_storage_drives() -> Vec<StorageDrive> {
-        let mut drives = Vec::new();
-
-        // Use lsblk with JSON output for robust parsing
-        if let Ok(output) = Command::new("lsblk")
-            .args([
-                "-d",
-                "-o",
-                "NAME,MODEL,SERIAL,SIZE,ROTA,WWN",
-                "-n",
-                "-e",
-                "7",
-                "--json",
-            ])
-            .output()
-            && output.status.success()
-            && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
-            && let Some(blockdevices) = json.get("blockdevices").and_then(|v| v.as_array())
-        {
-            for device in blockdevices {
-                let name = device
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-                if name.is_empty() {
-                    continue;
-                }
-
-                let model = device
-                    .get("model")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.trim().to_string())
-                    .unwrap_or_default();
-
-                let serial = device
-                    .get("serial")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.trim().to_string())
-                    .unwrap_or_default();
-
-                let size_str = device.get("size").and_then(|v| v.as_str()).unwrap_or("0");
-                let size_bytes = Self::parse_size(size_str).unwrap_or(0);
-
-                let rotational = device
-                    .get("rota")
-                    .and_then(|v| v.as_bool())
-                    .unwrap_or(false);
-
-                let wwn = device
-                    .get("wwn")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.trim().to_string())
-                    .filter(|s| !s.is_empty() && s != "null");
-
-                let device_path = Path::new("/sys/block").join(&name);
-
-                let mut drive = StorageDrive {
-                    name: name.clone(),
-                    model,
-                    serial,
-                    size_bytes,
-                    logical_block_size: Self::read_sysfs_u32(
-                        &device_path.join("queue/logical_block_size"),
-                    )
-                    .unwrap_or(512),
-                    physical_block_size: Self::read_sysfs_u32(
-                        &device_path.join("queue/physical_block_size"),
-                    )
-                    .unwrap_or(512),
-                    rotational,
-                    wwn,
-                    interface_type: Self::get_interface_type(&name, &device_path),
-                    smart_status: Self::get_smart_status(&name),
-                };
-
-                // Enhance with additional sysfs info if available
-                if device_path.exists() {
-                    if drive.model.is_empty() {
-                        drive.model = Self::read_sysfs_string(&device_path.join("device/model"));
-                    }
-                    if drive.serial.is_empty() {
-                        drive.serial = Self::read_sysfs_string(&device_path.join("device/serial"));
-                    }
-                }
-
-                drives.push(drive);
-            }
-        }
-
-        drives
-    }
-
-    fn gather_storage_controller() -> StorageController {
-        let mut controller = StorageController {
-            name: "Unknown".to_string(),
-            driver: "Unknown".to_string(),
-        };
-
-        // Use lspci with JSON output if available
-        if let Ok(output) = Command::new("lspci")
-            .args(["-nn", "-d", "::0100", "-J"]) // Storage controllers class with JSON
-            .output()
-            && output.status.success()
-            && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
-            && let Some(devices) = json.as_array()
-        {
-            for device in devices {
-                if let Some(device_info) = device.as_object()
-                    && let Some(name) = device_info
-                        .get("device")
-                        .and_then(|v| v.as_object())
-                        .and_then(|v| v.get("name"))
-                        .and_then(|v| v.as_str())
-                {
-                    controller.name = name.to_string();
-                    break;
-                }
-            }
-        }
-
-        // Fallback to text output if JSON fails
-        if controller.name == "Unknown"
-            && let Ok(output) = Command::new("lspci")
-                .args(["-nn", "-d", "::0100"]) // Storage controllers class
-                .output()
-            && output.status.success()
-        {
-            let output_str = String::from_utf8_lossy(&output.stdout);
-            if let Some(line) = output_str.lines().next() {
-                let parts: Vec<&str> = line.split(':').collect();
-                if parts.len() > 2 {
-                    controller.name = parts[2].trim().to_string();
-                }
-            }
-        }
-
-        // Try to get driver info from lsmod
-        if let Ok(output) = Command::new("lsmod").output()
-            && output.status.success()
-        {
-            let output_str = String::from_utf8_lossy(&output.stdout);
-            for line in output_str.lines() {
-                if line.contains("ahci")
-                    || line.contains("nvme")
-                    || line.contains("megaraid")
-                    || line.contains("mpt3sas")
-                {
-                    let parts: Vec<&str> = line.split_whitespace().collect();
-                    if !parts.is_empty() {
-                        controller.driver = parts[0].to_string();
-                        break;
-                    }
-                }
-            }
-        }
-
-        controller
-    }
-
-    fn gather_memory_modules() -> Vec<MemoryModule> {
-        let mut modules = Vec::new();
-
-        if let Ok(output) = Command::new("dmidecode").arg("--type").arg("17").output()
-            && output.status.success()
-        {
-            let output_str = String::from_utf8_lossy(&output.stdout);
-            let sections: Vec<&str> = output_str.split("Memory Device").collect();
-
-            for section in sections.into_iter().skip(1) {
-                let mut module = MemoryModule {
-                    size_bytes: 0,
-                    speed_mhz: None,
-                    manufacturer: None,
-                    part_number: None,
-                    serial_number: None,
-                    rank: None,
-                };
-
-                for line in section.lines() {
-                    let line = line.trim();
-                    if let Some(size_str) = line.strip_prefix("Size: ") {
-                        if size_str != "No Module Installed"
-                            && let Some((num, unit)) = size_str.split_once(' ')
-                            && let Ok(num) = num.parse::<u64>()
-                        {
-                            module.size_bytes = match unit {
-                                "MB" => num * 1024 * 1024,
-                                "GB" => num * 1024 * 1024 * 1024,
-                                "KB" => num * 1024,
-                                _ => 0,
-                            };
-                        }
-                    } else if let Some(speed_str) = line.strip_prefix("Speed: ") {
-                        if let Some((num, _unit)) = speed_str.split_once(' ') {
-                            module.speed_mhz = num.parse().ok();
-                        }
-                    } else if let Some(man) = line.strip_prefix("Manufacturer: ") {
-                        module.manufacturer = Some(man.to_string());
-                    } else if let Some(part) = line.strip_prefix("Part Number: ") {
-                        module.part_number = Some(part.to_string());
-                    } else if let Some(serial) = line.strip_prefix("Serial Number: ") {
-                        module.serial_number = Some(serial.to_string());
-                    } else if let Some(rank) = line.strip_prefix("Rank: ") {
-                        module.rank = rank.parse().ok();
-                    }
-                }
-
-                if module.size_bytes > 0 {
-                    modules.push(module);
-                }
-            }
-        }
-
-        modules
-    }
-
-    fn gather_cpus(sys: &System) -> Vec<CPU> {
-        let mut cpus = Vec::new();
-        let global_cpu = sys.global_cpu_info();
-
-        cpus.push(CPU {
-            model: global_cpu.brand().to_string(),
-            vendor: global_cpu.vendor_id().to_string(),
-            cores: sys.physical_core_count().unwrap_or(1) as u32,
-            threads: sys.cpus().len() as u32,
-            frequency_mhz: global_cpu.frequency(),
-        });
-
-        cpus
-    }
-
-    fn gather_chipset() -> Chipset {
-        Chipset {
-            name: Self::read_dmi("board-product-name").unwrap_or_else(|| "Unknown".to_string()),
-            vendor: Self::read_dmi("board-manufacturer").unwrap_or_else(|| "Unknown".to_string()),
-        }
-    }
-
-    fn gather_network_interfaces() -> Vec<NetworkInterface> {
-        let mut interfaces = Vec::new();
-        let sys_net_path = Path::new("/sys/class/net");
-
-        if let Ok(entries) = fs::read_dir(sys_net_path) {
-            for entry in entries.flatten() {
-                let iface_name = entry.file_name().into_string().unwrap_or_default();
-                let iface_path = entry.path();
-
-                // Skip virtual interfaces
-                if iface_name.starts_with("lo")
-                    || iface_name.starts_with("docker")
-                    || iface_name.starts_with("virbr")
-                    || iface_name.starts_with("veth")
-                    || iface_name.starts_with("br-")
-                    || iface_name.starts_with("tun")
-                    || iface_name.starts_with("wg")
-                {
-                    continue;
-                }
-
-                // Check if it's a physical interface by looking for device directory
-                if !iface_path.join("device").exists() {
-                    continue;
-                }
-
-                let mac_address = Self::read_sysfs_string(&iface_path.join("address"));
-                let speed_mbps = Self::read_sysfs_u32(&iface_path.join("speed"));
-                let operstate = Self::read_sysfs_string(&iface_path.join("operstate"));
-                let mtu = Self::read_sysfs_u32(&iface_path.join("mtu")).unwrap_or(1500);
-                let driver = Self::read_sysfs_string(&iface_path.join("device/driver/module"));
-                let firmware_version =
-                    Self::read_sysfs_opt_string(&iface_path.join("device/firmware_version"));
-
-                // Get IP addresses using ip command with JSON output
-                let (ipv4_addresses, ipv6_addresses) = Self::get_interface_ips_json(&iface_name);
-
-                interfaces.push(NetworkInterface {
-                    name: iface_name,
-                    mac_address,
-                    speed_mbps,
-                    is_up: operstate == "up",
-                    mtu,
-                    ipv4_addresses,
-                    ipv6_addresses,
-                    driver,
-                    firmware_version,
-                });
-            }
-        }
-
-        interfaces
-    }
-
-    fn gather_management_interface() -> Option<ManagementInterface> {
-        // Try to detect common management interfaces
-        if Path::new("/dev/ipmi0").exists() {
-            Some(ManagementInterface {
-                kind: "IPMI".to_string(),
-                address: None,
-                firmware: Self::read_dmi("bios-version"),
-            })
-        } else if Path::new("/sys/class/misc/mei").exists() {
-            Some(ManagementInterface {
-                kind: "Intel ME".to_string(),
-                address: None,
-                firmware: None,
-            })
-        } else {
-            None
-        }
-    }
-
-    fn get_host_uuid() -> String {
-        Self::read_dmi("system-uuid").unwrap()
-    }
-
-    // Helper methods
-    fn read_sysfs_string(path: &Path) -> String {
-        fs::read_to_string(path)
-            .unwrap_or_default()
-            .trim()
-            .to_string()
-    }
-
-    fn read_sysfs_opt_string(path: &Path) -> Option<String> {
-        fs::read_to_string(path)
-            .ok()
-            .map(|s| s.trim().to_string())
-            .filter(|s| !s.is_empty())
-    }
-
-    fn read_sysfs_u32(path: &Path) -> Option<u32> {
-        fs::read_to_string(path)
-            .ok()
-            .and_then(|s| s.trim().parse().ok())
-    }
-
-    fn read_dmi(field: &str) -> Option<String> {
-        Command::new("dmidecode")
-            .arg("-s")
-            .arg(field)
-            .output()
-            .ok()
-            .filter(|output| output.status.success())
-            .and_then(|output| String::from_utf8(output.stdout).ok())
-            .map(|s| s.trim().to_string())
-            .filter(|s| !s.is_empty())
-    }
-
-    fn get_interface_type(device_name: &str, device_path: &Path) -> String {
-        if device_name.starts_with("nvme") {
-            "NVMe".to_string()
-        } else if device_name.starts_with("sd") {
-            "SATA".to_string()
-        } else if device_name.starts_with("hd") {
-            "IDE".to_string()
-        } else if device_name.starts_with("vd") {
-            "VirtIO".to_string()
-        } else {
-            // Try to determine from device path
-            Self::read_sysfs_string(&device_path.join("device/subsystem"))
-                .split('/')
-                .next_back()
-                .unwrap_or("Unknown")
-                .to_string()
-        }
-    }
-
-    fn get_smart_status(device_name: &str) -> Option<String> {
-        Command::new("smartctl")
-            .arg("-H")
-            .arg(format!("/dev/{}", device_name))
-            .output()
-            .ok()
-            .filter(|output| output.status.success())
-            .and_then(|output| String::from_utf8(output.stdout).ok())
-            .and_then(|s| {
-                s.lines()
-                    .find(|line| line.contains("SMART overall-health self-assessment"))
-                    .and_then(|line| line.split(':').nth(1))
-                    .map(|s| s.trim().to_string())
-            })
-    }
-
-    fn parse_size(size_str: &str) -> Option<u64> {
-        if size_str.ends_with('T') {
-            size_str[..size_str.len() - 1]
-                .parse::<u64>()
-                .ok()
-                .map(|t| t * 1024 * 1024 * 1024 * 1024)
-        } else if size_str.ends_with('G') {
-            size_str[..size_str.len() - 1]
-                .parse::<u64>()
-                .ok()
-                .map(|g| g * 1024 * 1024 * 1024)
-        } else if size_str.ends_with('M') {
-            size_str[..size_str.len() - 1]
-                .parse::<u64>()
-                .ok()
-                .map(|m| m * 1024 * 1024)
-        } else if size_str.ends_with('K') {
-            size_str[..size_str.len() - 1]
-                .parse::<u64>()
-                .ok()
-                .map(|k| k * 1024)
-        } else if size_str.ends_with('B') {
-            size_str[..size_str.len() - 1].parse::<u64>().ok()
-        } else {
-            size_str.parse::<u64>().ok()
-        }
-    }
-
-    fn get_interface_ips_json(iface_name: &str) -> (Vec<String>, Vec<String>) {
-        let mut ipv4 = Vec::new();
-        let mut ipv6 = Vec::new();
-
-        // Get IPv4 addresses using JSON output
-        if let Ok(output) = Command::new("ip")
-            .args(["-j", "-4", "addr", "show", iface_name])
-            .output()
-            && output.status.success()
-            && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
-            && let Some(addrs) = json.as_array()
-        {
-            for addr_info in addrs {
-                if let Some(addr_info_obj) = addr_info.as_object()
-                    && let Some(addr_info) =
-                        addr_info_obj.get("addr_info").and_then(|v| v.as_array())
-                {
-                    for addr in addr_info {
-                        if let Some(addr_obj) = addr.as_object()
-                            && let Some(ip) = addr_obj.get("local").and_then(|v| v.as_str())
-                        {
-                            ipv4.push(ip.to_string());
-                        }
-                    }
-                }
-            }
-        }
-
-        // Get IPv6 addresses using JSON output
-        if let Ok(output) = Command::new("ip")
-            .args(["-j", "-6", "addr", "show", iface_name])
-            .output()
-            && output.status.success()
-            && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
-            && let Some(addrs) = json.as_array()
-        {
-            for addr_info in addrs {
-                if let Some(addr_info_obj) = addr_info.as_object()
-                    && let Some(addr_info) =
-                        addr_info_obj.get("addr_info").and_then(|v| v.as_array())
-                {
-                    for addr in addr_info {
-                        if let Some(addr_obj) = addr.as_object()
-                            && let Some(ip) = addr_obj.get("local").and_then(|v| v.as_str())
-                        {
-                            // Skip link-local addresses
-                            if !ip.starts_with("fe80::") {
-                                ipv6.push(ip.to_string());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        (ipv4, ipv6)
-    }
-}
--- a/harmony_inventory_agent/src/main.rs
+++ b/harmony_inventory_agent/src/main.rs
@@ -1,29 +0,0 @@
-// src/main.rs
-use actix_web::{App, HttpServer, Responder, get};
-use hwinfo::PhysicalHost;
-use std::env;
-
-mod hwinfo;
-
-#[get("/inventory")]
-async fn inventory() -> impl Responder {
-    log::info!("Received inventory request");
-    let host = PhysicalHost::gather();
-    log::info!("Inventory data gathered successfully");
-    actix_web::HttpResponse::Ok().json(host)
-}
-
-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-    env_logger::init();
-
-    let port = env::var("HARMONY_INVENTORY_AGENT_PORT").unwrap_or_else(|_| "8080".to_string());
-    let bind_addr = format!("0.0.0.0:{}", port);
-
-    log::info!("Starting inventory agent on {}", bind_addr);
-
-    HttpServer::new(|| App::new().service(inventory))
-        .bind(&bind_addr)?
-        .run()
-        .await
-}
--- a/harmony_tui/src/lib.rs
+++ b/harmony_tui/src/lib.rs
@@ -9,13 +9,7 @@ use widget::{help::HelpWidget, score::ScoreListWidget};
 use std::{panic, sync::Arc, time::Duration};

 use crossterm::event::{Event, EventStream, KeyCode, KeyEventKind};
-use harmony::{
-    instrumentation::{self, HarmonyEvent},
-    inventory::Inventory,
-    maestro::Maestro,
-    score::Score,
-    topology::Topology,
-};
+use harmony::{maestro::Maestro, score::Score, topology::Topology};
 use ratatui::{
    self, Frame,
    layout::{Constraint, Layout, Position},
@@ -45,62 +39,22 @@ pub mod tui {
 ///
 /// #[tokio::main]
 /// async fn main() {
-///     harmony_tui::run(
-///         Inventory::autoload(),
-///         HAClusterTopology::autoload(),
-///         vec![
-///             Box::new(SuccessScore {}),
-///             Box::new(ErrorScore {}),
-///             Box::new(PanicScore {}),
-///         ]
-///     ).await.unwrap();
+///     let inventory = Inventory::autoload();
+///     let topology = HAClusterTopology::autoload();
+///     let mut maestro = Maestro::new_without_initialization(inventory, topology);
+///
+///     maestro.register_all(vec![
+///         Box::new(SuccessScore {}),
+///         Box::new(ErrorScore {}),
+///         Box::new(PanicScore {}),
+///     ]);
+///     harmony_tui::init(maestro).await.unwrap();
 /// }
 /// ```
-pub async fn run<T: Topology + Send + Sync + 'static>(
-    inventory: Inventory,
-    topology: T,
-    scores: Vec<Box<dyn Score<T>>>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let handle = init_instrumentation().await;
-
-    let mut maestro = Maestro::initialize(inventory, topology).await.unwrap();
-    maestro.register_all(scores);
-
-    let result = init(maestro).await;
-
-    let _ = tokio::try_join!(handle);
-    result
-}
-
-async fn init<T: Topology + Send + Sync + 'static>(
+pub async fn init<T: Topology + Send + Sync + 'static>(
    maestro: Maestro<T>,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let result = HarmonyTUI::new(maestro).init().await;
-
-    instrumentation::instrument(HarmonyEvent::HarmonyFinished).unwrap();
-    result
-}
-
-async fn init_instrumentation() -> tokio::task::JoinHandle<()> {
-    let handle = tokio::spawn(handle_harmony_events());
-
-    loop {
-        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
-            break;
-        }
-    }
-
-    handle
-}
-
-async fn handle_harmony_events() {
-    instrumentation::subscribe("Harmony TUI Logger", async |event| {
-        if let HarmonyEvent::HarmonyFinished = event {
-            return false;
-        };
-        true
-    })
-    .await;
+    HarmonyTUI::new(maestro).init().await
 }

 pub struct HarmonyTUI<T: Topology> {
Author	SHA1	Message	Date
Ian Letourneau	387ae9f494	group related scores together	2025-08-09 23:20:45 -04:00
Ian Letourneau	336e1cfefe	rename a few scores & interprets Some checks failed Run Check Script / check (pull_request) Has been cancelled Details	2025-08-09 23:18:15 -04:00
Ian Letourneau	403e199062	fix: improve usage of indicatif for tracking progress	2025-08-09 23:18:15 -04:00