[Feature] Improve Container monitoring (#928 )

* align docker colors * change the name of the chart * Add tabs * Add volumes, health, stack and uptime * remove tests * fix table * Add stack filtering * search in filter * add container id * fix uptime * feat add ability to exclude container * remove stack colors, didnt look clear * better table * add disk io * Sync with main * undo locale * undo locale
2026-04-18 02:41:50 +02:00 · 2025-10-19 17:14:19 -04:00
306 changed files with 14442 additions and 69354 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,25 +12,16 @@ 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:
@@ -55,3 +29,48 @@ body:
      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/docker-images.yml
+++ b/.github/workflows/docker-images.yml
@@ -10,141 +10,67 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
-      max-parallel: 5
      matrix:
        include:
-          # henrygd/beszel
          - image: henrygd/beszel
+            context: ./
            dockerfile: ./internal/dockerfile_hub
            registry: docker.io
            username_secret: DOCKERHUB_USERNAME
            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

-          # henrygd/beszel-agent:alpine
          - image: henrygd/beszel-agent
-            dockerfile: ./internal/dockerfile_agent_alpine
+            context: ./
+            dockerfile: ./internal/dockerfile_agent
            registry: docker.io
            username_secret: DOCKERHUB_USERNAME
            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=alpine
-              type=semver,pattern={{version}}-alpine
-              type=semver,pattern={{major}}.{{minor}}-alpine
-              type=semver,pattern={{major}}-alpine

-          # henrygd/beszel-agent-nvidia
          - image: henrygd/beszel-agent-nvidia
+            context: ./
            dockerfile: ./internal/dockerfile_agent_nvidia
            platforms: linux/amd64
            registry: docker.io
            username_secret: DOCKERHUB_USERNAME
            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
            
-          # henrygd/beszel-agent-intel
          - image: henrygd/beszel-agent-intel
+            context: ./
            dockerfile: ./internal/dockerfile_agent_intel
            platforms: linux/amd64
            registry: docker.io
            username_secret: DOCKERHUB_USERNAME
            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

-          # ghcr.io/henrygd/beszel
          - image: ghcr.io/${{ github.repository }}/beszel
+            context: ./
            dockerfile: ./internal/dockerfile_hub
            registry: ghcr.io
            username: ${{ github.actor }}
            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

-          # ghcr.io/henrygd/beszel-agent
          - image: ghcr.io/${{ github.repository }}/beszel-agent
+            context: ./
            dockerfile: ./internal/dockerfile_agent
            registry: ghcr.io
            username: ${{ github.actor }}
            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=raw,value=latest
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

-          # ghcr.io/henrygd/beszel-agent-nvidia
          - image: ghcr.io/${{ github.repository }}/beszel-agent-nvidia
+            context: ./
            dockerfile: ./internal/dockerfile_agent_nvidia
            platforms: linux/amd64
            registry: ghcr.io
            username: ${{ github.actor }}
            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

-          # ghcr.io/henrygd/beszel-agent-intel
          - image: ghcr.io/${{ github.repository }}/beszel-agent-intel
+            context: ./
            dockerfile: ./internal/dockerfile_agent_intel
            platforms: linux/amd64
            registry: ghcr.io
            username: ${{ github.actor }}
            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
-
-          # ghcr.io/henrygd/beszel-agent:alpine
-          - image: ghcr.io/${{ github.repository }}/beszel-agent
-            dockerfile: ./internal/dockerfile_agent_alpine
-            registry: ghcr.io
-            username: ${{ github.actor }}
-            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=alpine
-              type=semver,pattern={{version}}-alpine
-              type=semver,pattern={{major}}.{{minor}}-alpine
-              type=semver,pattern={{major}}-alpine
-
-          # henrygd/beszel-agent (keep at bottom so it gets built after :alpine and gets the latest tag)
-          - image: henrygd/beszel-agent
-            dockerfile: ./internal/dockerfile_agent
-            registry: docker.io
-            username_secret: DOCKERHUB_USERNAME
-            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

    permissions:
      contents: read
@@ -174,7 +100,12 @@ jobs:
        uses: docker/metadata-action@v5
        with:
          images: ${{ matrix.image }}
-          tags: ${{ matrix.tags }}
+          tags: |
+            type=raw,value=edge
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}

      # https://github.com/docker/login-action
      - name: Login to Docker Hub
@@ -192,7 +123,7 @@ jobs:
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
-          context: ./
+          context: "${{ matrix.context }}"
          file: ${{ matrix.dockerfile }}
          platforms: ${{ matrix.platforms || 'linux/amd64,linux/arm64,linux/arm/v7' }}
          push: ${{ github.ref_type == 'tag' && secrets[matrix.password_secret] != '' }}
--- a/.github/workflows/inactivity-actions.yml
+++ b/.github/workflows/inactivity-actions.yml
@@ -6,30 +6,16 @@ on:
  workflow_dispatch:

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

 jobs:
-  lock-inactive:
-    name: Lock Inactive Issues
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: klaasnicolaas/action-inactivity-lock@v1.1.3
-        id: lock
-        with:
-          days-inactive-issues: 14
-          lock-reason-issues: ""
-          # Action can not skip PRs, set it to 100 years to cover it.
-          days-inactive-prs: 36524
-          lock-reason-prs: ""
-
  close-stale:
    name: Close Stale Issues
    runs-on: ubuntu-24.04
    steps:
      - name: Close Stale Issues
-        uses: actions/stale@v10
+        uses: actions/stale@v9
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

@@ -46,19 +32,12 @@ jobs:
          # Timing
          days-before-issue-stale: 14
          days-before-issue-close: 7
-          # 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
--- 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/.github/workflows/vulncheck.yml
+++ b/.github/workflows/vulncheck.yml
@@ -19,11 +19,11 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check out code into the Go module directory
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
        with:
-          go-version: 1.26.x
+          go-version: 1.25.x
          # cached: false
      - name: Get official govulncheck
        run: go install golang.org/x/vuln/cmd/govulncheck@latest
--- 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
@@ -5,7 +5,6 @@ project_name: beszel
 before:
  hooks:
    - go mod tidy
-    - go generate -run fetchsmartctl ./agent

 builds:
  - id: beszel
@@ -16,21 +15,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 +64,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 +77,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 +85,6 @@ archives:
      {{ .Binary }}_
      {{- .Os }}_
      {{- .Arch }}
-    format_overrides:
-      - goos: windows
-        formats: [zip]

 nfpms:
  - id: beszel-agent
@@ -158,7 +122,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/51
+++ b/51
@@ -3,45 +3,11 @@ 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,)

-.PHONY: tidy build-agent build-hub build-hub-dev build clean lint dev-server dev-agent dev-hub dev generate-locales fetch-smartctl-conditional
+.PHONY: tidy build-agent build-hub build-hub-dev build clean lint dev-server dev-agent dev-hub dev generate-locales
 .DEFAULT_GOAL := build

 clean:
@@ -51,6 +17,7 @@ clean:
 lint:
 	golangci-lint run

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

@@ -79,15 +46,9 @@ build-dotnet-conditional:
 		fi; \
 	fi

-# Download smartctl.exe at build time for Windows (skips if already present)
-fetch-smartctl-conditional:
-	@if [ "$(OS)" = "windows" ]; then \
-		go generate -run fetchsmartctl ./agent; \
-	fi
-
 # 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
+build-agent: tidy build-dotnet-conditional
+	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 +84,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,22 +5,22 @@
 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/agent/utils"
-	"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"
 )

-const defaultDataCacheTimeMs uint16 = 60_000
-
 type Agent struct {
 	sync.Mutex                                                                      // Used to lock agent while collecting data
 	debug                     bool                                                  // true if LOG_LEVEL is set to debug
@@ -29,16 +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)
-	detailsDirty              bool                                                  // Whether system details have changed and need to be resent
+	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
@@ -46,8 +42,6 @@ type Agent struct {
 	server                    *ssh.Server                                           // SSH server
 	dataDir                   string                                                // Directory for persisting data
 	keys                      []gossh.PublicKey                                     // SSH public keys
-	smartManager              *SmartManager                                         // Manages SMART data
-	systemdManager            *systemdManager                                       // Manages systemd services
 }

 // NewAgent creates a new agent with the given data directory for persisting data.
@@ -64,28 +58,17 @@ 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 {
 		slog.Info("Data directory", "path", agent.dataDir)
 	}

-	agent.memCalc, _ = utils.GetEnv("MEM_CALC")
+	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 := utils.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 := utils.GetEnv("LOG_LEVEL"); exists {
+	if logLevelStr, exists := GetEnv("LOG_LEVEL"); exists {
 		switch strings.ToLower(logLevelStr) {
 		case "debug":
 			agent.debug = true
@@ -99,21 +82,8 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {

 	slog.Debug(beszel.Version)

-	// initialize docker manager
-	agent.dockerManager = newDockerManager(agent)
-
 	// initialize system info
-	agent.refreshSystemDetails()
-
-	// SMART_INTERVAL env var to update smart data at this interval
-	if smartIntervalEnv, exists := utils.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)
@@ -127,35 +97,37 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	// initialize net io stats
 	agent.initializeNetIoStats()

-	agent.systemdManager, err = newSystemdManager()
-	if err != nil {
-		slog.Debug("Systemd", "err", err)
-	}
-
-	agent.smartManager, err = NewSmartManager()
-	if err != nil {
-		slog.Debug("SMART", "err", err)
-	}
+	// initialize docker manager
+	agent.dockerManager = newDockerManager(agent)

 	// initialize GPU manager
-	agent.gpuManager, err = NewGPUManager()
-	if err != nil {
+	if gm, err := NewGPUManager(); err != nil {
 		slog.Debug("GPU", "err", err)
+	} else {
+		agent.gpuManager = gm
 	}

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

 	return agent, nil
 }

-func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedData {
+// GetEnv retrieves an environment variable with a "BESZEL_AGENT_" prefix, or falls back to the unprefixed key.
+func GetEnv(key string) (value string, exists bool) {
+	if value, exists = os.LookupEnv("BESZEL_AGENT_" + key); exists {
+		return value, exists
+	}
+	// Fallback to the old unprefixed key
+	return os.LookupEnv(key)
+}
+
+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)
@@ -166,7 +138,6 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 		Stats: a.getSystemStats(cacheTimeMs),
 		Info:  a.systemInfo,
 	}
-
 	// slog.Info("System data", "data", data, "cacheTimeMs", cacheTimeMs)

 	if a.dockerManager != nil {
@@ -178,20 +149,7 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 		}
 	}

-	// skip updating systemd services if cache time is not the default 60sec interval
-	if a.systemdManager != nil && cacheTimeMs == defaultDataCacheTimeMs {
-		totalCount := uint16(a.systemdManager.getServiceStatsCount())
-		if totalCount > 0 {
-			numFailed := a.systemdManager.getFailedServiceCount()
-			data.Info.Services = []uint16{totalCount, numFailed}
-		}
-		if a.systemdManager.hasFreshStats {
-			data.SystemdServices = a.systemdManager.getServiceStats(nil, false)
-		}
-	}
-
 	data.Stats.ExtraFs = make(map[string]*system.FsStats)
-	data.Info.ExtraFsPct = make(map[string]float64)
 	for name, stats := range a.fsStats {
 		if !stats.Root && stats.DiskTotal > 0 {
 			// Use custom name if available, otherwise use device name
@@ -200,26 +158,45 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 				key = stats.Name
 			}
 			data.Stats.ExtraFs[key] = stats
-			// Add percentages to Info struct for dashboard
-			if stats.DiskTotal > 0 {
-				pct := utils.TwoDecimals((stats.DiskUsed / stats.DiskTotal) * 100)
-				data.Info.ExtraFsPct[key] = pct
-			}
 		}
 	}
 	slog.Debug("Extra FS", "data", data.Stats.ExtraFs)

 	a.cache.Set(data, cacheTimeMs)
-
-	return a.attachSystemDetails(data, cacheTimeMs, options.IncludeDetails)
+	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
@@ -1,11 +1,52 @@
-// Package battery provides functions to check if the system has a battery and return the charge state and percentage.
+//go:build !freebsd
+
+// Package battery provides functions to check if the system has a battery and to get the battery stats.
 package battery

-const (
-	stateUnknown uint8 = iota
-	stateEmpty
-	stateFull
-	stateCharging
-	stateDischarging
-	stateIdle
+import (
+	"errors"
+	"log/slog"
+
+	"github.com/distatus/battery"
 )
+
+var systemHasBattery = false
+var haveCheckedBattery = false
+
+// HasReadableBattery checks if the system has a battery and returns true if it does.
+func HasReadableBattery() bool {
+	if haveCheckedBattery {
+		return systemHasBattery
+	}
+	haveCheckedBattery = true
+	bat, err := battery.Get(0)
+	systemHasBattery = err == nil && bat != nil && bat.Design != 0 && bat.Full != 0
+	if !systemHasBattery {
+		slog.Debug("No battery found", "err", err)
+	}
+	return systemHasBattery
+}
+
+// GetBatteryStats returns the current battery percent and charge state
+func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
+	if !systemHasBattery {
+		return batteryPercent, batteryState, errors.ErrUnsupported
+	}
+	batteries, err := battery.GetAll()
+	if err != nil || len(batteries) == 0 {
+		return batteryPercent, batteryState, err
+	}
+	totalCapacity := float64(0)
+	totalCharge := float64(0)
+	for _, bat := range batteries {
+		if bat.Design != 0 {
+			totalCapacity += bat.Design
+		} else {
+			totalCapacity += bat.Full
+		}
+		totalCharge += bat.Current
+	}
+	batteryPercent = uint8(totalCharge / totalCapacity * 100)
+	batteryState = uint8(batteries[0].State.Raw)
+	return batteryPercent, batteryState, nil
+}
--- a/agent/battery/battery_darwin.go
+++ b/agent/battery/battery_darwin.go
@@ -1,96 +0,0 @@
-//go:build darwin
-
-package battery
-
-import (
-	"errors"
-	"log/slog"
-	"math"
-	"os/exec"
-	"sync"
-
-	"howett.net/plist"
-)
-
-type macBattery struct {
-	CurrentCapacity   int  `plist:"CurrentCapacity"`
-	MaxCapacity       int  `plist:"MaxCapacity"`
-	FullyCharged      bool `plist:"FullyCharged"`
-	IsCharging        bool `plist:"IsCharging"`
-	ExternalConnected bool `plist:"ExternalConnected"`
-}
-
-func readMacBatteries() ([]macBattery, error) {
-	out, err := exec.Command("ioreg", "-n", "AppleSmartBattery", "-r", "-a").Output()
-	if err != nil {
-		return nil, err
-	}
-	if len(out) == 0 {
-		return nil, nil
-	}
-	var batteries []macBattery
-	if _, err := plist.Unmarshal(out, &batteries); err != nil {
-		return nil, err
-	}
-	return batteries, nil
-}
-
-// HasReadableBattery checks if the system has a battery and returns true if it does.
-var HasReadableBattery = sync.OnceValue(func() bool {
-	systemHasBattery := false
-	batteries, err := readMacBatteries()
-	slog.Debug("Batteries", "batteries", batteries, "err", err)
-	for _, bat := range batteries {
-		if bat.MaxCapacity > 0 {
-			systemHasBattery = true
-			break
-		}
-	}
-	return systemHasBattery
-})
-
-// GetBatteryStats returns the current battery percent and charge state.
-// Uses CurrentCapacity/MaxCapacity to match the value macOS displays.
-func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
-	if !HasReadableBattery() {
-		return batteryPercent, batteryState, errors.ErrUnsupported
-	}
-	batteries, err := readMacBatteries()
-	if len(batteries) == 0 {
-		return batteryPercent, batteryState, errors.New("no batteries")
-	}
-
-	totalCapacity := 0
-	totalCharge := 0
-	batteryState = math.MaxUint8
-
-	for _, bat := range batteries {
-		if bat.MaxCapacity == 0 {
-			// skip ghost batteries with 0 capacity
-			// https://github.com/distatus/battery/issues/34
-			continue
-		}
-		totalCapacity += bat.MaxCapacity
-		totalCharge += min(bat.CurrentCapacity, bat.MaxCapacity)
-
-		switch {
-		case !bat.ExternalConnected:
-			batteryState = stateDischarging
-		case bat.IsCharging:
-			batteryState = stateCharging
-		case bat.CurrentCapacity == 0:
-			batteryState = stateEmpty
-		case !bat.FullyCharged:
-			batteryState = stateIdle
-		default:
-			batteryState = stateFull
-		}
-	}
-
-	if totalCapacity == 0 || batteryState == math.MaxUint8 {
-		return batteryPercent, batteryState, errors.New("no battery capacity")
-	}
-
-	batteryPercent = uint8(float64(totalCharge) / float64(totalCapacity) * 100)
-	return batteryPercent, batteryState, nil
-}
--- a/agent/battery/battery_freebsd.go
+++ b/agent/battery/battery_freebsd.go
@@ -1,4 +1,4 @@
-//go:build !darwin && !linux && !windows
+//go:build freebsd

 package battery

