updates

2026-03-22 13:36:16 +01:00 · 2025-11-24 16:57:06 -05:00 · 2025-11-24 16:40:18 -05:00 · 2025-11-21 17:49:17 -05:00 · 2025-11-21 17:09:42 -05:00
203 changed files with 8494 additions and 22014 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,2 +0,0 @@
-# Everything needs to be reviewed by Hank
-*   @henrygd
--- a/.github/DISCUSSION_TEMPLATE/ideas.yml
+++ b/.github/DISCUSSION_TEMPLATE/ideas.yml
@@ -1,19 +0,0 @@
-body:
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of Beszel is this about?
-      options:
-        - Hub
-        - Agent
-        - Hub & Agent
-      default: 0
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Description
-      description: Please describe in detail what you want to share.
-    validations:
-      required: true
--- a/.github/DISCUSSION_TEMPLATE/support.yml
+++ b/.github/DISCUSSION_TEMPLATE/support.yml
@@ -1,54 +1,19 @@
 body:
-  - type: checkboxes
-    id: terms
+  - type: markdown
    attributes:
-      label: Welcome!
-      description: |
-        Thank you for reaching out to the Beszel community for support! To help us assist you better, please make sure to review the following points before submitting your request:
+      value: |
+        ### Before opening a discussion:

-        Please note:
-        - For translation-related issues or requests, please use the [Crowdin project](https://crowdin.com/project/beszel).
-        **- Please do not submit support reqeusts that are specific to ZFS. We plan to add integration with ZFS utilities in the near future.**
-
-      options:
-      - label: I have read the [Documentation](https://beszel.dev/guide/getting-started)
-        required: true
-      - label: I have checked the [Common Issues Guide](https://beszel.dev/guide/common-issues) and my problem was not mentioned there.
-        required: true
-      - label: I have searched open and closed issues and discussions and my problem was not mentioned before.
-        required: true
-      - label: I have verified I am using the latest version available. You can check the latest release [here](https://github.com/henrygd/beszel/releases).
-        required: true
-
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of Beszel is this about?
-      options:
-        - Hub
-        - Agent
-        - Hub & Agent
-    default: 0
-    validations:
-      required: true
+        - Check the [common issues guide](https://beszel.dev/guide/common-issues).
+        - Search existing [issues](https://github.com/henrygd/beszel/issues) and [discussions](https://github.com/henrygd/beszel/discussions) (including closed).

  - type: textarea
    id: description
    attributes:
-      label: Problem Description
-      description: |
-        How to write a good bug report?
-
-        - Respect the issue template as much as possible.
-        - The title should be short and descriptive.
-        - Explain the conditions which led you to report this issue: the context.
-        - The context should lead to something, a problem that you’re facing.
-        - Remain clear and concise.
-        - Format your messages to help the reader focus on what matters and understand the structure of your message, use [Markdown syntax](https://help.github.com/articles/github-flavored-markdown)
+      label: Description
+      description: A clear and concise description of the issue or question. If applicable, add screenshots to help explain your problem.
    validations:
      required: true
-
  - type: input
    id: system
    attributes:
@@ -56,15 +21,13 @@ body:
      placeholder: linux/amd64 (agent), freebsd/arm64 (hub)
    validations:
      required: true
-  
-#  - type: input
-#    id: version
-#    attributes:
-#      label: Beszel version
-#      placeholder: 0.9.1
-#    validations:
-#      required: true
-
+  - type: input
+    id: version
+    attributes:
+      label: Beszel version
+      placeholder: 0.9.1
+    validations:
+      required: true
  - type: dropdown
    id: install-method
    attributes:
@@ -78,21 +41,18 @@ body:
        - Other (please describe above)
    validations:
      required: true
-  
  - type: textarea
    id: config
    attributes:
      label: Configuration
      description: Please provide any relevant service configuration
      render: yaml
-
  - type: textarea
    id: hub-logs
    attributes:
      label: Hub Logs
      description: Check the logs page in PocketBase (`/_/#/logs`) for relevant errors (copy JSON).
      render: json
-
  - type: textarea
    id: agent-logs
    attributes:
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,30 +1,8 @@
 name: 🐛 Bug report
-description: Use this template to report a bug or issue.
+description: Report a new bug or issue.
 title: '[Bug]: '
-labels: ['bug']
+labels: ['bug', "needs confirmation"]
 body:
-  - type: checkboxes
-    attributes:
-      label: Welcome!
-      description: |
-        The issue tracker is for reporting bugs and feature requests only. For end-user related support questions, please use the **[GitHub Discussions](https://github.com/henrygd/beszel/discussions/new?category=support)** instead
-
-        Please note:
-        - For translation-related issues or requests, please use the [Crowdin project](https://crowdin.com/project/beszel).
-        - To request a change or feature, use the [feature request form](https://github.com/henrygd/beszel/issues/new?template=feature_request.yml).
-        - Any issues that can be resolved by consulting the documentation or by reviewing existing open or closed issues will be closed.
-        **- Please do not submit bugs that are specific to ZFS. We plan to add integration with ZFS utilities in the near future.**
-
-      options:
-      - label: I have read the [Documentation](https://beszel.dev/guide/getting-started)
-        required: true
-      - label: I have checked the [Common Issues Guide](https://beszel.dev/guide/common-issues) and my problem was not mentioned there.
-        required: true
-      - label: I have searched open and closed issues and my problem was not mentioned before.
-        required: true
-      - label: I have verified I am using the latest version available. You can check the latest release [here](https://github.com/henrygd/beszel/releases).
-        required: true
-
  - type: dropdown
    id: component
    attributes:
@@ -34,53 +12,81 @@ body:
        - Hub
        - Agent
        - Hub & Agent
-      default: 0
    validations:
      required: true
+  - type: markdown
+    attributes:
+      value: |
+        ### Thanks for taking the time to fill out this bug report!

+        - For more general support, please [start a support thread](https://github.com/henrygd/beszel/discussions/new?category=support).
+        - To request a change or feature, use the [feature request form](https://github.com/henrygd/beszel/issues/new?template=feature_request.yml).
+        - Please do not submit bugs that are specific to ZFS. We plan to add integration with ZFS utilities in the near future.
+
+        ### Before submitting a bug report:
+
+        - Check the [common issues guide](https://beszel.dev/guide/common-issues).
+        - Search existing [issues](https://github.com/henrygd/beszel/issues) and [discussions](https://github.com/henrygd/beszel/discussions) (including closed).
  - type: textarea
    id: description
    attributes:
-      label: Problem Description
-      description: |
-        How to write a good bug report?
-
-        - Respect the issue template as much as possible.
-        - The title should be short and descriptive.
-        - Explain the conditions which led you to report this issue: the context.
-        - The context should lead to something, a problem that you’re facing.
-        - Remain clear and concise.
-        - Format your messages to help the reader focus on what matters and understand the structure of your message, use [Markdown syntax](https://help.github.com/articles/github-flavored-markdown)
+      label: Description
+      description: Explain the issue you experienced clearly and concisely.
+      placeholder: I went to the coffee pot and it was empty.
    validations:
      required: true
-
  - type: textarea
    id: expected-behavior
    attributes:
      label: Expected Behavior
-      description: |
-        In a perfect world, what should have happened?
-        **Important:** Be specific. Vague descriptions like "it should work" are not helpful.
+      description: In a perfect world, what should have happened?
      placeholder: When I got to the coffee pot, it should have been full.
    validations:
      required: true
-
  - type: textarea
    id: steps-to-reproduce
    attributes:
      label: Steps to Reproduce
-      description: |
-        Provide detailed, numbered steps that someone else can follow to reproduce the issue.
-        **Important:** Vague descriptions like "it doesn't work" or "it's broken" will result in the issue being closed.
-        Include specific actions, URLs, button clicks, and any relevant data or configuration.
+      description: Describe how to reproduce the issue in repeatable steps.
      placeholder: |
        1. Go to the coffee pot.
        2. Make more coffee.
        3. Pour it into a cup.
-        4. Observe that the cup is empty instead of full.
    validations:
      required: true
-
+  - type: dropdown
+    id: category
+    attributes:
+      label: Category
+      description: Which category does this relate to most?
+      options:
+        - Metrics
+        - Charts & Visualization
+        - Settings & Configuration
+        - Notifications & Alerts
+        - Authentication
+        - Installation
+        - Performance
+        - UI / UX
+        - Other
+    validations:
+      required: true
+  - type: dropdown
+    id: metrics
+    attributes:
+      label: Affected Metrics
+      description: If applicable, which specific metric does this relate to most?
+      options:
+        - CPU
+        - Memory
+        - Storage
+        - Network
+        - Containers
+        - GPU
+        - Sensors
+        - Other
+    validations:
+      required: true
  - type: input
    id: system
    attributes:
@@ -88,7 +94,6 @@ body:
      placeholder: linux/amd64 (agent), freebsd/arm64 (hub)
    validations:
      required: true
-  
  - type: input
    id: version
    attributes:
@@ -96,7 +101,6 @@ body:
      placeholder: 0.9.1
    validations:
      required: true
-  
  - type: dropdown
    id: install-method
    attributes:
@@ -110,21 +114,18 @@ body:
        - Other (please describe above)
    validations:
      required: true
-  
  - type: textarea
    id: config
    attributes:
      label: Configuration
      description: Please provide any relevant service configuration
      render: yaml
-  
  - type: textarea
    id: hub-logs
    attributes:
      label: Hub Logs
      description: Check the logs page in PocketBase (`/_/#/logs`) for relevant errors (copy JSON).
      render: json
-  
  - type: textarea
    id: agent-logs
    attributes:
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,8 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-  - name: 🗣️ Translations
-    url: https://crowdin.com/project/beszel
-    about: Please report translation issues and request new translations here. 
  - name: 💬 Support and questions
    url: https://github.com/henrygd/beszel/discussions
    about: Ask and answer questions here.
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,25 +1,8 @@
 name: 🚀 Feature request
 description: Request a new feature or change.
 title: "[Feature]: "
-labels: ["enhancement"]
+labels: ["enhancement", "needs review"]
 body:
-  - type: checkboxes
-    attributes:
-      label: Welcome!
-      description: |
-        The issue tracker is for reporting bugs and feature requests only. For end-user related support questions, please use the **[GitHub Discussions](https://github.com/henrygd/beszel/discussions)** instead
-
-        Please note:
-        - For **Bug reports**, use the [Bug Form](https://github.com/henrygd/beszel/issues/new?template=bug_report.yml).
-        - Any requests for new translations should be requested within the [crowdin project](https://crowdin.com/project/beszel).
-        - Create one issue per feature request. This helps us keep track of requests and prioritize them accordingly.
-
-      options:
-      - label: I have searched open and closed feature requests to make sure this or similar feature request does not already exist.
-        required: true
-      - label: This is a feature request, not a bug report or support question.
-        required: true
-
  - type: dropdown
    id: component
    attributes:
@@ -29,29 +12,65 @@ body:
        - Hub
        - Agent
        - Hub & Agent
-      default: 0
    validations:
      required: true
-
-  - type: textarea
-    id: description
+  - type: markdown
    attributes:
-      label: Description
-      description: |
-        Describe the solution or feature you'd like. Explain what problem this solves or what value it adds.
-        **Important:** Be specific and detailed. Vague requests like "make it better" will be closed.
-      placeholder: |
-        Example:
-        - What is the feature?
-        - What problem does it solve?
-        - How should it work?
+      value: Before submitting, please search existing [issues](https://github.com/henrygd/beszel/issues) and [discussions](https://github.com/henrygd/beszel/discussions) (including closed).
+  - type: textarea
+    attributes:
+      label: Describe the feature you would like to see
    validations:
      required: true
-
  - type: textarea
    id: motivation
    attributes:
      label: Motivation / Use Case
      description: Why do you want this feature? What problem does it solve?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe how you would like to see this feature implemented
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Screenshots
+      description: Please attach any relevant screenshots, such as images from your current solution or similar implementations.
+    validations:
+      required: false
+  - type: dropdown
+    id: category
+    attributes:
+      label: Category
+      description: Which category does this relate to most?
+      options:
+        - Metrics
+        - Charts & Visualization
+        - Settings & Configuration
+        - Notifications & Alerts
+        - Authentication
+        - Installation
+        - Performance
+        - UI / UX
+        - Other
+    validations:
+      required: true
+  - type: dropdown
+    id: metrics
+    attributes:
+      label: Affected Metrics
+      description: If applicable, which specific metric does this relate to most?
+      options:
+        - CPU
+        - Memory
+        - Storage
+        - Network
+        - Containers
+        - GPU
+        - Sensors
+        - Other
    validations:
      required: true
--- a/.github/workflows/inactivity-actions.yml
+++ b/.github/workflows/inactivity-actions.yml
@@ -6,7 +6,6 @@ on:
  workflow_dispatch:

 permissions:
-  actions: write
  issues: write
  pull-requests: write

@@ -49,16 +48,11 @@ jobs:
          # Action can not skip PRs, set it to 100 years to cover it.
          days-before-pr-stale: 36524

-          # Max issues to process before early exit. Next run resumes from cache. GH API limit: 5000.
-          operations-per-run: 1500
-
          # Labels
          stale-issue-label: 'stale'
          remove-stale-when-updated: true
-          any-of-labels: 'awaiting-requester'
-          exempt-issue-labels: 'enhancement' 
+          only-issue-labels: 'awaiting-requester'

          # Exemptions
          exempt-assignees: true
-
-          exempt-milestones: true
+          exempt-milestones: true
--- a/.github/workflows/label-from-dropdown.yml
+++ b/.github/workflows/label-from-dropdown.yml
@@ -0,0 +1,82 @@
+name: Label issues from dropdowns
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  label_from_dropdown:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - name: Apply labels based on dropdown choices
+        uses: actions/github-script@v7
+        with:
+          script: |
+
+            const issueNumber = context.issue.number;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            // Get the issue body
+            const body = context.payload.issue.body;
+
+            // Helper to find dropdown value in the body (assuming markdown format)
+            function extractSectionValue(heading) {
+              const regex = new RegExp(`### ${heading}\\s+([\\s\\S]*?)(?:\\n###|$)`, 'i');
+              const match = body.match(regex);
+              if (match) {
+                // Get the first non-empty line after the heading
+                const lines = match[1].split('\n').map(l => l.trim()).filter(Boolean);
+                return lines[0] || null;
+              }
+              return null;
+            }
+
+            // Extract dropdown selections
+            const category = extractSectionValue('Category');
+            const metrics = extractSectionValue('Affected Metrics');
+            const component = extractSectionValue('Component');
+
+            // Build labels to add
+            let labelsToAdd = [];
+            if (category) labelsToAdd.push(category);
+            if (metrics) labelsToAdd.push(metrics);
+            if (component) labelsToAdd.push(component);
+
+            // Get existing labels in the repo
+            const { data: existingLabels } = await github.rest.issues.listLabelsForRepo({
+              owner,
+              repo,
+              per_page: 100
+            });
+            const existingLabelNames = existingLabels.map(l => l.name);
+
+            // Find labels that need to be created
+            const labelsToCreate = labelsToAdd.filter(label => !existingLabelNames.includes(label));
+
+            // Create missing labels (with a default color)
+            for (const label of labelsToCreate) {
+              try {
+                await github.rest.issues.createLabel({
+                  owner,
+                  repo,
+                  name: label,
+                  color: 'ededed' // light gray, you can pick any hex color
+                });
+              } catch (e) {
+                // Ignore if label already exists (race condition), otherwise rethrow
+                if (!e || e.status !== 422) throw e;
+              }
+            }
+
+            // Now apply all labels (they all exist now)
+            if (labelsToAdd.length > 0) {
+              await github.rest.issues.addLabels({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                labels: labelsToAdd
+              });
+            } 
--- a/.gitignore
+++ b/.gitignore
@@ -10,7 +10,6 @@ dist
 *.exe
 internal/cmd/hub/hub
 internal/cmd/agent/agent
-agent.test
 node_modules
 build
 *timestamp*
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -16,21 +16,10 @@ builds:
    goos:
      - linux
      - darwin
-      - windows
-      - freebsd
    goarch:
      - amd64
      - arm64
      - arm
-    ignore:
-      - goos: windows
-        goarch: arm64
-      - goos: windows
-        goarch: arm
-      - goos: freebsd
-        goarch: arm64
-      - goos: freebsd
-        goarch: arm

  - id: beszel-agent
    binary: beszel-agent
@@ -76,18 +65,6 @@ builds:
      - goos: windows
        goarch: riscv64

-  - id: beszel-agent-linux-amd64-glibc
-    binary: beszel-agent
-    main: internal/cmd/agent/agent.go
-    env:
-      - CGO_ENABLED=0
-    flags:
-      - -tags=glibc
-    goos:
-      - linux
-    goarch:
-      - amd64
-
 archives:
  - id: beszel-agent
    formats: [tar.gz]
@@ -101,15 +78,6 @@ archives:
      - goos: windows
        formats: [zip]

-  - id: beszel-agent-linux-amd64-glibc
-    formats: [tar.gz]
-    ids:
-      - beszel-agent-linux-amd64-glibc
-    name_template: >-
-      {{ .Binary }}_
-      {{- .Os }}_
-      {{- .Arch }}_glibc
-
  - id: beszel
    formats: [tar.gz]
    ids:
@@ -118,9 +86,6 @@ archives:
      {{ .Binary }}_
      {{- .Os }}_
      {{- .Arch }}
-    format_overrides:
-      - goos: windows
-        formats: [zip]

 nfpms:
  - id: beszel-agent
@@ -158,7 +123,9 @@ nfpms:
        - debconf
      scripts:
        templates: ./supplemental/debian/templates
-        config: ./supplemental/debian/config.sh
+        # Currently broken due to a bug in goreleaser
+        # https://github.com/goreleaser/goreleaser/issues/5487
+        #config: ./supplemental/debian/config.sh

 scoops:
  - ids: [beszel-agent]
--- a/41
+++ b/41
@@ -3,40 +3,6 @@ OS ?= $(shell go env GOOS)
 ARCH ?= $(shell go env GOARCH)
 # Skip building the web UI if true
 SKIP_WEB ?= false
-# Controls NVML/glibc agent build tag behavior:
-# - auto (default): enable on linux/amd64 glibc hosts
-# - true: always enable
-# - false: always disable
-NVML ?= auto
-
-# Detect glibc host for local linux/amd64 builds.
-HOST_GLIBC := $(shell \
-	if [ "$(OS)" = "linux" ] && [ "$(ARCH)" = "amd64" ]; then \
-		for p in /lib64/ld-linux-x86-64.so.2 /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /lib/ld-linux-x86-64.so.2; do \
-			[ -e "$$p" ] && { echo true; exit 0; }; \
-		done; \
-		if command -v ldd >/dev/null 2>&1; then \
-			if ldd --version 2>&1 | tr '[:upper:]' '[:lower:]' | awk '/gnu libc|glibc/{found=1} END{exit !found}'; then \
-				echo true; \
-			else \
-				echo false; \
-			fi; \
-		else \
-			echo false; \
-		fi; \
-	else \
-		echo false; \
-	fi)
-
-# Enable glibc build tag for NVML on supported Linux builds.
-AGENT_GO_TAGS :=
-ifeq ($(NVML),true)
-AGENT_GO_TAGS := -tags glibc
-else ifeq ($(NVML),auto)
-ifeq ($(HOST_GLIBC),true)
-AGENT_GO_TAGS := -tags glibc
-endif
-endif

 # Set executable extension based on target OS
 EXE_EXT := $(if $(filter windows,$(OS)),.exe,)
@@ -51,6 +17,7 @@ clean:
 lint:
 	golangci-lint run

+test: export GOEXPERIMENT=synctest
 test:
 	go test -tags=testing ./...

@@ -87,7 +54,7 @@ fetch-smartctl-conditional:

 # Update build-agent to include conditional .NET build
 build-agent: tidy build-dotnet-conditional fetch-smartctl-conditional
-	GOOS=$(OS) GOARCH=$(ARCH) go build $(AGENT_GO_TAGS) -o ./build/beszel-agent_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/agent
+	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel-agent_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/agent

 build-hub: tidy $(if $(filter false,$(SKIP_WEB)),build-web-ui)
 	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/hub
@@ -123,9 +90,9 @@ dev-hub:

 dev-agent:
 	@if command -v entr >/dev/null 2>&1; then \
-		find ./internal/cmd/agent/*.go ./agent/*.go | entr -r go run $(AGENT_GO_TAGS) github.com/henrygd/beszel/internal/cmd/agent; \
+		find ./internal/cmd/agent/*.go ./agent/*.go | entr -r go run github.com/henrygd/beszel/internal/cmd/agent; \
 	else \
-		go run $(AGENT_GO_TAGS) github.com/henrygd/beszel/internal/cmd/agent; \
+		go run github.com/henrygd/beszel/internal/cmd/agent; \
 	fi
 	
 build-dotnet:
--- a/agent/agent.go
+++ b/agent/agent.go
@@ -5,17 +5,19 @@
 package agent

 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"log/slog"
 	"os"
+	"path/filepath"
 	"strings"
 	"sync"
-	"time"

 	"github.com/gliderlabs/ssh"
 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/agent/deltatracker"
-	"github.com/henrygd/beszel/internal/common"
 	"github.com/henrygd/beszel/internal/entities/system"
+	"github.com/shirou/gopsutil/v4/host"
 	gossh "golang.org/x/crypto/ssh"
 )

@@ -27,15 +29,12 @@ type Agent struct {
 	fsNames                   []string                                              // List of filesystem device names being monitored
 	fsStats                   map[string]*system.FsStats                            // Keeps track of disk stats for each filesystem
 	diskPrev                  map[uint16]map[string]prevDisk                        // Previous disk I/O counters per cache interval
-	diskUsageCacheDuration    time.Duration                                         // How long to cache disk usage (to avoid waking sleeping disks)
-	lastDiskUsageUpdate       time.Time                                             // Last time disk usage was collected
 	netInterfaces             map[string]struct{}                                   // Stores all valid network interfaces
 	netIoStats                map[uint16]system.NetIoStats                          // Keeps track of bandwidth usage per cache interval
 	netInterfaceDeltaTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64] // Per-cache-time NIC delta trackers
 	dockerManager             *dockerManager                                        // Manages Docker API requests
 	sensorConfig              *SensorConfig                                         // Sensors config
-	systemInfo                system.Info                                           // Host system info (dynamic)
-	systemDetails             system.Details                                        // Host system details (static, once-per-connection)
+	systemInfo                system.Info                                           // Host system info
 	gpuManager                *GPUManager                                           // Manages GPU data
 	cache                     *systemDataCache                                      // Cache for system stats based on cache time
 	connectionManager         *ConnectionManager                                    // Channel to signal connection events
@@ -61,7 +60,7 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	agent.netIoStats = make(map[uint16]system.NetIoStats)
 	agent.netInterfaceDeltaTrackers = make(map[uint16]*deltatracker.DeltaTracker[string, uint64])

-	agent.dataDir, err = GetDataDir(dataDir...)
+	agent.dataDir, err = getDataDir(dataDir...)
 	if err != nil {
 		slog.Warn("Data directory not found")
 	} else {
@@ -70,17 +69,6 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {

 	agent.memCalc, _ = GetEnv("MEM_CALC")
 	agent.sensorConfig = agent.newSensorConfig()
-
-	// Parse disk usage cache duration (e.g., "15m", "1h") to avoid waking sleeping disks
-	if diskUsageCache, exists := GetEnv("DISK_USAGE_CACHE"); exists {
-		if duration, err := time.ParseDuration(diskUsageCache); err == nil {
-			agent.diskUsageCacheDuration = duration
-			slog.Info("DISK_USAGE_CACHE", "duration", duration)
-		} else {
-			slog.Warn("Invalid DISK_USAGE_CACHE", "err", err)
-		}
-	}
-
 	// Set up slog with a log level determined by the LOG_LEVEL env var
 	if logLevelStr, exists := GetEnv("LOG_LEVEL"); exists {
 		switch strings.ToLower(logLevelStr) {
@@ -96,21 +84,8 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {

 	slog.Debug(beszel.Version)

-	// initialize docker manager
-	agent.dockerManager = newDockerManager()
-
 	// initialize system info
-	agent.refreshSystemDetails()
-
-	// SMART_INTERVAL env var to update smart data at this interval
-	if smartIntervalEnv, exists := GetEnv("SMART_INTERVAL"); exists {
-		if duration, err := time.ParseDuration(smartIntervalEnv); err == nil && duration > 0 {
-			agent.systemDetails.SmartInterval = duration
-			slog.Info("SMART_INTERVAL", "duration", duration)
-		} else {
-			slog.Warn("Invalid SMART_INTERVAL", "err", err)
-		}
-	}
+	agent.initializeSystemInfo()

 	// initialize connection manager
 	agent.connectionManager = newConnectionManager(agent)
@@ -124,6 +99,9 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	// initialize net io stats
 	agent.initializeNetIoStats()

+	// initialize docker manager
+	agent.dockerManager = newDockerManager(agent)
+
 	agent.systemdManager, err = newSystemdManager()
 	if err != nil {
 		slog.Debug("Systemd", "err", err)
@@ -142,7 +120,7 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {

 	// if debugging, print stats
 	if agent.debug {
-		slog.Debug("Stats", "data", agent.gatherStats(common.DataRequestOptions{CacheTimeMs: 60_000, IncludeDetails: true}))
+		slog.Debug("Stats", "data", agent.gatherStats(0))
 	}

 	return agent, nil
@@ -157,11 +135,10 @@ func GetEnv(key string) (value string, exists bool) {
 	return os.LookupEnv(key)
 }

-func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedData {
+func (a *Agent) gatherStats(cacheTimeMs uint16) *system.CombinedData {
 	a.Lock()
 	defer a.Unlock()

-	cacheTimeMs := options.CacheTimeMs
 	data, isCached := a.cache.Get(cacheTimeMs)
 	if isCached {
 		slog.Debug("Cached data", "cacheTimeMs", cacheTimeMs)
@@ -172,12 +149,6 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 		Stats: a.getSystemStats(cacheTimeMs),
 		Info:  a.systemInfo,
 	}
-
-	// Include static system details only when requested
-	if options.IncludeDetails {
-		data.Details = &a.systemDetails
-	}
-
 	// slog.Info("System data", "data", data, "cacheTimeMs", cacheTimeMs)

 	if a.dockerManager != nil {
@@ -224,12 +195,37 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 	return data
 }

-// Start initializes and starts the agent with optional WebSocket connection
+// StartAgent initializes and starts the agent with optional WebSocket connection
 func (a *Agent) Start(serverOptions ServerOptions) error {
 	a.keys = serverOptions.Keys
 	return a.connectionManager.Start(serverOptions)
 }

 func (a *Agent) getFingerprint() string {
-	return GetFingerprint(a.dataDir, a.systemDetails.Hostname, a.systemDetails.CpuModel)
+	// first look for a fingerprint in the data directory
+	if a.dataDir != "" {
+		if fp, err := os.ReadFile(filepath.Join(a.dataDir, "fingerprint")); err == nil {
+			return string(fp)
+		}
+	}
+
+	// if no fingerprint is found, generate one
+	fingerprint, err := host.HostID()
+	if err != nil || fingerprint == "" {
+		fingerprint = a.systemInfo.Hostname + a.systemInfo.CpuModel
+	}
+
+	// hash fingerprint
+	sum := sha256.Sum256([]byte(fingerprint))
+	fingerprint = hex.EncodeToString(sum[:24])
+
+	// save fingerprint to data directory
+	if a.dataDir != "" {
+		err = os.WriteFile(filepath.Join(a.dataDir, "fingerprint"), []byte(fingerprint), 0644)
+		if err != nil {
+			slog.Warn("Failed to save fingerprint", "err", err)
+		}
+	}
+
+	return fingerprint
 }
--- a/agent/agent_cache_test.go
+++ b/agent/agent_cache_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

@@ -21,7 +22,7 @@ func createTestCacheData() *system.CombinedData {
 			DiskTotal: 100000,
 		},
 		Info: system.Info{
-			AgentVersion: "0.12.0",
+			Hostname: "test-host",
 		},
 		Containers: []*container.Stats{
 			{
@@ -127,7 +128,7 @@ func TestCacheMultipleIntervals(t *testing.T) {
 				Mem: 16384,
 			},
 			Info: system.Info{
-				AgentVersion: "0.12.0",
+				Hostname: "test-host-2",
 			},
 			Containers: []*container.Stats{},
 		}
@@ -170,7 +171,7 @@ func TestCacheOverwrite(t *testing.T) {
 			Mem: 32768,
 		},
 		Info: system.Info{
-			AgentVersion: "0.12.0",
+			Hostname: "updated-host",
 		},
 		Containers: []*container.Stats{},
 	}
--- a/agent/agent_test_helpers.go
+++ b/agent/agent_test_helpers.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

--- a/agent/battery/battery.go
+++ b/agent/battery/battery.go
@@ -65,7 +65,7 @@ func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
 			continue
 		}
 		totalCapacity += bat.Full
-		totalCharge += min(bat.Current, bat.Full)
+		totalCharge += bat.Current
 		if bat.State.Raw >= 0 {
 			batteryState = uint8(bat.State.Raw)
 		}
--- a/agent/client.go
+++ b/agent/client.go
@@ -15,6 +15,9 @@ import (

 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/entities/smart"
+	"github.com/henrygd/beszel/internal/entities/system"
+	"github.com/henrygd/beszel/internal/entities/systemd"

 	"github.com/fxamacker/cbor/v2"
 	"github.com/lxzan/gws"
@@ -198,7 +201,7 @@ func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.R

 	if authRequest.NeedSysInfo {
 		response.Name, _ = GetEnv("SYSTEM_NAME")
-		response.Hostname = client.agent.systemDetails.Hostname
+		response.Hostname = client.agent.systemInfo.Hostname
 		serverAddr := client.agent.connectionManager.serverOptions.Addr
 		_, response.Port, _ = net.SplitHostPort(serverAddr)
 	}
@@ -256,16 +259,40 @@ func (client *WebSocketClient) sendMessage(data any) error {
 	return err
 }

-// sendResponse sends a response with optional request ID.
-// For ID-based requests, we must populate legacy typed fields for backward
-// compatibility with older hubs (<= 0.17) that don't read the generic Data field.
+// sendResponse sends a response with optional request ID for the new protocol
 func (client *WebSocketClient) sendResponse(data any, requestID *uint32) error {
 	if requestID != nil {
-		response := newAgentResponse(data, requestID)
+		// New format with ID - use typed fields
+		response := common.AgentResponse{
+			Id: requestID,
+		}
+
+		// Set the appropriate typed field based on data type
+		switch v := data.(type) {
+		case *system.CombinedData:
+			response.SystemData = v
+		case *common.FingerprintResponse:
+			response.Fingerprint = v
+		case string:
+			response.String = &v
+		case map[string]smart.SmartData:
+			response.SmartData = v
+		case systemd.ServiceDetails:
+			response.ServiceInfo = v
+		// case []byte:
+		// 	response.RawBytes = v
+		// case string:
+		// 	response.RawBytes = []byte(v)
+		default:
+			// For any other type, convert to error
+			response.Error = fmt.Sprintf("unsupported response type: %T", data)
+		}
+
 		return client.sendMessage(response)
+	} else {
+		// Legacy format - send data directly
+		return client.sendMessage(data)
 	}
-	// Legacy format - send data directly
-	return client.sendMessage(data)
 }

 // getUserAgent returns one of two User-Agent strings based on current time.
--- a/agent/client_test.go
+++ b/agent/client_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

--- a/agent/connection_manager.go
+++ b/agent/connection_manager.go
@@ -1,9 +1,9 @@
 package agent

 import (
-	"context"
 	"errors"
 	"log/slog"
+	"os"
 	"os/signal"
 	"syscall"
 	"time"
@@ -91,8 +91,8 @@ func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
 	c.eventChan = make(chan ConnectionEvent, 1)

 	// signal handling for shutdown
-	sigCtx, stopSignals := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
-	defer stopSignals()
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

 	c.startWsTicker()
 	c.connect()
@@ -109,8 +109,8 @@ func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
 			_ = c.startWebSocketConnection()
 		case <-healthTicker:
 			_ = health.Update()
-		case <-sigCtx.Done():
-			slog.Info("Shutting down", "cause", context.Cause(sigCtx))
+		case <-sigChan:
+			slog.Info("Shutting down")
 			_ = c.agent.StopServer()
 			c.closeWebSocket()
 			return health.CleanUp()
--- a/agent/connection_manager_test.go
+++ b/agent/connection_manager_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

--- a/agent/cpu.go
+++ b/agent/cpu.go
@@ -89,7 +89,10 @@ func getPerCoreCpuUsage(cacheTimeMs uint16) (system.Uint8Slice, error) {
 	lastTimes := lastPerCoreCpuTimes[cacheTimeMs]

 	// Limit to the number of cores available in both samples
-	length := min(len(lastTimes), len(perCoreTimes))
+	length := len(perCoreTimes)
+	if len(lastTimes) < length {
+		length = len(lastTimes)
+	}

 	usage := make([]uint8, length)
 	for i := 0; i < length; i++ {
--- a/agent/data_dir.go
+++ b/agent/data_dir.go
@@ -8,10 +8,10 @@ import (
 	"runtime"
 )

-// GetDataDir returns the path to the data directory for the agent and an error
+// getDataDir returns the path to the data directory for the agent and an error
 // if the directory is not valid. Attempts to find the optimal data directory if
 // no data directories are provided.
-func GetDataDir(dataDirs ...string) (string, error) {
+func getDataDir(dataDirs ...string) (string, error) {
 	if len(dataDirs) > 0 {
 		return testDataDirs(dataDirs)
 	}
--- a/agent/data_dir_test.go
+++ b/agent/data_dir_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

@@ -16,7 +17,7 @@ func TestGetDataDir(t *testing.T) {
 	// Test with explicit dataDir parameter
 	t.Run("explicit data dir", func(t *testing.T) {
 		tempDir := t.TempDir()
-		result, err := GetDataDir(tempDir)
+		result, err := getDataDir(tempDir)
 		require.NoError(t, err)
 		assert.Equal(t, tempDir, result)
 	})
@@ -25,7 +26,7 @@ func TestGetDataDir(t *testing.T) {
 	t.Run("explicit data dir - create new", func(t *testing.T) {
 		tempDir := t.TempDir()
 		newDir := filepath.Join(tempDir, "new-data-dir")
-		result, err := GetDataDir(newDir)
+		result, err := getDataDir(newDir)
 		require.NoError(t, err)
 		assert.Equal(t, newDir, result)

@@ -51,7 +52,7 @@ func TestGetDataDir(t *testing.T) {

 		os.Setenv("BESZEL_AGENT_DATA_DIR", tempDir)

-		result, err := GetDataDir()
+		result, err := getDataDir()
 		require.NoError(t, err)
 		assert.Equal(t, tempDir, result)
 	})
@@ -59,7 +60,7 @@ func TestGetDataDir(t *testing.T) {
 	// Test with invalid explicit dataDir
 	t.Run("invalid explicit data dir", func(t *testing.T) {
 		invalidPath := "/invalid/path/that/cannot/be/created"
-		_, err := GetDataDir(invalidPath)
+		_, err := getDataDir(invalidPath)
 		assert.Error(t, err)
 	})

@@ -78,7 +79,7 @@ func TestGetDataDir(t *testing.T) {

 		// This will try platform-specific defaults, which may or may not work
 		// We're mainly testing that it doesn't panic and returns some result
-		result, err := GetDataDir()
+		result, err := getDataDir()
 		// We don't assert success/failure here since it depends on system permissions
 		// Just verify we get a string result if no error
 		if err == nil {
--- a/agent/disk.go
+++ b/agent/disk.go
@@ -26,15 +26,6 @@ func parseFilesystemEntry(entry string) (device, customName string) {
 	return device, customName
 }

-func isDockerSpecialMountpoint(mountpoint string) bool {
-	switch mountpoint {
-	case "/etc/hosts", "/etc/resolv.conf", "/etc/hostname":
-		return true
-	default:
-		return false
-	}
-}
-
 // Sets up the filesystems to monitor for disk usage and I/O.
 func (a *Agent) initializeDiskInfo() {
 	filesystem, _ := GetEnv("FILESYSTEM")
@@ -78,15 +69,11 @@ func (a *Agent) initializeDiskInfo() {
 		if _, exists := a.fsStats[key]; !exists {
 			if root {
 				slog.Info("Detected root device", "name", key)
-				// Check if root device is in /proc/diskstats. Do not guess a
-				// fallback device for root: that can misattribute root I/O to a
-				// different disk while usage remains tied to root mountpoint.
+				// Check if root device is in /proc/diskstats, use fallback if not
 				if _, ioMatch = diskIoCounters[key]; !ioMatch {
-					if matchedKey, match := findIoDevice(filesystem, diskIoCounters); match {
-						key = matchedKey
-						ioMatch = true
-					} else {
-						slog.Warn("Root I/O unmapped; set FILESYSTEM", "device", device, "mountpoint", mountpoint)
+					key, ioMatch = findIoDevice(filesystem, diskIoCounters, a.fsStats)
+					if !ioMatch {
+						slog.Info("Using I/O fallback", "device", device, "mountpoint", mountpoint, "fallback", key)
 					}
 				}
 			} else {
@@ -127,7 +114,7 @@ func (a *Agent) initializeDiskInfo() {

 	// Add EXTRA_FILESYSTEMS env var values to fsStats
 	if extraFilesystems, exists := GetEnv("EXTRA_FILESYSTEMS"); exists {
-		for fsEntry := range strings.SplitSeq(extraFilesystems, ",") {
+		for _, fsEntry := range strings.Split(extraFilesystems, ",") {
 			// Parse custom name from format: device__customname
 			fs, customName := parseFilesystemEntry(fsEntry)

@@ -154,8 +141,8 @@ func (a *Agent) initializeDiskInfo() {
 	for _, p := range partitions {
 		// fmt.Println(p.Device, p.Mountpoint)
 		// Binary root fallback or docker root fallback
-		if !hasRoot && (p.Mountpoint == rootMountPoint || (isDockerSpecialMountpoint(p.Mountpoint) && strings.HasPrefix(p.Device, "/dev"))) {
-			fs, match := findIoDevice(filepath.Base(p.Device), diskIoCounters)
+		if !hasRoot && (p.Mountpoint == rootMountPoint || (p.Mountpoint == "/etc/hosts" && strings.HasPrefix(p.Device, "/dev"))) {
+			fs, match := findIoDevice(filepath.Base(p.Device), diskIoCounters, a.fsStats)
 			if match {
 				addFsStat(fs, p.Mountpoint, true)
 				hasRoot = true
@@ -189,26 +176,33 @@ func (a *Agent) initializeDiskInfo() {

 	// If no root filesystem set, use fallback
 	if !hasRoot {
-		rootKey := filepath.Base(rootMountPoint)
-		if _, exists := a.fsStats[rootKey]; exists {
-			rootKey = "root"
-		}
-		slog.Warn("Root device not detected; root I/O disabled", "mountpoint", rootMountPoint)
-		a.fsStats[rootKey] = &system.FsStats{Root: true, Mountpoint: rootMountPoint}
+		rootDevice, _ := findIoDevice(filepath.Base(filesystem), diskIoCounters, a.fsStats)
+		slog.Info("Root disk", "mountpoint", rootMountPoint, "io", rootDevice)
+		a.fsStats[rootDevice] = &system.FsStats{Root: true, Mountpoint: rootMountPoint}
 	}

 	a.initializeDiskIoStats(diskIoCounters)
 }

-// Returns matching device from /proc/diskstats.
+// Returns matching device from /proc/diskstats,
+// or the device with the most reads if no match is found.
 // bool is true if a match was found.
-func findIoDevice(filesystem string, diskIoCounters map[string]disk.IOCountersStat) (string, bool) {
+func findIoDevice(filesystem string, diskIoCounters map[string]disk.IOCountersStat, fsStats map[string]*system.FsStats) (string, bool) {
+	var maxReadBytes uint64
+	maxReadDevice := "/"
 	for _, d := range diskIoCounters {
 		if d.Name == filesystem || (d.Label != "" && d.Label == filesystem) {
 			return d.Name, true
 		}
+		if d.ReadBytes > maxReadBytes {
+			// don't use if device already exists in fsStats
+			if _, exists := fsStats[d.Name]; !exists {
+				maxReadBytes = d.ReadBytes
+				maxReadDevice = d.Name
+			}
+		}
 	}
-	return "", false
+	return maxReadDevice, false
 }

 // Sets start values for disk I/O stats.
@@ -231,19 +225,8 @@ func (a *Agent) initializeDiskIoStats(diskIoCounters map[string]disk.IOCountersS

 // Updates disk usage statistics for all monitored filesystems
 func (a *Agent) updateDiskUsage(systemStats *system.Stats) {
-	// Check if we should skip extra filesystem collection to avoid waking sleeping disks.
-	// Root filesystem is always updated since it can't be sleeping while the agent runs.
-	// Always collect on first call (lastDiskUsageUpdate is zero) or if caching is disabled.
-	cacheExtraFs := a.diskUsageCacheDuration > 0 &&
-		!a.lastDiskUsageUpdate.IsZero() &&
-		time.Since(a.lastDiskUsageUpdate) < a.diskUsageCacheDuration
-
 	// disk usage
 	for _, stats := range a.fsStats {
-		// Skip non-root filesystems if caching is active
-		if cacheExtraFs && !stats.Root {
-			continue
-		}
 		if d, err := disk.Usage(stats.Mountpoint); err == nil {
 			stats.DiskTotal = bytesToGigabytes(d.Total)
 			stats.DiskUsed = bytesToGigabytes(d.Used)
@@ -261,11 +244,6 @@ func (a *Agent) updateDiskUsage(systemStats *system.Stats) {
 			stats.TotalWrite = 0
 		}
 	}
-
-	// Update the last disk usage update time when we've collected extra filesystems
-	if !cacheExtraFs {
-		a.lastDiskUsageUpdate = time.Now()
-	}
 }

 // Updates disk I/O statistics for all monitored filesystems
--- a/agent/disk_test.go
+++ b/agent/disk_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

@@ -6,7 +7,6 @@ import (
 	"os"
 	"strings"
 	"testing"
-	"time"

 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/shirou/gopsutil/v4/disk"
@@ -93,62 +93,6 @@ func TestParseFilesystemEntry(t *testing.T) {
 	}
 }

-func TestFindIoDevice(t *testing.T) {
-	t.Run("matches by device name", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sda": {Name: "sda"},
-			"sdb": {Name: "sdb"},
-		}
-
-		device, ok := findIoDevice("sdb", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "sdb", device)
-	})
-
-	t.Run("matches by device label", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sda": {Name: "sda", Label: "rootfs"},
-			"sdb": {Name: "sdb"},
-		}
-
-		device, ok := findIoDevice("rootfs", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "sda", device)
-	})
-
-	t.Run("returns no fallback when not found", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sda": {Name: "sda"},
-			"sdb": {Name: "sdb"},
-		}
-
-		device, ok := findIoDevice("nvme0n1p1", ioCounters)
-		assert.False(t, ok)
-		assert.Equal(t, "", device)
-	})
-}
-
-func TestIsDockerSpecialMountpoint(t *testing.T) {
-	testCases := []struct {
-		name       string
-		mountpoint string
-		expected   bool
-	}{
-		{name: "hosts", mountpoint: "/etc/hosts", expected: true},
-		{name: "resolv", mountpoint: "/etc/resolv.conf", expected: true},
-		{name: "hostname", mountpoint: "/etc/hostname", expected: true},
-		{name: "root", mountpoint: "/", expected: false},
-		{name: "passwd", mountpoint: "/etc/passwd", expected: false},
-		{name: "extra-filesystem", mountpoint: "/extra-filesystems/sda1", expected: false},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.expected, isDockerSpecialMountpoint(tc.mountpoint))
-		})
-	}
-}
-
 func TestInitializeDiskInfoWithCustomNames(t *testing.T) {
 	// Set up environment variables
 	oldEnv := os.Getenv("EXTRA_FILESYSTEMS")
@@ -289,86 +233,3 @@ func TestExtraFsKeyGeneration(t *testing.T) {
 		})
 	}
 }
-
-func TestDiskUsageCaching(t *testing.T) {
-	t.Run("caching disabled updates all filesystems", func(t *testing.T) {
-		agent := &Agent{
-			fsStats: map[string]*system.FsStats{
-				"sda": {Root: true, Mountpoint: "/"},
-				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
-			},
-			diskUsageCacheDuration: 0, // caching disabled
-		}
-
-		var stats system.Stats
-		agent.updateDiskUsage(&stats)
-
-		// Both should be updated (non-zero values from disk.Usage)
-		// Root stats should be populated in systemStats
-		assert.True(t, agent.lastDiskUsageUpdate.IsZero() || !agent.lastDiskUsageUpdate.IsZero(),
-			"lastDiskUsageUpdate should be set when caching is disabled")
-	})
-
-	t.Run("caching enabled always updates root filesystem", func(t *testing.T) {
-		agent := &Agent{
-			fsStats: map[string]*system.FsStats{
-				"sda": {Root: true, Mountpoint: "/", DiskTotal: 100, DiskUsed: 50},
-				"sdb": {Root: false, Mountpoint: "/mnt/storage", DiskTotal: 200, DiskUsed: 100},
-			},
-			diskUsageCacheDuration: 1 * time.Hour,
-			lastDiskUsageUpdate:    time.Now(), // cache is fresh
-		}
-
-		// Store original extra fs values
-		originalExtraTotal := agent.fsStats["sdb"].DiskTotal
-		originalExtraUsed := agent.fsStats["sdb"].DiskUsed
-
-		var stats system.Stats
-		agent.updateDiskUsage(&stats)
-
-		// Root should be updated (systemStats populated from disk.Usage call)
-		// We can't easily check if disk.Usage was called, but we verify the flow works
-
-		// Extra filesystem should retain cached values (not reset)
-		assert.Equal(t, originalExtraTotal, agent.fsStats["sdb"].DiskTotal,
-			"extra filesystem DiskTotal should be unchanged when cached")
-		assert.Equal(t, originalExtraUsed, agent.fsStats["sdb"].DiskUsed,
-			"extra filesystem DiskUsed should be unchanged when cached")
-	})
-
-	t.Run("first call always updates all filesystems", func(t *testing.T) {
-		agent := &Agent{
-			fsStats: map[string]*system.FsStats{
-				"sda": {Root: true, Mountpoint: "/"},
-				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
-			},
-			diskUsageCacheDuration: 1 * time.Hour,
-			// lastDiskUsageUpdate is zero (first call)
-		}
-
-		var stats system.Stats
-		agent.updateDiskUsage(&stats)
-
-		// After first call, lastDiskUsageUpdate should be set
-		assert.False(t, agent.lastDiskUsageUpdate.IsZero(),
-			"lastDiskUsageUpdate should be set after first call")
-	})
-
-	t.Run("expired cache updates extra filesystems", func(t *testing.T) {
-		agent := &Agent{
-			fsStats: map[string]*system.FsStats{
-				"sda": {Root: true, Mountpoint: "/"},
-				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
-			},
-			diskUsageCacheDuration: 1 * time.Millisecond,
-			lastDiskUsageUpdate:    time.Now().Add(-1 * time.Second), // cache expired
-		}
-
-		var stats system.Stats
-		agent.updateDiskUsage(&stats)
-
-		// lastDiskUsageUpdate should be refreshed since cache expired
-		assert.True(t, time.Since(agent.lastDiskUsageUpdate) < time.Second,
-			"lastDiskUsageUpdate should be refreshed when cache expires")
-	})
-}
--- a/agent/docker.go
+++ b/agent/docker.go
@@ -1,7 +1,6 @@
 package agent

 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/binary"
@@ -15,7 +14,6 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -26,11 +24,6 @@ import (
 	"github.com/blang/semver"
 )

-// ansiEscapePattern matches ANSI escape sequences (colors, cursor movement, etc.)
-// This includes CSI sequences like \x1b[...m and simple escapes like \x1b[K
-var ansiEscapePattern = regexp.MustCompile(`\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[@-Z\\-_]`)
-var dockerContainerIDPattern = regexp.MustCompile(`^[a-fA-F0-9]{12,64}$`)
-
 const (
 	// Docker API timeout in milliseconds
 	dockerTimeoutMs = 2100
@@ -62,7 +55,6 @@ type dockerManager struct {
 	decoder             *json.Decoder               // Reusable JSON decoder that reads from buf
 	apiStats            *container.ApiStats         // Reusable API stats object
 	excludeContainers   []string                    // Patterns to exclude containers by name
-	usingPodman         bool                        // Whether the Docker Engine API is running on Podman

 	// Cache-time-aware tracking for CPU stats (similar to cpu.go)
 	// Maps cache time intervals to container-specific CPU usage tracking
@@ -74,7 +66,6 @@ type dockerManager struct {
 	// cacheTimeMs -> DeltaTracker for network bytes sent/received
 	networkSentTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
 	networkRecvTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
-	retrySleep          func(time.Duration)
 }

 // userAgentRoundTripper is a custom http.RoundTripper that adds a User-Agent header to all requests
@@ -338,8 +329,6 @@ func validateCpuPercentage(cpuPct float64, containerName string) error {
 func updateContainerStatsValues(stats *container.Stats, cpuPct float64, usedMemory uint64, sent_delta, recv_delta uint64, readTime time.Time) {
 	stats.Cpu = twoDecimals(cpuPct)
 	stats.Mem = bytesToMegabytes(float64(usedMemory))
-	stats.Bandwidth = [2]uint64{sent_delta, recv_delta}
-	// TODO(0.19+): stop populating NetworkSent/NetworkRecv (deprecated in 0.18.3)
 	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
 	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
 	stats.PrevReadTime = readTime
@@ -408,8 +397,6 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeM
 	// reset current stats
 	stats.Cpu = 0
 	stats.Mem = 0
-	stats.Bandwidth = [2]uint64{0, 0}
-	// TODO(0.19+): stop populating NetworkSent/NetworkRecv (deprecated in 0.18.3)
 	stats.NetworkSent = 0
 	stats.NetworkRecv = 0

@@ -486,7 +473,7 @@ func (dm *dockerManager) deleteContainerStatsSync(id string) {
 }

 // Creates a new http client for Docker or Podman API
-func newDockerManager() *dockerManager {
+func newDockerManager(a *Agent) *dockerManager {
 	dockerHost, exists := GetEnv("DOCKER_HOST")
 	if exists {
 		// return nil if set to empty string
@@ -568,17 +555,16 @@ func newDockerManager() *dockerManager {
 		lastCpuReadTime:     make(map[uint16]map[string]time.Time),
 		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
 		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		retrySleep:          time.Sleep,
 	}

 	// If using podman, return client
 	if strings.Contains(dockerHost, "podman") {
-		manager.usingPodman = true
+		a.systemInfo.Podman = true
 		manager.goodDockerVersion = true
 		return manager
 	}

-	// run version check in goroutine to avoid blocking (server may not be ready and requires retries)
+	// this can take up to 5 seconds with retry, so run in goroutine
 	go manager.checkDockerVersion()

 	// give version check a chance to complete before returning
@@ -598,18 +584,18 @@ func (dm *dockerManager) checkDockerVersion() {
 	const versionMaxTries = 2
 	for i := 1; i <= versionMaxTries; i++ {
 		resp, err = dm.client.Get("http://localhost/version")
-		if err == nil && resp.StatusCode == http.StatusOK {
+		if err == nil {
 			break
 		}
 		if resp != nil {
 			resp.Body.Close()
 		}
 		if i < versionMaxTries {
-			slog.Debug("Failed to get Docker version; retrying", "attempt", i, "err", err, "response", resp)
-			dm.retrySleep(5 * time.Second)
+			slog.Debug("Failed to get Docker version; retrying", "attempt", i, "error", err)
+			time.Sleep(5 * time.Second)
 		}
 	}
-	if err != nil || resp.StatusCode != http.StatusOK {
+	if err != nil {
 		return
 	}
 	if err := dm.decode(resp, &versionInfo); err != nil {
@@ -651,34 +637,9 @@ func getDockerHost() string {
 	return scheme + socks[0]
 }

-func validateContainerID(containerID string) error {
-	if !dockerContainerIDPattern.MatchString(containerID) {
-		return fmt.Errorf("invalid container id")
-	}
-	return nil
-}
-
-func buildDockerContainerEndpoint(containerID, action string, query url.Values) (string, error) {
-	if err := validateContainerID(containerID); err != nil {
-		return "", err
-	}
-	u := &url.URL{
-		Scheme: "http",
-		Host:   "localhost",
-		Path:   fmt.Sprintf("/containers/%s/%s", url.PathEscape(containerID), action),
-	}
-	if len(query) > 0 {
-		u.RawQuery = query.Encode()
-	}
-	return u.String(), nil
-}
-
 // getContainerInfo fetches the inspection data for a container
 func (dm *dockerManager) getContainerInfo(ctx context.Context, containerID string) ([]byte, error) {
-	endpoint, err := buildDockerContainerEndpoint(containerID, "json", nil)
-	if err != nil {
-		return nil, err
-	}
+	endpoint := fmt.Sprintf("http://localhost/containers/%s/json", containerID)
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return nil, err
@@ -709,15 +670,7 @@ func (dm *dockerManager) getContainerInfo(ctx context.Context, containerID strin

 // getLogs fetches the logs for a container
 func (dm *dockerManager) getLogs(ctx context.Context, containerID string) (string, error) {
-	query := url.Values{
-		"stdout": []string{"1"},
-		"stderr": []string{"1"},
-		"tail":   []string{fmt.Sprintf("%d", dockerLogsTail)},
-	}
-	endpoint, err := buildDockerContainerEndpoint(containerID, "logs", query)
-	if err != nil {
-		return "", err
-	}
+	endpoint := fmt.Sprintf("http://localhost/containers/%s/logs?stdout=1&stderr=1&tail=%d", containerID, dockerLogsTail)
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return "", err
@@ -735,52 +688,17 @@ func (dm *dockerManager) getLogs(ctx context.Context, containerID string) (strin
 	}

 	var builder strings.Builder
-	contentType := resp.Header.Get("Content-Type")
-	multiplexed := strings.HasSuffix(contentType, "multiplexed-stream")
-	logReader := io.Reader(resp.Body)
-	if !multiplexed {
-		// Podman may return multiplexed logs without Content-Type. Sniff the first frame header
-		// with a small buffered reader only when the header check fails.
-		bufferedReader := bufio.NewReaderSize(resp.Body, 8)
-		multiplexed = detectDockerMultiplexedStream(bufferedReader)
-		logReader = bufferedReader
-	}
-	if err := decodeDockerLogStream(logReader, &builder, multiplexed); err != nil {
+	if err := decodeDockerLogStream(resp.Body, &builder); err != nil {
 		return "", err
 	}

-	// Strip ANSI escape sequences from logs for clean display in web UI
-	logs := builder.String()
-	if strings.Contains(logs, "\x1b") {
-		logs = ansiEscapePattern.ReplaceAllString(logs, "")
-	}
-	return logs, nil
+	return builder.String(), nil
 }

-func detectDockerMultiplexedStream(reader *bufio.Reader) bool {
-	const headerSize = 8
-	header, err := reader.Peek(headerSize)
-	if err != nil {
-		return false
-	}
-	if header[0] != 0x01 && header[0] != 0x02 {
-		return false
-	}
-	// Docker's stream framing header reserves bytes 1-3 as zero.
-	if header[1] != 0 || header[2] != 0 || header[3] != 0 {
-		return false
-	}
-	frameLen := binary.BigEndian.Uint32(header[4:])
-	return frameLen <= maxLogFrameSize
-}
-
-func decodeDockerLogStream(reader io.Reader, builder *strings.Builder, multiplexed bool) error {
-	if !multiplexed {
-		_, err := io.Copy(builder, io.LimitReader(reader, maxTotalLogSize))
-		return err
-	}
+func decodeDockerLogStream(reader io.Reader, builder *strings.Builder) error {
 	const headerSize = 8
 	var header [headerSize]byte
+	buf := make([]byte, 0, dockerLogsTail*200)
 	totalBytesRead := 0

 	for {
@@ -804,37 +722,36 @@ func decodeDockerLogStream(reader io.Reader, builder *strings.Builder, multiplex
 		// Check if reading this frame would exceed total log size limit
 		if totalBytesRead+int(frameLen) > maxTotalLogSize {
 			// Read and discard remaining data to avoid blocking
-			_, _ = io.CopyN(io.Discard, reader, int64(frameLen))
+			_, _ = io.Copy(io.Discard, io.LimitReader(reader, int64(frameLen)))
 			slog.Debug("Truncating logs: limit reached", "read", totalBytesRead, "limit", maxTotalLogSize)
 			return nil
 		}

-		n, err := io.CopyN(builder, reader, int64(frameLen))
-		if err != nil {
+		buf = allocateBuffer(buf, int(frameLen))
+		if _, err := io.ReadFull(reader, buf[:frameLen]); err != nil {
 			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				if len(buf) > 0 {
+					builder.Write(buf[:min(int(frameLen), len(buf))])
+				}
 				return nil
 			}
 			return err
 		}
-		totalBytesRead += int(n)
+		builder.Write(buf[:frameLen])
+		totalBytesRead += int(frameLen)
 	}
 }

-// GetHostInfo fetches the system info from Docker
-func (dm *dockerManager) GetHostInfo() (info container.HostInfo, err error) {
-	resp, err := dm.client.Get("http://localhost/info")
-	if err != nil {
-		return info, err
+func allocateBuffer(current []byte, needed int) []byte {
+	if cap(current) >= needed {
+		return current[:needed]
 	}
-	defer resp.Body.Close()
-
-	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
-		return info, err
-	}
-
-	return info, nil
+	return make([]byte, needed)
 }

-func (dm *dockerManager) IsPodman() bool {
-	return dm.usingPodman
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
 }
--- a/agent/docker_test.go
+++ b/agent/docker_test.go
@@ -1,17 +1,11 @@
 //go:build testing
+// +build testing

 package agent

 import (
 	"bytes"
-	"context"
 	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"strings"
 	"testing"
@@ -25,37 +19,6 @@ import (

 var defaultCacheTimeMs = uint16(60_000)

-type recordingRoundTripper struct {
-	statusCode  int
-	body        string
-	contentType string
-	called      bool
-	lastPath    string
-	lastQuery   map[string]string
-}
-
-func (rt *recordingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	rt.called = true
-	rt.lastPath = req.URL.EscapedPath()
-	rt.lastQuery = map[string]string{}
-	for key, values := range req.URL.Query() {
-		if len(values) > 0 {
-			rt.lastQuery[key] = values[0]
-		}
-	}
-	resp := &http.Response{
-		StatusCode: rt.statusCode,
-		Status:     "200 OK",
-		Header:     make(http.Header),
-		Body:       io.NopCloser(strings.NewReader(rt.body)),
-		Request:    req,
-	}
-	if rt.contentType != "" {
-		resp.Header.Set("Content-Type", rt.contentType)
-	}
-	return resp, nil
-}
-
 // cycleCpuDeltas cycles the CPU tracking data for a specific cache time interval
 func (dm *dockerManager) cycleCpuDeltas(cacheTimeMs uint16) {
 	// Clear the CPU tracking maps for this cache time interval
@@ -147,72 +110,6 @@ func TestCalculateMemoryUsage(t *testing.T) {
 	}
 }

-func TestBuildDockerContainerEndpoint(t *testing.T) {
-	t.Run("valid container ID builds escaped endpoint", func(t *testing.T) {
-		endpoint, err := buildDockerContainerEndpoint("0123456789ab", "json", nil)
-		require.NoError(t, err)
-		assert.Equal(t, "http://localhost/containers/0123456789ab/json", endpoint)
-	})
-
-	t.Run("invalid container ID is rejected", func(t *testing.T) {
-		_, err := buildDockerContainerEndpoint("../../version", "json", nil)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "invalid container id")
-	})
-}
-
-func TestContainerDetailsRequestsValidateContainerID(t *testing.T) {
-	rt := &recordingRoundTripper{
-		statusCode: 200,
-		body:       `{"Config":{"Env":["SECRET=1"]}}`,
-	}
-	dm := &dockerManager{
-		client: &http.Client{Transport: rt},
-	}
-
-	_, err := dm.getContainerInfo(context.Background(), "../version")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid container id")
-	assert.False(t, rt.called, "request should be rejected before dispatching to Docker API")
-}
-
-func TestContainerDetailsRequestsUseExpectedDockerPaths(t *testing.T) {
-	t.Run("container info uses container json endpoint", func(t *testing.T) {
-		rt := &recordingRoundTripper{
-			statusCode: 200,
-			body:       `{"Config":{"Env":["SECRET=1"]},"Name":"demo"}`,
-		}
-		dm := &dockerManager{
-			client: &http.Client{Transport: rt},
-		}
-
-		body, err := dm.getContainerInfo(context.Background(), "0123456789ab")
-		require.NoError(t, err)
-		assert.True(t, rt.called)
-		assert.Equal(t, "/containers/0123456789ab/json", rt.lastPath)
-		assert.NotContains(t, string(body), "SECRET=1", "sensitive env vars should be removed")
-	})
-
-	t.Run("container logs uses expected endpoint and query params", func(t *testing.T) {
-		rt := &recordingRoundTripper{
-			statusCode: 200,
-			body:       "line1\nline2\n",
-		}
-		dm := &dockerManager{
-			client: &http.Client{Transport: rt},
-		}
-
-		logs, err := dm.getLogs(context.Background(), "abcdef123456")
-		require.NoError(t, err)
-		assert.True(t, rt.called)
-		assert.Equal(t, "/containers/abcdef123456/logs", rt.lastPath)
-		assert.Equal(t, "1", rt.lastQuery["stdout"])
-		assert.Equal(t, "1", rt.lastQuery["stderr"])
-		assert.Equal(t, "200", rt.lastQuery["tail"])
-		assert.Equal(t, "line1\nline2\n", logs)
-	})
-}
-
 func TestValidateCpuPercentage(t *testing.T) {
 	tests := []struct {
 		name          string
@@ -287,12 +184,11 @@ func TestUpdateContainerStatsValues(t *testing.T) {
 	// Check memory (should be converted to MB: 1048576 bytes = 1 MB)
 	assert.Equal(t, 1.0, stats.Mem)

-	// Check bandwidth (raw bytes)
-	assert.Equal(t, [2]uint64{524288, 262144}, stats.Bandwidth)
+	// Check network sent (should be converted to MB: 524288 bytes = 0.5 MB)
+	assert.Equal(t, 0.5, stats.NetworkSent)

-	// Deprecated fields still populated for backward compatibility with older hubs
-	assert.Equal(t, 0.5, stats.NetworkSent)  // 524288 bytes = 0.5 MB
-	assert.Equal(t, 0.25, stats.NetworkRecv) // 262144 bytes = 0.25 MB
+	// Check network recv (should be converted to MB: 262144 bytes = 0.25 MB)
+	assert.Equal(t, 0.25, stats.NetworkRecv)

 	// Check read time
 	assert.Equal(t, testTime, stats.PrevReadTime)
@@ -482,117 +378,6 @@ func TestDockerManagerCreation(t *testing.T) {
 	assert.NotNil(t, dm.networkRecvTrackers)
 }

-func TestCheckDockerVersion(t *testing.T) {
-	tests := []struct {
-		name      string
-		responses []struct {
-			statusCode int
-			body       string
-		}
-		expectedGood     bool
-		expectedRequests int
-	}{
-		{
-			name: "200 with good version on first try",
-			responses: []struct {
-				statusCode int
-				body       string
-			}{
-				{http.StatusOK, `{"Version":"25.0.1"}`},
-			},
-			expectedGood:     true,
-			expectedRequests: 1,
-		},
-		{
-			name: "200 with old version on first try",
-			responses: []struct {
-				statusCode int
-				body       string
-			}{
-				{http.StatusOK, `{"Version":"24.0.7"}`},
-			},
-			expectedGood:     false,
-			expectedRequests: 1,
-		},
-		{
-			name: "non-200 then 200 with good version",
-			responses: []struct {
-				statusCode int
-				body       string
-			}{
-				{http.StatusServiceUnavailable, `"not ready"`},
-				{http.StatusOK, `{"Version":"25.1.0"}`},
-			},
-			expectedGood:     true,
-			expectedRequests: 2,
-		},
-		{
-			name: "non-200 on all retries",
-			responses: []struct {
-				statusCode int
-				body       string
-			}{
-				{http.StatusInternalServerError, `"error"`},
-				{http.StatusUnauthorized, `"error"`},
-			},
-			expectedGood:     false,
-			expectedRequests: 2,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			requestCount := 0
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				idx := requestCount
-				requestCount++
-				if idx >= len(tt.responses) {
-					idx = len(tt.responses) - 1
-				}
-				w.WriteHeader(tt.responses[idx].statusCode)
-				fmt.Fprint(w, tt.responses[idx].body)
-			}))
-			defer server.Close()
-
-			dm := &dockerManager{
-				client: &http.Client{
-					Transport: &http.Transport{
-						DialContext: func(_ context.Context, network, _ string) (net.Conn, error) {
-							return net.Dial(network, server.Listener.Addr().String())
-						},
-					},
-				},
-				retrySleep: func(time.Duration) {},
-			}
-
-			dm.checkDockerVersion()
-
-			assert.Equal(t, tt.expectedGood, dm.goodDockerVersion)
-			assert.Equal(t, tt.expectedRequests, requestCount)
-		})
-	}
-
-	t.Run("request error on all retries", func(t *testing.T) {
-		requestCount := 0
-		dm := &dockerManager{
-			client: &http.Client{
-				Transport: &http.Transport{
-					DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
-						requestCount++
-						return nil, errors.New("connection refused")
-					},
-				},
-			},
-			retrySleep: func(time.Duration) {},
-		}
-
-		dm.checkDockerVersion()
-
-		assert.False(t, dm.goodDockerVersion)
-		assert.Equal(t, 2, requestCount)
-	})
-}
-
 func TestCycleCpuDeltas(t *testing.T) {
 	dm := &dockerManager{
 		lastCpuContainer: map[uint16]map[string]uint64{
@@ -742,10 +527,8 @@ func TestContainerStatsInitialization(t *testing.T) {

 	assert.Equal(t, 45.67, stats.Cpu)
 	assert.Equal(t, 2.0, stats.Mem)
-	assert.Equal(t, [2]uint64{1048576, 524288}, stats.Bandwidth)
-	// Deprecated fields still populated for backward compatibility with older hubs
-	assert.Equal(t, 1.0, stats.NetworkSent) // 1048576 bytes = 1 MB
-	assert.Equal(t, 0.5, stats.NetworkRecv) // 524288 bytes = 0.5 MB
+	assert.Equal(t, 1.0, stats.NetworkSent)
+	assert.Equal(t, 0.5, stats.NetworkRecv)
 	assert.Equal(t, testTime, stats.PrevReadTime)
 }

@@ -906,49 +689,11 @@ func TestContainerStatsEndToEndWithRealData(t *testing.T) {

 	assert.Equal(t, cpuPct, testStats.Cpu)
 	assert.Equal(t, bytesToMegabytes(float64(usedMemory)), testStats.Mem)
-	assert.Equal(t, [2]uint64{1000000, 500000}, testStats.Bandwidth)
-	// Deprecated fields still populated for backward compatibility with older hubs
 	assert.Equal(t, bytesToMegabytes(1000000), testStats.NetworkSent)
 	assert.Equal(t, bytesToMegabytes(500000), testStats.NetworkRecv)
 	assert.Equal(t, testTime, testStats.PrevReadTime)
 }

-func TestGetLogsDetectsMultiplexedWithoutContentType(t *testing.T) {
-	// Docker multiplexed frame: [stream][0,0,0][len(4 bytes BE)][payload]
-	frame := []byte{
-		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-		'H', 'e', 'l', 'l', 'o',
-	}
-	rt := &recordingRoundTripper{
-		statusCode: 200,
-		body:       string(frame),
-		// Intentionally omit content type to simulate Podman behavior.
-	}
-	dm := &dockerManager{
-		client: &http.Client{Transport: rt},
-	}
-
-	logs, err := dm.getLogs(context.Background(), "abcdef123456")
-	require.NoError(t, err)
-	assert.Equal(t, "Hello", logs)
-}
-
-func TestGetLogsDoesNotMisclassifyRawStreamAsMultiplexed(t *testing.T) {
-	// Starts with 0x01, but doesn't match Docker frame signature (reserved bytes aren't all zero).
-	raw := []byte{0x01, 0x02, 0x03, 0x04, 'r', 'a', 'w'}
-	rt := &recordingRoundTripper{
-		statusCode: 200,
-		body:       string(raw),
-	}
-	dm := &dockerManager{
-		client: &http.Client{Transport: rt},
-	}
-
-	logs, err := dm.getLogs(context.Background(), "abcdef123456")
-	require.NoError(t, err)
-	assert.Equal(t, raw, []byte(logs))
-}
-
 func TestEdgeCasesWithRealData(t *testing.T) {
 	// Test with minimal container stats
 	minimalStats := &container.ApiStats{
@@ -1057,24 +802,6 @@ func TestNetworkRateCalculationFormula(t *testing.T) {
 	}
 }

-func TestGetHostInfo(t *testing.T) {
-	data, err := os.ReadFile("test-data/system_info.json")
-	require.NoError(t, err)
-
-	var info container.HostInfo
-	err = json.Unmarshal(data, &info)
-	require.NoError(t, err)
-
-	assert.Equal(t, "6.8.0-31-generic", info.KernelVersion)
-	assert.Equal(t, "Ubuntu 24.04 LTS", info.OperatingSystem)
-	// assert.Equal(t, "24.04", info.OSVersion)
-	// assert.Equal(t, "linux", info.OSType)
-	// assert.Equal(t, "x86_64", info.Architecture)
-	assert.EqualValues(t, 4, info.NCPU)
-	assert.EqualValues(t, 2095882240, info.MemTotal)
-	// assert.Equal(t, "27.0.1", info.ServerVersion)
-}
-
 func TestDeltaTrackerCacheTimeIsolation(t *testing.T) {
 	// Test that different cache times have separate DeltaTracker instances
 	dm := &dockerManager{
@@ -1205,7 +932,6 @@ func TestDecodeDockerLogStream(t *testing.T) {
 		input       []byte
 		expected    string
 		expectError bool
-		multiplexed bool
 	}{
 		{
 			name: "simple log entry",
@@ -1216,7 +942,6 @@ func TestDecodeDockerLogStream(t *testing.T) {
 			},
 			expected:    "Hello World",
 			expectError: false,
-			multiplexed: true,
 		},
 		{
 			name: "multiple frames",
@@ -1230,7 +955,6 @@ func TestDecodeDockerLogStream(t *testing.T) {
 			},
 			expected:    "HelloWorld",
 			expectError: false,
-			multiplexed: true,
 		},
 		{
 			name: "zero length frame",
@@ -1243,20 +967,12 @@ func TestDecodeDockerLogStream(t *testing.T) {
 			},
 			expected:    "Hello",
 			expectError: false,
-			multiplexed: true,
 		},
 		{
 			name:        "empty input",
 			input:       []byte{},
 			expected:    "",
 			expectError: false,
-			multiplexed: true,
-		},
-		{
-			name:        "raw stream (not multiplexed)",
-			input:       []byte("raw log content"),
-			expected:    "raw log content",
-			multiplexed: false,
 		},
 	}

@@ -1264,7 +980,7 @@ func TestDecodeDockerLogStream(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			reader := bytes.NewReader(tt.input)
 			var builder strings.Builder
-			err := decodeDockerLogStream(reader, &builder, tt.multiplexed)
+			err := decodeDockerLogStream(reader, &builder)

 			if tt.expectError {
 				assert.Error(t, err)
@@ -1288,7 +1004,7 @@ func TestDecodeDockerLogStreamMemoryProtection(t *testing.T) {

 		reader := bytes.NewReader(input)
 		var builder strings.Builder
-		err := decodeDockerLogStream(reader, &builder, true)
+		err := decodeDockerLogStream(reader, &builder)

 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "log frame size")
@@ -1322,7 +1038,7 @@ func TestDecodeDockerLogStreamMemoryProtection(t *testing.T) {

 		reader := bytes.NewReader(input)
 		var builder strings.Builder
-		err := decodeDockerLogStream(reader, &builder, true)
+		err := decodeDockerLogStream(reader, &builder)

 		// Should complete without error (graceful truncation)
 		assert.NoError(t, err)
@@ -1337,6 +1053,53 @@ func TestDecodeDockerLogStreamMemoryProtection(t *testing.T) {
 	})
 }

+func TestAllocateBuffer(t *testing.T) {
+	tests := []struct {
+		name          string
+		currentCap    int
+		needed        int
+		expectedCap   int
+		shouldRealloc bool
+	}{
+		{
+			name:          "buffer has enough capacity",
+			currentCap:    1024,
+			needed:        512,
+			expectedCap:   1024,
+			shouldRealloc: false,
+		},
+		{
+			name:          "buffer needs reallocation",
+			currentCap:    512,
+			needed:        1024,
+			expectedCap:   1024,
+			shouldRealloc: true,
+		},
+		{
+			name:          "buffer needs exact size",
+			currentCap:    1024,
+			needed:        1024,
+			expectedCap:   1024,
+			shouldRealloc: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			current := make([]byte, 0, tt.currentCap)
+			result := allocateBuffer(current, tt.needed)
+
+			assert.Equal(t, tt.needed, len(result))
+			assert.GreaterOrEqual(t, cap(result), tt.expectedCap)
+
+			if tt.shouldRealloc {
+				// If reallocation was needed, capacity should be at least the needed size
+				assert.GreaterOrEqual(t, cap(result), tt.needed)
+			}
+		})
+	}
+}
+
 func TestShouldExcludeContainer(t *testing.T) {
 	tests := []struct {
 		name          string
@@ -1440,59 +1203,3 @@ func TestShouldExcludeContainer(t *testing.T) {
 		})
 	}
 }
-
-func TestAnsiEscapePattern(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected string
-	}{
-		{
-			name:     "no ANSI codes",
-			input:    "Hello, World!",
-			expected: "Hello, World!",
-		},
-		{
-			name:     "simple color code",
-			input:    "\x1b[34mINFO\x1b[0m client mode",
-			expected: "INFO client mode",
-		},
-		{
-			name:     "multiple color codes",
-			input:    "\x1b[31mERROR\x1b[0m: \x1b[33mWarning\x1b[0m message",
-			expected: "ERROR: Warning message",
-		},
-		{
-			name:     "bold and color",
-			input:    "\x1b[1;32mSUCCESS\x1b[0m",
-			expected: "SUCCESS",
-		},
-		{
-			name:     "cursor movement codes",
-			input:    "Line 1\x1b[KLine 2",
-			expected: "Line 1Line 2",
-		},
-		{
-			name:     "256 color code",
-			input:    "\x1b[38;5;196mRed text\x1b[0m",
-			expected: "Red text",
-		},
-		{
-			name:     "RGB/truecolor code",
-			input:    "\x1b[38;2;255;0;0mRed text\x1b[0m",
-			expected: "Red text",
-		},
-		{
-			name:     "mixed content with newlines",
-			input:    "\x1b[34m2024-01-01 12:00:00\x1b[0m INFO Starting\n\x1b[31m2024-01-01 12:00:01\x1b[0m ERROR Failed",
-			expected: "2024-01-01 12:00:00 INFO Starting\n2024-01-01 12:00:01 ERROR Failed",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := ansiEscapePattern.ReplaceAllString(tt.input, "")
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
--- a/agent/emmc_common.go
+++ b/agent/emmc_common.go
@@ -1,95 +0,0 @@
-package agent
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-func isEmmcBlockName(name string) bool {
-	if !strings.HasPrefix(name, "mmcblk") {
-		return false
-	}
-	suffix := strings.TrimPrefix(name, "mmcblk")
-	if suffix == "" {
-		return false
-	}
-	for _, c := range suffix {
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-func parseHexOrDecByte(s string) (uint8, bool) {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return 0, false
-	}
-	base := 10
-	if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
-		base = 16
-		s = s[2:]
-	}
-	parsed, err := strconv.ParseUint(s, base, 8)
-	if err != nil {
-		return 0, false
-	}
-	return uint8(parsed), true
-}
-
-func parseHexBytePair(s string) (uint8, uint8, bool) {
-	fields := strings.Fields(s)
-	if len(fields) < 2 {
-		return 0, 0, false
-	}
-	a, okA := parseHexOrDecByte(fields[0])
-	b, okB := parseHexOrDecByte(fields[1])
-	if !okA && !okB {
-		return 0, 0, false
-	}
-	return a, b, true
-}
-
-func emmcSmartStatus(preEOL uint8) string {
-	switch preEOL {
-	case 0x01:
-		return "PASSED"
-	case 0x02:
-		return "WARNING"
-	case 0x03:
-		return "FAILED"
-	default:
-		return "UNKNOWN"
-	}
-}
-
-func emmcPreEOLString(preEOL uint8) string {
-	switch preEOL {
-	case 0x01:
-		return "0x01 (normal)"
-	case 0x02:
-		return "0x02 (warning)"
-	case 0x03:
-		return "0x03 (urgent)"
-	default:
-		return fmt.Sprintf("0x%02x", preEOL)
-	}
-}
-
-func emmcLifeTimeString(v uint8) string {
-	// JEDEC eMMC: 0x01..0x0A => 0-100% used in 10% steps, 0x0B => exceeded.
-	switch {
-	case v == 0:
-		return "0x00 (not reported)"
-	case v >= 0x01 && v <= 0x0A:
-		low := int(v-1) * 10
-		high := int(v) * 10
-		return fmt.Sprintf("0x%02x (%d-%d%% used)", v, low, high)
-	case v == 0x0B:
-		return "0x0b (>100% used)"
-	default:
-		return fmt.Sprintf("0x%02x", v)
-	}
-}
--- a/agent/emmc_common_test.go
+++ b/agent/emmc_common_test.go
@@ -1,78 +0,0 @@
-package agent
-
-import "testing"
-
-func TestParseHexOrDecByte(t *testing.T) {
-	tests := []struct {
-		in   string
-		want uint8
-		ok   bool
-	}{
-		{"0x01", 1, true},
-		{"0X0b", 11, true},
-		{"01", 1, true},
-		{" 3 ", 3, true},
-		{"", 0, false},
-		{"0x", 0, false},
-		{"nope", 0, false},
-	}
-
-	for _, tt := range tests {
-		got, ok := parseHexOrDecByte(tt.in)
-		if ok != tt.ok || got != tt.want {
-			t.Fatalf("parseHexOrDecByte(%q) = (%d,%v), want (%d,%v)", tt.in, got, ok, tt.want, tt.ok)
-		}
-	}
-}
-
-func TestParseHexBytePair(t *testing.T) {
-	a, b, ok := parseHexBytePair("0x01 0x02\n")
-	if !ok || a != 1 || b != 2 {
-		t.Fatalf("parseHexBytePair hex = (%d,%d,%v), want (1,2,true)", a, b, ok)
-	}
-
-	a, b, ok = parseHexBytePair("01 02")
-	if !ok || a != 1 || b != 2 {
-		t.Fatalf("parseHexBytePair dec = (%d,%d,%v), want (1,2,true)", a, b, ok)
-	}
-
-	_, _, ok = parseHexBytePair("0x01")
-	if ok {
-		t.Fatalf("parseHexBytePair short input ok=true, want false")
-	}
-}
-
-func TestEmmcSmartStatus(t *testing.T) {
-	if got := emmcSmartStatus(0x01); got != "PASSED" {
-		t.Fatalf("emmcSmartStatus(0x01) = %q, want PASSED", got)
-	}
-	if got := emmcSmartStatus(0x02); got != "WARNING" {
-		t.Fatalf("emmcSmartStatus(0x02) = %q, want WARNING", got)
-	}
-	if got := emmcSmartStatus(0x03); got != "FAILED" {
-		t.Fatalf("emmcSmartStatus(0x03) = %q, want FAILED", got)
-	}
-	if got := emmcSmartStatus(0x00); got != "UNKNOWN" {
-		t.Fatalf("emmcSmartStatus(0x00) = %q, want UNKNOWN", got)
-	}
-}
-
-func TestIsEmmcBlockName(t *testing.T) {
-	cases := []struct {
-		name string
-		ok   bool
-	}{
-		{"mmcblk0", true},
-		{"mmcblk1", true},
-		{"mmcblk10", true},
-		{"mmcblk0p1", false},
-		{"sda", false},
-		{"mmcblk", false},
-		{"mmcblkA", false},
-	}
-	for _, c := range cases {
-		if got := isEmmcBlockName(c.name); got != c.ok {
-			t.Fatalf("isEmmcBlockName(%q) = %v, want %v", c.name, got, c.ok)
-		}
-	}
-}
--- a/agent/emmc_linux.go
+++ b/agent/emmc_linux.go
@@ -1,227 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/henrygd/beszel/internal/entities/smart"
-)
-
-// emmcSysfsRoot is a test hook; production value is "/sys".
-var emmcSysfsRoot = "/sys"
-
-type emmcHealth struct {
-	model    string
-	serial   string
-	revision string
-	capacity uint64
-	preEOL   uint8
-	lifeA    uint8
-	lifeB    uint8
-}
-
-func scanEmmcDevices() []*DeviceInfo {
-	blockDir := filepath.Join(emmcSysfsRoot, "class", "block")
-	entries, err := os.ReadDir(blockDir)
-	if err != nil {
-		return nil
-	}
-
-	devices := make([]*DeviceInfo, 0, 2)
-	for _, ent := range entries {
-		name := ent.Name()
-		if !isEmmcBlockName(name) {
-			continue
-		}
-
-		deviceDir := filepath.Join(blockDir, name, "device")
-		if !hasEmmcHealthFiles(deviceDir) {
-			continue
-		}
-
-		devPath := filepath.Join("/dev", name)
-		devices = append(devices, &DeviceInfo{
-			Name:     devPath,
-			Type:     "emmc",
-			InfoName: devPath + " [eMMC]",
-			Protocol: "MMC",
-		})
-	}
-
-	return devices
-}
-
-func (sm *SmartManager) collectEmmcHealth(deviceInfo *DeviceInfo) (bool, error) {
-	if deviceInfo == nil || deviceInfo.Name == "" {
-		return false, nil
-	}
-
-	base := filepath.Base(deviceInfo.Name)
-	if !isEmmcBlockName(base) && !strings.EqualFold(deviceInfo.Type, "emmc") && !strings.EqualFold(deviceInfo.Type, "mmc") {
-		return false, nil
-	}
-
-	health, ok := readEmmcHealth(base)
-	if !ok {
-		return false, nil
-	}
-
-	// Normalize the device type to keep pruning logic stable across refreshes.
-	deviceInfo.Type = "emmc"
-
-	key := health.serial
-	if key == "" {
-		key = filepath.Join("/dev", base)
-	}
-
-	status := emmcSmartStatus(health.preEOL)
-
-	attrs := []*smart.SmartAttribute{
-		{
-			Name:      "PreEOLInfo",
-			RawValue:  uint64(health.preEOL),
-			RawString: emmcPreEOLString(health.preEOL),
-		},
-		{
-			Name:      "DeviceLifeTimeEstA",
-			RawValue:  uint64(health.lifeA),
-			RawString: emmcLifeTimeString(health.lifeA),
-		},
-		{
-			Name:      "DeviceLifeTimeEstB",
-			RawValue:  uint64(health.lifeB),
-			RawString: emmcLifeTimeString(health.lifeB),
-		},
-	}
-
-	sm.Lock()
-	defer sm.Unlock()
-
-	if _, exists := sm.SmartDataMap[key]; !exists {
-		sm.SmartDataMap[key] = &smart.SmartData{}
-	}
-
-	data := sm.SmartDataMap[key]
-	data.ModelName = health.model
-	data.SerialNumber = health.serial
-	data.FirmwareVersion = health.revision
-	data.Capacity = health.capacity
-	data.Temperature = 0
-	data.SmartStatus = status
-	data.DiskName = filepath.Join("/dev", base)
-	data.DiskType = "emmc"
-	data.Attributes = attrs
-
-	return true, nil
-}
-
-func readEmmcHealth(blockName string) (emmcHealth, bool) {
-	var out emmcHealth
-
-	if !isEmmcBlockName(blockName) {
-		return out, false
-	}
-
-	deviceDir := filepath.Join(emmcSysfsRoot, "class", "block", blockName, "device")
-	preEOL, okPre := readHexByteFile(filepath.Join(deviceDir, "pre_eol_info"))
-
-	// Some kernels expose EXT_CSD lifetime via "life_time" (two bytes), others as
-	// separate files. Support both.
-	lifeA, lifeB, okLife := readLifeTime(deviceDir)
-
-	if !okPre && !okLife {
-		return out, false
-	}
-
-	out.preEOL = preEOL
-	out.lifeA = lifeA
-	out.lifeB = lifeB
-
-	out.model = readStringFile(filepath.Join(deviceDir, "name"))
-	out.serial = readStringFile(filepath.Join(deviceDir, "serial"))
-	out.revision = readStringFile(filepath.Join(deviceDir, "prv"))
-
-	if capBytes, ok := readBlockCapacityBytes(blockName); ok {
-		out.capacity = capBytes
-	}
-
-	return out, true
-}
-
-func readLifeTime(deviceDir string) (uint8, uint8, bool) {
-	if content, ok := readStringFileOK(filepath.Join(deviceDir, "life_time")); ok {
-		a, b, ok := parseHexBytePair(content)
-		return a, b, ok
-	}
-
-	a, okA := readHexByteFile(filepath.Join(deviceDir, "device_life_time_est_typ_a"))
-	b, okB := readHexByteFile(filepath.Join(deviceDir, "device_life_time_est_typ_b"))
-	if okA || okB {
-		return a, b, true
-	}
-	return 0, 0, false
-}
-
-func readBlockCapacityBytes(blockName string) (uint64, bool) {
-	sizePath := filepath.Join(emmcSysfsRoot, "class", "block", blockName, "size")
-	lbsPath := filepath.Join(emmcSysfsRoot, "class", "block", blockName, "queue", "logical_block_size")
-
-	sizeStr, ok := readStringFileOK(sizePath)
-	if !ok {
-		return 0, false
-	}
-	sectors, err := strconv.ParseUint(sizeStr, 10, 64)
-	if err != nil || sectors == 0 {
-		return 0, false
-	}
-
-	lbsStr, ok := readStringFileOK(lbsPath)
-	logicalBlockSize := uint64(512)
-	if ok {
-		if parsed, err := strconv.ParseUint(lbsStr, 10, 64); err == nil && parsed > 0 {
-			logicalBlockSize = parsed
-		}
-	}
-
-	return sectors * logicalBlockSize, true
-}
-
-func readHexByteFile(path string) (uint8, bool) {
-	content, ok := readStringFileOK(path)
-	if !ok {
-		return 0, false
-	}
-	b, ok := parseHexOrDecByte(content)
-	return b, ok
-}
-
-func readStringFile(path string) string {
-	content, _ := readStringFileOK(path)
-	return content
-}
-
-func readStringFileOK(path string) (string, bool) {
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return "", false
-	}
-	return strings.TrimSpace(string(b)), true
-}
-
-func hasEmmcHealthFiles(deviceDir string) bool {
-	entries, err := os.ReadDir(deviceDir)
-	if err != nil {
-		return false
-	}
-	for _, ent := range entries {
-		switch ent.Name() {
-		case "pre_eol_info", "life_time", "device_life_time_est_typ_a", "device_life_time_est_typ_b":
-			return true
-		}
-	}
-	return false
-}
--- a/agent/emmc_linux_test.go
+++ b/agent/emmc_linux_test.go
@@ -1,80 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/smart"
-)
-
-func TestEmmcMockSysfsScanAndCollect(t *testing.T) {
-	tmp := t.TempDir()
-	prev := emmcSysfsRoot
-	emmcSysfsRoot = tmp
-	t.Cleanup(func() { emmcSysfsRoot = prev })
-
-	// Fake: /sys/class/block/mmcblk0
-	mmcDeviceDir := filepath.Join(tmp, "class", "block", "mmcblk0", "device")
-	mmcQueueDir := filepath.Join(tmp, "class", "block", "mmcblk0", "queue")
-	if err := os.MkdirAll(mmcDeviceDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(mmcQueueDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	write := func(path, content string) {
-		t.Helper()
-		if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	write(filepath.Join(mmcDeviceDir, "pre_eol_info"), "0x02\n")
-	write(filepath.Join(mmcDeviceDir, "life_time"), "0x04 0x05\n")
-	write(filepath.Join(mmcDeviceDir, "name"), "H26M52103FMR\n")
-	write(filepath.Join(mmcDeviceDir, "serial"), "01234567\n")
-	write(filepath.Join(mmcDeviceDir, "prv"), "0x08\n")
-	write(filepath.Join(mmcQueueDir, "logical_block_size"), "512\n")
-	write(filepath.Join(tmp, "class", "block", "mmcblk0", "size"), "1024\n") // sectors
-
-	devs := scanEmmcDevices()
-	if len(devs) != 1 {
-		t.Fatalf("scanEmmcDevices() = %d devices, want 1", len(devs))
-	}
-	if devs[0].Name != "/dev/mmcblk0" || devs[0].Type != "emmc" {
-		t.Fatalf("scanEmmcDevices()[0] = %+v, want Name=/dev/mmcblk0 Type=emmc", devs[0])
-	}
-
-	sm := &SmartManager{SmartDataMap: map[string]*smart.SmartData{}}
-	ok, err := sm.collectEmmcHealth(devs[0])
-	if err != nil || !ok {
-		t.Fatalf("collectEmmcHealth() = (ok=%v, err=%v), want (true,nil)", ok, err)
-	}
-	if len(sm.SmartDataMap) != 1 {
-		t.Fatalf("SmartDataMap len=%d, want 1", len(sm.SmartDataMap))
-	}
-	var got *smart.SmartData
-	for _, v := range sm.SmartDataMap {
-		got = v
-		break
-	}
-	if got == nil {
-		t.Fatalf("SmartDataMap value nil")
-	}
-	if got.DiskType != "emmc" || got.DiskName != "/dev/mmcblk0" {
-		t.Fatalf("disk fields = (type=%q name=%q), want (emmc,/dev/mmcblk0)", got.DiskType, got.DiskName)
-	}
-	if got.SmartStatus != "WARNING" {
-		t.Fatalf("SmartStatus=%q, want WARNING", got.SmartStatus)
-	}
-	if got.SerialNumber != "01234567" || got.ModelName == "" || got.Capacity == 0 {
-		t.Fatalf("identity fields = (model=%q serial=%q cap=%d), want non-empty model, serial 01234567, cap>0", got.ModelName, got.SerialNumber, got.Capacity)
-	}
-	if len(got.Attributes) < 3 {
-		t.Fatalf("attributes len=%d, want >= 3", len(got.Attributes))
-	}
-}
--- a/agent/emmc_stub.go
+++ b/agent/emmc_stub.go
@@ -1,14 +0,0 @@
-//go:build !linux
-
-package agent
-
-// Non-Linux builds: eMMC health via sysfs is not available.
-
-func scanEmmcDevices() []*DeviceInfo {
-	return nil
-}
-
-func (sm *SmartManager) collectEmmcHealth(deviceInfo *DeviceInfo) (bool, error) {
-	return false, nil
-}
-
--- a/agent/fingerprint.go
+++ b/agent/fingerprint.go
@@ -1,87 +0,0 @@
-package agent
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/shirou/gopsutil/v4/cpu"
-	"github.com/shirou/gopsutil/v4/host"
-)
-
-const fingerprintFileName = "fingerprint"
-
-// knownBadUUID is a commonly known "product_uuid" that is not unique across systems.
-const knownBadUUID = "03000200-0400-0500-0006-000700080009"
-
-// GetFingerprint returns the agent fingerprint. It first tries to read a saved
-// fingerprint from the data directory. If not found (or dataDir is empty), it
-// generates one from system properties. The hostname and cpuModel parameters are
-// used as fallback material if host.HostID() fails. If either is empty, they
-// are fetched from the system automatically.
-//
-// If a new fingerprint is generated and a dataDir is provided, it is saved.
-func GetFingerprint(dataDir, hostname, cpuModel string) string {
-	if dataDir != "" {
-		if fp, err := readFingerprint(dataDir); err == nil {
-			return fp
-		}
-	}
-	fp := generateFingerprint(hostname, cpuModel)
-	if dataDir != "" {
-		_ = SaveFingerprint(dataDir, fp)
-	}
-	return fp
-}
-
-// generateFingerprint creates a fingerprint from system properties.
-// It tries host.HostID() first, falling back to hostname + cpuModel.
-// If hostname or cpuModel are empty, they are fetched from the system.
-func generateFingerprint(hostname, cpuModel string) string {
-	fingerprint, err := host.HostID()
-	if err != nil || fingerprint == "" || fingerprint == knownBadUUID {
-		if hostname == "" {
-			hostname, _ = os.Hostname()
-		}
-		if cpuModel == "" {
-			if info, err := cpu.Info(); err == nil && len(info) > 0 {
-				cpuModel = info[0].ModelName
-			}
-		}
-		fingerprint = hostname + cpuModel
-	}
-
-	sum := sha256.Sum256([]byte(fingerprint))
-	return hex.EncodeToString(sum[:24])
-}
-
-// readFingerprint reads the saved fingerprint from the data directory.
-func readFingerprint(dataDir string) (string, error) {
-	fp, err := os.ReadFile(filepath.Join(dataDir, fingerprintFileName))
-	if err != nil {
-		return "", err
-	}
-	s := strings.TrimSpace(string(fp))
-	if s == "" {
-		return "", errors.New("fingerprint file is empty")
-	}
-	return s, nil
-}
-
-// SaveFingerprint writes the fingerprint to the data directory.
-func SaveFingerprint(dataDir, fingerprint string) error {
-	return os.WriteFile(filepath.Join(dataDir, fingerprintFileName), []byte(fingerprint), 0o644)
-}
-
-// DeleteFingerprint removes the saved fingerprint file from the data directory.
-// Returns nil if the file does not exist (idempotent).
-func DeleteFingerprint(dataDir string) error {
-	err := os.Remove(filepath.Join(dataDir, fingerprintFileName))
-	if errors.Is(err, os.ErrNotExist) {
-		return nil
-	}
-	return err
-}
--- a/agent/fingerprint_test.go
+++ b/agent/fingerprint_test.go
@@ -1,102 +0,0 @@
-//go:build testing
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGetFingerprint(t *testing.T) {
-	t.Run("reads existing fingerprint from file", func(t *testing.T) {
-		dir := t.TempDir()
-		expected := "abc123def456"
-		err := os.WriteFile(filepath.Join(dir, fingerprintFileName), []byte(expected), 0644)
-		require.NoError(t, err)
-
-		fp := GetFingerprint(dir, "", "")
-		assert.Equal(t, expected, fp)
-	})
-
-	t.Run("trims whitespace from file", func(t *testing.T) {
-		dir := t.TempDir()
-		err := os.WriteFile(filepath.Join(dir, fingerprintFileName), []byte("  abc123  \n"), 0644)
-		require.NoError(t, err)
-
-		fp := GetFingerprint(dir, "", "")
-		assert.Equal(t, "abc123", fp)
-	})
-
-	t.Run("generates fingerprint when file does not exist", func(t *testing.T) {
-		dir := t.TempDir()
-		fp := GetFingerprint(dir, "", "")
-		assert.NotEmpty(t, fp)
-	})
-
-	t.Run("generates fingerprint when dataDir is empty", func(t *testing.T) {
-		fp := GetFingerprint("", "", "")
-		assert.NotEmpty(t, fp)
-	})
-
-	t.Run("generates consistent fingerprint for same inputs", func(t *testing.T) {
-		fp1 := GetFingerprint("", "myhost", "mycpu")
-		fp2 := GetFingerprint("", "myhost", "mycpu")
-		assert.Equal(t, fp1, fp2)
-	})
-
-	t.Run("prefers saved fingerprint over generated", func(t *testing.T) {
-		dir := t.TempDir()
-		require.NoError(t, SaveFingerprint(dir, "saved-fp"))
-
-		fp := GetFingerprint(dir, "anyhost", "anycpu")
-		assert.Equal(t, "saved-fp", fp)
-	})
-}
-
-func TestSaveFingerprint(t *testing.T) {
-	t.Run("saves fingerprint to file", func(t *testing.T) {
-		dir := t.TempDir()
-		err := SaveFingerprint(dir, "abc123")
-		require.NoError(t, err)
-
-		content, err := os.ReadFile(filepath.Join(dir, fingerprintFileName))
-		require.NoError(t, err)
-		assert.Equal(t, "abc123", string(content))
-	})
-
-	t.Run("overwrites existing fingerprint", func(t *testing.T) {
-		dir := t.TempDir()
-		require.NoError(t, SaveFingerprint(dir, "old"))
-		require.NoError(t, SaveFingerprint(dir, "new"))
-
-		content, err := os.ReadFile(filepath.Join(dir, fingerprintFileName))
-		require.NoError(t, err)
-		assert.Equal(t, "new", string(content))
-	})
-}
-
-func TestDeleteFingerprint(t *testing.T) {
-	t.Run("deletes existing fingerprint", func(t *testing.T) {
-		dir := t.TempDir()
-		fp := filepath.Join(dir, fingerprintFileName)
-		err := os.WriteFile(fp, []byte("abc123"), 0644)
-		require.NoError(t, err)
-
-		err = DeleteFingerprint(dir)
-		require.NoError(t, err)
-
-		// Verify file is gone
-		_, err = os.Stat(fp)
-		assert.True(t, os.IsNotExist(err))
-	})
-
-	t.Run("no error when file does not exist", func(t *testing.T) {
-		dir := t.TempDir()
-		err := DeleteFingerprint(dir)
-		assert.NoError(t, err)
-	})
-}
--- a/agent/gpu.go
+++ b/agent/gpu.go
@@ -5,29 +5,29 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"log/slog"
 	"maps"
 	"os/exec"
 	"regexp"
-	"runtime"
 	"strconv"
 	"strings"
 	"sync"
 	"time"

 	"github.com/henrygd/beszel/internal/entities/system"
+
+	"golang.org/x/exp/slog"
 )

 const (
 	// Commands
-	nvidiaSmiCmd    string = "nvidia-smi"
-	rocmSmiCmd      string = "rocm-smi"
-	tegraStatsCmd   string = "tegrastats"
-	nvtopCmd        string = "nvtop"
-	powermetricsCmd string = "powermetrics"
-	macmonCmd       string = "macmon"
-	noGPUFoundMsg   string = "no GPU found - see https://beszel.dev/guide/gpu"
+	nvidiaSmiCmd  string = "nvidia-smi"
+	rocmSmiCmd    string = "rocm-smi"
+	tegraStatsCmd string = "tegrastats"

+	// Polling intervals
+	nvidiaSmiInterval  string        = "4"    // in seconds
+	tegraStatsInterval string        = "3700" // in milliseconds
+	rocmSmiInterval    time.Duration = 4300 * time.Millisecond
 	// Command retry and timeout constants
 	retryWaitTime     time.Duration = 5 * time.Second
 	maxFailureRetries int           = 5
@@ -40,7 +40,11 @@ const (
 // GPUManager manages data collection for GPUs (either Nvidia or AMD)
 type GPUManager struct {
 	sync.Mutex
-	GpuDataMap map[string]*system.GPUData
+	nvidiaSmi     bool
+	rocmSmi       bool
+	tegrastats    bool
+	intelGpuStats bool
+	GpuDataMap    map[string]*system.GPUData
 	// lastAvgData stores the last calculated averages for each GPU
 	// Used when a collection happens before new data arrives (Count == 0)
 	lastAvgData map[string]system.GPUData
@@ -81,58 +85,6 @@ type gpuCollector struct {

 var errNoValidData = fmt.Errorf("no valid GPU data found") // Error for missing data

-// collectorSource identifies a selectable GPU collector in GPU_COLLECTOR.
-type collectorSource string
-
-const (
-	collectorSourceNVTop        collectorSource = collectorSource(nvtopCmd)
-	collectorSourceNVML         collectorSource = "nvml"
-	collectorSourceNvidiaSMI    collectorSource = collectorSource(nvidiaSmiCmd)
-	collectorSourceIntelGpuTop  collectorSource = collectorSource(intelGpuStatsCmd)
-	collectorSourceAmdSysfs     collectorSource = "amd_sysfs"
-	collectorSourceRocmSMI      collectorSource = collectorSource(rocmSmiCmd)
-	collectorSourceMacmon       collectorSource = collectorSource(macmonCmd)
-	collectorSourcePowermetrics collectorSource = collectorSource(powermetricsCmd)
-	collectorGroupNvidia        string          = "nvidia"
-	collectorGroupIntel         string          = "intel"
-	collectorGroupAmd           string          = "amd"
-	collectorGroupApple         string          = "apple"
-)
-
-func isValidCollectorSource(source collectorSource) bool {
-	switch source {
-	case collectorSourceNVTop,
-		collectorSourceNVML,
-		collectorSourceNvidiaSMI,
-		collectorSourceIntelGpuTop,
-		collectorSourceAmdSysfs,
-		collectorSourceRocmSMI,
-		collectorSourceMacmon,
-		collectorSourcePowermetrics:
-		return true
-	}
-	return false
-}
-
-// gpuCapabilities describes detected GPU tooling and sysfs support on the host.
-type gpuCapabilities struct {
-	hasNvidiaSmi    bool
-	hasRocmSmi      bool
-	hasAmdSysfs     bool
-	hasTegrastats   bool
-	hasIntelGpuTop  bool
-	hasNvtop        bool
-	hasMacmon       bool
-	hasPowermetrics bool
-}
-
-type collectorDefinition struct {
-	group              string
-	available          bool
-	start              func(onFailure func()) bool
-	deprecationWarning string
-}
-
 // starts and manages the ongoing collection of GPU data for the specified GPU management utility
 func (c *gpuCollector) start() {
 	for {
@@ -184,10 +136,10 @@ func (gm *GPUManager) getJetsonParser() func(output []byte) bool {
 	// use closure to avoid recompiling the regex
 	ramPattern := regexp.MustCompile(`RAM (\d+)/(\d+)MB`)
 	gr3dPattern := regexp.MustCompile(`GR3D_FREQ (\d+)%`)
-	tempPattern := regexp.MustCompile(`(?:tj|GPU)@(\d+\.?\d*)C`)
+	tempPattern := regexp.MustCompile(`tj@(\d+\.?\d*)C`)
 	// Orin Nano / NX do not have GPU specific power monitor
 	// TODO: Maybe use VDD_IN for Nano / NX and add a total system power chart
-	powerPattern := regexp.MustCompile(`(GPU_SOC|CPU_GPU_CV)\s+(\d+)mW|VDD_SYS_GPU\s+(\d+)/\d+`)
+	powerPattern := regexp.MustCompile(`(GPU_SOC|CPU_GPU_CV) (\d+)mW`)

 	// jetson devices have only one gpu so we'll just initialize here
 	gpuData := &system.GPUData{Name: "GPU"}
@@ -216,13 +168,7 @@ func (gm *GPUManager) getJetsonParser() func(output []byte) bool {
 		// Parse power usage
 		powerMatches := powerPattern.FindSubmatch(output)
 		if powerMatches != nil {
-			// powerMatches[2] is the "(GPU_SOC|CPU_GPU_CV) <N>mW" capture
-			// powerMatches[3] is the "VDD_SYS_GPU <N>/<N>" capture
-			powerStr := string(powerMatches[2])
-			if powerStr == "" {
-				powerStr = string(powerMatches[3])
-			}
-			power, _ := strconv.ParseFloat(powerStr, 64)
+			power, _ := strconv.ParseFloat(string(powerMatches[2]), 64)
 			gpuData.Power += power / milliwattsInAWatt
 		}
 		gpuData.Count++
@@ -285,11 +231,10 @@ func (gm *GPUManager) parseAmdData(output []byte) bool {
 		totalMemory, _ := strconv.ParseFloat(v.MemoryTotal, 64)
 		usage, _ := strconv.ParseFloat(v.Usage, 64)

-		id := v.ID
-		if _, ok := gm.GpuDataMap[id]; !ok {
-			gm.GpuDataMap[id] = &system.GPUData{Name: v.Name}
+		if _, ok := gm.GpuDataMap[v.ID]; !ok {
+			gm.GpuDataMap[v.ID] = &system.GPUData{Name: v.Name}
 		}
-		gpu := gm.GpuDataMap[id]
+		gpu := gm.GpuDataMap[v.ID]
 		gpu.Temperature, _ = strconv.ParseFloat(v.Temperature, 64)
 		gpu.MemoryUsed = bytesToMegabytes(memoryUsage)
 		gpu.MemoryTotal = bytesToMegabytes(totalMemory)
@@ -352,13 +297,8 @@ func (gm *GPUManager) calculateGPUAverage(id string, gpu *system.GPUData, cacheK
 	currentCount := uint32(gpu.Count)
 	deltaCount := gm.calculateDeltaCount(currentCount, lastSnapshot)

-	// If no new data arrived
+	// If no new data arrived, use last known average
 	if deltaCount == 0 {
-		// If GPU appears suspended (instantaneous values are 0), return zero values
-		// Otherwise return last known average for temporary collection gaps
-		if gpu.Temperature == 0 && gpu.MemoryUsed == 0 {
-			return system.GPUData{Name: gpu.Name}
-		}
 		return gm.lastAvgData[id] // zero value if not found
 	}

@@ -438,324 +378,105 @@ func (gm *GPUManager) storeSnapshot(id string, gpu *system.GPUData, cacheKey uin
 	gm.lastSnapshots[cacheKey][id] = snapshot
 }

-// discoverGpuCapabilities checks for available GPU tooling and sysfs support.
-// It only reports capability presence and does not apply policy decisions.
-func (gm *GPUManager) discoverGpuCapabilities() gpuCapabilities {
-	caps := gpuCapabilities{
-		hasAmdSysfs: gm.hasAmdSysfs(),
-	}
+// detectGPUs checks for the presence of GPU management tools (nvidia-smi, rocm-smi, tegrastats)
+// in the system path. It sets the corresponding flags in the GPUManager struct if any of these
+// tools are found. If none of the tools are found, it returns an error indicating that no GPU
+// management tools are available.
+func (gm *GPUManager) detectGPUs() error {
 	if _, err := exec.LookPath(nvidiaSmiCmd); err == nil {
-		caps.hasNvidiaSmi = true
+		gm.nvidiaSmi = true
 	}
 	if _, err := exec.LookPath(rocmSmiCmd); err == nil {
-		caps.hasRocmSmi = true
+		gm.rocmSmi = true
 	}
 	if _, err := exec.LookPath(tegraStatsCmd); err == nil {
-		caps.hasTegrastats = true
+		gm.tegrastats = true
+		gm.nvidiaSmi = false
 	}
 	if _, err := exec.LookPath(intelGpuStatsCmd); err == nil {
-		caps.hasIntelGpuTop = true
+		gm.intelGpuStats = true
 	}
-	if _, err := exec.LookPath(nvtopCmd); err == nil {
-		caps.hasNvtop = true
+	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats || gm.intelGpuStats {
+		return nil
 	}
-	if runtime.GOOS == "darwin" {
-		if _, err := exec.LookPath(macmonCmd); err == nil {
-			caps.hasMacmon = true
-		}
-		if _, err := exec.LookPath(powermetricsCmd); err == nil {
-			caps.hasPowermetrics = true
-		}
-	}
-	return caps
+	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, tegrastats, or intel_gpu_top")
 }

-func hasAnyGpuCollector(caps gpuCapabilities) bool {
-	return caps.hasNvidiaSmi || caps.hasRocmSmi || caps.hasAmdSysfs || caps.hasTegrastats || caps.hasIntelGpuTop || caps.hasNvtop || caps.hasMacmon || caps.hasPowermetrics
-}
-
-func (gm *GPUManager) startIntelCollector() {
-	go func() {
-		failures := 0
-		for {
-			if err := gm.collectIntelStats(); err != nil {
-				failures++
-				if failures > maxFailureRetries {
-					break
-				}
-				slog.Warn("Error collecting Intel GPU data; see https://beszel.dev/guide/gpu", "err", err)
-				time.Sleep(retryWaitTime)
-				continue
-			}
-		}
-	}()
-}
-
-func (gm *GPUManager) startNvidiaSmiCollector(intervalSeconds string) {
+// startCollector starts the appropriate GPU data collector based on the command
+func (gm *GPUManager) startCollector(command string) {
 	collector := gpuCollector{
-		name:    nvidiaSmiCmd,
+		name:    command,
 		bufSize: 10 * 1024,
-		cmdArgs: []string{
-			"-l", intervalSeconds,
+	}
+	switch command {
+	case intelGpuStatsCmd:
+		go func() {
+			failures := 0
+			for {
+				if err := gm.collectIntelStats(); err != nil {
+					failures++
+					if failures > maxFailureRetries {
+						break
+					}
+					slog.Warn("Error collecting Intel GPU data; see https://beszel.dev/guide/gpu", "err", err)
+					time.Sleep(retryWaitTime)
+					continue
+				}
+			}
+		}()
+	case nvidiaSmiCmd:
+		collector.cmdArgs = []string{
+			"-l", nvidiaSmiInterval,
 			"--query-gpu=index,name,temperature.gpu,memory.used,memory.total,utilization.gpu,power.draw",
 			"--format=csv,noheader,nounits",
-		},
-		parse: gm.parseNvidiaData,
-	}
-	go collector.start()
-}
-
-func (gm *GPUManager) startTegraStatsCollector(intervalMilliseconds string) {
-	collector := gpuCollector{
-		name:    tegraStatsCmd,
-		bufSize: 10 * 1024,
-		cmdArgs: []string{"--interval", intervalMilliseconds},
-		parse:   gm.getJetsonParser(),
-	}
-	go collector.start()
-}
-
-func (gm *GPUManager) startRocmSmiCollector(pollInterval time.Duration) {
-	collector := gpuCollector{
-		name:    rocmSmiCmd,
-		bufSize: 10 * 1024,
-		cmdArgs: []string{"--showid", "--showtemp", "--showuse", "--showpower", "--showproductname", "--showmeminfo", "vram", "--json"},
-		parse:   gm.parseAmdData,
-	}
-	go func() {
-		failures := 0
-		for {
-			if err := collector.collect(); err != nil {
-				failures++
-				if failures > maxFailureRetries {
-					break
+		}
+		collector.parse = gm.parseNvidiaData
+		go collector.start()
+	case tegraStatsCmd:
+		collector.cmdArgs = []string{"--interval", tegraStatsInterval}
+		collector.parse = gm.getJetsonParser()
+		go collector.start()
+	case rocmSmiCmd:
+		collector.cmdArgs = []string{"--showid", "--showtemp", "--showuse", "--showpower", "--showproductname", "--showmeminfo", "vram", "--json"}
+		collector.parse = gm.parseAmdData
+		go func() {
+			failures := 0
+			for {
+				if err := collector.collect(); err != nil {
+					failures++
+					if failures > maxFailureRetries {
+						break
+					}
+					slog.Warn("Error collecting AMD GPU data", "err", err)
 				}
-				slog.Warn("Error collecting AMD GPU data via rocm-smi", "err", err)
+				time.Sleep(rocmSmiInterval)
 			}
-			time.Sleep(pollInterval)
-		}
-	}()
-}
-
-func (gm *GPUManager) collectorDefinitions(caps gpuCapabilities) map[collectorSource]collectorDefinition {
-	return map[collectorSource]collectorDefinition{
-		collectorSourceNVML: {
-			group:     collectorGroupNvidia,
-			available: caps.hasNvidiaSmi,
-			start: func(_ func()) bool {
-				return gm.startNvmlCollector()
-			},
-		},
-		collectorSourceNvidiaSMI: {
-			group:     collectorGroupNvidia,
-			available: caps.hasNvidiaSmi,
-			start: func(_ func()) bool {
-				gm.startNvidiaSmiCollector("4") // seconds
-				return true
-			},
-		},
-		collectorSourceIntelGpuTop: {
-			group:     collectorGroupIntel,
-			available: caps.hasIntelGpuTop,
-			start: func(_ func()) bool {
-				gm.startIntelCollector()
-				return true
-			},
-		},
-		collectorSourceAmdSysfs: {
-			group:     collectorGroupAmd,
-			available: caps.hasAmdSysfs,
-			start: func(_ func()) bool {
-				return gm.startAmdSysfsCollector()
-			},
-		},
-		collectorSourceRocmSMI: {
-			group:              collectorGroupAmd,
-			available:          caps.hasRocmSmi,
-			deprecationWarning: "rocm-smi is deprecated and may be removed in a future release",
-			start: func(_ func()) bool {
-				gm.startRocmSmiCollector(4300 * time.Millisecond)
-				return true
-			},
-		},
-		collectorSourceNVTop: {
-			available: caps.hasNvtop,
-			start: func(onFailure func()) bool {
-				gm.startNvtopCollector("30", onFailure) // tens of milliseconds
-				return true
-			},
-		},
-		collectorSourceMacmon: {
-			group:     collectorGroupApple,
-			available: caps.hasMacmon,
-			start: func(_ func()) bool {
-				gm.startMacmonCollector()
-				return true
-			},
-		},
-		collectorSourcePowermetrics: {
-			group:     collectorGroupApple,
-			available: caps.hasPowermetrics,
-			start: func(_ func()) bool {
-				gm.startPowermetricsCollector()
-				return true
-			},
-		},
+		}()
 	}
 }

-// parseCollectorPriority parses GPU_COLLECTOR and returns valid ordered entries.
-func parseCollectorPriority(value string) []collectorSource {
-	parts := strings.Split(value, ",")
-	priorities := make([]collectorSource, 0, len(parts))
-	for _, raw := range parts {
-		name := collectorSource(strings.TrimSpace(strings.ToLower(raw)))
-		if !isValidCollectorSource(name) {
-			if name != "" {
-				slog.Warn("Ignoring unknown GPU collector", "collector", name)
-			}
-			continue
-		}
-		priorities = append(priorities, name)
-	}
-	return priorities
-}
-
-// startNvmlCollector initializes NVML and starts its polling loop.
-func (gm *GPUManager) startNvmlCollector() bool {
-	collector := &nvmlCollector{gm: gm}
-	if err := collector.init(); err != nil {
-		slog.Warn("Failed to initialize NVML", "err", err)
-		return false
-	}
-	go collector.start()
-	return true
-}
-
-// startAmdSysfsCollector starts AMD GPU collection via sysfs.
-func (gm *GPUManager) startAmdSysfsCollector() bool {
-	go func() {
-		if err := gm.collectAmdStats(); err != nil {
-			slog.Warn("Error collecting AMD GPU data via sysfs", "err", err)
-		}
-	}()
-	return true
-}
-
-// startCollectorsByPriority starts collectors in order with one source per vendor group.
-func (gm *GPUManager) startCollectorsByPriority(priorities []collectorSource, caps gpuCapabilities) int {
-	definitions := gm.collectorDefinitions(caps)
-	selectedGroups := make(map[string]bool, 3)
-	started := 0
-	for i, source := range priorities {
-		definition, ok := definitions[source]
-		if !ok || !definition.available {
-			continue
-		}
-		// nvtop is not a vendor-specific collector, so should only be used if no other collectors are selected or it is first in GPU_COLLECTOR.
-		if source == collectorSourceNVTop {
-			if len(selectedGroups) > 0 {
-				slog.Warn("Skipping nvtop because other collectors are selected")
-				continue
-			}
-			// if nvtop fails, fall back to remaining collectors.
-			remaining := append([]collectorSource(nil), priorities[i+1:]...)
-			if definition.start(func() {
-				gm.startCollectorsByPriority(remaining, caps)
-			}) {
-				started++
-				return started
-			}
-		}
-		group := definition.group
-		if group == "" || selectedGroups[group] {
-			continue
-		}
-		if definition.deprecationWarning != "" {
-			slog.Warn(definition.deprecationWarning)
-		}
-		if definition.start(nil) {
-			selectedGroups[group] = true
-			started++
-		}
-	}
-	return started
-}
-
-// resolveLegacyCollectorPriority builds the default collector order when GPU_COLLECTOR is unset.
-func (gm *GPUManager) resolveLegacyCollectorPriority(caps gpuCapabilities) []collectorSource {
-	priorities := make([]collectorSource, 0, 4)
-
-	if caps.hasNvidiaSmi && !caps.hasTegrastats {
-		if nvml, _ := GetEnv("NVML"); nvml == "true" {
-			priorities = append(priorities, collectorSourceNVML, collectorSourceNvidiaSMI)
-		} else {
-			priorities = append(priorities, collectorSourceNvidiaSMI)
-		}
-	}
-
-	if caps.hasRocmSmi {
-		if val, _ := GetEnv("AMD_SYSFS"); val == "true" {
-			priorities = append(priorities, collectorSourceAmdSysfs)
-		} else {
-			priorities = append(priorities, collectorSourceRocmSMI)
-		}
-	} else if caps.hasAmdSysfs {
-		priorities = append(priorities, collectorSourceAmdSysfs)
-	}
-
-	if caps.hasIntelGpuTop {
-		priorities = append(priorities, collectorSourceIntelGpuTop)
-	}
-
-	// Apple collectors are currently opt-in only for testing.
-	// Enable them with GPU_COLLECTOR=macmon or GPU_COLLECTOR=powermetrics.
-	// TODO: uncomment below when Apple collectors are confirmed to be working.
-	//
-	// Prefer macmon on macOS (no sudo). Fall back to powermetrics if present.
-	// if caps.hasMacmon {
-	// 	priorities = append(priorities, collectorSourceMacmon)
-	// } else if caps.hasPowermetrics {
-	// 	priorities = append(priorities, collectorSourcePowermetrics)
-	// }
-
-	// Keep nvtop as a last resort only when no vendor collector exists.
-	if len(priorities) == 0 && caps.hasNvtop {
-		priorities = append(priorities, collectorSourceNVTop)
-	}
-	return priorities
-}
-
 // NewGPUManager creates and initializes a new GPUManager
 func NewGPUManager() (*GPUManager, error) {
 	if skipGPU, _ := GetEnv("SKIP_GPU"); skipGPU == "true" {
 		return nil, nil
 	}
 	var gm GPUManager
-	caps := gm.discoverGpuCapabilities()
-	if !hasAnyGpuCollector(caps) {
-		return nil, fmt.Errorf(noGPUFoundMsg)
+	if err := gm.detectGPUs(); err != nil {
+		return nil, err
 	}
 	gm.GpuDataMap = make(map[string]*system.GPUData)

-	// Jetson devices should always use tegrastats (ignore GPU_COLLECTOR).
-	if caps.hasTegrastats {
-		gm.startTegraStatsCollector("3700")
-		return &gm, nil
+	if gm.nvidiaSmi {
+		gm.startCollector(nvidiaSmiCmd)
 	}
-
-	// if GPU_COLLECTOR is set, start user-defined collectors.
-	if collectorConfig, ok := GetEnv("GPU_COLLECTOR"); ok && strings.TrimSpace(collectorConfig) != "" {
-		priorities := parseCollectorPriority(collectorConfig)
-		if gm.startCollectorsByPriority(priorities, caps) == 0 {
-			return nil, fmt.Errorf("no configured GPU collectors are available")
-		}
-		return &gm, nil
+	if gm.rocmSmi {
+		gm.startCollector(rocmSmiCmd)
 	}
-
-	// auto-detect and start collectors when GPU_COLLECTOR is unset.
-	if gm.startCollectorsByPriority(gm.resolveLegacyCollectorPriority(caps), caps) == 0 {
-		return nil, fmt.Errorf(noGPUFoundMsg)
+	if gm.tegrastats {
+		gm.startCollector(tegraStatsCmd)
+	}
+	if gm.intelGpuStats {
+		gm.startCollector(intelGpuStatsCmd)
 	}

 	return &gm, nil
--- a/agent/gpu_amd_linux.go
+++ b/agent/gpu_amd_linux.go
@@ -1,302 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"bufio"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-var amdgpuNameCache = struct {
-	sync.RWMutex
-	hits   map[string]string
-	misses map[string]struct{}
-}{
-	hits:   make(map[string]string),
-	misses: make(map[string]struct{}),
-}
-
-// hasAmdSysfs returns true if any AMD GPU sysfs nodes are found
-func (gm *GPUManager) hasAmdSysfs() bool {
-	cards, err := filepath.Glob("/sys/class/drm/card*/device/vendor")
-	if err != nil {
-		return false
-	}
-	for _, vendorPath := range cards {
-		vendor, err := os.ReadFile(vendorPath)
-		if err == nil && strings.TrimSpace(string(vendor)) == "0x1002" {
-			return true
-		}
-	}
-	return false
-}
-
-// collectAmdStats collects AMD GPU metrics directly from sysfs to avoid the overhead of rocm-smi
-func (gm *GPUManager) collectAmdStats() error {
-	sysfsPollInterval := 3000 * time.Millisecond
-	cards, err := filepath.Glob("/sys/class/drm/card*")
-	if err != nil {
-		return err
-	}
-
-	var amdGpuPaths []string
-	for _, card := range cards {
-		// Ignore symbolic links and non-main card directories
-		if strings.Contains(filepath.Base(card), "-") || !isAmdGpu(card) {
-			continue
-		}
-		amdGpuPaths = append(amdGpuPaths, card)
-	}
-
-	if len(amdGpuPaths) == 0 {
-		return errNoValidData
-	}
-
-	slog.Debug("Using sysfs for AMD GPU data collection")
-
-	failures := 0
-	for {
-		hasData := false
-		for _, cardPath := range amdGpuPaths {
-			if gm.updateAmdGpuData(cardPath) {
-				hasData = true
-			}
-		}
-		if !hasData {
-			failures++
-			if failures > maxFailureRetries {
-				return errNoValidData
-			}
-			slog.Warn("No AMD GPU data from sysfs", "failures", failures)
-			time.Sleep(retryWaitTime)
-			continue
-		}
-		failures = 0
-		time.Sleep(sysfsPollInterval)
-	}
-}
-
-// isAmdGpu checks whether a DRM card path belongs to AMD vendor ID 0x1002.
-func isAmdGpu(cardPath string) bool {
-	vendorPath := filepath.Join(cardPath, "device/vendor")
-	vendor, err := os.ReadFile(vendorPath)
-	if err != nil {
-		return false
-	}
-	return strings.TrimSpace(string(vendor)) == "0x1002"
-}
-
-// updateAmdGpuData reads GPU metrics from sysfs and updates the GPU data map.
-// Returns true if at least some data was successfully read.
-func (gm *GPUManager) updateAmdGpuData(cardPath string) bool {
-	devicePath := filepath.Join(cardPath, "device")
-	id := filepath.Base(cardPath)
-
-	// Read all sysfs values first (no lock needed - these can be slow)
-	usage, usageErr := readSysfsFloat(filepath.Join(devicePath, "gpu_busy_percent"))
-	memUsed, memUsedErr := readSysfsFloat(filepath.Join(devicePath, "mem_info_vram_used"))
-	memTotal, _ := readSysfsFloat(filepath.Join(devicePath, "mem_info_vram_total"))
-	// if gtt is present, add it to the memory used and total (https://github.com/henrygd/beszel/issues/1569#issuecomment-3837640484)
-	if gttUsed, err := readSysfsFloat(filepath.Join(devicePath, "mem_info_gtt_used")); err == nil && gttUsed > 0 {
-		if gttTotal, err := readSysfsFloat(filepath.Join(devicePath, "mem_info_gtt_total")); err == nil {
-			memUsed += gttUsed
-			memTotal += gttTotal
-		}
-	}
-
-	var temp, power float64
-	hwmons, _ := filepath.Glob(filepath.Join(devicePath, "hwmon/hwmon*"))
-	for _, hwmonDir := range hwmons {
-		if t, err := readSysfsFloat(filepath.Join(hwmonDir, "temp1_input")); err == nil {
-			temp = t / 1000.0
-		}
-		if p, err := readSysfsFloat(filepath.Join(hwmonDir, "power1_average")); err == nil {
-			power += p / 1000000.0
-		} else if p, err := readSysfsFloat(filepath.Join(hwmonDir, "power1_input")); err == nil {
-			power += p / 1000000.0
-		}
-	}
-
-	// Check if we got any meaningful data
-	if usageErr != nil && memUsedErr != nil && temp == 0 {
-		return false
-	}
-
-	// Single lock to update all values atomically
-	gm.Lock()
-	defer gm.Unlock()
-
-	gpu, ok := gm.GpuDataMap[id]
-	if !ok {
-		gpu = &system.GPUData{Name: getAmdGpuName(devicePath)}
-		gm.GpuDataMap[id] = gpu
-	}
-
-	if usageErr == nil {
-		gpu.Usage += usage
-	}
-	gpu.MemoryUsed = bytesToMegabytes(memUsed)
-	gpu.MemoryTotal = bytesToMegabytes(memTotal)
-	gpu.Temperature = temp
-	gpu.Power += power
-	gpu.Count++
-	return true
-}
-
-// readSysfsFloat reads and parses a numeric value from a sysfs file.
-func readSysfsFloat(path string) (float64, error) {
-	val, err := os.ReadFile(path)
-	if err != nil {
-		return 0, err
-	}
-	return strconv.ParseFloat(strings.TrimSpace(string(val)), 64)
-}
-
-// normalizeHexID normalizes hex IDs by trimming spaces, lowercasing, and dropping 0x.
-func normalizeHexID(id string) string {
-	return strings.TrimPrefix(strings.ToLower(strings.TrimSpace(id)), "0x")
-}
-
-// cacheKeyForAmdgpu builds the cache key for a device and optional revision.
-func cacheKeyForAmdgpu(deviceID, revisionID string) string {
-	if revisionID != "" {
-		return deviceID + ":" + revisionID
-	}
-	return deviceID
-}
-
-// lookupAmdgpuNameInFile resolves an AMDGPU name from amdgpu.ids by device/revision.
-func lookupAmdgpuNameInFile(deviceID, revisionID, filePath string) (name string, exact bool, found bool) {
-	file, err := os.Open(filePath)
-	if err != nil {
-		return "", false, false
-	}
-	defer file.Close()
-
-	var byDevice string
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		parts := strings.SplitN(line, ",", 3)
-		if len(parts) != 3 {
-			continue
-		}
-
-		dev := normalizeHexID(parts[0])
-		rev := normalizeHexID(parts[1])
-		productName := strings.TrimSpace(parts[2])
-		if dev == "" || productName == "" || dev != deviceID {
-			continue
-		}
-		if byDevice == "" {
-			byDevice = productName
-		}
-		if revisionID != "" && rev == revisionID {
-			return productName, true, true
-		}
-	}
-	if byDevice != "" {
-		return byDevice, false, true
-	}
-	return "", false, false
-}
-
-// getCachedAmdgpuName returns cached hit/miss status for the given device/revision.
-func getCachedAmdgpuName(deviceID, revisionID string) (name string, found bool, done bool) {
-	// Build the list of cache keys to check. We always look up the exact device+revision key.
-	// When revisionID is set, we also look up deviceID alone, since the cache may store a
-	// device-only fallback when we couldn't resolve the exact revision.
-	keys := []string{cacheKeyForAmdgpu(deviceID, revisionID)}
-	if revisionID != "" {
-		keys = append(keys, deviceID)
-	}
-
-	knownMisses := 0
-	amdgpuNameCache.RLock()
-	defer amdgpuNameCache.RUnlock()
-	for _, key := range keys {
-		if name, ok := amdgpuNameCache.hits[key]; ok {
-			return name, true, true
-		}
-		if _, ok := amdgpuNameCache.misses[key]; ok {
-			knownMisses++
-		}
-	}
-	// done=true means "don't bother doing slow lookup": we either found a name (above) or
-	// every key we checked was already a known miss, so we've tried before and failed.
-	return "", false, knownMisses == len(keys)
-}
-
-// normalizeAmdgpuName trims standard suffixes from AMDGPU product names.
-func normalizeAmdgpuName(name string) string {
-	for _, suffix := range []string{" Graphics", " Series"} {
-		name = strings.TrimSuffix(name, suffix)
-	}
-	return name
-}
-
-// cacheAmdgpuName stores a resolved AMDGPU name in the lookup cache.
-func cacheAmdgpuName(deviceID, revisionID, name string, exact bool) {
-	name = normalizeAmdgpuName(name)
-	amdgpuNameCache.Lock()
-	defer amdgpuNameCache.Unlock()
-	if exact && revisionID != "" {
-		amdgpuNameCache.hits[cacheKeyForAmdgpu(deviceID, revisionID)] = name
-	}
-	amdgpuNameCache.hits[deviceID] = name
-}
-
-// cacheMissingAmdgpuName records unresolved device/revision lookups.
-func cacheMissingAmdgpuName(deviceID, revisionID string) {
-	amdgpuNameCache.Lock()
-	defer amdgpuNameCache.Unlock()
-	amdgpuNameCache.misses[deviceID] = struct{}{}
-	if revisionID != "" {
-		amdgpuNameCache.misses[cacheKeyForAmdgpu(deviceID, revisionID)] = struct{}{}
-	}
-}
-
-// getAmdGpuName attempts to get a descriptive GPU name.
-// First tries product_name (rarely available), then looks up the PCI device ID.
-// Falls back to showing the raw device ID if not found in the lookup table.
-func getAmdGpuName(devicePath string) string {
-	// Try product_name first (works for some enterprise GPUs)
-	if prod, err := os.ReadFile(filepath.Join(devicePath, "product_name")); err == nil {
-		return strings.TrimSpace(string(prod))
-	}
-
-	// Read PCI device ID and look it up
-	if deviceID, err := os.ReadFile(filepath.Join(devicePath, "device")); err == nil {
-		id := normalizeHexID(string(deviceID))
-		revision := ""
-		if revBytes, revErr := os.ReadFile(filepath.Join(devicePath, "revision")); revErr == nil {
-			revision = normalizeHexID(string(revBytes))
-		}
-
-		if name, found, done := getCachedAmdgpuName(id, revision); found {
-			return name
-		} else if !done {
-			if name, exact, ok := lookupAmdgpuNameInFile(id, revision, "/usr/share/libdrm/amdgpu.ids"); ok {
-				cacheAmdgpuName(id, revision, name, exact)
-				return normalizeAmdgpuName(name)
-			}
-			cacheMissingAmdgpuName(id, revision)
-		}
-
-		return fmt.Sprintf("AMD GPU (%s)", id)
-	}
-
-	return "AMD GPU"
-}
--- a/agent/gpu_amd_linux_test.go
+++ b/agent/gpu_amd_linux_test.go
@@ -1,264 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNormalizeHexID(t *testing.T) {
-	tests := []struct {
-		in   string
-		want string
-	}{
-		{"0x1002", "1002"},
-		{"C2", "c2"},
-		{"  15BF  ", "15bf"},
-		{"0x15bf", "15bf"},
-		{"", ""},
-	}
-	for _, tt := range tests {
-		subName := tt.in
-		if subName == "" {
-			subName = "empty_string"
-		}
-		t.Run(subName, func(t *testing.T) {
-			got := normalizeHexID(tt.in)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestCacheKeyForAmdgpu(t *testing.T) {
-	tests := []struct {
-		deviceID   string
-		revisionID string
-		want       string
-	}{
-		{"1114", "c2", "1114:c2"},
-		{"15bf", "", "15bf"},
-		{"1506", "c1", "1506:c1"},
-	}
-	for _, tt := range tests {
-		got := cacheKeyForAmdgpu(tt.deviceID, tt.revisionID)
-		assert.Equal(t, tt.want, got)
-	}
-}
-
-func TestReadSysfsFloat(t *testing.T) {
-	dir := t.TempDir()
-
-	validPath := filepath.Join(dir, "val")
-	require.NoError(t, os.WriteFile(validPath, []byte("  42.5  \n"), 0o644))
-	got, err := readSysfsFloat(validPath)
-	require.NoError(t, err)
-	assert.Equal(t, 42.5, got)
-
-	// Integer and scientific
-	sciPath := filepath.Join(dir, "sci")
-	require.NoError(t, os.WriteFile(sciPath, []byte("1e2"), 0o644))
-	got, err = readSysfsFloat(sciPath)
-	require.NoError(t, err)
-	assert.Equal(t, 100.0, got)
-
-	// Missing file
-	_, err = readSysfsFloat(filepath.Join(dir, "missing"))
-	require.Error(t, err)
-
-	// Invalid content
-	badPath := filepath.Join(dir, "bad")
-	require.NoError(t, os.WriteFile(badPath, []byte("not a number"), 0o644))
-	_, err = readSysfsFloat(badPath)
-	require.Error(t, err)
-}
-
-func TestIsAmdGpu(t *testing.T) {
-	dir := t.TempDir()
-	deviceDir := filepath.Join(dir, "device")
-	require.NoError(t, os.MkdirAll(deviceDir, 0o755))
-
-	// AMD vendor 0x1002 -> true
-	require.NoError(t, os.WriteFile(filepath.Join(deviceDir, "vendor"), []byte("0x1002\n"), 0o644))
-	assert.True(t, isAmdGpu(dir), "vendor 0x1002 should be AMD")
-
-	// Non-AMD vendor -> false
-	require.NoError(t, os.WriteFile(filepath.Join(deviceDir, "vendor"), []byte("0x10de\n"), 0o644))
-	assert.False(t, isAmdGpu(dir), "vendor 0x10de should not be AMD")
-
-	// Missing vendor file -> false
-	require.NoError(t, os.Remove(filepath.Join(deviceDir, "vendor")))
-	assert.False(t, isAmdGpu(dir), "missing vendor file should be false")
-}
-
-func TestAmdgpuNameCacheRoundTrip(t *testing.T) {
-	// Cache a name and retrieve it (unique key to avoid affecting other tests)
-	deviceID, revisionID := "cachedev99", "00"
-	cacheAmdgpuName(deviceID, revisionID, "AMD Test GPU 99 Graphics", true)
-
-	name, found, done := getCachedAmdgpuName(deviceID, revisionID)
-	assert.True(t, found)
-	assert.True(t, done)
-	assert.Equal(t, "AMD Test GPU 99", name)
-
-	// Device-only key also stored
-	name2, found2, _ := getCachedAmdgpuName(deviceID, "")
-	assert.True(t, found2)
-	assert.Equal(t, "AMD Test GPU 99", name2)
-
-	// Cache a miss
-	cacheMissingAmdgpuName("missedev99", "ab")
-	_, found3, done3 := getCachedAmdgpuName("missedev99", "ab")
-	assert.False(t, found3)
-	assert.True(t, done3, "done should be true so caller skips file lookup")
-}
-
-func TestUpdateAmdGpuDataWithFakeSysfs(t *testing.T) {
-	tests := []struct {
-		name            string
-		writeGTT        bool
-		wantMemoryUsed  float64
-		wantMemoryTotal float64
-	}{
-		{
-			name:            "sums vram and gtt when gtt is present",
-			writeGTT:        true,
-			wantMemoryUsed:  bytesToMegabytes(1073741824 + 536870912),
-			wantMemoryTotal: bytesToMegabytes(2147483648 + 4294967296),
-		},
-		{
-			name:            "falls back to vram when gtt is missing",
-			writeGTT:        false,
-			wantMemoryUsed:  bytesToMegabytes(1073741824),
-			wantMemoryTotal: bytesToMegabytes(2147483648),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			dir := t.TempDir()
-			cardPath := filepath.Join(dir, "card0")
-			devicePath := filepath.Join(cardPath, "device")
-			hwmonPath := filepath.Join(devicePath, "hwmon", "hwmon0")
-			require.NoError(t, os.MkdirAll(hwmonPath, 0o755))
-
-			write := func(name, content string) {
-				require.NoError(t, os.WriteFile(filepath.Join(devicePath, name), []byte(content), 0o644))
-			}
-			write("vendor", "0x1002")
-			write("device", "0x1506")
-			write("revision", "0xc1")
-			write("gpu_busy_percent", "25")
-			write("mem_info_vram_used", "1073741824")
-			write("mem_info_vram_total", "2147483648")
-			if tt.writeGTT {
-				write("mem_info_gtt_used", "536870912")
-				write("mem_info_gtt_total", "4294967296")
-			}
-			require.NoError(t, os.WriteFile(filepath.Join(hwmonPath, "temp1_input"), []byte("45000"), 0o644))
-			require.NoError(t, os.WriteFile(filepath.Join(hwmonPath, "power1_input"), []byte("20000000"), 0o644))
-
-			// Pre-cache name so getAmdGpuName returns a known value (it uses system amdgpu.ids path)
-			cacheAmdgpuName("1506", "c1", "AMD Radeon 610M Graphics", true)
-
-			gm := &GPUManager{GpuDataMap: make(map[string]*system.GPUData)}
-			ok := gm.updateAmdGpuData(cardPath)
-			require.True(t, ok)
-
-			gpu, ok := gm.GpuDataMap["card0"]
-			require.True(t, ok)
-			assert.Equal(t, "AMD Radeon 610M", gpu.Name)
-			assert.Equal(t, 25.0, gpu.Usage)
-			assert.Equal(t, tt.wantMemoryUsed, gpu.MemoryUsed)
-			assert.Equal(t, tt.wantMemoryTotal, gpu.MemoryTotal)
-			assert.Equal(t, 45.0, gpu.Temperature)
-			assert.Equal(t, 20.0, gpu.Power)
-			assert.Equal(t, 1.0, gpu.Count)
-		})
-	}
-}
-
-func TestLookupAmdgpuNameInFile(t *testing.T) {
-	idsPath := filepath.Join("test-data", "amdgpu.ids")
-
-	tests := []struct {
-		name       string
-		deviceID   string
-		revisionID string
-		wantName   string
-		wantExact  bool
-		wantFound  bool
-	}{
-		{
-			name:       "exact device and revision match",
-			deviceID:   "1114",
-			revisionID: "c2",
-			wantName:   "AMD Radeon 860M Graphics",
-			wantExact:  true,
-			wantFound:  true,
-		},
-		{
-			name:       "exact match 15BF revision 01 returns 760M",
-			deviceID:   "15bf",
-			revisionID: "01",
-			wantName:   "AMD Radeon 760M Graphics",
-			wantExact:  true,
-			wantFound:  true,
-		},
-		{
-			name:       "exact match 15BF revision 00 returns 780M",
-			deviceID:   "15bf",
-			revisionID: "00",
-			wantName:   "AMD Radeon 780M Graphics",
-			wantExact:  true,
-			wantFound:  true,
-		},
-		{
-			name:       "device-only match returns first entry for device",
-			deviceID:   "1506",
-			revisionID: "",
-			wantName:   "AMD Radeon 610M",
-			wantExact:  false,
-			wantFound:  true,
-		},
-		{
-			name:       "unknown device not found",
-			deviceID:   "dead",
-			revisionID: "00",
-			wantName:   "",
-			wantExact:  false,
-			wantFound:  false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotName, gotExact, gotFound := lookupAmdgpuNameInFile(tt.deviceID, tt.revisionID, idsPath)
-			assert.Equal(t, tt.wantName, gotName, "name")
-			assert.Equal(t, tt.wantExact, gotExact, "exact")
-			assert.Equal(t, tt.wantFound, gotFound, "found")
-		})
-	}
-}
-
-func TestGetAmdGpuNameFromIdsFile(t *testing.T) {
-	// Test that getAmdGpuName resolves a name when we can't inject the ids path.
-	// We only verify behavior when product_name is missing and device/revision
-	// would be read from sysfs; the actual lookup uses /usr/share/libdrm/amdgpu.ids.
-	// So this test focuses on normalizeAmdgpuName and that lookupAmdgpuNameInFile
-	// returns the expected name for our test-data file.
-	idsPath := filepath.Join("test-data", "amdgpu.ids")
-	name, exact, found := lookupAmdgpuNameInFile("1435", "ae", idsPath)
-	require.True(t, found)
-	require.True(t, exact)
-	assert.Equal(t, "AMD Custom GPU 0932", name)
-	assert.Equal(t, "AMD Custom GPU 0932", normalizeAmdgpuName(name))
-
-	// " Graphics" suffix is trimmed by normalizeAmdgpuName
-	name2 := "AMD Radeon 860M Graphics"
-	assert.Equal(t, "AMD Radeon 860M", normalizeAmdgpuName(name2))
-}
--- a/agent/gpu_amd_unsupported.go
+++ b/agent/gpu_amd_unsupported.go
@@ -1,15 +0,0 @@
-//go:build !linux
-
-package agent
-
-import (
-	"errors"
-)
-
-func (gm *GPUManager) hasAmdSysfs() bool {
-	return false
-}
-
-func (gm *GPUManager) collectAmdStats() error {
-	return errors.ErrUnsupported
-}
--- a/agent/gpu_darwin.go
+++ b/agent/gpu_darwin.go
@@ -1,252 +0,0 @@
-//go:build darwin
-
-package agent
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"io"
-	"log/slog"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-const (
-	// powermetricsSampleIntervalMs is the sampling interval passed to powermetrics (-i).
-	powermetricsSampleIntervalMs = 500
-	// powermetricsPollInterval is how often we run powermetrics to collect a new sample.
-	powermetricsPollInterval = 2 * time.Second
-	// macmonIntervalMs is the sampling interval passed to macmon pipe (-i), in milliseconds.
-	macmonIntervalMs = 2500
-)
-
-const appleGPUID = "0"
-
-// startPowermetricsCollector runs powermetrics --samplers gpu_power in a loop and updates
-// GPU usage and power. Requires root (sudo) on macOS. A single logical GPU is reported as id "0".
-func (gm *GPUManager) startPowermetricsCollector() {
-	// Ensure single GPU entry for Apple GPU
-	if _, ok := gm.GpuDataMap[appleGPUID]; !ok {
-		gm.GpuDataMap[appleGPUID] = &system.GPUData{Name: "Apple GPU"}
-	}
-
-	go func() {
-		failures := 0
-		for {
-			if err := gm.collectPowermetrics(); err != nil {
-				failures++
-				if failures > maxFailureRetries {
-					slog.Warn("powermetrics GPU collector failed repeatedly, stopping", "err", err)
-					break
-				}
-				slog.Warn("Error collecting macOS GPU data via powermetrics (may require sudo)", "err", err)
-				time.Sleep(retryWaitTime)
-				continue
-			}
-			failures = 0
-			time.Sleep(powermetricsPollInterval)
-		}
-	}()
-}
-
-// collectPowermetrics runs powermetrics once and parses GPU usage and power from its output.
-func (gm *GPUManager) collectPowermetrics() error {
-	interval := strconv.Itoa(powermetricsSampleIntervalMs)
-	cmd := exec.Command(powermetricsCmd, "--samplers", "gpu_power", "-i", interval, "-n", "1")
-	cmd.Stderr = nil
-	out, err := cmd.Output()
-	if err != nil {
-		return err
-	}
-	if !gm.parsePowermetricsData(out) {
-		return errNoValidData
-	}
-	return nil
-}
-
-// parsePowermetricsData parses powermetrics gpu_power output and updates GpuDataMap["0"].
-// Example output:
-//
-//	**** GPU usage ****
-//	GPU HW active frequency: 444 MHz
-//	GPU HW active residency:   0.97% (444 MHz: .97% ...
-//	GPU idle residency:  99.03%
-//	GPU Power: 4 mW
-func (gm *GPUManager) parsePowermetricsData(output []byte) bool {
-	var idleResidency, powerMW float64
-	var gotIdle, gotPower bool
-
-	scanner := bufio.NewScanner(bytes.NewReader(output))
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if strings.HasPrefix(line, "GPU idle residency:") {
-			// "GPU idle residency:  99.03%"
-			fields := strings.Fields(strings.TrimPrefix(line, "GPU idle residency:"))
-			if len(fields) >= 1 {
-				pct := strings.TrimSuffix(fields[0], "%")
-				if v, err := strconv.ParseFloat(pct, 64); err == nil {
-					idleResidency = v
-					gotIdle = true
-				}
-			}
-		} else if strings.HasPrefix(line, "GPU Power:") {
-			// "GPU Power: 4 mW"
-			fields := strings.Fields(strings.TrimPrefix(line, "GPU Power:"))
-			if len(fields) >= 1 {
-				if v, err := strconv.ParseFloat(fields[0], 64); err == nil {
-					powerMW = v
-					gotPower = true
-				}
-			}
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return false
-	}
-	if !gotIdle && !gotPower {
-		return false
-	}
-
-	gm.Lock()
-	defer gm.Unlock()
-
-	if _, ok := gm.GpuDataMap[appleGPUID]; !ok {
-		gm.GpuDataMap[appleGPUID] = &system.GPUData{Name: "Apple GPU"}
-	}
-	gpu := gm.GpuDataMap[appleGPUID]
-
-	if gotIdle {
-		// Usage = 100 - idle residency (e.g. 100 - 99.03 = 0.97%)
-		gpu.Usage += 100 - idleResidency
-	}
-	if gotPower {
-		// mW -> W
-		gpu.Power += powerMW / milliwattsInAWatt
-	}
-	gpu.Count++
-	return true
-}
-
-// startMacmonCollector runs `macmon pipe` in a loop and parses one JSON object per line.
-// This collector does not require sudo. A single logical GPU is reported as id "0".
-func (gm *GPUManager) startMacmonCollector() {
-	if _, ok := gm.GpuDataMap[appleGPUID]; !ok {
-		gm.GpuDataMap[appleGPUID] = &system.GPUData{Name: "Apple GPU"}
-	}
-
-	go func() {
-		failures := 0
-		for {
-			if err := gm.collectMacmonPipe(); err != nil {
-				failures++
-				if failures > maxFailureRetries {
-					slog.Warn("macmon GPU collector failed repeatedly, stopping", "err", err)
-					break
-				}
-				slog.Warn("Error collecting macOS GPU data via macmon", "err", err)
-				time.Sleep(retryWaitTime)
-				continue
-			}
-			failures = 0
-			// `macmon pipe` is long-running; if it returns, wait a bit before restarting.
-			time.Sleep(retryWaitTime)
-		}
-	}()
-}
-
-type macmonTemp struct {
-	GPUTempAvg float64 `json:"gpu_temp_avg"`
-}
-
-type macmonSample struct {
-	GPUPower    float64    `json:"gpu_power"`     // watts (macmon reports fractional values)
-	GPURAMPower float64    `json:"gpu_ram_power"` // watts
-	GPUUsage    []float64  `json:"gpu_usage"`     // [freq_mhz, usage] where usage is typically 0..1
-	Temp        macmonTemp `json:"temp"`
-}
-
-func (gm *GPUManager) collectMacmonPipe() (err error) {
-	cmd := exec.Command(macmonCmd, "pipe", "-i", strconv.Itoa(macmonIntervalMs))
-	// Avoid blocking if macmon writes to stderr.
-	cmd.Stderr = io.Discard
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	// Ensure we always reap the child to avoid zombies on any return path and
-	// propagate a non-zero exit code if no other error was set.
-	defer func() {
-		_ = stdout.Close()
-		if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
-			_ = cmd.Process.Kill()
-		}
-		if waitErr := cmd.Wait(); err == nil && waitErr != nil {
-			err = waitErr
-		}
-	}()
-
-	scanner := bufio.NewScanner(stdout)
-	var hadSample bool
-	for scanner.Scan() {
-		line := bytes.TrimSpace(scanner.Bytes())
-		if len(line) == 0 {
-			continue
-		}
-		if gm.parseMacmonLine(line) {
-			hadSample = true
-		}
-	}
-	if scanErr := scanner.Err(); scanErr != nil {
-		return scanErr
-	}
-	if !hadSample {
-		return errNoValidData
-	}
-	return nil
-}
-
-// parseMacmonLine parses a single macmon JSON line and updates Apple GPU metrics.
-func (gm *GPUManager) parseMacmonLine(line []byte) bool {
-	var sample macmonSample
-	if err := json.Unmarshal(line, &sample); err != nil {
-		return false
-	}
-
-	usage := 0.0
-	if len(sample.GPUUsage) >= 2 {
-		usage = sample.GPUUsage[1]
-		// Heuristic: macmon typically reports 0..1; convert to percentage.
-		if usage <= 1.0 {
-			usage *= 100
-		}
-	}
-
-	// Consider the line valid if it contains at least one GPU metric.
-	if usage == 0 && sample.GPUPower == 0 && sample.Temp.GPUTempAvg == 0 {
-		return false
-	}
-
-	gm.Lock()
-	defer gm.Unlock()
-
-	gpu, ok := gm.GpuDataMap[appleGPUID]
-	if !ok {
-		gpu = &system.GPUData{Name: "Apple GPU"}
-		gm.GpuDataMap[appleGPUID] = gpu
-	}
-	gpu.Temperature = sample.Temp.GPUTempAvg
-	gpu.Usage += usage
-	// macmon reports power in watts; include VRAM power if present.
-	gpu.Power += sample.GPUPower + sample.GPURAMPower
-	gpu.Count++
-	return true
-}
--- a/agent/gpu_darwin_test.go
+++ b/agent/gpu_darwin_test.go
@@ -1,81 +0,0 @@
-//go:build darwin
-
-package agent
-
-import (
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestParsePowermetricsData(t *testing.T) {
-	input := `
-Machine model: Mac14,10
-OS version: 25D125
-
-*** Sampled system activity (Sat Feb 14 00:42:06 2026 -0500) (503.05ms elapsed) ***
-
-**** GPU usage ****
-
-GPU HW active frequency: 444 MHz
-GPU HW active residency:   0.97% (444 MHz: .97% 612 MHz:   0% 808 MHz:   0% 968 MHz:   0% 1110 MHz:   0% 1236 MHz:   0% 1338 MHz:   0% 1398 MHz:   0%)
-GPU SW requested state: (P1 : 100% P2 :   0% P3 :   0% P4 :   0% P5 :   0% P6 :   0% P7 :   0% P8 :   0%)
-GPU idle residency:  99.03%
-GPU Power: 4 mW
-`
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-	valid := gm.parsePowermetricsData([]byte(input))
-	require.True(t, valid)
-
-	g0, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "Apple GPU", g0.Name)
-	// Usage = 100 - 99.03 = 0.97
-	assert.InDelta(t, 0.97, g0.Usage, 0.01)
-	// 4 mW -> 0.004 W
-	assert.InDelta(t, 0.004, g0.Power, 0.0001)
-	assert.Equal(t, 1.0, g0.Count)
-}
-
-func TestParsePowermetricsDataPartial(t *testing.T) {
-	// Only power line (e.g. older macOS or different sampler output)
-	input := `
-**** GPU usage ****
-GPU Power: 120 mW
-`
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-	valid := gm.parsePowermetricsData([]byte(input))
-	require.True(t, valid)
-
-	g0, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "Apple GPU", g0.Name)
-	assert.InDelta(t, 0.12, g0.Power, 0.001)
-	assert.Equal(t, 1.0, g0.Count)
-}
-
-func TestParseMacmonLine(t *testing.T) {
-	input := `{"all_power":0.6468324661254883,"ane_power":0.0,"cpu_power":0.6359732151031494,"ecpu_usage":[2061,0.1726151406764984],"gpu_power":0.010859241709113121,"gpu_ram_power":0.000965250947047025,"gpu_usage":[503,0.013633215799927711],"memory":{"ram_total":17179869184,"ram_usage":12322914304,"swap_total":0,"swap_usage":0},"pcpu_usage":[1248,0.11792058497667313],"ram_power":0.14885640144348145,"sys_power":10.4955415725708,"temp":{"cpu_temp_avg":23.041261672973633,"gpu_temp_avg":29.44516944885254},"timestamp":"2026-02-17T19:34:27.942556+00:00"}`
-
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-	valid := gm.parseMacmonLine([]byte(input))
-	require.True(t, valid)
-
-	g0, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "Apple GPU", g0.Name)
-	// macmon reports usage fraction 0..1; expect percent conversion.
-	assert.InDelta(t, 1.3633, g0.Usage, 0.05)
-	// power includes gpu_power + gpu_ram_power
-	assert.InDelta(t, 0.011824, g0.Power, 0.0005)
-	assert.InDelta(t, 29.445, g0.Temperature, 0.01)
-	assert.Equal(t, 1.0, g0.Count)
-}
--- a/agent/gpu_darwin_unsupported.go
+++ b/agent/gpu_darwin_unsupported.go
@@ -1,9 +0,0 @@
-//go:build !darwin
-
-package agent
-
-// startPowermetricsCollector is a no-op on non-darwin platforms; the real implementation is in gpu_darwin.go.
-func (gm *GPUManager) startPowermetricsCollector() {}
-
-// startMacmonCollector is a no-op on non-darwin platforms; the real implementation is in gpu_darwin.go.
-func (gm *GPUManager) startMacmonCollector() {}
--- a/agent/gpu_intel.go
+++ b/agent/gpu_intel.go
@@ -27,11 +27,10 @@ func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {
 	defer gm.Unlock()

 	// only one gpu for now - cmd doesn't provide all by default
-	id := "i0" // prefix with i to avoid conflicts with nvidia card ids
-	gpuData, ok := gm.GpuDataMap[id]
+	gpuData, ok := gm.GpuDataMap["0"]
 	if !ok {
 		gpuData = &system.GPUData{Name: "GPU", Engines: make(map[string]float64)}
-		gm.GpuDataMap[id] = gpuData
+		gm.GpuDataMap["0"] = gpuData
 	}

 	gpuData.Power += sample.PowerGPU
--- a/agent/gpu_nvml.go
+++ b/agent/gpu_nvml.go
@@ -1,224 +0,0 @@
-//go:build amd64 && (windows || (linux && glibc))
-
-package agent
-
-import (
-	"fmt"
-	"log/slog"
-	"strings"
-	"time"
-	"unsafe"
-
-	"github.com/ebitengine/purego"
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-// NVML constants and types
-const (
-	nvmlSuccess int = 0
-)
-
-type nvmlDevice uintptr
-
-type nvmlReturn int
-
-type nvmlMemoryV1 struct {
-	Total uint64
-	Free  uint64
-	Used  uint64
-}
-
-type nvmlMemoryV2 struct {
-	Version  uint32
-	Total    uint64
-	Reserved uint64
-	Free     uint64
-	Used     uint64
-}
-
-type nvmlUtilization struct {
-	Gpu    uint32
-	Memory uint32
-}
-
-type nvmlPciInfo struct {
-	BusId          [16]byte
-	Domain         uint32
-	Bus            uint32
-	Device         uint32
-	PciDeviceId    uint32
-	PciSubSystemId uint32
-}
-
-// NVML function signatures
-var (
-	nvmlInit                      func() nvmlReturn
-	nvmlShutdown                  func() nvmlReturn
-	nvmlDeviceGetCount            func(count *uint32) nvmlReturn
-	nvmlDeviceGetHandleByIndex    func(index uint32, device *nvmlDevice) nvmlReturn
-	nvmlDeviceGetName             func(device nvmlDevice, name *byte, length uint32) nvmlReturn
-	nvmlDeviceGetMemoryInfo       func(device nvmlDevice, memory uintptr) nvmlReturn
-	nvmlDeviceGetUtilizationRates func(device nvmlDevice, utilization *nvmlUtilization) nvmlReturn
-	nvmlDeviceGetTemperature      func(device nvmlDevice, sensorType int, temp *uint32) nvmlReturn
-	nvmlDeviceGetPowerUsage       func(device nvmlDevice, power *uint32) nvmlReturn
-	nvmlDeviceGetPciInfo          func(device nvmlDevice, pci *nvmlPciInfo) nvmlReturn
-	nvmlErrorString               func(result nvmlReturn) string
-)
-
-type nvmlCollector struct {
-	gm      *GPUManager
-	lib     uintptr
-	devices []nvmlDevice
-	bdfs    []string
-	isV2    bool
-}
-
-func (c *nvmlCollector) init() error {
-	slog.Debug("NVML: Initializing")
-	libPath := getNVMLPath()
-
-	lib, err := openLibrary(libPath)
-	if err != nil {
-		return fmt.Errorf("failed to load %s: %w", libPath, err)
-	}
-	c.lib = lib
-
-	purego.RegisterLibFunc(&nvmlInit, lib, "nvmlInit")
-	purego.RegisterLibFunc(&nvmlShutdown, lib, "nvmlShutdown")
-	purego.RegisterLibFunc(&nvmlDeviceGetCount, lib, "nvmlDeviceGetCount")
-	purego.RegisterLibFunc(&nvmlDeviceGetHandleByIndex, lib, "nvmlDeviceGetHandleByIndex")
-	purego.RegisterLibFunc(&nvmlDeviceGetName, lib, "nvmlDeviceGetName")
-	// Try to get v2 memory info, fallback to v1 if not available
-	if hasSymbol(lib, "nvmlDeviceGetMemoryInfo_v2") {
-		c.isV2 = true
-		purego.RegisterLibFunc(&nvmlDeviceGetMemoryInfo, lib, "nvmlDeviceGetMemoryInfo_v2")
-	} else {
-		purego.RegisterLibFunc(&nvmlDeviceGetMemoryInfo, lib, "nvmlDeviceGetMemoryInfo")
-	}
-	purego.RegisterLibFunc(&nvmlDeviceGetUtilizationRates, lib, "nvmlDeviceGetUtilizationRates")
-	purego.RegisterLibFunc(&nvmlDeviceGetTemperature, lib, "nvmlDeviceGetTemperature")
-	purego.RegisterLibFunc(&nvmlDeviceGetPowerUsage, lib, "nvmlDeviceGetPowerUsage")
-	purego.RegisterLibFunc(&nvmlDeviceGetPciInfo, lib, "nvmlDeviceGetPciInfo")
-	purego.RegisterLibFunc(&nvmlErrorString, lib, "nvmlErrorString")
-
-	if ret := nvmlInit(); ret != nvmlReturn(nvmlSuccess) {
-		return fmt.Errorf("nvmlInit failed: %v", ret)
-	}
-
-	var count uint32
-	if ret := nvmlDeviceGetCount(&count); ret != nvmlReturn(nvmlSuccess) {
-		return fmt.Errorf("nvmlDeviceGetCount failed: %v", ret)
-	}
-
-	for i := uint32(0); i < count; i++ {
-		var device nvmlDevice
-		if ret := nvmlDeviceGetHandleByIndex(i, &device); ret == nvmlReturn(nvmlSuccess) {
-			c.devices = append(c.devices, device)
-			// Get BDF for power state check
-			var pci nvmlPciInfo
-			if ret := nvmlDeviceGetPciInfo(device, &pci); ret == nvmlReturn(nvmlSuccess) {
-				busID := string(pci.BusId[:])
-				if idx := strings.Index(busID, "\x00"); idx != -1 {
-					busID = busID[:idx]
-				}
-				c.bdfs = append(c.bdfs, strings.ToLower(busID))
-			} else {
-				c.bdfs = append(c.bdfs, "")
-			}
-		}
-	}
-
-	return nil
-}
-
-func (c *nvmlCollector) start() {
-	defer nvmlShutdown()
-	ticker := time.Tick(3 * time.Second)
-
-	for range ticker {
-		c.collect()
-	}
-}
-
-func (c *nvmlCollector) collect() {
-	c.gm.Lock()
-	defer c.gm.Unlock()
-
-	for i, device := range c.devices {
-		id := fmt.Sprintf("%d", i)
-		bdf := c.bdfs[i]
-
-		// Update GPUDataMap
-		if _, ok := c.gm.GpuDataMap[id]; !ok {
-			var nameBuf [64]byte
-			if ret := nvmlDeviceGetName(device, &nameBuf[0], 64); ret != nvmlReturn(nvmlSuccess) {
-				continue
-			}
-			name := string(nameBuf[:strings.Index(string(nameBuf[:]), "\x00")])
-			name = strings.TrimPrefix(name, "NVIDIA ")
-			c.gm.GpuDataMap[id] = &system.GPUData{Name: strings.TrimSuffix(name, " Laptop GPU")}
-		}
-		gpu := c.gm.GpuDataMap[id]
-
-		if bdf != "" && !c.isGPUActive(bdf) {
-			slog.Debug("NVML: GPU is suspended, skipping", "bdf", bdf)
-			gpu.Temperature = 0
-			gpu.MemoryUsed = 0
-			continue
-		}
-
-		// Utilization
-		var utilization nvmlUtilization
-		if ret := nvmlDeviceGetUtilizationRates(device, &utilization); ret != nvmlReturn(nvmlSuccess) {
-			slog.Debug("NVML: Utilization failed (GPU likely suspended)", "bdf", bdf, "ret", ret)
-			gpu.Temperature = 0
-			gpu.MemoryUsed = 0
-			continue
-		}
-
-		slog.Debug("NVML: Collecting data for GPU", "bdf", bdf)
-
-		// Temperature
-		var temp uint32
-		nvmlDeviceGetTemperature(device, 0, &temp) // 0 is NVML_TEMPERATURE_GPU
-
-		// Memory: only poll if GPU is active to avoid leaving D3cold state (#1522)
-		if utilization.Gpu > 0 {
-			var usedMem, totalMem uint64
-			if c.isV2 {
-				var memory nvmlMemoryV2
-				memory.Version = 0x02000028 // (2 << 24) | 40 bytes
-				if ret := nvmlDeviceGetMemoryInfo(device, uintptr(unsafe.Pointer(&memory))); ret != nvmlReturn(nvmlSuccess) {
-					slog.Debug("NVML: MemoryInfo_v2 failed", "bdf", bdf, "ret", ret)
-				} else {
-					usedMem = memory.Used
-					totalMem = memory.Total
-				}
-			} else {
-				var memory nvmlMemoryV1
-				if ret := nvmlDeviceGetMemoryInfo(device, uintptr(unsafe.Pointer(&memory))); ret != nvmlReturn(nvmlSuccess) {
-					slog.Debug("NVML: MemoryInfo failed", "bdf", bdf, "ret", ret)
-				} else {
-					usedMem = memory.Used
-					totalMem = memory.Total
-				}
-			}
-			if totalMem > 0 {
-				gpu.MemoryUsed = float64(usedMem) / 1024 / 1024 / mebibytesInAMegabyte
-				gpu.MemoryTotal = float64(totalMem) / 1024 / 1024 / mebibytesInAMegabyte
-			}
-		} else {
-			slog.Debug("NVML: Skipping memory info (utilization=0)", "bdf", bdf)
-		}
-
-		// Power
-		var power uint32
-		nvmlDeviceGetPowerUsage(device, &power)
-
-		gpu.Temperature = float64(temp)
-		gpu.Usage += float64(utilization.Gpu)
-		gpu.Power += float64(power) / 1000.0
-		gpu.Count++
-		slog.Debug("NVML: Collected data", "gpu", gpu)
-	}
-}
--- a/agent/gpu_nvml_linux.go
+++ b/agent/gpu_nvml_linux.go
@@ -1,57 +0,0 @@
-//go:build glibc && linux && amd64
-
-package agent
-
-import (
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/ebitengine/purego"
-)
-
-func openLibrary(name string) (uintptr, error) {
-	return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL)
-}
-
-func getNVMLPath() string {
-	return "libnvidia-ml.so.1"
-}
-
-func hasSymbol(lib uintptr, symbol string) bool {
-	_, err := purego.Dlsym(lib, symbol)
-	return err == nil
-}
-
-func (c *nvmlCollector) isGPUActive(bdf string) bool {
-	// runtime_status
-	statusPath := filepath.Join("/sys/bus/pci/devices", bdf, "power/runtime_status")
-	status, err := os.ReadFile(statusPath)
-	if err != nil {
-		slog.Debug("NVML: Can't read runtime_status", "bdf", bdf, "err", err)
-		return true // Assume active if we can't read status
-	}
-	statusStr := strings.TrimSpace(string(status))
-	if statusStr != "active" && statusStr != "resuming" {
-		slog.Debug("NVML: GPU not active", "bdf", bdf, "status", statusStr)
-		return false
-	}
-
-	// power_state (D0 check)
-	// Find any drm card device power_state
-	pstatePathPattern := filepath.Join("/sys/bus/pci/devices", bdf, "drm/card*/device/power_state")
-	matches, _ := filepath.Glob(pstatePathPattern)
-	if len(matches) > 0 {
-		pstate, err := os.ReadFile(matches[0])
-		if err == nil {
-			pstateStr := strings.TrimSpace(string(pstate))
-			if pstateStr != "D0" {
-				slog.Debug("NVML: GPU not in D0 state", "bdf", bdf, "pstate", pstateStr)
-				return false
-			}
-		}
-	}
-
-	return true
-}
--- a/agent/gpu_nvml_unsupported.go
+++ b/agent/gpu_nvml_unsupported.go
@@ -1,15 +0,0 @@
-//go:build (!linux && !windows) || !amd64 || (linux && !glibc)
-
-package agent
-
-import "fmt"
-
-type nvmlCollector struct {
-	gm *GPUManager
-}
-
-func (c *nvmlCollector) init() error {
-	return fmt.Errorf("nvml not supported on this platform")
-}
-
-func (c *nvmlCollector) start() {}
--- a/agent/gpu_nvml_windows.go
+++ b/agent/gpu_nvml_windows.go
@@ -1,25 +0,0 @@
-//go:build windows && amd64
-
-package agent
-
-import (
-	"golang.org/x/sys/windows"
-)
-
-func openLibrary(name string) (uintptr, error) {
-	handle, err := windows.LoadLibrary(name)
-	return uintptr(handle), err
-}
-
-func getNVMLPath() string {
-	return "nvml.dll"
-}
-
-func hasSymbol(lib uintptr, symbol string) bool {
-	_, err := windows.GetProcAddress(windows.Handle(lib), symbol)
-	return err == nil
-}
-
-func (c *nvmlCollector) isGPUActive(bdf string) bool {
-	return true
-}
--- a/agent/gpu_nvtop.go
+++ b/agent/gpu_nvtop.go
@@ -1,159 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"io"
-	"log/slog"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-type nvtopSnapshot struct {
-	DeviceName string  `json:"device_name"`
-	Temp       *string `json:"temp"`
-	PowerDraw  *string `json:"power_draw"`
-	GpuUtil    *string `json:"gpu_util"`
-	MemTotal   *string `json:"mem_total"`
-	MemUsed    *string `json:"mem_used"`
-}
-
-// parseNvtopNumber parses nvtop numeric strings with units (C/W/%).
-func parseNvtopNumber(raw string) float64 {
-	cleaned := strings.TrimSpace(raw)
-	cleaned = strings.TrimSuffix(cleaned, "C")
-	cleaned = strings.TrimSuffix(cleaned, "W")
-	cleaned = strings.TrimSuffix(cleaned, "%")
-	val, _ := strconv.ParseFloat(cleaned, 64)
-	return val
-}
-
-// parseNvtopData parses a single nvtop JSON snapshot payload.
-func (gm *GPUManager) parseNvtopData(output []byte) bool {
-	var snapshots []nvtopSnapshot
-	if err := json.Unmarshal(output, &snapshots); err != nil || len(snapshots) == 0 {
-		return false
-	}
-	return gm.updateNvtopSnapshots(snapshots)
-}
-
-// updateNvtopSnapshots applies one decoded nvtop snapshot batch to GPU accumulators.
-func (gm *GPUManager) updateNvtopSnapshots(snapshots []nvtopSnapshot) bool {
-	gm.Lock()
-	defer gm.Unlock()
-
-	valid := false
-	usedIDs := make(map[string]struct{}, len(snapshots))
-	for i, sample := range snapshots {
-		if sample.DeviceName == "" {
-			continue
-		}
-		indexID := "n" + strconv.Itoa(i)
-		id := indexID
-
-		// nvtop ordering can change, so prefer reusing an existing slot with matching device name.
-		if existingByIndex, ok := gm.GpuDataMap[indexID]; ok && existingByIndex.Name != "" && existingByIndex.Name != sample.DeviceName {
-			for existingID, gpu := range gm.GpuDataMap {
-				if !strings.HasPrefix(existingID, "n") {
-					continue
-				}
-				if _, taken := usedIDs[existingID]; taken {
-					continue
-				}
-				if gpu.Name == sample.DeviceName {
-					id = existingID
-					break
-				}
-			}
-		}
-
-		if _, ok := gm.GpuDataMap[id]; !ok {
-			gm.GpuDataMap[id] = &system.GPUData{Name: sample.DeviceName}
-		}
-		gpu := gm.GpuDataMap[id]
-		gpu.Name = sample.DeviceName
-
-		if sample.Temp != nil {
-			gpu.Temperature = parseNvtopNumber(*sample.Temp)
-		}
-		if sample.MemUsed != nil {
-			gpu.MemoryUsed = bytesToMegabytes(parseNvtopNumber(*sample.MemUsed))
-		}
-		if sample.MemTotal != nil {
-			gpu.MemoryTotal = bytesToMegabytes(parseNvtopNumber(*sample.MemTotal))
-		}
-		if sample.GpuUtil != nil {
-			gpu.Usage += parseNvtopNumber(*sample.GpuUtil)
-		}
-		if sample.PowerDraw != nil {
-			gpu.Power += parseNvtopNumber(*sample.PowerDraw)
-		}
-		gpu.Count++
-		usedIDs[id] = struct{}{}
-		valid = true
-	}
-	return valid
-}
-
-// collectNvtopStats runs nvtop loop mode and continuously decodes JSON snapshots.
-func (gm *GPUManager) collectNvtopStats(interval string) error {
-	cmd := exec.Command(nvtopCmd, "-lP", "-d", interval)
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-	defer func() {
-		_ = stdout.Close()
-		if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
-			_ = cmd.Process.Kill()
-		}
-		_ = cmd.Wait()
-	}()
-
-	decoder := json.NewDecoder(stdout)
-	foundValid := false
-	for {
-		var snapshots []nvtopSnapshot
-		if err := decoder.Decode(&snapshots); err != nil {
-			if err == io.EOF {
-				if foundValid {
-					return nil
-				}
-				return errNoValidData
-			}
-			return err
-		}
-		if gm.updateNvtopSnapshots(snapshots) {
-			foundValid = true
-		}
-	}
-}
-
-// startNvtopCollector starts nvtop collection with retry or fallback callback handling.
-func (gm *GPUManager) startNvtopCollector(interval string, onFailure func()) {
-	go func() {
-		failures := 0
-		for {
-			if err := gm.collectNvtopStats(interval); err != nil {
-				if onFailure != nil {
-					slog.Warn("Error collecting GPU data via nvtop", "err", err)
-					onFailure()
-					return
-				}
-				failures++
-				if failures > maxFailureRetries {
-					break
-				}
-				slog.Warn("Error collecting GPU data via nvtop", "err", err)
-				time.Sleep(retryWaitTime)
-				continue
-			}
-		}
-	}()
-}
--- a/agent/gpu_test.go
+++ b/agent/gpu_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

@@ -249,100 +250,6 @@ func TestParseAmdData(t *testing.T) {
 	}
 }

-func TestParseNvtopData(t *testing.T) {
-	input, err := os.ReadFile("test-data/nvtop.json")
-	require.NoError(t, err)
-
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-	valid := gm.parseNvtopData(input)
-	require.True(t, valid)
-
-	g0, ok := gm.GpuDataMap["n0"]
-	require.True(t, ok)
-	assert.Equal(t, "NVIDIA GeForce RTX 3050 Ti Laptop GPU", g0.Name)
-	assert.Equal(t, 48.0, g0.Temperature)
-	assert.Equal(t, 5.0, g0.Usage)
-	assert.Equal(t, 13.0, g0.Power)
-	assert.Equal(t, bytesToMegabytes(349372416), g0.MemoryUsed)
-	assert.Equal(t, bytesToMegabytes(4294967296), g0.MemoryTotal)
-	assert.Equal(t, 1.0, g0.Count)
-
-	g1, ok := gm.GpuDataMap["n1"]
-	require.True(t, ok)
-	assert.Equal(t, "AMD Radeon 680M", g1.Name)
-	assert.Equal(t, 48.0, g1.Temperature)
-	assert.Equal(t, 12.0, g1.Usage)
-	assert.Equal(t, 9.0, g1.Power)
-	assert.Equal(t, bytesToMegabytes(1213784064), g1.MemoryUsed)
-	assert.Equal(t, bytesToMegabytes(16929173504), g1.MemoryTotal)
-	assert.Equal(t, 1.0, g1.Count)
-}
-
-func TestUpdateNvtopSnapshotsKeepsDeviceAssociationWhenOrderChanges(t *testing.T) {
-	strPtr := func(s string) *string { return &s }
-
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-
-	firstBatch := []nvtopSnapshot{
-		{
-			DeviceName: "NVIDIA GeForce RTX 3050 Ti Laptop GPU",
-			GpuUtil:    strPtr("20%"),
-			PowerDraw:  strPtr("10W"),
-		},
-		{
-			DeviceName: "AMD Radeon 680M",
-			GpuUtil:    strPtr("30%"),
-			PowerDraw:  strPtr("20W"),
-		},
-	}
-	secondBatchSwapped := []nvtopSnapshot{
-		{
-			DeviceName: "AMD Radeon 680M",
-			GpuUtil:    strPtr("40%"),
-			PowerDraw:  strPtr("25W"),
-		},
-		{
-			DeviceName: "NVIDIA GeForce RTX 3050 Ti Laptop GPU",
-			GpuUtil:    strPtr("50%"),
-			PowerDraw:  strPtr("15W"),
-		},
-	}
-
-	require.True(t, gm.updateNvtopSnapshots(firstBatch))
-	require.True(t, gm.updateNvtopSnapshots(secondBatchSwapped))
-
-	nvidia := gm.GpuDataMap["n0"]
-	require.NotNil(t, nvidia)
-	assert.Equal(t, "NVIDIA GeForce RTX 3050 Ti Laptop GPU", nvidia.Name)
-	assert.Equal(t, 70.0, nvidia.Usage)
-	assert.Equal(t, 25.0, nvidia.Power)
-	assert.Equal(t, 2.0, nvidia.Count)
-
-	amd := gm.GpuDataMap["n1"]
-	require.NotNil(t, amd)
-	assert.Equal(t, "AMD Radeon 680M", amd.Name)
-	assert.Equal(t, 70.0, amd.Usage)
-	assert.Equal(t, 45.0, amd.Power)
-	assert.Equal(t, 2.0, amd.Count)
-}
-
-func TestParseCollectorPriority(t *testing.T) {
-	got := parseCollectorPriority(" nvml, nvidia-smi, intel_gpu_top, amd_sysfs, nvtop, rocm-smi, bad ")
-	want := []collectorSource{
-		collectorSourceNVML,
-		collectorSourceNvidiaSMI,
-		collectorSourceIntelGpuTop,
-		collectorSourceAmdSysfs,
-		collectorSourceNVTop,
-		collectorSourceRocmSMI,
-	}
-	assert.Equal(t, want, got)
-}
-
 func TestParseJetsonData(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -400,19 +307,6 @@ func TestParseJetsonData(t *testing.T) {
 				Count:       1,
 			},
 		},
-		{
-			name:  "orin-style output with GPU@ temp and VDD_SYS_GPU power",
-			input: "RAM 3276/7859MB (lfb 5x4MB) SWAP 1626/12122MB (cached 181MB) CPU [44%@1421,49%@2031,67%@2034,17%@1420,25%@1419,8%@1420] EMC_FREQ 1%@1866 GR3D_FREQ 0%@114 APE 150 MTS fg 1% bg 1% PLL@42.5C MCPU@42.5C PMIC@50C Tboard@38C GPU@39.5C BCPU@42.5C thermal@41.3C Tdiode@39.25C VDD_SYS_GPU 182/182 VDD_SYS_SOC 730/730 VDD_4V0_WIFI 0/0 VDD_IN 5297/5297 VDD_SYS_CPU 1917/1917 VDD_SYS_DDR 1241/1241",
-			wantMetrics: &system.GPUData{
-				Name:        "GPU",
-				MemoryUsed:  3276.0,
-				MemoryTotal: 7859.0,
-				Usage:       0.0,
-				Power:       0.182, // 182mW -> 0.182W
-				Temperature: 39.5,
-				Count:       1,
-			},
-		},
 	}

 	for _, tt := range tests {
@@ -931,7 +825,7 @@ func TestInitializeSnapshots(t *testing.T) {
 }

 func TestCalculateGPUAverage(t *testing.T) {
-	t.Run("returns cached average when deltaCount is zero", func(t *testing.T) {
+	t.Run("returns zero value when deltaCount is zero", func(t *testing.T) {
 		gm := &GPUManager{
 			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
 				5000: {
@@ -944,10 +838,9 @@ func TestCalculateGPUAverage(t *testing.T) {
 		}

 		gpu := &system.GPUData{
-			Count:       10.0, // Same as snapshot, so delta = 0
-			Usage:       100.0,
-			Power:       200.0,
-			Temperature: 50.0, // Non-zero to avoid "suspended" check
+			Count: 10.0, // Same as snapshot, so delta = 0
+			Usage: 100.0,
+			Power: 200.0,
 		}

 		result := gm.calculateGPUAverage("0", gpu, 5000)
@@ -956,31 +849,6 @@ func TestCalculateGPUAverage(t *testing.T) {
 		assert.Equal(t, 100.0, result.Power, "Should return cached average")
 	})

-	t.Run("returns zero value when GPU is suspended", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {
-					"0": {count: 10, usage: 100, power: 200},
-				},
-			},
-			lastAvgData: map[string]system.GPUData{
-				"0": {Usage: 50.0, Power: 100.0},
-			},
-		}
-
-		gpu := &system.GPUData{
-			Name:        "Test GPU",
-			Count:       10.0,
-			Temperature: 0,
-			MemoryUsed:  0,
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, 0.0, result.Usage, "Should return zero usage")
-		assert.Equal(t, 0.0, result.Power, "Should return zero power")
-	})
-
 	t.Run("calculates average for standard GPU", func(t *testing.T) {
 		gm := &GPUManager{
 			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
@@ -1080,35 +948,36 @@ func TestCalculateGPUAverage(t *testing.T) {
 	})
 }

-func TestGPUCapabilitiesAndLegacyPriority(t *testing.T) {
+func TestDetectGPUs(t *testing.T) {
 	// Save original PATH
 	origPath := os.Getenv("PATH")
 	defer os.Setenv("PATH", origPath)
-	hasAmdSysfs := (&GPUManager{}).hasAmdSysfs()
+
+	// Set up temp dir with the commands
+	tempDir := t.TempDir()
+	os.Setenv("PATH", tempDir)

 	tests := []struct {
 		name           string
-		setupCommands  func(string) error
+		setupCommands  func() error
 		wantNvidiaSmi  bool
 		wantRocmSmi    bool
 		wantTegrastats bool
-		wantNvtop      bool
 		wantErr        bool
 	}{
 		{
 			name: "nvidia-smi not available",
-			setupCommands: func(_ string) error {
+			setupCommands: func() error {
 				return nil
 			},
 			wantNvidiaSmi:  false,
 			wantRocmSmi:    false,
 			wantTegrastats: false,
-			wantNvtop:      false,
 			wantErr:        true,
 		},
 		{
 			name: "nvidia-smi available",
-			setupCommands: func(tempDir string) error {
+			setupCommands: func() error {
 				path := filepath.Join(tempDir, "nvidia-smi")
 				script := `#!/bin/sh
 echo "test"`
@@ -1120,12 +989,11 @@ echo "test"`
 			wantNvidiaSmi:  true,
 			wantTegrastats: false,
 			wantRocmSmi:    false,
-			wantNvtop:      false,
 			wantErr:        false,
 		},
 		{
 			name: "rocm-smi available",
-			setupCommands: func(tempDir string) error {
+			setupCommands: func() error {
 				path := filepath.Join(tempDir, "rocm-smi")
 				script := `#!/bin/sh
 echo "test"`
@@ -1134,15 +1002,14 @@ echo "test"`
 				}
 				return nil
 			},
-			wantNvidiaSmi:  false,
+			wantNvidiaSmi:  true,
 			wantRocmSmi:    true,
 			wantTegrastats: false,
-			wantNvtop:      false,
 			wantErr:        false,
 		},
 		{
 			name: "tegrastats available",
-			setupCommands: func(tempDir string) error {
+			setupCommands: func() error {
 				path := filepath.Join(tempDir, "tegrastats")
 				script := `#!/bin/sh
 echo "test"`
@@ -1152,31 +1019,13 @@ echo "test"`
 				return nil
 			},
 			wantNvidiaSmi:  false,
-			wantRocmSmi:    false,
+			wantRocmSmi:    true,
 			wantTegrastats: true,
-			wantNvtop:      false,
-			wantErr:        false,
-		},
-		{
-			name: "nvtop available",
-			setupCommands: func(tempDir string) error {
-				path := filepath.Join(tempDir, "nvtop")
-				script := `#!/bin/sh
-echo "[]"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			wantNvidiaSmi:  false,
-			wantRocmSmi:    false,
-			wantTegrastats: false,
-			wantNvtop:      true,
 			wantErr:        false,
 		},
 		{
 			name: "no gpu tools available",
-			setupCommands: func(_ string) error {
+			setupCommands: func() error {
 				os.Setenv("PATH", "")
 				return nil
 			},
@@ -1186,53 +1035,29 @@ echo "[]"`

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tempDir := t.TempDir()
-			os.Setenv("PATH", tempDir)
-			if err := tt.setupCommands(tempDir); err != nil {
+			if err := tt.setupCommands(); err != nil {
 				t.Fatal(err)
 			}

 			gm := &GPUManager{}
-			caps := gm.discoverGpuCapabilities()
-			var err error
-			if !hasAnyGpuCollector(caps) {
-				err = fmt.Errorf(noGPUFoundMsg)
-			}
-			priorities := gm.resolveLegacyCollectorPriority(caps)
-			hasPriority := func(source collectorSource) bool {
-				for _, s := range priorities {
-					if s == source {
-						return true
-					}
-				}
-				return false
-			}
-			gotNvidiaSmi := hasPriority(collectorSourceNvidiaSMI)
-			gotRocmSmi := hasPriority(collectorSourceRocmSMI)
-			gotTegrastats := caps.hasTegrastats
-			gotNvtop := caps.hasNvtop
+			err := gm.detectGPUs()

-			t.Logf("nvidiaSmi: %v, rocmSmi: %v, tegrastats: %v", gotNvidiaSmi, gotRocmSmi, gotTegrastats)
+			t.Logf("nvidiaSmi: %v, rocmSmi: %v, tegrastats: %v", gm.nvidiaSmi, gm.rocmSmi, gm.tegrastats)

-			wantErr := tt.wantErr
-			if hasAmdSysfs && (tt.name == "nvidia-smi not available" || tt.name == "no gpu tools available") {
-				wantErr = false
-			}
-			if wantErr {
+			if tt.wantErr {
 				assert.Error(t, err)
 				return
 			}

 			assert.NoError(t, err)
-			assert.Equal(t, tt.wantNvidiaSmi, gotNvidiaSmi)
-			assert.Equal(t, tt.wantRocmSmi, gotRocmSmi)
-			assert.Equal(t, tt.wantTegrastats, gotTegrastats)
-			assert.Equal(t, tt.wantNvtop, gotNvtop)
+			assert.Equal(t, tt.wantNvidiaSmi, gm.nvidiaSmi)
+			assert.Equal(t, tt.wantRocmSmi, gm.rocmSmi)
+			assert.Equal(t, tt.wantTegrastats, gm.tegrastats)
 		})
 	}
 }

-func TestCollectorStartHelpers(t *testing.T) {
+func TestStartCollector(t *testing.T) {
 	// Save original PATH
 	origPath := os.Getenv("PATH")
 	defer os.Setenv("PATH", origPath)
@@ -1317,27 +1142,6 @@ echo "11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 80% tj@70C VDD_GPU_SOC 1000m
 				},
 			},
 		},
-		{
-			name:    "nvtop collector",
-			command: "nvtop",
-			setup: func(t *testing.T) error {
-				path := filepath.Join(dir, "nvtop")
-				script := `#!/bin/sh
-echo '[{"device_name":"NVIDIA Test GPU","temp":"52C","power_draw":"31W","gpu_util":"37%","mem_total":"4294967296","mem_used":"536870912","processes":[]}]'`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			validate: func(t *testing.T, gm *GPUManager) {
-				gpu, exists := gm.GpuDataMap["n0"]
-				assert.True(t, exists)
-				if exists {
-					assert.Equal(t, "NVIDIA Test GPU", gpu.Name)
-					assert.Equal(t, 52.0, gpu.Temperature)
-				}
-			},
-		},
 	}

 	for _, tt := range tests {
@@ -1350,157 +1154,13 @@ echo '[{"device_name":"NVIDIA Test GPU","temp":"52C","power_draw":"31W","gpu_uti
 					GpuDataMap: make(map[string]*system.GPUData),
 				}
 			}
-			switch tt.command {
-			case nvidiaSmiCmd:
-				tt.gm.startNvidiaSmiCollector("4")
-			case rocmSmiCmd:
-				tt.gm.startRocmSmiCollector(4300 * time.Millisecond)
-			case tegraStatsCmd:
-				tt.gm.startTegraStatsCollector("3700")
-			case nvtopCmd:
-				tt.gm.startNvtopCollector("30", nil)
-			default:
-				t.Fatalf("unknown test command %q", tt.command)
-			}
+			tt.gm.startCollector(tt.command)
 			time.Sleep(50 * time.Millisecond) // Give collector time to run
 			tt.validate(t, tt.gm)
 		})
 	}
 }

-func TestNewGPUManagerPriorityNvtopFallback(t *testing.T) {
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-	t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "nvtop,nvidia-smi")
-
-	nvtopPath := filepath.Join(dir, "nvtop")
-	nvtopScript := `#!/bin/sh
-echo 'not-json'`
-	require.NoError(t, os.WriteFile(nvtopPath, []byte(nvtopScript), 0755))
-
-	nvidiaPath := filepath.Join(dir, "nvidia-smi")
-	nvidiaScript := `#!/bin/sh
-echo "0, NVIDIA Priority GPU, 45, 512, 2048, 12, 25"`
-	require.NoError(t, os.WriteFile(nvidiaPath, []byte(nvidiaScript), 0755))
-
-	gm, err := NewGPUManager()
-	require.NoError(t, err)
-	require.NotNil(t, gm)
-
-	time.Sleep(150 * time.Millisecond)
-	gpu, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "Priority GPU", gpu.Name)
-	assert.Equal(t, 45.0, gpu.Temperature)
-}
-
-func TestNewGPUManagerPriorityMixedCollectors(t *testing.T) {
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-	t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "intel_gpu_top,rocm-smi")
-
-	intelPath := filepath.Join(dir, "intel_gpu_top")
-	intelScript := `#!/bin/sh
-echo "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS             VCS"
-echo " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa       %  se  wa"
-echo "226  223      338  58  2.00  2.69   1820    965   0.00    0   0    0.00   0   0"
-echo "189  187      412  67  1.80  2.45   1950    823   8.50    2   1    15.00   1   0"
-`
-	require.NoError(t, os.WriteFile(intelPath, []byte(intelScript), 0755))
-
-	rocmPath := filepath.Join(dir, "rocm-smi")
-	rocmScript := `#!/bin/sh
-echo '{"card0": {"Temperature (Sensor edge) (C)": "49.0", "Current Socket Graphics Package Power (W)": "28.159", "GPU use (%)": "0", "VRAM Total Memory (B)": "536870912", "VRAM Total Used Memory (B)": "445550592", "Card Series": "Rembrandt [Radeon 680M]", "GUID": "34756"}}'
-`
-	require.NoError(t, os.WriteFile(rocmPath, []byte(rocmScript), 0755))
-
-	gm, err := NewGPUManager()
-	require.NoError(t, err)
-	require.NotNil(t, gm)
-
-	time.Sleep(150 * time.Millisecond)
-	_, intelOk := gm.GpuDataMap["i0"]
-	_, amdOk := gm.GpuDataMap["34756"]
-	assert.True(t, intelOk)
-	assert.True(t, amdOk)
-}
-
-func TestNewGPUManagerPriorityNvmlFallbackToNvidiaSmi(t *testing.T) {
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-	t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "nvml,nvidia-smi")
-
-	nvidiaPath := filepath.Join(dir, "nvidia-smi")
-	nvidiaScript := `#!/bin/sh
-echo "0, NVIDIA Fallback GPU, 41, 256, 1024, 8, 14"`
-	require.NoError(t, os.WriteFile(nvidiaPath, []byte(nvidiaScript), 0755))
-
-	gm, err := NewGPUManager()
-	require.NoError(t, err)
-	require.NotNil(t, gm)
-
-	time.Sleep(150 * time.Millisecond)
-	gpu, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "Fallback GPU", gpu.Name)
-}
-
-func TestNewGPUManagerConfiguredCollectorsMustStart(t *testing.T) {
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-
-	t.Run("configured valid collector unavailable", func(t *testing.T) {
-		t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "nvidia-smi")
-		gm, err := NewGPUManager()
-		require.Nil(t, gm)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "no configured GPU collectors are available")
-	})
-
-	t.Run("configured collector list has only unknown entries", func(t *testing.T) {
-		t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "bad,unknown")
-		gm, err := NewGPUManager()
-		require.Nil(t, gm)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "no configured GPU collectors are available")
-	})
-}
-
-func TestNewGPUManagerJetsonIgnoresCollectorConfig(t *testing.T) {
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-	t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "nvidia-smi")
-
-	tegraPath := filepath.Join(dir, "tegrastats")
-	tegraScript := `#!/bin/sh
-echo "11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 80% tj@70C VDD_GPU_SOC 1000mW"`
-	require.NoError(t, os.WriteFile(tegraPath, []byte(tegraScript), 0755))
-
-	gm, err := NewGPUManager()
-	require.NoError(t, err)
-	require.NotNil(t, gm)
-
-	time.Sleep(100 * time.Millisecond)
-	gpu, ok := gm.GpuDataMap["0"]
-	require.True(t, ok)
-	assert.Equal(t, "GPU", gpu.Name)
-}
-
 // TestAccumulationTableDriven tests the accumulation behavior for all three GPU types
 func TestAccumulation(t *testing.T) {
 	type expectedGPUValues struct {
@@ -1686,7 +1346,7 @@ func TestIntelUpdateFromStats(t *testing.T) {
 	ok := gm.updateIntelFromStats(&sample1)
 	assert.True(t, ok)

-	gpu := gm.GpuDataMap["i0"]
+	gpu := gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
 	assert.Equal(t, "GPU", gpu.Name)
 	assert.EqualValues(t, 10.5, gpu.Power)
@@ -1708,7 +1368,7 @@ func TestIntelUpdateFromStats(t *testing.T) {
 	ok = gm.updateIntelFromStats(&sample2)
 	assert.True(t, ok)

-	gpu = gm.GpuDataMap["i0"]
+	gpu = gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
 	assert.EqualValues(t, 10.5, gpu.Power)
 	assert.EqualValues(t, 30.0, gpu.Engines["Render/3D"]) // 20 + 10
@@ -1747,7 +1407,7 @@ echo "298  295      278  51  2.20  3.12   1675    942   5.75    1   2    9.50
 		t.Fatalf("collectIntelStats error: %v", err)
 	}

-	gpu := gm.GpuDataMap["i0"]
+	gpu := gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
 	// Power should be sum of samples 2-4 (first is skipped): 2.0 + 1.8 + 2.2 = 6.0
 	assert.EqualValues(t, 6.0, gpu.Power)
--- a/agent/handlers.go
+++ b/agent/handlers.go
@@ -9,7 +9,7 @@ import (
 	"github.com/henrygd/beszel/internal/common"
 	"github.com/henrygd/beszel/internal/entities/smart"

-	"log/slog"
+	"golang.org/x/exp/slog"
 )

 // HandlerContext provides context for request handlers
@@ -94,7 +94,7 @@ func (h *GetDataHandler) Handle(hctx *HandlerContext) error {
 	var options common.DataRequestOptions
 	_ = cbor.Unmarshal(hctx.Request.Data, &options)

-	sysStats := hctx.Agent.gatherStats(options)
+	sysStats := hctx.Agent.gatherStats(options.CacheTimeMs)
 	return hctx.SendResponse(sysStats, hctx.RequestID)
 }

--- a/agent/handlers_test.go
+++ b/agent/handlers_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

--- a/agent/health/health.go
+++ b/agent/health/health.go
@@ -9,31 +9,11 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"runtime"
 	"time"
 )

 // healthFile is the path to the health file
-var healthFile = getHealthFilePath()
-
-func getHealthFilePath() string {
-	filename := "beszel_health"
-	if runtime.GOOS == "linux" {
-		fullPath := filepath.Join("/dev/shm", filename)
-		if err := updateHealthFile(fullPath); err == nil {
-			return fullPath
-		}
-	}
-	return filepath.Join(os.TempDir(), filename)
-}
-
-func updateHealthFile(path string) error {
-	file, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	return file.Close()
-}
+var healthFile = filepath.Join(os.TempDir(), "beszel_health")

 // Check checks if the agent is connected by checking the modification time of the health file
 func Check() error {
@@ -50,7 +30,11 @@ func Check() error {

 // Update updates the modification time of the health file
 func Update() error {
-	return updateHealthFile(healthFile)
+	file, err := os.Create(healthFile)
+	if err != nil {
+		return err
+	}
+	return file.Close()
 }

 // CleanUp removes the health file
--- a/agent/health/health_test.go
+++ b/agent/health/health_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package health

@@ -36,6 +37,7 @@ func TestHealth(t *testing.T) {
 	})

 	// This test uses synctest to simulate time passing.
+	// NOTE: This test requires GOEXPERIMENT=synctest to run.
 	t.Run("check with simulated time", func(t *testing.T) {
 		synctest.Test(t, func(t *testing.T) {
 			// Update the file to set the initial timestamp.
--- a/agent/lhm/beszel_lhm.cs
+++ b/agent/lhm/beszel_lhm.cs
@@ -52,12 +52,7 @@ class Program
    foreach (var sensor in hardware.Sensors)
    {
      var validTemp = sensor.SensorType == SensorType.Temperature && sensor.Value.HasValue;
-      if (!validTemp ||
-          sensor.Name.IndexOf("Distance", StringComparison.OrdinalIgnoreCase) >= 0 ||
-          sensor.Name.IndexOf("Limit", StringComparison.OrdinalIgnoreCase) >= 0 ||
-          sensor.Name.IndexOf("Critical", StringComparison.OrdinalIgnoreCase) >= 0 ||
-          sensor.Name.IndexOf("Warning", StringComparison.OrdinalIgnoreCase) >= 0 ||
-          sensor.Name.IndexOf("Resolution", StringComparison.OrdinalIgnoreCase) >= 0)
+      if (!validTemp || sensor.Name.Contains("Distance"))
      {
        continue;
      }
--- a/agent/lhm/beszel_lhm.csproj
+++ b/agent/lhm/beszel_lhm.csproj
@@ -3,11 +3,9 @@
    <OutputType>Exe</OutputType>
    <TargetFramework>net48</TargetFramework>
    <Platforms>x64</Platforms>
-    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.5" />
+    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.4" />
  </ItemGroup>
 </Project>
--- a/agent/response.go
+++ b/agent/response.go
@@ -1,31 +0,0 @@
-package agent
-
-import (
-	"github.com/fxamacker/cbor/v2"
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/smart"
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/henrygd/beszel/internal/entities/systemd"
-)
-
-// newAgentResponse creates an AgentResponse using legacy typed fields.
-// This maintains backward compatibility with <= 0.17 hubs that expect specific fields.
-func newAgentResponse(data any, requestID *uint32) common.AgentResponse {
-	response := common.AgentResponse{Id: requestID}
-	switch v := data.(type) {
-	case *system.CombinedData:
-		response.SystemData = v
-	case *common.FingerprintResponse:
-		response.Fingerprint = v
-	case string:
-		response.String = &v
-	case map[string]smart.SmartData:
-		response.SmartData = v
-	case systemd.ServiceDetails:
-		response.ServiceInfo = v
-	default:
-		// For unknown types, use the generic Data field
-		response.Data, _ = cbor.Marshal(data)
-	}
-	return response
-}
--- a/agent/sensors_test.go
+++ b/agent/sensors_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

--- a/agent/server.go
+++ b/agent/server.go
@@ -13,7 +13,9 @@ import (

 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/entities/smart"
 	"github.com/henrygd/beszel/internal/entities/system"
+	"github.com/henrygd/beszel/internal/entities/systemd"

 	"github.com/blang/semver"
 	"github.com/fxamacker/cbor/v2"
@@ -36,9 +38,6 @@ var hubVersions map[string]semver.Version
 // and begins listening for connections. Returns an error if the server
 // is already running or if there's an issue starting the server.
 func (a *Agent) StartServer(opts ServerOptions) error {
-	if disableSSH, _ := GetEnv("DISABLE_SSH"); disableSSH == "true" {
-		return errors.New("SSH disabled")
-	}
 	if a.server != nil {
 		return errors.New("server already started")
 	}
@@ -166,9 +165,20 @@ func (a *Agent) handleSSHRequest(w io.Writer, req *common.HubRequest[cbor.RawMes
 	}

 	// responder that writes AgentResponse to stdout
-	// Uses legacy typed fields for backward compatibility with <= 0.17
 	sshResponder := func(data any, requestID *uint32) error {
-		response := newAgentResponse(data, requestID)
+		response := common.AgentResponse{Id: requestID}
+		switch v := data.(type) {
+		case *system.CombinedData:
+			response.SystemData = v
+		case string:
+			response.String = &v
+		case map[string]smart.SmartData:
+			response.SmartData = v
+		case systemd.ServiceDetails:
+			response.ServiceInfo = v
+		default:
+			response.Error = fmt.Sprintf("unsupported response type: %T", data)
+		}
 		return cbor.NewEncoder(w).Encode(response)
 	}

@@ -192,7 +202,7 @@ func (a *Agent) handleSSHRequest(w io.Writer, req *common.HubRequest[cbor.RawMes

 // handleLegacyStats serves the legacy one-shot stats payload for older hubs
 func (a *Agent) handleLegacyStats(w io.Writer, hubVersion semver.Version) error {
-	stats := a.gatherStats(common.DataRequestOptions{CacheTimeMs: 60_000})
+	stats := a.gatherStats(60_000)
 	return a.writeToSession(w, stats, hubVersion)
 }

--- a/agent/server_test.go
+++ b/agent/server_test.go
@@ -1,5 +1,3 @@
-//go:build testing
-
 package agent

 import (
@@ -182,23 +180,6 @@ func TestStartServer(t *testing.T) {
 	}
 }

-func TestStartServerDisableSSH(t *testing.T) {
-	os.Setenv("BESZEL_AGENT_DISABLE_SSH", "true")
-	defer os.Unsetenv("BESZEL_AGENT_DISABLE_SSH")
-
-	agent, err := NewAgent("")
-	require.NoError(t, err)
-
-	opts := ServerOptions{
-		Network: "tcp",
-		Addr:    ":45990",
-	}
-
-	err = agent.StartServer(opts)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "SSH disabled")
-}
-
 /////////////////////////////////////////////////////////////////
 //////////////////// ParseKeys Tests ////////////////////////////
 /////////////////////////////////////////////////////////////////
@@ -532,7 +513,7 @@ func TestWriteToSessionEncoding(t *testing.T) {
 				err = json.Unmarshal([]byte(encodedData), &decodedJson)
 				assert.Error(t, err, "Should not be valid JSON data")

-				assert.Equal(t, testData.Details.Hostname, decodedCbor.Details.Hostname)
+				assert.Equal(t, testData.Info.Hostname, decodedCbor.Info.Hostname)
 				assert.Equal(t, testData.Stats.Cpu, decodedCbor.Stats.Cpu)
 			} else {
 				// Should be JSON - try to decode as JSON
@@ -545,7 +526,7 @@ func TestWriteToSessionEncoding(t *testing.T) {
 				assert.Error(t, err, "Should not be valid CBOR data")

 				// Verify the decoded JSON data matches our test data
-				assert.Equal(t, testData.Details.Hostname, decodedJson.Details.Hostname)
+				assert.Equal(t, testData.Info.Hostname, decodedJson.Info.Hostname)
 				assert.Equal(t, testData.Stats.Cpu, decodedJson.Stats.Cpu)

 				// Verify it looks like JSON (starts with '{' and contains readable field names)
@@ -569,12 +550,13 @@ func createTestCombinedData() *system.CombinedData {
 			DiskUsed:  549755813888,  // 512GB
 			DiskPct:   50.0,
 		},
-		Details: &system.Details{
-			Hostname: "test-host",
-		},
 		Info: system.Info{
+			Hostname:     "test-host",
+			Cores:        8,
+			CpuModel:     "Test CPU Model",
 			Uptime:       3600,
 			AgentVersion: "0.12.0",
+			Os:           system.Linux,
 		},
 		Containers: []*container.Stats{
 			{
--- a/agent/smart.go
+++ b/agent/smart.go
@@ -8,10 +8,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log/slog"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
@@ -19,6 +17,8 @@ import (
 	"time"

 	"github.com/henrygd/beszel/internal/entities/smart"
+
+	"golang.org/x/exp/slog"
 )

 // SmartManager manages data collection for SMART devices
@@ -28,7 +28,7 @@ type SmartManager struct {
 	SmartDevices    []*DeviceInfo
 	refreshMutex    sync.Mutex
 	lastScanTime    time.Time
-	smartctlPath    string
+	binPath         string
 	excludedDevices map[string]struct{}
 }

@@ -53,12 +53,6 @@ type DeviceInfo struct {
 	parserType string
 }

-// deviceKey is a composite key for a device, used to identify a device uniquely.
-type deviceKey struct {
-	name       string
-	deviceType string
-}
-
 var errNoValidSmartData = fmt.Errorf("no valid SMART data found") // Error for missing data

 // Refresh updates SMART data for all known devices
@@ -170,35 +164,27 @@ func (sm *SmartManager) ScanDevices(force bool) error {
 		configuredDevices = parsedDevices
 	}

+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, sm.binPath, "--scan", "-j")
+	output, err := cmd.Output()
+
 	var (
 		scanErr        error
 		scannedDevices []*DeviceInfo
 		hasValidScan   bool
 	)

-	if sm.smartctlPath != "" {
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, sm.smartctlPath, "--scan", "-j")
-		output, err := cmd.Output()
-		if err != nil {
-			scanErr = err
-		} else {
-			scannedDevices, hasValidScan = sm.parseScan(output)
-			if !hasValidScan {
-				scanErr = errNoValidSmartData
-			}
+	if err != nil {
+		scanErr = err
+	} else {
+		scannedDevices, hasValidScan = sm.parseScan(output)
+		if !hasValidScan {
+			scanErr = errNoValidSmartData
 		}
 	}

-	// Add eMMC devices (Linux only) by reading sysfs health fields. This does not
-	// require smartctl and does not scan the whole device.
-	if emmcDevices := scanEmmcDevices(); len(emmcDevices) > 0 {
-		scannedDevices = append(scannedDevices, emmcDevices...)
-		hasValidScan = true
-	}
-
 	finalDevices := mergeDeviceLists(currentDevices, scannedDevices, configuredDevices)
 	finalDevices = sm.filterExcludedDevices(finalDevices)
 	sm.updateSmartDevices(finalDevices)
@@ -215,11 +201,7 @@ func (sm *SmartManager) ScanDevices(force bool) error {
 }

 func (sm *SmartManager) parseConfiguredDevices(config string) ([]*DeviceInfo, error) {
-	splitChar := os.Getenv("SMART_DEVICES_SEPARATOR")
-	if splitChar == "" {
-		splitChar = ","
-	}
-	entries := strings.Split(config, splitChar)
+	entries := strings.Split(config, ",")
 	devices := make([]*DeviceInfo, 0, len(entries))
 	for _, entry := range entries {
 		entry = strings.TrimSpace(entry)
@@ -343,13 +325,6 @@ func normalizeParserType(value string) string {
 	}
 }

-// makeDeviceKey creates a composite key from device name and type.
-// This allows multiple drives under the same device path (e.g., RAID controllers)
-// to be tracked separately.
-func makeDeviceKey(name, deviceType string) deviceKey {
-	return deviceKey{name: name, deviceType: deviceType}
-}
-
 // parseSmartOutput attempts each SMART parser, optionally detecting the type when
 // it is not provided, and updates the device info when a parser succeeds.
 func (sm *SmartManager) parseSmartOutput(deviceInfo *DeviceInfo, output []byte) bool {
@@ -450,75 +425,35 @@ func (sm *SmartManager) CollectSmart(deviceInfo *DeviceInfo) error {
 		return errNoValidSmartData
 	}

-	// eMMC health is not exposed via SMART on Linux, but the kernel provides
-	// wear / EOL indicators via sysfs. Prefer that path when available.
-	if deviceInfo != nil {
-		if ok, err := sm.collectEmmcHealth(deviceInfo); ok {
-			return err
-		}
-	}
-
-	if sm.smartctlPath == "" {
-		return errNoValidSmartData
-	}
-
 	// slog.Info("collecting SMART data", "device", deviceInfo.Name, "type", deviceInfo.Type, "has_existing_data", sm.hasDataForDevice(deviceInfo.Name))

 	// Check if we have any existing data for this device
 	hasExistingData := sm.hasDataForDevice(deviceInfo.Name)

-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()

 	// Try with -n standby first if we have existing data
-	args := sm.smartctlArgs(deviceInfo, hasExistingData)
-	cmd := exec.CommandContext(ctx, sm.smartctlPath, args...)
+	args := sm.smartctlArgs(deviceInfo, true)
+	cmd := exec.CommandContext(ctx, sm.binPath, args...)
 	output, err := cmd.CombinedOutput()

 	// Check if device is in standby (exit status 2)
-	if exitErr, ok := errors.AsType[*exec.ExitError](err); ok && exitErr.ExitCode() == 2 {
+	if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 2 {
 		if hasExistingData {
 			// Device is in standby and we have cached data, keep using cache
 			return nil
 		}
 		// No cached data, need to collect initial data by bypassing standby
-		ctx2, cancel2 := context.WithTimeout(context.Background(), 15*time.Second)
+		ctx2, cancel2 := context.WithTimeout(context.Background(), 2*time.Second)
 		defer cancel2()
 		args = sm.smartctlArgs(deviceInfo, false)
-		cmd = exec.CommandContext(ctx2, sm.smartctlPath, args...)
+		cmd = exec.CommandContext(ctx2, sm.binPath, args...)
 		output, err = cmd.CombinedOutput()
 	}

 	hasValidData := sm.parseSmartOutput(deviceInfo, output)

-	// If NVMe controller path failed, try namespace path as fallback.
-	// NVMe controllers (/dev/nvme0) don't always support SMART queries. See github.com/henrygd/beszel/issues/1504
-	if !hasValidData && err != nil && isNvmeControllerPath(deviceInfo.Name) {
-		controllerPath := deviceInfo.Name
-		namespacePath := controllerPath + "n1"
-		if !sm.isExcludedDevice(namespacePath) {
-			deviceInfo.Name = namespacePath
-
-			ctx3, cancel3 := context.WithTimeout(context.Background(), 15*time.Second)
-			defer cancel3()
-			args = sm.smartctlArgs(deviceInfo, false)
-			cmd = exec.CommandContext(ctx3, sm.smartctlPath, args...)
-			output, err = cmd.CombinedOutput()
-			hasValidData = sm.parseSmartOutput(deviceInfo, output)
-
-			// Auto-exclude the controller path so future scans don't re-add it
-			if hasValidData {
-				sm.Lock()
-				if sm.excludedDevices == nil {
-					sm.excludedDevices = make(map[string]struct{})
-				}
-				sm.excludedDevices[controllerPath] = struct{}{}
-				sm.Unlock()
-				slog.Debug("auto-excluded NVMe controller path", "path", controllerPath)
-			}
-		}
-	}
-
 	if !hasValidData {
 		if err != nil {
 			slog.Info("smartctl failed", "device", deviceInfo.Name, "err", err)
@@ -534,12 +469,10 @@ func (sm *SmartManager) CollectSmart(deviceInfo *DeviceInfo) error {
 // smartctlArgs returns the arguments for the smartctl command
 // based on the device type and whether to include standby mode
 func (sm *SmartManager) smartctlArgs(deviceInfo *DeviceInfo, includeStandby bool) []string {
-	args := make([]string, 0, 9)
-	var deviceType, parserType string
+	args := make([]string, 0, 7)

 	if deviceInfo != nil {
-		deviceType = strings.ToLower(deviceInfo.Type)
-		parserType = strings.ToLower(deviceInfo.parserType)
+		deviceType := strings.ToLower(deviceInfo.Type)
 		// types sometimes misidentified in scan; see github.com/henrygd/beszel/issues/1345
 		if deviceType != "" && deviceType != "scsi" && deviceType != "ata" {
 			args = append(args, "-d", deviceInfo.Type)
@@ -547,13 +480,6 @@ func (sm *SmartManager) smartctlArgs(deviceInfo *DeviceInfo, includeStandby bool
 	}

 	args = append(args, "-a", "--json=c")
-	effectiveType := parserType
-	if effectiveType == "" {
-		effectiveType = deviceType
-	}
-	if effectiveType == "sat" || effectiveType == "ata" {
-		args = append(args, "-l", "devstat")
-	}

 	if includeStandby {
 		args = append(args, "-n", "standby")
@@ -614,28 +540,6 @@ func mergeDeviceLists(existing, scanned, configured []*DeviceInfo) []*DeviceInfo
 		return existing
 	}

-	// buildUniqueNameIndex returns devices that appear exactly once by name.
-	// It is used to safely apply name-only fallbacks without RAID ambiguity.
-	buildUniqueNameIndex := func(devices []*DeviceInfo) map[string]*DeviceInfo {
-		counts := make(map[string]int, len(devices))
-		for _, dev := range devices {
-			if dev == nil || dev.Name == "" {
-				continue
-			}
-			counts[dev.Name]++
-		}
-		unique := make(map[string]*DeviceInfo, len(counts))
-		for _, dev := range devices {
-			if dev == nil || dev.Name == "" {
-				continue
-			}
-			if counts[dev.Name] == 1 {
-				unique[dev.Name] = dev
-			}
-		}
-		return unique
-	}
-
 	// preserveVerifiedType copies the verified type/parser metadata from an existing
 	// device record so that subsequent scans/config updates never downgrade a
 	// previously verified device.
@@ -648,90 +552,69 @@ func mergeDeviceLists(existing, scanned, configured []*DeviceInfo) []*DeviceInfo
 		target.parserType = prev.parserType
 	}

-	// applyConfiguredMetadata updates a matched device with any configured
-	// overrides, preserving verified type data when present.
-	applyConfiguredMetadata := func(existingDev, configuredDev *DeviceInfo) {
-		// Only update the type if it has not been verified yet; otherwise we
-		// keep the existing verified metadata intact.
-		if configuredDev.Type != "" && !existingDev.typeVerified {
-			newType := strings.TrimSpace(configuredDev.Type)
-			existingDev.Type = newType
-			existingDev.typeVerified = false
-			existingDev.parserType = normalizeParserType(newType)
-		}
-		if configuredDev.InfoName != "" {
-			existingDev.InfoName = configuredDev.InfoName
-		}
-		if configuredDev.Protocol != "" {
-			existingDev.Protocol = configuredDev.Protocol
-		}
-	}
-
-	existingIndex := make(map[deviceKey]*DeviceInfo, len(existing))
+	existingIndex := make(map[string]*DeviceInfo, len(existing))
 	for _, dev := range existing {
 		if dev == nil || dev.Name == "" {
 			continue
 		}
-		existingIndex[makeDeviceKey(dev.Name, dev.Type)] = dev
+		existingIndex[dev.Name] = dev
 	}
-	existingByName := buildUniqueNameIndex(existing)

 	finalDevices := make([]*DeviceInfo, 0, len(scanned)+len(configured))
-	deviceIndex := make(map[deviceKey]*DeviceInfo, len(scanned)+len(configured))
+	deviceIndex := make(map[string]*DeviceInfo, len(scanned)+len(configured))

 	// Start with the newly scanned devices so we always surface fresh metadata,
 	// but ensure we retain any previously verified parser assignment.
-	for _, scannedDevice := range scanned {
-		if scannedDevice == nil || scannedDevice.Name == "" {
+	for _, dev := range scanned {
+		if dev == nil || dev.Name == "" {
 			continue
 		}

 		// Work on a copy so we can safely adjust metadata without mutating the
 		// input slices that may be reused elsewhere.
-		copyDev := *scannedDevice
-		key := makeDeviceKey(copyDev.Name, copyDev.Type)
-		if prev := existingIndex[key]; prev != nil {
-			preserveVerifiedType(&copyDev, prev)
-		} else if prev := existingByName[copyDev.Name]; prev != nil {
+		copyDev := *dev
+		if prev := existingIndex[copyDev.Name]; prev != nil {
 			preserveVerifiedType(&copyDev, prev)
 		}

 		finalDevices = append(finalDevices, &copyDev)
-		copyKey := makeDeviceKey(copyDev.Name, copyDev.Type)
-		deviceIndex[copyKey] = finalDevices[len(finalDevices)-1]
+		deviceIndex[copyDev.Name] = finalDevices[len(finalDevices)-1]
 	}
-	deviceIndexByName := buildUniqueNameIndex(finalDevices)

 	// Merge configured devices on top so users can override scan results (except
 	// for verified type information).
-	for _, configuredDevice := range configured {
-		if configuredDevice == nil || configuredDevice.Name == "" {
+	for _, dev := range configured {
+		if dev == nil || dev.Name == "" {
 			continue
 		}

-		key := makeDeviceKey(configuredDevice.Name, configuredDevice.Type)
-		if existingDev, ok := deviceIndex[key]; ok {
-			applyConfiguredMetadata(existingDev, configuredDevice)
-			continue
-		}
-		if existingDev := deviceIndexByName[configuredDevice.Name]; existingDev != nil {
-			applyConfiguredMetadata(existingDev, configuredDevice)
+		if existingDev, ok := deviceIndex[dev.Name]; ok {
+			// Only update the type if it has not been verified yet; otherwise we
+			// keep the existing verified metadata intact.
+			if dev.Type != "" && !existingDev.typeVerified {
+				newType := strings.TrimSpace(dev.Type)
+				existingDev.Type = newType
+				existingDev.typeVerified = false
+				existingDev.parserType = normalizeParserType(newType)
+			}
+			if dev.InfoName != "" {
+				existingDev.InfoName = dev.InfoName
+			}
+			if dev.Protocol != "" {
+				existingDev.Protocol = dev.Protocol
+			}
 			continue
 		}

-		copyDev := *configuredDevice
-		key = makeDeviceKey(copyDev.Name, copyDev.Type)
-		if prev := existingIndex[key]; prev != nil {
-			preserveVerifiedType(&copyDev, prev)
-		} else if prev := existingByName[copyDev.Name]; prev != nil {
+		copyDev := *dev
+		if prev := existingIndex[copyDev.Name]; prev != nil {
 			preserveVerifiedType(&copyDev, prev)
 		} else if copyDev.Type != "" {
 			copyDev.parserType = normalizeParserType(copyDev.Type)
 		}

 		finalDevices = append(finalDevices, &copyDev)
-		copyKey := makeDeviceKey(copyDev.Name, copyDev.Type)
-		deviceIndex[copyKey] = finalDevices[len(finalDevices)-1]
+		deviceIndex[copyDev.Name] = finalDevices[len(finalDevices)-1]
 	}

 	return finalDevices
@@ -749,14 +632,12 @@ func (sm *SmartManager) updateSmartDevices(devices []*DeviceInfo) {
 		return
 	}

-	validKeys := make(map[deviceKey]struct{}, len(devices))
-	nameCounts := make(map[string]int, len(devices))
+	validNames := make(map[string]struct{}, len(devices))
 	for _, device := range devices {
 		if device == nil || device.Name == "" {
 			continue
 		}
-		validKeys[makeDeviceKey(device.Name, device.Type)] = struct{}{}
-		nameCounts[device.Name]++
+		validNames[device.Name] = struct{}{}
 	}

 	for key, data := range sm.SmartDataMap {
@@ -765,11 +646,7 @@ func (sm *SmartManager) updateSmartDevices(devices []*DeviceInfo) {
 			continue
 		}

-		if data.DiskType == "" {
-			if nameCounts[data.DiskName] == 1 {
-				continue
-			}
-		} else if _, ok := validKeys[makeDeviceKey(data.DiskName, data.DiskType)]; ok {
+		if _, ok := validNames[data.DiskName]; ok {
 			continue
 		}

@@ -857,11 +734,6 @@ func (sm *SmartManager) parseSmartForSata(output []byte) (bool, int) {
 	smartData.FirmwareVersion = data.FirmwareVersion
 	smartData.Capacity = data.UserCapacity.Bytes
 	smartData.Temperature = data.Temperature.Current
-	if smartData.Temperature == 0 {
-		if temp, ok := temperatureFromAtaDeviceStatistics(data.AtaDeviceStatistics); ok {
-			smartData.Temperature = temp
-		}
-	}
 	smartData.SmartStatus = getSmartStatus(smartData.Temperature, data.SmartStatus.Passed)
 	smartData.DiskName = data.Device.Name
 	smartData.DiskType = data.Device.Type
@@ -900,36 +772,6 @@ func getSmartStatus(temperature uint8, passed bool) string {
 	}
 }

-func temperatureFromAtaDeviceStatistics(stats smart.AtaDeviceStatistics) (uint8, bool) {
-	entry := findAtaDeviceStatisticsEntry(stats, 5, "Current Temperature")
-	if entry == nil || entry.Value == nil {
-		return 0, false
-	}
-	if *entry.Value > 255 {
-		return 0, false
-	}
-	return uint8(*entry.Value), true
-}
-
-// findAtaDeviceStatisticsEntry centralizes ATA devstat lookups so additional
-// metrics can be pulled from the same structure in the future.
-func findAtaDeviceStatisticsEntry(stats smart.AtaDeviceStatistics, pageNumber uint8, entryName string) *smart.AtaDeviceStatisticsEntry {
-	for pageIdx := range stats.Pages {
-		page := &stats.Pages[pageIdx]
-		if page.Number != pageNumber {
-			continue
-		}
-		for entryIdx := range page.Table {
-			entry := &page.Table[entryIdx]
-			if !strings.EqualFold(entry.Name, entryName) {
-				continue
-			}
-			return entry
-		}
-	}
-	return nil
-}
-
 func (sm *SmartManager) parseSmartForScsi(output []byte) (bool, int) {
 	var data smart.SmartInfoForScsi

@@ -1115,27 +957,6 @@ func (sm *SmartManager) detectSmartctl() (string, error) {
 	return "", errors.New("smartctl not found")
 }

-// isNvmeControllerPath checks if the path matches an NVMe controller pattern
-// like /dev/nvme0, /dev/nvme1, etc. (without namespace suffix like n1)
-func isNvmeControllerPath(path string) bool {
-	base := filepath.Base(path)
-	if !strings.HasPrefix(base, "nvme") {
-		return false
-	}
-	suffix := strings.TrimPrefix(base, "nvme")
-	if suffix == "" {
-		return false
-	}
-	// Controller paths are just "nvme" + digits (e.g., nvme0, nvme1)
-	// Namespace paths have "n" after the controller number (e.g., nvme0n1)
-	for _, c := range suffix {
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
-}
-
 // NewSmartManager creates and initializes a new SmartManager
 func NewSmartManager() (*SmartManager, error) {
 	sm := &SmartManager{
@@ -1143,15 +964,11 @@ func NewSmartManager() (*SmartManager, error) {
 	}
 	sm.refreshExcludedDevices()
 	path, err := sm.detectSmartctl()
-	slog.Debug("smartctl", "path", path, "err", err)
 	if err != nil {
-		// Keep the previous fail-fast behavior unless this Linux host exposes
-		// eMMC health via sysfs, in which case smartctl is optional.
-		if runtime.GOOS == "linux" && len(scanEmmcDevices()) > 0 {
-			return sm, nil
-		}
+		slog.Debug(err.Error())
 		return nil, err
 	}
-	sm.smartctlPath = path
+	slog.Debug("smartctl", "path", path)
+	sm.binPath = path
 	return sm, nil
 }
--- a/agent/smart_test.go
+++ b/agent/smart_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package agent

@@ -88,39 +89,6 @@ func TestParseSmartForSata(t *testing.T) {
 	}
 }

-func TestParseSmartForSataDeviceStatisticsTemperature(t *testing.T) {
-	jsonPayload := []byte(`{
-		"smartctl": {"exit_status": 0},
-		"device": {"name": "/dev/sdb", "type": "sat"},
-		"model_name": "SanDisk SSD U110 16GB",
-		"serial_number": "DEVSTAT123",
-		"firmware_version": "U21B001",
-		"user_capacity": {"bytes": 16013942784},
-		"smart_status": {"passed": true},
-		"ata_smart_attributes": {"table": []},
-		"ata_device_statistics": {
-			"pages": [
-				{
-					"number": 5,
-					"name": "Temperature Statistics",
-					"table": [
-						{"name": "Current Temperature", "value": 22, "flags": {"valid": true}}
-					]
-				}
-			]
-		}
-	}`)
-
-	sm := &SmartManager{SmartDataMap: make(map[string]*smart.SmartData)}
-	hasData, exitStatus := sm.parseSmartForSata(jsonPayload)
-	require.True(t, hasData)
-	assert.Equal(t, 0, exitStatus)
-
-	deviceData, ok := sm.SmartDataMap["DEVSTAT123"]
-	require.True(t, ok, "expected smart data entry for serial DEVSTAT123")
-	assert.Equal(t, uint8(22), deviceData.Temperature)
-}
-
 func TestParseSmartForSataParentheticalRawValue(t *testing.T) {
 	jsonPayload := []byte(`{
 		"smartctl": {"exit_status": 0},
@@ -227,24 +195,6 @@ func TestDevicesSnapshotReturnsCopy(t *testing.T) {
 	assert.Len(t, snapshot, 2)
 }

-func TestScanDevicesWithEnvOverrideAndSeparator(t *testing.T) {
-	t.Setenv("SMART_DEVICES_SEPARATOR", "|")
-	t.Setenv("SMART_DEVICES", "/dev/sda:jmb39x-q,0|/dev/nvme0:nvme")
-
-	sm := &SmartManager{
-		SmartDataMap: make(map[string]*smart.SmartData),
-	}
-
-	err := sm.ScanDevices(true)
-	require.NoError(t, err)
-
-	require.Len(t, sm.SmartDevices, 2)
-	assert.Equal(t, "/dev/sda", sm.SmartDevices[0].Name)
-	assert.Equal(t, "jmb39x-q,0", sm.SmartDevices[0].Type)
-	assert.Equal(t, "/dev/nvme0", sm.SmartDevices[1].Name)
-	assert.Equal(t, "nvme", sm.SmartDevices[1].Type)
-}
-
 func TestScanDevicesWithEnvOverride(t *testing.T) {
 	t.Setenv("SMART_DEVICES", "/dev/sda:sat, /dev/nvme0:nvme")

@@ -299,21 +249,15 @@ func TestSmartctlArgs(t *testing.T) {

 	sataDevice := &DeviceInfo{Name: "/dev/sda", Type: "sat"}
 	assert.Equal(t,
-		[]string{"-d", "sat", "-a", "--json=c", "-l", "devstat", "-n", "standby", "/dev/sda"},
+		[]string{"-d", "sat", "-a", "--json=c", "-n", "standby", "/dev/sda"},
 		sm.smartctlArgs(sataDevice, true),
 	)

 	assert.Equal(t,
-		[]string{"-d", "sat", "-a", "--json=c", "-l", "devstat", "/dev/sda"},
+		[]string{"-d", "sat", "-a", "--json=c", "/dev/sda"},
 		sm.smartctlArgs(sataDevice, false),
 	)

-	nvmeDevice := &DeviceInfo{Name: "/dev/nvme0", Type: "nvme"}
-	assert.Equal(t,
-		[]string{"-d", "nvme", "-a", "--json=c", "-n", "standby", "/dev/nvme0"},
-		sm.smartctlArgs(nvmeDevice, true),
-	)
-
 	assert.Equal(t,
 		[]string{"-a", "--json=c", "-n", "standby"},
 		sm.smartctlArgs(nil, true),
@@ -498,88 +442,6 @@ func TestMergeDeviceListsUpdatesTypeWhenUnverified(t *testing.T) {
 	assert.Equal(t, "", device.parserType)
 }

-func TestMergeDeviceListsHandlesDevicesWithSameNameAndDifferentTypes(t *testing.T) {
-	// There are use cases where the same device name is re-used,
-	// for example, a RAID controller with multiple drives.
-	scanned := []*DeviceInfo{
-		{Name: "/dev/sda", Type: "megaraid,0"},
-		{Name: "/dev/sda", Type: "megaraid,1"},
-		{Name: "/dev/sda", Type: "megaraid,2"},
-	}
-
-	merged := mergeDeviceLists(nil, scanned, nil)
-	require.Len(t, merged, 3, "should have 3 separate devices for RAID controller")
-
-	byKey := make(map[string]*DeviceInfo, len(merged))
-	for _, dev := range merged {
-		key := dev.Name + "|" + dev.Type
-		byKey[key] = dev
-	}
-
-	assert.Contains(t, byKey, "/dev/sda|megaraid,0")
-	assert.Contains(t, byKey, "/dev/sda|megaraid,1")
-	assert.Contains(t, byKey, "/dev/sda|megaraid,2")
-}
-
-func TestMergeDeviceListsHandlesMixedRAIDAndRegular(t *testing.T) {
-	// Test mixing RAID drives with regular devices
-	scanned := []*DeviceInfo{
-		{Name: "/dev/sda", Type: "megaraid,0"},
-		{Name: "/dev/sda", Type: "megaraid,1"},
-		{Name: "/dev/sdb", Type: "sat"},
-		{Name: "/dev/nvme0", Type: "nvme"},
-	}
-
-	merged := mergeDeviceLists(nil, scanned, nil)
-	require.Len(t, merged, 4, "should have 4 separate devices")
-
-	byKey := make(map[string]*DeviceInfo, len(merged))
-	for _, dev := range merged {
-		key := dev.Name + "|" + dev.Type
-		byKey[key] = dev
-	}
-
-	assert.Contains(t, byKey, "/dev/sda|megaraid,0")
-	assert.Contains(t, byKey, "/dev/sda|megaraid,1")
-	assert.Contains(t, byKey, "/dev/sdb|sat")
-	assert.Contains(t, byKey, "/dev/nvme0|nvme")
-}
-
-func TestUpdateSmartDevicesPreservesRAIDDrives(t *testing.T) {
-	// Test that updateSmartDevices correctly validates RAID drives using composite keys
-	sm := &SmartManager{
-		SmartDevices: []*DeviceInfo{
-			{Name: "/dev/sda", Type: "megaraid,0"},
-			{Name: "/dev/sda", Type: "megaraid,1"},
-		},
-		SmartDataMap: map[string]*smart.SmartData{
-			"serial-0": {
-				DiskName:     "/dev/sda",
-				DiskType:     "megaraid,0",
-				SerialNumber: "serial-0",
-			},
-			"serial-1": {
-				DiskName:     "/dev/sda",
-				DiskType:     "megaraid,1",
-				SerialNumber: "serial-1",
-			},
-			"serial-stale": {
-				DiskName:     "/dev/sda",
-				DiskType:     "megaraid,2",
-				SerialNumber: "serial-stale",
-			},
-		},
-	}
-
-	sm.updateSmartDevices(sm.SmartDevices)
-
-	// serial-0 and serial-1 should be preserved (matching devices exist)
-	assert.Contains(t, sm.SmartDataMap, "serial-0")
-	assert.Contains(t, sm.SmartDataMap, "serial-1")
-	// serial-stale should be removed (no matching device)
-	assert.NotContains(t, sm.SmartDataMap, "serial-stale")
-}
-
 func TestParseSmartOutputMarksVerified(t *testing.T) {
 	fixturePath := filepath.Join("test-data", "smart", "nvme0.json")
 	data, err := os.ReadFile(fixturePath)
@@ -918,36 +780,3 @@ func TestFilterExcludedDevices(t *testing.T) {
 		})
 	}
 }
-
-func TestIsNvmeControllerPath(t *testing.T) {
-	tests := []struct {
-		path     string
-		expected bool
-	}{
-		// Controller paths (should return true)
-		{"/dev/nvme0", true},
-		{"/dev/nvme1", true},
-		{"/dev/nvme10", true},
-		{"nvme0", true},
-
-		// Namespace paths (should return false)
-		{"/dev/nvme0n1", false},
-		{"/dev/nvme1n1", false},
-		{"/dev/nvme0n1p1", false},
-		{"nvme0n1", false},
-
-		// Non-NVMe paths (should return false)
-		{"/dev/sda", false},
-		{"/dev/sda1", false},
-		{"/dev/hda", false},
-		{"", false},
-		{"/dev/nvme", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.path, func(t *testing.T) {
-			result := isNvmeControllerPath(tt.path)
-			assert.Equal(t, tt.expected, result, "path: %s", tt.path)
-		})
-	}
-}
--- a/agent/system.go
+++ b/agent/system.go
@@ -2,18 +2,15 @@ package agent

 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"log/slog"
 	"os"
-	"runtime"
 	"strconv"
 	"strings"
 	"time"

 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/agent/battery"
-	"github.com/henrygd/beszel/internal/entities/container"
 	"github.com/henrygd/beszel/internal/entities/system"

 	"github.com/shirou/gopsutil/v4/cpu"
@@ -30,79 +27,41 @@ type prevDisk struct {
 }

 // Sets initial / non-changing values about the host system
-func (a *Agent) refreshSystemDetails() {
+func (a *Agent) initializeSystemInfo() {
 	a.systemInfo.AgentVersion = beszel.Version
-
-	// get host info from Docker if available
-	var hostInfo container.HostInfo
-
-	if a.dockerManager != nil {
-		a.systemDetails.Podman = a.dockerManager.IsPodman()
-		hostInfo, _ = a.dockerManager.GetHostInfo()
-	}
-
-	a.systemDetails.Hostname, _ = os.Hostname()
-	if arch, err := host.KernelArch(); err == nil {
-		a.systemDetails.Arch = arch
-	} else {
-		a.systemDetails.Arch = runtime.GOARCH
-	}
+	a.systemInfo.Hostname, _ = os.Hostname()

 	platform, _, version, _ := host.PlatformInformation()

 	if platform == "darwin" {
-		a.systemDetails.Os = system.Darwin
-		a.systemDetails.OsName = fmt.Sprintf("macOS %s", version)
+		a.systemInfo.KernelVersion = version
+		a.systemInfo.Os = system.Darwin
 	} else if strings.Contains(platform, "indows") {
-		a.systemDetails.Os = system.Windows
-		a.systemDetails.OsName = strings.Replace(platform, "Microsoft ", "", 1)
-		a.systemDetails.Kernel = version
+		a.systemInfo.KernelVersion = fmt.Sprintf("%s %s", strings.Replace(platform, "Microsoft ", "", 1), version)
+		a.systemInfo.Os = system.Windows
 	} else if platform == "freebsd" {
-		a.systemDetails.Os = system.Freebsd
-		a.systemDetails.Kernel, _ = host.KernelVersion()
-		if prettyName, err := getOsPrettyName(); err == nil {
-			a.systemDetails.OsName = prettyName
-		} else {
-			a.systemDetails.OsName = "FreeBSD"
-		}
+		a.systemInfo.Os = system.Freebsd
+		a.systemInfo.KernelVersion = version
 	} else {
-		a.systemDetails.Os = system.Linux
-		a.systemDetails.OsName = hostInfo.OperatingSystem
-		if a.systemDetails.OsName == "" {
-			if prettyName, err := getOsPrettyName(); err == nil {
-				a.systemDetails.OsName = prettyName
-			} else {
-				a.systemDetails.OsName = platform
-			}
-		}
-		a.systemDetails.Kernel = hostInfo.KernelVersion
-		if a.systemDetails.Kernel == "" {
-			a.systemDetails.Kernel, _ = host.KernelVersion()
-		}
+		a.systemInfo.Os = system.Linux
+	}
+
+	if a.systemInfo.KernelVersion == "" {
+		a.systemInfo.KernelVersion, _ = host.KernelVersion()
 	}

 	// cpu model
 	if info, err := cpu.Info(); err == nil && len(info) > 0 {
-		a.systemDetails.CpuModel = info[0].ModelName
+		a.systemInfo.CpuModel = info[0].ModelName
 	}
 	// cores / threads
-	cores, _ := cpu.Counts(false)
-	threads := hostInfo.NCPU
-	if threads == 0 {
-		threads, _ = cpu.Counts(true)
-	}
-	// in lxc, logical cores reflects container limits, so use that as cores if lower
-	if threads > 0 && threads < cores {
-		cores = threads
-	}
-	a.systemDetails.Cores = cores
-	a.systemDetails.Threads = threads
-
-	// total memory
-	a.systemDetails.MemoryTotal = hostInfo.MemTotal
-	if a.systemDetails.MemoryTotal == 0 {
-		if v, err := mem.VirtualMemory(); err == nil {
-			a.systemDetails.MemoryTotal = v.Total
+	a.systemInfo.Cores, _ = cpu.Counts(false)
+	if threads, err := cpu.Counts(true); err == nil {
+		if threads > 0 && threads < a.systemInfo.Cores {
+			// in lxc logical cores reflects container limits, so use that as cores if lower
+			a.systemInfo.Cores = threads
+		} else {
+			a.systemInfo.Threads = threads
 		}
 	}

@@ -236,16 +195,21 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		}
 	}

-	// update system info
+	// update base system info
 	a.systemInfo.ConnectionType = a.connectionManager.ConnectionType
 	a.systemInfo.Cpu = systemStats.Cpu
 	a.systemInfo.LoadAvg = systemStats.LoadAvg
+	// TODO: remove these in future release in favor of load avg array
+	a.systemInfo.LoadAvg1 = systemStats.LoadAvg[0]
+	a.systemInfo.LoadAvg5 = systemStats.LoadAvg[1]
+	a.systemInfo.LoadAvg15 = systemStats.LoadAvg[2]
 	a.systemInfo.MemPct = systemStats.MemPct
 	a.systemInfo.DiskPct = systemStats.DiskPct
-	a.systemInfo.Battery = systemStats.Battery
 	a.systemInfo.Uptime, _ = host.Uptime()
+	// TODO: in future release, remove MB bandwidth values in favor of bytes
+	a.systemInfo.Bandwidth = twoDecimals(systemStats.NetworkSent + systemStats.NetworkRecv)
 	a.systemInfo.BandwidthBytes = systemStats.Bandwidth[0] + systemStats.Bandwidth[1]
-	a.systemInfo.Threads = a.systemDetails.Threads
+	slog.Debug("sysinfo", "data", a.systemInfo)

 	return systemStats
 }
@@ -275,24 +239,3 @@ func getARCSize() (uint64, error) {

 	return 0, fmt.Errorf("failed to parse size field")
 }
-
-// getOsPrettyName attempts to get the pretty OS name from /etc/os-release on Linux systems
-func getOsPrettyName() (string, error) {
-	file, err := os.Open("/etc/os-release")
-	if err != nil {
-		return "", err
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if after, ok := strings.CutPrefix(line, "PRETTY_NAME="); ok {
-			value := after
-			value = strings.Trim(value, `"`)
-			return value, nil
-		}
-	}
-
-	return "", errors.New("pretty name not found")
-}
--- a/agent/systemd.go
+++ b/agent/systemd.go
@@ -8,7 +8,6 @@ import (
 	"log/slog"
 	"maps"
 	"math"
-	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -29,36 +28,11 @@ type systemdManager struct {
 	patterns        []string
 }

-// isSystemdAvailable checks if systemd is used on the system to avoid unnecessary connection attempts (#1548)
-func isSystemdAvailable() bool {
-	paths := []string{
-		"/run/systemd/system",
-		"/run/dbus/system_bus_socket",
-		"/var/run/dbus/system_bus_socket",
-	}
-	for _, path := range paths {
-		if _, err := os.Stat(path); err == nil {
-			return true
-		}
-	}
-	if data, err := os.ReadFile("/proc/1/comm"); err == nil {
-		return strings.TrimSpace(string(data)) == "systemd"
-	}
-	return false
-}
-
 // newSystemdManager creates a new systemdManager.
 func newSystemdManager() (*systemdManager, error) {
 	if skipSystemd, _ := GetEnv("SKIP_SYSTEMD"); skipSystemd == "true" {
 		return nil, nil
 	}
-
-	// Check if systemd is available on the system before attempting connection
-	if !isSystemdAvailable() {
-		slog.Debug("Systemd not available")
-		return nil, nil
-	}
-
 	conn, err := dbus.NewSystemConnectionContext(context.Background())
 	if err != nil {
 		slog.Debug("Error connecting to systemd", "err", err, "ref", "https://beszel.dev/guide/systemd")
@@ -144,27 +118,13 @@ func (sm *systemdManager) getServiceStats(conn *dbus.Conn, refresh bool) []*syst
 		return nil
 	}

-	// Track which units are currently present to remove stale entries
-	currentUnits := make(map[string]struct{}, len(units))
-
 	for _, unit := range units {
-		currentUnits[unit.Name] = struct{}{}
 		service, err := sm.updateServiceStats(conn, unit)
 		if err != nil {
 			continue
 		}
 		services = append(services, service)
 	}
-
-	// Remove services that no longer exist in systemd
-	sm.Lock()
-	for unitName := range sm.serviceStatsMap {
-		if _, exists := currentUnits[unitName]; !exists {
-			delete(sm.serviceStatsMap, unitName)
-		}
-	}
-	sm.Unlock()
-
 	sm.hasFreshStats = true
 	return services
 }
--- a/agent/systemd_nonlinux_test.go
+++ b/agent/systemd_nonlinux_test.go
@@ -19,11 +19,11 @@ func TestSystemdManagerGetServiceStats(t *testing.T) {
 	assert.NoError(t, err)

 	// Test with refresh = true
-	result := manager.getServiceStats("any-service", true)
+	result := manager.getServiceStats(true)
 	assert.Nil(t, result)

 	// Test with refresh = false
-	result = manager.getServiceStats("any-service", false)
+	result = manager.getServiceStats(false)
 	assert.Nil(t, result)
 }

--- a/agent/systemd_test.go
+++ b/agent/systemd_test.go
@@ -4,7 +4,6 @@ package agent

 import (
 	"os"
-	"strings"
 	"testing"

 	"github.com/stretchr/testify/assert"
@@ -49,35 +48,6 @@ func TestUnescapeServiceNameInvalid(t *testing.T) {
 	}
 }

-func TestIsSystemdAvailable(t *testing.T) {
-	// Note: This test's result will vary based on the actual system running the tests
-	// On systems with systemd, it should return true
-	// On systems without systemd, it should return false
-	result := isSystemdAvailable()
-
-	// Check if either the /run/systemd/system directory exists or PID 1 is systemd
-	runSystemdExists := false
-	if _, err := os.Stat("/run/systemd/system"); err == nil {
-		runSystemdExists = true
-	}
-
-	pid1IsSystemd := false
-	if data, err := os.ReadFile("/proc/1/comm"); err == nil {
-		pid1IsSystemd = strings.TrimSpace(string(data)) == "systemd"
-	}
-
-	expected := runSystemdExists || pid1IsSystemd
-
-	assert.Equal(t, expected, result, "isSystemdAvailable should correctly detect systemd presence")
-
-	// Log the result for informational purposes
-	if result {
-		t.Log("Systemd is available on this system")
-	} else {
-		t.Log("Systemd is not available on this system")
-	}
-}
-
 func TestGetServicePatterns(t *testing.T) {
 	tests := []struct {
 		name           string
--- a/agent/test-data/amdgpu.ids
+++ b/agent/test-data/amdgpu.ids
@@ -1,700 +0,0 @@
-# List of AMDGPU IDs
-#
-# Syntax:
-# device_id,	revision_id,	product_name        <-- single tab after comma
-
-1.0.0
-1114,	C2,	AMD Radeon 860M Graphics
-1114,	C3,	AMD Radeon 840M Graphics
-1114,	D2,	AMD Radeon 860M Graphics
-1114,	D3,	AMD Radeon 840M Graphics
-1309,	00,	AMD Radeon R7 Graphics
-130A,	00,	AMD Radeon R6 Graphics
-130B,	00,	AMD Radeon R4 Graphics
-130C,	00,	AMD Radeon R7 Graphics
-130D,	00,	AMD Radeon R6 Graphics
-130E,	00,	AMD Radeon R5 Graphics
-130F,	00,	AMD Radeon R7 Graphics
-130F,	D4,	AMD Radeon R7 Graphics
-130F,	D5,	AMD Radeon R7 Graphics
-130F,	D6,	AMD Radeon R7 Graphics
-130F,	D7,	AMD Radeon R7 Graphics
-1313,	00,	AMD Radeon R7 Graphics
-1313,	D4,	AMD Radeon R7 Graphics
-1313,	D5,	AMD Radeon R7 Graphics
-1313,	D6,	AMD Radeon R7 Graphics
-1315,	00,	AMD Radeon R5 Graphics
-1315,	D4,	AMD Radeon R5 Graphics
-1315,	D5,	AMD Radeon R5 Graphics
-1315,	D6,	AMD Radeon R5 Graphics
-1315,	D7,	AMD Radeon R5 Graphics
-1316,	00,	AMD Radeon R5 Graphics
-1318,	00,	AMD Radeon R5 Graphics
-131B,	00,	AMD Radeon R4 Graphics
-131C,	00,	AMD Radeon R7 Graphics
-131D,	00,	AMD Radeon R6 Graphics
-1435,	AE,	AMD Custom GPU 0932
-1506,	C1,	AMD Radeon 610M
-1506,	C2,	AMD Radeon 610M
-1506,	C3,	AMD Radeon 610M
-1506,	C4,	AMD Radeon 610M
-150E,	C1,	AMD Radeon 890M Graphics
-150E,	C4,	AMD Radeon 890M Graphics
-150E,	C5,	AMD Radeon 890M Graphics
-150E,	C6,	AMD Radeon 890M Graphics
-150E,	D1,	AMD Radeon 890M Graphics
-150E,	D2,	AMD Radeon 890M Graphics
-150E,	D3,	AMD Radeon 890M Graphics
-1586,	C1,	Radeon 8060S Graphics
-1586,	C2,	Radeon 8050S Graphics
-1586,	C4,	Radeon 8050S Graphics
-1586,	D1,	Radeon 8060S Graphics
-1586,	D2,	Radeon 8050S Graphics
-1586,	D4,	Radeon 8050S Graphics
-1586,	D5,	Radeon 8040S Graphics
-15BF,	00,	AMD Radeon 780M Graphics
-15BF,	01,	AMD Radeon 760M Graphics
-15BF,	02,	AMD Radeon 780M Graphics
-15BF,	03,	AMD Radeon 760M Graphics
-15BF,	C1,	AMD Radeon 780M Graphics
-15BF,	C2,	AMD Radeon 780M Graphics
-15BF,	C3,	AMD Radeon 760M Graphics
-15BF,	C4,	AMD Radeon 780M Graphics
-15BF,	C5,	AMD Radeon 740M Graphics
-15BF,	C6,	AMD Radeon 780M Graphics
-15BF,	C7,	AMD Radeon 780M Graphics
-15BF,	C8,	AMD Radeon 760M Graphics
-15BF,	C9,	AMD Radeon 780M Graphics
-15BF,	CA,	AMD Radeon 740M Graphics
-15BF,	CB,	AMD Radeon 760M Graphics
-15BF,	CC,	AMD Radeon 740M Graphics
-15BF,	CD,	AMD Radeon 760M Graphics
-15BF,	CF,	AMD Radeon 780M Graphics
-15BF,	D0,	AMD Radeon 780M Graphics
-15BF,	D1,	AMD Radeon 780M Graphics
-15BF,	D2,	AMD Radeon 780M Graphics
-15BF,	D3,	AMD Radeon 780M Graphics
-15BF,	D4,	AMD Radeon 780M Graphics
-15BF,	D5,	AMD Radeon 760M Graphics
-15BF,	D6,	AMD Radeon 760M Graphics
-15BF,	D7,	AMD Radeon 780M Graphics
-15BF,	D8,	AMD Radeon 740M Graphics
-15BF,	D9,	AMD Radeon 780M Graphics
-15BF,	DA,	AMD Radeon 780M Graphics
-15BF,	DB,	AMD Radeon 760M Graphics
-15BF,	DC,	AMD Radeon 760M Graphics
-15BF,	DD,	AMD Radeon 780M Graphics
-15BF,	DE,	AMD Radeon 740M Graphics
-15BF,	DF,	AMD Radeon 760M Graphics
-15BF,	F0,	AMD Radeon 760M Graphics
-15C8,	C1,	AMD Radeon 740M Graphics
-15C8,	C2,	AMD Radeon 740M Graphics
-15C8,	C3,	AMD Radeon 740M Graphics
-15C8,	C4,	AMD Radeon 740M Graphics
-15C8,	D1,	AMD Radeon 740M Graphics
-15C8,	D2,	AMD Radeon 740M Graphics
-15C8,	D3,	AMD Radeon 740M Graphics
-15C8,	D4,	AMD Radeon 740M Graphics
-15D8,	00,	AMD Radeon RX Vega 8 Graphics WS
-15D8,	91,	AMD Radeon Vega 3 Graphics
-15D8,	91,	AMD Ryzen Embedded R1606G with Radeon Vega Gfx
-15D8,	92,	AMD Radeon Vega 3 Graphics
-15D8,	92,	AMD Ryzen Embedded R1505G with Radeon Vega Gfx
-15D8,	93,	AMD Radeon Vega 1 Graphics
-15D8,	A1,	AMD Radeon Vega 10 Graphics
-15D8,	A2,	AMD Radeon Vega 8 Graphics
-15D8,	A3,	AMD Radeon Vega 6 Graphics
-15D8,	A4,	AMD Radeon Vega 3 Graphics
-15D8,	B1,	AMD Radeon Vega 10 Graphics
-15D8,	B2,	AMD Radeon Vega 8 Graphics
-15D8,	B3,	AMD Radeon Vega 6 Graphics
-15D8,	B4,	AMD Radeon Vega 3 Graphics
-15D8,	C1,	AMD Radeon Vega 10 Graphics
-15D8,	C2,	AMD Radeon Vega 8 Graphics
-15D8,	C3,	AMD Radeon Vega 6 Graphics
-15D8,	C4,	AMD Radeon Vega 3 Graphics
-15D8,	C5,	AMD Radeon Vega 3 Graphics
-15D8,	C8,	AMD Radeon Vega 11 Graphics
-15D8,	C9,	AMD Radeon Vega 8 Graphics
-15D8,	CA,	AMD Radeon Vega 11 Graphics
-15D8,	CB,	AMD Radeon Vega 8 Graphics
-15D8,	CC,	AMD Radeon Vega 3 Graphics
-15D8,	CE,	AMD Radeon Vega 3 Graphics
-15D8,	CF,	AMD Ryzen Embedded R1305G with Radeon Vega Gfx
-15D8,	D1,	AMD Radeon Vega 10 Graphics
-15D8,	D2,	AMD Radeon Vega 8 Graphics
-15D8,	D3,	AMD Radeon Vega 6 Graphics
-15D8,	D4,	AMD Radeon Vega 3 Graphics
-15D8,	D8,	AMD Radeon Vega 11 Graphics
-15D8,	D9,	AMD Radeon Vega 8 Graphics
-15D8,	DA,	AMD Radeon Vega 11 Graphics
-15D8,	DB,	AMD Radeon Vega 3 Graphics
-15D8,	DB,	AMD Radeon Vega 8 Graphics
-15D8,	DC,	AMD Radeon Vega 3 Graphics
-15D8,	DD,	AMD Radeon Vega 3 Graphics
-15D8,	DE,	AMD Radeon Vega 3 Graphics
-15D8,	DF,	AMD Radeon Vega 3 Graphics
-15D8,	E3,	AMD Radeon Vega 3 Graphics
-15D8,	E4,	AMD Ryzen Embedded R1102G with Radeon Vega Gfx
-15DD,	81,	AMD Ryzen Embedded V1807B with Radeon Vega Gfx
-15DD,	82,	AMD Ryzen Embedded V1756B with Radeon Vega Gfx
-15DD,	83,	AMD Ryzen Embedded V1605B with Radeon Vega Gfx
-15DD,	84,	AMD Radeon Vega 6 Graphics
-15DD,	85,	AMD Ryzen Embedded V1202B with Radeon Vega Gfx
-15DD,	86,	AMD Radeon Vega 11 Graphics
-15DD,	88,	AMD Radeon Vega 8 Graphics
-15DD,	C1,	AMD Radeon Vega 11 Graphics
-15DD,	C2,	AMD Radeon Vega 8 Graphics
-15DD,	C3,	AMD Radeon Vega 3 / 10 Graphics
-15DD,	C4,	AMD Radeon Vega 8 Graphics
-15DD,	C5,	AMD Radeon Vega 3 Graphics
-15DD,	C6,	AMD Radeon Vega 11 Graphics
-15DD,	C8,	AMD Radeon Vega 8 Graphics
-15DD,	C9,	AMD Radeon Vega 11 Graphics
-15DD,	CA,	AMD Radeon Vega 8 Graphics
-15DD,	CB,	AMD Radeon Vega 3 Graphics
-15DD,	CC,	AMD Radeon Vega 6 Graphics
-15DD,	CE,	AMD Radeon Vega 3 Graphics
-15DD,	CF,	AMD Radeon Vega 3 Graphics
-15DD,	D0,	AMD Radeon Vega 10 Graphics
-15DD,	D1,	AMD Radeon Vega 8 Graphics
-15DD,	D3,	AMD Radeon Vega 11 Graphics
-15DD,	D5,	AMD Radeon Vega 8 Graphics
-15DD,	D6,	AMD Radeon Vega 11 Graphics
-15DD,	D7,	AMD Radeon Vega 8 Graphics
-15DD,	D8,	AMD Radeon Vega 3 Graphics
-15DD,	D9,	AMD Radeon Vega 6 Graphics
-15DD,	E1,	AMD Radeon Vega 3 Graphics
-15DD,	E2,	AMD Radeon Vega 3 Graphics
-163F,	AE,	AMD Custom GPU 0405
-163F,	E1,	AMD Custom GPU 0405
-164E,	D8,	AMD Radeon 610M
-164E,	D9,	AMD Radeon 610M
-164E,	DA,	AMD Radeon 610M
-164E,	DB,	AMD Radeon 610M
-164E,	DC,	AMD Radeon 610M
-1681,	06,	AMD Radeon 680M
-1681,	07,	AMD Radeon 660M
-1681,	0A,	AMD Radeon 680M
-1681,	0B,	AMD Radeon 660M
-1681,	C7,	AMD Radeon 680M
-1681,	C8,	AMD Radeon 680M
-1681,	C9,	AMD Radeon 660M
-1900,	01,	AMD Radeon 780M Graphics
-1900,	02,	AMD Radeon 760M Graphics
-1900,	03,	AMD Radeon 780M Graphics
-1900,	04,	AMD Radeon 760M Graphics
-1900,	05,	AMD Radeon 780M Graphics
-1900,	06,	AMD Radeon 780M Graphics
-1900,	07,	AMD Radeon 760M Graphics
-1900,	B0,	AMD Radeon 780M Graphics
-1900,	B1,	AMD Radeon 780M Graphics
-1900,	B2,	AMD Radeon 780M Graphics
-1900,	B3,	AMD Radeon 780M Graphics
-1900,	B4,	AMD Radeon 780M Graphics
-1900,	B5,	AMD Radeon 780M Graphics
-1900,	B6,	AMD Radeon 780M Graphics
-1900,	B7,	AMD Radeon 760M Graphics
-1900,	B8,	AMD Radeon 760M Graphics
-1900,	B9,	AMD Radeon 780M Graphics
-1900,	BA,	AMD Radeon 780M Graphics
-1900,	BB,	AMD Radeon 780M Graphics
-1900,	C0,	AMD Radeon 780M Graphics
-1900,	C1,	AMD Radeon 760M Graphics
-1900,	C2,	AMD Radeon 780M Graphics
-1900,	C3,	AMD Radeon 760M Graphics
-1900,	C4,	AMD Radeon 780M Graphics
-1900,	C5,	AMD Radeon 780M Graphics
-1900,	C6,	AMD Radeon 760M Graphics
-1900,	C7,	AMD Radeon 780M Graphics
-1900,	C8,	AMD Radeon 760M Graphics
-1900,	C9,	AMD Radeon 780M Graphics
-1900,	CA,	AMD Radeon 760M Graphics
-1900,	CB,	AMD Radeon 780M Graphics
-1900,	CC,	AMD Radeon 780M Graphics
-1900,	CD,	AMD Radeon 760M Graphics
-1900,	CE,	AMD Radeon 780M Graphics
-1900,	CF,	AMD Radeon 760M Graphics
-1900,	D0,	AMD Radeon 780M Graphics
-1900,	D1,	AMD Radeon 760M Graphics
-1900,	D2,	AMD Radeon 780M Graphics
-1900,	D3,	AMD Radeon 760M Graphics
-1900,	D4,	AMD Radeon 780M Graphics
-1900,	D5,	AMD Radeon 780M Graphics
-1900,	D6,	AMD Radeon 760M Graphics
-1900,	D7,	AMD Radeon 780M Graphics
-1900,	D8,	AMD Radeon 760M Graphics
-1900,	D9,	AMD Radeon 780M Graphics
-1900,	DA,	AMD Radeon 760M Graphics
-1900,	DB,	AMD Radeon 780M Graphics
-1900,	DC,	AMD Radeon 780M Graphics
-1900,	DD,	AMD Radeon 760M Graphics
-1900,	DE,	AMD Radeon 780M Graphics
-1900,	DF,	AMD Radeon 760M Graphics
-1900,	F0,	AMD Radeon 780M Graphics
-1900,	F1,	AMD Radeon 780M Graphics
-1900,	F2,	AMD Radeon 780M Graphics
-1901,	C1,	AMD Radeon 740M Graphics
-1901,	C2,	AMD Radeon 740M Graphics
-1901,	C3,	AMD Radeon 740M Graphics
-1901,	C6,	AMD Radeon 740M Graphics
-1901,	C7,	AMD Radeon 740M Graphics
-1901,	C8,	AMD Radeon 740M Graphics
-1901,	C9,	AMD Radeon 740M Graphics
-1901,	CA,	AMD Radeon 740M Graphics
-1901,	D1,	AMD Radeon 740M Graphics
-1901,	D2,	AMD Radeon 740M Graphics
-1901,	D3,	AMD Radeon 740M Graphics
-1901,	D4,	AMD Radeon 740M Graphics
-1901,	D5,	AMD Radeon 740M Graphics
-1901,	D6,	AMD Radeon 740M Graphics
-1901,	D7,	AMD Radeon 740M Graphics
-1901,	D8,	AMD Radeon 740M Graphics
-6600,	00,	AMD Radeon HD 8600 / 8700M
-6600,	81,	AMD Radeon R7 M370
-6601,	00,	AMD Radeon HD 8500M / 8700M
-6604,	00,	AMD Radeon R7 M265 Series
-6604,	81,	AMD Radeon R7 M350
-6605,	00,	AMD Radeon R7 M260 Series
-6605,	81,	AMD Radeon R7 M340
-6606,	00,	AMD Radeon HD 8790M
-6607,	00,	AMD Radeon R5 M240
-6608,	00,	AMD FirePro W2100
-6610,	00,	AMD Radeon R7 200 Series
-6610,	81,	AMD Radeon R7 350
-6610,	83,	AMD Radeon R5 340
-6610,	87,	AMD Radeon R7 200 Series
-6611,	00,	AMD Radeon R7 200 Series
-6611,	87,	AMD Radeon R7 200 Series
-6613,	00,	AMD Radeon R7 200 Series
-6617,	00,	AMD Radeon R7 240 Series
-6617,	87,	AMD Radeon R7 200 Series
-6617,	C7,	AMD Radeon R7 240 Series
-6640,	00,	AMD Radeon HD 8950
-6640,	80,	AMD Radeon R9 M380
-6646,	00,	AMD Radeon R9 M280X
-6646,	80,	AMD Radeon R9 M385
-6646,	80,	AMD Radeon R9 M470X
-6647,	00,	AMD Radeon R9 M200X Series
-6647,	80,	AMD Radeon R9 M380
-6649,	00,	AMD FirePro W5100
-6658,	00,	AMD Radeon R7 200 Series
-665C,	00,	AMD Radeon HD 7700 Series
-665D,	00,	AMD Radeon R7 200 Series
-665F,	81,	AMD Radeon R7 360 Series
-6660,	00,	AMD Radeon HD 8600M Series
-6660,	81,	AMD Radeon R5 M335
-6660,	83,	AMD Radeon R5 M330
-6663,	00,	AMD Radeon HD 8500M Series
-6663,	83,	AMD Radeon R5 M320
-6664,	00,	AMD Radeon R5 M200 Series
-6665,	00,	AMD Radeon R5 M230 Series
-6665,	83,	AMD Radeon R5 M320
-6665,	C3,	AMD Radeon R5 M435
-6666,	00,	AMD Radeon R5 M200 Series
-6667,	00,	AMD Radeon R5 M200 Series
-666F,	00,	AMD Radeon HD 8500M
-66A1,	02,	AMD Instinct MI60 / MI50
-66A1,	06,	AMD Radeon Pro VII
-66AF,	C1,	AMD Radeon VII
-6780,	00,	AMD FirePro W9000
-6784,	00,	ATI FirePro V (FireGL V) Graphics Adapter
-6788,	00,	ATI FirePro V (FireGL V) Graphics Adapter
-678A,	00,	AMD FirePro W8000
-6798,	00,	AMD Radeon R9 200 / HD 7900 Series
-6799,	00,	AMD Radeon HD 7900 Series
-679A,	00,	AMD Radeon HD 7900 Series
-679B,	00,	AMD Radeon HD 7900 Series
-679E,	00,	AMD Radeon HD 7800 Series
-67A0,	00,	AMD Radeon FirePro W9100
-67A1,	00,	AMD Radeon FirePro W8100
-67B0,	00,	AMD Radeon R9 200 Series
-67B0,	80,	AMD Radeon R9 390 Series
-67B1,	00,	AMD Radeon R9 200 Series
-67B1,	80,	AMD Radeon R9 390 Series
-67B9,	00,	AMD Radeon R9 200 Series
-67C0,	00,	AMD Radeon Pro WX 7100 Graphics
-67C0,	80,	AMD Radeon E9550
-67C2,	01,	AMD Radeon Pro V7350x2
-67C2,	02,	AMD Radeon Pro V7300X
-67C4,	00,	AMD Radeon Pro WX 7100 Graphics
-67C4,	80,	AMD Radeon E9560 / E9565 Graphics
-67C7,	00,	AMD Radeon Pro WX 5100 Graphics
-67C7,	80,	AMD Radeon E9390 Graphics
-67D0,	01,	AMD Radeon Pro V7350x2
-67D0,	02,	AMD Radeon Pro V7300X
-67DF,	C0,	AMD Radeon Pro 580X
-67DF,	C1,	AMD Radeon RX 580 Series
-67DF,	C2,	AMD Radeon RX 570 Series
-67DF,	C3,	AMD Radeon RX 580 Series
-67DF,	C4,	AMD Radeon RX 480 Graphics
-67DF,	C5,	AMD Radeon RX 470 Graphics
-67DF,	C6,	AMD Radeon RX 570 Series
-67DF,	C7,	AMD Radeon RX 480 Graphics
-67DF,	CF,	AMD Radeon RX 470 Graphics
-67DF,	D7,	AMD Radeon RX 470 Graphics
-67DF,	E0,	AMD Radeon RX 470 Series
-67DF,	E1,	AMD Radeon RX 590 Series
-67DF,	E3,	AMD Radeon RX Series
-67DF,	E7,	AMD Radeon RX 580 Series
-67DF,	EB,	AMD Radeon Pro 580X
-67DF,	EF,	AMD Radeon RX 570 Series
-67DF,	F7,	AMD Radeon RX P30PH
-67DF,	FF,	AMD Radeon RX 470 Series
-67E0,	00,	AMD Radeon Pro WX Series
-67E3,	00,	AMD Radeon Pro WX 4100
-67E8,	00,	AMD Radeon Pro WX Series
-67E8,	01,	AMD Radeon Pro WX Series
-67E8,	80,	AMD Radeon E9260 Graphics
-67EB,	00,	AMD Radeon Pro V5300X
-67EF,	C0,	AMD Radeon RX Graphics
-67EF,	C1,	AMD Radeon RX 460 Graphics
-67EF,	C2,	AMD Radeon Pro Series
-67EF,	C3,	AMD Radeon RX Series
-67EF,	C5,	AMD Radeon RX 460 Graphics
-67EF,	C7,	AMD Radeon RX Graphics
-67EF,	CF,	AMD Radeon RX 460 Graphics
-67EF,	E0,	AMD Radeon RX 560 Series
-67EF,	E1,	AMD Radeon RX Series
-67EF,	E2,	AMD Radeon RX 560X
-67EF,	E3,	AMD Radeon RX Series
-67EF,	E5,	AMD Radeon RX 560 Series
-67EF,	E7,	AMD Radeon RX 560 Series
-67EF,	EF,	AMD Radeon 550 Series
-67EF,	FF,	AMD Radeon RX 460 Graphics
-67FF,	C0,	AMD Radeon Pro 465
-67FF,	C1,	AMD Radeon RX 560 Series
-67FF,	CF,	AMD Radeon RX 560 Series
-67FF,	EF,	AMD Radeon RX 560 Series
-67FF,	FF,	AMD Radeon RX 550 Series
-6800,	00,	AMD Radeon HD 7970M
-6801,	00,	AMD Radeon HD 8970M
-6806,	00,	AMD Radeon R9 M290X
-6808,	00,	AMD FirePro W7000
-6808,	00,	ATI FirePro V (FireGL V) Graphics Adapter
-6809,	00,	ATI FirePro W5000
-6810,	00,	AMD Radeon R9 200 Series
-6810,	81,	AMD Radeon R9 370 Series
-6811,	00,	AMD Radeon R9 200 Series
-6811,	81,	AMD Radeon R7 370 Series
-6818,	00,	AMD Radeon HD 7800 Series
-6819,	00,	AMD Radeon HD 7800 Series
-6820,	00,	AMD Radeon R9 M275X
-6820,	81,	AMD Radeon R9 M375
-6820,	83,	AMD Radeon R9 M375X
-6821,	00,	AMD Radeon R9 M200X Series
-6821,	83,	AMD Radeon R9 M370X
-6821,	87,	AMD Radeon R7 M380
-6822,	00,	AMD Radeon E8860
-6823,	00,	AMD Radeon R9 M200X Series
-6825,	00,	AMD Radeon HD 7800M Series
-6826,	00,	AMD Radeon HD 7700M Series
-6827,	00,	AMD Radeon HD 7800M Series
-6828,	00,	AMD FirePro W600
-682B,	00,	AMD Radeon HD 8800M Series
-682B,	87,	AMD Radeon R9 M360
-682C,	00,	AMD FirePro W4100
-682D,	00,	AMD Radeon HD 7700M Series
-682F,	00,	AMD Radeon HD 7700M Series
-6830,	00,	AMD Radeon 7800M Series
-6831,	00,	AMD Radeon 7700M Series
-6835,	00,	AMD Radeon R7 Series / HD 9000 Series
-6837,	00,	AMD Radeon HD 7700 Series
-683D,	00,	AMD Radeon HD 7700 Series
-683F,	00,	AMD Radeon HD 7700 Series
-684C,	00,	ATI FirePro V (FireGL V) Graphics Adapter
-6860,	00,	AMD Radeon Instinct MI25
-6860,	01,	AMD Radeon Instinct MI25
-6860,	02,	AMD Radeon Instinct MI25
-6860,	03,	AMD Radeon Pro V340
-6860,	04,	AMD Radeon Instinct MI25x2
-6860,	07,	AMD Radeon Pro V320
-6861,	00,	AMD Radeon Pro WX 9100
-6862,	00,	AMD Radeon Pro SSG
-6863,	00,	AMD Radeon Vega Frontier Edition
-6864,	03,	AMD Radeon Pro V340
-6864,	04,	AMD Radeon Instinct MI25x2
-6864,	05,	AMD Radeon Pro V340
-6868,	00,	AMD Radeon Pro WX 8200
-686C,	00,	AMD Radeon Instinct MI25 MxGPU
-686C,	01,	AMD Radeon Instinct MI25 MxGPU
-686C,	02,	AMD Radeon Instinct MI25 MxGPU
-686C,	03,	AMD Radeon Pro V340 MxGPU
-686C,	04,	AMD Radeon Instinct MI25x2 MxGPU
-686C,	05,	AMD Radeon Pro V340L MxGPU
-686C,	06,	AMD Radeon Instinct MI25 MxGPU
-687F,	01,	AMD Radeon RX Vega
-687F,	C0,	AMD Radeon RX Vega
-687F,	C1,	AMD Radeon RX Vega
-687F,	C3,	AMD Radeon RX Vega
-687F,	C7,	AMD Radeon RX Vega
-6900,	00,	AMD Radeon R7 M260
-6900,	81,	AMD Radeon R7 M360
-6900,	83,	AMD Radeon R7 M340
-6900,	C1,	AMD Radeon R5 M465 Series
-6900,	C3,	AMD Radeon R5 M445 Series
-6900,	D1,	AMD Radeon 530 Series
-6900,	D3,	AMD Radeon 530 Series
-6901,	00,	AMD Radeon R5 M255
-6902,	00,	AMD Radeon Series
-6907,	00,	AMD Radeon R5 M255
-6907,	87,	AMD Radeon R5 M315
-6920,	00,	AMD Radeon R9 M395X
-6920,	01,	AMD Radeon R9 M390X
-6921,	00,	AMD Radeon R9 M390X
-6929,	00,	AMD FirePro S7150
-6929,	01,	AMD FirePro S7100X
-692B,	00,	AMD FirePro W7100
-6938,	00,	AMD Radeon R9 200 Series
-6938,	F0,	AMD Radeon R9 200 Series
-6938,	F1,	AMD Radeon R9 380 Series
-6939,	00,	AMD Radeon R9 200 Series
-6939,	F0,	AMD Radeon R9 200 Series
-6939,	F1,	AMD Radeon R9 380 Series
-694C,	C0,	AMD Radeon RX Vega M GH Graphics
-694E,	C0,	AMD Radeon RX Vega M GL Graphics
-6980,	00,	AMD Radeon Pro WX 3100
-6981,	00,	AMD Radeon Pro WX 3200 Series
-6981,	01,	AMD Radeon Pro WX 3200 Series
-6981,	10,	AMD Radeon Pro WX 3200 Series
-6985,	00,	AMD Radeon Pro WX 3100
-6986,	00,	AMD Radeon Pro WX 2100
-6987,	80,	AMD Embedded Radeon E9171
-6987,	C0,	AMD Radeon 550X Series
-6987,	C1,	AMD Radeon RX 640
-6987,	C3,	AMD Radeon 540X Series
-6987,	C7,	AMD Radeon 540
-6995,	00,	AMD Radeon Pro WX 2100
-6997,	00,	AMD Radeon Pro WX 2100
-699F,	81,	AMD Embedded Radeon E9170 Series
-699F,	C0,	AMD Radeon 500 Series
-699F,	C1,	AMD Radeon 540 Series
-699F,	C3,	AMD Radeon 500 Series
-699F,	C7,	AMD Radeon RX 550 / 550 Series
-699F,	C9,	AMD Radeon 540
-6FDF,	E7,	AMD Radeon RX 590 GME
-6FDF,	EF,	AMD Radeon RX 580 2048SP
-7300,	C1,	AMD FirePro S9300 x2
-7300,	C8,	AMD Radeon R9 Fury Series
-7300,	C9,	AMD Radeon Pro Duo
-7300,	CA,	AMD Radeon R9 Fury Series
-7300,	CB,	AMD Radeon R9 Fury Series
-7312,	00,	AMD Radeon Pro W5700
-731E,	C6,	AMD Radeon RX 5700XTB
-731E,	C7,	AMD Radeon RX 5700B
-731F,	C0,	AMD Radeon RX 5700 XT 50th Anniversary
-731F,	C1,	AMD Radeon RX 5700 XT
-731F,	C2,	AMD Radeon RX 5600M
-731F,	C3,	AMD Radeon RX 5700M
-731F,	C4,	AMD Radeon RX 5700
-731F,	C5,	AMD Radeon RX 5700 XT
-731F,	CA,	AMD Radeon RX 5600 XT
-731F,	CB,	AMD Radeon RX 5600 OEM
-7340,	C1,	AMD Radeon RX 5500M
-7340,	C3,	AMD Radeon RX 5300M
-7340,	C5,	AMD Radeon RX 5500 XT
-7340,	C7,	AMD Radeon RX 5500
-7340,	C9,	AMD Radeon RX 5500XTB
-7340,	CF,	AMD Radeon RX 5300
-7341,	00,	AMD Radeon Pro W5500
-7347,	00,	AMD Radeon Pro W5500M
-7360,	41,	AMD Radeon Pro 5600M
-7360,	C3,	AMD Radeon Pro V520
-7362,	C1,	AMD Radeon Pro V540
-7362,	C3,	AMD Radeon Pro V520
-738C,	01,	AMD Instinct MI100
-73A1,	00,	AMD Radeon Pro V620
-73A3,	00,	AMD Radeon Pro W6800
-73A5,	C0,	AMD Radeon RX 6950 XT
-73AE,	00,	AMD Radeon Pro V620 MxGPU
-73AF,	C0,	AMD Radeon RX 6900 XT
-73BF,	C0,	AMD Radeon RX 6900 XT
-73BF,	C1,	AMD Radeon RX 6800 XT
-73BF,	C3,	AMD Radeon RX 6800
-73DF,	C0,	AMD Radeon RX 6750 XT
-73DF,	C1,	AMD Radeon RX 6700 XT
-73DF,	C2,	AMD Radeon RX 6800M
-73DF,	C3,	AMD Radeon RX 6800M
-73DF,	C5,	AMD Radeon RX 6700 XT
-73DF,	CF,	AMD Radeon RX 6700M
-73DF,	D5,	AMD Radeon RX 6750 GRE 12GB
-73DF,	D7,	AMD TDC-235
-73DF,	DF,	AMD Radeon RX 6700
-73DF,	E5,	AMD Radeon RX 6750 GRE 12GB
-73DF,	FF,	AMD Radeon RX 6700
-73E0,	00,	AMD Radeon RX 6600M
-73E1,	00,	AMD Radeon Pro W6600M
-73E3,	00,	AMD Radeon Pro W6600
-73EF,	C0,	AMD Radeon RX 6800S
-73EF,	C1,	AMD Radeon RX 6650 XT
-73EF,	C2,	AMD Radeon RX 6700S
-73EF,	C3,	AMD Radeon RX 6650M
-73EF,	C4,	AMD Radeon RX 6650M XT
-73FF,	C1,	AMD Radeon RX 6600 XT
-73FF,	C3,	AMD Radeon RX 6600M
-73FF,	C7,	AMD Radeon RX 6600
-73FF,	CB,	AMD Radeon RX 6600S
-73FF,	CF,	AMD Radeon RX 6600 LE
-73FF,	DF,	AMD Radeon RX 6750 GRE 10GB
-7408,	00,	AMD Instinct MI250X
-740C,	01,	AMD Instinct MI250X / MI250
-740F,	02,	AMD Instinct MI210
-7421,	00,	AMD Radeon Pro W6500M
-7422,	00,	AMD Radeon Pro W6400
-7423,	00,	AMD Radeon Pro W6300M
-7423,	01,	AMD Radeon Pro W6300
-7424,	00,	AMD Radeon RX 6300
-743F,	C1,	AMD Radeon RX 6500 XT
-743F,	C3,	AMD Radeon RX 6500
-743F,	C3,	AMD Radeon RX 6500M
-743F,	C7,	AMD Radeon RX 6400
-743F,	C8,	AMD Radeon RX 6500M
-743F,	CC,	AMD Radeon 6550S
-743F,	CE,	AMD Radeon RX 6450M
-743F,	CF,	AMD Radeon RX 6300M
-743F,	D3,	AMD Radeon RX 6550M
-743F,	D7,	AMD Radeon RX 6400
-7448,	00,	AMD Radeon Pro W7900
-7449,	00,	AMD Radeon Pro W7800 48GB
-744A,	00,	AMD Radeon Pro W7900 Dual Slot
-744B,	00,	AMD Radeon Pro W7900D
-744C,	C8,	AMD Radeon RX 7900 XTX
-744C,	CC,	AMD Radeon RX 7900 XT
-744C,	CE,	AMD Radeon RX 7900 GRE
-744C,	CF,	AMD Radeon RX 7900M
-745E,	CC,	AMD Radeon Pro W7800
-7460,	00,	AMD Radeon Pro V710
-7461,	00,	AMD Radeon Pro V710 MxGPU
-7470,	00,	AMD Radeon Pro W7700
-747E,	C8,	AMD Radeon RX 7800 XT
-747E,	D8,	AMD Radeon RX 7800M
-747E,	DB,	AMD Radeon RX 7700
-747E,	FF,	AMD Radeon RX 7700 XT
-7480,	00,	AMD Radeon Pro W7600
-7480,	C0,	AMD Radeon RX 7600 XT
-7480,	C1,	AMD Radeon RX 7700S
-7480,	C2,	AMD Radeon RX 7650 GRE
-7480,	C3,	AMD Radeon RX 7600S
-7480,	C7,	AMD Radeon RX 7600M XT
-7480,	CF,	AMD Radeon RX 7600
-7481,   C7,     AMD Steam Machine
-7483,	CF,	AMD Radeon RX 7600M
-7489,	00,	AMD Radeon Pro W7500
-7499,	00,	AMD Radeon Pro W7400
-7499,	C0,	AMD Radeon RX 7400
-7499,	C1,	AMD Radeon RX 7300
-74A0,	00,	AMD Instinct MI300A
-74A1,	00,	AMD Instinct MI300X
-74A2,	00,	AMD Instinct MI308X
-74A5,	00,	AMD Instinct MI325X
-74A8,	00,	AMD Instinct MI308X HF
-74A9,	00,	AMD Instinct MI300X HF
-74B5,	00,	AMD Instinct MI300X VF
-74B6,	00,	AMD Instinct MI308X
-74BD,	00,	AMD Instinct MI300X HF
-7550,	C0,	AMD Radeon RX 9070 XT
-7550,	C2,	AMD Radeon RX 9070 GRE
-7550,	C3,	AMD Radeon RX 9070
-7551,	C0,	AMD Radeon AI PRO R9700
-7590,	C0,	AMD Radeon RX 9060 XT
-7590,	C7,	AMD Radeon RX 9060
-75A0,	C0,	AMD Instinct MI350X
-75A3,	C0,	AMD Instinct MI355X
-75B0,	C0,	AMD Instinct MI350X VF
-75B3,	C0,	AMD Instinct MI355X VF
-9830,	00,	AMD Radeon HD 8400 / R3 Series
-9831,	00,	AMD Radeon HD 8400E
-9832,	00,	AMD Radeon HD 8330
-9833,	00,	AMD Radeon HD 8330E
-9834,	00,	AMD Radeon HD 8210
-9835,	00,	AMD Radeon HD 8210E
-9836,	00,	AMD Radeon HD 8200 / R3 Series
-9837,	00,	AMD Radeon HD 8280E
-9838,	00,	AMD Radeon HD 8200 / R3 series
-9839,	00,	AMD Radeon HD 8180
-983D,	00,	AMD Radeon HD 8250
-9850,	00,	AMD Radeon R3 Graphics
-9850,	03,	AMD Radeon R3 Graphics
-9850,	40,	AMD Radeon R2 Graphics
-9850,	45,	AMD Radeon R3 Graphics
-9851,	00,	AMD Radeon R4 Graphics
-9851,	01,	AMD Radeon R5E Graphics
-9851,	05,	AMD Radeon R5 Graphics
-9851,	06,	AMD Radeon R5E Graphics
-9851,	40,	AMD Radeon R4 Graphics
-9851,	45,	AMD Radeon R5 Graphics
-9852,	00,	AMD Radeon R2 Graphics
-9852,	40,	AMD Radeon E1 Graphics
-9853,	00,	AMD Radeon R2 Graphics
-9853,	01,	AMD Radeon R4E Graphics
-9853,	03,	AMD Radeon R2 Graphics
-9853,	05,	AMD Radeon R1E Graphics
-9853,	06,	AMD Radeon R1E Graphics
-9853,	07,	AMD Radeon R1E Graphics
-9853,	08,	AMD Radeon R1E Graphics
-9853,	40,	AMD Radeon R2 Graphics
-9854,	00,	AMD Radeon R3 Graphics
-9854,	01,	AMD Radeon R3E Graphics
-9854,	02,	AMD Radeon R3 Graphics
-9854,	05,	AMD Radeon R2 Graphics
-9854,	06,	AMD Radeon R4 Graphics
-9854,	07,	AMD Radeon R3 Graphics
-9855,	02,	AMD Radeon R6 Graphics
-9855,	05,	AMD Radeon R4 Graphics
-9856,	00,	AMD Radeon R2 Graphics
-9856,	01,	AMD Radeon R2E Graphics
-9856,	02,	AMD Radeon R2 Graphics
-9856,	05,	AMD Radeon R1E Graphics
-9856,	06,	AMD Radeon R2 Graphics
-9856,	07,	AMD Radeon R1E Graphics
-9856,	08,	AMD Radeon R1E Graphics
-9856,	13,	AMD Radeon R1E Graphics
-9874,	81,	AMD Radeon R6 Graphics
-9874,	84,	AMD Radeon R7 Graphics
-9874,	85,	AMD Radeon R6 Graphics
-9874,	87,	AMD Radeon R5 Graphics
-9874,	88,	AMD Radeon R7E Graphics
-9874,	89,	AMD Radeon R6E Graphics
-9874,	C4,	AMD Radeon R7 Graphics
-9874,	C5,	AMD Radeon R6 Graphics
-9874,	C6,	AMD Radeon R6 Graphics
-9874,	C7,	AMD Radeon R5 Graphics
-9874,	C8,	AMD Radeon R7 Graphics
-9874,	C9,	AMD Radeon R7 Graphics
-9874,	CA,	AMD Radeon R5 Graphics
-9874,	CB,	AMD Radeon R5 Graphics
-9874,	CC,	AMD Radeon R7 Graphics
-9874,	CD,	AMD Radeon R7 Graphics
-9874,	CE,	AMD Radeon R5 Graphics
-9874,	E1,	AMD Radeon R7 Graphics
-9874,	E2,	AMD Radeon R7 Graphics
-9874,	E3,	AMD Radeon R7 Graphics
-9874,	E4,	AMD Radeon R7 Graphics
-9874,	E5,	AMD Radeon R5 Graphics
-9874,	E6,	AMD Radeon R5 Graphics
-98E4,	80,	AMD Radeon R5E Graphics
-98E4,	81,	AMD Radeon R4E Graphics
-98E4,	83,	AMD Radeon R2E Graphics
-98E4,	84,	AMD Radeon R2E Graphics
-98E4,	86,	AMD Radeon R1E Graphics
-98E4,	C0,	AMD Radeon R4 Graphics
-98E4,	C1,	AMD Radeon R5 Graphics
-98E4,	C2,	AMD Radeon R4 Graphics
-98E4,	C4,	AMD Radeon R5 Graphics
-98E4,	C6,	AMD Radeon R5 Graphics
-98E4,	C8,	AMD Radeon R4 Graphics
-98E4,	C9,	AMD Radeon R4 Graphics
-98E4,	CA,	AMD Radeon R5 Graphics
-98E4,	D0,	AMD Radeon R2 Graphics
-98E4,	D1,	AMD Radeon R2 Graphics
-98E4,	D2,	AMD Radeon R2 Graphics
-98E4,	D4,	AMD Radeon R2 Graphics
-98E4,	D9,	AMD Radeon R5 Graphics
-98E4,	DA,	AMD Radeon R5 Graphics
-98E4,	DB,	AMD Radeon R3 Graphics
-98E4,	E1,	AMD Radeon R3 Graphics
-98E4,	E2,	AMD Radeon R3 Graphics
-98E4,	E9,	AMD Radeon R4 Graphics
-98E4,	EA,	AMD Radeon R4 Graphics
-98E4,	EB,	AMD Radeon R3 Graphics
-98E4,	EB,	AMD Radeon R4 Graphics
--- a/agent/test-data/nvtop.json
+++ b/agent/test-data/nvtop.json
@@ -1,34 +0,0 @@
-[
-  {
-   "device_name": "NVIDIA GeForce RTX 3050 Ti Laptop GPU",
-   "gpu_clock": "1485MHz",
-   "mem_clock": "6001MHz",
-   "temp": "48C",
-   "fan_speed": null,
-   "power_draw": "13W",
-   "gpu_util": "5%",
-   "encode": "0%",
-   "decode": "0%",
-   "mem_util": "8%",
-   "mem_total": "4294967296",
-   "mem_used": "349372416",
-   "mem_free": "3945594880",
-   "processes" : []
-  },
-  {
-   "device_name": "AMD Radeon 680M",
-   "gpu_clock": "2200MHz",
-   "mem_clock": "2400MHz",
-   "temp": "48C",
-   "fan_speed": "CPU Fan",
-   "power_draw": "9W",
-   "gpu_util": "12%",
-   "encode": null,
-   "decode": "0%",
-   "mem_util": "7%",
-   "mem_total": "16929173504",
-   "mem_used": "1213784064",
-   "mem_free": "15715389440",
-   "processes" : []
-  }
-]
--- a/agent/test-data/system_info.json
+++ b/agent/test-data/system_info.json
@@ -1,17 +0,0 @@
-{
-  "ID": "7TRN:IPZB:QYBB:VPBQ:UMPP:KARE:6ZNR:XE6T:7EWV:PKF4:ZOJD:TPYS",
-  "Containers": 14,
-  "ContainersRunning": 3,
-  "ContainersPaused": 1,
-  "ContainersStopped": 10,
-  "Images": 508,
-  "Driver": "overlay2",
-  "KernelVersion": "6.8.0-31-generic",
-  "OperatingSystem": "Ubuntu 24.04 LTS",
-  "OSVersion": "24.04",
-  "OSType": "linux",
-  "Architecture": "x86_64",
-  "NCPU": 4,
-  "MemTotal": 2095882240,
-  "ServerVersion": "27.0.1"
-}
--- a/agent/update.go
+++ b/agent/update.go
@@ -1,10 +1,12 @@
 package agent

 import (
+	"fmt"
 	"log"
 	"os"
 	"os/exec"
 	"runtime"
+	"strings"

 	"github.com/henrygd/beszel/internal/ghupdate"
 )
@@ -63,9 +65,9 @@ func detectRestarter() restarter {
 	if path, err := exec.LookPath("rc-service"); err == nil {
 		return &openRCRestarter{cmd: path}
 	}
-	if path, err := exec.LookPath("procd"); err == nil {
-		return &openWRTRestarter{cmd: path}
-	}
+    if path, err := exec.LookPath("procd"); err == nil {
+        return &openWRTRestarter{cmd: path}
+    }
 	if path, err := exec.LookPath("service"); err == nil {
 		if runtime.GOOS == "freebsd" {
 			return &freeBSDRestarter{cmd: path}
@@ -79,7 +81,7 @@ func detectRestarter() restarter {
 func Update(useMirror bool) error {
 	exePath, _ := os.Executable()

-	dataDir, err := GetDataDir()
+	dataDir, err := getDataDir()
 	if err != nil {
 		dataDir = os.TempDir()
 	}
@@ -106,12 +108,12 @@ func Update(useMirror bool) error {
 		}
 	}

-	// Fix SELinux context if necessary
-	if err := ghupdate.HandleSELinuxContext(exePath); err != nil {
+	// 6) Fix SELinux context if necessary
+	if err := handleSELinuxContext(exePath); err != nil {
 		ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: SELinux context handling: %v", err)
 	}

-	// Restart service if running under a recognised init system
+	// 7) Restart service if running under a recognised init system
 	if r := detectRestarter(); r != nil {
 		if err := r.Restart(); err != nil {
 			ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: failed to restart service: %v", err)
@@ -125,3 +127,42 @@ func Update(useMirror bool) error {

 	return nil
 }
+
+// handleSELinuxContext restores or applies the correct SELinux label to the binary.
+func handleSELinuxContext(path string) error {
+	out, err := exec.Command("getenforce").Output()
+	if err != nil {
+		// SELinux not enabled or getenforce not available
+		return nil
+	}
+	state := strings.TrimSpace(string(out))
+	if state == "Disabled" {
+		return nil
+	}
+
+	ghupdate.ColorPrint(ghupdate.ColorYellow, "SELinux is enabled; applying context…")
+	var errs []string
+
+	// Try persistent context via semanage+restorecon
+	if semanagePath, err := exec.LookPath("semanage"); err == nil {
+		if err := exec.Command(semanagePath, "fcontext", "-a", "-t", "bin_t", path).Run(); err != nil {
+			errs = append(errs, "semanage fcontext failed: "+err.Error())
+		} else if restoreconPath, err := exec.LookPath("restorecon"); err == nil {
+			if err := exec.Command(restoreconPath, "-v", path).Run(); err != nil {
+				errs = append(errs, "restorecon failed: "+err.Error())
+			}
+		}
+	}
+
+	// Fallback to temporary context via chcon
+	if chconPath, err := exec.LookPath("chcon"); err == nil {
+		if err := exec.Command(chconPath, "-t", "bin_t", path).Run(); err != nil {
+			errs = append(errs, "chcon failed: "+err.Error())
+		}
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("SELinux context errors: %s", strings.Join(errs, "; "))
+	}
+	return nil
+}
--- a/beszel.go
+++ b/beszel.go
@@ -6,7 +6,7 @@ import "github.com/blang/semver"

 const (
 	// Version is the current version of the application.
-	Version = "0.18.4"
+	Version = "0.16.1"
 	// AppName is the name of the application.
 	AppName = "beszel"
 )
--- a/go.mod
+++ b/go.mod
@@ -1,27 +1,25 @@
 module github.com/henrygd/beszel

-go 1.26.0
+go 1.25.3

 require (
 	github.com/blang/semver v3.5.1+incompatible
-	github.com/coreos/go-systemd/v22 v22.7.0
+	github.com/coreos/go-systemd/v22 v22.6.0
 	github.com/distatus/battery v0.11.0
-	github.com/ebitengine/purego v0.9.1
 	github.com/fxamacker/cbor/v2 v2.9.0
 	github.com/gliderlabs/ssh v0.3.8
 	github.com/google/uuid v1.6.0
 	github.com/lxzan/gws v1.8.9
-	github.com/nicholas-fedor/shoutrrr v0.13.2
-	github.com/pocketbase/dbx v1.12.0
-	github.com/pocketbase/pocketbase v0.36.4
-	github.com/shirou/gopsutil/v4 v4.26.1
+	github.com/nicholas-fedor/shoutrrr v0.12.0
+	github.com/pocketbase/dbx v1.11.0
+	github.com/pocketbase/pocketbase v0.33.0
+	github.com/shirou/gopsutil/v4 v4.25.10
 	github.com/spf13/cast v1.10.0
-	github.com/spf13/cobra v1.10.2
+	github.com/spf13/cobra v1.10.1
 	github.com/spf13/pflag v1.0.10
 	github.com/stretchr/testify v1.11.1
-	golang.org/x/crypto v0.48.0
-	golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa
-	golang.org/x/sys v0.41.0
+	golang.org/x/crypto v0.44.0
+	golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6
 	gopkg.in/yaml.v3 v3.0.1
 )

@@ -33,17 +31,18 @@ require (
 	github.com/dolthub/maphash v0.1.0 // indirect
 	github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/ebitengine/purego v0.9.1 // indirect
 	github.com/fatih/color v1.18.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.13 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.11 // indirect
 	github.com/ganigeorgiev/fexpr v0.5.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
 	github.com/go-sql-driver/mysql v1.9.1 // indirect
-	github.com/godbus/dbus/v5 v5.2.2 // indirect
-	github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
+	github.com/godbus/dbus/v5 v5.2.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/klauspost/compress v1.18.4 // indirect
-	github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88 // indirect
+	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
@@ -54,15 +53,16 @@ require (
 	github.com/tklauser/numcpus v0.11.0 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/image v0.36.0 // indirect
-	golang.org/x/net v0.50.0 // indirect
-	golang.org/x/oauth2 v0.35.0 // indirect
-	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/term v0.40.0 // indirect
-	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/image v0.33.0 // indirect
+	golang.org/x/net v0.47.0 // indirect
+	golang.org/x/oauth2 v0.33.0 // indirect
+	golang.org/x/sync v0.18.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/term v0.37.0 // indirect
+	golang.org/x/text v0.31.0 // indirect
 	howett.net/plist v1.0.1 // indirect
-	modernc.org/libc v1.67.6 // indirect
+	modernc.org/libc v1.66.10 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.45.0 // indirect
+	modernc.org/sqlite v1.40.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -9,8 +9,8 @@ github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3d
 github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
 github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
 github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
-github.com/coreos/go-systemd/v22 v22.7.0 h1:LAEzFkke61DFROc7zNLX/WA2i5J8gYqe0rSj9KI28KA=
-github.com/coreos/go-systemd/v22 v22.7.0/go.mod h1:xNUYtjHu2EDXbsxz1i41wouACIwT7Ybq9o0BQhMwD0w=
+github.com/coreos/go-systemd/v22 v22.6.0 h1:aGVa/v8B7hpb0TKl0MWoAavPDmHvobFe5R5zn0bCJWo=
+github.com/coreos/go-systemd/v22 v22.6.0/go.mod h1:iG+pp635Fo7ZmV/j14KUcmEyWF+0X7Lua8rrTWzYgWU=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
@@ -33,8 +33,8 @@ github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHk
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
 github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
-github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM=
-github.com/gabriel-vasile/mimetype v1.4.13/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+github.com/gabriel-vasile/mimetype v1.4.11 h1:AQvxbp830wPhHTqc1u7nzoLT+ZFxGY7emj5DR5DYFik=
+github.com/gabriel-vasile/mimetype v1.4.11/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
 github.com/ganigeorgiev/fexpr v0.5.0 h1:XA9JxtTE/Xm+g/JFI6RfZEHSiQlk+1glLvRK1Lpv/Tk=
 github.com/ganigeorgiev/fexpr v0.5.0/go.mod h1:RyGiGqmeXhEQ6+mlGdnUleLHgtzzu/VGO2WtJkF5drE=
 github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
@@ -51,15 +51,15 @@ github.com/go-sql-driver/mysql v1.9.1 h1:FrjNGn/BsJQjVRuSa8CBrM5BWA9BWoXXat3KrtS
 github.com/go-sql-driver/mysql v1.9.1/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
 github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
-github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
-github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
-github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
-github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/godbus/dbus/v5 v5.2.0 h1:3WexO+U+yg9T70v9FdHr9kCxYlazaAXUhx2VMkbfax8=
+github.com/godbus/dbus/v5 v5.2.0/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 h1:z2ogiKUYzX5Is6zr/vP9vJGqPwcdqsWjOt+V8J7+bTc=
-github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d h1:KJIErDwbSHjnp/SGzE5ed8Aol7JsKiI5X7yWKAtzhM0=
+github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
@@ -69,14 +69,14 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf
 github.com/jarcoal/httpmock v1.4.1 h1:0Ju+VCFuARfFlhVXFc2HxlcQkfB+Xq12/EotHko+x2A=
 github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/klauspost/compress v1.18.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
-github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88 h1:PTw+yKnXcOFCR6+8hHTyWBeQ/P4Nb7dd4/0ohEcWQuM=
-github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
+github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 h1:PwQumkgq4/acIiZhtifTV5OUqqiP82UAl0h87xj/l9k=
+github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/lxzan/gws v1.8.9 h1:VU3SGUeWlQrEwfUSfokcZep8mdg/BrUF+y73YYshdBM=
 github.com/lxzan/gws v1.8.9/go.mod h1:d9yHaR1eDTBHagQC6KY7ycUOaz5KWeqQtP3xu7aMK8Y=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
@@ -85,19 +85,19 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.13.2 h1:hfsYBIqSFYGg92pZP5CXk/g7/OJIkLYmiUnRl+AD1IA=
-github.com/nicholas-fedor/shoutrrr v0.13.2/go.mod h1:ZqzV3gY/Wj6AvWs1etlO7+yKbh4iptSbeL8avBpMQbA=
-github.com/onsi/ginkgo/v2 v2.28.1 h1:S4hj+HbZp40fNKuLUQOYLDgZLwNUVn19N3Atb98NCyI=
-github.com/onsi/ginkgo/v2 v2.28.1/go.mod h1:CLtbVInNckU3/+gC8LzkGUb9oF+e8W8TdUsxPwvdOgE=
-github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28=
-github.com/onsi/gomega v1.39.1/go.mod h1:hL6yVALoTOxeWudERyfppUcZXjMwIMLnuSfruD2lcfg=
+github.com/nicholas-fedor/shoutrrr v0.12.0 h1:8mwJdfU+uBEybSymwQJMGl/grG7lvVUKbVSNxn3XvUI=
+github.com/nicholas-fedor/shoutrrr v0.12.0/go.mod h1:WYiRalR4C43Qmd2zhPWGIFIxu633NB1hDM6Ap/DQcsA=
+github.com/onsi/ginkgo/v2 v2.27.2 h1:LzwLj0b89qtIy6SSASkzlNvX6WktqurSHwkk2ipF/Ns=
+github.com/onsi/ginkgo/v2 v2.27.2/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
+github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
+github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pocketbase/dbx v1.12.0 h1:/oLErM+A0b4xI0PWTGPqSDVjzix48PqI/bng2l0PzoA=
-github.com/pocketbase/dbx v1.12.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
-github.com/pocketbase/pocketbase v0.36.4 h1:zTjRZbp2WfTOJJfb+pFRWa200UaQwxZYt8RzkFMlAZ4=
-github.com/pocketbase/pocketbase v0.36.4/go.mod h1:9CiezhRudd9FZGa5xZa53QZBTNxc5vvw/FGG+diAECI=
+github.com/pocketbase/dbx v1.11.0 h1:LpZezioMfT3K4tLrqA55wWFw1EtH1pM4tzSVa7kgszU=
+github.com/pocketbase/dbx v1.11.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
+github.com/pocketbase/pocketbase v0.33.0 h1:v2EfiY3hxigzRJ/BwFuwVn0vUv7d2QQoD5zUFPaKR9o=
+github.com/pocketbase/pocketbase v0.33.0/go.mod h1:9BEs+CRV7CrS+X5LfBh4bdJQsbzQAIklft3ovGe/c5A=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
@@ -105,12 +105,12 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v4 v4.26.1 h1:TOkEyriIXk2HX9d4isZJtbjXbEjf5qyKPAzbzY0JWSo=
-github.com/shirou/gopsutil/v4 v4.26.1/go.mod h1:medLI9/UNAb0dOI9Q3/7yWSqKkj00u+1tgY8nvv41pc=
+github.com/shirou/gopsutil/v4 v4.25.10 h1:at8lk/5T1OgtuCp+AwrDofFRjnvosn0nkN2OLQ6g8tA=
+github.com/shirou/gopsutil/v4 v4.25.10/go.mod h1:+kSwyC8DRUD9XXEHCAFjK+0nuArFJM0lva+StQAcskM=
 github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
 github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
-github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -129,41 +129,41 @@ github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQ
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
+golang.org/x/crypto v0.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU=
+golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc=
+golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 h1:zfMcR1Cs4KNuomFFgGefv5N0czO2XZpUbxGUy8i8ug0=
+golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.36.0 h1:Iknbfm1afbgtwPTmHnS2gTM/6PPZfH+z2EFuOkSbqwc=
-golang.org/x/image v0.36.0/go.mod h1:YsWD2TyyGKiIX1kZlu9QfKIsQ4nAAK9bdgdrIsE7xy4=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
+golang.org/x/image v0.33.0 h1:LXRZRnv1+zGd5XBUVRFmYEphyyKJjQjCRiOuAP3sZfQ=
+golang.org/x/image v0.33.0/go.mod h1:DD3OsTYT9chzuzTQt+zMcOlBHgfoKQb1gry8p76Y1sc=
+golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
+golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
-golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
-golang.org/x/oauth2 v0.35.0 h1:Mv2mzuHuZuY2+bkyWXIHMfhNdJAdwW3FuWeCPYN5GVQ=
-golang.org/x/oauth2 v0.35.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/oauth2 v0.33.0 h1:4Q+qn+E5z8gPRJfmRy7C2gGG3T4jIprK6aSYgTXGRpo=
+golang.org/x/oauth2 v0.33.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
-golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
+golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
-golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ=
+golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -185,8 +185,10 @@ modernc.org/gc/v3 v3.1.1 h1:k8T3gkXWY9sEiytKhcgyiZ2L0DTyCQ/nvX+LoCljoRE=
 modernc.org/gc/v3 v3.1.1/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
 modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.67.6 h1:eVOQvpModVLKOdT+LvBPjdQqfrZq+pC39BygcT+E7OI=
-modernc.org/libc v1.67.6/go.mod h1:JAhxUVlolfYDErnwiqaLvUqc8nfb2r6S6slAgZOnaiE=
+modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
+modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
+modernc.org/libc v1.67.0 h1:QzL4IrKab2OFmxA3/vRYl0tLXrIamwrhD6CKD4WBVjQ=
+modernc.org/libc v1.67.0/go.mod h1:QvvnnJ5P7aitu0ReNpVIEyesuhmDLQ8kaEoyMjIFZJA=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
@@ -195,8 +197,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
 modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.45.0 h1:r51cSGzKpbptxnby+EIIz5fop4VuE4qFoVEjNvWoObs=
-modernc.org/sqlite v1.45.0/go.mod h1:CzbrU2lSB1DKUusvwGz7rqEKIq+NUd8GWuBBZDs9/nA=
+modernc.org/sqlite v1.40.0 h1:bNWEDlYhNPAUdUdBzjAvn8icAs/2gaKlj4vM+tQ6KdQ=
+modernc.org/sqlite v1.40.0/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
--- a/internal/alerts/alerts.go
+++ b/internal/alerts/alerts.go
@@ -49,7 +49,6 @@ type SystemAlertStats struct {
 	GPU          map[string]SystemAlertGPUData `json:"g"`
 	Temperatures map[string]float32            `json:"t"`
 	LoadAvg      [3]float64                    `json:"la"`
-	Battery      [2]uint8                      `json:"bat"`
 }

 type SystemAlertGPUData struct {
@@ -105,7 +104,6 @@ func NewAlertManager(app hubLike) *AlertManager {
 func (am *AlertManager) bindEvents() {
 	am.hub.OnRecordAfterUpdateSuccess("alerts").BindFunc(updateHistoryOnAlertUpdate)
 	am.hub.OnRecordAfterDeleteSuccess("alerts").BindFunc(resolveHistoryOnAlertDelete)
-	am.hub.OnRecordAfterUpdateSuccess("smart_devices").BindFunc(am.handleSmartDeviceAlert)
 }

 // IsNotificationSilenced checks if a notification should be silenced based on configured quiet hours
--- a/internal/alerts/alerts_battery_test.go
+++ b/internal/alerts/alerts_battery_test.go
@@ -1,386 +0,0 @@
-//go:build testing
-
-package alerts_test
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-	beszelTests "github.com/henrygd/beszel/internal/tests"
-
-	"github.com/pocketbase/dbx"
-	"github.com/pocketbase/pocketbase/tools/types"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// TestBatteryAlertLogic tests that battery alerts trigger when value drops BELOW threshold
-// (opposite of other alerts like CPU, Memory, etc. which trigger when exceeding threshold)
-func TestBatteryAlertLogic(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system
-	systems, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
-	require.NoError(t, err)
-	systemRecord := systems[0]
-
-	// Create a battery alert with threshold of 20% and min of 1 minute (immediate trigger)
-	batteryAlert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
-		"name":   "Battery",
-		"system": systemRecord.Id,
-		"user":   user.Id,
-		"value":  20, // threshold: 20%
-		"min":    1,  // 1 minute (immediate trigger for testing)
-	})
-	require.NoError(t, err)
-
-	// Verify alert is not triggered initially
-	assert.False(t, batteryAlert.GetBool("triggered"), "Alert should not be triggered initially")
-
-	// Create system stats with battery at 50% (above threshold - should NOT trigger)
-	statsHigh := system.Stats{
-		Cpu:     10,
-		MemPct:  30,
-		DiskPct: 40,
-		Battery: [2]uint8{50, 1}, // 50% battery, discharging
-	}
-	statsHighJSON, _ := json.Marshal(statsHigh)
-	_, err = beszelTests.CreateRecord(hub, "system_stats", map[string]any{
-		"system": systemRecord.Id,
-		"type":   "1m",
-		"stats":  string(statsHighJSON),
-	})
-	require.NoError(t, err)
-
-	// Create CombinedData for the alert handler
-	combinedDataHigh := &system.CombinedData{
-		Stats: statsHigh,
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Simulate system update time
-	systemRecord.Set("updated", time.Now().UTC())
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts with high battery
-	am := hub.GetAlertManager()
-	err = am.HandleSystemAlerts(systemRecord, combinedDataHigh)
-	require.NoError(t, err)
-
-	// Verify alert is still NOT triggered (battery 50% is above threshold 20%)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.False(t, batteryAlert.GetBool("triggered"), "Alert should NOT be triggered when battery (50%%) is above threshold (20%%)")
-
-	// Now create stats with battery at 15% (below threshold - should trigger)
-	statsLow := system.Stats{
-		Cpu:     10,
-		MemPct:  30,
-		DiskPct: 40,
-		Battery: [2]uint8{15, 1}, // 15% battery, discharging
-	}
-	statsLowJSON, _ := json.Marshal(statsLow)
-	_, err = beszelTests.CreateRecord(hub, "system_stats", map[string]any{
-		"system": systemRecord.Id,
-		"type":   "1m",
-		"stats":  string(statsLowJSON),
-	})
-	require.NoError(t, err)
-
-	combinedDataLow := &system.CombinedData{
-		Stats: statsLow,
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Update system timestamp
-	systemRecord.Set("updated", time.Now().UTC())
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts with low battery
-	err = am.HandleSystemAlerts(systemRecord, combinedDataLow)
-	require.NoError(t, err)
-
-	// Wait for the alert to be processed
-	time.Sleep(20 * time.Millisecond)
-
-	// Verify alert IS triggered (battery 15% is below threshold 20%)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.True(t, batteryAlert.GetBool("triggered"), "Alert SHOULD be triggered when battery (15%%) drops below threshold (20%%)")
-
-	// Now test resolution: battery goes back above threshold
-	statsRecovered := system.Stats{
-		Cpu:     10,
-		MemPct:  30,
-		DiskPct: 40,
-		Battery: [2]uint8{25, 1}, // 25% battery, discharging
-	}
-	statsRecoveredJSON, _ := json.Marshal(statsRecovered)
-	_, err = beszelTests.CreateRecord(hub, "system_stats", map[string]any{
-		"system": systemRecord.Id,
-		"type":   "1m",
-		"stats":  string(statsRecoveredJSON),
-	})
-	require.NoError(t, err)
-
-	combinedDataRecovered := &system.CombinedData{
-		Stats: statsRecovered,
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Update system timestamp
-	systemRecord.Set("updated", time.Now().UTC())
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts with recovered battery
-	err = am.HandleSystemAlerts(systemRecord, combinedDataRecovered)
-	require.NoError(t, err)
-
-	// Wait for the alert to be processed
-	time.Sleep(20 * time.Millisecond)
-
-	// Verify alert is now resolved (battery 25% is above threshold 20%)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.False(t, batteryAlert.GetBool("triggered"), "Alert should be resolved when battery (25%%) goes above threshold (20%%)")
-}
-
-// TestBatteryAlertNoBattery verifies that systems without battery data don't trigger alerts
-func TestBatteryAlertNoBattery(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system
-	systems, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
-	require.NoError(t, err)
-	systemRecord := systems[0]
-
-	// Create a battery alert
-	batteryAlert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
-		"name":   "Battery",
-		"system": systemRecord.Id,
-		"user":   user.Id,
-		"value":  20,
-		"min":    1,
-	})
-	require.NoError(t, err)
-
-	// Create stats with NO battery data (Battery[0] = 0)
-	statsNoBattery := system.Stats{
-		Cpu:     10,
-		MemPct:  30,
-		DiskPct: 40,
-		Battery: [2]uint8{0, 0}, // No battery
-	}
-
-	combinedData := &system.CombinedData{
-		Stats: statsNoBattery,
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Simulate system update time
-	systemRecord.Set("updated", time.Now().UTC())
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts
-	am := hub.GetAlertManager()
-	err = am.HandleSystemAlerts(systemRecord, combinedData)
-	require.NoError(t, err)
-
-	// Wait a moment for processing
-	time.Sleep(20 * time.Millisecond)
-
-	// Verify alert is NOT triggered (no battery data should skip the alert)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.False(t, batteryAlert.GetBool("triggered"), "Alert should NOT be triggered when system has no battery")
-}
-
-// TestBatteryAlertAveragedSamples tests battery alerts with min > 1 (averaging multiple samples)
-// This ensures the inverted threshold logic works correctly across averaged time windows
-func TestBatteryAlertAveragedSamples(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system
-	systems, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
-	require.NoError(t, err)
-	systemRecord := systems[0]
-
-	// Create a battery alert with threshold of 25% and min of 2 minutes (requires averaging)
-	batteryAlert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
-		"name":   "Battery",
-		"system": systemRecord.Id,
-		"user":   user.Id,
-		"value":  25, // threshold: 25%
-		"min":    2,  // 2 minutes - requires averaging
-	})
-	require.NoError(t, err)
-
-	// Verify alert is not triggered initially
-	assert.False(t, batteryAlert.GetBool("triggered"), "Alert should not be triggered initially")
-
-	am := hub.GetAlertManager()
-	now := time.Now().UTC()
-
-	// Create system_stats records with low battery (below threshold)
-	// The alert has min=2 minutes, so alert.time = now - 2 minutes
-	// For the alert to be valid, alert.time must be AFTER the oldest record's created time
-	// So we need records older than (now - 2 min), plus records within the window
-	// Records at: now-3min (oldest, before window), now-90s, now-60s, now-30s
-	recordTimes := []time.Duration{
-		-180 * time.Second, // 3 min ago - this makes the oldest record before alert.time
-		-90 * time.Second,
-		-60 * time.Second,
-		-30 * time.Second,
-	}
-
-	for _, offset := range recordTimes {
-		statsLow := system.Stats{
-			Cpu:     10,
-			MemPct:  30,
-			DiskPct: 40,
-			Battery: [2]uint8{15, 1}, // 15% battery (below 25% threshold)
-		}
-		statsLowJSON, _ := json.Marshal(statsLow)
-
-		recordTime := now.Add(offset)
-		record, err := beszelTests.CreateRecord(hub, "system_stats", map[string]any{
-			"system": systemRecord.Id,
-			"type":   "1m",
-			"stats":  string(statsLowJSON),
-		})
-		require.NoError(t, err)
-		// Update created time to simulate historical records - use SetRaw with formatted string
-		record.SetRaw("created", recordTime.Format(types.DefaultDateLayout))
-		err = hub.SaveNoValidate(record)
-		require.NoError(t, err)
-	}
-
-	// Create combined data with low battery
-	combinedDataLow := &system.CombinedData{
-		Stats: system.Stats{
-			Cpu:     10,
-			MemPct:  30,
-			DiskPct: 40,
-			Battery: [2]uint8{15, 1},
-		},
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Update system timestamp
-	systemRecord.Set("updated", now)
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts - should trigger because average battery is below threshold
-	err = am.HandleSystemAlerts(systemRecord, combinedDataLow)
-	require.NoError(t, err)
-
-	// Wait for alert processing
-	time.Sleep(20 * time.Millisecond)
-
-	// Verify alert IS triggered (average battery 15% is below threshold 25%)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.True(t, batteryAlert.GetBool("triggered"),
-		"Alert SHOULD be triggered when average battery (15%%) is below threshold (25%%) over min period")
-
-	// Now add records with high battery to test resolution
-	// Use a new time window 2 minutes later
-	newNow := now.Add(2 * time.Minute)
-	// Records need to span before the alert time window (newNow - 2 min)
-	recordTimesHigh := []time.Duration{
-		-180 * time.Second, // 3 min before newNow - makes oldest record before alert.time
-		-90 * time.Second,
-		-60 * time.Second,
-		-30 * time.Second,
-	}
-
-	for _, offset := range recordTimesHigh {
-		statsHigh := system.Stats{
-			Cpu:     10,
-			MemPct:  30,
-			DiskPct: 40,
-			Battery: [2]uint8{50, 1}, // 50% battery (above 25% threshold)
-		}
-		statsHighJSON, _ := json.Marshal(statsHigh)
-
-		recordTime := newNow.Add(offset)
-		record, err := beszelTests.CreateRecord(hub, "system_stats", map[string]any{
-			"system": systemRecord.Id,
-			"type":   "1m",
-			"stats":  string(statsHighJSON),
-		})
-		require.NoError(t, err)
-		record.SetRaw("created", recordTime.Format(types.DefaultDateLayout))
-		err = hub.SaveNoValidate(record)
-		require.NoError(t, err)
-	}
-
-	// Create combined data with high battery
-	combinedDataHigh := &system.CombinedData{
-		Stats: system.Stats{
-			Cpu:     10,
-			MemPct:  30,
-			DiskPct: 40,
-			Battery: [2]uint8{50, 1},
-		},
-		Info: system.Info{
-			AgentVersion: "0.12.0",
-			Cpu:          10,
-			MemPct:       30,
-			DiskPct:      40,
-		},
-	}
-
-	// Update system timestamp to the new time window
-	systemRecord.Set("updated", newNow)
-	err = hub.SaveNoValidate(systemRecord)
-	require.NoError(t, err)
-
-	// Handle system alerts - should resolve because average battery is now above threshold
-	err = am.HandleSystemAlerts(systemRecord, combinedDataHigh)
-	require.NoError(t, err)
-
-	// Wait for alert processing
-	time.Sleep(20 * time.Millisecond)
-
-	// Verify alert is resolved (average battery 50% is above threshold 25%)
-	batteryAlert, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": batteryAlert.Id})
-	require.NoError(t, err)
-	assert.False(t, batteryAlert.GetBool("triggered"),
-		"Alert should be resolved when average battery (50%%) is above threshold (25%%) over min period")
-}
--- a/internal/alerts/alerts_quiet_hours_test.go
+++ b/internal/alerts/alerts_quiet_hours_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package alerts_test

--- a/internal/alerts/alerts_smart.go
+++ b/internal/alerts/alerts_smart.go
@@ -1,107 +0,0 @@
-package alerts
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/pocketbase/pocketbase/core"
-)
-
-// handleSmartDeviceAlert sends alerts when a SMART device state worsens into WARNING/FAILED.
-// This is automatic and does not require user opt-in.
-func (am *AlertManager) handleSmartDeviceAlert(e *core.RecordEvent) error {
-	oldState := e.Record.Original().GetString("state")
-	newState := e.Record.GetString("state")
-
-	if !shouldSendSmartDeviceAlert(oldState, newState) {
-		return e.Next()
-	}
-
-	systemID := e.Record.GetString("system")
-	if systemID == "" {
-		return e.Next()
-	}
-
-	// Fetch the system record to get the name and users
-	systemRecord, err := e.App.FindRecordById("systems", systemID)
-	if err != nil {
-		e.App.Logger().Error("Failed to find system for SMART alert", "err", err, "systemID", systemID)
-		return e.Next()
-	}
-
-	systemName := systemRecord.GetString("name")
-	deviceName := e.Record.GetString("name")
-	model := e.Record.GetString("model")
-	statusLabel := smartStateLabel(newState)
-
-	// Build alert message
-	title := fmt.Sprintf("SMART %s on %s: %s %s", statusLabel, systemName, deviceName, smartStateEmoji(newState))
-	var message string
-	if model != "" {
-		message = fmt.Sprintf("Disk %s (%s) SMART status changed to %s", deviceName, model, newState)
-	} else {
-		message = fmt.Sprintf("Disk %s SMART status changed to %s", deviceName, newState)
-	}
-
-	// Get users associated with the system
-	userIDs := systemRecord.GetStringSlice("users")
-	if len(userIDs) == 0 {
-		return e.Next()
-	}
-
-	// Send alert to each user
-	for _, userID := range userIDs {
-		if err := am.SendAlert(AlertMessageData{
-			UserID:   userID,
-			SystemID: systemID,
-			Title:    title,
-			Message:  message,
-			Link:     am.hub.MakeLink("system", systemID),
-			LinkText: "View " + systemName,
-		}); err != nil {
-			e.App.Logger().Error("Failed to send SMART alert", "err", err, "userID", userID)
-		}
-	}
-
-	return e.Next()
-}
-
-func shouldSendSmartDeviceAlert(oldState, newState string) bool {
-	oldSeverity := smartStateSeverity(oldState)
-	newSeverity := smartStateSeverity(newState)
-
-	// Ignore unknown states and recoveries; only alert on worsening transitions
-	// from known-good/degraded states into WARNING/FAILED.
-	return oldSeverity >= 1 && newSeverity > oldSeverity
-}
-
-func smartStateSeverity(state string) int {
-	switch state {
-	case "PASSED":
-		return 1
-	case "WARNING":
-		return 2
-	case "FAILED":
-		return 3
-	default:
-		return 0
-	}
-}
-
-func smartStateEmoji(state string) string {
-	switch state {
-	case "WARNING":
-		return "\U0001F7E0"
-	default:
-		return "\U0001F534"
-	}
-}
-
-func smartStateLabel(state string) string {
-	switch state {
-	case "FAILED":
-		return "failure"
-	default:
-		return strings.ToLower(state)
-	}
-}
--- a/internal/alerts/alerts_smart_test.go
+++ b/internal/alerts/alerts_smart_test.go
@@ -1,264 +0,0 @@
-//go:build testing
-
-package alerts_test
-
-import (
-	"testing"
-	"time"
-
-	beszelTests "github.com/henrygd/beszel/internal/tests"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSmartDeviceAlert(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system for the user
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "test-system",
-		"users": []string{user.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	// Create a smart_device with state PASSED
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/sda",
-		"model":  "Samsung SSD 970 EVO",
-		"state":  "PASSED",
-	})
-	assert.NoError(t, err)
-
-	// Verify no emails sent initially
-	assert.Zero(t, hub.TestMailer.TotalSend(), "should have 0 emails sent initially")
-
-	// Re-fetch the record so PocketBase can properly track original values
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	// Update the smart device state to FAILED
-	smartDevice.Set("state", "FAILED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	// Wait for the alert to be processed
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify that an email was sent
-	assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 email sent after state changed to FAILED")
-
-	// Check the email content
-	lastMessage := hub.TestMailer.LastMessage()
-	assert.Contains(t, lastMessage.Subject, "SMART failure on test-system")
-	assert.Contains(t, lastMessage.Subject, "/dev/sda")
-	assert.Contains(t, lastMessage.Text, "Samsung SSD 970 EVO")
-	assert.Contains(t, lastMessage.Text, "FAILED")
-}
-
-func TestSmartDeviceAlertPassedToWarning(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "test-system",
-		"users": []string{user.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/mmcblk0",
-		"model":  "eMMC",
-		"state":  "PASSED",
-	})
-	assert.NoError(t, err)
-
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	smartDevice.Set("state", "WARNING")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 email sent after state changed to WARNING")
-	lastMessage := hub.TestMailer.LastMessage()
-	assert.Contains(t, lastMessage.Subject, "SMART warning on test-system")
-	assert.Contains(t, lastMessage.Text, "WARNING")
-}
-
-func TestSmartDeviceAlertWarningToFailed(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "test-system",
-		"users": []string{user.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/mmcblk0",
-		"model":  "eMMC",
-		"state":  "WARNING",
-	})
-	assert.NoError(t, err)
-
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	smartDevice.Set("state", "FAILED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 email sent after state changed from WARNING to FAILED")
-	lastMessage := hub.TestMailer.LastMessage()
-	assert.Contains(t, lastMessage.Subject, "SMART failure on test-system")
-	assert.Contains(t, lastMessage.Text, "FAILED")
-}
-
-func TestSmartDeviceAlertNoAlertOnNonPassedToFailed(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system for the user
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "test-system",
-		"users": []string{user.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	// Create a smart_device with state UNKNOWN
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/sda",
-		"model":  "Samsung SSD 970 EVO",
-		"state":  "UNKNOWN",
-	})
-	assert.NoError(t, err)
-
-	// Re-fetch the record so PocketBase can properly track original values
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	// Update the state from UNKNOWN to FAILED - should NOT trigger alert.
-	// We only alert from known healthy/degraded states.
-	smartDevice.Set("state", "FAILED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify no email was sent (only PASSED -> FAILED triggers alert)
-	assert.Zero(t, hub.TestMailer.TotalSend(), "should have 0 emails when changing from UNKNOWN to FAILED")
-
-	// Re-fetch the record again
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	// Update state from FAILED to PASSED - should NOT trigger alert
-	smartDevice.Set("state", "PASSED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify no email was sent
-	assert.Zero(t, hub.TestMailer.TotalSend(), "should have 0 emails when changing from FAILED to PASSED")
-}
-
-func TestSmartDeviceAlertMultipleUsers(t *testing.T) {
-	hub, user1 := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a second user
-	user2, err := beszelTests.CreateUser(hub, "test2@example.com", "password")
-	assert.NoError(t, err)
-
-	// Create user settings for the second user
-	_, err = beszelTests.CreateRecord(hub, "user_settings", map[string]any{
-		"user":     user2.Id,
-		"settings": `{"emails":["test2@example.com"],"webhooks":[]}`,
-	})
-	assert.NoError(t, err)
-
-	// Create a system with both users
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "shared-system",
-		"users": []string{user1.Id, user2.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	// Create a smart_device with state PASSED
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/nvme0n1",
-		"model":  "WD Black SN850",
-		"state":  "PASSED",
-	})
-	assert.NoError(t, err)
-
-	// Re-fetch the record so PocketBase can properly track original values
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	// Update the smart device state to FAILED
-	smartDevice.Set("state", "FAILED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify that two emails were sent (one for each user)
-	assert.EqualValues(t, 2, hub.TestMailer.TotalSend(), "should have 2 emails sent for 2 users")
-}
-
-func TestSmartDeviceAlertWithoutModel(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a system for the user
-	system, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "test-system",
-		"users": []string{user.Id},
-		"host":  "127.0.0.1",
-	})
-	assert.NoError(t, err)
-
-	// Create a smart_device with state PASSED but no model
-	smartDevice, err := beszelTests.CreateRecord(hub, "smart_devices", map[string]any{
-		"system": system.Id,
-		"name":   "/dev/sdb",
-		"state":  "PASSED",
-	})
-	assert.NoError(t, err)
-
-	// Re-fetch the record so PocketBase can properly track original values
-	smartDevice, err = hub.FindRecordById("smart_devices", smartDevice.Id)
-	assert.NoError(t, err)
-
-	// Update the smart device state to FAILED
-	smartDevice.Set("state", "FAILED")
-	err = hub.Save(smartDevice)
-	assert.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify that an email was sent
-	assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 email sent")
-
-	// Check that the email doesn't have empty parentheses for missing model
-	lastMessage := hub.TestMailer.LastMessage()
-	assert.NotContains(t, lastMessage.Text, "()", "should not have empty parentheses for missing model")
-	assert.Contains(t, lastMessage.Text, "/dev/sdb")
-}
--- a/internal/alerts/alerts_system.go
+++ b/internal/alerts/alerts_system.go
@@ -66,30 +66,17 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 			unit = ""
 		case "GPU":
 			val = data.Info.GpuPct
-		case "Battery":
-			if data.Stats.Battery[0] == 0 {
-				continue
-			}
-			val = float64(data.Stats.Battery[0])
 		}

 		triggered := alertRecord.GetBool("triggered")
 		threshold := alertRecord.GetFloat("value")

-		// Battery alert has inverted logic: trigger when value is BELOW threshold
-		lowAlert := isLowAlert(name)
-
 		// CONTINUE
-		// For normal alerts: IF not triggered and curValue <= threshold, OR triggered and curValue > threshold
-		// For low alerts (Battery): IF not triggered and curValue >= threshold, OR triggered and curValue < threshold
-		if lowAlert {
-			if (!triggered && val >= threshold) || (triggered && val < threshold) {
-				continue
-			}
-		} else {
-			if (!triggered && val <= threshold) || (triggered && val > threshold) {
-				continue
-			}
+		// IF alert is not triggered and curValue is less than threshold
+		// OR alert is triggered and curValue is greater than threshold
+		if (!triggered && val <= threshold) || (triggered && val > threshold) {
+			// log.Printf("Skipping alert %s: val %f | threshold %f | triggered %v\n", name, val, threshold, triggered)
+			continue
 		}

 		min := max(1, cast.ToUint8(alertRecord.Get("min")))
@@ -107,11 +94,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst

 		// send alert immediately if min is 1 - no need to sum up values.
 		if min == 1 {
-			if lowAlert {
-				alert.triggered = val < threshold
-			} else {
-				alert.triggered = val > threshold
-			}
+			alert.triggered = val > threshold
 			go am.sendSystemAlert(alert)
 			continue
 		}
@@ -236,8 +219,6 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 					}
 				}
 				alert.val += maxUsage
-			case "Battery":
-				alert.val += float64(stats.Battery[0])
 			default:
 				continue
 			}
@@ -275,24 +256,12 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 		// log.Printf("%s: val %f | count %d | min-count %f | threshold %f\n", alert.name, alert.val, alert.count, minCount, alert.threshold)
 		// pass through alert if count is greater than or equal to minCount
 		if float32(alert.count) >= minCount {
-			// Battery alert has inverted logic: trigger when value is BELOW threshold
-			lowAlert := isLowAlert(alert.name)
-			if lowAlert {
-				if !alert.triggered && alert.val < alert.threshold {
-					alert.triggered = true
-					go am.sendSystemAlert(alert)
-				} else if alert.triggered && alert.val >= alert.threshold {
-					alert.triggered = false
-					go am.sendSystemAlert(alert)
-				}
-			} else {
-				if !alert.triggered && alert.val > alert.threshold {
-					alert.triggered = true
-					go am.sendSystemAlert(alert)
-				} else if alert.triggered && alert.val <= alert.threshold {
-					alert.triggered = false
-					go am.sendSystemAlert(alert)
-				}
+			if !alert.triggered && alert.val > alert.threshold {
+				alert.triggered = true
+				go am.sendSystemAlert(alert)
+			} else if alert.triggered && alert.val <= alert.threshold {
+				alert.triggered = false
+				go am.sendSystemAlert(alert)
 			}
 		}
 	}
@@ -319,19 +288,10 @@ func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
 	}

 	var subject string
-	lowAlert := isLowAlert(alert.name)
 	if alert.triggered {
-		if lowAlert {
-			subject = fmt.Sprintf("%s %s below threshold", systemName, titleAlertName)
-		} else {
-			subject = fmt.Sprintf("%s %s above threshold", systemName, titleAlertName)
-		}
+		subject = fmt.Sprintf("%s %s above threshold", systemName, titleAlertName)
 	} else {
-		if lowAlert {
-			subject = fmt.Sprintf("%s %s above threshold", systemName, titleAlertName)
-		} else {
-			subject = fmt.Sprintf("%s %s below threshold", systemName, titleAlertName)
-		}
+		subject = fmt.Sprintf("%s %s below threshold", systemName, titleAlertName)
 	}
 	minutesLabel := "minute"
 	if alert.min > 1 {
@@ -356,7 +316,3 @@ func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
 		LinkText: "View " + systemName,
 	})
 }
-
-func isLowAlert(name string) bool {
-	return name == "Battery"
-}
--- a/internal/alerts/alerts_test.go
+++ b/internal/alerts/alerts_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package alerts_test

--- a/internal/alerts/alerts_test_helpers.go
+++ b/internal/alerts/alerts_test_helpers.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package alerts

--- a/internal/cmd/agent/agent.go
+++ b/internal/cmd/agent/agent.go
@@ -17,8 +17,9 @@ import (
 type cmdOptions struct {
 	key    string // key is the public key(s) for SSH authentication.
 	listen string // listen is the address or port to listen on.
-	hubURL string // hubURL is the URL of the Beszel hub.
-	token  string // token is the token to use for authentication.
+	// TODO: add hubURL and token
+	// hubURL string // hubURL is the URL of the hub to use.
+	// token  string // token is the token to use for authentication.
 }

 // parse parses the command line flags and populates the config struct.
@@ -31,6 +32,9 @@ func (opts *cmdOptions) parse() bool {

 	// Subcommands that don't require any pflag parsing
 	switch subcommand {
+	case "-v", "version":
+		fmt.Println(beszel.AppName+"-agent", beszel.Version)
+		return true
 	case "health":
 		err := health.Check()
 		if err != nil {
@@ -38,22 +42,18 @@ func (opts *cmdOptions) parse() bool {
 		}
 		fmt.Print("ok")
 		return true
-	case "fingerprint":
-		handleFingerprint()
-		return true
 	}

 	// pflag.CommandLine.ParseErrorsWhitelist.UnknownFlags = true
 	pflag.StringVarP(&opts.key, "key", "k", "", "Public key(s) for SSH authentication")
 	pflag.StringVarP(&opts.listen, "listen", "l", "", "Address or port to listen on")
-	pflag.StringVarP(&opts.hubURL, "url", "u", "", "URL of the Beszel hub")
-	pflag.StringVarP(&opts.token, "token", "t", "", "Token to use for authentication")
+	// pflag.StringVarP(&opts.hubURL, "hub-url", "u", "", "URL of the hub to use")
+	// pflag.StringVarP(&opts.token, "token", "t", "", "Token to use for authentication")
 	chinaMirrors := pflag.BoolP("china-mirrors", "c", false, "Use mirror for update (gh.beszel.dev) instead of GitHub")
-	version := pflag.BoolP("version", "v", false, "Show version information")
 	help := pflag.BoolP("help", "h", false, "Show this help message")

 	// Convert old single-dash long flags to double-dash for backward compatibility
-	flagsToConvert := []string{"key", "listen", "url", "token"}
+	flagsToConvert := []string{"key", "listen"}
 	for i, arg := range os.Args {
 		for _, flag := range flagsToConvert {
 			singleDash := "-" + flag
@@ -74,9 +74,9 @@ func (opts *cmdOptions) parse() bool {
 		builder.WriteString(os.Args[0])
 		builder.WriteString(" [command] [flags]\n")
 		builder.WriteString("\nCommands:\n")
-		builder.WriteString("  fingerprint  View or reset the agent fingerprint\n")
-		builder.WriteString("  health       Check if the agent is running\n")
-		builder.WriteString("  update       Update to the latest version\n")
+		builder.WriteString("  health    Check if the agent is running\n")
+		// builder.WriteString("  help      Display this help message\n")
+		builder.WriteString("  update    Update to the latest version\n")
 		builder.WriteString("\nFlags:\n")
 		fmt.Print(builder.String())
 		pflag.PrintDefaults()
@@ -87,9 +87,6 @@ func (opts *cmdOptions) parse() bool {

 	// Must run after pflag.Parse()
 	switch {
-	case *version:
-		fmt.Println(beszel.AppName+"-agent", beszel.Version)
-		return true
 	case *help || subcommand == "help":
 		pflag.Usage()
 		return true
@@ -98,13 +95,6 @@ func (opts *cmdOptions) parse() bool {
 		return true
 	}

-	// Set environment variables from CLI flags (if provided)
-	if opts.hubURL != "" {
-		os.Setenv("HUB_URL", opts.hubURL)
-	}
-	if opts.token != "" {
-		os.Setenv("TOKEN", opts.token)
-	}
 	return false
 }

@@ -137,38 +127,6 @@ func (opts *cmdOptions) getAddress() string {
 	return agent.GetAddress(opts.listen)
 }

-// handleFingerprint handles the "fingerprint" command with subcommands "view" and "reset".
-func handleFingerprint() {
-	subCmd := ""
-	if len(os.Args) > 2 {
-		subCmd = os.Args[2]
-	}
-
-	switch subCmd {
-	case "", "view":
-		dataDir, _ := agent.GetDataDir()
-		fp := agent.GetFingerprint(dataDir, "", "")
-		fmt.Println(fp)
-	case "help", "-h", "--help":
-		fmt.Print(fingerprintUsage())
-	case "reset":
-		dataDir, err := agent.GetDataDir()
-		if err != nil {
-			log.Fatal(err)
-		}
-		if err := agent.DeleteFingerprint(dataDir); err != nil {
-			log.Fatal(err)
-		}
-		fmt.Println("Fingerprint reset. A new one will be generated on next start.")
-	default:
-		log.Fatalf("Unknown command: %q\n\n%s", subCmd, fingerprintUsage())
-	}
-}
-
-func fingerprintUsage() string {
-	return fmt.Sprintf("Usage: %s fingerprint [view|reset]\n\nCommands:\n  view   Print fingerprint (default)\n  reset  Reset saved fingerprint\n", os.Args[0])
-}
-
 func main() {
 	var opts cmdOptions
 	subcommandHandled := opts.parse()
--- a/internal/common/common-ws.go
+++ b/internal/common/common-ws.go
@@ -1,7 +1,6 @@
 package common

 import (
-	"github.com/fxamacker/cbor/v2"
 	"github.com/henrygd/beszel/internal/entities/smart"
 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/henrygd/beszel/internal/entities/systemd"
@@ -35,14 +34,14 @@ type HubRequest[T any] struct {
 // AgentResponse defines the structure for responses sent from agent to hub.
 type AgentResponse struct {
 	Id          *uint32                    `cbor:"0,keyasint,omitempty"`
-	SystemData  *system.CombinedData       `cbor:"1,keyasint,omitempty,omitzero"` // Legacy (<= 0.17)
-	Fingerprint *FingerprintResponse       `cbor:"2,keyasint,omitempty,omitzero"` // Legacy (<= 0.17)
+	SystemData  *system.CombinedData       `cbor:"1,keyasint,omitempty,omitzero"`
+	Fingerprint *FingerprintResponse       `cbor:"2,keyasint,omitempty,omitzero"`
 	Error       string                     `cbor:"3,keyasint,omitempty,omitzero"`
-	String      *string                    `cbor:"4,keyasint,omitempty,omitzero"` // Legacy (<= 0.17)
-	SmartData   map[string]smart.SmartData `cbor:"5,keyasint,omitempty,omitzero"` // Legacy (<= 0.17)
-	ServiceInfo systemd.ServiceDetails     `cbor:"6,keyasint,omitempty,omitzero"` // Legacy (<= 0.17)
-	// Data is the generic response payload for new endpoints (0.18+)
-	Data cbor.RawMessage `cbor:"7,keyasint,omitempty,omitzero"`
+	String      *string                    `cbor:"4,keyasint,omitempty,omitzero"`
+	SmartData   map[string]smart.SmartData `cbor:"5,keyasint,omitempty,omitzero"`
+	ServiceInfo systemd.ServiceDetails     `cbor:"6,keyasint,omitempty,omitzero"`
+	// Logs        *LogsPayload         `cbor:"4,keyasint,omitempty,omitzero"`
+	// RawBytes    []byte               `cbor:"4,keyasint,omitempty,omitzero"`
 }

 type FingerprintRequest struct {
@@ -59,8 +58,8 @@ type FingerprintResponse struct {
 }

 type DataRequestOptions struct {
-	CacheTimeMs    uint16 `cbor:"0,keyasint"`
-	IncludeDetails bool   `cbor:"1,keyasint"`
+	CacheTimeMs uint16 `cbor:"0,keyasint"`
+	// ResourceType uint8  `cbor:"1,keyasint,omitempty,omitzero"`
 }

 type ContainerLogsRequest struct {
--- a/internal/dockerfile_agent
+++ b/internal/dockerfile_agent
@@ -23,9 +23,6 @@ COPY --from=builder /agent /agent
 # this is so we don't need to create the /tmp directory in the scratch container
 COPY --from=builder /tmp /tmp

-# AMD GPU name lookup (used by agent on Linux when /usr/share/libdrm/amdgpu.ids is read)
-COPY --from=builder /app/agent/test-data/amdgpu.ids /usr/share/libdrm/amdgpu.ids
-
 # Ensure data persistence across container recreations
 VOLUME ["/var/lib/beszel-agent"]

--- a/internal/dockerfile_agent_alpine
+++ b/internal/dockerfile_agent_alpine
@@ -17,12 +17,9 @@ RUN rm -rf /tmp/*
 # --------------------------
 # Final image: default scratch-based agent
 # --------------------------
-FROM alpine:3.23
+FROM alpine:latest
 COPY --from=builder /agent /agent

-# AMD GPU name lookup (used by agent on Linux when /usr/share/libdrm/amdgpu.ids is read)
-COPY --from=builder /app/agent/test-data/amdgpu.ids /usr/share/libdrm/amdgpu.ids
-
 RUN apk add --no-cache smartmontools

 # Ensure data persistence across container recreations
--- a/internal/dockerfile_agent_intel
+++ b/internal/dockerfile_agent_intel
@@ -16,7 +16,7 @@ RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-
 # Final image
 # Note: must cap_add: [CAP_PERFMON] and mount /dev/dri/ as volume
 # --------------------------
-FROM alpine:3.23
+FROM alpine:edge

 COPY --from=builder /agent /agent

--- a/internal/dockerfile_agent_nvidia
+++ b/internal/dockerfile_agent_nvidia
@@ -1,4 +1,4 @@
-FROM --platform=$BUILDPLATFORM golang:bookworm AS builder
+FROM --platform=$BUILDPLATFORM golang:alpine AS builder

 WORKDIR /app

@@ -10,7 +10,7 @@ COPY . ./

 # Build
 ARG TARGETOS TARGETARCH
-RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -tags glibc -ldflags "-w -s" -o /agent ./internal/cmd/agent
+RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./internal/cmd/agent

 # --------------------------
 # Smartmontools builder stage
@@ -37,9 +37,6 @@ RUN apt-get update && apt-get install -y \
 FROM nvidia/cuda:12.2.2-base-ubuntu22.04
 COPY --from=builder /agent /agent

-# AMD GPU name lookup (used by agent on hybrid laptops when /usr/share/libdrm/amdgpu.ids is read)
-COPY --from=builder /app/agent/test-data/amdgpu.ids /usr/share/libdrm/amdgpu.ids
-
 # Copy smartmontools binaries and config files
 COPY --from=smartmontools-builder /usr/sbin/smartctl /usr/sbin/smartctl

--- a/internal/entities/container/container.go
+++ b/internal/entities/container/container.go
@@ -34,14 +34,6 @@ type ApiStats struct {
 	MemoryStats MemoryStats `json:"memory_stats"`
 }

-// Docker system info from /info API endpoint
-type HostInfo struct {
-	OperatingSystem string `json:"OperatingSystem"`
-	KernelVersion   string `json:"KernelVersion"`
-	NCPU            int    `json:"NCPU"`
-	MemTotal        uint64 `json:"MemTotal"`
-}
-
 func (s *ApiStats) CalculateCpuPercentLinux(prevCpuContainer uint64, prevCpuSystem uint64) float64 {
 	cpuDelta := s.CPUStats.CPUUsage.TotalUsage - prevCpuContainer
 	systemDelta := s.CPUStats.SystemUsage - prevCpuSystem
@@ -129,12 +121,11 @@ var DockerHealthStrings = map[string]DockerHealth{

 // Docker container stats
 type Stats struct {
-	Name        string    `json:"n" cbor:"0,keyasint"`
-	Cpu         float64   `json:"c" cbor:"1,keyasint"`
-	Mem         float64   `json:"m" cbor:"2,keyasint"`
-	NetworkSent float64   `json:"ns,omitzero" cbor:"3,keyasint,omitzero"` // deprecated 0.18.3 (MB) - keep field for old agents/records
-	NetworkRecv float64   `json:"nr,omitzero" cbor:"4,keyasint,omitzero"` // deprecated 0.18.3 (MB) - keep field for old agents/records
-	Bandwidth   [2]uint64 `json:"b,omitzero" cbor:"9,keyasint,omitzero"`  // [sent bytes, recv bytes]
+	Name        string  `json:"n" cbor:"0,keyasint"`
+	Cpu         float64 `json:"c" cbor:"1,keyasint"`
+	Mem         float64 `json:"m" cbor:"2,keyasint"`
+	NetworkSent float64 `json:"ns" cbor:"3,keyasint"`
+	NetworkRecv float64 `json:"nr" cbor:"4,keyasint"`

 	Health DockerHealth `json:"-" cbor:"5,keyasint"`
 	Status string       `json:"-" cbor:"6,keyasint"`
--- a/internal/entities/smart/smart.go
+++ b/internal/entities/smart/smart.go
@@ -130,23 +130,10 @@ type SummaryInfo struct {
 }

 type AtaSmartAttributes struct {
+	// Revision int                 `json:"revision"`
 	Table []AtaSmartAttribute `json:"table"`
 }

-type AtaDeviceStatistics struct {
-	Pages []AtaDeviceStatisticsPage `json:"pages"`
-}
-
-type AtaDeviceStatisticsPage struct {
-	Number uint8                      `json:"number"`
-	Table  []AtaDeviceStatisticsEntry `json:"table"`
-}
-
-type AtaDeviceStatisticsEntry struct {
-	Name  string  `json:"name"`
-	Value *uint64 `json:"value,omitempty"`
-}
-
 type AtaSmartAttribute struct {
 	ID         uint16 `json:"id"`
 	Name       string `json:"name"`
@@ -356,8 +343,7 @@ type SmartInfoForSata struct {
 	SmartStatus SmartStatusInfo `json:"smart_status"`
 	// AtaSmartData                 AtaSmartData                 `json:"ata_smart_data"`
 	// AtaSctCapabilities           AtaSctCapabilities           `json:"ata_sct_capabilities"`
-	AtaSmartAttributes  AtaSmartAttributes  `json:"ata_smart_attributes"`
-	AtaDeviceStatistics AtaDeviceStatistics `json:"ata_device_statistics"`
+	AtaSmartAttributes AtaSmartAttributes `json:"ata_smart_attributes"`
 	// PowerOnTime                  PowerOnTimeInfo              `json:"power_on_time"`
 	// PowerCycleCount              uint16                       `json:"power_cycle_count"`
 	Temperature TemperatureInfo `json:"temperature"`
--- a/internal/entities/system/system.go
+++ b/internal/entities/system/system.go
@@ -27,8 +27,8 @@ type Stats struct {
 	DiskWritePs    float64             `json:"dw" cbor:"13,keyasint"`
 	MaxDiskReadPs  float64             `json:"drm,omitempty" cbor:"14,keyasint,omitempty"`
 	MaxDiskWritePs float64             `json:"dwm,omitempty" cbor:"15,keyasint,omitempty"`
-	NetworkSent    float64             `json:"ns,omitzero" cbor:"16,keyasint,omitzero"`
-	NetworkRecv    float64             `json:"nr,omitzero" cbor:"17,keyasint,omitzero"`
+	NetworkSent    float64             `json:"ns" cbor:"16,keyasint"`
+	NetworkRecv    float64             `json:"nr" cbor:"17,keyasint"`
 	MaxNetworkSent float64             `json:"nsm,omitempty" cbor:"18,keyasint,omitempty"`
 	MaxNetworkRecv float64             `json:"nrm,omitempty" cbor:"19,keyasint,omitempty"`
 	Temperatures   map[string]float64  `json:"t,omitempty" cbor:"20,keyasint,omitempty"`
@@ -123,49 +123,31 @@ const (
 	ConnectionTypeWebSocket
 )

-// Core system data that is needed in All Systems table
 type Info struct {
-	Hostname      string `json:"h,omitempty" cbor:"0,keyasint,omitempty"` // deprecated - moved to Details struct
-	KernelVersion string `json:"k,omitempty" cbor:"1,keyasint,omitempty"` // deprecated - moved to Details struct
-	Cores         int    `json:"c,omitzero" cbor:"2,keyasint,omitzero"`   // deprecated - moved to Details struct
-	// Threads is needed in Info struct to calculate load average thresholds
+	Hostname       string  `json:"h" cbor:"0,keyasint"`
+	KernelVersion  string  `json:"k,omitempty" cbor:"1,keyasint,omitempty"`
+	Cores          int     `json:"c" cbor:"2,keyasint"`
 	Threads        int     `json:"t,omitempty" cbor:"3,keyasint,omitempty"`
-	CpuModel       string  `json:"m,omitempty" cbor:"4,keyasint,omitempty"` // deprecated - moved to Details struct
+	CpuModel       string  `json:"m" cbor:"4,keyasint"`
 	Uptime         uint64  `json:"u" cbor:"5,keyasint"`
 	Cpu            float64 `json:"cpu" cbor:"6,keyasint"`
 	MemPct         float64 `json:"mp" cbor:"7,keyasint"`
 	DiskPct        float64 `json:"dp" cbor:"8,keyasint"`
 	Bandwidth      float64 `json:"b" cbor:"9,keyasint"`
 	AgentVersion   string  `json:"v" cbor:"10,keyasint"`
-	Podman         bool    `json:"p,omitempty" cbor:"11,keyasint,omitempty"` // deprecated - moved to Details struct
+	Podman         bool    `json:"p,omitempty" cbor:"11,keyasint,omitempty"`
 	GpuPct         float64 `json:"g,omitempty" cbor:"12,keyasint,omitempty"`
 	DashboardTemp  float64 `json:"dt,omitempty" cbor:"13,keyasint,omitempty"`
-	Os             Os      `json:"os,omitempty" cbor:"14,keyasint,omitempty"`  // deprecated - moved to Details struct
-	LoadAvg1       float64 `json:"l1,omitempty" cbor:"15,keyasint,omitempty"`  // deprecated - use `la` array instead
-	LoadAvg5       float64 `json:"l5,omitempty" cbor:"16,keyasint,omitempty"`  // deprecated - use `la` array instead
-	LoadAvg15      float64 `json:"l15,omitempty" cbor:"17,keyasint,omitempty"` // deprecated - use `la` array instead
+	Os             Os      `json:"os" cbor:"14,keyasint"`
+	LoadAvg1       float64 `json:"l1,omitempty" cbor:"15,keyasint,omitempty"`
+	LoadAvg5       float64 `json:"l5,omitempty" cbor:"16,keyasint,omitempty"`
+	LoadAvg15      float64 `json:"l15,omitempty" cbor:"17,keyasint,omitempty"`
 	BandwidthBytes uint64  `json:"bb" cbor:"18,keyasint"`
-
+	// TODO: remove load fields in future release in favor of load avg array
 	LoadAvg        [3]float64         `json:"la,omitempty" cbor:"19,keyasint"`
 	ConnectionType ConnectionType     `json:"ct,omitempty" cbor:"20,keyasint,omitempty,omitzero"`
 	ExtraFsPct     map[string]float64 `json:"efs,omitempty" cbor:"21,keyasint,omitempty"`
 	Services       []uint16           `json:"sv,omitempty" cbor:"22,keyasint,omitempty"` // [totalServices, numFailedServices]
-	Battery        [2]uint8           `json:"bat,omitzero" cbor:"23,keyasint,omitzero"`  // [percent, charge state]
-}
-
-// Data that does not change during process lifetime and is not needed in All Systems table
-type Details struct {
-	Hostname      string        `cbor:"0,keyasint"`
-	Kernel        string        `cbor:"1,keyasint,omitempty"`
-	Cores         int           `cbor:"2,keyasint"`
-	Threads       int           `cbor:"3,keyasint"`
-	CpuModel      string        `cbor:"4,keyasint"`
-	Os            Os            `cbor:"5,keyasint"`
-	OsName        string        `cbor:"6,keyasint"`
-	Arch          string        `cbor:"7,keyasint"`
-	Podman        bool          `cbor:"8,keyasint,omitempty"`
-	MemoryTotal   uint64        `cbor:"9,keyasint"`
-	SmartInterval time.Duration `cbor:"10,keyasint,omitempty"`
 }

 // Final data structure to return to the hub
@@ -174,5 +156,4 @@ type CombinedData struct {
 	Info            Info               `json:"info" cbor:"1,keyasint"`
 	Containers      []*container.Stats `json:"container" cbor:"2,keyasint"`
 	SystemdServices []*systemd.Service `json:"systemd,omitempty" cbor:"3,keyasint,omitempty"`
-	Details         *Details           `cbor:"4,keyasint,omitempty"`
 }
--- a/internal/ghupdate/ghupdate.go
+++ b/internal/ghupdate/ghupdate.go
@@ -11,7 +11,6 @@ import (
 	"log/slog"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -34,7 +33,7 @@ func ColorPrint(color, text string) {
 	fmt.Println(color + text + colorReset)
 }

-func ColorPrintf(color, format string, args ...any) {
+func ColorPrintf(color, format string, args ...interface{}) {
 	fmt.Printf(color+format+colorReset+"\n", args...)
 }

@@ -346,32 +345,5 @@ func archiveSuffix(binaryName, goos, goarch string) string {
 	if goos == "windows" {
 		return fmt.Sprintf("%s_%s_%s.zip", binaryName, goos, goarch)
 	}
-	// Use glibc build for agent on glibc systems (includes NVML support via purego)
-	if binaryName == "beszel-agent" && goos == "linux" && goarch == "amd64" && isGlibc() {
-		return fmt.Sprintf("%s_%s_%s_glibc.tar.gz", binaryName, goos, goarch)
-	}
 	return fmt.Sprintf("%s_%s_%s.tar.gz", binaryName, goos, goarch)
 }
-
-func isGlibc() bool {
-	for _, path := range []string{
-		"/lib64/ld-linux-x86-64.so.2",                // common on many distros
-		"/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", // Debian/Ubuntu
-		"/lib/ld-linux-x86-64.so.2",                  // alternate
-	} {
-		if _, err := os.Stat(path); err == nil {
-			return true
-		}
-	}
-	// Fallback to ldd output when present (musl ldd reports musl, glibc reports GNU libc/glibc).
-	if lddPath, err := exec.LookPath("ldd"); err == nil {
-		out, err := exec.Command(lddPath, "--version").CombinedOutput()
-		if err == nil {
-			s := strings.ToLower(string(out))
-			if strings.Contains(s, "gnu libc") || strings.Contains(s, "glibc") {
-				return true
-			}
-		}
-	}
-	return false
-}
--- a/internal/ghupdate/selinux.go
+++ b/internal/ghupdate/selinux.go
@@ -1,66 +0,0 @@
-package ghupdate
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-)
-
-// HandleSELinuxContext restores or applies the correct SELinux label to the binary.
-func HandleSELinuxContext(path string) error {
-	out, err := exec.Command("getenforce").Output()
-	if err != nil {
-		// SELinux not enabled or getenforce not available
-		return nil
-	}
-	state := strings.TrimSpace(string(out))
-	if state == "Disabled" {
-		return nil
-	}
-
-	ColorPrint(ColorYellow, "SELinux is enabled; applying context…")
-
-	// Try persistent context via semanage+restorecon
-	if success := trySemanageRestorecon(path); success {
-		return nil
-	}
-
-	// Fallback to temporary context via chcon
-	if chconPath, err := exec.LookPath("chcon"); err == nil {
-		if err := exec.Command(chconPath, "-t", "bin_t", path).Run(); err != nil {
-			return fmt.Errorf("chcon failed: %w", err)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("no SELinux tools available (semanage/restorecon or chcon)")
-}
-
-// trySemanageRestorecon attempts to set persistent SELinux context using semanage and restorecon.
-// Returns true if successful, false otherwise.
-func trySemanageRestorecon(path string) bool {
-	semanagePath, err := exec.LookPath("semanage")
-	if err != nil {
-		return false
-	}
-
-	restoreconPath, err := exec.LookPath("restorecon")
-	if err != nil {
-		return false
-	}
-
-	// Try to add the fcontext rule; if it already exists, try to modify it
-	if err := exec.Command(semanagePath, "fcontext", "-a", "-t", "bin_t", path).Run(); err != nil {
-		// Rule may already exist, try modify instead
-		if err := exec.Command(semanagePath, "fcontext", "-m", "-t", "bin_t", path).Run(); err != nil {
-			return false
-		}
-	}
-
-	// Apply the context with restorecon
-	if err := exec.Command(restoreconPath, "-v", path).Run(); err != nil {
-		return false
-	}
-
-	return true
-}
--- a/internal/ghupdate/selinux_test.go
+++ b/internal/ghupdate/selinux_test.go
@@ -1,53 +0,0 @@
-package ghupdate
-
-import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-func TestHandleSELinuxContext_NoSELinux(t *testing.T) {
-	// Skip on SELinux systems - this test is for non-SELinux behavior
-	if _, err := exec.LookPath("getenforce"); err == nil {
-		t.Skip("skipping on SELinux-enabled system")
-	}
-
-	// On systems without SELinux, getenforce will fail and the function
-	// should return nil without error
-	tempFile := filepath.Join(t.TempDir(), "test-binary")
-	if err := os.WriteFile(tempFile, []byte("test"), 0755); err != nil {
-		t.Fatalf("failed to create temp file: %v", err)
-	}
-
-	err := HandleSELinuxContext(tempFile)
-	if err != nil {
-		t.Errorf("HandleSELinuxContext() on non-SELinux system returned error: %v", err)
-	}
-}
-
-func TestHandleSELinuxContext_InvalidPath(t *testing.T) {
-	// Skip on SELinux systems - this test is for non-SELinux behavior
-	if _, err := exec.LookPath("getenforce"); err == nil {
-		t.Skip("skipping on SELinux-enabled system")
-	}
-
-	// On non-SELinux systems, getenforce fails early so even invalid paths succeed
-	err := HandleSELinuxContext("/nonexistent/path/binary")
-	if err != nil {
-		t.Errorf("HandleSELinuxContext() with invalid path on non-SELinux system returned error: %v", err)
-	}
-}
-
-func TestTrySemanageRestorecon_NoTools(t *testing.T) {
-	// Skip if semanage is available (we don't want to modify system SELinux policy)
-	if _, err := exec.LookPath("semanage"); err == nil {
-		t.Skip("skipping on system with semanage available")
-	}
-
-	// Should return false when semanage is not available
-	result := trySemanageRestorecon("/some/path")
-	if result {
-		t.Error("trySemanageRestorecon() returned true when semanage is not available")
-	}
-}
--- a/internal/hub/agent_connect.go
+++ b/internal/hub/agent_connect.go
@@ -66,15 +66,6 @@ func (acr *agentConnectRequest) agentConnect() (err error) {

 	// Check if token is an active universal token
 	acr.userId, acr.isUniversalToken = universalTokenMap.GetMap().GetOk(acr.token)
-	if !acr.isUniversalToken {
-		// Fallback: check for a permanent universal token stored in the DB
-		if rec, err := acr.hub.FindFirstRecordByFilter("universal_tokens", "token = {:token}", dbx.Params{"token": acr.token}); err == nil {
-			if userID := rec.GetString("user"); userID != "" {
-				acr.userId = userID
-				acr.isUniversalToken = true
-			}
-		}
-	}

 	// Find matching fingerprint records for this token
 	fpRecords := getFingerprintRecordsByToken(acr.token, acr.hub)
--- a/internal/hub/agent_connect_test.go
+++ b/internal/hub/agent_connect_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package hub

@@ -9,7 +10,6 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"testing"
 	"time"
@@ -35,26 +35,6 @@ func createTestHub(t testing.TB) (*Hub, *pbtests.TestApp, error) {
 	return NewHub(testApp), testApp, nil
 }

-// cleanupTestHub stops background system goroutines before tearing down the app.
-func cleanupTestHub(hub *Hub, testApp *pbtests.TestApp) {
-	if hub != nil {
-		sm := hub.GetSystemManager()
-		sm.RemoveAllSystems()
-		// Give updater goroutines a brief window to observe cancellation before DB teardown.
-		for range 20 {
-			if sm.GetSystemCount() == 0 {
-				break
-			}
-			runtime.Gosched()
-			time.Sleep(5 * time.Millisecond)
-		}
-		time.Sleep(20 * time.Millisecond)
-	}
-	if testApp != nil {
-		testApp.Cleanup()
-	}
-}
-
 // Helper function to create a test record
 func createTestRecord(app core.App, collection string, data map[string]any) (*core.Record, error) {
 	col, err := app.FindCachedCollectionByNameOrId(collection)
@@ -84,7 +64,7 @@ func TestValidateAgentHeaders(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	testCases := []struct {
 		name          string
@@ -165,7 +145,7 @@ func TestGetAllFingerprintRecordsByToken(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// create test user
 	userRecord, err := createTestUser(testApp)
@@ -255,7 +235,7 @@ func TestSetFingerprint(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
@@ -335,7 +315,7 @@ func TestCreateSystemFromAgentData(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
@@ -445,7 +425,7 @@ func TestUniversalTokenFlow(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(nil, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
@@ -513,7 +493,7 @@ func TestAgentConnect(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
@@ -672,7 +652,7 @@ func TestHandleAgentConnect(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
@@ -757,7 +737,7 @@ func TestAgentWebSocketIntegration(t *testing.T) {
 	// Create hub and test app
 	hub, testApp, err := createTestHub(t)
 	require.NoError(t, err)
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Get the hub's SSH key
 	hubSigner, err := hub.GetSSHKey("")
@@ -962,8 +942,6 @@ func TestAgentWebSocketIntegration(t *testing.T) {
 				}
 			}

-			time.Sleep(20 * time.Millisecond)
-
 			// Verify fingerprint state by re-reading the specific record
 			updatedFingerprintRecord, err := testApp.FindRecordById("fingerprints", fingerprintRecord.Id)
 			require.NoError(t, err)
@@ -998,7 +976,7 @@ func TestMultipleSystemsWithSameUniversalToken(t *testing.T) {
 	// Create hub and test app
 	hub, testApp, err := createTestHub(t)
 	require.NoError(t, err)
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Get the hub's SSH key
 	hubSigner, err := hub.GetSSHKey("")
@@ -1166,8 +1144,6 @@ func TestMultipleSystemsWithSameUniversalToken(t *testing.T) {
 					assert.Equal(t, systemCount, systemsAfterCount, "Total system count should remain the same")
 				}

-				time.Sleep(20 * time.Millisecond)
-
 				// Verify that a fingerprint record exists for this fingerprint
 				fingerprints, err := testApp.FindRecordsByFilter("fingerprints", "token = {:token} && fingerprint = {:fingerprint}", "", -1, 0, map[string]any{
 					"token":       universalToken,
@@ -1193,111 +1169,11 @@ func TestMultipleSystemsWithSameUniversalToken(t *testing.T) {
 	}
 }

-// TestPermanentUniversalTokenFromDB verifies that a universal token persisted in the DB
-// (universal_tokens collection) is accepted for agent self-registration even if it is not
-// present in the in-memory universalTokenMap.
-func TestPermanentUniversalTokenFromDB(t *testing.T) {
-	// Create hub and test app
-	hub, testApp, err := createTestHub(t)
-	require.NoError(t, err)
-	defer cleanupTestHub(hub, testApp)
-
-	// Get the hub's SSH key
-	hubSigner, err := hub.GetSSHKey("")
-	require.NoError(t, err)
-	goodPubKey := hubSigner.PublicKey()
-
-	// Create test user
-	userRecord, err := createTestUser(testApp)
-	require.NoError(t, err)
-
-	// Create a permanent universal token record in the DB (do NOT add it to universalTokenMap)
-	universalToken := "db-universal-token-123"
-	_, err = createTestRecord(testApp, "universal_tokens", map[string]any{
-		"user":  userRecord.Id,
-		"token": universalToken,
-	})
-	require.NoError(t, err)
-
-	// Create HTTP server with the actual API route
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/api/beszel/agent-connect" {
-			acr := &agentConnectRequest{
-				hub: hub,
-				req: r,
-				res: w,
-			}
-			acr.agentConnect()
-		} else {
-			http.NotFound(w, r)
-		}
-	}))
-	defer ts.Close()
-
-	// Create and configure agent
-	agentDataDir := t.TempDir()
-	err = os.WriteFile(filepath.Join(agentDataDir, "fingerprint"), []byte("db-token-system-fingerprint"), 0644)
-	require.NoError(t, err)
-
-	testAgent, err := agent.NewAgent(agentDataDir)
-	require.NoError(t, err)
-
-	// Set up environment variables for the agent
-	os.Setenv("BESZEL_AGENT_HUB_URL", ts.URL)
-	os.Setenv("BESZEL_AGENT_TOKEN", universalToken)
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	// Start agent in background
-	done := make(chan error, 1)
-	go func() {
-		serverOptions := agent.ServerOptions{
-			Network: "tcp",
-			Addr:    "127.0.0.1:46050",
-			Keys:    []ssh.PublicKey{goodPubKey},
-		}
-		done <- testAgent.Start(serverOptions)
-	}()
-
-	// Wait for connection result
-	maxWait := 2 * time.Second
-	time.Sleep(20 * time.Millisecond)
-	checkInterval := 20 * time.Millisecond
-	timeout := time.After(maxWait)
-	ticker := time.Tick(checkInterval)
-
-	connectionManager := testAgent.GetConnectionManager()
-	for {
-		select {
-		case <-timeout:
-			t.Fatalf("Expected connection to succeed but timed out - agent state: %d", connectionManager.State)
-		case <-ticker:
-			if connectionManager.State == agent.WebSocketConnected {
-				// Success
-				goto verify
-			}
-		case err := <-done:
-			// If Start returns early, treat it as failure
-			if err != nil {
-				t.Fatalf("Agent failed to start/connect: %v", err)
-			}
-		}
-	}
-
-verify:
-	// Verify that a system was created for the user (self-registration path)
-	systemsAfter, err := testApp.FindRecordsByFilter("systems", "users ~ {:userId}", "", -1, 0, map[string]any{"userId": userRecord.Id})
-	require.NoError(t, err)
-	require.NotEmpty(t, systemsAfter, "Expected a system to be created for DB-backed universal token")
-}
-
 // TestFindOrCreateSystemForToken tests the findOrCreateSystemForToken function
 func TestFindOrCreateSystemForToken(t *testing.T) {
 	hub, testApp, err := createTestHub(t)
 	require.NoError(t, err)
-	defer cleanupTestHub(hub, testApp)
+	defer testApp.Cleanup()

 	// Create test user
 	userRecord, err := createTestUser(testApp)
--- a/internal/hub/config/config_test.go
+++ b/internal/hub/config/config_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package config_test

--- a/internal/hub/expirymap/expirymap_test.go
+++ b/internal/hub/expirymap/expirymap_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package expirymap

@@ -414,11 +415,7 @@ func TestExpiryMap_RemoveValue_WithExpiration(t *testing.T) {
 	// Wait for first value to expire
 	time.Sleep(time.Millisecond * 20)

-	// Trigger lazy cleanup of the expired key
-	_, ok := em.GetOk("key1")
-	assert.False(t, ok)
-
-	// Try to remove the remaining "value1" entry (key3)
+	// Try to remove the expired value - should remove one of the "value1" entries
 	removedValue, ok := em.RemovebyValue("value1")
 	assert.True(t, ok)
 	assert.Equal(t, "value1", removedValue)
@@ -426,9 +423,14 @@ func TestExpiryMap_RemoveValue_WithExpiration(t *testing.T) {
 	// Should still have key2 (different value)
 	assert.True(t, em.Has("key2"))

-	// key1 should be gone due to expiration and key3 should be removed by value.
-	assert.False(t, em.Has("key1"))
-	assert.False(t, em.Has("key3"))
+	// Should have removed one of the "value1" entries (either key1 or key3)
+	// But we can't predict which one due to map iteration order
+	key1Exists := em.Has("key1")
+	key3Exists := em.Has("key3")
+
+	// Exactly one of key1 or key3 should be gone
+	assert.False(t, key1Exists && key3Exists) // Both shouldn't exist
+	assert.True(t, key1Exists || key3Exists)  // At least one should still exist
 }

 func TestExpiryMap_ValueOperations_Integration(t *testing.T) {
--- a/internal/hub/heartbeat/heartbeat.go
+++ b/internal/hub/heartbeat/heartbeat.go
@@ -1,303 +0,0 @@
-// Package heartbeat sends periodic outbound pings to an external monitoring
-// endpoint (e.g. BetterStack, Uptime Kuma, Healthchecks.io) so operators can
-// monitor Beszel without exposing it to the internet.
-package heartbeat
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel"
-	"github.com/pocketbase/pocketbase/core"
-)
-
-// Default values for heartbeat configuration.
-const (
-	defaultInterval = 60 // seconds
-	httpTimeout     = 10 * time.Second
-)
-
-// Payload is the JSON body sent with each heartbeat request.
-type Payload struct {
-	// Status is "ok" when all non-paused systems are up, "warn" when alerts
-	// are triggered but no systems are down, and "error" when any system is down.
-	Status    string         `json:"status"`
-	Timestamp string         `json:"timestamp"`
-	Msg       string         `json:"msg"`
-	Systems   SystemsSummary `json:"systems"`
-	Down      []SystemInfo   `json:"down_systems,omitempty"`
-	Alerts    []AlertInfo    `json:"triggered_alerts,omitempty"`
-	Version   string         `json:"beszel_version"`
-}
-
-// SystemsSummary contains counts of systems by status.
-type SystemsSummary struct {
-	Total   int `json:"total"`
-	Up      int `json:"up"`
-	Down    int `json:"down"`
-	Paused  int `json:"paused"`
-	Pending int `json:"pending"`
-}
-
-// SystemInfo identifies a system that is currently down.
-type SystemInfo struct {
-	ID   string `json:"id" db:"id"`
-	Name string `json:"name" db:"name"`
-	Host string `json:"host" db:"host"`
-}
-
-// AlertInfo describes a currently triggered alert.
-type AlertInfo struct {
-	SystemID   string  `json:"system_id"`
-	SystemName string  `json:"system_name"`
-	AlertName  string  `json:"alert_name"`
-	Threshold  float64 `json:"threshold"`
-}
-
-// Config holds heartbeat settings read from environment variables.
-type Config struct {
-	URL      string // endpoint to ping
-	Interval int    // seconds between pings
-	Method   string // HTTP method (GET or POST, default POST)
-}
-
-// Heartbeat manages the periodic outbound health check.
-type Heartbeat struct {
-	app    core.App
-	config Config
-	client *http.Client
-}
-
-// New creates a Heartbeat if configuration is present.
-// Returns nil if HEARTBEAT_URL is not set (feature disabled).
-func New(app core.App, getEnv func(string) (string, bool)) *Heartbeat {
-	url, _ := getEnv("HEARTBEAT_URL")
-	url = strings.TrimSpace(url)
-	if app == nil || url == "" {
-		return nil
-	}
-
-	interval := defaultInterval
-	if v, ok := getEnv("HEARTBEAT_INTERVAL"); ok {
-		if parsed, err := strconv.Atoi(v); err == nil && parsed > 0 {
-			interval = parsed
-		}
-	}
-
-	method := http.MethodPost
-	if v, ok := getEnv("HEARTBEAT_METHOD"); ok {
-		v = strings.ToUpper(strings.TrimSpace(v))
-		if v == http.MethodGet || v == http.MethodHead {
-			method = v
-		}
-	}
-
-	return &Heartbeat{
-		app: app,
-		config: Config{
-			URL:      url,
-			Interval: interval,
-			Method:   method,
-		},
-		client: &http.Client{Timeout: httpTimeout},
-	}
-}
-
-// Start begins the heartbeat loop. It blocks and should be called in a goroutine.
-// The loop runs until the provided stop channel is closed.
-func (hb *Heartbeat) Start(stop <-chan struct{}) {
-	sanitizedURL := sanitizeHeartbeatURL(hb.config.URL)
-	hb.app.Logger().Info("Heartbeat enabled",
-		"url", sanitizedURL,
-		"interval", fmt.Sprintf("%ds", hb.config.Interval),
-		"method", hb.config.Method,
-	)
-
-	// Send an initial heartbeat immediately on startup.
-	hb.send()
-
-	ticker := time.NewTicker(time.Duration(hb.config.Interval) * time.Second)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-stop:
-			return
-		case <-ticker.C:
-			hb.send()
-		}
-	}
-}
-
-// Send performs a single heartbeat ping. Exposed for the test-heartbeat API endpoint.
-func (hb *Heartbeat) Send() error {
-	return hb.send()
-}
-
-// GetConfig returns the current heartbeat configuration.
-func (hb *Heartbeat) GetConfig() Config {
-	return hb.config
-}
-
-func (hb *Heartbeat) send() error {
-	var req *http.Request
-	var err error
-	method := normalizeMethod(hb.config.Method)
-
-	if method == http.MethodGet || method == http.MethodHead {
-		req, err = http.NewRequest(method, hb.config.URL, nil)
-	} else {
-		payload, payloadErr := hb.buildPayload()
-		if payloadErr != nil {
-			hb.app.Logger().Error("Heartbeat: failed to build payload", "err", payloadErr)
-			return payloadErr
-		}
-
-		body, jsonErr := json.Marshal(payload)
-		if jsonErr != nil {
-			hb.app.Logger().Error("Heartbeat: failed to marshal payload", "err", jsonErr)
-			return jsonErr
-		}
-		req, err = http.NewRequest(http.MethodPost, hb.config.URL, bytes.NewReader(body))
-		if err == nil {
-			req.Header.Set("Content-Type", "application/json")
-		}
-	}
-
-	if err != nil {
-		hb.app.Logger().Error("Heartbeat: failed to create request", "err", err)
-		return err
-	}
-
-	req.Header.Set("User-Agent", "Beszel-Heartbeat")
-
-	resp, err := hb.client.Do(req)
-	if err != nil {
-		hb.app.Logger().Error("Heartbeat: request failed", "url", sanitizeHeartbeatURL(hb.config.URL), "err", err)
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode >= 400 {
-		hb.app.Logger().Warn("Heartbeat: non-success response",
-			"url", sanitizeHeartbeatURL(hb.config.URL),
-			"status", resp.StatusCode,
-		)
-		return fmt.Errorf("heartbeat endpoint returned status %d", resp.StatusCode)
-	}
-
-	return nil
-}
-
-func (hb *Heartbeat) buildPayload() (*Payload, error) {
-	db := hb.app.DB()
-
-	// Count systems by status.
-	var systemCounts []struct {
-		Status string `db:"status"`
-		Count  int    `db:"cnt"`
-	}
-	err := db.NewQuery("SELECT status, COUNT(*) as cnt FROM systems GROUP BY status").All(&systemCounts)
-	if err != nil {
-		return nil, fmt.Errorf("query system counts: %w", err)
-	}
-
-	summary := SystemsSummary{}
-	for _, sc := range systemCounts {
-		switch sc.Status {
-		case "up":
-			summary.Up = sc.Count
-		case "down":
-			summary.Down = sc.Count
-		case "paused":
-			summary.Paused = sc.Count
-		case "pending":
-			summary.Pending = sc.Count
-		}
-		summary.Total += sc.Count
-	}
-
-	// Get names of down systems.
-	var downSystems []SystemInfo
-	if summary.Down > 0 {
-		err = db.NewQuery("SELECT id, name, host FROM systems WHERE status = 'down'").All(&downSystems)
-		if err != nil {
-			return nil, fmt.Errorf("query down systems: %w", err)
-		}
-	}
-
-	// Get triggered alerts with system names.
-	var triggeredAlerts []struct {
-		SystemID   string  `db:"system"`
-		SystemName string  `db:"system_name"`
-		AlertName  string  `db:"name"`
-		Value      float64 `db:"value"`
-	}
-	err = db.NewQuery(`
-		SELECT a.system, s.name as system_name, a.name, a.value
-		FROM alerts a
-		JOIN systems s ON a.system = s.id
-		WHERE a.triggered = true
-	`).All(&triggeredAlerts)
-	if err != nil {
-		// Non-fatal: alerts info is supplementary.
-		triggeredAlerts = nil
-	}
-
-	alerts := make([]AlertInfo, 0, len(triggeredAlerts))
-	for _, ta := range triggeredAlerts {
-		alerts = append(alerts, AlertInfo{
-			SystemID:   ta.SystemID,
-			SystemName: ta.SystemName,
-			AlertName:  ta.AlertName,
-			Threshold:  ta.Value,
-		})
-	}
-
-	// Determine overall status.
-	status := "ok"
-	msg := "All systems operational"
-	if summary.Down > 0 {
-		status = "error"
-		names := make([]string, len(downSystems))
-		for i, ds := range downSystems {
-			names[i] = ds.Name
-		}
-		msg = fmt.Sprintf("%d system(s) down: %s", summary.Down, strings.Join(names, ", "))
-	} else if len(alerts) > 0 {
-		status = "warn"
-		msg = fmt.Sprintf("%d alert(s) triggered", len(alerts))
-	}
-
-	return &Payload{
-		Status:    status,
-		Timestamp: time.Now().UTC().Format(time.RFC3339),
-		Msg:       msg,
-		Systems:   summary,
-		Down:      downSystems,
-		Alerts:    alerts,
-		Version:   beszel.Version,
-	}, nil
-}
-
-func normalizeMethod(method string) string {
-	upper := strings.ToUpper(strings.TrimSpace(method))
-	if upper == http.MethodGet || upper == http.MethodHead || upper == http.MethodPost {
-		return upper
-	}
-	return http.MethodPost
-}
-
-func sanitizeHeartbeatURL(rawURL string) string {
-	parsed, err := url.Parse(strings.TrimSpace(rawURL))
-	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-		return "<invalid-url>"
-	}
-	return parsed.Scheme + "://" + parsed.Host
-}
--- a/internal/hub/heartbeat/heartbeat_test.go
+++ b/internal/hub/heartbeat/heartbeat_test.go
@@ -1,257 +0,0 @@
-//go:build testing
-
-package heartbeat_test
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/hub/heartbeat"
-	beszeltests "github.com/henrygd/beszel/internal/tests"
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNew(t *testing.T) {
-	t.Run("returns nil when app is missing", func(t *testing.T) {
-		hb := heartbeat.New(nil, envGetter(map[string]string{
-			"HEARTBEAT_URL": "https://heartbeat.example.com/ping",
-		}))
-		assert.Nil(t, hb)
-	})
-
-	t.Run("returns nil when URL is missing", func(t *testing.T) {
-		app := newTestHub(t)
-		hb := heartbeat.New(app.App, func(string) (string, bool) {
-			return "", false
-		})
-		assert.Nil(t, hb)
-	})
-
-	t.Run("parses and normalizes config values", func(t *testing.T) {
-		app := newTestHub(t)
-		env := map[string]string{
-			"HEARTBEAT_URL":      "  https://heartbeat.example.com/ping  ",
-			"HEARTBEAT_INTERVAL": "90",
-			"HEARTBEAT_METHOD":   "head",
-		}
-		getEnv := func(key string) (string, bool) {
-			v, ok := env[key]
-			return v, ok
-		}
-
-		hb := heartbeat.New(app.App, getEnv)
-		require.NotNil(t, hb)
-		cfg := hb.GetConfig()
-		assert.Equal(t, "https://heartbeat.example.com/ping", cfg.URL)
-		assert.Equal(t, 90, cfg.Interval)
-		assert.Equal(t, http.MethodHead, cfg.Method)
-	})
-}
-
-func TestSendGETDoesNotRequireAppOrDB(t *testing.T) {
-	app := newTestHub(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, http.MethodGet, r.Method)
-		assert.Equal(t, "Beszel-Heartbeat", r.Header.Get("User-Agent"))
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	hb := heartbeat.New(app.App, envGetter(map[string]string{
-		"HEARTBEAT_URL":    server.URL,
-		"HEARTBEAT_METHOD": "GET",
-	}))
-	require.NotNil(t, hb)
-
-	require.NoError(t, hb.Send())
-}
-
-func TestSendReturnsErrorOnHTTPFailureStatus(t *testing.T) {
-	app := newTestHub(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	hb := heartbeat.New(app.App, envGetter(map[string]string{
-		"HEARTBEAT_URL":    server.URL,
-		"HEARTBEAT_METHOD": "GET",
-	}))
-	require.NotNil(t, hb)
-
-	err := hb.Send()
-	require.Error(t, err)
-	assert.ErrorContains(t, err, "heartbeat endpoint returned status 500")
-}
-
-func TestSendPOSTBuildsExpectedStatuses(t *testing.T) {
-	tests := []struct {
-		name           string
-		setup          func(t *testing.T, app *beszeltests.TestHub, user *core.Record)
-		expectStatus   string
-		expectMsgPart  string
-		expectDown     int
-		expectAlerts   int
-		expectTotal    int
-		expectUp       int
-		expectPaused   int
-		expectPending  int
-		expectDownSumm int
-	}{
-		{
-			name: "error when at least one system is down",
-			setup: func(t *testing.T, app *beszeltests.TestHub, user *core.Record) {
-				downSystem := createTestSystem(t, app, user.Id, "db-1", "10.0.0.1", "down")
-				_ = createTestSystem(t, app, user.Id, "web-1", "10.0.0.2", "up")
-				createTriggeredAlert(t, app, user.Id, downSystem.Id, "CPU", 95)
-			},
-			expectStatus:   "error",
-			expectMsgPart:  "1 system(s) down",
-			expectDown:     1,
-			expectAlerts:   1,
-			expectTotal:    2,
-			expectUp:       1,
-			expectDownSumm: 1,
-		},
-		{
-			name: "warn when only alerts are triggered",
-			setup: func(t *testing.T, app *beszeltests.TestHub, user *core.Record) {
-				system := createTestSystem(t, app, user.Id, "api-1", "10.1.0.1", "up")
-				createTriggeredAlert(t, app, user.Id, system.Id, "CPU", 90)
-			},
-			expectStatus:   "warn",
-			expectMsgPart:  "1 alert(s) triggered",
-			expectDown:     0,
-			expectAlerts:   1,
-			expectTotal:    1,
-			expectUp:       1,
-			expectDownSumm: 0,
-		},
-		{
-			name: "ok when no down systems and no alerts",
-			setup: func(t *testing.T, app *beszeltests.TestHub, user *core.Record) {
-				_ = createTestSystem(t, app, user.Id, "node-1", "10.2.0.1", "up")
-				_ = createTestSystem(t, app, user.Id, "node-2", "10.2.0.2", "paused")
-				_ = createTestSystem(t, app, user.Id, "node-3", "10.2.0.3", "pending")
-			},
-			expectStatus:   "ok",
-			expectMsgPart:  "All systems operational",
-			expectDown:     0,
-			expectAlerts:   0,
-			expectTotal:    3,
-			expectUp:       1,
-			expectPaused:   1,
-			expectPending:  1,
-			expectDownSumm: 0,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			app := newTestHub(t)
-			user := createTestUser(t, app)
-			tt.setup(t, app, user)
-
-			type requestCapture struct {
-				method      string
-				userAgent   string
-				contentType string
-				payload     heartbeat.Payload
-			}
-
-			captured := make(chan requestCapture, 1)
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				defer r.Body.Close()
-				body, err := io.ReadAll(r.Body)
-				require.NoError(t, err)
-
-				var payload heartbeat.Payload
-				require.NoError(t, json.Unmarshal(body, &payload))
-				captured <- requestCapture{
-					method:      r.Method,
-					userAgent:   r.Header.Get("User-Agent"),
-					contentType: r.Header.Get("Content-Type"),
-					payload:     payload,
-				}
-				w.WriteHeader(http.StatusNoContent)
-			}))
-			defer server.Close()
-
-			hb := heartbeat.New(app.App, envGetter(map[string]string{
-				"HEARTBEAT_URL":    server.URL,
-				"HEARTBEAT_METHOD": "POST",
-			}))
-			require.NotNil(t, hb)
-			require.NoError(t, hb.Send())
-
-			req := <-captured
-			assert.Equal(t, http.MethodPost, req.method)
-			assert.Equal(t, "Beszel-Heartbeat", req.userAgent)
-			assert.Equal(t, "application/json", req.contentType)
-
-			assert.Equal(t, tt.expectStatus, req.payload.Status)
-			assert.Contains(t, req.payload.Msg, tt.expectMsgPart)
-			assert.Equal(t, tt.expectDown, len(req.payload.Down))
-			assert.Equal(t, tt.expectAlerts, len(req.payload.Alerts))
-			assert.Equal(t, tt.expectTotal, req.payload.Systems.Total)
-			assert.Equal(t, tt.expectUp, req.payload.Systems.Up)
-			assert.Equal(t, tt.expectDownSumm, req.payload.Systems.Down)
-			assert.Equal(t, tt.expectPaused, req.payload.Systems.Paused)
-			assert.Equal(t, tt.expectPending, req.payload.Systems.Pending)
-		})
-	}
-}
-
-func newTestHub(t *testing.T) *beszeltests.TestHub {
-	t.Helper()
-	app, err := beszeltests.NewTestHub(t.TempDir())
-	require.NoError(t, err)
-	t.Cleanup(app.Cleanup)
-	return app
-}
-
-func createTestUser(t *testing.T, app *beszeltests.TestHub) *core.Record {
-	t.Helper()
-	user, err := beszeltests.CreateUser(app.App, "admin@example.com", "password123")
-	require.NoError(t, err)
-	return user
-}
-
-func createTestSystem(t *testing.T, app *beszeltests.TestHub, userID, name, host, status string) *core.Record {
-	t.Helper()
-	system, err := beszeltests.CreateRecord(app.App, "systems", map[string]any{
-		"name":   name,
-		"host":   host,
-		"port":   "45876",
-		"users":  []string{userID},
-		"status": status,
-	})
-	require.NoError(t, err)
-	return system
-}
-
-func createTriggeredAlert(t *testing.T, app *beszeltests.TestHub, userID, systemID, name string, threshold float64) *core.Record {
-	t.Helper()
-	alert, err := beszeltests.CreateRecord(app.App, "alerts", map[string]any{
-		"name":      name,
-		"system":    systemID,
-		"user":      userID,
-		"value":     threshold,
-		"min":       0,
-		"triggered": true,
-	})
-	require.NoError(t, err)
-	return alert
-}
-
-func envGetter(values map[string]string) func(string) (string, bool) {
-	return func(key string) (string, bool) {
-		v, ok := values[key]
-		return v, ok
-	}
-}
--- a/internal/hub/hub.go
+++ b/internal/hub/hub.go
@@ -9,20 +9,17 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"regexp"
 	"strings"
 	"time"

 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/internal/alerts"
 	"github.com/henrygd/beszel/internal/hub/config"
-	"github.com/henrygd/beszel/internal/hub/heartbeat"
 	"github.com/henrygd/beszel/internal/hub/systems"
 	"github.com/henrygd/beszel/internal/records"
 	"github.com/henrygd/beszel/internal/users"

 	"github.com/google/uuid"
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
@@ -35,15 +32,11 @@ type Hub struct {
 	um     *users.UserManager
 	rm     *records.RecordManager
 	sm     *systems.SystemManager
-	hb     *heartbeat.Heartbeat
-	hbStop chan struct{}
 	pubKey string
 	signer ssh.Signer
 	appURL string
 }

-var containerIDPattern = regexp.MustCompile(`^[a-fA-F0-9]{12,64}$`)
-
 // NewHub creates a new Hub instance with default configuration
 func NewHub(app core.App) *Hub {
 	hub := &Hub{}
@@ -54,10 +47,6 @@ func NewHub(app core.App) *Hub {
 	hub.rm = records.NewRecordManager(hub)
 	hub.sm = systems.NewSystemManager(hub)
 	hub.appURL, _ = GetEnv("APP_URL")
-	hub.hb = heartbeat.New(app, GetEnv)
-	if hub.hb != nil {
-		hub.hbStop = make(chan struct{})
-	}
 	return hub
 }

@@ -98,10 +87,6 @@ func (h *Hub) StartHub() error {
 		if err := h.sm.Initialize(); err != nil {
 			return err
 		}
-		// start heartbeat if configured
-		if h.hb != nil {
-			go h.hb.Start(h.hbStop)
-		}
 		return e.Next()
 	})

@@ -208,34 +193,7 @@ func setCollectionAuthSettings(app core.App) error {
 	}
 	containersListRule := strings.Replace(systemsReadRule, "users.id", "system.users.id", 1)
 	containersCollection.ListRule = &containersListRule
-	if err := app.Save(containersCollection); err != nil {
-		return err
-	}
-
-	// allow all users to access system-related collections if SHARE_ALL_SYSTEMS is set
-	// these collections all have a "system" relation field
-	systemRelatedCollections := []string{"system_details", "smart_devices", "systemd_services"}
-	for _, collectionName := range systemRelatedCollections {
-		collection, err := app.FindCollectionByNameOrId(collectionName)
-		if err != nil {
-			return err
-		}
-		collection.ListRule = &containersListRule
-		// set viewRule for collections that need it (system_details, smart_devices)
-		if collection.ViewRule != nil {
-			collection.ViewRule = &containersListRule
-		}
-		// set deleteRule for smart_devices (allows user to dismiss disk warnings)
-		if collectionName == "smart_devices" {
-			deleteRule := containersListRule + " && @request.auth.role != \"readonly\""
-			collection.DeleteRule = &deleteRule
-		}
-		if err := app.Save(collection); err != nil {
-			return err
-		}
-	}
-
-	return nil
+	return app.Save(containersCollection)
 }

 // registerCronJobs sets up scheduled tasks
@@ -301,9 +259,6 @@ func (h *Hub) registerApiRoutes(se *core.ServeEvent) error {
 	})
 	// send test notification
 	apiAuth.POST("/test-notification", h.SendTestNotification)
-	// heartbeat status and test
-	apiAuth.GET("/heartbeat-status", h.getHeartbeatStatus)
-	apiAuth.POST("/test-heartbeat", h.testHeartbeat)
 	// get config.yml content
 	apiAuth.GET("/config-yaml", config.GetYamlConfig)
 	// handle agent websocket connection
@@ -313,8 +268,8 @@ func (h *Hub) registerApiRoutes(se *core.ServeEvent) error {
 	// update / delete user alerts
 	apiAuth.POST("/user-alerts", alerts.UpsertUserAlerts)
 	apiAuth.DELETE("/user-alerts", alerts.DeleteUserAlerts)
-	// refresh SMART devices for a system
-	apiAuth.POST("/smart/refresh", h.refreshSmartData)
+	// get SMART data
+	apiAuth.GET("/smart", h.getSmartData)
 	// get systemd service details
 	apiAuth.GET("/systemd/info", h.getSystemdInfo)
 	// /containers routes
@@ -333,129 +288,27 @@ func (h *Hub) getUniversalToken(e *core.RequestEvent) error {
 	userID := e.Auth.Id
 	query := e.Request.URL.Query()
 	token := query.Get("token")
-	enable := query.Get("enable")
-	permanent := query.Get("permanent")

-	// helper for deleting any existing permanent token record for this user
-	deletePermanent := func() error {
-		rec, err := h.FindFirstRecordByFilter("universal_tokens", "user = {:user}", dbx.Params{"user": userID})
-		if err != nil {
-			return nil // no record
-		}
-		return h.Delete(rec)
-	}
-
-	// helper for upserting a permanent token record for this user
-	upsertPermanent := func(token string) error {
-		rec, err := h.FindFirstRecordByFilter("universal_tokens", "user = {:user}", dbx.Params{"user": userID})
-		if err == nil {
-			rec.Set("token", token)
-			return h.Save(rec)
-		}
-
-		col, err := h.FindCachedCollectionByNameOrId("universal_tokens")
-		if err != nil {
-			return err
-		}
-		newRec := core.NewRecord(col)
-		newRec.Set("user", userID)
-		newRec.Set("token", token)
-		return h.Save(newRec)
-	}
-
-	// Disable universal tokens (both ephemeral and permanent)
-	if enable == "0" {
-		tokenMap.RemovebyValue(userID)
-		_ = deletePermanent()
-		return e.JSON(http.StatusOK, map[string]any{"token": token, "active": false, "permanent": false})
-	}
-
-	// Enable universal token (ephemeral or permanent)
-	if enable == "1" {
-		if token == "" {
-			token = uuid.New().String()
-		}
-
-		if permanent == "1" {
-			// make token permanent (persist across restarts)
-			tokenMap.RemovebyValue(userID)
-			if err := upsertPermanent(token); err != nil {
-				return err
-			}
-			return e.JSON(http.StatusOK, map[string]any{"token": token, "active": true, "permanent": true})
-		}
-
-		// default: ephemeral mode (1 hour)
-		_ = deletePermanent()
-		tokenMap.Set(token, userID, time.Hour)
-		return e.JSON(http.StatusOK, map[string]any{"token": token, "active": true, "permanent": false})
-	}
-
-	// Read current state
-	// Prefer permanent token if it exists.
-	if rec, err := h.FindFirstRecordByFilter("universal_tokens", "user = {:user}", dbx.Params{"user": userID}); err == nil {
-		dbToken := rec.GetString("token")
-		// If no token was provided, or the caller is asking about their permanent token, return it.
-		if token == "" || token == dbToken {
-			return e.JSON(http.StatusOK, map[string]any{"token": dbToken, "active": true, "permanent": true})
-		}
-		// Token doesn't match their permanent token (avoid leaking other info)
-		return e.JSON(http.StatusOK, map[string]any{"token": token, "active": false, "permanent": false})
-	}
-
-	// No permanent token; fall back to ephemeral token map.
 	if token == "" {
 		// return existing token if it exists
 		if token, _, ok := tokenMap.GetByValue(userID); ok {
-			return e.JSON(http.StatusOK, map[string]any{"token": token, "active": true, "permanent": false})
+			return e.JSON(http.StatusOK, map[string]any{"token": token, "active": true})
 		}
 		// if no token is provided, generate a new one
 		token = uuid.New().String()
 	}
+	response := map[string]any{"token": token}

-	// Token is considered active only if it belongs to the current user.
-	activeUser, ok := tokenMap.GetOk(token)
-	active := ok && activeUser == userID
-	response := map[string]any{"token": token, "active": active, "permanent": false}
+	switch query.Get("enable") {
+	case "1":
+		tokenMap.Set(token, userID, time.Hour)
+	case "0":
+		tokenMap.RemovebyValue(userID)
+	}
+	_, response["active"] = tokenMap.GetOk(token)
 	return e.JSON(http.StatusOK, response)
 }

-// getHeartbeatStatus returns current heartbeat configuration and whether it's enabled
-func (h *Hub) getHeartbeatStatus(e *core.RequestEvent) error {
-	if e.Auth.GetString("role") != "admin" {
-		return e.ForbiddenError("Requires admin role", nil)
-	}
-	if h.hb == nil {
-		return e.JSON(http.StatusOK, map[string]any{
-			"enabled": false,
-			"msg":     "Set HEARTBEAT_URL to enable outbound heartbeat monitoring",
-		})
-	}
-	cfg := h.hb.GetConfig()
-	return e.JSON(http.StatusOK, map[string]any{
-		"enabled":  true,
-		"url":      cfg.URL,
-		"interval": cfg.Interval,
-		"method":   cfg.Method,
-	})
-}
-
-// testHeartbeat triggers a single heartbeat ping and returns the result
-func (h *Hub) testHeartbeat(e *core.RequestEvent) error {
-	if e.Auth.GetString("role") != "admin" {
-		return e.ForbiddenError("Requires admin role", nil)
-	}
-	if h.hb == nil {
-		return e.JSON(http.StatusOK, map[string]any{
-			"err": "Heartbeat not configured. Set HEARTBEAT_URL environment variable.",
-		})
-	}
-	if err := h.hb.Send(); err != nil {
-		return e.JSON(http.StatusOK, map[string]any{"err": err.Error()})
-	}
-	return e.JSON(http.StatusOK, map[string]any{"err": false})
-}
-
 // containerRequestHandler handles both container logs and info requests
 func (h *Hub) containerRequestHandler(e *core.RequestEvent, fetchFunc func(*systems.System, string) (string, error), responseKey string) error {
 	systemID := e.Request.URL.Query().Get("system")
@@ -464,9 +317,6 @@ func (h *Hub) containerRequestHandler(e *core.RequestEvent, fetchFunc func(*syst
 	if systemID == "" || containerID == "" {
 		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system and container parameters are required"})
 	}
-	if !containerIDPattern.MatchString(containerID) {
-		return e.JSON(http.StatusBadRequest, map[string]string{"error": "invalid container parameter"})
-	}

 	system, err := h.sm.GetSystem(systemID)
 	if err != nil {
@@ -515,25 +365,22 @@ func (h *Hub) getSystemdInfo(e *core.RequestEvent) error {
 	return e.JSON(http.StatusOK, map[string]any{"details": details})
 }

-// refreshSmartData handles POST /api/beszel/smart/refresh requests
-// Fetches fresh SMART data from the agent and updates the collection
-func (h *Hub) refreshSmartData(e *core.RequestEvent) error {
+// getSmartData handles GET /api/beszel/smart requests
+func (h *Hub) getSmartData(e *core.RequestEvent) error {
 	systemID := e.Request.URL.Query().Get("system")
 	if systemID == "" {
 		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system parameter is required"})
 	}
-
 	system, err := h.sm.GetSystem(systemID)
 	if err != nil {
 		return e.JSON(http.StatusNotFound, map[string]string{"error": "system not found"})
 	}
-
-	// Fetch and save SMART devices
-	if err := system.FetchAndSaveSmartDevices(); err != nil {
-		return e.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	data, err := system.FetchSmartDataFromAgent()
+	if err != nil {
+		return e.JSON(http.StatusNotFound, map[string]string{"error": err.Error()})
 	}
-
-	return e.JSON(http.StatusOK, map[string]string{"status": "ok"})
+	e.Response.Header().Set("Cache-Control", "public, max-age=60")
+	return e.JSON(http.StatusOK, data)
 }

 // generates key pair if it doesn't exist and returns signer
--- a/internal/hub/hub_test.go
+++ b/internal/hub/hub_test.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package hub_test

@@ -361,58 +362,6 @@ func TestApiRoutesAuthentication(t *testing.T) {
 			ExpectedContent: []string{"test-system"},
 			TestAppFactory:  testAppFactory,
 		},
-		{
-			Name:            "GET /heartbeat-status - no auth should fail",
-			Method:          http.MethodGet,
-			URL:             "/api/beszel/heartbeat-status",
-			ExpectedStatus:  401,
-			ExpectedContent: []string{"requires valid"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /heartbeat-status - with user auth should fail",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/heartbeat-status",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  403,
-			ExpectedContent: []string{"Requires admin role"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /heartbeat-status - with admin auth should succeed",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/heartbeat-status",
-			Headers: map[string]string{
-				"Authorization": adminUserToken,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{`"enabled":false`},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "POST /test-heartbeat - with user auth should fail",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/test-heartbeat",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  403,
-			ExpectedContent: []string{"Requires admin role"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "POST /test-heartbeat - with admin auth should report disabled state",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/test-heartbeat",
-			Headers: map[string]string{
-				"Authorization": adminUserToken,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"Heartbeat not configured"},
-			TestAppFactory:  testAppFactory,
-		},
 		{
 			Name:            "GET /universal-token - no auth should fail",
 			Method:          http.MethodGet,
@@ -429,18 +378,7 @@ func TestApiRoutesAuthentication(t *testing.T) {
 				"Authorization": userToken,
 			},
 			ExpectedStatus:  200,
-			ExpectedContent: []string{"active", "token", "permanent"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /universal-token - enable permanent should succeed",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/universal-token?enable=1&permanent=1&token=permanent-token-123",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"permanent\":true", "permanent-token-123"},
+			ExpectedContent: []string{"active", "token"},
 			TestAppFactory:  testAppFactory,
 		},
 		{
@@ -544,7 +482,7 @@ func TestApiRoutesAuthentication(t *testing.T) {
 		{
 			Name:   "GET /containers/logs - with auth but invalid system should fail",
 			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/logs?system=invalid-system&container=0123456789ab",
+			URL:    "/api/beszel/containers/logs?system=invalid-system&container=test-container",
 			Headers: map[string]string{
 				"Authorization": userToken,
 			},
@@ -552,39 +490,6 @@ func TestApiRoutesAuthentication(t *testing.T) {
 			ExpectedContent: []string{"system not found"},
 			TestAppFactory:  testAppFactory,
 		},
-		{
-			Name:   "GET /containers/logs - traversal container should fail validation",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/logs?system=" + system.Id + "&container=..%2F..%2Fversion",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"invalid container parameter"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /containers/info - traversal container should fail validation",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/info?system=" + system.Id + "&container=../../version?x=",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"invalid container parameter"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /containers/info - non-hex container should fail validation",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/info?system=" + system.Id + "&container=container_name",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"invalid container parameter"},
-			TestAppFactory:  testAppFactory,
-		},

 		// Auth Optional Routes - Should work without authentication
 		{
--- a/internal/hub/hub_test_helpers.go
+++ b/internal/hub/hub_test_helpers.go
@@ -1,4 +1,5 @@
 //go:build testing
+// +build testing

 package hub

--- a/internal/hub/systems/system.go
+++ b/internal/hub/systems/system.go
@@ -9,15 +9,12 @@ import (
 	"math/rand"
 	"net"
 	"strings"
-	"sync/atomic"
 	"time"

 	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/hub/transport"
 	"github.com/henrygd/beszel/internal/hub/ws"

 	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/smart"
 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/henrygd/beszel/internal/entities/systemd"

@@ -25,30 +22,24 @@ import (

 	"github.com/blang/semver"
 	"github.com/fxamacker/cbor/v2"
-	"github.com/lxzan/gws"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"golang.org/x/crypto/ssh"
 )

 type System struct {
-	Id             string                  `db:"id"`
-	Host           string                  `db:"host"`
-	Port           string                  `db:"port"`
-	Status         string                  `db:"status"`
-	manager        *SystemManager          // Manager that this system belongs to
-	client         *ssh.Client             // SSH client for fetching data
-	sshTransport   *transport.SSHTransport // SSH transport for requests
-	data           *system.CombinedData    // system data from agent
-	ctx            context.Context         // Context for stopping the updater
-	cancel         context.CancelFunc      // Stops and removes system from updater
-	WsConn         *ws.WsConn              // Handler for agent WebSocket connection
-	agentVersion   semver.Version          // Agent version
-	updateTicker   *time.Ticker            // Ticker for updating the system
-	detailsFetched atomic.Bool             // True if static system details have been fetched and saved
-	smartFetching  atomic.Bool             // True if SMART devices are currently being fetched
-	smartInterval  time.Duration           // Interval for periodic SMART data updates
-	lastSmartFetch atomic.Int64            // Unix milliseconds of last SMART data fetch
+	Id           string               `db:"id"`
+	Host         string               `db:"host"`
+	Port         string               `db:"port"`
+	Status       string               `db:"status"`
+	manager      *SystemManager       // Manager that this system belongs to
+	client       *ssh.Client          // SSH client for fetching data
+	data         *system.CombinedData // system data from agent
+	ctx          context.Context      // Context for stopping the updater
+	cancel       context.CancelFunc   // Stops and removes system from updater
+	WsConn       *ws.WsConn           // Handler for agent WebSocket connection
+	agentVersion semver.Version       // Agent version
+	updateTicker *time.Ticker         // Ticker for updating the system
 }

 func (sm *SystemManager) NewSystem(systemId string) *System {
@@ -121,37 +112,10 @@ func (sys *System) update() error {
 		sys.handlePaused()
 		return nil
 	}
-	options := common.DataRequestOptions{
-		CacheTimeMs: uint16(interval),
+	data, err := sys.fetchDataFromAgent(common.DataRequestOptions{CacheTimeMs: uint16(interval)})
+	if err == nil {
+		_, err = sys.createRecords(data)
 	}
-	// fetch system details if not already fetched
-	if !sys.detailsFetched.Load() {
-		options.IncludeDetails = true
-	}
-
-	data, err := sys.fetchDataFromAgent(options)
-	if err != nil {
-		return err
-	}
-
-	// create system records
-	_, err = sys.createRecords(data)
-
-	// Fetch and save SMART devices when system first comes online or at intervals
-	if backgroundSmartFetchEnabled() {
-		if sys.smartInterval <= 0 {
-			sys.smartInterval = time.Hour
-		}
-		lastFetch := sys.lastSmartFetch.Load()
-		if time.Since(time.UnixMilli(lastFetch)) >= sys.smartInterval && sys.smartFetching.CompareAndSwap(false, true) {
-			go func() {
-				defer sys.smartFetching.Store(false)
-				sys.lastSmartFetch.Store(time.Now().UnixMilli())
-				_ = sys.FetchAndSaveSmartDevices()
-			}()
-		}
-	}
-
 	return err
 }

@@ -176,11 +140,12 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 	}
 	hub := sys.manager.hub
 	err = hub.RunInTransaction(func(txApp core.App) error {
-		// add system_stats record
+		// add system_stats and container_stats records
 		systemStatsCollection, err := txApp.FindCachedCollectionByNameOrId("system_stats")
 		if err != nil {
 			return err
 		}
+
 		systemStatsRecord := core.NewRecord(systemStatsCollection)
 		systemStatsRecord.Set("system", systemRecord.Id)
 		systemStatsRecord.Set("stats", data.Stats)
@@ -188,14 +153,14 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 		if err := txApp.SaveNoValidate(systemStatsRecord); err != nil {
 			return err
 		}
-
-		// add containers and container_stats records
 		if len(data.Containers) > 0 {
+			// add / update containers records
 			if data.Containers[0].Id != "" {
 				if err := createContainerRecords(txApp, data.Containers, sys.Id); err != nil {
 					return err
 				}
 			}
+			// add new container_stats record
 			containerStatsCollection, err := txApp.FindCachedCollectionByNameOrId("container_stats")
 			if err != nil {
 				return err
@@ -216,20 +181,9 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 			}
 		}

-		// add system details record
-		if data.Details != nil {
-			if err := createSystemDetailsRecord(txApp, data.Details, sys.Id); err != nil {
-				return err
-			}
-			sys.detailsFetched.Store(true)
-			// update smart interval if it's set on the agent side
-			if data.Details.SmartInterval > 0 {
-				sys.smartInterval = data.Details.SmartInterval
-			}
-		}
-
 		// update system record (do this last because it triggers alerts and we need above records to be inserted first)
 		systemRecord.Set("status", up)
+
 		systemRecord.Set("info", data.Info)
 		if err := txApp.SaveNoValidate(systemRecord); err != nil {
 			return err
@@ -240,31 +194,6 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 	return systemRecord, err
 }

-func createSystemDetailsRecord(app core.App, data *system.Details, systemId string) error {
-	collectionName := "system_details"
-	params := dbx.Params{
-		"id":       systemId,
-		"system":   systemId,
-		"hostname": data.Hostname,
-		"kernel":   data.Kernel,
-		"cores":    data.Cores,
-		"threads":  data.Threads,
-		"cpu":      data.CpuModel,
-		"os":       data.Os,
-		"os_name":  data.OsName,
-		"arch":     data.Arch,
-		"memory":   data.MemoryTotal,
-		"podman":   data.Podman,
-		"updated":  time.Now().UTC(),
-	}
-	result, err := app.DB().Update(collectionName, params, dbx.HashExp{"id": systemId}).Execute()
-	rowsAffected, _ := result.RowsAffected()
-	if err != nil || rowsAffected == 0 {
-		_, err = app.DB().Insert(collectionName, params).Execute()
-	}
-	return err
-}
-
 func createSystemdStatsRecords(app core.App, data []*systemd.Service, systemId string) error {
 	if len(data) == 0 {
 		return nil
@@ -279,7 +208,7 @@ func createSystemdStatsRecords(app core.App, data []*systemd.Service, systemId s
 	for i, service := range data {
 		suffix := fmt.Sprintf("%d", i)
 		valueStrings = append(valueStrings, fmt.Sprintf("({:id%[1]s}, {:system}, {:name%[1]s}, {:state%[1]s}, {:sub%[1]s}, {:cpu%[1]s}, {:cpuPeak%[1]s}, {:memory%[1]s}, {:memPeak%[1]s}, {:updated})", suffix))
-		params["id"+suffix] = makeStableHashId(systemId, service.Name)
+		params["id"+suffix] = getSystemdServiceId(systemId, service.Name)
 		params["name"+suffix] = service.Name
 		params["state"+suffix] = service.State
 		params["sub"+suffix] = service.Sub
@@ -296,6 +225,13 @@ func createSystemdStatsRecords(app core.App, data []*systemd.Service, systemId s
 	return err
 }

+// getSystemdServiceId generates a deterministic unique id for a systemd service
+func getSystemdServiceId(systemId string, serviceName string) string {
+	hash := fnv.New32a()
+	hash.Write([]byte(systemId + serviceName))
+	return fmt.Sprintf("%x", hash.Sum32())
+}
+
 // createContainerRecords creates container records
 func createContainerRecords(app core.App, data []*container.Stats, systemId string) error {
 	if len(data) == 0 {
@@ -317,11 +253,7 @@ func createContainerRecords(app core.App, data []*container.Stats, systemId stri
 		params["health"+suffix] = container.Health
 		params["cpu"+suffix] = container.Cpu
 		params["memory"+suffix] = container.Mem
-		netBytes := container.Bandwidth[0] + container.Bandwidth[1]
-		if netBytes == 0 {
-			netBytes = uint64((container.NetworkSent + container.NetworkRecv) * 1024 * 1024)
-		}
-		params["net"+suffix] = netBytes
+		params["net"+suffix] = container.NetworkSent + container.NetworkRecv
 	}
 	queryString := fmt.Sprintf(
 		"INSERT INTO containers (id, system, name, image, status, health, cpu, memory, net, updated) VALUES %s ON CONFLICT(id) DO UPDATE SET system = excluded.system, name = excluded.name, image = excluded.image, status = excluded.status, health = excluded.health, cpu = excluded.cpu, memory = excluded.memory, net = excluded.net, updated = excluded.updated",
@@ -367,78 +299,8 @@ func (sys *System) getContext() (context.Context, context.CancelFunc) {
 	return sys.ctx, sys.cancel
 }

-// request sends a request to the agent, trying WebSocket first, then SSH.
-// This is the unified request method that uses the transport abstraction.
-func (sys *System) request(ctx context.Context, action common.WebSocketAction, req any, dest any) error {
-	// Try WebSocket first
-	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		wsTransport := transport.NewWebSocketTransport(sys.WsConn)
-		if err := wsTransport.Request(ctx, action, req, dest); err == nil {
-			return nil
-		} else if !shouldFallbackToSSH(err) {
-			return err
-		} else if shouldCloseWebSocket(err) {
-			sys.closeWebSocketConnection()
-		}
-	}
-
-	// Fall back to SSH if WebSocket fails
-	if err := sys.ensureSSHTransport(); err != nil {
-		return err
-	}
-	err := sys.sshTransport.RequestWithRetry(ctx, action, req, dest, 1)
-	// Keep legacy SSH client/version fields in sync for other code paths.
-	if sys.sshTransport != nil {
-		sys.client = sys.sshTransport.GetClient()
-		sys.agentVersion = sys.sshTransport.GetAgentVersion()
-	}
-	return err
-}
-
-func shouldFallbackToSSH(err error) bool {
-	if err == nil {
-		return false
-	}
-	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
-		return true
-	}
-	if errors.Is(err, gws.ErrConnClosed) {
-		return true
-	}
-	return errors.Is(err, transport.ErrWebSocketNotConnected)
-}
-
-func shouldCloseWebSocket(err error) bool {
-	if err == nil {
-		return false
-	}
-	return errors.Is(err, gws.ErrConnClosed) || errors.Is(err, transport.ErrWebSocketNotConnected)
-}
-
-// ensureSSHTransport ensures the SSH transport is initialized and connected.
-func (sys *System) ensureSSHTransport() error {
-	if sys.sshTransport == nil {
-		if sys.manager.sshConfig == nil {
-			if err := sys.manager.createSSHClientConfig(); err != nil {
-				return err
-			}
-		}
-		sys.sshTransport = transport.NewSSHTransport(transport.SSHTransportConfig{
-			Host:    sys.Host,
-			Port:    sys.Port,
-			Config:  sys.manager.sshConfig,
-			Timeout: 4 * time.Second,
-		})
-	}
-	// Sync client state with transport
-	if sys.client != nil {
-		sys.sshTransport.SetClient(sys.client)
-		sys.sshTransport.SetAgentVersion(sys.agentVersion)
-	}
-	return nil
-}
-
-// fetchDataFromAgent attempts to fetch data from the agent, prioritizing WebSocket if available.
+// fetchDataFromAgent attempts to fetch data from the agent,
+// prioritizing WebSocket if available.
 func (sys *System) fetchDataFromAgent(options common.DataRequestOptions) (*system.CombinedData, error) {
 	if sys.data == nil {
 		sys.data = &system.CombinedData{}
@@ -464,56 +326,152 @@ func (sys *System) fetchDataViaWebSocket(options common.DataRequestOptions) (*sy
 	if sys.WsConn == nil || !sys.WsConn.IsConnected() {
 		return nil, errors.New("no websocket connection")
 	}
-	wsTransport := transport.NewWebSocketTransport(sys.WsConn)
-	err := wsTransport.Request(context.Background(), common.GetData, options, sys.data)
+	err := sys.WsConn.RequestSystemData(context.Background(), sys.data, options)
 	if err != nil {
 		return nil, err
 	}
 	return sys.data, nil
 }

+// fetchStringFromAgentViaSSH is a generic function to fetch strings via SSH
+func (sys *System) fetchStringFromAgentViaSSH(action common.WebSocketAction, requestData any, errorMsg string) (string, error) {
+	var result string
+	err := sys.runSSHOperation(4*time.Second, 1, func(session *ssh.Session) (bool, error) {
+		stdout, err := session.StdoutPipe()
+		if err != nil {
+			return false, err
+		}
+		stdin, stdinErr := session.StdinPipe()
+		if stdinErr != nil {
+			return false, stdinErr
+		}
+		if err := session.Shell(); err != nil {
+			return false, err
+		}
+		req := common.HubRequest[any]{Action: action, Data: requestData}
+		_ = cbor.NewEncoder(stdin).Encode(req)
+		_ = stdin.Close()
+		var resp common.AgentResponse
+		err = cbor.NewDecoder(stdout).Decode(&resp)
+		if err != nil {
+			return false, err
+		}
+		if resp.String == nil {
+			return false, errors.New(errorMsg)
+		}
+		result = *resp.String
+		return false, nil
+	})
+	return result, err
+}
+
 // FetchContainerInfoFromAgent fetches container info from the agent
 func (sys *System) FetchContainerInfoFromAgent(containerID string) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	var result string
-	err := sys.request(ctx, common.GetContainerInfo, common.ContainerInfoRequest{ContainerID: containerID}, &result)
-	return result, err
+	// fetch via websocket
+	if sys.WsConn != nil && sys.WsConn.IsConnected() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		return sys.WsConn.RequestContainerInfo(ctx, containerID)
+	}
+	// fetch via SSH
+	return sys.fetchStringFromAgentViaSSH(common.GetContainerInfo, common.ContainerInfoRequest{ContainerID: containerID}, "no info in response")
 }

 // FetchContainerLogsFromAgent fetches container logs from the agent
 func (sys *System) FetchContainerLogsFromAgent(containerID string) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	var result string
-	err := sys.request(ctx, common.GetContainerLogs, common.ContainerLogsRequest{ContainerID: containerID}, &result)
-	return result, err
+	// fetch via websocket
+	if sys.WsConn != nil && sys.WsConn.IsConnected() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		return sys.WsConn.RequestContainerLogs(ctx, containerID)
+	}
+	// fetch via SSH
+	return sys.fetchStringFromAgentViaSSH(common.GetContainerLogs, common.ContainerLogsRequest{ContainerID: containerID}, "no logs in response")
 }

 // FetchSystemdInfoFromAgent fetches detailed systemd service information from the agent
 func (sys *System) FetchSystemdInfoFromAgent(serviceName string) (systemd.ServiceDetails, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
+	// fetch via websocket
+	if sys.WsConn != nil && sys.WsConn.IsConnected() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		return sys.WsConn.RequestSystemdInfo(ctx, serviceName)
+	}
+
 	var result systemd.ServiceDetails
-	err := sys.request(ctx, common.GetSystemdInfo, common.SystemdInfoRequest{ServiceName: serviceName}, &result)
+	err := sys.runSSHOperation(5*time.Second, 1, func(session *ssh.Session) (bool, error) {
+		stdout, err := session.StdoutPipe()
+		if err != nil {
+			return false, err
+		}
+		stdin, stdinErr := session.StdinPipe()
+		if stdinErr != nil {
+			return false, stdinErr
+		}
+		if err := session.Shell(); err != nil {
+			return false, err
+		}
+
+		req := common.HubRequest[any]{Action: common.GetSystemdInfo, Data: common.SystemdInfoRequest{ServiceName: serviceName}}
+		if err := cbor.NewEncoder(stdin).Encode(req); err != nil {
+			return false, err
+		}
+		_ = stdin.Close()
+
+		var resp common.AgentResponse
+		if err := cbor.NewDecoder(stdout).Decode(&resp); err != nil {
+			return false, err
+		}
+		if resp.ServiceInfo == nil {
+			if resp.Error != "" {
+				return false, errors.New(resp.Error)
+			}
+			return false, errors.New("no systemd info in response")
+		}
+		result = resp.ServiceInfo
+		return false, nil
+	})
+
 	return result, err
 }

 // FetchSmartDataFromAgent fetches SMART data from the agent
-func (sys *System) FetchSmartDataFromAgent() (map[string]smart.SmartData, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-	var result map[string]smart.SmartData
-	err := sys.request(ctx, common.GetSmartData, nil, &result)
-	return result, err
-}
-
-func makeStableHashId(strings ...string) string {
-	hash := fnv.New32a()
-	for _, str := range strings {
-		hash.Write([]byte(str))
+func (sys *System) FetchSmartDataFromAgent() (map[string]any, error) {
+	// fetch via websocket
+	if sys.WsConn != nil && sys.WsConn.IsConnected() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		return sys.WsConn.RequestSmartData(ctx)
 	}
-	return fmt.Sprintf("%x", hash.Sum32())
+	// fetch via SSH
+	var result map[string]any
+	err := sys.runSSHOperation(5*time.Second, 1, func(session *ssh.Session) (bool, error) {
+		stdout, err := session.StdoutPipe()
+		if err != nil {
+			return false, err
+		}
+		stdin, stdinErr := session.StdinPipe()
+		if stdinErr != nil {
+			return false, stdinErr
+		}
+		if err := session.Shell(); err != nil {
+			return false, err
+		}
+		req := common.HubRequest[any]{Action: common.GetSmartData}
+		_ = cbor.NewEncoder(stdin).Encode(req)
+		_ = stdin.Close()
+		var resp common.AgentResponse
+		if err := cbor.NewDecoder(stdout).Decode(&resp); err != nil {
+			return false, err
+		}
+		// Convert to generic map for JSON response
+		result = make(map[string]any, len(resp.SmartData))
+		for k, v := range resp.SmartData {
+			result[k] = v
+		}
+		return false, nil
+	})
+	return result, err
 }

 // fetchDataViaSSH handles fetching data using SSH.
@@ -669,9 +627,6 @@ func (sys *System) createSessionWithTimeout(timeout time.Duration) (*ssh.Session

 // closeSSHConnection closes the SSH connection but keeps the system in the manager
 func (sys *System) closeSSHConnection() {
-	if sys.sshTransport != nil {
-		sys.sshTransport.Close()
-	}
 	if sys.client != nil {
 		sys.client.Close()
 		sys.client = nil
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
henrygd	1275af956b	updates	2025-11-24 16:57:06 -05:00
henrygd	bf36015bd9	updates	2025-11-24 16:40:18 -05:00
henrygd	56807dc5e4	updates	2025-11-21 17:49:17 -05:00
henrygd	56a9915b43	quiet hours progress	2025-11-21 17:09:42 -05:00