--- a/agent/battery/battery_linux.go
+++ b/agent/battery/battery_linux.go
@@ -1,120 +0,0 @@
-//go:build linux
-
-package battery
-
-import (
-	"errors"
-	"log/slog"
-	"math"
-	"os"
-	"path/filepath"
-	"strconv"
-	"sync"
-
-	"github.com/henrygd/beszel/agent/utils"
-)
-
-// getBatteryPaths returns the paths of all batteries in /sys/class/power_supply
-var getBatteryPaths func() ([]string, error)
-
-// HasReadableBattery checks if the system has a battery and returns true if it does.
-var HasReadableBattery func() bool
-
-func init() {
-	resetBatteryState("/sys/class/power_supply")
-}
-
-// resetBatteryState resets the sync.Once functions to a fresh state.
-// Tests call this after swapping sysfsPowerSupply so the new path is picked up.
-func resetBatteryState(sysfsPowerSupplyPath string) {
-	getBatteryPaths = sync.OnceValues(func() ([]string, error) {
-		entries, err := os.ReadDir(sysfsPowerSupplyPath)
-		if err != nil {
-			return nil, err
-		}
-		var paths []string
-		for _, e := range entries {
-			path := filepath.Join(sysfsPowerSupplyPath, e.Name())
-			if utils.ReadStringFile(filepath.Join(path, "type")) == "Battery" {
-				paths = append(paths, path)
-			}
-		}
-		return paths, nil
-	})
-	HasReadableBattery = sync.OnceValue(func() bool {
-		systemHasBattery := false
-		paths, err := getBatteryPaths()
-		for _, path := range paths {
-			if _, ok := utils.ReadStringFileOK(filepath.Join(path, "capacity")); ok {
-				systemHasBattery = true
-				break
-			}
-		}
-		if !systemHasBattery {
-			slog.Debug("No battery found", "err", err)
-		}
-		return systemHasBattery
-	})
-}
-
-func parseSysfsState(status string) uint8 {
-	switch status {
-	case "Empty":
-		return stateEmpty
-	case "Full":
-		return stateFull
-	case "Charging":
-		return stateCharging
-	case "Discharging":
-		return stateDischarging
-	case "Not charging":
-		return stateIdle
-	default:
-		return stateUnknown
-	}
-}
-
-// GetBatteryStats returns the current battery percent and charge state.
-// Reads /sys/class/power_supply/*/capacity directly so the kernel-reported
-// value is used, which is always 0-100 and matches what the OS displays.
-func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
-	if !HasReadableBattery() {
-		return batteryPercent, batteryState, errors.ErrUnsupported
-	}
-	paths, err := getBatteryPaths()
-	if err != nil {
-		return batteryPercent, batteryState, err
-	}
-	if len(paths) == 0 {
-		return batteryPercent, batteryState, errors.New("no batteries")
-	}
-
-	batteryState = math.MaxUint8
-	totalPercent := 0
-	count := 0
-
-	for _, path := range paths {
-		capStr, ok := utils.ReadStringFileOK(filepath.Join(path, "capacity"))
-		if !ok {
-			continue
-		}
-		cap, parseErr := strconv.Atoi(capStr)
-		if parseErr != nil {
-			continue
-		}
-		totalPercent += cap
-		count++
-
-		state := parseSysfsState(utils.ReadStringFile(filepath.Join(path, "status")))
-		if state != stateUnknown {
-			batteryState = state
-		}
-	}
-
-	if count == 0 || batteryState == math.MaxUint8 {
-		return batteryPercent, batteryState, errors.New("no battery capacity")
-	}
-
-	batteryPercent = uint8(totalPercent / count)
-	return batteryPercent, batteryState, nil
-}
--- a/agent/battery/battery_linux_test.go
+++ b/agent/battery/battery_linux_test.go
@@ -1,201 +0,0 @@
-//go:build testing && linux
-
-package battery
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// setupFakeSysfs creates a temporary sysfs-like tree under t.TempDir(),
-// swaps sysfsPowerSupply, resets the sync.Once caches, and restores
-// everything on cleanup. Returns a helper to create battery directories.
-func setupFakeSysfs(t *testing.T) (tmpDir string, addBattery func(name, capacity, status string)) {
-	t.Helper()
-
-	tmp := t.TempDir()
-	resetBatteryState(tmp)
-
-	write := func(path, content string) {
-		t.Helper()
-		dir := filepath.Dir(path)
-		if err := os.MkdirAll(dir, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	addBattery = func(name, capacity, status string) {
-		t.Helper()
-		batDir := filepath.Join(tmp, name)
-		write(filepath.Join(batDir, "type"), "Battery")
-		write(filepath.Join(batDir, "capacity"), capacity)
-		write(filepath.Join(batDir, "status"), status)
-	}
-
-	return tmp, addBattery
-}
-
-func TestParseSysfsState(t *testing.T) {
-	tests := []struct {
-		input string
-		want  uint8
-	}{
-		{"Empty", stateEmpty},
-		{"Full", stateFull},
-		{"Charging", stateCharging},
-		{"Discharging", stateDischarging},
-		{"Not charging", stateIdle},
-		{"", stateUnknown},
-		{"SomethingElse", stateUnknown},
-	}
-	for _, tt := range tests {
-		assert.Equal(t, tt.want, parseSysfsState(tt.input), "parseSysfsState(%q)", tt.input)
-	}
-}
-
-func TestGetBatteryStats_SingleBattery(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "72", "Discharging")
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	assert.Equal(t, uint8(72), pct)
-	assert.Equal(t, stateDischarging, state)
-}
-
-func TestGetBatteryStats_MultipleBatteries(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "80", "Charging")
-	addBattery("BAT1", "40", "Charging")
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	// average of 80 and 40 = 60
-	assert.EqualValues(t, 60, pct)
-	assert.Equal(t, stateCharging, state)
-}
-
-func TestGetBatteryStats_FullBattery(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "100", "Full")
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	assert.Equal(t, uint8(100), pct)
-	assert.Equal(t, stateFull, state)
-}
-
-func TestGetBatteryStats_EmptyBattery(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "0", "Empty")
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	assert.Equal(t, uint8(0), pct)
-	assert.Equal(t, stateEmpty, state)
-}
-
-func TestGetBatteryStats_NotCharging(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "80", "Not charging")
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	assert.Equal(t, uint8(80), pct)
-	assert.Equal(t, stateIdle, state)
-}
-
-func TestGetBatteryStats_NoBatteries(t *testing.T) {
-	setupFakeSysfs(t) // empty directory, no batteries
-
-	_, _, err := GetBatteryStats()
-	assert.Error(t, err)
-}
-
-func TestGetBatteryStats_NonBatterySupplyIgnored(t *testing.T) {
-	tmp, addBattery := setupFakeSysfs(t)
-
-	// Add a real battery
-	addBattery("BAT0", "55", "Charging")
-
-	// Add an AC adapter (type != Battery) - should be ignored
-	acDir := filepath.Join(tmp, "AC0")
-	if err := os.MkdirAll(acDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(acDir, "type"), []byte("Mains"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	pct, state, err := GetBatteryStats()
-	assert.NoError(t, err)
-	assert.Equal(t, uint8(55), pct)
-	assert.Equal(t, stateCharging, state)
-}
-
-func TestGetBatteryStats_InvalidCapacitySkipped(t *testing.T) {
-	tmp, addBattery := setupFakeSysfs(t)
-
-	// One battery with valid capacity
-	addBattery("BAT0", "90", "Discharging")
-
-	// Another with invalid capacity text
-	badDir := filepath.Join(tmp, "BAT1")
-	if err := os.MkdirAll(badDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(badDir, "type"), []byte("Battery"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(badDir, "capacity"), []byte("not-a-number"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(badDir, "status"), []byte("Discharging"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	pct, _, err := GetBatteryStats()
-	assert.NoError(t, err)
-	// Only BAT0 counted
-	assert.Equal(t, uint8(90), pct)
-}
-
-func TestGetBatteryStats_UnknownStatusOnly(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "50", "SomethingWeird")
-
-	_, _, err := GetBatteryStats()
-	assert.Error(t, err)
-}
-
-func TestHasReadableBattery_True(t *testing.T) {
-	_, addBattery := setupFakeSysfs(t)
-	addBattery("BAT0", "50", "Charging")
-
-	assert.True(t, HasReadableBattery())
-}
-
-func TestHasReadableBattery_False(t *testing.T) {
-	setupFakeSysfs(t) // no batteries
-
-	assert.False(t, HasReadableBattery())
-}
-
-func TestHasReadableBattery_NoCapacityFile(t *testing.T) {
-	tmp, _ := setupFakeSysfs(t)
-
-	// Battery dir with type file but no capacity file
-	batDir := filepath.Join(tmp, "BAT0")
-	err := os.MkdirAll(batDir, 0o755)
-	assert.NoError(t, err)
-	err = os.WriteFile(filepath.Join(batDir, "type"), []byte("Battery"), 0o644)
-	assert.NoError(t, err)
-
-	assert.False(t, HasReadableBattery())
-}
--- a/agent/battery/battery_windows.go
+++ b/agent/battery/battery_windows.go
@@ -1,298 +0,0 @@
-//go:build windows
-
-// Most of the Windows battery code is based on
-// distatus/battery by Karol 'Kenji Takahashi' Woźniak
-
-package battery
-
-import (
-	"errors"
-	"log/slog"
-	"math"
-	"sync"
-	"syscall"
-	"unsafe"
-
-	"golang.org/x/sys/windows"
-)
-
-type batteryQueryInformation struct {
-	BatteryTag       uint32
-	InformationLevel int32
-	AtRate           int32
-}
-
-type batteryInformation struct {
-	Capabilities        uint32
-	Technology          uint8
-	Reserved            [3]uint8
-	Chemistry           [4]uint8
-	DesignedCapacity    uint32
-	FullChargedCapacity uint32
-	DefaultAlert1       uint32
-	DefaultAlert2       uint32
-	CriticalBias        uint32
-	CycleCount          uint32
-}
-
-type batteryWaitStatus struct {
-	BatteryTag   uint32
-	Timeout      uint32
-	PowerState   uint32
-	LowCapacity  uint32
-	HighCapacity uint32
-}
-
-type batteryStatus struct {
-	PowerState uint32
-	Capacity   uint32
-	Voltage    uint32
-	Rate       int32
-}
-
-type winGUID struct {
-	Data1 uint32
-	Data2 uint16
-	Data3 uint16
-	Data4 [8]byte
-}
-
-type spDeviceInterfaceData struct {
-	cbSize             uint32
-	InterfaceClassGuid winGUID
-	Flags              uint32
-	Reserved           uint
-}
-
-var guidDeviceBattery = winGUID{
-	0x72631e54,
-	0x78A4,
-	0x11d0,
-	[8]byte{0xbc, 0xf7, 0x00, 0xaa, 0x00, 0xb7, 0xb3, 0x2a},
-}
-
-var (
-	setupapi                         = &windows.LazyDLL{Name: "setupapi.dll", System: true}
-	setupDiGetClassDevsW             = setupapi.NewProc("SetupDiGetClassDevsW")
-	setupDiEnumDeviceInterfaces      = setupapi.NewProc("SetupDiEnumDeviceInterfaces")
-	setupDiGetDeviceInterfaceDetailW = setupapi.NewProc("SetupDiGetDeviceInterfaceDetailW")
-	setupDiDestroyDeviceInfoList     = setupapi.NewProc("SetupDiDestroyDeviceInfoList")
-)
-
-// winBatteryGet reads one battery by index. Returns (fullCapacity, currentCapacity, state, error).
-// Returns error == errNotFound when there are no more batteries.
-var errNotFound = errors.New("no more batteries")
-
-func setupDiSetup(proc *windows.LazyProc, nargs, a1, a2, a3, a4, a5, a6 uintptr) (uintptr, error) {
-	_ = nargs
-	r1, _, errno := syscall.SyscallN(proc.Addr(), a1, a2, a3, a4, a5, a6)
-	if windows.Handle(r1) == windows.InvalidHandle {
-		if errno != 0 {
-			return 0, error(errno)
-		}
-		return 0, syscall.EINVAL
-	}
-	return r1, nil
-}
-
-func setupDiCall(proc *windows.LazyProc, nargs, a1, a2, a3, a4, a5, a6 uintptr) syscall.Errno {
-	_ = nargs
-	r1, _, errno := syscall.SyscallN(proc.Addr(), a1, a2, a3, a4, a5, a6)
-	if r1 == 0 {
-		if errno != 0 {
-			return errno
-		}
-		return syscall.EINVAL
-	}
-	return 0
-}
-
-func readWinBatteryState(powerState uint32) uint8 {
-	switch {
-	case powerState&0x00000004 != 0:
-		return stateCharging
-	case powerState&0x00000008 != 0:
-		return stateEmpty
-	case powerState&0x00000002 != 0:
-		return stateDischarging
-	case powerState&0x00000001 != 0:
-		return stateFull
-	default:
-		return stateUnknown
-	}
-}
-
-func winBatteryGet(idx int) (full, current uint32, state uint8, err error) {
-	hdev, err := setupDiSetup(
-		setupDiGetClassDevsW,
-		4,
-		uintptr(unsafe.Pointer(&guidDeviceBattery)),
-		0, 0,
-		2|16, // DIGCF_PRESENT|DIGCF_DEVICEINTERFACE
-		0, 0,
-	)
-	if err != nil {
-		return 0, 0, stateUnknown, err
-	}
-	defer syscall.SyscallN(setupDiDestroyDeviceInfoList.Addr(), hdev)
-
-	var did spDeviceInterfaceData
-	did.cbSize = uint32(unsafe.Sizeof(did))
-	errno := setupDiCall(
-		setupDiEnumDeviceInterfaces,
-		5,
-		hdev, 0,
-		uintptr(unsafe.Pointer(&guidDeviceBattery)),
-		uintptr(idx),
-		uintptr(unsafe.Pointer(&did)),
-		0,
-	)
-	if errno == 259 { // ERROR_NO_MORE_ITEMS
-		return 0, 0, stateUnknown, errNotFound
-	}
-	if errno != 0 {
-		return 0, 0, stateUnknown, errno
-	}
-
-	var cbRequired uint32
-	errno = setupDiCall(
-		setupDiGetDeviceInterfaceDetailW,
-		6,
-		hdev,
-		uintptr(unsafe.Pointer(&did)),
-		0, 0,
-		uintptr(unsafe.Pointer(&cbRequired)),
-		0,
-	)
-	if errno != 0 && errno != 122 { // ERROR_INSUFFICIENT_BUFFER
-		return 0, 0, stateUnknown, errno
-	}
-	didd := make([]uint16, cbRequired/2)
-	cbSize := (*uint32)(unsafe.Pointer(&didd[0]))
-	if unsafe.Sizeof(uint(0)) == 8 {
-		*cbSize = 8
-	} else {
-		*cbSize = 6
-	}
-	errno = setupDiCall(
-		setupDiGetDeviceInterfaceDetailW,
-		6,
-		hdev,
-		uintptr(unsafe.Pointer(&did)),
-		uintptr(unsafe.Pointer(&didd[0])),
-		uintptr(cbRequired),
-		uintptr(unsafe.Pointer(&cbRequired)),
-		0,
-	)
-	if errno != 0 {
-		return 0, 0, stateUnknown, errno
-	}
-	devicePath := &didd[2:][0]
-
-	handle, err := windows.CreateFile(
-		devicePath,
-		windows.GENERIC_READ|windows.GENERIC_WRITE,
-		windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE,
-		nil,
-		windows.OPEN_EXISTING,
-		windows.FILE_ATTRIBUTE_NORMAL,
-		0,
-	)
-	if err != nil {
-		return 0, 0, stateUnknown, err
-	}
-	defer windows.CloseHandle(handle)
-
-	var dwOut uint32
-	var dwWait uint32
-	var bqi batteryQueryInformation
-	err = windows.DeviceIoControl(
-		handle,
-		2703424, // IOCTL_BATTERY_QUERY_TAG
-		(*byte)(unsafe.Pointer(&dwWait)),
-		uint32(unsafe.Sizeof(dwWait)),
-		(*byte)(unsafe.Pointer(&bqi.BatteryTag)),
-		uint32(unsafe.Sizeof(bqi.BatteryTag)),
-		&dwOut, nil,
-	)
-	if err != nil || bqi.BatteryTag == 0 {
-		return 0, 0, stateUnknown, errors.New("battery tag not returned")
-	}
-
-	var bi batteryInformation
-	if err = windows.DeviceIoControl(
-		handle,
-		2703428, // IOCTL_BATTERY_QUERY_INFORMATION
-		(*byte)(unsafe.Pointer(&bqi)),
-		uint32(unsafe.Sizeof(bqi)),
-		(*byte)(unsafe.Pointer(&bi)),
-		uint32(unsafe.Sizeof(bi)),
-		&dwOut, nil,
-	); err != nil {
-		return 0, 0, stateUnknown, err
-	}
-
-	bws := batteryWaitStatus{BatteryTag: bqi.BatteryTag}
-	var bs batteryStatus
-	if err = windows.DeviceIoControl(
-		handle,
-		2703436, // IOCTL_BATTERY_QUERY_STATUS
-		(*byte)(unsafe.Pointer(&bws)),
-		uint32(unsafe.Sizeof(bws)),
-		(*byte)(unsafe.Pointer(&bs)),
-		uint32(unsafe.Sizeof(bs)),
-		&dwOut, nil,
-	); err != nil {
-		return 0, 0, stateUnknown, err
-	}
-
-	if bs.Capacity == 0xffffffff { // BATTERY_UNKNOWN_CAPACITY
-		return 0, 0, stateUnknown, errors.New("battery capacity unknown")
-	}
-
-	return bi.FullChargedCapacity, bs.Capacity, readWinBatteryState(bs.PowerState), nil
-}
-
-// HasReadableBattery checks if the system has a battery and returns true if it does.
-var HasReadableBattery = sync.OnceValue(func() bool {
-	systemHasBattery := false
-	full, _, _, err := winBatteryGet(0)
-	if err == nil && full > 0 {
-		systemHasBattery = true
-	}
-	if !systemHasBattery {
-		slog.Debug("No battery found", "err", err)
-	}
-	return systemHasBattery
-})
-
-// GetBatteryStats returns the current battery percent and charge state.
-func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
-	if !HasReadableBattery() {
-		return batteryPercent, batteryState, errors.ErrUnsupported
-	}
-
-	totalFull := uint32(0)
-	totalCurrent := uint32(0)
-	batteryState = math.MaxUint8
-
-	for i := 0; ; i++ {
-		full, current, state, bErr := winBatteryGet(i)
-		if errors.Is(bErr, errNotFound) {
-			break
-		}
-		if bErr != nil || full == 0 {
-			continue
-		}
-		totalFull += full
-		totalCurrent += min(current, full)
-		batteryState = state
-	}
-
-	if totalFull == 0 || batteryState == math.MaxUint8 {
-		return batteryPercent, batteryState, errors.New("no battery capacity")
-	}
-
-	batteryPercent = uint8(float64(totalCurrent) / float64(totalFull) * 100)
-	return batteryPercent, batteryState, nil
-}
--- a/agent/client.go
+++ b/agent/client.go
@@ -14,13 +14,12 @@ import (
 	"time"

 	"github.com/henrygd/beszel"
-	"github.com/henrygd/beszel/agent/utils"
 	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/entities/system"

 	"github.com/fxamacker/cbor/v2"
 	"github.com/lxzan/gws"
 	"golang.org/x/crypto/ssh"
-	"golang.org/x/net/proxy"
 )

 const (
@@ -45,7 +44,7 @@ type WebSocketClient struct {
 // newWebSocketClient creates a new WebSocket client for the given agent.
 // It reads configuration from environment variables and validates the hub URL.
 func newWebSocketClient(agent *Agent) (client *WebSocketClient, err error) {
-	hubURLStr, exists := utils.GetEnv("HUB_URL")
+	hubURLStr, exists := GetEnv("HUB_URL")
 	if !exists {
 		return nil, errors.New("HUB_URL environment variable not set")
 	}
@@ -74,12 +73,12 @@ func newWebSocketClient(agent *Agent) (client *WebSocketClient, err error) {
 // If neither is set, it returns an error.
 func getToken() (string, error) {
 	// get token from env var
-	token, _ := utils.GetEnv("TOKEN")
+	token, _ := GetEnv("TOKEN")
 	if token != "" {
 		return token, nil
 	}
 	// get token from file
-	tokenFile, _ := utils.GetEnv("TOKEN_FILE")
+	tokenFile, _ := GetEnv("TOKEN_FILE")
 	if tokenFile == "" {
 		return "", errors.New("must set TOKEN or TOKEN_FILE")
 	}
@@ -105,11 +104,6 @@ func (client *WebSocketClient) getOptions() *gws.ClientOption {
 	}
 	client.hubURL.Path = path.Join(client.hubURL.Path, "api/beszel/agent-connect")

-	// make sure BESZEL_AGENT_ALL_PROXY works (GWS only checks ALL_PROXY)
-	if val := os.Getenv("BESZEL_AGENT_ALL_PROXY"); val != "" {
-		os.Setenv("ALL_PROXY", val)
-	}
-
 	client.options = &gws.ClientOption{
 		Addr:      client.hubURL.String(),
 		TlsConfig: &tls.Config{InsecureSkipVerify: true},
@@ -118,9 +112,6 @@ func (client *WebSocketClient) getOptions() *gws.ClientOption {
 			"X-Token":    []string{client.token},
 			"X-Beszel":   []string{beszel.Version},
 		},
-		NewDialer: func() (gws.Dialer, error) {
-			return proxy.FromEnvironment(), nil
-		},
 	}
 	return client.options
 }
@@ -207,8 +198,8 @@ func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.R
 	}

 	if authRequest.NeedSysInfo {
-		response.Name, _ = utils.GetEnv("SYSTEM_NAME")
-		response.Hostname = client.agent.systemDetails.Hostname
+		response.Name, _ = GetEnv("SYSTEM_NAME")
+		response.Hostname = client.agent.systemInfo.Hostname
 		serverAddr := client.agent.connectionManager.serverOptions.Addr
 		_, response.Port, _ = net.SplitHostPort(serverAddr)
 	}
@@ -266,16 +257,34 @@ 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 []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

@@ -70,11 +71,19 @@ func TestNewWebSocketClient(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			// Set up environment
 			if tc.hubURL != "" {
-				t.Setenv("BESZEL_AGENT_HUB_URL", tc.hubURL)
+				os.Setenv("BESZEL_AGENT_HUB_URL", tc.hubURL)
+			} else {
+				os.Unsetenv("BESZEL_AGENT_HUB_URL")
 			}
 			if tc.token != "" {
-				t.Setenv("BESZEL_AGENT_TOKEN", tc.token)
+				os.Setenv("BESZEL_AGENT_TOKEN", tc.token)
+			} else {
+				os.Unsetenv("BESZEL_AGENT_TOKEN")
 			}
+			defer func() {
+				os.Unsetenv("BESZEL_AGENT_HUB_URL")
+				os.Unsetenv("BESZEL_AGENT_TOKEN")
+			}()

 			client, err := newWebSocketClient(agent)

@@ -130,8 +139,12 @@ func TestWebSocketClient_GetOptions(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			// Set up environment
-			t.Setenv("BESZEL_AGENT_HUB_URL", tc.inputURL)
-			t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+			os.Setenv("BESZEL_AGENT_HUB_URL", tc.inputURL)
+			os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+			defer func() {
+				os.Unsetenv("BESZEL_AGENT_HUB_URL")
+				os.Unsetenv("BESZEL_AGENT_TOKEN")
+			}()

 			client, err := newWebSocketClient(agent)
 			require.NoError(t, err)
@@ -173,8 +186,12 @@ func TestWebSocketClient_VerifySignature(t *testing.T) {
 	require.NoError(t, err)

 	// Set up environment
-	t.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	client, err := newWebSocketClient(agent)
 	require.NoError(t, err)
@@ -242,8 +259,12 @@ func TestWebSocketClient_HandleHubRequest(t *testing.T) {
 	agent := createTestAgent(t)

 	// Set up environment
-	t.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	client, err := newWebSocketClient(agent)
 	require.NoError(t, err)
@@ -330,8 +351,13 @@ func TestGetUserAgent(t *testing.T) {
 func TestWebSocketClient_Close(t *testing.T) {
 	agent := createTestAgent(t)

-	t.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	// Set up environment
+	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	client, err := newWebSocketClient(agent)
 	require.NoError(t, err)
@@ -346,8 +372,13 @@ func TestWebSocketClient_Close(t *testing.T) {
 func TestWebSocketClient_ConnectRateLimit(t *testing.T) {
 	agent := createTestAgent(t)

-	t.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	// Set up environment
+	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	client, err := newWebSocketClient(agent)
 	require.NoError(t, err)
@@ -363,10 +394,20 @@ func TestWebSocketClient_ConnectRateLimit(t *testing.T) {

 // TestGetToken tests the getToken function with various scenarios
 func TestGetToken(t *testing.T) {
+	unsetEnvVars := func() {
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+		os.Unsetenv("TOKEN")
+		os.Unsetenv("BESZEL_AGENT_TOKEN_FILE")
+		os.Unsetenv("TOKEN_FILE")
+	}
+
 	t.Run("token from TOKEN environment variable", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Set TOKEN env var
 		expectedToken := "test-token-from-env"
-		t.Setenv("TOKEN", expectedToken)
+		os.Setenv("TOKEN", expectedToken)
+		defer os.Unsetenv("TOKEN")

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -374,9 +415,12 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("token from BESZEL_AGENT_TOKEN environment variable", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Set BESZEL_AGENT_TOKEN env var (should take precedence)
 		expectedToken := "test-token-from-beszel-env"
-		t.Setenv("BESZEL_AGENT_TOKEN", expectedToken)
+		os.Setenv("BESZEL_AGENT_TOKEN", expectedToken)
+		defer os.Unsetenv("BESZEL_AGENT_TOKEN")

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -384,6 +428,8 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("token from TOKEN_FILE", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Create a temporary token file
 		expectedToken := "test-token-from-file"
 		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
@@ -395,7 +441,8 @@ func TestGetToken(t *testing.T) {
 		tokenFile.Close()

 		// Set TOKEN_FILE env var
-		t.Setenv("TOKEN_FILE", tokenFile.Name())
+		os.Setenv("TOKEN_FILE", tokenFile.Name())
+		defer os.Unsetenv("TOKEN_FILE")

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -403,6 +450,8 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("token from BESZEL_AGENT_TOKEN_FILE", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Create a temporary token file
 		expectedToken := "test-token-from-beszel-file"
 		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
@@ -414,7 +463,8 @@ func TestGetToken(t *testing.T) {
 		tokenFile.Close()

 		// Set BESZEL_AGENT_TOKEN_FILE env var (should take precedence)
-		t.Setenv("BESZEL_AGENT_TOKEN_FILE", tokenFile.Name())
+		os.Setenv("BESZEL_AGENT_TOKEN_FILE", tokenFile.Name())
+		defer os.Unsetenv("BESZEL_AGENT_TOKEN_FILE")

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -422,6 +472,8 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("TOKEN takes precedence over TOKEN_FILE", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Create a temporary token file
 		fileToken := "token-from-file"
 		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
@@ -434,8 +486,12 @@ func TestGetToken(t *testing.T) {

 		// Set both TOKEN and TOKEN_FILE
 		envToken := "token-from-env"
-		t.Setenv("TOKEN", envToken)
-		t.Setenv("TOKEN_FILE", tokenFile.Name())
+		os.Setenv("TOKEN", envToken)
+		os.Setenv("TOKEN_FILE", tokenFile.Name())
+		defer func() {
+			os.Unsetenv("TOKEN")
+			os.Unsetenv("TOKEN_FILE")
+		}()

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -443,10 +499,7 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("error when neither TOKEN nor TOKEN_FILE is set", func(t *testing.T) {
-		t.Setenv("BESZEL_AGENT_TOKEN", "")
-		t.Setenv("TOKEN", "")
-		t.Setenv("BESZEL_AGENT_TOKEN_FILE", "")
-		t.Setenv("TOKEN_FILE", "")
+		unsetEnvVars()

 		token, err := getToken()
 		assert.Error(t, err)
@@ -455,8 +508,11 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("error when TOKEN_FILE points to non-existent file", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Set TOKEN_FILE to a non-existent file
-		t.Setenv("TOKEN_FILE", "/non/existent/file.txt")
+		os.Setenv("TOKEN_FILE", "/non/existent/file.txt")
+		defer os.Unsetenv("TOKEN_FILE")

 		token, err := getToken()
 		assert.Error(t, err)
@@ -465,6 +521,8 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("handles empty token file", func(t *testing.T) {
+		unsetEnvVars()
+
 		// Create an empty token file
 		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
 		require.NoError(t, err)
@@ -472,7 +530,8 @@ func TestGetToken(t *testing.T) {
 		tokenFile.Close()

 		// Set TOKEN_FILE env var
-		t.Setenv("TOKEN_FILE", tokenFile.Name())
+		os.Setenv("TOKEN_FILE", tokenFile.Name())
+		defer os.Unsetenv("TOKEN_FILE")

 		token, err := getToken()
 		assert.NoError(t, err)
@@ -480,6 +539,8 @@ func TestGetToken(t *testing.T) {
 	})

 	t.Run("strips whitespace from TOKEN_FILE", func(t *testing.T) {
+		unsetEnvVars()
+
 		tokenWithWhitespace := "  test-token-with-whitespace  \n\t"
 		expectedToken := "test-token-with-whitespace"
 		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
@@ -490,7 +551,8 @@ func TestGetToken(t *testing.T) {
 		require.NoError(t, err)
 		tokenFile.Close()

-		t.Setenv("TOKEN_FILE", tokenFile.Name())
+		os.Setenv("TOKEN_FILE", tokenFile.Name())
+		defer os.Unsetenv("TOKEN_FILE")

 		token, err := getToken()
 		assert.NoError(t, err)
--- a/agent/connection_manager.go
+++ b/agent/connection_manager.go
@@ -1,18 +1,14 @@
 package agent

 import (
-	"context"
 	"errors"
 	"log/slog"
-	"net"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 	"time"

 	"github.com/henrygd/beszel/agent/health"
-	"github.com/henrygd/beszel/agent/utils"
 	"github.com/henrygd/beszel/internal/entities/system"
 )

@@ -95,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()
@@ -113,38 +109,15 @@ func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
 			_ = c.startWebSocketConnection()
 		case <-healthTicker:
 			_ = health.Update()
-		case <-sigCtx.Done():
-			slog.Info("Shutting down", "cause", context.Cause(sigCtx))
-			return c.stop()
+		case <-sigChan:
+			slog.Info("Shutting down")
+			_ = c.agent.StopServer()
+			c.closeWebSocket()
+			return health.CleanUp()
 		}
 	}
 }

-// stop does not stop the connection manager itself, just any active connections. The manager will attempt to reconnect after stopping, so this should only be called immediately before shutting down the entire agent.
-//
-// If we need or want to expose a graceful Stop method in the future, do something like this to actually stop the manager:
-//
-//	func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
-//		ctx, cancel := context.WithCancel(context.Background())
-//		c.cancel = cancel
-//
-//		for {
-//			select {
-//			case <-ctx.Done():
-//				return c.stop()
-//			}
-//		}
-//	}
-//
-//	func (c *ConnectionManager) Stop() {
-//		c.cancel()
-//	}
-func (c *ConnectionManager) stop() error {
-	_ = c.agent.StopServer()
-	c.closeWebSocket()
-	return health.CleanUp()
-}
-
 // handleEvent processes connection events and updates the connection state accordingly.
 func (c *ConnectionManager) handleEvent(event ConnectionEvent) {
 	switch event {
@@ -212,16 +185,9 @@ func (c *ConnectionManager) connect() {

 	// Try WebSocket first, if it fails, start SSH server
 	err := c.startWebSocketConnection()
-	if err != nil {
-		if shouldExitOnErr(err) {
-			time.Sleep(2 * time.Second) // prevent tight restart loop
-			_ = c.stop()
-			os.Exit(1)
-		}
-		if c.State == Disconnected {
-			c.startSSHServer()
-			c.startWsTicker()
-		}
+	if err != nil && c.State == Disconnected {
+		c.startSSHServer()
+		c.startWsTicker()
 	}
 }

@@ -258,14 +224,3 @@ func (c *ConnectionManager) closeWebSocket() {
 		c.wsClient.Close()
 	}
 }
-
-// shouldExitOnErr checks if the error is a DNS resolution failure and if the
-// EXIT_ON_DNS_ERROR env var is set. https://github.com/henrygd/beszel/issues/1924.
-func shouldExitOnErr(err error) bool {
-	if val, _ := utils.GetEnv("EXIT_ON_DNS_ERROR"); val == "true" {
-		if opErr, ok := errors.AsType[*net.OpError](err); ok {
-			return strings.Contains(opErr.Err.Error(), "lookup")
-		}
-	}
-	return false
-}
--- a/agent/connection_manager_test.go
+++ b/agent/connection_manager_test.go
@@ -1,13 +1,14 @@
 //go:build testing
+// +build testing

 package agent

 import (
 	"crypto/ed25519"
-	"errors"
 	"fmt"
 	"net"
 	"net/url"
+	"os"
 	"testing"
 	"time"

@@ -183,6 +184,10 @@ func TestConnectionManager_TickerManagement(t *testing.T) {

 // TestConnectionManager_WebSocketConnectionFlow tests WebSocket connection logic
 func TestConnectionManager_WebSocketConnectionFlow(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping WebSocket connection test in short mode")
+	}
+
 	agent := createTestAgent(t)
 	cm := agent.connectionManager

@@ -192,18 +197,19 @@ func TestConnectionManager_WebSocketConnectionFlow(t *testing.T) {
 	assert.Equal(t, Disconnected, cm.State, "State should remain Disconnected after failed connection")

 	// Test with invalid URL
-	t.Setenv("BESZEL_AGENT_HUB_URL", "1,33%")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-
-	_, err2 := newWebSocketClient(agent)
-	assert.Error(t, err2, "WebSocket client creation should fail with invalid URL")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "invalid-url")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	// Test with missing token
-	t.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
+	os.Unsetenv("BESZEL_AGENT_TOKEN")

-	_, err3 := newWebSocketClient(agent)
-	assert.Error(t, err3, "WebSocket client creation should fail without token")
+	_, err2 := newWebSocketClient(agent)
+	assert.Error(t, err2, "WebSocket client creation should fail without token")
 }

 // TestConnectionManager_ReconnectionLogic tests reconnection prevention logic
@@ -229,8 +235,12 @@ func TestConnectionManager_ConnectWithRateLimit(t *testing.T) {
 	cm := agent.connectionManager

 	// Set up environment for WebSocket client creation
-	t.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	// Create WebSocket client
 	wsClient, err := newWebSocketClient(agent)
@@ -276,8 +286,12 @@ func TestConnectionManager_CloseWebSocket(t *testing.T) {
 	}, "Should not panic when closing nil WebSocket client")

 	// Set up environment and create WebSocket client
-	t.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
-	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	os.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
+	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
+	defer func() {
+		os.Unsetenv("BESZEL_AGENT_HUB_URL")
+		os.Unsetenv("BESZEL_AGENT_TOKEN")
+	}()

 	wsClient, err := newWebSocketClient(agent)
 	require.NoError(t, err)
@@ -299,65 +313,3 @@ func TestConnectionManager_ConnectFlow(t *testing.T) {
 		cm.connect()
 	}, "Connect should not panic without WebSocket client")
 }
-
-func TestShouldExitOnErr(t *testing.T) {
-	createDialErr := func(msg string) error {
-		return &net.OpError{
-			Op:  "dial",
-			Net: "tcp",
-			Err: errors.New(msg),
-		}
-	}
-
-	tests := []struct {
-		name     string
-		err      error
-		envValue string
-		expected bool
-	}{
-		{
-			name:     "no env var",
-			err:      createDialErr("lookup lkahsdfasdf: no such host"),
-			envValue: "",
-			expected: false,
-		},
-		{
-			name:     "env var false",
-			err:      createDialErr("lookup lkahsdfasdf: no such host"),
-			envValue: "false",
-			expected: false,
-		},
-		{
-			name:     "env var true, matching error",
-			err:      createDialErr("lookup lkahsdfasdf: no such host"),
-			envValue: "true",
-			expected: true,
-		},
-		{
-			name:     "env var true, matching error with extra context",
-			err:      createDialErr("lookup beszel.server.lan on [::1]:53: read udp [::1]:44557->[::1]:53: read: connection refused"),
-			envValue: "true",
-			expected: true,
-		},
-		{
-			name:     "env var true, non-matching error",
-			err:      errors.New("connection refused"),
-			envValue: "true",
-			expected: false,
-		},
-		{
-			name:     "env var true, dial but not lookup",
-			err:      createDialErr("connection timeout"),
-			envValue: "true",
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("EXIT_ON_DNS_ERROR", tt.envValue)
-			result := shouldExitOnErr(tt.err)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
--- a/agent/cpu.go
+++ b/agent/cpu.go
@@ -4,102 +4,34 @@ import (
 	"math"
 	"runtime"

-	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/shirou/gopsutil/v4/cpu"
 )

 var lastCpuTimes = make(map[uint16]cpu.TimesStat)
-var lastPerCoreCpuTimes = make(map[uint16][]cpu.TimesStat)

 // init initializes the CPU monitoring by storing the initial CPU times
 // for the default 60-second cache interval.
 func init() {
-	if times, err := cpu.Times(false); err == nil && len(times) > 0 {
+	if times, err := cpu.Times(false); err == nil {
 		lastCpuTimes[60000] = times[0]
 	}
-	if perCoreTimes, err := cpu.Times(true); err == nil && len(perCoreTimes) > 0 {
-		lastPerCoreCpuTimes[60000] = perCoreTimes
-	}
 }

-// CpuMetrics contains detailed CPU usage breakdown
-type CpuMetrics struct {
-	Total  float64
-	User   float64
-	System float64
-	Iowait float64
-	Steal  float64
-	Idle   float64
-}
-
-// getCpuMetrics calculates detailed CPU usage metrics using cached previous measurements.
-// It returns percentages for total, user, system, iowait, and steal time.
-func getCpuMetrics(cacheTimeMs uint16) (CpuMetrics, error) {
+// getCpuPercent calculates the CPU usage percentage using cached previous measurements.
+// It uses the specified cache time interval to determine the time window for calculation.
+// Returns the CPU usage percentage (0-100) and any error encountered.
+func getCpuPercent(cacheTimeMs uint16) (float64, error) {
 	times, err := cpu.Times(false)
 	if err != nil || len(times) == 0 {
-		return CpuMetrics{}, err
+		return 0, err
 	}
 	// if cacheTimeMs is not in lastCpuTimes, use 60000 as fallback lastCpuTime
 	if _, ok := lastCpuTimes[cacheTimeMs]; !ok {
 		lastCpuTimes[cacheTimeMs] = lastCpuTimes[60000]
 	}
-
-	t1 := lastCpuTimes[cacheTimeMs]
-	t2 := times[0]
-
-	t1All, _ := getAllBusy(t1)
-	t2All, _ := getAllBusy(t2)
-
-	totalDelta := t2All - t1All
-	if totalDelta <= 0 {
-		return CpuMetrics{}, nil
-	}
-
-	metrics := CpuMetrics{
-		Total:  calculateBusy(t1, t2),
-		User:   clampPercent((t2.User - t1.User) / totalDelta * 100),
-		System: clampPercent((t2.System - t1.System) / totalDelta * 100),
-		Iowait: clampPercent((t2.Iowait - t1.Iowait) / totalDelta * 100),
-		Steal:  clampPercent((t2.Steal - t1.Steal) / totalDelta * 100),
-		Idle:   clampPercent((t2.Idle - t1.Idle) / totalDelta * 100),
-	}
-
+	delta := calculateBusy(lastCpuTimes[cacheTimeMs], times[0])
 	lastCpuTimes[cacheTimeMs] = times[0]
-	return metrics, nil
-}
-
-// clampPercent ensures the percentage is between 0 and 100
-func clampPercent(value float64) float64 {
-	return math.Min(100, math.Max(0, value))
-}
-
-// getPerCoreCpuUsage calculates per-core CPU busy usage as integer percentages (0-100).
-// It uses cached previous measurements for the provided cache interval.
-func getPerCoreCpuUsage(cacheTimeMs uint16) (system.Uint8Slice, error) {
-	perCoreTimes, err := cpu.Times(true)
-	if err != nil || len(perCoreTimes) == 0 {
-		return nil, err
-	}
-
-	// Initialize cache if needed
-	if _, ok := lastPerCoreCpuTimes[cacheTimeMs]; !ok {
-		lastPerCoreCpuTimes[cacheTimeMs] = lastPerCoreCpuTimes[60000]
-	}
-
-	lastTimes := lastPerCoreCpuTimes[cacheTimeMs]
-
-	// Limit to the number of cores available in both samples
-	length := min(len(lastTimes), len(perCoreTimes))
-
-	usage := make([]uint8, length)
-	for i := 0; i < length; i++ {
-		t1 := lastTimes[i]
-		t2 := perCoreTimes[i]
-		usage[i] = uint8(math.Round(calculateBusy(t1, t2)))
-	}
-
-	lastPerCoreCpuTimes[cacheTimeMs] = perCoreTimes
-	return usage, nil
+	return delta, nil
 }

 // calculateBusy calculates the CPU busy percentage between two time points.
@@ -109,10 +41,13 @@ func calculateBusy(t1, t2 cpu.TimesStat) float64 {
 	t1All, t1Busy := getAllBusy(t1)
 	t2All, t2Busy := getAllBusy(t2)

-	if t2All <= t1All || t2Busy <= t1Busy {
+	if t2Busy <= t1Busy {
 		return 0
 	}
-	return clampPercent((t2Busy - t1Busy) / (t2All - t1All) * 100)
+	if t2All <= t1All {
+		return 100
+	}
+	return math.Min(100, math.Max(0, (t2Busy-t1Busy)/(t2All-t1All)*100))
 }

 // getAllBusy calculates the total CPU time and busy CPU time from CPU times statistics.
--- a/agent/data_dir.go
+++ b/agent/data_dir.go
@@ -6,19 +6,17 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-
-	"github.com/henrygd/beszel/agent/utils"
 )

-// 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)
 	}

-	dataDir, _ := utils.GetEnv("DATA_DIR")
+	dataDir, _ := GetEnv("DATA_DIR")
 	if dataDir != "" {
 		dataDirs = append(dataDirs, dataDir)
 	}
--- 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)

@@ -39,9 +40,19 @@ func TestGetDataDir(t *testing.T) {
 	t.Run("DATA_DIR environment variable", func(t *testing.T) {
 		tempDir := t.TempDir()

-		t.Setenv("BESZEL_AGENT_DATA_DIR", tempDir)
+		// Set environment variable
+		oldValue := os.Getenv("DATA_DIR")
+		defer func() {
+			if oldValue == "" {
+				os.Unsetenv("BESZEL_AGENT_DATA_DIR")
+			} else {
+				os.Setenv("BESZEL_AGENT_DATA_DIR", oldValue)
+			}
+		}()

-		result, err := GetDataDir()
+		os.Setenv("BESZEL_AGENT_DATA_DIR", tempDir)
+
+		result, err := getDataDir()
 		require.NoError(t, err)
 		assert.Equal(t, tempDir, result)
 	})
@@ -49,15 +60,26 @@ 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)
 	})

 	// Test fallback behavior (empty dataDir, no env var)
 	t.Run("fallback to default directories", func(t *testing.T) {
+		// Clear DATA_DIR environment variable
+		oldValue := os.Getenv("DATA_DIR")
+		defer func() {
+			if oldValue == "" {
+				os.Unsetenv("DATA_DIR")
+			} else {
+				os.Setenv("DATA_DIR", oldValue)
+			}
+		}()
+		os.Unsetenv("DATA_DIR")
+
 		// 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
@@ -1,7 +1,6 @@
 package agent

 import (
-	"context"
 	"log/slog"
 	"os"
 	"path/filepath"
@@ -9,59 +8,11 @@ import (
 	"strings"
 	"time"

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

 	"github.com/shirou/gopsutil/v4/disk"
 )

-// fsRegistrationContext holds the shared lookup state needed to resolve a
-// filesystem into the tracked fsStats key and metadata.
-type fsRegistrationContext struct {
-	filesystem     string // value of optional FILESYSTEM env var
-	isWindows      bool
-	efPath         string // path to extra filesystems (default "/extra-filesystems")
-	diskIoCounters map[string]disk.IOCountersStat
-}
-
-// diskDiscovery groups the transient state for a single initializeDiskInfo run so
-// helper methods can share the same partitions, mount paths, and lookup functions
-type diskDiscovery struct {
-	agent          *Agent
-	rootMountPoint string
-	partitions     []disk.PartitionStat
-	usageFn        func(string) (*disk.UsageStat, error)
-	ctx            fsRegistrationContext
-}
-
-// prevDisk stores previous per-device disk counters for a given cache interval
-type prevDisk struct {
-	readBytes  uint64
-	writeBytes uint64
-	readTime   uint64 // cumulative ms spent on reads (from ReadTime)
-	writeTime  uint64 // cumulative ms spent on writes (from WriteTime)
-	ioTime     uint64 // cumulative ms spent doing I/O (from IoTime)
-	weightedIO uint64 // cumulative weighted ms (queue-depth × ms, from WeightedIO)
-	readCount  uint64 // cumulative read operation count
-	writeCount uint64 // cumulative write operation count
-	at         time.Time
-}
-
-// prevDiskFromCounter creates a prevDisk snapshot from a disk.IOCountersStat at time t.
-func prevDiskFromCounter(d disk.IOCountersStat, t time.Time) prevDisk {
-	return prevDisk{
-		readBytes:  d.ReadBytes,
-		writeBytes: d.WriteBytes,
-		readTime:   d.ReadTime,
-		writeTime:  d.WriteTime,
-		ioTime:     d.IoTime,
-		weightedIO: d.WeightedIO,
-		readCount:  d.ReadCount,
-		writeCount: d.WriteCount,
-		at:         t,
-	}
-}
-
 // parseFilesystemEntry parses a filesystem entry in the format "device__customname"
 // Returns the device/filesystem part and the custom name part
 func parseFilesystemEntry(entry string) (device, customName string) {
@@ -75,465 +26,176 @@ func parseFilesystemEntry(entry string) (device, customName string) {
 	return device, customName
 }

-// extraFilesystemPartitionInfo derives the I/O device and optional display name
-// for a mounted /extra-filesystems partition. Prefer the partition device reported
-// by the system and only use the folder name for custom naming metadata.
-func extraFilesystemPartitionInfo(p disk.PartitionStat) (device, customName string) {
-	device = strings.TrimSpace(p.Device)
-	folderDevice, customName := parseFilesystemEntry(filepath.Base(p.Mountpoint))
-	if device == "" {
-		device = folderDevice
-	}
-	return device, customName
-}
-
-func isDockerSpecialMountpoint(mountpoint string) bool {
-	switch mountpoint {
-	case "/etc/hosts", "/etc/resolv.conf", "/etc/hostname":
-		return true
-	}
-	return false
-}
-
-// registerFilesystemStats resolves the tracked key and stats payload for a
-// filesystem before it is inserted into fsStats.
-func registerFilesystemStats(existing map[string]*system.FsStats, device, mountpoint string, root bool, customName string, ctx fsRegistrationContext) (string, *system.FsStats, bool) {
-	key := device
-	if !ctx.isWindows {
-		key = filepath.Base(device)
-	}
-
-	if root {
-		// Try to map root device to a diskIoCounters entry. First checks for an
-		// exact key match, then uses findIoDevice for normalized / prefix-based
-		// matching (e.g. nda0p2 -> nda0), and finally falls back to FILESYSTEM.
-		if _, ioMatch := ctx.diskIoCounters[key]; !ioMatch {
-			if matchedKey, match := findIoDevice(key, ctx.diskIoCounters); match {
-				key = matchedKey
-			} else if ctx.filesystem != "" {
-				if matchedKey, match := findIoDevice(ctx.filesystem, ctx.diskIoCounters); match {
-					key = matchedKey
-				}
-			}
-			if _, ioMatch = ctx.diskIoCounters[key]; !ioMatch {
-				slog.Warn("Root I/O unmapped; set FILESYSTEM", "device", device, "mountpoint", mountpoint)
-			}
-		}
-	} else {
-		// Check if non-root has diskstats and prefer the folder device for
-		// /extra-filesystems mounts when the discovered partition device is a
-		// mapper path (e.g. luks UUID) that obscures the underlying block device.
-		if _, ioMatch := ctx.diskIoCounters[key]; !ioMatch {
-			if strings.HasPrefix(mountpoint, ctx.efPath) {
-				folderDevice, _ := parseFilesystemEntry(filepath.Base(mountpoint))
-				if folderDevice != "" {
-					if matchedKey, match := findIoDevice(folderDevice, ctx.diskIoCounters); match {
-						key = matchedKey
-					}
-				}
-			}
-			if _, ioMatch = ctx.diskIoCounters[key]; !ioMatch {
-				if matchedKey, match := findIoDevice(key, ctx.diskIoCounters); match {
-					key = matchedKey
-				}
-			}
-		}
-	}
-
-	if _, exists := existing[key]; exists {
-		return "", nil, false
-	}
-
-	fsStats := &system.FsStats{Root: root, Mountpoint: mountpoint}
-	if customName != "" {
-		fsStats.Name = customName
-	}
-	return key, fsStats, true
-}
-
-// addFsStat inserts a discovered filesystem if it resolves to a new tracking
-// key. The key selection itself lives in buildFsStatRegistration so that logic
-// can stay directly unit-tested.
-func (d *diskDiscovery) addFsStat(device, mountpoint string, root bool, customName string) {
-	key, fsStats, ok := registerFilesystemStats(d.agent.fsStats, device, mountpoint, root, customName, d.ctx)
-	if !ok {
-		return
-	}
-	d.agent.fsStats[key] = fsStats
-	name := key
-	if customName != "" {
-		name = customName
-	}
-	slog.Info("Detected disk", "name", name, "device", device, "mount", mountpoint, "io", key, "root", root)
-}
-
-// addConfiguredRootFs resolves FILESYSTEM against partitions first, then falls
-// back to direct diskstats matching for setups like ZFS where partitions do not
-// expose the physical device name.
-func (d *diskDiscovery) addConfiguredRootFs() bool {
-	if d.ctx.filesystem == "" {
-		return false
-	}
-
-	for _, p := range d.partitions {
-		if filesystemMatchesPartitionSetting(d.ctx.filesystem, p) {
-			d.addFsStat(p.Device, p.Mountpoint, true, "")
-			return true
-		}
-	}
-
-	// FILESYSTEM may name a physical disk absent from partitions (e.g. ZFS lists
-	// dataset paths like zroot/ROOT/default, not block devices).
-	if ioKey, match := findIoDevice(d.ctx.filesystem, d.ctx.diskIoCounters); match {
-		d.agent.fsStats[ioKey] = &system.FsStats{Root: true, Mountpoint: d.rootMountPoint}
-		return true
-	}
-
-	slog.Warn("Partition details not found", "filesystem", d.ctx.filesystem)
-	return false
-}
-
-func isRootFallbackPartition(p disk.PartitionStat, rootMountPoint string) bool {
-	return p.Mountpoint == rootMountPoint ||
-		(isDockerSpecialMountpoint(p.Mountpoint) && strings.HasPrefix(p.Device, "/dev"))
-}
-
-// addPartitionRootFs handles the non-configured root fallback path when a
-// partition looks like the active root mount but still needs translating to an
-// I/O device key.
-func (d *diskDiscovery) addPartitionRootFs(device, mountpoint string) bool {
-	fs, match := findIoDevice(filepath.Base(device), d.ctx.diskIoCounters)
-	if !match {
-		return false
-	}
-	// The resolved I/O device is already known here, so use it directly to avoid
-	// a second fallback search inside buildFsStatRegistration.
-	d.addFsStat(fs, mountpoint, true, "")
-	return true
-}
-
-// addLastResortRootFs is only used when neither FILESYSTEM nor partition-based
-// heuristics can identify root, so it picks the busiest I/O device as a final
-// fallback and preserves the root mountpoint for usage collection.
-func (d *diskDiscovery) addLastResortRootFs() {
-	rootKey := mostActiveIoDevice(d.ctx.diskIoCounters)
-	if rootKey != "" {
-		slog.Warn("Using most active device for root I/O; set FILESYSTEM to override", "device", rootKey)
-	} else {
-		rootKey = filepath.Base(d.rootMountPoint)
-		if _, exists := d.agent.fsStats[rootKey]; exists {
-			rootKey = "root"
-		}
-		slog.Warn("Root I/O device not detected; set FILESYSTEM to override")
-	}
-	d.agent.fsStats[rootKey] = &system.FsStats{Root: true, Mountpoint: d.rootMountPoint}
-}
-
-// findPartitionByFilesystemSetting matches an EXTRA_FILESYSTEMS entry against a
-// discovered partition either by mountpoint or by device suffix.
-func findPartitionByFilesystemSetting(filesystem string, partitions []disk.PartitionStat) (disk.PartitionStat, bool) {
-	for _, p := range partitions {
-		if strings.HasSuffix(p.Device, filesystem) || p.Mountpoint == filesystem {
-			return p, true
-		}
-	}
-	return disk.PartitionStat{}, false
-}
-
-// addConfiguredExtraFsEntry resolves one EXTRA_FILESYSTEMS entry, preferring a
-// discovered partition and falling back to any path that disk.Usage accepts.
-func (d *diskDiscovery) addConfiguredExtraFsEntry(filesystem, customName string) {
-	if p, found := findPartitionByFilesystemSetting(filesystem, d.partitions); found {
-		d.addFsStat(p.Device, p.Mountpoint, false, customName)
-		return
-	}
-
-	if _, err := d.usageFn(filesystem); err == nil {
-		d.addFsStat(filepath.Base(filesystem), filesystem, false, customName)
-		return
-	} else {
-		slog.Error("Invalid filesystem", "name", filesystem, "err", err)
-	}
-}
-
-// addConfiguredExtraFilesystems parses and registers the comma-separated
-// EXTRA_FILESYSTEMS env var entries.
-func (d *diskDiscovery) addConfiguredExtraFilesystems(extraFilesystems string) {
-	for fsEntry := range strings.SplitSeq(extraFilesystems, ",") {
-		filesystem, customName := parseFilesystemEntry(fsEntry)
-		d.addConfiguredExtraFsEntry(filesystem, customName)
-	}
-}
-
-// addPartitionExtraFs registers partitions mounted under /extra-filesystems so
-// their display names can come from the folder name while their I/O keys still
-// prefer the underlying partition device. Only direct children are matched to
-// avoid registering nested virtual mounts (e.g. /proc, /sys) that are returned by
-// disk.Partitions(true) when the host root is bind-mounted in /extra-filesystems.
-func (d *diskDiscovery) addPartitionExtraFs(p disk.PartitionStat) {
-	if filepath.Dir(p.Mountpoint) != d.ctx.efPath {
-		return
-	}
-	device, customName := extraFilesystemPartitionInfo(p)
-	d.addFsStat(device, p.Mountpoint, false, customName)
-}
-
-// addExtraFilesystemFolders handles bare directories under /extra-filesystems
-// that may not appear in partition discovery, while skipping mountpoints that
-// were already registered from higher-fidelity sources.
-func (d *diskDiscovery) addExtraFilesystemFolders(folderNames []string) {
-	existingMountpoints := make(map[string]bool, len(d.agent.fsStats))
-	for _, stats := range d.agent.fsStats {
-		existingMountpoints[stats.Mountpoint] = true
-	}
-
-	for _, folderName := range folderNames {
-		mountpoint := filepath.Join(d.ctx.efPath, folderName)
-		slog.Debug("/extra-filesystems", "mountpoint", mountpoint)
-		if existingMountpoints[mountpoint] {
-			continue
-		}
-		device, customName := parseFilesystemEntry(folderName)
-		d.addFsStat(device, mountpoint, false, customName)
-	}
-}
-
 // Sets up the filesystems to monitor for disk usage and I/O.
 func (a *Agent) initializeDiskInfo() {
-	filesystem, _ := utils.GetEnv("FILESYSTEM")
+	filesystem, _ := GetEnv("FILESYSTEM")
+	efPath := "/extra-filesystems"
 	hasRoot := false
-	isWindows := runtime.GOOS == "windows"

-	partitions, err := disk.PartitionsWithContext(context.Background(), true)
+	partitions, err := disk.Partitions(false)
 	if err != nil {
 		slog.Error("Error getting disk partitions", "err", err)
 	}
 	slog.Debug("Disk", "partitions", partitions)

-	// trim trailing backslash for Windows devices (#1361)
-	if isWindows {
-		for i, p := range partitions {
-			partitions[i].Device = strings.TrimSuffix(p.Device, "\\")
-		}
-	}
+	// ioContext := context.WithValue(a.sensorsContext,
+	// 	common.EnvKey, common.EnvMap{common.HostProcEnvKey: "/tmp/testproc"},
+	// )
+	// diskIoCounters, err := disk.IOCountersWithContext(ioContext)

 	diskIoCounters, err := disk.IOCounters()
 	if err != nil {
 		slog.Error("Error getting diskstats", "err", err)
 	}
 	slog.Debug("Disk I/O", "diskstats", diskIoCounters)
-	ctx := fsRegistrationContext{
-		filesystem:     filesystem,
-		isWindows:      isWindows,
-		diskIoCounters: diskIoCounters,
-		efPath:         "/extra-filesystems",
+
+	// Helper function to add a filesystem to fsStats if it doesn't exist
+	addFsStat := func(device, mountpoint string, root bool, customName ...string) {
+		var key string
+		if runtime.GOOS == "windows" {
+			key = device
+		} else {
+			key = filepath.Base(device)
+		}
+		var ioMatch bool
+		if _, exists := a.fsStats[key]; !exists {
+			if root {
+				slog.Info("Detected root device", "name", key)
+				// Check if root device is in /proc/diskstats, use fallback if not
+				if _, ioMatch = diskIoCounters[key]; !ioMatch {
+					key, ioMatch = findIoDevice(filesystem, diskIoCounters, a.fsStats)
+					if !ioMatch {
+						slog.Info("Using I/O fallback", "device", device, "mountpoint", mountpoint, "fallback", key)
+					}
+				}
+			} else {
+				// Check if non-root has diskstats and fall back to folder name if not
+				// Scenario: device is encrypted and named luks-2bcb02be-999d-4417-8d18-5c61e660fb6e - not in /proc/diskstats.
+				// However, the device can be specified by mounting folder from luks device at /extra-filesystems/sda1
+				if _, ioMatch = diskIoCounters[key]; !ioMatch {
+					efBase := filepath.Base(mountpoint)
+					if _, ioMatch = diskIoCounters[efBase]; ioMatch {
+						key = efBase
+					}
+				}
+			}
+			fsStats := &system.FsStats{Root: root, Mountpoint: mountpoint}
+			if len(customName) > 0 && customName[0] != "" {
+				fsStats.Name = customName[0]
+			}
+			a.fsStats[key] = fsStats
+		}
 	}

-	// Get the appropriate root mount point for this system
-	discovery := diskDiscovery{
-		agent:          a,
-		rootMountPoint: a.getRootMountPoint(),
-		partitions:     partitions,
-		usageFn:        disk.Usage,
-		ctx:            ctx,
+	// Use FILESYSTEM env var to find root filesystem
+	if filesystem != "" {
+		for _, p := range partitions {
+			if strings.HasSuffix(p.Device, filesystem) || p.Mountpoint == filesystem {
+				addFsStat(p.Device, p.Mountpoint, true)
+				hasRoot = true
+				break
+			}
+		}
+		if !hasRoot {
+			slog.Warn("Partition details not found", "filesystem", filesystem)
+		}
 	}

-	hasRoot = discovery.addConfiguredRootFs()
-
 	// Add EXTRA_FILESYSTEMS env var values to fsStats
-	if extraFilesystems, exists := utils.GetEnv("EXTRA_FILESYSTEMS"); exists {
-		discovery.addConfiguredExtraFilesystems(extraFilesystems)
+	if extraFilesystems, exists := GetEnv("EXTRA_FILESYSTEMS"); exists {
+		for _, fsEntry := range strings.Split(extraFilesystems, ",") {
+			// Parse custom name from format: device__customname
+			fs, customName := parseFilesystemEntry(fsEntry)
+
+			found := false
+			for _, p := range partitions {
+				if strings.HasSuffix(p.Device, fs) || p.Mountpoint == fs {
+					addFsStat(p.Device, p.Mountpoint, false, customName)
+					found = true
+					break
+				}
+			}
+			// if not in partitions, test if we can get disk usage
+			if !found {
+				if _, err := disk.Usage(fs); err == nil {
+					addFsStat(filepath.Base(fs), fs, false, customName)
+				} else {
+					slog.Error("Invalid filesystem", "name", fs, "err", err)
+				}
+			}
+		}
 	}

 	// Process partitions for various mount points
 	for _, p := range partitions {
-		if !hasRoot && isRootFallbackPartition(p, discovery.rootMountPoint) {
-			hasRoot = discovery.addPartitionRootFs(p.Device, p.Mountpoint)
+		// fmt.Println(p.Device, p.Mountpoint)
+		// Binary root fallback or docker root fallback
+		if !hasRoot && (p.Mountpoint == "/" || (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
+			}
+		}
+
+		// Check if device is in /extra-filesystems
+		if strings.HasPrefix(p.Mountpoint, efPath) {
+			device, customName := parseFilesystemEntry(p.Mountpoint)
+			addFsStat(device, p.Mountpoint, false, customName)
 		}
-		discovery.addPartitionExtraFs(p)
 	}

 	// Check all folders in /extra-filesystems and add them if not already present
-	if folders, err := os.ReadDir(discovery.ctx.efPath); err == nil {
-		folderNames := make([]string, 0, len(folders))
+	if folders, err := os.ReadDir(efPath); err == nil {
+		existingMountpoints := make(map[string]bool)
+		for _, stats := range a.fsStats {
+			existingMountpoints[stats.Mountpoint] = true
+		}
 		for _, folder := range folders {
 			if folder.IsDir() {
-				folderNames = append(folderNames, folder.Name())
+				mountpoint := filepath.Join(efPath, folder.Name())
+				slog.Debug("/extra-filesystems", "mountpoint", mountpoint)
+				if !existingMountpoints[mountpoint] {
+					device, customName := parseFilesystemEntry(folder.Name())
+					addFsStat(device, mountpoint, false, customName)
+				}
 			}
 		}
-		discovery.addExtraFilesystemFolders(folderNames)
 	}

-	// If no root filesystem set, try the most active I/O device as a last
-	// resort (e.g. ZFS where dataset names are unrelated to disk names).
+	// If no root filesystem set, use fallback
 	if !hasRoot {
-		discovery.addLastResortRootFs()
+		rootDevice, _ := findIoDevice(filepath.Base(filesystem), diskIoCounters, a.fsStats)
+		slog.Info("Root disk", "mountpoint", "/", "io", rootDevice)
+		a.fsStats[rootDevice] = &system.FsStats{Root: true, Mountpoint: "/"}
 	}

-	a.pruneDuplicateRootExtraFilesystems()
 	a.initializeDiskIoStats(diskIoCounters)
 }

-// Removes extra filesystems that mirror root usage (https://github.com/henrygd/beszel/issues/1428).
-func (a *Agent) pruneDuplicateRootExtraFilesystems() {
-	var rootMountpoint string
-	for _, stats := range a.fsStats {
-		if stats != nil && stats.Root {
-			rootMountpoint = stats.Mountpoint
-			break
-		}
-	}
-	if rootMountpoint == "" {
-		return
-	}
-	rootUsage, err := disk.Usage(rootMountpoint)
-	if err != nil {
-		return
-	}
-	for name, stats := range a.fsStats {
-		if stats == nil || stats.Root {
-			continue
-		}
-		extraUsage, err := disk.Usage(stats.Mountpoint)
-		if err != nil {
-			continue
-		}
-		if hasSameDiskUsage(rootUsage, extraUsage) {
-			slog.Info("Ignoring duplicate FS", "name", name, "mount", stats.Mountpoint)
-			delete(a.fsStats, name)
-		}
-	}
-}
-
-// hasSameDiskUsage compares root/extra usage with a small byte tolerance.
-func hasSameDiskUsage(a, b *disk.UsageStat) bool {
-	if a == nil || b == nil || a.Total == 0 || b.Total == 0 {
-		return false
-	}
-	// Allow minor drift between sequential disk usage calls.
-	const toleranceBytes uint64 = 16 * 1024 * 1024
-	return withinUsageTolerance(a.Total, b.Total, toleranceBytes) &&
-		withinUsageTolerance(a.Used, b.Used, toleranceBytes)
-}
-
-// withinUsageTolerance reports whether two byte values differ by at most tolerance.
-func withinUsageTolerance(a, b, tolerance uint64) bool {
-	if a >= b {
-		return a-b <= tolerance
-	}
-	return b-a <= tolerance
-}
-
-type ioMatchCandidate struct {
-	name  string
-	bytes uint64
-	ops   uint64
-}
-
-// findIoDevice prefers exact device/label matches, then falls back to a
-// prefix-related candidate with the highest recent activity.
-func findIoDevice(filesystem string, diskIoCounters map[string]disk.IOCountersStat) (string, bool) {
-	filesystem = normalizeDeviceName(filesystem)
-	if filesystem == "" {
-		return "", false
-	}
-
-	candidates := []ioMatchCandidate{}
-
+// 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, fsStats map[string]*system.FsStats) (string, bool) {
+	var maxReadBytes uint64
+	maxReadDevice := "/"
 	for _, d := range diskIoCounters {
-		if normalizeDeviceName(d.Name) == filesystem || (d.Label != "" && normalizeDeviceName(d.Label) == filesystem) {
+		if d.Name == filesystem || (d.Label != "" && d.Label == filesystem) {
 			return d.Name, true
 		}
-		if prefixRelated(normalizeDeviceName(d.Name), filesystem) ||
-			(d.Label != "" && prefixRelated(normalizeDeviceName(d.Label), filesystem)) {
-			candidates = append(candidates, ioMatchCandidate{
-				name:  d.Name,
-				bytes: d.ReadBytes + d.WriteBytes,
-				ops:   d.ReadCount + d.WriteCount,
-			})
+		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
+			}
 		}
 	}
-
-	if len(candidates) == 0 {
-		return "", false
-	}
-
-	best := candidates[0]
-	for _, c := range candidates[1:] {
-		if c.bytes > best.bytes ||
-			(c.bytes == best.bytes && c.ops > best.ops) ||
-			(c.bytes == best.bytes && c.ops == best.ops && c.name < best.name) {
-			best = c
-		}
-	}
-
-	slog.Info("Using disk I/O fallback", "requested", filesystem, "selected", best.name)
-	return best.name, true
-}
-
-// mostActiveIoDevice returns the device with the highest I/O activity,
-// or "" if diskIoCounters is empty.
-func mostActiveIoDevice(diskIoCounters map[string]disk.IOCountersStat) string {
-	var best ioMatchCandidate
-	for _, d := range diskIoCounters {
-		c := ioMatchCandidate{
-			name:  d.Name,
-			bytes: d.ReadBytes + d.WriteBytes,
-			ops:   d.ReadCount + d.WriteCount,
-		}
-		if best.name == "" || c.bytes > best.bytes ||
-			(c.bytes == best.bytes && c.ops > best.ops) ||
-			(c.bytes == best.bytes && c.ops == best.ops && c.name < best.name) {
-			best = c
-		}
-	}
-	return best.name
-}
-
-// prefixRelated reports whether either identifier is a prefix of the other.
-func prefixRelated(a, b string) bool {
-	if a == "" || b == "" || a == b {
-		return false
-	}
-	return strings.HasPrefix(a, b) || strings.HasPrefix(b, a)
-}
-
-// filesystemMatchesPartitionSetting checks whether a FILESYSTEM env var value
-// matches a partition by mountpoint, exact device name, or prefix relationship
-// (e.g. FILESYSTEM=ada0 matches partition /dev/ada0p2).
-func filesystemMatchesPartitionSetting(filesystem string, p disk.PartitionStat) bool {
-	filesystem = strings.TrimSpace(filesystem)
-	if filesystem == "" {
-		return false
-	}
-	if p.Mountpoint == filesystem {
-		return true
-	}
-
-	fsName := normalizeDeviceName(filesystem)
-	partName := normalizeDeviceName(p.Device)
-	if fsName == "" || partName == "" {
-		return false
-	}
-	if fsName == partName {
-		return true
-	}
-	return prefixRelated(partName, fsName)
-}
-
-// normalizeDeviceName canonicalizes device strings for comparisons.
-func normalizeDeviceName(value string) string {
-	name := filepath.Base(strings.TrimSpace(value))
-	if name == "." {
-		return ""
-	}
-	return name
+	return maxReadDevice, false
 }

 // Sets start values for disk I/O stats.
 func (a *Agent) initializeDiskIoStats(diskIoCounters map[string]disk.IOCountersStat) {
-	a.fsNames = a.fsNames[:0]
-	now := time.Now()
 	for device, stats := range a.fsStats {
 		// skip if not in diskIoCounters
 		d, exists := diskIoCounters[device]
@@ -542,7 +204,7 @@ func (a *Agent) initializeDiskIoStats(diskIoCounters map[string]disk.IOCountersS
 			continue
 		}
 		// populate initial values
-		stats.Time = now
+		stats.Time = time.Now()
 		stats.TotalRead = d.ReadBytes
 		stats.TotalWrite = d.WriteBytes
 		// add to list of valid io device names
@@ -552,26 +214,15 @@ 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 = utils.BytesToGigabytes(d.Total)
-			stats.DiskUsed = utils.BytesToGigabytes(d.Used)
+			stats.DiskTotal = bytesToGigabytes(d.Total)
+			stats.DiskUsed = bytesToGigabytes(d.Used)
 			if stats.Root {
-				systemStats.DiskTotal = utils.BytesToGigabytes(d.Total)
-				systemStats.DiskUsed = utils.BytesToGigabytes(d.Used)
-				systemStats.DiskPct = utils.TwoDecimals(d.UsedPercent)
+				systemStats.DiskTotal = bytesToGigabytes(d.Total)
+				systemStats.DiskUsed = bytesToGigabytes(d.Used)
+				systemStats.DiskPct = twoDecimals(d.UsedPercent)
 			}
 		} else {
 			// reset stats if error (likely unmounted)
@@ -582,11 +233,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
@@ -609,72 +255,36 @@ func (a *Agent) updateDiskIo(cacheTimeMs uint16, systemStats *system.Stats) {
 			prev, hasPrev := a.diskPrev[cacheTimeMs][name]
 			if !hasPrev {
 				// Seed from agent-level fsStats if present, else seed from current
-				prev = prevDisk{
-					readBytes:  stats.TotalRead,
-					writeBytes: stats.TotalWrite,
-					readTime:   d.ReadTime,
-					writeTime:  d.WriteTime,
-					ioTime:     d.IoTime,
-					weightedIO: d.WeightedIO,
-					readCount:  d.ReadCount,
-					writeCount: d.WriteCount,
-					at:         stats.Time,
-				}
+				prev = prevDisk{readBytes: stats.TotalRead, writeBytes: stats.TotalWrite, at: stats.Time}
 				if prev.at.IsZero() {
-					prev = prevDiskFromCounter(d, now)
+					prev = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
 				}
 			}

 			msElapsed := uint64(now.Sub(prev.at).Milliseconds())
-
-			// Update per-interval snapshot
-			a.diskPrev[cacheTimeMs][name] = prevDiskFromCounter(d, now)
-
-			// Avoid division by zero or clock issues
 			if msElapsed < 100 {
+				// Avoid division by zero or clock issues; update snapshot and continue
+				a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
 				continue
 			}

 			diskIORead := (d.ReadBytes - prev.readBytes) * 1000 / msElapsed
 			diskIOWrite := (d.WriteBytes - prev.writeBytes) * 1000 / msElapsed
-			readMbPerSecond := utils.BytesToMegabytes(float64(diskIORead))
-			writeMbPerSecond := utils.BytesToMegabytes(float64(diskIOWrite))
+			readMbPerSecond := bytesToMegabytes(float64(diskIORead))
+			writeMbPerSecond := bytesToMegabytes(float64(diskIOWrite))

 			// validate values
 			if readMbPerSecond > 50_000 || writeMbPerSecond > 50_000 {
 				slog.Warn("Invalid disk I/O. Resetting.", "name", d.Name, "read", readMbPerSecond, "write", writeMbPerSecond)
+				// Reset interval snapshot and seed from current
+				a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
 				// also refresh agent baseline to avoid future negatives
 				a.initializeDiskIoStats(ioCounters)
 				continue
 			}

-			// These properties are calculated differently on different platforms,
-			// but generally represent cumulative time spent doing reads/writes on the device.
-			// This can surpass 100% if there are multiple concurrent I/O operations.
-			// Linux kernel docs:
-			// This is the total number of milliseconds spent by all reads (as
-			// measured from __make_request() to end_that_request_last()).
-			// https://www.kernel.org/doc/Documentation/iostats.txt (fields 4, 8)
-			diskReadTime := utils.TwoDecimals(float64(d.ReadTime-prev.readTime) / float64(msElapsed) * 100)
-			diskWriteTime := utils.TwoDecimals(float64(d.WriteTime-prev.writeTime) / float64(msElapsed) * 100)
-
-			// I/O utilization %: fraction of wall time the device had any I/O in progress (0-100).
-			diskIoUtilPct := utils.TwoDecimals(float64(d.IoTime-prev.ioTime) / float64(msElapsed) * 100)
-
-			// Weighted I/O: queue-depth weighted I/O time, normalized to interval (can exceed 100%).
-			// Linux kernel field 11: incremented by iops_in_progress × ms_since_last_update.
-			// Used to display queue depth. Multipled by 100 to increase accuracy of digit truncation (divided by 100 in UI).
-			diskWeightedIO := utils.TwoDecimals(float64(d.WeightedIO-prev.weightedIO) / float64(msElapsed) * 100)
-
-			// r_await / w_await: average time per read/write operation in milliseconds.
-			// Equivalent to r_await and w_await in iostat.
-			var rAwait, wAwait float64
-			if deltaReadCount := d.ReadCount - prev.readCount; deltaReadCount > 0 {
-				rAwait = utils.TwoDecimals(float64(d.ReadTime-prev.readTime) / float64(deltaReadCount))
-			}
-			if deltaWriteCount := d.WriteCount - prev.writeCount; deltaWriteCount > 0 {
-				wAwait = utils.TwoDecimals(float64(d.WriteTime-prev.writeTime) / float64(deltaWriteCount))
-			}
+			// Update per-interval snapshot
+			a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}

 			// Update global fsStats baseline for cross-interval correctness
 			stats.Time = now
@@ -684,62 +294,13 @@ func (a *Agent) updateDiskIo(cacheTimeMs uint16, systemStats *system.Stats) {
 			stats.DiskWritePs = writeMbPerSecond
 			stats.DiskReadBytes = diskIORead
 			stats.DiskWriteBytes = diskIOWrite
-			stats.DiskIoStats[0] = diskReadTime
-			stats.DiskIoStats[1] = diskWriteTime
-			stats.DiskIoStats[2] = diskIoUtilPct
-			stats.DiskIoStats[3] = rAwait
-			stats.DiskIoStats[4] = wAwait
-			stats.DiskIoStats[5] = diskWeightedIO

 			if stats.Root {
 				systemStats.DiskReadPs = stats.DiskReadPs
 				systemStats.DiskWritePs = stats.DiskWritePs
 				systemStats.DiskIO[0] = diskIORead
 				systemStats.DiskIO[1] = diskIOWrite
-				systemStats.DiskIoStats[0] = diskReadTime
-				systemStats.DiskIoStats[1] = diskWriteTime
-				systemStats.DiskIoStats[2] = diskIoUtilPct
-				systemStats.DiskIoStats[3] = rAwait
-				systemStats.DiskIoStats[4] = wAwait
-				systemStats.DiskIoStats[5] = diskWeightedIO
 			}
 		}
 	}
 }
-
-// getRootMountPoint returns the appropriate root mount point for the system.
-// On Windows it returns the system drive (e.g. "C:").
-// For immutable systems like Fedora Silverblue, it returns /sysroot instead of /
-func (a *Agent) getRootMountPoint() string {
-	if runtime.GOOS == "windows" {
-		if sd := os.Getenv("SystemDrive"); sd != "" {
-			return sd
-		}
-		return "C:"
-	}
-
-	// 1. Check if /etc/os-release contains indicators of an immutable system
-	if osReleaseContent, err := os.ReadFile("/etc/os-release"); err == nil {
-		content := string(osReleaseContent)
-		if strings.Contains(content, "fedora") && strings.Contains(content, "silverblue") ||
-			strings.Contains(content, "coreos") ||
-			strings.Contains(content, "flatcar") ||
-			strings.Contains(content, "rhel-atomic") ||
-			strings.Contains(content, "centos-atomic") {
-			// Verify that /sysroot exists before returning it
-			if _, err := os.Stat("/sysroot"); err == nil {
-				return "/sysroot"
-			}
-		}
-	}
-
-	// 2. Check if /run/ostree is present (ostree-based systems like Silverblue)
-	if _, err := os.Stat("/run/ostree"); err == nil {
-		// Verify that /sysroot exists before returning it
-		if _, err := os.Stat("/sysroot"); err == nil {
-			return "/sysroot"
-		}
-	}
-
-	return "/"
-}
--- 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,683 +93,19 @@ func TestParseFilesystemEntry(t *testing.T) {
 	}
 }

-func TestExtraFilesystemPartitionInfo(t *testing.T) {
-	t.Run("uses partition device for label-only mountpoint", func(t *testing.T) {
-		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
-			Device:     "/dev/sdc",
-			Mountpoint: "/extra-filesystems/Share",
-		})
-
-		assert.Equal(t, "/dev/sdc", device)
-		assert.Equal(t, "", customName)
-	})
-
-	t.Run("uses custom name from mountpoint suffix", func(t *testing.T) {
-		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
-			Device:     "/dev/sdc",
-			Mountpoint: "/extra-filesystems/sdc__Share",
-		})
-
-		assert.Equal(t, "/dev/sdc", device)
-		assert.Equal(t, "Share", customName)
-	})
-
-	t.Run("falls back to folder device when partition device is unavailable", func(t *testing.T) {
-		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
-			Mountpoint: "/extra-filesystems/sdc__Share",
-		})
-
-		assert.Equal(t, "sdc", device)
-		assert.Equal(t, "Share", customName)
-	})
-
-	t.Run("supports custom name without folder device prefix", func(t *testing.T) {
-		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
-			Device:     "/dev/sdc",
-			Mountpoint: "/extra-filesystems/__Share",
-		})
-
-		assert.Equal(t, "/dev/sdc", device)
-		assert.Equal(t, "Share", customName)
-	})
-}
-
-func TestBuildFsStatRegistration(t *testing.T) {
-	t.Run("uses basename for non-windows exact io match", func(t *testing.T) {
-		key, stats, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			"/dev/sda1",
-			"/mnt/data",
-			false,
-			"archive",
-			fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"sda1": {Name: "sda1"},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, "sda1", key)
-		assert.Equal(t, "/mnt/data", stats.Mountpoint)
-		assert.Equal(t, "archive", stats.Name)
-		assert.False(t, stats.Root)
-	})
-
-	t.Run("maps root partition to io device by prefix", func(t *testing.T) {
-		key, stats, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			"/dev/ada0p2",
-			"/",
-			true,
-			"",
-			fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"ada0": {Name: "ada0", ReadBytes: 1000, WriteBytes: 1000},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, "ada0", key)
-		assert.True(t, stats.Root)
-		assert.Equal(t, "/", stats.Mountpoint)
-	})
-
-	t.Run("uses filesystem setting as root fallback", func(t *testing.T) {
-		key, _, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			"overlay",
-			"/",
-			true,
-			"",
-			fsRegistrationContext{
-				filesystem: "nvme0n1p2",
-				isWindows:  false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"nvme0n1": {Name: "nvme0n1", ReadBytes: 1000, WriteBytes: 1000},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, "nvme0n1", key)
-	})
-
-	t.Run("prefers parsed extra-filesystems device over mapper device", func(t *testing.T) {
-		key, stats, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			"/dev/mapper/luks-2bcb02be-999d-4417-8d18-5c61e660fb6e",
-			"/extra-filesystems/nvme0n1p2__Archive",
-			false,
-			"Archive",
-			fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"dm-1":      {Name: "dm-1", Label: "luks-2bcb02be-999d-4417-8d18-5c61e660fb6e"},
-					"nvme0n1p2": {Name: "nvme0n1p2"},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, "nvme0n1p2", key)
-		assert.Equal(t, "Archive", stats.Name)
-	})
-
-	t.Run("falls back to mapper io device when folder device cannot be resolved", func(t *testing.T) {
-		key, stats, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			"/dev/mapper/luks-2bcb02be-999d-4417-8d18-5c61e660fb6e",
-			"/extra-filesystems/Archive",
-			false,
-			"Archive",
-			fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"dm-1": {Name: "dm-1", Label: "luks-2bcb02be-999d-4417-8d18-5c61e660fb6e"},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, "dm-1", key)
-		assert.Equal(t, "Archive", stats.Name)
-	})
-
-	t.Run("uses full device name on windows", func(t *testing.T) {
-		key, _, ok := registerFilesystemStats(
-			map[string]*system.FsStats{},
-			`C:`,
-			`C:\\`,
-			false,
-			"",
-			fsRegistrationContext{
-				isWindows: true,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					`C:`: {Name: `C:`},
-				},
-			},
-		)
-
-		assert.True(t, ok)
-		assert.Equal(t, `C:`, key)
-	})
-
-	t.Run("skips existing key", func(t *testing.T) {
-		key, stats, ok := registerFilesystemStats(
-			map[string]*system.FsStats{"sda1": {Mountpoint: "/existing"}},
-			"/dev/sda1",
-			"/mnt/data",
-			false,
-			"",
-			fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"sda1": {Name: "sda1"},
-				},
-			},
-		)
-
-		assert.False(t, ok)
-		assert.Empty(t, key)
-		assert.Nil(t, stats)
-	})
-}
-
-func TestAddConfiguredRootFs(t *testing.T) {
-	t.Run("adds root from matching partition", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent:          agent,
-			rootMountPoint: "/",
-			partitions:     []disk.PartitionStat{{Device: "/dev/ada0p2", Mountpoint: "/"}},
-			ctx: fsRegistrationContext{
-				filesystem: "/dev/ada0p2",
-				isWindows:  false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"ada0": {Name: "ada0", ReadBytes: 1000, WriteBytes: 1000},
-				},
-			},
-		}
-
-		ok := discovery.addConfiguredRootFs()
-
-		assert.True(t, ok)
-		stats, exists := agent.fsStats["ada0"]
-		assert.True(t, exists)
-		assert.True(t, stats.Root)
-		assert.Equal(t, "/", stats.Mountpoint)
-	})
-
-	t.Run("adds root from io device when partition is missing", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent:          agent,
-			rootMountPoint: "/sysroot",
-			ctx: fsRegistrationContext{
-				filesystem: "zroot",
-				isWindows:  false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"nda0": {Name: "nda0", Label: "zroot", ReadBytes: 1000, WriteBytes: 1000},
-				},
-			},
-		}
-
-		ok := discovery.addConfiguredRootFs()
-
-		assert.True(t, ok)
-		stats, exists := agent.fsStats["nda0"]
-		assert.True(t, exists)
-		assert.True(t, stats.Root)
-		assert.Equal(t, "/sysroot", stats.Mountpoint)
-	})
-
-	t.Run("returns false when filesystem cannot be resolved", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent:          agent,
-			rootMountPoint: "/",
-			ctx: fsRegistrationContext{
-				filesystem:     "missing-disk",
-				isWindows:      false,
-				diskIoCounters: map[string]disk.IOCountersStat{},
-			},
-		}
-
-		ok := discovery.addConfiguredRootFs()
-
-		assert.False(t, ok)
-		assert.Empty(t, agent.fsStats)
-	})
-}
-
-func TestAddPartitionRootFs(t *testing.T) {
-	t.Run("adds root from fallback partition candidate", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent: agent,
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"nvme0n1": {Name: "nvme0n1", ReadBytes: 1000, WriteBytes: 1000},
-				},
-			},
-		}
-
-		ok := discovery.addPartitionRootFs("/dev/nvme0n1p2", "/")
-
-		assert.True(t, ok)
-		stats, exists := agent.fsStats["nvme0n1"]
-		assert.True(t, exists)
-		assert.True(t, stats.Root)
-		assert.Equal(t, "/", stats.Mountpoint)
-	})
-
-	t.Run("returns false when no io device matches", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{agent: agent, ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{}}}
-
-		ok := discovery.addPartitionRootFs("/dev/mapper/root", "/")
-
-		assert.False(t, ok)
-		assert.Empty(t, agent.fsStats)
-	})
-}
-
-func TestAddLastResortRootFs(t *testing.T) {
-	t.Run("uses most active io device when available", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{agent: agent, rootMountPoint: "/", ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{
-			"sda": {Name: "sda", ReadBytes: 5000, WriteBytes: 5000},
-			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000},
-		}}}
-
-		discovery.addLastResortRootFs()
-
-		stats, exists := agent.fsStats["sda"]
-		assert.True(t, exists)
-		assert.True(t, stats.Root)
-	})
-
-	t.Run("falls back to root key when mountpoint basename collides", func(t *testing.T) {
-		agent := &Agent{fsStats: map[string]*system.FsStats{
-			"sysroot": {Mountpoint: "/extra-filesystems/sysroot"},
-		}}
-		discovery := diskDiscovery{agent: agent, rootMountPoint: "/sysroot", ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{}}}
-
-		discovery.addLastResortRootFs()
-
-		stats, exists := agent.fsStats["root"]
-		assert.True(t, exists)
-		assert.True(t, stats.Root)
-		assert.Equal(t, "/sysroot", stats.Mountpoint)
-	})
-}
-
-func TestAddConfiguredExtraFsEntry(t *testing.T) {
-	t.Run("uses matching partition when present", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent:      agent,
-			partitions: []disk.PartitionStat{{Device: "/dev/sdb1", Mountpoint: "/mnt/backup"}},
-			usageFn: func(string) (*disk.UsageStat, error) {
-				t.Fatal("usage fallback should not be called when partition matches")
-				return nil, nil
-			},
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"sdb1": {Name: "sdb1"},
-				},
-			},
-		}
-
-		discovery.addConfiguredExtraFsEntry("sdb1", "backup")
-
-		stats, exists := agent.fsStats["sdb1"]
-		assert.True(t, exists)
-		assert.Equal(t, "/mnt/backup", stats.Mountpoint)
-		assert.Equal(t, "backup", stats.Name)
-	})
-
-	t.Run("falls back to usage-validated path", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent: agent,
-			usageFn: func(path string) (*disk.UsageStat, error) {
-				assert.Equal(t, "/srv/archive", path)
-				return &disk.UsageStat{}, nil
-			},
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"archive": {Name: "archive"},
-				},
-			},
-		}
-
-		discovery.addConfiguredExtraFsEntry("/srv/archive", "archive")
-
-		stats, exists := agent.fsStats["archive"]
-		assert.True(t, exists)
-		assert.Equal(t, "/srv/archive", stats.Mountpoint)
-		assert.Equal(t, "archive", stats.Name)
-	})
-
-	t.Run("ignores invalid filesystem entry", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent: agent,
-			usageFn: func(string) (*disk.UsageStat, error) {
-				return nil, os.ErrNotExist
-			},
-		}
-
-		discovery.addConfiguredExtraFsEntry("/missing/archive", "")
-
-		assert.Empty(t, agent.fsStats)
-	})
-}
-
-func TestAddConfiguredExtraFilesystems(t *testing.T) {
-	t.Run("parses and registers multiple configured filesystems", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		discovery := diskDiscovery{
-			agent:      agent,
-			partitions: []disk.PartitionStat{{Device: "/dev/sda1", Mountpoint: "/mnt/fast"}},
-			usageFn: func(path string) (*disk.UsageStat, error) {
-				if path == "/srv/archive" {
-					return &disk.UsageStat{}, nil
-				}
-				return nil, os.ErrNotExist
-			},
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"sda1":    {Name: "sda1"},
-					"archive": {Name: "archive"},
-				},
-			},
-		}
-
-		discovery.addConfiguredExtraFilesystems("sda1__fast,/srv/archive__cold")
-
-		assert.Contains(t, agent.fsStats, "sda1")
-		assert.Equal(t, "fast", agent.fsStats["sda1"].Name)
-		assert.Contains(t, agent.fsStats, "archive")
-		assert.Equal(t, "cold", agent.fsStats["archive"].Name)
-	})
-}
-
-func TestAddExtraFilesystemFolders(t *testing.T) {
-	t.Run("adds missing folders and skips existing mountpoints", func(t *testing.T) {
-		agent := &Agent{fsStats: map[string]*system.FsStats{
-			"existing": {Mountpoint: "/extra-filesystems/existing"},
-		}}
-		discovery := diskDiscovery{
-			agent: agent,
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				efPath:    "/extra-filesystems",
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"newdisk": {Name: "newdisk"},
-				},
-			},
-		}
-
-		discovery.addExtraFilesystemFolders([]string{"existing", "newdisk__Archive"})
-
-		assert.Len(t, agent.fsStats, 2)
-		stats, exists := agent.fsStats["newdisk"]
-		assert.True(t, exists)
-		assert.Equal(t, "/extra-filesystems/newdisk__Archive", stats.Mountpoint)
-		assert.Equal(t, "Archive", stats.Name)
-	})
-}
-
-func TestAddPartitionExtraFs(t *testing.T) {
-	makeDiscovery := func(agent *Agent) diskDiscovery {
-		return diskDiscovery{
-			agent: agent,
-			ctx: fsRegistrationContext{
-				isWindows: false,
-				efPath:    "/extra-filesystems",
-				diskIoCounters: map[string]disk.IOCountersStat{
-					"nvme0n1p1": {Name: "nvme0n1p1"},
-					"nvme1n1":   {Name: "nvme1n1"},
-				},
-			},
-		}
-	}
-
-	t.Run("registers direct child of extra-filesystems", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		d := makeDiscovery(agent)
-
-		d.addPartitionExtraFs(disk.PartitionStat{
-			Device:     "/dev/nvme0n1p1",
-			Mountpoint: "/extra-filesystems/nvme0n1p1__caddy1-root",
-		})
-
-		stats, exists := agent.fsStats["nvme0n1p1"]
-		assert.True(t, exists)
-		assert.Equal(t, "/extra-filesystems/nvme0n1p1__caddy1-root", stats.Mountpoint)
-		assert.Equal(t, "caddy1-root", stats.Name)
-	})
-
-	t.Run("skips nested mount under extra-filesystem bind mount", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		d := makeDiscovery(agent)
-
-		// These simulate the virtual mounts that appear when host / is bind-mounted
-		// with disk.Partitions(all=true) — e.g. /proc, /sys, /dev visible under the mount.
-		for _, nested := range []string{
-			"/extra-filesystems/nvme0n1p1__caddy1-root/proc",
-			"/extra-filesystems/nvme0n1p1__caddy1-root/sys",
-			"/extra-filesystems/nvme0n1p1__caddy1-root/dev",
-			"/extra-filesystems/nvme0n1p1__caddy1-root/run",
-		} {
-			d.addPartitionExtraFs(disk.PartitionStat{Device: "tmpfs", Mountpoint: nested})
-		}
-
-		assert.Empty(t, agent.fsStats)
-	})
-
-	t.Run("registers both direct children, skips their nested mounts", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		d := makeDiscovery(agent)
-
-		partitions := []disk.PartitionStat{
-			{Device: "/dev/nvme0n1p1", Mountpoint: "/extra-filesystems/nvme0n1p1__caddy1-root"},
-			{Device: "/dev/nvme1n1", Mountpoint: "/extra-filesystems/nvme1n1__caddy1-docker"},
-			{Device: "proc", Mountpoint: "/extra-filesystems/nvme0n1p1__caddy1-root/proc"},
-			{Device: "sysfs", Mountpoint: "/extra-filesystems/nvme0n1p1__caddy1-root/sys"},
-			{Device: "overlay", Mountpoint: "/extra-filesystems/nvme0n1p1__caddy1-root/var/lib/docker"},
-		}
-		for _, p := range partitions {
-			d.addPartitionExtraFs(p)
-		}
-
-		assert.Len(t, agent.fsStats, 2)
-		assert.Equal(t, "caddy1-root", agent.fsStats["nvme0n1p1"].Name)
-		assert.Equal(t, "caddy1-docker", agent.fsStats["nvme1n1"].Name)
-	})
-
-	t.Run("skips partition not under extra-filesystems", func(t *testing.T) {
-		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
-		d := makeDiscovery(agent)
-
-		d.addPartitionExtraFs(disk.PartitionStat{
-			Device:     "/dev/nvme0n1p1",
-			Mountpoint: "/",
-		})
-
-		assert.Empty(t, agent.fsStats)
-	})
-}
-
-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 match 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)
-	})
-
-	t.Run("uses uncertain unique prefix fallback", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"nvme0n1": {Name: "nvme0n1"},
-			"sda":     {Name: "sda"},
-		}
-
-		device, ok := findIoDevice("nvme0n1p2", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "nvme0n1", device)
-	})
-
-	t.Run("uses dominant activity when prefix matches are ambiguous", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sda": {Name: "sda", ReadBytes: 5000, WriteBytes: 5000, ReadCount: 100, WriteCount: 100},
-			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 50, WriteCount: 50},
-		}
-
-		device, ok := findIoDevice("sd", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "sda", device)
-	})
-
-	t.Run("uses highest activity when ambiguous without dominance", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sda": {Name: "sda", ReadBytes: 3000, WriteBytes: 3000, ReadCount: 50, WriteCount: 50},
-			"sdb": {Name: "sdb", ReadBytes: 2500, WriteBytes: 2500, ReadCount: 40, WriteCount: 40},
-		}
-
-		device, ok := findIoDevice("sd", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "sda", device)
-	})
-
-	t.Run("matches /dev/-prefixed partition to parent disk", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"nda0": {Name: "nda0", ReadBytes: 1000, WriteBytes: 1000},
-		}
-
-		device, ok := findIoDevice("/dev/nda0p2", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "nda0", device)
-	})
-
-	t.Run("uses deterministic name tie-breaker", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sdb": {Name: "sdb", ReadBytes: 2000, WriteBytes: 2000, ReadCount: 10, WriteCount: 10},
-			"sda": {Name: "sda", ReadBytes: 2000, WriteBytes: 2000, ReadCount: 10, WriteCount: 10},
-		}
-
-		device, ok := findIoDevice("sd", ioCounters)
-		assert.True(t, ok)
-		assert.Equal(t, "sda", device)
-	})
-}
-
-func TestFilesystemMatchesPartitionSetting(t *testing.T) {
-	p := disk.PartitionStat{Device: "/dev/ada0p2", Mountpoint: "/"}
-
-	t.Run("matches mountpoint setting", func(t *testing.T) {
-		assert.True(t, filesystemMatchesPartitionSetting("/", p))
-	})
-
-	t.Run("matches exact partition setting", func(t *testing.T) {
-		assert.True(t, filesystemMatchesPartitionSetting("ada0p2", p))
-		assert.True(t, filesystemMatchesPartitionSetting("/dev/ada0p2", p))
-	})
-
-	t.Run("matches prefix-style parent setting", func(t *testing.T) {
-		assert.True(t, filesystemMatchesPartitionSetting("ada0", p))
-		assert.True(t, filesystemMatchesPartitionSetting("/dev/ada0", p))
-	})
-
-	t.Run("does not match unrelated device", func(t *testing.T) {
-		assert.False(t, filesystemMatchesPartitionSetting("sda", p))
-		assert.False(t, filesystemMatchesPartitionSetting("nvme0n1", p))
-		assert.False(t, filesystemMatchesPartitionSetting("", p))
-	})
-}
-
-func TestMostActiveIoDevice(t *testing.T) {
-	t.Run("returns most active device", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"nda0": {Name: "nda0", ReadBytes: 5000, WriteBytes: 5000, ReadCount: 100, WriteCount: 100},
-			"nda1": {Name: "nda1", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 50, WriteCount: 50},
-		}
-		assert.Equal(t, "nda0", mostActiveIoDevice(ioCounters))
-	})
-
-	t.Run("uses deterministic tie-breaker", func(t *testing.T) {
-		ioCounters := map[string]disk.IOCountersStat{
-			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 10, WriteCount: 10},
-			"sda": {Name: "sda", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 10, WriteCount: 10},
-		}
-		assert.Equal(t, "sda", mostActiveIoDevice(ioCounters))
-	})
-
-	t.Run("returns empty for empty map", func(t *testing.T) {
-		assert.Equal(t, "", mostActiveIoDevice(map[string]disk.IOCountersStat{}))
-	})
-}
-
-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")
+	defer func() {
+		if oldEnv != "" {
+			os.Setenv("EXTRA_FILESYSTEMS", oldEnv)
+		} else {
+			os.Unsetenv("EXTRA_FILESYSTEMS")
+		}
+	}()
+
 	// Test with custom names
-	t.Setenv("EXTRA_FILESYSTEMS", "sda1__my-storage,/dev/sdb1__backup-drive,nvme0n1p2")
+	os.Setenv("EXTRA_FILESYSTEMS", "sda1__my-storage,/dev/sdb1__backup-drive,nvme0n1p2")

 	// Mock disk partitions (we'll just test the parsing logic)
 	// Since the actual disk operations are system-dependent, we'll focus on the parsing
@@ -797,7 +133,7 @@ func TestInitializeDiskInfoWithCustomNames(t *testing.T) {

 	for _, tc := range testCases {
 		t.Run("env_"+tc.envValue, func(t *testing.T) {
-			t.Setenv("EXTRA_FILESYSTEMS", tc.envValue)
+			os.Setenv("EXTRA_FILESYSTEMS", tc.envValue)

 			// Create mock partitions that would match our test cases
 			partitions := []disk.PartitionStat{}
@@ -818,7 +154,7 @@ func TestInitializeDiskInfoWithCustomNames(t *testing.T) {
 			// Test the parsing logic by calling the relevant part
 			// We'll create a simplified version to test just the parsing
 			extraFilesystems := tc.envValue
-			for fsEntry := range strings.SplitSeq(extraFilesystems, ",") {
+			for _, fsEntry := range strings.Split(extraFilesystems, ",") {
 				// Parse the entry
 				fsEntry = strings.TrimSpace(fsEntry)
 				var fs, customName string
@@ -897,150 +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")
-	})
-}
-
-func TestHasSameDiskUsage(t *testing.T) {
-	const toleranceBytes uint64 = 16 * 1024 * 1024
-
-	t.Run("returns true when totals and usage are equal", func(t *testing.T) {
-		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
-		b := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
-		assert.True(t, hasSameDiskUsage(a, b))
-	})
-
-	t.Run("returns true within tolerance", func(t *testing.T) {
-		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
-		b := &disk.UsageStat{
-			Total: a.Total + toleranceBytes - 1,
-			Used:  a.Used - toleranceBytes + 1,
-		}
-		assert.True(t, hasSameDiskUsage(a, b))
-	})
-
-	t.Run("returns false when total exceeds tolerance", func(t *testing.T) {
-		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
-		b := &disk.UsageStat{
-			Total: a.Total + toleranceBytes + 1,
-			Used:  a.Used,
-		}
-		assert.False(t, hasSameDiskUsage(a, b))
-	})
-
-	t.Run("returns false for nil or zero total", func(t *testing.T) {
-		assert.False(t, hasSameDiskUsage(nil, &disk.UsageStat{Total: 1, Used: 1}))
-		assert.False(t, hasSameDiskUsage(&disk.UsageStat{Total: 1, Used: 1}, nil))
-		assert.False(t, hasSameDiskUsage(&disk.UsageStat{Total: 0, Used: 0}, &disk.UsageStat{Total: 1, Used: 1}))
-	})
-}
-
-func TestInitializeDiskIoStatsResetsTrackedDevices(t *testing.T) {
-	agent := &Agent{
-		fsStats: map[string]*system.FsStats{
-			"sda": {},
-			"sdb": {},
-		},
-		fsNames: []string{"stale", "sda"},
-	}
-
-	agent.initializeDiskIoStats(map[string]disk.IOCountersStat{
-		"sda": {Name: "sda", ReadBytes: 10, WriteBytes: 20},
-		"sdb": {Name: "sdb", ReadBytes: 30, WriteBytes: 40},
-	})
-
-	assert.ElementsMatch(t, []string{"sda", "sdb"}, agent.fsNames)
-	assert.Len(t, agent.fsNames, 2)
-	assert.Equal(t, uint64(10), agent.fsStats["sda"].TotalRead)
-	assert.Equal(t, uint64(20), agent.fsStats["sda"].TotalWrite)
-	assert.False(t, agent.fsStats["sda"].Time.IsZero())
-	assert.False(t, agent.fsStats["sdb"].Time.IsZero())
-
-	agent.initializeDiskIoStats(map[string]disk.IOCountersStat{
-		"sdb": {Name: "sdb", ReadBytes: 50, WriteBytes: 60},
-	})
-
-	assert.Equal(t, []string{"sdb"}, agent.fsNames)
-	assert.Equal(t, uint64(50), agent.fsStats["sdb"].TotalRead)
-	assert.Equal(t, uint64(60), agent.fsStats["sdb"].TotalWrite)
-}
--- a/agent/docker.go
+++ b/agent/docker.go
@@ -1,74 +1,59 @@
 package agent

 import (
-	"bufio"
 	"bytes"
 	"context"
-	"encoding/binary"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
 	"os"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
 	"strings"
 	"sync"
 	"time"

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

 	"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
 	// Maximum realistic network speed (5 GB/s) to detect bad deltas
 	maxNetworkSpeedBps uint64 = 5e9
+	// Container and health constants
+	composeProjectLabel   = "com.docker.compose.project"
+	healthStatusNone      = "none"
+	containerStateRunning = "running"
+	containerStateUnknown = "unknown"
+	volumeTypeVolume      = "volume"
+	diskOpRead            = "read"
+	diskOpReadCap         = "Read"
+	diskOpWrite           = "write"
+	diskOpWriteCap        = "Write"
 	// Maximum conceivable memory usage of a container (100TB) to detect bad memory stats
 	maxMemoryUsage uint64 = 100 * 1024 * 1024 * 1024 * 1024
-	// Number of log lines to request when fetching container logs
-	dockerLogsTail = 200
-	// Maximum size of a single log frame (1MB) to prevent memory exhaustion
-	// A single log line larger than 1MB is likely an error or misconfiguration
-	maxLogFrameSize = 1024 * 1024
-	// Maximum total log content size (5MB) to prevent memory exhaustion
-	// This provides a reasonable limit for network transfer and browser rendering
-	maxTotalLogSize = 5 * 1024 * 1024
 )

 type dockerManager struct {
-	agent                *Agent                      // Used to propagate system detail changes back to the agent
-	client               *http.Client                // Client to query Docker API
-	wg                   sync.WaitGroup              // WaitGroup to wait for all goroutines to finish
-	sem                  chan struct{}               // Semaphore to limit concurrent container requests
-	containerStatsMutex  sync.RWMutex                // Mutex to prevent concurrent access to containerStatsMap
-	apiContainerList     []*container.ApiInfo        // List of containers from Docker API
-	containerStatsMap    map[string]*container.Stats // Keeps track of container stats
-	validIds             map[string]struct{}         // Map of valid container ids, used to prune invalid containers from containerStatsMap
-	goodDockerVersion    bool                        // Whether docker version is at least 25.0.0 (one-shot works correctly)
-	dockerVersionChecked bool                        // Whether a version probe has completed successfully
-	isWindows            bool                        // Whether the Docker Engine API is running on Windows
-	buf                  *bytes.Buffer               // Buffer to store and read response bodies
-	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
+	client              *http.Client                // Client to query Docker API
+	wg                  sync.WaitGroup              // WaitGroup to wait for all goroutines to finish
+	sem                 chan struct{}               // Semaphore to limit concurrent container requests
+	containerStatsMutex sync.RWMutex                // Mutex to prevent concurrent access to containerStatsMap
+	apiContainerList    []*container.ApiInfo        // List of containers from Docker API
+	containerStatsMap   map[string]*container.Stats // Keeps track of container stats
+	validIds            map[string]struct{}         // Map of valid container ids, used to prune invalid containers from containerStatsMap
+	goodDockerVersion   bool                        // Whether docker version is at least 25.0.0 (one-shot works correctly)
+	isWindows           bool                        // Whether the Docker Engine API is running on Windows
+	buf                 *bytes.Buffer               // Buffer to store and read response bodies
+	decoder             *json.Decoder               // Reusable JSON decoder that reads from buf
+	apiStats            *container.ApiStats         // Reusable API stats object
+	volumeSizeCache     map[string]float64          // Cached volume sizes (name -> size in MB)
+	volumeSizeUpdated   time.Time                   // Last time volume sizes were updated

 	// Cache-time-aware tracking for CPU stats (similar to cpu.go)
 	// Maps cache time intervals to container-specific CPU usage tracking
@@ -80,7 +65,11 @@ type dockerManager struct {
 	// cacheTimeMs -> DeltaTracker for network bytes sent/received
 	networkSentTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
 	networkRecvTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
-	lastNetworkReadTime map[uint16]map[string]time.Time // cacheTimeMs -> containerId -> last network read time
+
+	// Disk I/O delta trackers - one per cache time to avoid interference
+	// cacheTimeMs -> DeltaTracker for disk bytes read/written
+	diskReadTrackers  map[uint16]*deltatracker.DeltaTracker[string, uint64]
+	diskWriteTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
 }

 // userAgentRoundTripper is a custom http.RoundTripper that adds a User-Agent header to all requests
@@ -89,14 +78,6 @@ type userAgentRoundTripper struct {
 	userAgent string
 }

-// dockerVersionResponse contains the /version fields used for engine checks.
-type dockerVersionResponse struct {
-	Version    string `json:"Version"`
-	Components []struct {
-		Name string `json:"Name"`
-	} `json:"Components"`
-}
-
 // RoundTrip implements the http.RoundTripper interface
 func (u *userAgentRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", u.userAgent)
@@ -119,19 +100,6 @@ func (d *dockerManager) dequeue() {
 	}
 }

-// shouldExcludeContainer checks if a container name matches any exclusion pattern
-func (dm *dockerManager) shouldExcludeContainer(name string) bool {
-	if len(dm.excludeContainers) == 0 {
-		return false
-	}
-	for _, pattern := range dm.excludeContainers {
-		if match, _ := path.Match(pattern, name); match {
-			return true
-		}
-	}
-	return false
-}
-
 // Returns stats for all running containers with cache-time-aware delta tracking
 func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats, error) {
 	resp, err := dm.client.Get("http://localhost/containers/json")
@@ -144,14 +112,7 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 		return nil, err
 	}

-	// Detect Podman and Windows from Server header
-	serverHeader := resp.Header.Get("Server")
-	if !dm.usingPodman && detectPodmanFromHeader(serverHeader) {
-		dm.setIsPodman()
-	}
-	dm.isWindows = strings.Contains(serverHeader, "windows")
-
-	dm.ensureDockerVersionChecked()
+	dm.isWindows = strings.Contains(resp.Header.Get("Server"), "windows")

 	containersLength := len(dm.apiContainerList)

@@ -166,13 +127,6 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,

 	for _, ctr := range dm.apiContainerList {
 		ctr.IdShort = ctr.Id[:12]
-
-		// Skip this container if it matches the exclusion pattern
-		if dm.shouldExcludeContainer(ctr.Names[0][1:]) {
-			slog.Debug("Excluding container", "name", ctr.Names[0][1:])
-			continue
-		}
-
 		dm.validIds[ctr.IdShort] = struct{}{}
 		// check if container is less than 1 minute old (possible restart)
 		// note: can't use Created field because it's not updated on restart
@@ -222,8 +176,9 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 		}
 	}

-	// prepare network trackers for next interval for this cache time
+	// prepare network and disk trackers for next interval for this cache time
 	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
+	dm.cycleDiskDeltasForCacheTime(cacheTimeMs)

 	return stats, nil
 }
@@ -302,8 +257,34 @@ func (dm *dockerManager) cycleNetworkDeltasForCacheTime(cacheTimeMs uint16) {
 	}
 }

+// getDiskTracker returns the DeltaTracker for disk I/O for a specific cache time, creating it if needed
+func (dm *dockerManager) getDiskTracker(cacheTimeMs uint16, isRead bool) *deltatracker.DeltaTracker[string, uint64] {
+	var trackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
+	if isRead {
+		trackers = dm.diskReadTrackers
+	} else {
+		trackers = dm.diskWriteTrackers
+	}
+
+	if trackers[cacheTimeMs] == nil {
+		trackers[cacheTimeMs] = deltatracker.NewDeltaTracker[string, uint64]()
+	}
+
+	return trackers[cacheTimeMs]
+}
+
+// cycleDiskDeltasForCacheTime cycles the disk delta trackers for a specific cache time
+func (dm *dockerManager) cycleDiskDeltasForCacheTime(cacheTimeMs uint16) {
+	if dm.diskReadTrackers[cacheTimeMs] != nil {
+		dm.diskReadTrackers[cacheTimeMs].Cycle()
+	}
+	if dm.diskWriteTrackers[cacheTimeMs] != nil {
+		dm.diskWriteTrackers[cacheTimeMs].Cycle()
+	}
+}
+
 // calculateNetworkStats calculates network sent/receive deltas using DeltaTracker
-func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats *container.ApiStats, name string, cacheTimeMs uint16) (uint64, uint64) {
+func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats *container.ApiStats, stats *container.Stats, initialized bool, name string, cacheTimeMs uint16) (uint64, uint64) {
 	var total_sent, total_recv uint64
 	for _, v := range apiStats.Networks {
 		total_sent += v.TxBytes
@@ -322,11 +303,10 @@ func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats
 	sent_delta_raw := sentTracker.Delta(ctr.IdShort)
 	recv_delta_raw := recvTracker.Delta(ctr.IdShort)

-	// Calculate bytes per second using per-cache-time read time to avoid
-	// interference between different cache intervals (e.g. 1000ms vs 60000ms)
+	// Calculate bytes per second independently for Tx and Rx if we have previous data
 	var sent_delta, recv_delta uint64
-	if prevReadTime, ok := dm.lastNetworkReadTime[cacheTimeMs][ctr.IdShort]; ok {
-		millisecondsElapsed := uint64(time.Since(prevReadTime).Milliseconds())
+	if initialized {
+		millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
 		if millisecondsElapsed > 0 {
 			if sent_delta_raw > 0 {
 				sent_delta = sent_delta_raw * 1000 / millisecondsElapsed
@@ -348,6 +328,50 @@ func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats
 	return sent_delta, recv_delta
 }

+// calculateDiskStats calculates disk read/write deltas using DeltaTracker
+func (dm *dockerManager) calculateDiskStats(ctr *container.ApiInfo, apiStats *container.ApiStats, stats *container.Stats, initialized bool, cacheTimeMs uint16) (uint64, uint64) {
+	var total_read, total_write uint64
+	for _, entry := range apiStats.BlkioStats.IoServiceBytesRecursive {
+		switch entry.Op {
+		case diskOpRead, diskOpReadCap:
+			total_read += entry.Value
+		case diskOpWrite, diskOpWriteCap:
+			total_write += entry.Value
+		}
+	}
+
+	// Get the DeltaTracker for this specific cache time
+	readTracker := dm.getDiskTracker(cacheTimeMs, true)
+	writeTracker := dm.getDiskTracker(cacheTimeMs, false)
+
+	// Set current values in the cache-time-specific DeltaTracker
+	readTracker.Set(ctr.IdShort, total_read)
+	writeTracker.Set(ctr.IdShort, total_write)
+
+	// Get deltas (bytes since last measurement)
+	read_delta_raw := readTracker.Delta(ctr.IdShort)
+	write_delta_raw := writeTracker.Delta(ctr.IdShort)
+
+	// Calculate bytes per second if we have previous data
+	var read_delta, write_delta uint64
+	if initialized {
+		millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
+		if millisecondsElapsed > 0 {
+			if read_delta_raw > 0 {
+				read_delta = read_delta_raw * 1000 / millisecondsElapsed
+			}
+			if write_delta_raw > 0 {
+				write_delta = write_delta_raw * 1000 / millisecondsElapsed
+			}
+		}
+	}
+
+	// Store current disk values for legacy compatibility
+	stats.PrevDisk.Read, stats.PrevDisk.Write = total_read, total_write
+
+	return read_delta, write_delta
+}
+
 // validateCpuPercentage checks if CPU percentage is within valid range
 func validateCpuPercentage(cpuPct float64, containerName string) error {
 	if cpuPct > 100 {
@@ -357,171 +381,93 @@ func validateCpuPercentage(cpuPct float64, containerName string) error {
 }

 // updateContainerStatsValues updates the final stats values
-func updateContainerStatsValues(stats *container.Stats, cpuPct float64, usedMemory uint64, sent_delta, recv_delta uint64, readTime time.Time) {
-	stats.Cpu = utils.TwoDecimals(cpuPct)
-	stats.Mem = utils.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 = utils.BytesToMegabytes(float64(sent_delta))
-	stats.NetworkRecv = utils.BytesToMegabytes(float64(recv_delta))
+func updateContainerStatsValues(stats *container.Stats, cpuPct float64, usedMemory uint64, sent_delta, recv_delta, read_delta, write_delta uint64, readTime time.Time) {
+	stats.Cpu = twoDecimals(cpuPct)
+	stats.Mem = bytesToMegabytes(float64(usedMemory))
+	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
+	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
+	stats.DiskRead = bytesToMegabytes(float64(read_delta))
+	stats.DiskWrite = bytesToMegabytes(float64(write_delta))
 	stats.PrevReadTime = readTime
 }

-// convertContainerPortsToString formats the ports of a container into a sorted, deduplicated string.
-// ctr.Ports is nilled out after processing so the slice is not accidentally reused.
-func convertContainerPortsToString(ctr *container.ApiInfo) string {
-	if len(ctr.Ports) == 0 {
-		return ""
-	}
-	sort.Slice(ctr.Ports, func(i, j int) bool {
-		return ctr.Ports[i].PublicPort < ctr.Ports[j].PublicPort
-	})
-	var builder strings.Builder
-	seenPorts := make(map[uint16]struct{})
-	for _, p := range ctr.Ports {
-		_, ok := seenPorts[p.PublicPort]
-		if p.PublicPort == 0 || ok {
-			continue
-		}
-		seenPorts[p.PublicPort] = struct{}{}
-		if builder.Len() > 0 {
-			builder.WriteString(", ")
-		}
-		switch p.IP {
-		case "0.0.0.0", "::":
-		default:
-			builder.WriteString(p.IP)
-			builder.WriteByte(':')
-		}
-		builder.WriteString(strconv.Itoa(int(p.PublicPort)))
-	}
-	// clear ports slice so it doesn't get reused and blend into next response
-	ctr.Ports = nil
-	return builder.String()
-}
-
-func parseDockerStatus(status string) (string, container.DockerHealth) {
-	trimmed := strings.TrimSpace(status)
-	if trimmed == "" {
-		return "", container.DockerHealthNone
-	}
-
-	// Remove "About " from status
-	trimmed = strings.Replace(trimmed, "About ", "", 1)
-
-	openIdx := strings.LastIndex(trimmed, "(")
-	if openIdx == -1 || !strings.HasSuffix(trimmed, ")") {
-		return trimmed, container.DockerHealthNone
-	}
-
-	statusText := strings.TrimSpace(trimmed[:openIdx])
-	if statusText == "" {
-		statusText = trimmed
-	}
-
-	healthText := strings.TrimSpace(strings.TrimSuffix(trimmed[openIdx+1:], ")"))
-	// Some Docker statuses include a "health:" prefix inside the parentheses.
-	// Strip it so it maps correctly to the known health states.
-	if colonIdx := strings.IndexRune(healthText, ':'); colonIdx != -1 {
-		prefix := strings.ToLower(strings.TrimSpace(healthText[:colonIdx]))
-		if prefix == "health" || prefix == "health status" {
-			healthText = strings.TrimSpace(healthText[colonIdx+1:])
-		}
-	}
-	if health, ok := parseDockerHealthStatus(healthText); ok {
-		return statusText, health
-	}
-
-	return trimmed, container.DockerHealthNone
-}
-
-// parseDockerHealthStatus maps Docker health status strings to container.DockerHealth values
-func parseDockerHealthStatus(status string) (container.DockerHealth, bool) {
-	health, ok := container.DockerHealthStrings[strings.ToLower(strings.TrimSpace(status))]
-	return health, ok
-}
-
-// getPodmanContainerHealth fetches container health status from the container inspect endpoint.
-// Used for Podman which doesn't provide health status in the /containers/json endpoint as of March 2026.
-// https://github.com/containers/podman/issues/27786
-func (dm *dockerManager) getPodmanContainerHealth(containerID string) (container.DockerHealth, error) {
-	resp, err := dm.client.Get(fmt.Sprintf("http://localhost/containers/%s/json", url.PathEscape(containerID)))
-	if err != nil {
-		return container.DockerHealthNone, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return container.DockerHealthNone, fmt.Errorf("container inspect request failed: %s", resp.Status)
-	}
-
-	var inspectInfo struct {
-		State struct {
-			Health struct {
-				Status string
-			}
-		}
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&inspectInfo); err != nil {
-		return container.DockerHealthNone, err
-	}
-
-	if health, ok := parseDockerHealthStatus(inspectInfo.State.Health.Status); ok {
-		return health, nil
-	}
-
-	return container.DockerHealthNone, nil
-}
-
 // Updates stats for individual container with cache-time-aware delta tracking
 func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeMs uint16) error {
 	name := ctr.Names[0][1:]

-	resp, err := dm.client.Get(fmt.Sprintf("http://localhost/containers/%s/stats?stream=0&one-shot=1", ctr.IdShort))
+	resp, err := dm.client.Get("http://localhost/containers/" + ctr.IdShort + "/stats?stream=0&one-shot=1")
 	if err != nil {
 		return err
 	}

-	statusText, health := parseDockerStatus(ctr.Status)
-
-	// Docker exposes Health.Status on /containers/json in API 1.52+.
-	// Podman currently requires falling back to the inspect endpoint as of March 2026.
-	// https://github.com/containers/podman/issues/27786
-	if ctr.Health.Status != "" {
-		if h, ok := parseDockerHealthStatus(ctr.Health.Status); ok {
-			health = h
-		}
-	} else if dm.usingPodman {
-		if podmanHealth, err := dm.getPodmanContainerHealth(ctr.IdShort); err == nil {
-			health = podmanHealth
-		}
-	}
-
 	dm.containerStatsMutex.Lock()
 	defer dm.containerStatsMutex.Unlock()

 	// add empty values if they doesn't exist in map
 	stats, initialized := dm.containerStatsMap[ctr.IdShort]
 	if !initialized {
-		stats = &container.Stats{Name: name, Id: ctr.IdShort, Image: ctr.Image}
+		stats = &container.Stats{Name: name}
 		dm.containerStatsMap[ctr.IdShort] = stats
 	}

-	stats.Id = ctr.IdShort
-	stats.Status = statusText
-	stats.Health = health
+	// Update name in case it changed
+	stats.Name = name

-	if len(ctr.Ports) > 0 {
-		stats.Ports = convertContainerPortsToString(ctr)
+	// Set container metadata
+	stats.IdShort = ctr.IdShort
+	stats.Status = ctr.State
+	if stats.Status == "" {
+		stats.Status = containerStateUnknown
+	}
+
+	// Set health status
+	stats.Health = healthStatusNone
+	if ctr.Health != "" {
+		stats.Health = ctr.Health
+	}
+
+	// Set Docker Compose project name
+	if ctr.Labels != nil {
+		if projectName, exists := ctr.Labels[composeProjectLabel]; exists {
+			stats.Project = projectName
+		}
+	}
+
+	// Calculate uptime for running containers
+	if ctr.StartedAt > 0 && stats.Status == containerStateRunning {
+		startedTime := time.Unix(ctr.StartedAt, 0)
+		stats.Uptime = twoDecimals(time.Since(startedTime).Seconds())
+	} else {
+		stats.Uptime = 0
+	}
+
+	// Collect volume information and fetch sizes
+	volumeCount := 0
+	for _, mount := range ctr.Mounts {
+		if mount.Type == volumeTypeVolume && mount.Name != "" {
+			volumeCount++
+		}
+	}
+	if volumeCount > 0 {
+		stats.Volumes = make(map[string]float64, volumeCount)
+		for _, mount := range ctr.Mounts {
+			if mount.Type == volumeTypeVolume && mount.Name != "" {
+				// Fetch volume size using Docker system df API
+				size := dm.getVolumeSize(mount.Name)
+				stats.Volumes[mount.Name] = size
+			}
+		}
+	} else {
+		stats.Volumes = nil
 	}

 	// 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
+	stats.DiskRead = 0
+	stats.DiskWrite = 0

 	res := dm.apiStats
 	res.Networks = nil
@@ -561,13 +507,7 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeM
 	}

 	// Calculate network stats using DeltaTracker
-	sent_delta, recv_delta := dm.calculateNetworkStats(ctr, res, name, cacheTimeMs)
-
-	// Store per-cache-time network read time for next rate calculation
-	if dm.lastNetworkReadTime[cacheTimeMs] == nil {
-		dm.lastNetworkReadTime[cacheTimeMs] = make(map[string]time.Time)
-	}
-	dm.lastNetworkReadTime[cacheTimeMs][ctr.IdShort] = time.Now()
+	sent_delta, recv_delta := dm.calculateNetworkStats(ctr, res, stats, initialized, name, cacheTimeMs)

 	// Store current network values for legacy compatibility
 	var total_sent, total_recv uint64
@@ -577,8 +517,11 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeM
 	}
 	stats.PrevNet.Sent, stats.PrevNet.Recv = total_sent, total_recv

+	// Calculate disk I/O stats using DeltaTracker
+	read_delta, write_delta := dm.calculateDiskStats(ctr, res, stats, initialized, cacheTimeMs)
+
 	// Update final stats values
-	updateContainerStatsValues(stats, cpuPct, usedMemory, sent_delta, recv_delta, res.Read)
+	updateContainerStatsValues(stats, cpuPct, usedMemory, sent_delta, recv_delta, read_delta, write_delta, res.Read)
 	// store per-cache-time read time for Windows CPU percent calc
 	dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort] = res.Read

@@ -599,14 +542,11 @@ func (dm *dockerManager) deleteContainerStatsSync(id string) {
 	for ct := range dm.lastCpuReadTime {
 		delete(dm.lastCpuReadTime[ct], id)
 	}
-	for ct := range dm.lastNetworkReadTime {
-		delete(dm.lastNetworkReadTime[ct], id)
-	}
 }

 // Creates a new http client for Docker or Podman API
-func newDockerManager(agent *Agent) *dockerManager {
-	dockerHost, exists := utils.GetEnv("DOCKER_HOST")
+func newDockerManager(a *Agent) *dockerManager {
+	dockerHost, exists := GetEnv("DOCKER_HOST")
 	if exists {
 		// return nil if set to empty string
 		if dockerHost == "" {
@@ -642,7 +582,7 @@ func newDockerManager(agent *Agent) *dockerManager {

 	// configurable timeout
 	timeout := time.Millisecond * time.Duration(dockerTimeoutMs)
-	if t, set := utils.GetEnv("DOCKER_TIMEOUT"); set {
+	if t, set := GetEnv("DOCKER_TIMEOUT"); set {
 		timeout, err = time.ParseDuration(t)
 		if err != nil {
 			slog.Error(err.Error())
@@ -657,21 +597,7 @@ func newDockerManager(agent *Agent) *dockerManager {
 		userAgent: "Docker-Client/",
 	}

-	// Read container exclusion patterns from environment variable
-	var excludeContainers []string
-	if excludeStr, set := utils.GetEnv("EXCLUDE_CONTAINERS"); set && excludeStr != "" {
-		parts := strings.SplitSeq(excludeStr, ",")
-		for part := range parts {
-			trimmed := strings.TrimSpace(part)
-			if trimmed != "" {
-				excludeContainers = append(excludeContainers, trimmed)
-			}
-		}
-		slog.Info("EXCLUDE_CONTAINERS", "patterns", excludeContainers)
-	}
-
 	manager := &dockerManager{
-		agent: agent,
 		client: &http.Client{
 			Timeout:   timeout,
 			Transport: userAgentTransport,
@@ -680,7 +606,7 @@ func newDockerManager(agent *Agent) *dockerManager {
 		sem:               make(chan struct{}, 5),
 		apiContainerList:  []*container.ApiInfo{},
 		apiStats:          &container.ApiStats{},
-		excludeContainers: excludeContainers,
+		volumeSizeCache:   make(map[string]float64),

 		// Initialize cache-time-aware tracking structures
 		lastCpuContainer:    make(map[uint16]map[string]uint64),
@@ -688,55 +614,52 @@ func newDockerManager(agent *Agent) *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]),
-		lastNetworkReadTime: make(map[uint16]map[string]time.Time),
+		diskReadTrackers:    make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
+		diskWriteTrackers:   make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
 	}

-	// Best-effort startup probe. If the engine is not ready yet, getDockerStats will
-	// retry after the first successful /containers/json request.
-	_, _ = manager.checkDockerVersion()
+	// If using podman, return client
+	if strings.Contains(dockerHost, "podman") {
+		a.systemInfo.Podman = true
+		manager.goodDockerVersion = true
+		return manager
+	}
+
+	// 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
+	time.Sleep(50 * time.Millisecond)

 	return manager
 }

 // checkDockerVersion checks Docker version and sets goodDockerVersion if at least 25.0.0.
 // Versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch.
-func (dm *dockerManager) checkDockerVersion() (bool, error) {
-	resp, err := dm.client.Get("http://localhost/version")
+func (dm *dockerManager) checkDockerVersion() {
+	var err error
+	var resp *http.Response
+	var versionInfo struct {
+		Version string `json:"Version"`
+	}
+	const versionMaxTries = 2
+	for i := 1; i <= versionMaxTries; i++ {
+		resp, err = dm.client.Get("http://localhost/version")
+		if err == nil {
+			break
+		}
+		if resp != nil {
+			resp.Body.Close()
+		}
+		if i < versionMaxTries {
+			slog.Debug("Failed to get Docker version; retrying", "attempt", i, "error", err)
+			time.Sleep(5 * time.Second)
+		}
+	}
 	if err != nil {
-		return false, err
-	}
-	if resp.StatusCode != http.StatusOK {
-		status := resp.Status
-		resp.Body.Close()
-		return false, fmt.Errorf("docker version request failed: %s", status)
-	}
-
-	var versionInfo dockerVersionResponse
-	serverHeader := resp.Header.Get("Server")
-	if err := dm.decode(resp, &versionInfo); err != nil {
-		return false, err
-	}
-
-	dm.applyDockerVersionInfo(serverHeader, &versionInfo)
-	dm.dockerVersionChecked = true
-	return true, nil
-}
-
-// ensureDockerVersionChecked retries the version probe after a successful
-// container list request.
-func (dm *dockerManager) ensureDockerVersionChecked() {
-	if dm.dockerVersionChecked {
 		return
 	}
-	if _, err := dm.checkDockerVersion(); err != nil {
-		slog.Debug("Failed to get Docker version", "err", err)
-	}
-}
-
-// applyDockerVersionInfo updates version-dependent behavior from engine metadata.
-func (dm *dockerManager) applyDockerVersionInfo(serverHeader string, versionInfo *dockerVersionResponse) {
-	if detectPodmanEngine(serverHeader, versionInfo) {
-		dm.setIsPodman()
+	if err := dm.decode(resp, &versionInfo); err != nil {
 		return
 	}
 	// if version > 24, one-shot works correctly and we can limit concurrent operations
@@ -747,6 +670,49 @@ func (dm *dockerManager) applyDockerVersionInfo(serverHeader string, versionInfo
 	}
 }

+// getVolumeSize returns the cached size of a Docker volume
+// Refreshes the cache every 5 minutes using the system df API
+// Returns size in MB (megabytes)
+func (dm *dockerManager) getVolumeSize(volumeName string) float64 {
+	// Refresh cache if older than 5 minutes
+	if time.Since(dm.volumeSizeUpdated) > 5*time.Minute {
+		dm.refreshVolumeSizes()
+	}
+
+	return dm.volumeSizeCache[volumeName]
+}
+
+// refreshVolumeSizes fetches all volume sizes from Docker and updates the cache
+func (dm *dockerManager) refreshVolumeSizes() {
+	type volumeInfo struct {
+		Name     string
+		UsageData struct {
+			Size int64
+		}
+	}
+	type systemDfResponse struct {
+		Volumes []volumeInfo
+	}
+
+	resp, err := dm.client.Get("http://localhost/system/df")
+	if err != nil {
+		return
+	}
+
+	var dfData systemDfResponse
+	if err := dm.decode(resp, &dfData); err != nil {
+		return
+	}
+
+	// Update all volume sizes in cache
+	for _, vol := range dfData.Volumes {
+		// Convert bytes to MB (megabytes)
+		dm.volumeSizeCache[vol.Name] = float64(vol.UsageData.Size) / 1_000_000
+	}
+
+	dm.volumeSizeUpdated = time.Now()
+}
+
 // Decodes Docker API JSON response using a reusable buffer and decoder. Not thread safe.
 func (dm *dockerManager) decode(resp *http.Response, d any) error {
 	if dm.buf == nil {
@@ -774,234 +740,3 @@ 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
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := dm.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return nil, fmt.Errorf("container info request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
-	}
-
-	// Remove sensitive environment variables from Config.Env
-	var containerInfo map[string]any
-	if err := json.NewDecoder(resp.Body).Decode(&containerInfo); err != nil {
-		return nil, err
-	}
-	if config, ok := containerInfo["Config"].(map[string]any); ok {
-		delete(config, "Env")
-	}
-
-	return json.Marshal(containerInfo)
-}
-
-// 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
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return "", err
-	}
-
-	resp, err := dm.client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return "", fmt.Errorf("logs request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
-	}
-
-	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 {
-		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
-}
-
-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
-	}
-	const headerSize = 8
-	var header [headerSize]byte
-	totalBytesRead := 0
-
-	for {
-		if _, err := io.ReadFull(reader, header[:]); err != nil {
-			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
-				return nil
-			}
-			return err
-		}
-
-		frameLen := binary.BigEndian.Uint32(header[4:])
-		if frameLen == 0 {
-			continue
-		}
-
-		// Prevent memory exhaustion from excessively large frames
-		if frameLen > maxLogFrameSize {
-			return fmt.Errorf("log frame size (%d) exceeds maximum (%d)", frameLen, maxLogFrameSize)
-		}
-
-		// 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))
-			slog.Debug("Truncating logs: limit reached", "read", totalBytesRead, "limit", maxTotalLogSize)
-			return nil
-		}
-
-		n, err := io.CopyN(builder, reader, int64(frameLen))
-		if err != nil {
-			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
-				return nil
-			}
-			return err
-		}
-		totalBytesRead += int(n)
-	}
-}
-
-// 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
-	}
-	defer resp.Body.Close()
-
-	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
-		return info, err
-	}
-
-	return info, nil
-}
-
-func (dm *dockerManager) IsPodman() bool {
-	return dm.usingPodman
-}
-
-// setIsPodman sets the manager to Podman mode and updates system details accordingly.
-func (dm *dockerManager) setIsPodman() {
-	if dm.usingPodman {
-		return
-	}
-	dm.usingPodman = true
-	dm.goodDockerVersion = true
-	dm.dockerVersionChecked = true
-	// keep system details updated - this may be detected late if server isn't ready when
-	// agent starts, so make sure we notify the hub if this happens later.
-	if dm.agent != nil {
-		dm.agent.updateSystemDetails(func(details *system.Details) {
-			details.Podman = true
-		})
-	}
-}
-
-// detectPodmanFromHeader identifies Podman from the Docker API server header.
-func detectPodmanFromHeader(server string) bool {
-	return strings.HasPrefix(server, "Libpod")
-}
-
-// detectPodmanFromVersion identifies Podman from the version payload.
-func detectPodmanFromVersion(versionInfo *dockerVersionResponse) bool {
-	if versionInfo == nil {
-		return false
-	}
-	for _, component := range versionInfo.Components {
-		if strings.HasPrefix(component.Name, "Podman") {
-			return true
-		}
-	}
-	return false
-}
-
-// detectPodmanEngine checks both header and version metadata for Podman.
-func detectPodmanEngine(serverHeader string, versionInfo *dockerVersionResponse) bool {
-	if detectPodmanFromHeader(serverHeader) {
-		return true
-	}
-	return detectPodmanFromVersion(versionInfo)
-}
--- a/agent/docker_test.go
+++ b/agent/docker_test.go
--- 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,215 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"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 = utils.ReadStringFile(filepath.Join(deviceDir, "name"))
-	out.serial = utils.ReadStringFile(filepath.Join(deviceDir, "serial"))
-	out.revision = utils.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 := utils.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 := utils.ReadStringFileOK(sizePath)
-	if !ok {
-		return 0, false
-	}
-	sectors, err := strconv.ParseUint(sizeStr, 10, 64)
-	if err != nil || sectors == 0 {
-		return 0, false
-	}
-
-	lbsStr, ok := utils.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 := utils.ReadStringFileOK(path)
-	if !ok {
-		return 0, false
-	}
-	b, ok := parseHexOrDecByte(content)
-	return b, ok
-}
-
-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,30 +5,29 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"log/slog"
 	"maps"
 	"os/exec"
 	"regexp"
-	"runtime"
 	"strconv"
 	"strings"
 	"sync"
 	"time"

-	"github.com/henrygd/beszel/agent/utils"
 	"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
@@ -41,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
@@ -82,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 {
@@ -185,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"}
@@ -217,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++
@@ -286,14 +231,13 @@ 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 = utils.BytesToMegabytes(memoryUsage)
-		gpu.MemoryTotal = utils.BytesToMegabytes(totalMemory)
+		gpu.MemoryUsed = bytesToMegabytes(memoryUsage)
+		gpu.MemoryTotal = bytesToMegabytes(totalMemory)
 		gpu.Usage += usage
 		gpu.Power += power
 		gpu.Count++
@@ -353,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
 	}

@@ -367,16 +306,16 @@ func (gm *GPUManager) calculateGPUAverage(id string, gpu *system.GPUData, cacheK
 	gpuAvg := *gpu
 	deltaUsage, deltaPower, deltaPowerPkg := gm.calculateDeltas(gpu, lastSnapshot)

-	gpuAvg.Power = utils.TwoDecimals(deltaPower / float64(deltaCount))
+	gpuAvg.Power = twoDecimals(deltaPower / float64(deltaCount))

 	if gpu.Engines != nil {
 		// make fresh map for averaged engine metrics to avoid mutating
 		// the accumulator map stored in gm.GpuDataMap
 		gpuAvg.Engines = make(map[string]float64, len(gpu.Engines))
 		gpuAvg.Usage = gm.calculateIntelGPUUsage(&gpuAvg, gpu, lastSnapshot, deltaCount)
-		gpuAvg.PowerPkg = utils.TwoDecimals(deltaPowerPkg / float64(deltaCount))
+		gpuAvg.PowerPkg = twoDecimals(deltaPowerPkg / float64(deltaCount))
 	} else {
-		gpuAvg.Usage = utils.TwoDecimals(deltaUsage / float64(deltaCount))
+		gpuAvg.Usage = twoDecimals(deltaUsage / float64(deltaCount))
 	}

 	gm.lastAvgData[id] = gpuAvg
@@ -411,17 +350,17 @@ func (gm *GPUManager) calculateIntelGPUUsage(gpuAvg, gpu *system.GPUData, lastSn
 		} else {
 			deltaEngine = engine
 		}
-		gpuAvg.Engines[name] = utils.TwoDecimals(deltaEngine / float64(deltaCount))
+		gpuAvg.Engines[name] = twoDecimals(deltaEngine / float64(deltaCount))
 		maxEngineUsage = max(maxEngineUsage, deltaEngine/float64(deltaCount))
 	}
-	return utils.TwoDecimals(maxEngineUsage)
+	return twoDecimals(maxEngineUsage)
 }

 // updateInstantaneousValues updates values that should reflect current state, not averages
 func (gm *GPUManager) updateInstantaneousValues(gpuAvg *system.GPUData, gpu *system.GPUData) {
-	gpuAvg.Temperature = utils.TwoDecimals(gpu.Temperature)
-	gpuAvg.MemoryUsed = utils.TwoDecimals(gpu.MemoryUsed)
-	gpuAvg.MemoryTotal = utils.TwoDecimals(gpu.MemoryTotal)
+	gpuAvg.Temperature = twoDecimals(gpu.Temperature)
+	gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
+	gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
 }

 // storeSnapshot saves the current GPU state for this cache key
@@ -439,325 +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 := utils.LookPathHomebrew(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: true,
-			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, _ := utils.GetEnv("NVML"); nvml == "true" {
-			priorities = append(priorities, collectorSourceNVML, collectorSourceNvidiaSMI)
-		} else {
-			priorities = append(priorities, collectorSourceNvidiaSMI)
-		}
-	}
-
-	if caps.hasRocmSmi {
-		if val, _ := utils.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, _ := utils.GetEnv("SKIP_GPU"); skipGPU == "true" {
+	if skipGPU, _ := GetEnv("SKIP_GPU"); skipGPU == "true" {
 		return nil, nil
 	}
 	var gm GPUManager
-	caps := gm.discoverGpuCapabilities()
+	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)
 	}
-
-	// Respect explicit collector selection before capability auto-detection.
-	if collectorConfig, ok := utils.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)
 	}
-
-	if !hasAnyGpuCollector(caps) {
-		return nil, fmt.Errorf(noGPUFoundMsg)
+	if gm.tegrastats {
+		gm.startCollector(tegraStatsCmd)
 	}
-
-	// 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.intelGpuStats {
+		gm.startCollector(intelGpuStatsCmd)
 	}

 	return &gm, nil
--- a/agent/gpu_amd_linux.go
+++ b/agent/gpu_amd_linux.go
@@ -1,303 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"bufio"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"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 := utils.ReadStringFileLimited(vendorPath, 64)
-		if err == nil && 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 {
-	vendor, err := utils.ReadStringFileLimited(filepath.Join(cardPath, "device/vendor"), 64)
-	if err != nil {
-		return false
-	}
-	return 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 = utils.BytesToMegabytes(memUsed)
-	gpu.MemoryTotal = utils.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 := utils.ReadStringFileLimited(path, 64)
-	if err != nil {
-		slog.Debug("Failed to read sysfs value", "path", path, "error", err)
-		return 0, err
-	}
-	return strconv.ParseFloat(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 := utils.ReadStringFileLimited(filepath.Join(devicePath, "product_name"), 128); err == nil {
-		return prod
-	}
-
-	// Read PCI device ID and look it up
-	if deviceID, err := utils.ReadStringFileLimited(filepath.Join(devicePath, "device"), 64); err == nil {
-		id := normalizeHexID(deviceID)
-		revision := ""
-		if rev, revErr := utils.ReadStringFileLimited(filepath.Join(devicePath, "revision"), 64); revErr == nil {
-			revision = normalizeHexID(rev)
-		}
-
-		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,265 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"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:  utils.BytesToMegabytes(1073741824 + 536870912),
-			wantMemoryTotal: utils.BytesToMegabytes(2147483648 + 4294967296),
-		},
-		{
-			name:            "falls back to vram when gtt is missing",
-			writeGTT:        false,
-			wantMemoryUsed:  utils.BytesToMegabytes(1073741824),
-			wantMemoryTotal: utils.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,257 +0,0 @@
-//go:build darwin
-
-package agent
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"io"
-	"log/slog"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"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) {
-	macmonPath, err := utils.LookPathHomebrew(macmonCmd)
-	if err != nil {
-		return err
-	}
-	cmd := exec.Command(macmonPath, "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
@@ -7,7 +7,6 @@ import (
 	"strconv"
 	"strings"

-	"github.com/henrygd/beszel/agent/utils"
 	"github.com/henrygd/beszel/internal/entities/system"
 )

@@ -28,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
@@ -51,12 +49,7 @@ func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {

 // collectIntelStats executes intel_gpu_top in text mode (-l) and parses the output
 func (gm *GPUManager) collectIntelStats() (err error) {
-	// Build command arguments, optionally selecting a device via -d
-	args := []string{"-s", intelGpuStatsInterval, "-l"}
-	if dev, ok := utils.GetEnv("INTEL_GPU_DEVICE"); ok && dev != "" {
-		args = append(args, "-d", dev)
-	}
-	cmd := exec.Command(intelGpuStatsCmd, args...)
+	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-l")
 	// Avoid blocking if intel_gpu_top writes to stderr
 	cmd.Stderr = io.Discard
 	stdout, err := cmd.StdoutPipe()
@@ -136,9 +129,7 @@ func (gm *GPUManager) parseIntelHeaders(header1 string, header2 string) (engineN
 	powerIndex = -1 // Initialize to -1, will be set to actual index if found
 	// Collect engine names from header1
 	for _, col := range h1 {
-		key := strings.TrimRightFunc(col, func(r rune) bool {
-			return (r >= '0' && r <= '9') || r == '/'
-		})
+		key := strings.TrimRightFunc(col, func(r rune) bool { return r >= '0' && r <= '9' })
 		var friendly string
 		switch key {
 		case "RCS":
--- 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,160 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"io"
-	"log/slog"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"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 = utils.BytesToMegabytes(parseNvtopNumber(*sample.MemUsed))
-		}
-		if sample.MemTotal != nil {
-			gpu.MemoryTotal = utils.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,16 +1,14 @@
 //go:build testing
+// +build testing

 package agent

 import (
-	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 	"time"

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

 	"github.com/stretchr/testify/assert"
@@ -250,100 +248,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, utils.BytesToMegabytes(349372416), g0.MemoryUsed)
-	assert.Equal(t, utils.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, utils.BytesToMegabytes(1213784064), g1.MemoryUsed)
-	assert.Equal(t, utils.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
@@ -401,19 +305,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 {
@@ -932,7 +823,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: {
@@ -945,10 +836,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)
@@ -957,31 +847,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{
@@ -1081,33 +946,36 @@ func TestCalculateGPUAverage(t *testing.T) {
 	})
 }

-func TestGPUCapabilitiesAndLegacyPriority(t *testing.T) {
+func TestDetectGPUs(t *testing.T) {
 	// Save original PATH
-	hasAmdSysfs := (&GPUManager{}).hasAmdSysfs()
+	origPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", origPath)
+
+	// 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"`
@@ -1119,12 +987,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"`
@@ -1133,15 +1000,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"`
@@ -1151,32 +1017,14 @@ 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 {
-				t.Setenv("PATH", "")
+			setupCommands: func() error {
+				os.Setenv("PATH", "")
 				return nil
 			},
 			wantErr: true,
@@ -1185,56 +1033,36 @@ echo "[]"`

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tempDir := t.TempDir()
-			t.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)
+
 	// Set up temp dir with the commands
 	dir := t.TempDir()
-	t.Setenv("PATH", dir)
+	os.Setenv("PATH", dir)

 	tests := []struct {
 		name     string
@@ -1312,27 +1140,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 {
@@ -1345,161 +1152,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) {
-	dir := t.TempDir()
-	t.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) {
-	dir := t.TempDir()
-	t.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) {
-	dir := t.TempDir()
-	t.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) {
-	dir := t.TempDir()
-	t.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 TestCollectorDefinitionsNvmlDoesNotRequireNvidiaSmi(t *testing.T) {
-	gm := &GPUManager{}
-	definitions := gm.collectorDefinitions(gpuCapabilities{})
-	require.Contains(t, definitions, collectorSourceNVML)
-	assert.True(t, definitions[collectorSourceNVML].available)
-}
-
-func TestNewGPUManagerConfiguredNvmlBypassesCapabilityGate(t *testing.T) {
-	dir := t.TempDir()
-	t.Setenv("PATH", dir)
-	t.Setenv("BESZEL_AGENT_GPU_COLLECTOR", "nvml")
-
-	gm, err := NewGPUManager()
-	require.Nil(t, gm)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "no configured GPU collectors are available")
-	assert.NotContains(t, err.Error(), noGPUFoundMsg)
-}
-
-func TestNewGPUManagerJetsonIgnoresCollectorConfig(t *testing.T) {
-	dir := t.TempDir()
-	t.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 {
@@ -1685,7 +1344,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)
@@ -1707,7 +1366,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
@@ -1717,8 +1376,12 @@ func TestIntelUpdateFromStats(t *testing.T) {
 }

 func TestIntelCollectorStreaming(t *testing.T) {
+	// Save and override PATH
+	origPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", origPath)
+
 	dir := t.TempDir()
-	t.Setenv("PATH", dir)
+	os.Setenv("PATH", dir)

 	// Create a fake intel_gpu_top that prints -l format with four samples (first will be skipped) and exits
 	scriptPath := filepath.Join(dir, "intel_gpu_top")
@@ -1742,7 +1405,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)
@@ -1774,15 +1437,6 @@ func TestParseIntelHeaders(t *testing.T) {
 			wantPowerIndex:    4, // "gpu" is at index 4
 			wantPreEngineCols: 8, // 17 total cols - 3*3 = 8
 		},
-		{
-			name:              "basic headers with RCS BCS VCS using index in name",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s           RCS/0           BCS/1           VCS/2",
-			header2:           " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa       %  se  wa       %  se  wa",
-			wantEngineNames:   []string{"RCS", "BCS", "VCS"},
-			wantFriendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			wantPowerIndex:    4, // "gpu" is at index 4
-			wantPreEngineCols: 8, // 17 total cols - 3*3 = 8
-		},
 		{
 			name:              "headers with only RCS",
 			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS",
@@ -1970,42 +1624,3 @@ func TestParseIntelData(t *testing.T) {
 		})
 	}
 }
-
-func TestIntelCollectorDeviceEnv(t *testing.T) {
-	dir := t.TempDir()
-	t.Setenv("PATH", dir)
-
-	// Prepare a file to capture args
-	argsFile := filepath.Join(dir, "args.txt")
-
-	// Create a fake intel_gpu_top that records its arguments and prints minimal valid output
-	scriptPath := filepath.Join(dir, "intel_gpu_top")
-	script := fmt.Sprintf(`#!/bin/sh
-echo "$@" > %s
-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"
-`, argsFile)
-	if err := os.WriteFile(scriptPath, []byte(script), 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	// Set device selector via prefixed env var
-	t.Setenv("BESZEL_AGENT_INTEL_GPU_DEVICE", "sriov")
-
-	gm := &GPUManager{GpuDataMap: make(map[string]*system.GPUData)}
-	if err := gm.collectIntelStats(); err != nil {
-		t.Fatalf("collectIntelStats error: %v", err)
-	}
-
-	// Verify that -d sriov was passed
-	data, err := os.ReadFile(argsFile)
-	if err != nil {
-		t.Fatalf("failed reading args file: %v", err)
-	}
-	argsStr := strings.TrimSpace(string(data))
-	require.Contains(t, argsStr, "-d sriov")
-	require.Contains(t, argsStr, "-s ")
-	require.Contains(t, argsStr, "-l")
-}
--- a/agent/handlers.go
+++ b/agent/handlers.go
@@ -1,15 +1,11 @@
 package agent

 import (
-	"context"
 	"errors"
 	"fmt"

 	"github.com/fxamacker/cbor/v2"
 	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/smart"
-
-	"log/slog"
 )

 // HandlerContext provides context for request handlers
@@ -47,10 +43,6 @@ func NewHandlerRegistry() *HandlerRegistry {

 	registry.Register(common.GetData, &GetDataHandler{})
 	registry.Register(common.CheckFingerprint, &CheckFingerprintHandler{})
-	registry.Register(common.GetContainerLogs, &GetContainerLogsHandler{})
-	registry.Register(common.GetContainerInfo, &GetContainerInfoHandler{})
-	registry.Register(common.GetSmartData, &GetSmartDataHandler{})
-	registry.Register(common.GetSystemdInfo, &GetSystemdInfoHandler{})

 	return registry
 }
@@ -94,7 +86,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)
 }

@@ -107,99 +99,3 @@ type CheckFingerprintHandler struct{}
 func (h *CheckFingerprintHandler) Handle(hctx *HandlerContext) error {
 	return hctx.Client.handleAuthChallenge(hctx.Request, hctx.RequestID)
 }
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetContainerLogsHandler handles container log requests
-type GetContainerLogsHandler struct{}
-
-func (h *GetContainerLogsHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.dockerManager == nil {
-		return hctx.SendResponse("", hctx.RequestID)
-	}
-
-	var req common.ContainerLogsRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-	logContent, err := hctx.Agent.dockerManager.getLogs(ctx, req.ContainerID)
-	if err != nil {
-		return err
-	}
-
-	return hctx.SendResponse(logContent, hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetContainerInfoHandler handles container info requests
-type GetContainerInfoHandler struct{}
-
-func (h *GetContainerInfoHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.dockerManager == nil {
-		return hctx.SendResponse("", hctx.RequestID)
-	}
-
-	var req common.ContainerInfoRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-	info, err := hctx.Agent.dockerManager.getContainerInfo(ctx, req.ContainerID)
-	if err != nil {
-		return err
-	}
-
-	return hctx.SendResponse(string(info), hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetSmartDataHandler handles SMART data requests
-type GetSmartDataHandler struct{}
-
-func (h *GetSmartDataHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.smartManager == nil {
-		// return empty map to indicate no data
-		return hctx.SendResponse(map[string]smart.SmartData{}, hctx.RequestID)
-	}
-	if err := hctx.Agent.smartManager.Refresh(false); err != nil {
-		slog.Debug("smart refresh failed", "err", err)
-	}
-	data := hctx.Agent.smartManager.GetCurrentData()
-	return hctx.SendResponse(data, hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetSystemdInfoHandler handles detailed systemd service info requests
-type GetSystemdInfoHandler struct{}
-
-func (h *GetSystemdInfoHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.systemdManager == nil {
-		return errors.ErrUnsupported
-	}
-
-	var req common.SystemdInfoRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-	if req.ServiceName == "" {
-		return errors.New("service name is required")
-	}
-
-	details, err := hctx.Agent.systemdManager.getServiceDetails(req.ServiceName)
-	if err != nil {
-		return err
-	}
-
-	return hctx.SendResponse(details, 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.6" />
+    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.4" />
  </ItemGroup>
 </Project>
--- a/agent/mdraid_linux.go
+++ b/agent/mdraid_linux.go
@@ -1,233 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/henrygd/beszel/agent/utils"
-	"github.com/henrygd/beszel/internal/entities/smart"
-)
-
-// mdraidSysfsRoot is a test hook; production value is "/sys".
-var mdraidSysfsRoot = "/sys"
-
-type mdraidHealth struct {
-	level         string
-	arrayState    string
-	degraded      uint64
-	raidDisks     uint64
-	syncAction    string
-	syncCompleted string
-	syncSpeed     string
-	mismatchCnt   uint64
-	capacity      uint64
-}
-
-// scanMdraidDevices discovers Linux md arrays exposed in sysfs.
-func scanMdraidDevices() []*DeviceInfo {
-	blockDir := filepath.Join(mdraidSysfsRoot, "block")
-	entries, err := os.ReadDir(blockDir)
-	if err != nil {
-		return nil
-	}
-
-	devices := make([]*DeviceInfo, 0, 2)
-	for _, ent := range entries {
-		name := ent.Name()
-		if !isMdraidBlockName(name) {
-			continue
-		}
-		mdDir := filepath.Join(blockDir, name, "md")
-		if !utils.FileExists(filepath.Join(mdDir, "array_state")) {
-			continue
-		}
-
-		devPath := filepath.Join("/dev", name)
-		devices = append(devices, &DeviceInfo{
-			Name:     devPath,
-			Type:     "mdraid",
-			InfoName: devPath + " [mdraid]",
-			Protocol: "MD",
-		})
-	}
-
-	return devices
-}
-
-// collectMdraidHealth reads mdraid health and stores it in SmartDataMap.
-func (sm *SmartManager) collectMdraidHealth(deviceInfo *DeviceInfo) (bool, error) {
-	if deviceInfo == nil || deviceInfo.Name == "" {
-		return false, nil
-	}
-
-	base := filepath.Base(deviceInfo.Name)
-	if !isMdraidBlockName(base) && !strings.EqualFold(deviceInfo.Type, "mdraid") {
-		return false, nil
-	}
-
-	health, ok := readMdraidHealth(base)
-	if !ok {
-		return false, nil
-	}
-
-	deviceInfo.Type = "mdraid"
-	key := fmt.Sprintf("mdraid:%s", base)
-	status := mdraidSmartStatus(health)
-
-	attrs := make([]*smart.SmartAttribute, 0, 10)
-	if health.arrayState != "" {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "ArrayState", RawString: health.arrayState})
-	}
-	if health.level != "" {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "RaidLevel", RawString: health.level})
-	}
-	if health.raidDisks > 0 {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "RaidDisks", RawValue: health.raidDisks})
-	}
-	if health.degraded > 0 {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "Degraded", RawValue: health.degraded})
-	}
-	if health.syncAction != "" {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "SyncAction", RawString: health.syncAction})
-	}
-	if health.syncCompleted != "" {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "SyncCompleted", RawString: health.syncCompleted})
-	}
-	if health.syncSpeed != "" {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "SyncSpeed", RawString: health.syncSpeed})
-	}
-	if health.mismatchCnt > 0 {
-		attrs = append(attrs, &smart.SmartAttribute{Name: "MismatchCount", RawValue: health.mismatchCnt})
-	}
-
-	sm.Lock()
-	defer sm.Unlock()
-
-	if _, exists := sm.SmartDataMap[key]; !exists {
-		sm.SmartDataMap[key] = &smart.SmartData{}
-	}
-
-	data := sm.SmartDataMap[key]
-	data.ModelName = "Linux MD RAID"
-	if health.level != "" {
-		data.ModelName = "Linux MD RAID (" + health.level + ")"
-	}
-	data.Capacity = health.capacity
-	data.SmartStatus = status
-	data.DiskName = filepath.Join("/dev", base)
-	data.DiskType = "mdraid"
-	data.Attributes = attrs
-
-	return true, nil
-}
-
-// readMdraidHealth reads md array health fields from sysfs.
-func readMdraidHealth(blockName string) (mdraidHealth, bool) {
-	var out mdraidHealth
-
-	if !isMdraidBlockName(blockName) {
-		return out, false
-	}
-
-	mdDir := filepath.Join(mdraidSysfsRoot, "block", blockName, "md")
-	arrayState, okState := utils.ReadStringFileOK(filepath.Join(mdDir, "array_state"))
-	if !okState {
-		return out, false
-	}
-
-	out.arrayState = arrayState
-	out.level = utils.ReadStringFile(filepath.Join(mdDir, "level"))
-	out.syncAction = utils.ReadStringFile(filepath.Join(mdDir, "sync_action"))
-	out.syncCompleted = utils.ReadStringFile(filepath.Join(mdDir, "sync_completed"))
-	out.syncSpeed = utils.ReadStringFile(filepath.Join(mdDir, "sync_speed"))
-
-	if val, ok := utils.ReadUintFile(filepath.Join(mdDir, "raid_disks")); ok {
-		out.raidDisks = val
-	}
-	if val, ok := utils.ReadUintFile(filepath.Join(mdDir, "degraded")); ok {
-		out.degraded = val
-	}
-	if val, ok := utils.ReadUintFile(filepath.Join(mdDir, "mismatch_cnt")); ok {
-		out.mismatchCnt = val
-	}
-
-	if capBytes, ok := readMdraidBlockCapacityBytes(blockName, mdraidSysfsRoot); ok {
-		out.capacity = capBytes
-	}
-
-	return out, true
-}
-
-// mdraidSmartStatus maps md state/sync signals to a SMART-like status.
-func mdraidSmartStatus(health mdraidHealth) string {
-	state := strings.ToLower(strings.TrimSpace(health.arrayState))
-	switch state {
-	case "inactive", "faulty", "broken", "stopped":
-		return "FAILED"
-	}
-	// During rebuild/recovery, arrays are often temporarily degraded; report as
-	// warning instead of hard failure while synchronization is in progress.
-	syncAction := strings.ToLower(strings.TrimSpace(health.syncAction))
-	switch syncAction {
-	case "resync", "recover", "reshape":
-		return "WARNING"
-	}
-	if health.degraded > 0 {
-		return "FAILED"
-	}
-	switch syncAction {
-	case "check", "repair":
-		return "WARNING"
-	}
-	switch state {
-	case "clean", "active", "active-idle", "write-pending", "read-auto", "readonly":
-		return "PASSED"
-	}
-	return "UNKNOWN"
-}
-
-// isMdraidBlockName matches /dev/mdN-style block device names.
-func isMdraidBlockName(name string) bool {
-	if !strings.HasPrefix(name, "md") {
-		return false
-	}
-	suffix := strings.TrimPrefix(name, "md")
-	if suffix == "" {
-		return false
-	}
-	for _, c := range suffix {
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-// readMdraidBlockCapacityBytes converts block size metadata into bytes.
-func readMdraidBlockCapacityBytes(blockName, root string) (uint64, bool) {
-	sizePath := filepath.Join(root, "block", blockName, "size")
-	lbsPath := filepath.Join(root, "block", blockName, "queue", "logical_block_size")
-
-	sizeStr, ok := utils.ReadStringFileOK(sizePath)
-	if !ok {
-		return 0, false
-	}
-	sectors, err := strconv.ParseUint(sizeStr, 10, 64)
-	if err != nil || sectors == 0 {
-		return 0, false
-	}
-
-	logicalBlockSize := uint64(512)
-	if lbsStr, ok := utils.ReadStringFileOK(lbsPath); ok {
-		if parsed, err := strconv.ParseUint(lbsStr, 10, 64); err == nil && parsed > 0 {
-			logicalBlockSize = parsed
-		}
-	}
-
-	return sectors * logicalBlockSize, true
-}
--- a/agent/mdraid_linux_test.go
+++ b/agent/mdraid_linux_test.go
@@ -1,103 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/smart"
-)
-
-func TestMdraidMockSysfsScanAndCollect(t *testing.T) {
-	tmp := t.TempDir()
-	prev := mdraidSysfsRoot
-	mdraidSysfsRoot = tmp
-	t.Cleanup(func() { mdraidSysfsRoot = prev })
-
-	mdDir := filepath.Join(tmp, "block", "md0", "md")
-	queueDir := filepath.Join(tmp, "block", "md0", "queue")
-	if err := os.MkdirAll(mdDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(queueDir, 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(mdDir, "array_state"), "active\n")
-	write(filepath.Join(mdDir, "level"), "raid1\n")
-	write(filepath.Join(mdDir, "raid_disks"), "2\n")
-	write(filepath.Join(mdDir, "degraded"), "0\n")
-	write(filepath.Join(mdDir, "sync_action"), "resync\n")
-	write(filepath.Join(mdDir, "sync_completed"), "10%\n")
-	write(filepath.Join(mdDir, "sync_speed"), "100M\n")
-	write(filepath.Join(mdDir, "mismatch_cnt"), "0\n")
-	write(filepath.Join(queueDir, "logical_block_size"), "512\n")
-	write(filepath.Join(tmp, "block", "md0", "size"), "2048\n")
-
-	devs := scanMdraidDevices()
-	if len(devs) != 1 {
-		t.Fatalf("scanMdraidDevices() = %d devices, want 1", len(devs))
-	}
-	if devs[0].Name != "/dev/md0" || devs[0].Type != "mdraid" {
-		t.Fatalf("scanMdraidDevices()[0] = %+v, want Name=/dev/md0 Type=mdraid", devs[0])
-	}
-
-	sm := &SmartManager{SmartDataMap: map[string]*smart.SmartData{}}
-	ok, err := sm.collectMdraidHealth(devs[0])
-	if err != nil || !ok {
-		t.Fatalf("collectMdraidHealth() = (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 != "mdraid" || got.DiskName != "/dev/md0" {
-		t.Fatalf("disk fields = (type=%q name=%q), want (mdraid,/dev/md0)", got.DiskType, got.DiskName)
-	}
-	if got.SmartStatus != "WARNING" {
-		t.Fatalf("SmartStatus=%q, want WARNING", got.SmartStatus)
-	}
-	if got.ModelName == "" || got.Capacity == 0 {
-		t.Fatalf("identity fields = (model=%q cap=%d), want non-empty model and cap>0", got.ModelName, got.Capacity)
-	}
-	if len(got.Attributes) < 5 {
-		t.Fatalf("attributes len=%d, want >= 5", len(got.Attributes))
-	}
-}
-
-func TestMdraidSmartStatus(t *testing.T) {
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "inactive"}); got != "FAILED" {
-		t.Fatalf("mdraidSmartStatus(inactive) = %q, want FAILED", got)
-	}
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "active", degraded: 1, syncAction: "recover"}); got != "WARNING" {
-		t.Fatalf("mdraidSmartStatus(degraded+recover) = %q, want WARNING", got)
-	}
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "active", degraded: 1}); got != "FAILED" {
-		t.Fatalf("mdraidSmartStatus(degraded) = %q, want FAILED", got)
-	}
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "active", syncAction: "recover"}); got != "WARNING" {
-		t.Fatalf("mdraidSmartStatus(recover) = %q, want WARNING", got)
-	}
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "clean"}); got != "PASSED" {
-		t.Fatalf("mdraidSmartStatus(clean) = %q, want PASSED", got)
-	}
-	if got := mdraidSmartStatus(mdraidHealth{arrayState: "unknown"}); got != "UNKNOWN" {
-		t.Fatalf("mdraidSmartStatus(unknown) = %q, want UNKNOWN", got)
-	}
-}
--- a/agent/mdraid_stub.go
+++ b/agent/mdraid_stub.go
@@ -1,11 +0,0 @@
-//go:build !linux
-
-package agent
-
-func scanMdraidDevices() []*DeviceInfo {
-	return nil
-}
-
-func (sm *SmartManager) collectMdraidHealth(deviceInfo *DeviceInfo) (bool, error) {
-	return false, nil
-}
--- a/agent/network.go
+++ b/agent/network.go
@@ -8,7 +8,6 @@ import (
 	"time"

 	"github.com/henrygd/beszel/agent/deltatracker"
-	"github.com/henrygd/beszel/agent/utils"
 	"github.com/henrygd/beszel/internal/entities/system"
 	psutilNet "github.com/shirou/gopsutil/v4/net"
 )
@@ -95,7 +94,7 @@ func (a *Agent) initializeNetIoStats() {
 	a.netInterfaces = make(map[string]struct{}, 0)

 	// parse NICS env var for whitelist / blacklist
-	nicsEnvVal, nicsEnvExists := utils.GetEnv("NICS")
+	nicsEnvVal, nicsEnvExists := GetEnv("NICS")
 	var nicCfg *NicConfig
 	if nicsEnvExists {
 		nicCfg = newNicConfig(nicsEnvVal)
@@ -104,7 +103,10 @@ func (a *Agent) initializeNetIoStats() {
 	// get current network I/O stats and record valid interfaces
 	if netIO, err := psutilNet.IOCounters(true); err == nil {
 		for _, v := range netIO {
-			if skipNetworkInterface(v, nicCfg) {
+			if nicsEnvExists && !isValidNic(v.Name, nicCfg) {
+				continue
+			}
+			if a.skipNetworkInterface(v) {
 				continue
 			}
 			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
@@ -213,8 +215,10 @@ func (a *Agent) applyNetworkTotals(
 	totalBytesSent, totalBytesRecv uint64,
 	bytesSentPerSecond, bytesRecvPerSecond uint64,
 ) {
-	if bytesSentPerSecond > 10_000_000_000 || bytesRecvPerSecond > 10_000_000_000 {
-		slog.Warn("Invalid net stats. Resetting.", "sent", bytesSentPerSecond, "recv", bytesRecvPerSecond)
+	networkSentPs := bytesToMegabytes(float64(bytesSentPerSecond))
+	networkRecvPs := bytesToMegabytes(float64(bytesRecvPerSecond))
+	if networkSentPs > 10_000 || networkRecvPs > 10_000 {
+		slog.Warn("Invalid net stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
 		for _, v := range netIO {
 			if _, exists := a.netInterfaces[v.Name]; !exists {
 				continue
@@ -224,29 +228,21 @@ func (a *Agent) applyNetworkTotals(
 		a.initializeNetIoStats()
 		delete(a.netIoStats, cacheTimeMs)
 		delete(a.netInterfaceDeltaTrackers, cacheTimeMs)
+		systemStats.NetworkSent = 0
+		systemStats.NetworkRecv = 0
 		systemStats.Bandwidth[0], systemStats.Bandwidth[1] = 0, 0
 		return
 	}

+	systemStats.NetworkSent = networkSentPs
+	systemStats.NetworkRecv = networkRecvPs
 	systemStats.Bandwidth[0], systemStats.Bandwidth[1] = bytesSentPerSecond, bytesRecvPerSecond
 	nis.BytesSent = totalBytesSent
 	nis.BytesRecv = totalBytesRecv
 	a.netIoStats[cacheTimeMs] = nis
 }

-// skipNetworkInterface returns true if the network interface should be ignored.
-func skipNetworkInterface(v psutilNet.IOCountersStat, nicCfg *NicConfig) bool {
-	if nicCfg != nil {
-		if !isValidNic(v.Name, nicCfg) {
-			return true
-		}
-		// In whitelist mode, we honor explicit inclusion without auto-filtering.
-		if !nicCfg.isBlacklist {
-			return false
-		}
-		// In blacklist mode, still apply the auto-filter below.
-	}
-
+func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
 	switch {
 	case strings.HasPrefix(v.Name, "lo"),
 		strings.HasPrefix(v.Name, "docker"),
--- a/agent/network_test.go
+++ b/agent/network_test.go
@@ -261,39 +261,6 @@ func TestNewNicConfig(t *testing.T) {
 		})
 	}
 }
-func TestSkipNetworkInterface(t *testing.T) {
-	tests := []struct {
-		name       string
-		nic        psutilNet.IOCountersStat
-		nicCfg     *NicConfig
-		expectSkip bool
-	}{
-		{"loopback lo", psutilNet.IOCountersStat{Name: "lo", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"loopback lo0", psutilNet.IOCountersStat{Name: "lo0", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"docker prefix", psutilNet.IOCountersStat{Name: "docker0", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"br- prefix", psutilNet.IOCountersStat{Name: "br-lan", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"veth prefix", psutilNet.IOCountersStat{Name: "veth0abc", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"bond prefix", psutilNet.IOCountersStat{Name: "bond0", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"cali prefix", psutilNet.IOCountersStat{Name: "cali1234", BytesSent: 100, BytesRecv: 100}, nil, true},
-		{"zero BytesRecv", psutilNet.IOCountersStat{Name: "eth0", BytesSent: 100, BytesRecv: 0}, nil, true},
-		{"zero BytesSent", psutilNet.IOCountersStat{Name: "eth0", BytesSent: 0, BytesRecv: 100}, nil, true},
-		{"both zero", psutilNet.IOCountersStat{Name: "eth0", BytesSent: 0, BytesRecv: 0}, nil, true},
-		{"normal eth0", psutilNet.IOCountersStat{Name: "eth0", BytesSent: 100, BytesRecv: 200}, nil, false},
-		{"normal wlan0", psutilNet.IOCountersStat{Name: "wlan0", BytesSent: 1, BytesRecv: 1}, nil, false},
-		{"whitelist overrides skip (docker)", psutilNet.IOCountersStat{Name: "docker0", BytesSent: 100, BytesRecv: 100}, newNicConfig("docker0"), false},
-		{"whitelist overrides skip (lo)", psutilNet.IOCountersStat{Name: "lo", BytesSent: 100, BytesRecv: 100}, newNicConfig("lo"), false},
-		{"whitelist exclusion", psutilNet.IOCountersStat{Name: "eth1", BytesSent: 100, BytesRecv: 100}, newNicConfig("eth0"), true},
-		{"blacklist skip lo", psutilNet.IOCountersStat{Name: "lo", BytesSent: 100, BytesRecv: 100}, newNicConfig("-eth0"), true},
-		{"blacklist explicit eth0", psutilNet.IOCountersStat{Name: "eth0", BytesSent: 100, BytesRecv: 100}, newNicConfig("-eth0"), true},
-		{"blacklist allow eth1", psutilNet.IOCountersStat{Name: "eth1", BytesSent: 100, BytesRecv: 100}, newNicConfig("-eth0"), false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.expectSkip, skipNetworkInterface(tt.nic, tt.nicCfg))
-		})
-	}
-}
-
 func TestEnsureNetworkInterfacesMap(t *testing.T) {
 	var a Agent
 	var stats system.Stats
@@ -416,6 +383,8 @@ func TestApplyNetworkTotals(t *testing.T) {
 		totalBytesSent        uint64
 		totalBytesRecv        uint64
 		expectReset           bool
+		expectedNetworkSent   float64
+		expectedNetworkRecv   float64
 		expectedBandwidthSent uint64
 		expectedBandwidthRecv uint64
 	}{
@@ -426,6 +395,8 @@ func TestApplyNetworkTotals(t *testing.T) {
 			totalBytesSent:        10000000,
 			totalBytesRecv:        20000000,
 			expectReset:           false,
+			expectedNetworkSent:   0.95, // ~1 MB/s rounded to 2 decimals
+			expectedNetworkRecv:   1.91, // ~2 MB/s rounded to 2 decimals
 			expectedBandwidthSent: 1000000,
 			expectedBandwidthRecv: 2000000,
 		},
@@ -453,6 +424,18 @@ func TestApplyNetworkTotals(t *testing.T) {
 			totalBytesRecv:     20000000,
 			expectReset:        true,
 		},
+		{
+			name:                  "Valid network stats - at threshold boundary",
+			bytesSentPerSecond:    10485750000, // ~9999.99 MB/s (rounds to 9999.99)
+			bytesRecvPerSecond:    10485750000, // ~9999.99 MB/s (rounds to 9999.99)
+			totalBytesSent:        10000000,
+			totalBytesRecv:        20000000,
+			expectReset:           false,
+			expectedNetworkSent:   9999.99,
+			expectedNetworkRecv:   9999.99,
+			expectedBandwidthSent: 10485750000,
+			expectedBandwidthRecv: 10485750000,
+		},
 		{
 			name:                  "Zero values",
 			bytesSentPerSecond:    0,
@@ -460,6 +443,8 @@ func TestApplyNetworkTotals(t *testing.T) {
 			totalBytesSent:        0,
 			totalBytesRecv:        0,
 			expectReset:           false,
+			expectedNetworkSent:   0.0,
+			expectedNetworkRecv:   0.0,
 			expectedBandwidthSent: 0,
 			expectedBandwidthRecv: 0,
 		},
@@ -496,10 +481,14 @@ func TestApplyNetworkTotals(t *testing.T) {
 				// Should have reset network tracking state - maps cleared and stats zeroed
 				assert.NotContains(t, a.netIoStats, cacheTimeMs, "cache entry should be cleared after reset")
 				assert.NotContains(t, a.netInterfaceDeltaTrackers, cacheTimeMs, "tracker should be cleared on reset")
+				assert.Zero(t, systemStats.NetworkSent)
+				assert.Zero(t, systemStats.NetworkRecv)
 				assert.Zero(t, systemStats.Bandwidth[0])
 				assert.Zero(t, systemStats.Bandwidth[1])
 			} else {
 				// Should have applied stats
+				assert.Equal(t, tt.expectedNetworkSent, systemStats.NetworkSent)
+				assert.Equal(t, tt.expectedNetworkRecv, systemStats.NetworkRecv)
 				assert.Equal(t, tt.expectedBandwidthSent, systemStats.Bandwidth[0])
 				assert.Equal(t, tt.expectedBandwidthRecv, systemStats.Bandwidth[1])

--- 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.go
+++ b/agent/sensors.go
@@ -2,67 +2,48 @@ package agent

 import (
 	"context"
-	"errors"
 	"fmt"
 	"log/slog"
 	"path"
 	"runtime"
 	"strconv"
 	"strings"
-	"time"
 	"unicode/utf8"

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

 	"github.com/shirou/gopsutil/v4/common"
 	"github.com/shirou/gopsutil/v4/sensors"
 )

-var errTemperatureFetchTimeout = errors.New("temperature collection timed out")
-
-// Matches sensors.TemperaturesWithContext to allow for panic recovery (gopsutil/issues/1832)
-type getTempsFn func(ctx context.Context) ([]sensors.TemperatureStat, error)
-
 type SensorConfig struct {
 	context        context.Context
 	sensors        map[string]struct{}
 	primarySensor  string
-	timeout        time.Duration
 	isBlacklist    bool
 	hasWildcards   bool
 	skipCollection bool
-	firstRun       bool
 }

 func (a *Agent) newSensorConfig() *SensorConfig {
-	primarySensor, _ := utils.GetEnv("PRIMARY_SENSOR")
-	sysSensors, _ := utils.GetEnv("SYS_SENSORS")
-	sensorsEnvVal, sensorsSet := utils.GetEnv("SENSORS")
+	primarySensor, _ := GetEnv("PRIMARY_SENSOR")
+	sysSensors, _ := GetEnv("SYS_SENSORS")
+	sensorsEnvVal, sensorsSet := GetEnv("SENSORS")
 	skipCollection := sensorsSet && sensorsEnvVal == ""
-	sensorsTimeout, _ := utils.GetEnv("SENSORS_TIMEOUT")

-	return a.newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal, sensorsTimeout, skipCollection)
+	return a.newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal, skipCollection)
 }

+// Matches sensors.TemperaturesWithContext to allow for panic recovery (gopsutil/issues/1832)
+type getTempsFn func(ctx context.Context) ([]sensors.TemperatureStat, error)
+
 // newSensorConfigWithEnv creates a SensorConfig with the provided environment variables
 // sensorsSet indicates if the SENSORS environment variable was explicitly set (even to empty string)
-func (a *Agent) newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal, sensorsTimeout string, skipCollection bool) *SensorConfig {
-	timeout := 2 * time.Second
-	if sensorsTimeout != "" {
-		if d, err := time.ParseDuration(sensorsTimeout); err == nil {
-			timeout = d
-		} else {
-			slog.Warn("Invalid SENSORS_TIMEOUT", "value", sensorsTimeout)
-		}
-	}
-
+func (a *Agent) newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal string, skipCollection bool) *SensorConfig {
 	config := &SensorConfig{
 		context:        context.Background(),
 		primarySensor:  primarySensor,
-		timeout:        timeout,
 		skipCollection: skipCollection,
-		firstRun:       true,
 		sensors:        make(map[string]struct{}),
 	}

@@ -104,12 +85,10 @@ func (a *Agent) updateTemperatures(systemStats *system.Stats) {
 	// reset high temp
 	a.systemInfo.DashboardTemp = 0

-	temps, err := a.getTempsWithTimeout(getSensorTemps)
+	temps, err := a.getTempsWithPanicRecovery(getSensorTemps)
 	if err != nil {
 		// retry once on panic (gopsutil/issues/1832)
-		if !errors.Is(err, errTemperatureFetchTimeout) {
-			temps, err = a.getTempsWithTimeout(getSensorTemps)
-		}
+		temps, err = a.getTempsWithPanicRecovery(getSensorTemps)
 		if err != nil {
 			slog.Warn("Error updating temperatures", "err", err)
 			if len(systemStats.Temperatures) > 0 {
@@ -156,7 +135,7 @@ func (a *Agent) updateTemperatures(systemStats *system.Stats) {
 		case sensorName:
 			a.systemInfo.DashboardTemp = sensor.Temperature
 		}
-		systemStats.Temperatures[sensorName] = utils.TwoDecimals(sensor.Temperature)
+		systemStats.Temperatures[sensorName] = twoDecimals(sensor.Temperature)
 	}
 }

@@ -172,34 +151,6 @@ func (a *Agent) getTempsWithPanicRecovery(getTemps getTempsFn) (temps []sensors.
 	return
 }

-func (a *Agent) getTempsWithTimeout(getTemps getTempsFn) ([]sensors.TemperatureStat, error) {
-	type result struct {
-		temps []sensors.TemperatureStat
-		err   error
-	}
-
-	// Use a longer timeout on the first run to allow for initialization
-	// (e.g. Windows LHM subprocess startup)
-	timeout := a.sensorConfig.timeout
-	if a.sensorConfig.firstRun {
-		a.sensorConfig.firstRun = false
-		timeout = 10 * time.Second
-	}
-
-	resultCh := make(chan result, 1)
-	go func() {
-		temps, err := a.getTempsWithPanicRecovery(getTemps)
-		resultCh <- result{temps: temps, err: err}
-	}()
-
-	select {
-	case res := <-resultCh:
-		return res.temps, res.err
-	case <-time.After(timeout):
-		return nil, errTemperatureFetchTimeout
-	}
-}
-
 // isValidSensor checks if a sensor is valid based on the sensor name and the sensor config
 func isValidSensor(sensorName string, config *SensorConfig) bool {
 	// if no sensors configured, everything is valid
--- a/agent/sensors_test.go
+++ b/agent/sensors_test.go
@@ -1,12 +1,13 @@
 //go:build testing
+// +build testing

 package agent

 import (
 	"context"
 	"fmt"
+	"os"
 	"testing"
-	"time"

 	"github.com/henrygd/beszel/internal/entities/system"

@@ -168,7 +169,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 		primarySensor  string
 		sysSensors     string
 		sensors        string
-		sensorsTimeout string
 		skipCollection bool
 		expectedConfig *SensorConfig
 	}{
@@ -180,37 +180,12 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:        context.Background(),
 				primarySensor:  "",
-				timeout:        2 * time.Second,
 				sensors:        map[string]struct{}{},
 				isBlacklist:    false,
 				hasWildcards:   false,
 				skipCollection: false,
 			},
 		},
-		{
-			name:           "Custom timeout",
-			primarySensor:  "",
-			sysSensors:     "",
-			sensors:        "",
-			sensorsTimeout: "5s",
-			expectedConfig: &SensorConfig{
-				context: context.Background(),
-				timeout: 5 * time.Second,
-				sensors: map[string]struct{}{},
-			},
-		},
-		{
-			name:           "Invalid timeout falls back to default",
-			primarySensor:  "",
-			sysSensors:     "",
-			sensors:        "",
-			sensorsTimeout: "notaduration",
-			expectedConfig: &SensorConfig{
-				context: context.Background(),
-				timeout: 2 * time.Second,
-				sensors: map[string]struct{}{},
-			},
-		},
 		{
 			name:           "Explicitly set to empty string",
 			primarySensor:  "",
@@ -220,7 +195,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:        context.Background(),
 				primarySensor:  "",
-				timeout:        2 * time.Second,
 				sensors:        map[string]struct{}{},
 				isBlacklist:    false,
 				hasWildcards:   false,
@@ -235,7 +209,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:       context.Background(),
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors:       map[string]struct{}{},
 				isBlacklist:   false,
 				hasWildcards:  false,
@@ -249,7 +222,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:       context.Background(),
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors: map[string]struct{}{
 					"cpu_temp": {},
 					"gpu_temp": {},
@@ -266,7 +238,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:       context.Background(),
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors: map[string]struct{}{
 					"cpu_temp": {},
 					"gpu_temp": {},
@@ -283,7 +254,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:       context.Background(),
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors: map[string]struct{}{
 					"cpu_*":    {},
 					"gpu_temp": {},
@@ -300,7 +270,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			expectedConfig: &SensorConfig{
 				context:       context.Background(),
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors: map[string]struct{}{
 					"cpu_*":    {},
 					"gpu_temp": {},
@@ -316,7 +285,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			sensors:       "cpu_temp",
 			expectedConfig: &SensorConfig{
 				primarySensor: "cpu_temp",
-				timeout:       2 * time.Second,
 				sensors: map[string]struct{}{
 					"cpu_temp": {},
 				},
@@ -328,7 +296,7 @@ func TestNewSensorConfigWithEnv(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := agent.newSensorConfigWithEnv(tt.primarySensor, tt.sysSensors, tt.sensors, tt.sensorsTimeout, tt.skipCollection)
+			result := agent.newSensorConfigWithEnv(tt.primarySensor, tt.sysSensors, tt.sensors, tt.skipCollection)

 			// Check primary sensor
 			assert.Equal(t, tt.expectedConfig.primarySensor, result.primarySensor)
@@ -347,7 +315,6 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 			// Check flags
 			assert.Equal(t, tt.expectedConfig.isBlacklist, result.isBlacklist)
 			assert.Equal(t, tt.expectedConfig.hasWildcards, result.hasWildcards)
-			assert.Equal(t, tt.expectedConfig.timeout, result.timeout)

 			// Check context
 			if tt.sysSensors != "" {
@@ -363,18 +330,40 @@ func TestNewSensorConfigWithEnv(t *testing.T) {
 }

 func TestNewSensorConfig(t *testing.T) {
+	// Save original environment variables
+	originalPrimary, hasPrimary := os.LookupEnv("BESZEL_AGENT_PRIMARY_SENSOR")
+	originalSys, hasSys := os.LookupEnv("BESZEL_AGENT_SYS_SENSORS")
+	originalSensors, hasSensors := os.LookupEnv("BESZEL_AGENT_SENSORS")
+
+	// Restore environment variables after the test
+	defer func() {
+		// Clean up test environment variables
+		os.Unsetenv("BESZEL_AGENT_PRIMARY_SENSOR")
+		os.Unsetenv("BESZEL_AGENT_SYS_SENSORS")
+		os.Unsetenv("BESZEL_AGENT_SENSORS")
+
+		// Restore original values if they existed
+		if hasPrimary {
+			os.Setenv("BESZEL_AGENT_PRIMARY_SENSOR", originalPrimary)
+		}
+		if hasSys {
+			os.Setenv("BESZEL_AGENT_SYS_SENSORS", originalSys)
+		}
+		if hasSensors {
+			os.Setenv("BESZEL_AGENT_SENSORS", originalSensors)
+		}
+	}()
+
 	// Set test environment variables
-	t.Setenv("BESZEL_AGENT_PRIMARY_SENSOR", "test_primary")
-	t.Setenv("BESZEL_AGENT_SYS_SENSORS", "/test/path")
-	t.Setenv("BESZEL_AGENT_SENSORS", "test_sensor1,test_*,test_sensor3")
-	t.Setenv("BESZEL_AGENT_SENSORS_TIMEOUT", "7s")
+	os.Setenv("BESZEL_AGENT_PRIMARY_SENSOR", "test_primary")
+	os.Setenv("BESZEL_AGENT_SYS_SENSORS", "/test/path")
+	os.Setenv("BESZEL_AGENT_SENSORS", "test_sensor1,test_*,test_sensor3")

 	agent := &Agent{}
 	result := agent.newSensorConfig()

 	// Verify results
 	assert.Equal(t, "test_primary", result.primarySensor)
-	assert.Equal(t, 7*time.Second, result.timeout)
 	assert.NotNil(t, result.sensors)
 	assert.Equal(t, 3, len(result.sensors))
 	assert.True(t, result.hasWildcards)
@@ -563,59 +552,3 @@ func TestGetTempsWithPanicRecovery(t *testing.T) {
 		})
 	}
 }
-
-func TestGetTempsWithTimeout(t *testing.T) {
-	agent := &Agent{
-		sensorConfig: &SensorConfig{
-			context: context.Background(),
-			timeout: 10 * time.Millisecond,
-		},
-	}
-
-	t.Run("returns temperatures before timeout", func(t *testing.T) {
-		temps, err := agent.getTempsWithTimeout(func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-			return []sensors.TemperatureStat{{SensorKey: "cpu_temp", Temperature: 42}}, nil
-		})
-
-		require.NoError(t, err)
-		require.Len(t, temps, 1)
-		assert.Equal(t, "cpu_temp", temps[0].SensorKey)
-	})
-
-	t.Run("returns timeout error when collector hangs", func(t *testing.T) {
-		temps, err := agent.getTempsWithTimeout(func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-			time.Sleep(50 * time.Millisecond)
-			return []sensors.TemperatureStat{{SensorKey: "cpu_temp", Temperature: 42}}, nil
-		})
-
-		assert.Nil(t, temps)
-		assert.ErrorIs(t, err, errTemperatureFetchTimeout)
-	})
-}
-
-func TestUpdateTemperaturesSkipsOnTimeout(t *testing.T) {
-	agent := &Agent{
-		systemInfo: system.Info{DashboardTemp: 99},
-		sensorConfig: &SensorConfig{
-			context: context.Background(),
-			timeout: 10 * time.Millisecond,
-		},
-	}
-
-	t.Cleanup(func() {
-		getSensorTemps = sensors.TemperaturesWithContext
-	})
-	getSensorTemps = func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-		time.Sleep(50 * time.Millisecond)
-		return nil, nil
-	}
-
-	stats := &system.Stats{
-		Temperatures: map[string]float64{"stale": 50},
-	}
-
-	agent.updateTemperatures(stats)
-
-	assert.Equal(t, 0.0, agent.systemInfo.DashboardTemp)
-	assert.Equal(t, map[string]float64{}, stats.Temperatures)
-}
--- a/agent/server.go
+++ b/agent/server.go
@@ -12,7 +12,6 @@ import (
 	"time"

 	"github.com/henrygd/beszel"
-	"github.com/henrygd/beszel/agent/utils"
 	"github.com/henrygd/beszel/internal/common"
 	"github.com/henrygd/beszel/internal/entities/system"

@@ -37,9 +36,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, _ := utils.GetEnv("DISABLE_SSH"); disableSSH == "true" {
-		return errors.New("SSH disabled")
-	}
 	if a.server != nil {
 		return errors.New("server already started")
 	}
@@ -167,9 +163,14 @@ 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
+		default:
+			response.Error = fmt.Sprintf("unsupported response type: %T", data)
+		}
 		return cbor.NewEncoder(w).Encode(response)
 	}

@@ -193,7 +194,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: defaultDataCacheTimeMs})
+	stats := a.gatherStats(60_000)
 	return a.writeToSession(w, stats, hubVersion)
 }

@@ -239,11 +240,11 @@ func ParseKeys(input string) ([]gossh.PublicKey, error) {
 // and finally defaults to ":45876".
 func GetAddress(addr string) string {
 	if addr == "" {
-		addr, _ = utils.GetEnv("LISTEN")
+		addr, _ = GetEnv("LISTEN")
 	}
 	if addr == "" {
 		// Legacy PORT environment variable support
-		addr, _ = utils.GetEnv("PORT")
+		addr, _ = GetEnv("PORT")
 	}
 	if addr == "" {
 		return ":45876"
@@ -259,7 +260,7 @@ func GetAddress(addr string) string {
 // It checks the NETWORK environment variable first, then infers from
 // the address format: addresses starting with "/" are "unix", others are "tcp".
 func GetNetwork(addr string) string {
-	if network, ok := utils.GetEnv("NETWORK"); ok && network != "" {
+	if network, ok := GetEnv("NETWORK"); ok && network != "" {
 		return network
 	}
 	if strings.HasPrefix(addr, "/") {
--- a/agent/server_test.go
+++ b/agent/server_test.go
@@ -1,5 +1,3 @@
-//go:build testing
-
 package agent

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

-func TestStartServerDisableSSH(t *testing.T) {
-	t.Setenv("BESZEL_AGENT_DISABLE_SSH", "true")
-
-	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 ////////////////////////////
 /////////////////////////////////////////////////////////////////
@@ -531,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
@@ -544,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)
@@ -568,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
--- a/agent/smart_nonwindows.go
+++ b/agent/smart_nonwindows.go
@@ -1,9 +0,0 @@
-//go:build !windows
-
-package agent
-
-import "errors"
-
-func ensureEmbeddedSmartctl() (string, error) {
-	return "", errors.ErrUnsupported
-}
--- a/agent/smart_test.go
+++ b/agent/smart_test.go
--- a/agent/smart_windows.go
+++ b/agent/smart_windows.go
@@ -1,40 +0,0 @@
-//go:build windows
-
-package agent
-
-import (
-	_ "embed"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-//go:embed smartmontools/smartctl.exe
-var embeddedSmartctl []byte
-
-var (
-	smartctlOnce sync.Once
-	smartctlPath string
-	smartctlErr  error
-)
-
-func ensureEmbeddedSmartctl() (string, error) {
-	smartctlOnce.Do(func() {
-		destDir := filepath.Join(os.TempDir(), "beszel", "smartmontools")
-		if err := os.MkdirAll(destDir, 0o755); err != nil {
-			smartctlErr = fmt.Errorf("failed to create smartctl directory: %w", err)
-			return
-		}
-
-		destPath := filepath.Join(destDir, "smartctl.exe")
-		if err := os.WriteFile(destPath, embeddedSmartctl, 0o755); err != nil {
-			smartctlErr = fmt.Errorf("failed to write embedded smartctl: %w", err)
-			return
-		}
-
-		smartctlPath = destPath
-	})
-
-	return smartctlPath, smartctlErr
-}
--- 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/agent/utils"
-	"github.com/henrygd/beszel/agent/zfs"
-	"github.com/henrygd/beszel/internal/entities/container"
 	"github.com/henrygd/beszel/internal/entities/system"

 	"github.com/shirou/gopsutil/v4/cpu"
@@ -22,139 +19,75 @@ import (
 	"github.com/shirou/gopsutil/v4/mem"
 )

+// prevDisk stores previous per-device disk counters for a given cache interval
+type prevDisk struct {
+	readBytes  uint64
+	writeBytes uint64
+	at         time.Time
+}
+
 // 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
 		}
 	}

 	// zfs
-	if _, err := zfs.ARCSize(); err != nil {
+	if _, err := getARCSize(); err != nil {
 		slog.Debug("Not monitoring ZFS ARC", "err", err)
 	} else {
 		a.zfs = true
 	}
 }

-// attachSystemDetails returns details only for fresh default-interval responses.
-func (a *Agent) attachSystemDetails(data *system.CombinedData, cacheTimeMs uint16, includeRequested bool) *system.CombinedData {
-	if cacheTimeMs != defaultDataCacheTimeMs || (!includeRequested && !a.detailsDirty) {
-		return data
-	}
-
-	// copy data to avoid adding details to the original cached struct
-	response := *data
-	response.Details = &a.systemDetails
-	a.detailsDirty = false
-	return &response
-}
-
-// updateSystemDetails applies a mutation to the static details payload and marks
-// it for inclusion on the next fresh default-interval response.
-func (a *Agent) updateSystemDetails(updateFunc func(details *system.Details)) {
-	updateFunc(&a.systemDetails)
-	a.detailsDirty = true
-}
-
 // Returns current info, stats about the host system
 func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	var systemStats system.Stats

 	// battery
-	if batteryPercent, batteryState, err := battery.GetBatteryStats(); err == nil {
-		systemStats.Battery[0] = batteryPercent
-		systemStats.Battery[1] = batteryState
+	if battery.HasReadableBattery() {
+		systemStats.Battery[0], systemStats.Battery[1], _ = battery.GetBatteryStats()
 	}

-	// cpu metrics
-	cpuMetrics, err := getCpuMetrics(cacheTimeMs)
+	// cpu percent
+	cpuPercent, err := getCpuPercent(cacheTimeMs)
 	if err == nil {
-		systemStats.Cpu = utils.TwoDecimals(cpuMetrics.Total)
-		systemStats.CpuBreakdown = []float64{
-			utils.TwoDecimals(cpuMetrics.User),
-			utils.TwoDecimals(cpuMetrics.System),
-			utils.TwoDecimals(cpuMetrics.Iowait),
-			utils.TwoDecimals(cpuMetrics.Steal),
-			utils.TwoDecimals(cpuMetrics.Idle),
-		}
+		systemStats.Cpu = twoDecimals(cpuPercent)
 	} else {
-		slog.Error("Error getting cpu metrics", "err", err)
-	}
-
-	// per-core cpu usage
-	if perCoreUsage, err := getPerCoreCpuUsage(cacheTimeMs); err == nil {
-		systemStats.CpuCoresUsage = perCoreUsage
+		slog.Error("Error getting cpu percent", "err", err)
 	}

 	// load average
@@ -170,8 +103,8 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	// memory
 	if v, err := mem.VirtualMemory(); err == nil {
 		// swap
-		systemStats.Swap = utils.BytesToGigabytes(v.SwapTotal)
-		systemStats.SwapUsed = utils.BytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
+		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
+		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
 		// cache + buffers value for default mem calculation
 		// note: gopsutil automatically adds SReclaimable to v.Cached
 		cacheBuff := v.Cached + v.Buffers - v.Shared
@@ -191,16 +124,16 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		// }
 		// subtract ZFS ARC size from used memory and add as its own category
 		if a.zfs {
-			if arcSize, _ := zfs.ARCSize(); arcSize > 0 && arcSize < v.Used {
+			if arcSize, _ := getARCSize(); arcSize > 0 && arcSize < v.Used {
 				v.Used = v.Used - arcSize
 				v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
-				systemStats.MemZfsArc = utils.BytesToGigabytes(arcSize)
+				systemStats.MemZfsArc = bytesToGigabytes(arcSize)
 			}
 		}
-		systemStats.Mem = utils.BytesToGigabytes(v.Total)
-		systemStats.MemBuffCache = utils.BytesToGigabytes(cacheBuff)
-		systemStats.MemUsed = utils.BytesToGigabytes(v.Used)
-		systemStats.MemPct = utils.TwoDecimals(v.UsedPercent)
+		systemStats.Mem = bytesToGigabytes(v.Total)
+		systemStats.MemBuffCache = bytesToGigabytes(cacheBuff)
+		systemStats.MemUsed = bytesToGigabytes(v.Used)
+		systemStats.MemPct = twoDecimals(v.UsedPercent)
 	}

 	// disk usage
@@ -249,37 +182,47 @@ 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
 }

-// 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")
+// Returns the size of the ZFS ARC memory cache in bytes
+func getARCSize() (uint64, error) {
+	file, err := os.Open("/proc/spl/kstat/zfs/arcstats")
 	if err != nil {
-		return "", err
+		return 0, err
 	}
 	defer file.Close()

+	// Scan the lines
 	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
+		if strings.HasPrefix(line, "size") {
+			// Example line: size 4 15032385536
+			fields := strings.Fields(line)
+			if len(fields) < 3 {
+				return 0, err
+			}
+			// Return the size as uint64
+			return strconv.ParseUint(fields[2], 10, 64)
 		}
 	}

-	return "", errors.New("pretty name not found")
+	return 0, fmt.Errorf("failed to parse size field")
 }
--- a/agent/system_test.go
+++ b/agent/system_test.go
@@ -1,61 +0,0 @@
-package agent
-
-import (
-	"testing"
-
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGatherStatsDoesNotAttachDetailsToCachedRequests(t *testing.T) {
-	agent := &Agent{
-		cache:         NewSystemDataCache(),
-		systemDetails: system.Details{Hostname: "updated-host", Podman: true},
-		detailsDirty:  true,
-	}
-	cached := &system.CombinedData{
-		Info: system.Info{Hostname: "cached-host"},
-	}
-	agent.cache.Set(cached, defaultDataCacheTimeMs)
-
-	response := agent.gatherStats(common.DataRequestOptions{CacheTimeMs: defaultDataCacheTimeMs})
-
-	assert.Same(t, cached, response)
-	assert.Nil(t, response.Details)
-	assert.True(t, agent.detailsDirty)
-	assert.Equal(t, "cached-host", response.Info.Hostname)
-	assert.Nil(t, cached.Details)
-
-	secondResponse := agent.gatherStats(common.DataRequestOptions{CacheTimeMs: defaultDataCacheTimeMs})
-	assert.Same(t, cached, secondResponse)
-	assert.Nil(t, secondResponse.Details)
-}
-
-func TestUpdateSystemDetailsMarksDetailsDirty(t *testing.T) {
-	agent := &Agent{}
-
-	agent.updateSystemDetails(func(details *system.Details) {
-		details.Hostname = "updated-host"
-		details.Podman = true
-	})
-
-	assert.True(t, agent.detailsDirty)
-	assert.Equal(t, "updated-host", agent.systemDetails.Hostname)
-	assert.True(t, agent.systemDetails.Podman)
-
-	original := &system.CombinedData{}
-	realTimeResponse := agent.attachSystemDetails(original, 1000, true)
-	assert.Same(t, original, realTimeResponse)
-	assert.Nil(t, realTimeResponse.Details)
-	assert.True(t, agent.detailsDirty)
-
-	response := agent.attachSystemDetails(original, defaultDataCacheTimeMs, false)
-	require.NotNil(t, response.Details)
-	assert.NotSame(t, original, response)
-	assert.Equal(t, "updated-host", response.Details.Hostname)
-	assert.True(t, response.Details.Podman)
-	assert.False(t, agent.detailsDirty)
-	assert.Nil(t, original.Details)
-}
--- a/agent/systemd.go
+++ b/agent/systemd.go
@@ -1,314 +0,0 @@
-//go:build linux
-
-package agent
-
-import (
-	"context"
-	"errors"
-	"log/slog"
-	"maps"
-	"math"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/coreos/go-systemd/v22/dbus"
-	"github.com/henrygd/beszel/agent/utils"
-	"github.com/henrygd/beszel/internal/entities/systemd"
-)
-
-var errNoActiveTime = errors.New("no active time")
-
-// systemdManager manages the collection of systemd service statistics.
-type systemdManager struct {
-	sync.Mutex
-	serviceStatsMap map[string]*systemd.Service
-	isRunning       bool
-	hasFreshStats   bool
-	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, _ := utils.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")
-		return nil, err
-	}
-
-	manager := &systemdManager{
-		serviceStatsMap: make(map[string]*systemd.Service),
-		patterns:        getServicePatterns(),
-	}
-
-	manager.startWorker(conn)
-
-	return manager, nil
-}
-
-func (sm *systemdManager) startWorker(conn *dbus.Conn) {
-	if sm.isRunning {
-		return
-	}
-	sm.isRunning = true
-	// prime the service stats map with the current services
-	_ = sm.getServiceStats(conn, true)
-	// update the services every 10 minutes
-	go func() {
-		for {
-			time.Sleep(time.Minute * 10)
-			_ = sm.getServiceStats(nil, true)
-		}
-	}()
-}
-
-// getServiceStatsCount returns the number of systemd services.
-func (sm *systemdManager) getServiceStatsCount() int {
-	return len(sm.serviceStatsMap)
-}
-
-// getFailedServiceCount returns the number of systemd services in a failed state.
-func (sm *systemdManager) getFailedServiceCount() uint16 {
-	sm.Lock()
-	defer sm.Unlock()
-	count := uint16(0)
-	for _, service := range sm.serviceStatsMap {
-		if service.State == systemd.StatusFailed {
-			count++
-		}
-	}
-	return count
-}
-
-// getServiceStats collects statistics for all running systemd services.
-func (sm *systemdManager) getServiceStats(conn *dbus.Conn, refresh bool) []*systemd.Service {
-	// start := time.Now()
-	// defer func() {
-	// 	slog.Info("systemdManager.getServiceStats", "duration", time.Since(start))
-	// }()
-
-	var services []*systemd.Service
-	var err error
-
-	if !refresh {
-		// return nil
-		sm.Lock()
-		defer sm.Unlock()
-		for _, service := range sm.serviceStatsMap {
-			services = append(services, service)
-		}
-		sm.hasFreshStats = false
-		return services
-	}
-
-	if conn == nil || !conn.Connected() {
-		conn, err = dbus.NewSystemConnectionContext(context.Background())
-		if err != nil {
-			return nil
-		}
-		defer conn.Close()
-	}
-
-	units, err := conn.ListUnitsByPatternsContext(context.Background(), []string{"loaded"}, sm.patterns)
-	if err != nil {
-		slog.Error("Error listing systemd service units", "err", err)
-		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
-}
-
-// updateServiceStats updates the statistics for a single systemd service.
-func (sm *systemdManager) updateServiceStats(conn *dbus.Conn, unit dbus.UnitStatus) (*systemd.Service, error) {
-	sm.Lock()
-	defer sm.Unlock()
-
-	ctx := context.Background()
-
-	// if service has never been active (no active since time), skip it
-	if activeEnterTsProp, err := conn.GetUnitTypePropertyContext(ctx, unit.Name, "Unit", "ActiveEnterTimestamp"); err == nil {
-		if ts, ok := activeEnterTsProp.Value.Value().(uint64); !ok || ts == 0 || ts == math.MaxUint64 {
-			return nil, errNoActiveTime
-		}
-	} else {
-		return nil, err
-	}
-
-	service, serviceExists := sm.serviceStatsMap[unit.Name]
-	if !serviceExists {
-		service = &systemd.Service{Name: unescapeServiceName(strings.TrimSuffix(unit.Name, ".service"))}
-		sm.serviceStatsMap[unit.Name] = service
-	}
-
-	memPeak := service.MemPeak
-	if memPeakProp, err := conn.GetUnitTypePropertyContext(ctx, unit.Name, "Service", "MemoryPeak"); err == nil {
-		// If memPeak is MaxUint64 the api is saying it's not available
-		if v, ok := memPeakProp.Value.Value().(uint64); ok && v != math.MaxUint64 {
-			memPeak = v
-		}
-	}
-
-	var memUsage uint64
-	if memProp, err := conn.GetUnitTypePropertyContext(ctx, unit.Name, "Service", "MemoryCurrent"); err == nil {
-		// If memUsage is MaxUint64 the api is saying it's not available
-		if v, ok := memProp.Value.Value().(uint64); ok && v != math.MaxUint64 {
-			memUsage = v
-		}
-	}
-
-	service.State = systemd.ParseServiceStatus(unit.ActiveState)
-	service.Sub = systemd.ParseServiceSubState(unit.SubState)
-
-	// some systems always return 0 for mem peak, so we should update the peak if the current usage is greater
-	if memUsage > memPeak {
-		memPeak = memUsage
-	}
-
-	var cpuUsage uint64
-	if cpuProp, err := conn.GetUnitTypePropertyContext(ctx, unit.Name, "Service", "CPUUsageNSec"); err == nil {
-		if v, ok := cpuProp.Value.Value().(uint64); ok {
-			cpuUsage = v
-		}
-	}
-
-	service.Mem = memUsage
-	if memPeak > service.MemPeak {
-		service.MemPeak = memPeak
-	}
-	service.UpdateCPUPercent(cpuUsage)
-
-	return service, nil
-}
-
-// getServiceDetails collects extended information for a specific systemd service.
-func (sm *systemdManager) getServiceDetails(serviceName string) (systemd.ServiceDetails, error) {
-	conn, err := dbus.NewSystemConnectionContext(context.Background())
-	if err != nil {
-		return nil, err
-	}
-	defer conn.Close()
-
-	unitName := serviceName
-	if !strings.HasSuffix(unitName, ".service") {
-		unitName += ".service"
-	}
-
-	ctx := context.Background()
-	props, err := conn.GetUnitPropertiesContext(ctx, unitName)
-	if err != nil {
-		return nil, err
-	}
-
-	// Start with all unit properties
-	details := make(systemd.ServiceDetails)
-	maps.Copy(details, props)
-
-	// // Add service-specific properties
-	servicePropNames := []string{
-		"MainPID", "ExecMainPID", "TasksCurrent", "TasksMax",
-		"MemoryCurrent", "MemoryPeak", "MemoryLimit", "CPUUsageNSec",
-		"NRestarts", "ExecMainStartTimestampRealtime", "Result",
-	}
-
-	for _, propName := range servicePropNames {
-		if variant, err := conn.GetUnitTypePropertyContext(ctx, unitName, "Service", propName); err == nil {
-			value := variant.Value.Value()
-			// Check if the value is MaxUint64, which indicates unlimited/infinite
-			if uint64Value, ok := value.(uint64); ok && uint64Value == math.MaxUint64 {
-				// Set to nil to indicate unlimited - frontend will handle this appropriately
-				details[propName] = nil
-			} else {
-				details[propName] = value
-			}
-		}
-	}
-
-	return details, nil
-}
-
-// unescapeServiceName unescapes systemd service names that contain C-style escape sequences like \x2d
-func unescapeServiceName(name string) string {
-	if !strings.Contains(name, "\\x") {
-		return name
-	}
-	unescaped, err := strconv.Unquote("\"" + name + "\"")
-	if err != nil {
-		return name
-	}
-	return unescaped
-}
-
-// getServicePatterns returns the list of service patterns to match.
-// It reads from the SERVICE_PATTERNS environment variable if set,
-// otherwise defaults to "*service".
-func getServicePatterns() []string {
-	patterns := []string{}
-	if envPatterns, _ := utils.GetEnv("SERVICE_PATTERNS"); envPatterns != "" {
-		for pattern := range strings.SplitSeq(envPatterns, ",") {
-			pattern = strings.TrimSpace(pattern)
-			if pattern == "" {
-				continue
-			}
-			if !strings.HasSuffix(pattern, "timer") && !strings.HasSuffix(pattern, ".service") {
-				pattern += ".service"
-			}
-			patterns = append(patterns, pattern)
-		}
-	}
-	if len(patterns) == 0 {
-		patterns = []string{"*.service"}
-	}
-	return patterns
-}
--- a/agent/systemd_nonlinux.go
+++ b/agent/systemd_nonlinux.go
@@ -1,38 +0,0 @@
-//go:build !linux
-
-package agent
-
-import (
-	"errors"
-
-	"github.com/henrygd/beszel/internal/entities/systemd"
-)
-
-// systemdManager manages the collection of systemd service statistics.
-type systemdManager struct {
-	hasFreshStats bool
-}
-
-// newSystemdManager creates a new systemdManager.
-func newSystemdManager() (*systemdManager, error) {
-	return &systemdManager{}, nil
-}
-
-// getServiceStats returns nil for non-linux systems.
-func (sm *systemdManager) getServiceStats(conn any, refresh bool) []*systemd.Service {
-	return nil
-}
-
-// getServiceStatsCount returns 0 for non-linux systems.
-func (sm *systemdManager) getServiceStatsCount() int {
-	return 0
-}
-
-// getFailedServiceCount returns 0 for non-linux systems.
-func (sm *systemdManager) getFailedServiceCount() uint16 {
-	return 0
-}
-
-func (sm *systemdManager) getServiceDetails(string) (systemd.ServiceDetails, error) {
-	return nil, errors.New("systemd manager unavailable")
-}
--- a/agent/systemd_nonlinux_test.go
+++ b/agent/systemd_nonlinux_test.go
@@ -1,53 +0,0 @@
-//go:build !linux && testing
-
-package agent
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewSystemdManager(t *testing.T) {
-	manager, err := newSystemdManager()
-	assert.NoError(t, err)
-	assert.NotNil(t, manager)
-}
-
-func TestSystemdManagerGetServiceStats(t *testing.T) {
-	manager, err := newSystemdManager()
-	assert.NoError(t, err)
-
-	// Test with refresh = true
-	result := manager.getServiceStats("any-service", true)
-	assert.Nil(t, result)
-
-	// Test with refresh = false
-	result = manager.getServiceStats("any-service", false)
-	assert.Nil(t, result)
-}
-
-func TestSystemdManagerGetServiceDetails(t *testing.T) {
-	manager, err := newSystemdManager()
-	assert.NoError(t, err)
-
-	result, err := manager.getServiceDetails("any-service")
-	assert.Error(t, err)
-	assert.Equal(t, "systemd manager unavailable", err.Error())
-	assert.Nil(t, result)
-
-	// Test with empty service name
-	result, err = manager.getServiceDetails("")
-	assert.Error(t, err)
-	assert.Equal(t, "systemd manager unavailable", err.Error())
-	assert.Nil(t, result)
-}
-
-func TestSystemdManagerFields(t *testing.T) {
-	manager, err := newSystemdManager()
-	assert.NoError(t, err)
-
-	// The non-linux manager should be a simple struct with no special fields
-	// We can't test private fields directly, but we can test the methods work
-	assert.NotNil(t, manager)
-}
--- a/agent/systemd_test.go
+++ b/agent/systemd_test.go
@@ -1,185 +0,0 @@
-//go:build linux && testing
-
-package agent
-
-import (
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestUnescapeServiceName(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"nginx.service", "nginx.service"},                                     // No escaping needed
-		{"test\\x2dwith\\x2ddashes.service", "test-with-dashes.service"},       // \x2d is dash
-		{"service\\x20with\\x20spaces.service", "service with spaces.service"}, // \x20 is space
-		{"mixed\\x2dand\\x2dnormal", "mixed-and-normal"},                       // Mixed escaped and normal
-		{"no-escape-here", "no-escape-here"},                                   // No escape sequences
-		{"", ""},                                                               // Empty string
-		{"\\x2d\\x2d", "--"},                                                   // Multiple escapes
-	}
-
-	for _, test := range tests {
-		t.Run(test.input, func(t *testing.T) {
-			result := unescapeServiceName(test.input)
-			assert.Equal(t, test.expected, result)
-		})
-	}
-}
-
-func TestUnescapeServiceNameInvalid(t *testing.T) {
-	// Test invalid escape sequences - should return original string
-	invalidInputs := []string{
-		"invalid\\x",   // Incomplete escape
-		"invalid\\xZZ", // Invalid hex
-		"invalid\\x2",  // Incomplete hex
-		"invalid\\xyz", // Not a valid escape
-	}
-
-	for _, input := range invalidInputs {
-		t.Run(input, func(t *testing.T) {
-			result := unescapeServiceName(input)
-			assert.Equal(t, input, result, "Invalid escape sequences should return original string")
-		})
-	}
-}
-
-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
-		prefixedEnv    string
-		unprefixedEnv  string
-		expected       []string
-		cleanupEnvVars bool
-	}{
-		{
-			name:           "default when no env var set",
-			prefixedEnv:    "",
-			unprefixedEnv:  "",
-			expected:       []string{"*.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "single pattern with prefixed env",
-			prefixedEnv:    "nginx",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "single pattern with unprefixed env",
-			prefixedEnv:    "",
-			unprefixedEnv:  "nginx",
-			expected:       []string{"nginx.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "prefixed env takes precedence",
-			prefixedEnv:    "nginx",
-			unprefixedEnv:  "apache",
-			expected:       []string{"nginx.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "multiple patterns",
-			prefixedEnv:    "nginx,apache,postgresql",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "apache.service", "postgresql.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "patterns with .service suffix",
-			prefixedEnv:    "nginx.service,apache.service",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "apache.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "mixed patterns with and without suffix",
-			prefixedEnv:    "nginx.service,apache,postgresql.service",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "apache.service", "postgresql.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "patterns with whitespace",
-			prefixedEnv:    " nginx , apache , postgresql ",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "apache.service", "postgresql.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "empty patterns are skipped",
-			prefixedEnv:    "nginx,,apache,  ,postgresql",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "apache.service", "postgresql.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "wildcard pattern",
-			prefixedEnv:    "*nginx*,*apache*",
-			unprefixedEnv:  "",
-			expected:       []string{"*nginx*.service", "*apache*.service"},
-			cleanupEnvVars: true,
-		},
-		{
-			name:           "opt into timer monitoring",
-			prefixedEnv:    "nginx.service,docker,apache.timer",
-			unprefixedEnv:  "",
-			expected:       []string{"nginx.service", "docker.service", "apache.timer"},
-			cleanupEnvVars: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Set up environment variables
-			if tt.prefixedEnv != "" {
-				t.Setenv("BESZEL_AGENT_SERVICE_PATTERNS", tt.prefixedEnv)
-			}
-			if tt.unprefixedEnv != "" {
-				t.Setenv("SERVICE_PATTERNS", tt.unprefixedEnv)
-			}
-
-			// Run the function
-			result := getServicePatterns()
-
-			// Verify results
-			assert.Equal(t, tt.expected, result, "Patterns should match expected values")
-		})
-	}
-}
--- 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/smart/apple_nvme.json
+++ b/agent/test-data/smart/apple_nvme.json
@@ -1,51 +0,0 @@
-{
-  "json_format_version": [1, 0],
-  "smartctl": {
-    "version": [7, 4],
-    "argv": ["smartctl", "-aix", "-j", "IOService:/AppleARMPE/arm-io@10F00000/AppleT810xIO/ans@77400000/AppleASCWrapV4/iop-ans-nub/RTBuddy(ANS2)/RTBuddyService/AppleANS3NVMeController/NS_01@1"],
-    "exit_status": 4
-  },
-  "device": {
-    "name": "IOService:/AppleARMPE/arm-io@10F00000/AppleT810xIO/ans@77400000/AppleASCWrapV4/iop-ans-nub/RTBuddy(ANS2)/RTBuddyService/AppleANS3NVMeController/NS_01@1",
-    "info_name": "IOService:/AppleARMPE/arm-io@10F00000/AppleT810xIO/ans@77400000/AppleASCWrapV4/iop-ans-nub/RTBuddy(ANS2)/RTBuddyService/AppleANS3NVMeController/NS_01@1",
-    "type": "nvme",
-    "protocol": "NVMe"
-  },
-  "model_name": "APPLE SSD AP0256Q",
-  "serial_number": "0ba0147940253c15",
-  "firmware_version": "555",
-  "smart_support": {
-    "available": true,
-    "enabled": true
-  },
-  "smart_status": {
-    "passed": true,
-    "nvme": {
-      "value": 0
-    }
-  },
-  "nvme_smart_health_information_log": {
-    "critical_warning": 0,
-    "temperature": 42,
-    "available_spare": 100,
-    "available_spare_threshold": 99,
-    "percentage_used": 1,
-    "data_units_read": 270189386,
-    "data_units_written": 166753862,
-    "host_reads": 7543766995,
-    "host_writes": 3761621926,
-    "controller_busy_time": 0,
-    "power_cycles": 366,
-    "power_on_hours": 2850,
-    "unsafe_shutdowns": 195,
-    "media_errors": 0,
-    "num_err_log_entries": 0
-  },
-  "temperature": {
-    "current": 42
-  },
-  "power_cycle_count": 366,
-  "power_on_time": {
-    "hours": 2850
-  }
-}
--- a/agent/test-data/smart/nvme0.json
+++ b/agent/test-data/smart/nvme0.json
@@ -1,272 +0,0 @@
-{
-  "json_format_version": [
-    1,
-    0
-  ],
-  "smartctl": {
-    "version": [
-      7,
-      5
-    ],
-    "pre_release": false,
-    "svn_revision": "5714",
-    "platform_info": "x86_64-linux-6.17.1-2-cachyos",
-    "build_info": "(local build)",
-    "argv": [
-      "smartctl",
-      "-aj",
-      "/dev/nvme0"
-    ],
-    "exit_status": 0
-  },
-  "local_time": {
-    "time_t": 1761507494,
-    "asctime": "Sun Oct 26 15:38:14 2025 EDT"
-  },
-  "device": {
-    "name": "/dev/nvme0",
-    "info_name": "/dev/nvme0",
-    "type": "nvme",
-    "protocol": "NVMe"
-  },
-  "model_name": "PELADN 512GB",
-  "serial_number": "2024031600129",
-  "firmware_version": "VC2S038E",
-  "nvme_pci_vendor": {
-    "id": 4332,
-    "subsystem_id": 4332
-  },
-  "nvme_ieee_oui_identifier": 57420,
-  "nvme_controller_id": 1,
-  "nvme_version": {
-    "string": "1.4",
-    "value": 66560
-  },
-  "nvme_number_of_namespaces": 1,
-  "nvme_namespaces": [
-    {
-      "id": 1,
-      "size": {
-        "blocks": 1000215216,
-        "bytes": 512110190592
-      },
-      "capacity": {
-        "blocks": 1000215216,
-        "bytes": 512110190592
-      },
-      "utilization": {
-        "blocks": 1000215216,
-        "bytes": 512110190592
-      },
-      "formatted_lba_size": 512,
-      "eui64": {
-        "oui": 57420,
-        "ext_id": 112094110470
-      },
-      "features": {
-        "value": 0,
-        "thin_provisioning": false,
-        "na_fields": false,
-        "dealloc_or_unwritten_block_error": false,
-        "uid_reuse": false,
-        "np_fields": false,
-        "other": 0
-      },
-      "lba_formats": [
-        {
-          "formatted": true,
-          "data_bytes": 512,
-          "metadata_bytes": 0,
-          "relative_performance": 0
-        }
-      ]
-    }
-  ],
-  "user_capacity": {
-    "blocks": 1000215216,
-    "bytes": 512110190592
-  },
-  "logical_block_size": 512,
-  "smart_support": {
-    "available": true,
-    "enabled": true
-  },
-  "nvme_firmware_update_capabilities": {
-    "value": 2,
-    "slots": 1,
-    "first_slot_is_read_only": false,
-    "activiation_without_reset": false,
-    "multiple_update_detection": false,
-    "other": 0
-  },
-  "nvme_optional_admin_commands": {
-    "value": 23,
-    "security_send_receive": true,
-    "format_nvm": true,
-    "firmware_download": true,
-    "namespace_management": false,
-    "self_test": true,
-    "directives": false,
-    "mi_send_receive": false,
-    "virtualization_management": false,
-    "doorbell_buffer_config": false,
-    "get_lba_status": false,
-    "command_and_feature_lockdown": false,
-    "other": 0
-  },
-  "nvme_optional_nvm_commands": {
-    "value": 94,
-    "compare": false,
-    "write_uncorrectable": true,
-    "dataset_management": true,
-    "write_zeroes": true,
-    "save_select_feature_nonzero": true,
-    "reservations": false,
-    "timestamp": true,
-    "verify": false,
-    "copy": false,
-    "other": 0
-  },
-  "nvme_log_page_attributes": {
-    "value": 2,
-    "smart_health_per_namespace": false,
-    "commands_effects_log": true,
-    "extended_get_log_page_cmd": false,
-    "telemetry_log": false,
-    "persistent_event_log": false,
-    "supported_log_pages_log": false,
-    "telemetry_data_area_4": false,
-    "other": 0
-  },
-  "nvme_maximum_data_transfer_pages": 32,
-  "nvme_composite_temperature_threshold": {
-    "warning": 100,
-    "critical": 110
-  },
-  "temperature": {
-    "op_limit_max": 100,
-    "critical_limit_max": 110,
-    "current": 61
-  },
-  "nvme_power_states": [
-    {
-      "non_operational_state": false,
-      "relative_read_latency": 0,
-      "relative_read_throughput": 0,
-      "relative_write_latency": 0,
-      "relative_write_throughput": 0,
-      "entry_latency_us": 230000,
-      "exit_latency_us": 50000,
-      "max_power": {
-        "value": 800,
-        "scale": 2,
-        "units_per_watt": 100
-      }
-    },
-    {
-      "non_operational_state": false,
-      "relative_read_latency": 1,
-      "relative_read_throughput": 1,
-      "relative_write_latency": 1,
-      "relative_write_throughput": 1,
-      "entry_latency_us": 4000,
-      "exit_latency_us": 50000,
-      "max_power": {
-        "value": 400,
-        "scale": 2,
-        "units_per_watt": 100
-      }
-    },
-    {
-      "non_operational_state": false,
-      "relative_read_latency": 2,
-      "relative_read_throughput": 2,
-      "relative_write_latency": 2,
-      "relative_write_throughput": 2,
-      "entry_latency_us": 4000,
-      "exit_latency_us": 250000,
-      "max_power": {
-        "value": 300,
-        "scale": 2,
-        "units_per_watt": 100
-      }
-    },
-    {
-      "non_operational_state": true,
-      "relative_read_latency": 3,
-      "relative_read_throughput": 3,
-      "relative_write_latency": 3,
-      "relative_write_throughput": 3,
-      "entry_latency_us": 5000,
-      "exit_latency_us": 10000,
-      "max_power": {
-        "value": 300,
-        "scale": 1,
-        "units_per_watt": 10000
-      }
-    },
-    {
-      "non_operational_state": true,
-      "relative_read_latency": 4,
-      "relative_read_throughput": 4,
-      "relative_write_latency": 4,
-      "relative_write_throughput": 4,
-      "entry_latency_us": 54000,
-      "exit_latency_us": 45000,
-      "max_power": {
-        "value": 50,
-        "scale": 1,
-        "units_per_watt": 10000
-      }
-    }
-  ],
-  "smart_status": {
-    "passed": true,
-    "nvme": {
-      "value": 0
-    }
-  },
-  "nvme_smart_health_information_log": {
-    "nsid": -1,
-    "critical_warning": 0,
-    "temperature": 61,
-    "available_spare": 100,
-    "available_spare_threshold": 32,
-    "percentage_used": 0,
-    "data_units_read": 6573104,
-    "data_units_written": 16040567,
-    "host_reads": 63241130,
-    "host_writes": 253050006,
-    "controller_busy_time": 0,
-    "power_cycles": 430,
-    "power_on_hours": 4399,
-    "unsafe_shutdowns": 44,
-    "media_errors": 0,
-    "num_err_log_entries": 0,
-    "warning_temp_time": 0,
-    "critical_comp_time": 0
-  },
-  "spare_available": {
-    "current_percent": 100,
-    "threshold_percent": 32
-  },
-  "endurance_used": {
-    "current_percent": 0
-  },
-  "power_cycle_count": 430,
-  "power_on_time": {
-    "hours": 4399
-  },
-  "nvme_error_information_log": {
-    "size": 8,
-    "read": 8,
-    "unread": 0
-  },
-  "nvme_self_test_log": {
-    "nsid": -1,
-    "current_self_test_operation": {
-      "value": 0,
-      "string": "No self-test in progress"
-    }
-  }
-}
--- a/agent/test-data/smart/scan.json
+++ b/agent/test-data/smart/scan.json
@@ -1,36 +0,0 @@
-{
-  "json_format_version": [
-    1,
-    0
-  ],
-  "smartctl": {
-    "version": [
-      7,
-      5
-    ],
-    "pre_release": false,
-    "svn_revision": "5714",
-    "platform_info": "x86_64-linux-6.17.1-2-cachyos",
-    "build_info": "(local build)",
-    "argv": [
-      "smartctl",
-      "--scan",
-      "-j"
-    ],
-    "exit_status": 0
-  },
-  "devices": [
-    {
-      "name": "/dev/sda",
-      "info_name": "/dev/sda [SAT]",
-      "type": "sat",
-      "protocol": "ATA"
-    },
-    {
-      "name": "/dev/nvme0",
-      "info_name": "/dev/nvme0",
-      "type": "nvme",
-      "protocol": "NVMe"
-    }
-  ]
-}
--- a/agent/test-data/smart/scsi.json
+++ b/agent/test-data/smart/scsi.json
@@ -1,125 +0,0 @@
-{
-   "json_format_version": [
-      1,
-      0
-   ],
-   "smartctl": {
-      "version": [
-         7,
-         3
-      ],
-      "svn_revision": "5338",
-      "platform_info": "x86_64-linux-6.12.43+deb12-amd64",
-      "build_info": "(local build)",
-      "argv": [
-         "smartctl",
-         "-aj",
-         "/dev/sde"
-      ],
-      "exit_status": 0
-   },
-   "local_time": {
-      "time_t": 1761502142,
-      "asctime": "Sun Oct 21 21:09:02 2025 MSK"
-   },
-   "device": {
-      "name": "/dev/sde",
-      "info_name": "/dev/sde",
-      "type": "scsi",
-      "protocol": "SCSI"
-   },
-   "scsi_vendor": "YADRO",
-   "scsi_product": "WUH721414AL4204",
-   "scsi_model_name": "YADRO WUH721414AL4204",
-   "scsi_revision": "C240",
-   "scsi_version": "SPC-4",
-   "user_capacity": {
-      "blocks": 3418095616,
-      "bytes": 14000519643136
-   },
-   "logical_block_size": 4096,
-   "scsi_lb_provisioning": {
-      "name": "fully provisioned",
-      "value": 0,
-      "management_enabled": {
-         "name": "LBPME",
-         "value": 0
-      },
-      "read_zeros": {
-         "name": "LBPRZ",
-         "value": 0
-      }
-   },
-   "rotation_rate": 7200,
-   "form_factor": {
-      "scsi_value": 2,
-      "name": "3.5 inches"
-   },
-   "logical_unit_id": "0x5000cca29063dc00",
-   "serial_number": "9YHSDH9B",
-   "device_type": {
-      "scsi_terminology": "Peripheral Device Type [PDT]",
-      "scsi_value": 0,
-      "name": "disk"
-   },
-   "scsi_transport_protocol": {
-      "name": "SAS (SPL-4)",
-      "value": 6
-   },
-   "smart_support": {
-      "available": true,
-      "enabled": true
-   },
-   "temperature_warning": {
-      "enabled": true
-   },
-   "smart_status": {
-      "passed": true
-   },
-   "temperature": {
-      "current": 34,
-      "drive_trip": 85
-   },
-   "power_on_time": {
-      "hours": 458,
-      "minutes": 25
-   },
-   "scsi_start_stop_cycle_counter": {
-      "year_of_manufacture": "2022",
-      "week_of_manufacture": "41",
-      "specified_cycle_count_over_device_lifetime": 50000,
-      "accumulated_start_stop_cycles": 2,
-      "specified_load_unload_count_over_device_lifetime": 600000,
-      "accumulated_load_unload_cycles": 418
-   },
-   "scsi_grown_defect_list": 0,
-   "scsi_error_counter_log": {
-      "read": {
-         "errors_corrected_by_eccfast": 0,
-         "errors_corrected_by_eccdelayed": 0,
-         "errors_corrected_by_rereads_rewrites": 0,
-         "total_errors_corrected": 0,
-         "correction_algorithm_invocations": 346,
-         "gigabytes_processed": "3,641",
-         "total_uncorrected_errors": 0
-      },
-      "write": {
-         "errors_corrected_by_eccfast": 0,
-         "errors_corrected_by_eccdelayed": 0,
-         "errors_corrected_by_rereads_rewrites": 0,
-         "total_errors_corrected": 0,
-         "correction_algorithm_invocations": 4052,
-         "gigabytes_processed": "2124,590",
-         "total_uncorrected_errors": 0
-      },
-      "verify": {
-         "errors_corrected_by_eccfast": 0,
-         "errors_corrected_by_eccdelayed": 0,
-         "errors_corrected_by_rereads_rewrites": 0,
-         "total_errors_corrected": 0,
-         "correction_algorithm_invocations": 223,
-         "gigabytes_processed": "0,000",
-         "total_uncorrected_errors": 0
-      }
-   }
-}
--- a/agent/test-data/smart/sda.json
+++ b/agent/test-data/smart/sda.json
--- 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/tools/fetchsmartctl/main.go
+++ b/agent/tools/fetchsmartctl/main.go
@@ -1,130 +0,0 @@
-package main
-
-import (
-	"crypto/sha1"
-	"crypto/sha256"
-	"encoding/hex"
-	"flag"
-	"fmt"
-	"hash"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-// Download smartctl.exe from the given URL and save it to the given destination.
-// This is used to embed smartctl.exe in the Windows build.
-
-func main() {
-	url := flag.String("url", "", "URL to download smartctl.exe from (required)")
-	out := flag.String("out", "", "Destination path for smartctl.exe (required)")
-	sha := flag.String("sha", "", "Optional SHA1/SHA256 checksum for integrity validation")
-	force := flag.Bool("force", false, "Force re-download even if destination exists")
-	flag.Parse()
-
-	if *url == "" || *out == "" {
-		fatalf("-url and -out are required")
-	}
-
-	if !*force {
-		if info, err := os.Stat(*out); err == nil && info.Size() > 0 {
-			fmt.Println("smartctl.exe already present, skipping download")
-			return
-		}
-	}
-
-	if err := downloadFile(*url, *out, *sha); err != nil {
-		fatalf("download failed: %v", err)
-	}
-}
-
-func downloadFile(url, dest, shaHex string) error {
-	// Prepare destination
-	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
-		return fmt.Errorf("create dir: %w", err)
-	}
-
-	// HTTP client
-	client := &http.Client{Timeout: 60 * time.Second}
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return fmt.Errorf("new request: %w", err)
-	}
-	req.Header.Set("User-Agent", "beszel-fetchsmartctl/1.0")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("http get: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("unexpected HTTP status: %s", resp.Status)
-	}
-
-	tmp := dest + ".tmp"
-	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
-	if err != nil {
-		return fmt.Errorf("open tmp: %w", err)
-	}
-
-	// Determine hash algorithm based on length (SHA1=40, SHA256=64)
-	var hasher hash.Hash
-	if shaHex := strings.TrimSpace(shaHex); shaHex != "" {
-		cleanSha := strings.ToLower(strings.ReplaceAll(shaHex, " ", ""))
-		switch len(cleanSha) {
-		case 40:
-			hasher = sha1.New()
-		case 64:
-			hasher = sha256.New()
-		default:
-			f.Close()
-			os.Remove(tmp)
-			return fmt.Errorf("unsupported hash length: %d (expected 40 for SHA1 or 64 for SHA256)", len(cleanSha))
-		}
-	}
-
-	var mw io.Writer = f
-	if hasher != nil {
-		mw = io.MultiWriter(f, hasher)
-	}
-	if _, err := io.Copy(mw, resp.Body); err != nil {
-		f.Close()
-		os.Remove(tmp)
-		return fmt.Errorf("write tmp: %w", err)
-	}
-	if err := f.Close(); err != nil {
-		os.Remove(tmp)
-		return fmt.Errorf("close tmp: %w", err)
-	}
-
-	if hasher != nil && shaHex != "" {
-		cleanSha := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(shaHex), " ", ""))
-		got := strings.ToLower(hex.EncodeToString(hasher.Sum(nil)))
-		if got != cleanSha {
-			os.Remove(tmp)
-			return fmt.Errorf("hash mismatch: got %s want %s", got, cleanSha)
-		}
-	}
-
-	// Make executable and move into place
-	if err := os.Chmod(tmp, 0o755); err != nil {
-		os.Remove(tmp)
-		return fmt.Errorf("chmod: %w", err)
-	}
-	if err := os.Rename(tmp, dest); err != nil {
-		os.Remove(tmp)
-		return fmt.Errorf("rename: %w", err)
-	}
-
-	fmt.Println("smartctl.exe downloaded to", dest)
-	return nil
-}
-
-func fatalf(format string, a ...any) {
-	fmt.Fprintf(os.Stderr, format+"\n", a...)
-	os.Exit(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/agent/utils.go
+++ b/agent/utils.go
@@ -0,0 +1,15 @@
+package agent
+
+import "math"
+
+func bytesToMegabytes(b float64) float64 {
+	return twoDecimals(b / 1048576)
+}
+
+func bytesToGigabytes(b uint64) float64 {
+	return twoDecimals(float64(b) / 1073741824)
+}
+
+func twoDecimals(value float64) float64 {
+	return math.Round(value*100) / 100
+}
--- a/agent/utils/utils.go
+++ b/agent/utils/utils.go
@@ -1,117 +0,0 @@
-// Package utils provides utility functions for the agent.
-package utils
-
-import (
-	"fmt"
-	"io"
-	"math"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-// GetEnv retrieves an environment variable with a "BESZEL_AGENT_" prefix, or falls back to the unprefixed key.
-func GetEnv(key string) (value string, exists bool) {
-	if value, exists = os.LookupEnv("BESZEL_AGENT_" + key); exists {
-		return value, exists
-	}
-	return os.LookupEnv(key)
-}
-
-// BytesToMegabytes converts bytes to megabytes and rounds to two decimal places.
-func BytesToMegabytes(b float64) float64 {
-	return TwoDecimals(b / 1048576)
-}
-
-// BytesToGigabytes converts bytes to gigabytes and rounds to two decimal places.
-func BytesToGigabytes(b uint64) float64 {
-	return TwoDecimals(float64(b) / 1073741824)
-}
-
-// TwoDecimals rounds a float64 value to two decimal places.
-func TwoDecimals(value float64) float64 {
-	return math.Round(value*100) / 100
-}
-
-// func RoundFloat(val float64, precision uint) float64 {
-//     ratio := math.Pow(10, float64(precision))
-//     return math.Round(val*ratio) / ratio
-// }
-
-// ReadStringFile returns trimmed file contents or empty string on error.
-func ReadStringFile(path string) string {
-	content, _ := ReadStringFileOK(path)
-	return content
-}
-
-// ReadStringFileOK returns trimmed file contents and read success.
-func ReadStringFileOK(path string) (string, bool) {
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return "", false
-	}
-	return strings.TrimSpace(string(b)), true
-}
-
-// ReadStringFileLimited reads a file into a string with a maximum size (in bytes) to avoid
-// allocating large buffers and potential panics with pseudo-files when the size is misreported.
-func ReadStringFileLimited(path string, maxSize int) (string, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	buf := make([]byte, maxSize)
-	n, err := f.Read(buf)
-	if err != nil && err != io.EOF {
-		return "", err
-	}
-	if n < 0 {
-		return "", fmt.Errorf("%s returned negative bytes: %d", path, n)
-	}
-	return strings.TrimSpace(string(buf[:n])), nil
-}
-
-// FileExists reports whether the given path exists.
-func FileExists(path string) bool {
-	_, err := os.Stat(path)
-	return err == nil
-}
-
-// ReadUintFile parses a decimal uint64 value from a file.
-func ReadUintFile(path string) (uint64, bool) {
-	raw, ok := ReadStringFileOK(path)
-	if !ok {
-		return 0, false
-	}
-	parsed, err := strconv.ParseUint(raw, 10, 64)
-	if err != nil {
-		return 0, false
-	}
-	return parsed, true
-}
-
-// LookPathHomebrew is like exec.LookPath but also checks Homebrew paths.
-func LookPathHomebrew(file string) (string, error) {
-	foundPath, lookPathErr := exec.LookPath(file)
-	if lookPathErr == nil {
-		return foundPath, nil
-	}
-	var homebrewPath string
-	switch runtime.GOOS {
-	case "darwin":
-		homebrewPath = filepath.Join("/opt", "homebrew", "bin", file)
-	case "linux":
-		homebrewPath = filepath.Join("/home", "linuxbrew", ".linuxbrew", "bin", file)
-	}
-	if homebrewPath != "" {
-		if _, err := os.Stat(homebrewPath); err == nil {
-			return homebrewPath, nil
-		}
-	}
-	return "", lookPathErr
-}
--- a/agent/utils/utils_test.go
+++ b/agent/utils/utils_test.go
@@ -1,158 +0,0 @@
-package utils
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTwoDecimals(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    float64
-		expected float64
-	}{
-		{"round down", 1.234, 1.23},
-		{"round half up", 1.235, 1.24}, // math.Round rounds half up
-		{"no rounding needed", 1.23, 1.23},
-		{"negative number", -1.235, -1.24}, // math.Round rounds half up (more negative)
-		{"zero", 0.0, 0.0},
-		{"large number", 123.456, 123.46}, // rounds 5 up
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := TwoDecimals(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestBytesToMegabytes(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    float64
-		expected float64
-	}{
-		{"1 MB", 1048576, 1.0},
-		{"512 KB", 524288, 0.5},
-		{"zero", 0, 0},
-		{"large value", 1073741824, 1024}, // 1 GB = 1024 MB
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := BytesToMegabytes(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestBytesToGigabytes(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    uint64
-		expected float64
-	}{
-		{"1 GB", 1073741824, 1.0},
-		{"512 MB", 536870912, 0.5},
-		{"0 GB", 0, 0},
-		{"2 GB", 2147483648, 2.0},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := BytesToGigabytes(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestFileFunctions(t *testing.T) {
-	tmpDir := t.TempDir()
-	testFilePath := filepath.Join(tmpDir, "test.txt")
-	testContent := "hello world"
-
-	// Test FileExists (false)
-	assert.False(t, FileExists(testFilePath))
-
-	// Test ReadStringFileOK (false)
-	content, ok := ReadStringFileOK(testFilePath)
-	assert.False(t, ok)
-	assert.Empty(t, content)
-
-	// Test ReadStringFile (empty)
-	assert.Empty(t, ReadStringFile(testFilePath))
-
-	// Write file
-	err := os.WriteFile(testFilePath, []byte(testContent+"\n "), 0644)
-	assert.NoError(t, err)
-
-	// Test FileExists (true)
-	assert.True(t, FileExists(testFilePath))
-
-	// Test ReadStringFileOK (true)
-	content, ok = ReadStringFileOK(testFilePath)
-	assert.True(t, ok)
-	assert.Equal(t, testContent, content)
-
-	// Test ReadStringFile (content)
-	assert.Equal(t, testContent, ReadStringFile(testFilePath))
-}
-
-func TestReadUintFile(t *testing.T) {
-	tmpDir := t.TempDir()
-
-	t.Run("valid uint", func(t *testing.T) {
-		path := filepath.Join(tmpDir, "uint.txt")
-		os.WriteFile(path, []byte(" 12345\n"), 0644)
-		val, ok := ReadUintFile(path)
-		assert.True(t, ok)
-		assert.Equal(t, uint64(12345), val)
-	})
-
-	t.Run("invalid uint", func(t *testing.T) {
-		path := filepath.Join(tmpDir, "invalid.txt")
-		os.WriteFile(path, []byte("abc"), 0644)
-		val, ok := ReadUintFile(path)
-		assert.False(t, ok)
-		assert.Equal(t, uint64(0), val)
-	})
-
-	t.Run("missing file", func(t *testing.T) {
-		path := filepath.Join(tmpDir, "missing.txt")
-		val, ok := ReadUintFile(path)
-		assert.False(t, ok)
-		assert.Equal(t, uint64(0), val)
-	})
-}
-
-func TestGetEnv(t *testing.T) {
-	key := "TEST_VAR"
-	prefixedKey := "BESZEL_AGENT_" + key
-
-	t.Run("prefixed variable exists", func(t *testing.T) {
-		t.Setenv(prefixedKey, "prefixed_val")
-		t.Setenv(key, "unprefixed_val")
-
-		val, exists := GetEnv(key)
-		assert.True(t, exists)
-		assert.Equal(t, "prefixed_val", val)
-	})
-
-	t.Run("only unprefixed variable exists", func(t *testing.T) {
-		t.Setenv(key, "unprefixed_val")
-
-		val, exists := GetEnv(key)
-		assert.True(t, exists)
-		assert.Equal(t, "unprefixed_val", val)
-	})
-
-	t.Run("neither variable exists", func(t *testing.T) {
-		val, exists := GetEnv(key)
-		assert.False(t, exists)
-		assert.Empty(t, val)
-	})
-}
--- a/agent/zfs/zfs_freebsd.go
+++ b/agent/zfs/zfs_freebsd.go
@@ -1,11 +0,0 @@
-//go:build freebsd
-
-package zfs
-
-import (
-	"golang.org/x/sys/unix"
-)
-
-func ARCSize() (uint64, error) {
-	return unix.SysctlUint64("kstat.zfs.misc.arcstats.size")
-}
--- a/agent/zfs/zfs_linux.go
+++ b/agent/zfs/zfs_linux.go
@@ -1,34 +0,0 @@
-//go:build linux
-
-// Package zfs provides functions to read ZFS statistics.
-package zfs
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-)
-
-func ARCSize() (uint64, error) {
-	file, err := os.Open("/proc/spl/kstat/zfs/arcstats")
-	if err != nil {
-		return 0, err
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.HasPrefix(line, "size") {
-			fields := strings.Fields(line)
-			if len(fields) < 3 {
-				return 0, fmt.Errorf("unexpected arcstats size format: %s", line)
-			}
-			return strconv.ParseUint(fields[2], 10, 64)
-		}
-	}
-
-	return 0, fmt.Errorf("size field not found in arcstats")
-}
--- a/agent/zfs/zfs_unsupported.go
+++ b/agent/zfs/zfs_unsupported.go
@@ -1,9 +0,0 @@
-//go:build !linux && !freebsd
-
-package zfs
-
-import "errors"
-
-func ARCSize() (uint64, error) {
-	return 0, errors.ErrUnsupported
-}
--- 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.7"
+	Version = "0.13.2"
 	// AppName is the name of the application.
 	AppName = "beszel"
 )
--- a/go.mod
+++ b/go.mod
@@ -1,28 +1,28 @@
 module github.com/henrygd/beszel

-go 1.26.1
+go 1.25.1
+
+// lock shoutrrr to specific version to allow review before updating
+replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.9.1

 require (
 	github.com/blang/semver v3.5.1+incompatible
-	github.com/coreos/go-systemd/v22 v22.7.0
-	github.com/ebitengine/purego v0.10.0
+	github.com/distatus/battery v0.11.0
 	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.9.1
-	github.com/nicholas-fedor/shoutrrr v0.14.3
-	github.com/pocketbase/dbx v1.12.0
-	github.com/pocketbase/pocketbase v0.36.8
-	github.com/shirou/gopsutil/v4 v4.26.3
+	github.com/lxzan/gws v1.8.9
+	github.com/nicholas-fedor/shoutrrr v0.10.0
+	github.com/pocketbase/dbx v1.11.0
+	github.com/pocketbase/pocketbase v0.30.1
+	github.com/shirou/gopsutil/v4 v4.25.9
 	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.49.0
-	golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90
-	golang.org/x/sys v0.42.0
+	golang.org/x/crypto v0.42.0
+	golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9
 	gopkg.in/yaml.v3 v3.0.1
-	howett.net/plist v1.0.1
 )

 require (
@@ -30,39 +30,40 @@ require (
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/disintegration/imaging v1.6.2 // indirect
+	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/eclipse/paho.golang v0.23.0 // indirect
-	github.com/fatih/color v1.19.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.13 // indirect
+	github.com/ebitengine/purego v0.9.0 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.10 // 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/gorilla/websocket v1.5.3 // 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.5 // indirect
-	github.com/lufia/plan9stats v0.0.0-20260324052639-156f7da3f749 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 // 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
+	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/tklauser/go-sysconf v0.3.16 // indirect
-	github.com/tklauser/numcpus v0.11.0 // indirect
+	github.com/tklauser/go-sysconf v0.3.15 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/image v0.38.0 // indirect
-	golang.org/x/net v0.52.0 // indirect
-	golang.org/x/oauth2 v0.36.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/term v0.41.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
-	modernc.org/libc v1.70.0 // indirect
+	golang.org/x/image v0.31.0 // indirect
+	golang.org/x/net v0.44.0 // indirect
+	golang.org/x/oauth2 v0.31.0 // indirect
+	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/sys v0.36.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	howett.net/plist v1.0.1 // indirect
+	modernc.org/libc v1.66.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.48.0 // indirect
+	modernc.org/sqlite v1.39.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -9,30 +9,30 @@ 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/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=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
+github.com/distatus/battery v0.11.0 h1:KJk89gz90Iq/wJtbjjM9yUzBXV+ASV/EG2WOOL7N8lc=
+github.com/distatus/battery v0.11.0/go.mod h1:KmVkE8A8hpIX4T78QRdMktYpEp35QfOL8A8dwZBxq2k=
+github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ=
+github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4=
 github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCOBXMn8=
 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU=
-github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
-github.com/eclipse/paho.golang v0.23.0 h1:KHgl2wz6EJo7cMBmkuhpt7C576vP+kpPv7jjvSyR6Mk=
-github.com/eclipse/paho.golang v0.23.0/go.mod h1:nQRhTkoZv8EAiNs5UU0/WdQIx2NrnWUpL9nsGJTQN04=
-github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
-github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
+github.com/ebitengine/purego v0.9.0 h1:mh0zpKBIXDceC63hpvPuGLiJ8ZAa3DfrFTudmfi8A4k=
+github.com/ebitengine/purego v0.9.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 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.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
+github.com/gabriel-vasile/mimetype v1.4.10/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=
@@ -49,55 +49,49 @@ 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/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-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw=
-github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 h1:EEHtgt9IwisQ2AZ4pIsMjahcegHh6rmhqxzIRQIyepY=
+github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6/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/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
-github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 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.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
-github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 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-20260324052639-156f7da3f749 h1:Qj3hTcdWH8uMZDI41HNuTuJN525C7NBrbtH5kSO6fPk=
-github.com/lufia/plan9stats v0.0.0-20260324052639-156f7da3f749/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
-github.com/lxzan/gws v1.9.1 h1:4lbIp4cW0hOLP3ejFHR/uWRy741AURx7oKkNNi2OT9o=
-github.com/lxzan/gws v1.9.1/go.mod h1:gXHSCPmTGryWJ4icuqy8Yho32E4YIMHH0fkDRYJRbdc=
+github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 h1:mFWunSatvkQQDhpdyuFAYwyAan3hzCuma+Pz8sqvOfg=
+github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54/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=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 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.14.3 h1:aBX2iw9a7jl5wfHd3bi9LnS5ucoYIy6KcLH9XVF+gig=
-github.com/nicholas-fedor/shoutrrr v0.14.3/go.mod h1:U7IywBkLpBV7rgn8iLbQ9/LklJG1gm24bFv5cXXsDKs=
-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/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/nicholas-fedor/shoutrrr v0.9.1 h1:SEBhM6P1favzILO0f55CY3P9JwvM9RZ7B1ZMCl+Injs=
+github.com/nicholas-fedor/shoutrrr v0.9.1/go.mod h1:khue5m8LYyMzdPWuJxDTJeT89l9gjwjA+a+r0e8qxxk=
+github.com/onsi/ginkgo/v2 v2.25.3 h1:Ty8+Yi/ayDAGtk4XxmmfUy4GabvM+MegeB4cDLRi6nw=
+github.com/onsi/ginkgo/v2 v2.25.3/go.mod h1:43uiyQC4Ed2tkOzLsEYm7hnrb7UJTWHYNsuy3bG/snE=
+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.8 h1:gCNqoesZ44saYOD3J7edhi5nDwUWKyQG7boM/kVwz2c=
-github.com/pocketbase/pocketbase v0.36.8/go.mod h1:OY4WaXbP0WnF/EXoBbboWJK+ZSZ1A85tiA0sjrTKxTA=
+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.30.1 h1:8lgfhH+HiSw1PyKVMq2sjtC4ZNvda2f/envTAzWMLOA=
+github.com/pocketbase/pocketbase v0.30.1/go.mod h1:sUI+uekXZam5Wa0eh+DClc+HieKMCeqsHA7Ydd9vwyE=
 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,90 +99,90 @@ 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.3 h1:2ESdQt90yU3oXF/CdOlRCJxrP+Am1aBYubTMTfxJ1qc=
-github.com/shirou/gopsutil/v4 v4.26.3/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ=
+github.com/shirou/gopsutil/v4 v4.25.9 h1:JImNpf6gCVhKgZhtaAHJ0serfFGtlfIlSC08eaKdTrU=
+github.com/shirou/gopsutil/v4 v4.25.9/go.mod h1:gxIxoC+7nQRwUl/xNhutXlD8lq+jxTgpIkEf3rADHL8=
 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=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
-github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA=
-github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
-github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
-github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
+github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
+github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
+github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
+github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
+go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
 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.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
-golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA=
-golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9 h1:TQwNpfvNkxAVlItJf6Cr5JTsVZoC/Sj7K3OZv2Pc14A=
+golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.38.0 h1:5l+q+Y9JDC7mBOMjo4/aPhMDcxEptsX+Tt3GgRQRPuE=
-golang.org/x/image v0.38.0/go.mod h1:/3f6vaXC+6CEanU4KJxbcUZyEePbyKbaLoDOe4ehFYY=
-golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
-golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
+golang.org/x/image v0.31.0 h1:mLChjE2MV6g1S7oqbXC0/UcKijjm5fnJLUYKIYrLESA=
+golang.org/x/image v0.31.0/go.mod h1:R9ec5Lcp96v9FTF+ajwaH3uGxPH4fKfHHAVbUILxghA=
+golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
+golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
-golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
-golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
-golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo=
+golang.org/x/oauth2 v0.31.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.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.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
-golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
+golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
 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.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
-golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
+golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
+golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 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=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 howett.net/plist v1.0.1 h1:37GdZ8tP09Q35o9ych3ehygcsL+HqKSwzctveSlarvM=
 howett.net/plist v1.0.1/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
-modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
-modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
-modernc.org/ccgo/v4 v4.32.0 h1:hjG66bI/kqIPX1b2yT6fr/jt+QedtP2fqojG2VrFuVw=
-modernc.org/ccgo/v4 v4.32.0/go.mod h1:6F08EBCx5uQc38kMGl+0Nm0oWczoo1c7cgpzEry7Uc0=
-modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
-modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
+modernc.org/cc/v4 v4.26.5 h1:xM3bX7Mve6G8K8b+T11ReenJOT+BmVqQj0FY5T4+5Y4=
+modernc.org/cc/v4 v4.26.5/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.1 h1:wPKYn5EC/mYTqBO373jKjvX2n+3+aK7+sICCv4Fjy1A=
+modernc.org/ccgo/v4 v4.28.1/go.mod h1:uD+4RnfrVgE6ec9NGguUNdhqzNIeeomeXf6CL0GTE5Q=
+modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA=
+modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
-modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo=
-modernc.org/gc/v3 v3.1.2/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.70.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw=
-modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo=
+modernc.org/libc v1.66.3 h1:cfCbjTUcdsKyyZZfEUKfoHcP3S0Wkvz3jgSzByEWVCQ=
+modernc.org/libc v1.66.3/go.mod h1:XD9zO8kt59cANKvHPXpx7yS2ELPheAey0vjIuZOhOU8=
+modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
+modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
 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=
@@ -197,8 +191,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.48.0 h1:ElZyLop3Q2mHYk5IFPPXADejZrlHu7APbpB0sF78bq4=
-modernc.org/sqlite v1.48.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
+modernc.org/sqlite v1.39.0 h1:6bwu9Ooim0yVYA7IZn9demiQk/Ejp0BtTjBWFLymSeY=
+modernc.org/sqlite v1.39.0/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
 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
@@ -21,14 +21,13 @@ type hubLike interface {

 type AlertManager struct {
 	hub           hubLike
-	stopOnce      sync.Once
+	alertQueue    chan alertTask
+	stopChan      chan struct{}
 	pendingAlerts sync.Map
-	alertsCache   *AlertsCache
 }

 type AlertMessageData struct {
 	UserID   string
-	SystemID string
 	Title    string
 	Message  string
 	Link     string
@@ -40,31 +39,19 @@ type UserNotificationSettings struct {
 	Webhooks []string `json:"webhooks"`
 }

-type SystemAlertFsStats struct {
-	DiskTotal float64 `json:"d"`
-	DiskUsed  float64 `json:"du"`
-}
-
-// Values pulled from system_stats.stats that are relevant to alerts.
 type SystemAlertStats struct {
-	Cpu          float64                       `json:"cpu"`
-	Mem          float64                       `json:"mp"`
-	Disk         float64                       `json:"dp"`
-	Bandwidth    [2]uint64                     `json:"b"`
-	GPU          map[string]SystemAlertGPUData `json:"g"`
-	Temperatures map[string]float32            `json:"t"`
-	LoadAvg      [3]float64                    `json:"la"`
-	Battery      [2]uint8                      `json:"bat"`
-	ExtraFs      map[string]SystemAlertFsStats `json:"efs"`
-}
-
-type SystemAlertGPUData struct {
-	Usage float64 `json:"u"`
+	Cpu          float64            `json:"cpu"`
+	Mem          float64            `json:"mp"`
+	Disk         float64            `json:"dp"`
+	NetSent      float64            `json:"ns"`
+	NetRecv      float64            `json:"nr"`
+	Temperatures map[string]float32 `json:"t"`
+	LoadAvg      [3]float64         `json:"la"`
 }

 type SystemAlertData struct {
 	systemRecord *core.Record
-	alertData    CachedAlertData
+	alertRecord  *core.Record
 	name         string
 	unit         string
 	val          float64
@@ -85,6 +72,7 @@ var supportsTitle = map[string]struct{}{
 	"ifttt":      {},
 	"join":       {},
 	"lark":       {},
+	"matrix":     {},
 	"ntfy":       {},
 	"opsgenie":   {},
 	"pushbullet": {},
@@ -98,10 +86,12 @@ var supportsTitle = map[string]struct{}{
 // NewAlertManager creates a new AlertManager instance.
 func NewAlertManager(app hubLike) *AlertManager {
 	am := &AlertManager{
-		hub:         app,
-		alertsCache: NewAlertsCache(app),
+		hub:        app,
+		alertQueue: make(chan alertTask, 5),
+		stopChan:   make(chan struct{}),
 	}
 	am.bindEvents()
+	go am.startWorker()
 	return am
 }

@@ -109,97 +99,10 @@ 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)
-
-	am.hub.OnServe().BindFunc(func(e *core.ServeEvent) error {
-		// Populate all alerts into cache on startup
-		_ = am.alertsCache.PopulateFromDB(true)
-
-		if err := resolveStatusAlerts(e.App); err != nil {
-			e.App.Logger().Error("Failed to resolve stale status alerts", "err", err)
-		}
-		if err := am.restorePendingStatusAlerts(); err != nil {
-			e.App.Logger().Error("Failed to restore pending status alerts", "err", err)
-		}
-		return e.Next()
-	})
-}
-
-// IsNotificationSilenced checks if a notification should be silenced based on configured quiet hours
-func (am *AlertManager) IsNotificationSilenced(userID, systemID string) bool {
-	// Query for quiet hours windows that match this user and system
-	// Include both global windows (system is null/empty) and system-specific windows
-	var filter string
-	var params dbx.Params
-
-	if systemID == "" {
-		// If no systemID provided, only check global windows
-		filter = "user={:user} AND system=''"
-		params = dbx.Params{"user": userID}
-	} else {
-		// Check both global and system-specific windows
-		filter = "user={:user} AND (system='' OR system={:system})"
-		params = dbx.Params{
-			"user":   userID,
-			"system": systemID,
-		}
-	}
-
-	quietHourWindows, err := am.hub.FindAllRecords("quiet_hours", dbx.NewExp(filter, params))
-	if err != nil || len(quietHourWindows) == 0 {
-		return false
-	}
-
-	now := time.Now().UTC()
-
-	for _, window := range quietHourWindows {
-		windowType := window.GetString("type")
-		start := window.GetDateTime("start").Time()
-		end := window.GetDateTime("end").Time()
-
-		if windowType == "daily" {
-			// For daily recurring windows, extract just the time portion and compare
-			// The start/end are stored as full datetime but we only care about HH:MM
-			startHour, startMin, _ := start.Clock()
-			endHour, endMin, _ := end.Clock()
-			nowHour, nowMin, _ := now.Clock()
-
-			// Convert to minutes since midnight for easier comparison
-			startMinutes := startHour*60 + startMin
-			endMinutes := endHour*60 + endMin
-			nowMinutes := nowHour*60 + nowMin
-
-			// Handle case where window crosses midnight
-			if endMinutes < startMinutes {
-				// Window crosses midnight (e.g., 23:00 - 01:00)
-				if nowMinutes >= startMinutes || nowMinutes < endMinutes {
-					return true
-				}
-			} else {
-				// Normal case (e.g., 09:00 - 17:00)
-				if nowMinutes >= startMinutes && nowMinutes < endMinutes {
-					return true
-				}
-			}
-		} else {
-			// One-time window: check if current time is within the date range
-			if (now.After(start) || now.Equal(start)) && now.Before(end) {
-				return true
-			}
-		}
-	}
-
-	return false
 }

 // SendAlert sends an alert to the user
 func (am *AlertManager) SendAlert(data AlertMessageData) error {
-	// Check if alert is silenced
-	if am.IsNotificationSilenced(data.UserID, data.SystemID) {
-		am.hub.Logger().Info("Notification silenced", "user", data.UserID, "system", data.SystemID, "title", data.Title)
-		return nil
-	}
-
 	// get user settings
 	record, err := am.hub.FindFirstRecordByFilter(
 		"user_settings", "user={:user}",
@@ -276,14 +179,13 @@ func (am *AlertManager) SendShoutrrrAlert(notificationUrl, title, message, link,
 	}

 	// Add link
-	switch scheme {
-	case "ntfy":
+	if scheme == "ntfy" {
 		queryParams.Add("Actions", fmt.Sprintf("view, %s, %s", linkText, link))
-	case "lark":
+	} else if scheme == "lark" {
 		queryParams.Add("link", link)
-	case "bark":
+	} else if scheme == "bark" {
 		queryParams.Add("url", link)
-	default:
+	} else {
 		message += "\n\n" + link
 	}

@@ -302,12 +204,17 @@ func (am *AlertManager) SendShoutrrrAlert(notificationUrl, title, message, link,
 	return nil
 }

-// setAlertTriggered updates the "triggered" status of an alert record in the database
-func (am *AlertManager) setAlertTriggered(alert CachedAlertData, triggered bool) error {
-	alertRecord, err := am.hub.FindRecordById("alerts", alert.Id)
-	if err != nil {
-		return err
+func (am *AlertManager) SendTestNotification(e *core.RequestEvent) error {
+	var data struct {
+		URL string `json:"url"`
 	}
-	alertRecord.Set("triggered", triggered)
-	return am.hub.Save(alertRecord)
+	err := e.BindBody(&data)
+	if err != nil || data.URL == "" {
+		return e.BadRequestError("URL is required", err)
+	}
+	err = am.SendShoutrrrAlert(data.URL, "Test Alert", "This is a notification from Beszel.", am.hub.Settings().Meta.AppURL, "View Beszel")
+	if err != nil {
+		return e.JSON(200, map[string]string{"err": err.Error()})
+	}
+	return e.JSON(200, map[string]bool{"err": false})
 }
--- a/Show More
+++ b/Show More