mac 2026-08-29 22:20:00 → now 1 session(s) Session Started Where Title FUBB6l 2026-08-30 21:44 Code/dashboard LACT GPU profile display and switcher ⚑ ❬FUBB6l❭ LACT GPU profile display and switcher ~/Code/dashboard ──────────────────────────────────────────────────────────────────────────────────────────────────── │ 2026-08-30 21:46:39 • user │ │ We're implementing a new plugin: LACT graphics card profile display and switcher. │ │ - You can get the available profiles with `lact cli profile list` │ - fetch the currently active profile with `lact cli profile get` │ - set profile with `lact cli profile set ` │ │ All commands have a parameter `--gpu-id ` to select a GPU. The parameter comes as first │ parameter before commands. │ Get a list of available GPUs with `lact cli list`. │ Shorten the GPU names like on the overview card. │ │ The list of profiles should be a dropdown per GPU and have a reload button. Do not refresh the │ profiles automatically (see llama plugin model load dropdown for example) │ 2026-08-30 21:46:39 • assistant • Qwen3.8-27B-Think @plan │ │ Let me start by understanding the codebase structure, and then investigate how existing plugins │ (especially the llama plugin) are implemented, and after that, I'll make a plan for the LACT │ plugin. │ │ Let me take a look at the codebase. │ │ I'll explore the codebase to understand the plugin architecture before planning the LACT plugin. │ │ read /home/mac/Code/dashboard/app/plugins/base.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/plugins/base.py" │ } │ out │ /home/mac/Code/dashboard/app/plugins/base.py │ file │ │ 1: from collections.abc import Awaitable, Callable │ 2: from dataclasses import dataclass, field │ 3: │ 4: │ 5: @dataclass │ 6: class Plugin: │ 7: id: str │ 8: title: str │ 9: description: str = "" │ 10: skeleton_fn: Callable[[], Awaitable[str]] | None = field(default=None) │ 11: open_fn: Callable[[], Awaitable[None]] | None = field(default=None) │ 12: close_fn: Callable[[], Awaitable[None]] | None = field(default=None) │ 13: │ 14: async def skeleton(self) -> str: │ 15: if self.skeleton_fn is None: │ 16: raise NotImplementedError │ 17: return await self.skeleton_fn() │ 18: │ 19: async def open(self) -> None: │ 20: if self.open_fn is not None: │ 21: await self.open_fn() │ 22: │ 23: async def close(self) -> None: │ 24: if self.close_fn is not None: │ 25: await self.close_fn() │ │ (End of file - total 25 lines) │ │ glob app/plugins/**/*.py ok 0.0s │ in │ { │ "pattern": "app/plugins/**/*.py" │ } │ out │ /home/mac/Code/dashboard/app/plugins/sleep.py │ /home/mac/Code/dashboard/app/plugins/base.py │ /home/mac/Code/dashboard/app/plugins/__init__.py │ /home/mac/Code/dashboard/app/plugins/llamacpp.py │ glob app/plugins/**/*.html ok 0.0s │ in │ { │ "pattern": "app/plugins/**/*.html" │ } │ out No files found │ │ tokens 525 in 164 out 8899 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:46:44 • assistant • Qwen3.8-27B-Think @plan │ │ Let me read the plugins' `__init__.py` and the llamacpp.py plugin, and also check how the │ templates are structured. │ │ read /home/mac/Code/dashboard/app/plugins/__init__.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/plugins/__init__.py" │ } │ out │ /home/mac/Code/dashboard/app/plugins/__init__.py │ file │ │ 1: from app.plugins.base import Plugin │ 2: from app.plugins.llamacpp import plugin as llamacpp_plugin, router as llamacpp_router │ 3: from app.plugins.sleep import plugin as sleep_plugin, router as sleep_router │ 4: │ 5: PLUGINS: list[Plugin] = [llamacpp_plugin, sleep_plugin] │ 6: ROUTERS = [llamacpp_router, sleep_router] │ 7: │ 8: __all__ = ["PLUGINS", "ROUTERS", "Plugin"] │ │ (End of file - total 8 lines) │ │ read /home/mac/Code/dashboard/app/plugins/llamacpp.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py" │ } │ out │ /home/mac/Code/dashboard/app/plugins/llamacpp.py │ file │ │ 1: from typing import Any │ 2: │ 3: import httpx │ 4: from fastapi import APIRouter, Form │ 5: from fastapi.responses import HTMLResponse │ 6: │ 7: from app.config import Settings, get_settings │ 8: from app.plugins.base import Plugin │ 9: from app.render import render │ 10: │ 11: router = APIRouter(prefix="/api/plugins/llamacpp", tags=["plugins"]) │ 12: │ 13: │ 14: def _headers(settings: Settings) -> dict[str, str]: │ 15: h = {} │ 16: if settings.llama_api_key: │ 17: h["Authorization"] = f"Bearer {settings.llama_api_key}" │ 18: return h │ 19: │ 20: │ 21: def _client() -> httpx.AsyncClient: │ 22: settings = get_settings() │ 23: return httpx.AsyncClient( │ 24: base_url=settings.llama_base_url.rstrip("/"), │ 25: timeout=settings.llama_timeout, │ 26: headers=_headers(settings), │ 27: ) │ 28: │ 29: │ 30: async def gather_status() -> dict[str, Any]: │ 31: """Query the llama-server router. Never raises; returns status dict.""" │ 32: settings = get_settings() │ 33: status: dict[str, Any] = { │ 34: "base_url": settings.llama_base_url, │ 35: "reachable": False, │ 36: "health": None, │ 37: "models": [], │ 38: "error": None, │ 39: } │ 40: try: │ 41: async with _client() as client: │ 42: try: │ 43: r = await client.get("/health") │ 44: status["health"] = r.json().get("status") if r.status_code == 200 else │ f"http {r.status_code}" │ 45: except httpx.HTTPError: │ 46: pass │ 47: r = await client.get("/models") │ 48: _ = r.raise_for_status() │ 49: status["reachable"] = True │ 50: data = r.json() │ 51: for m in data.get("data", []): │ 52: st: dict[str, Any] = m.get("status") or {} │ 53: item: dict[str, str | bool | float] = { │ 54: "id": str(m.get("id", "?")), │ 55: "sta │ … [4220 more chars] │ │ tokens 377 in 103 out 9587 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:46:46 • assistant • Qwen3.8-27B-Think @plan │ │ Next, let's take a look at the templates, the sleep plugin, and how the plugins are rendered in │ the UI. Also, let's check how GPU names are shortened on the overview card. │ │ glob templates/**/*.html ok 0.0s │ in │ { │ "pattern": "templates/**/*.html" │ } │ out │ /home/mac/Code/dashboard/templates/plugins/sleep_state.html │ /home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html │ /home/mac/Code/dashboard/templates/plugins/llamacpp_state.html │ /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html │ /home/mac/Code/dashboard/templates/plugins.html │ /home/mac/Code/dashboard/templates/index.html │ /home/mac/Code/dashboard/templates/overview.html │ /home/mac/Code/dashboard/templates/service_detail.html │ /home/mac/Code/dashboard/templates/services.html │ /home/mac/Code/dashboard/templates/journal.html │ /home/mac/Code/dashboard/templates/processes.html │ /home/mac/Code/dashboard/templates/disks.html │ read /home/mac/Code/dashboard/app/plugins/sleep.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/plugins/sleep.py" │ } │ out │ /home/mac/Code/dashboard/app/plugins/sleep.py │ file │ │ 1: import asyncio │ 2: import json │ 3: import os │ 4: import signal │ 5: from typing import Any │ 6: │ 7: from fastapi import APIRouter, Form │ 8: from fastapi.responses import HTMLResponse │ 9: │ 10: from app.plugins.base import Plugin │ 11: from app.render import render │ 12: │ 13: router = APIRouter(prefix="/api/plugins/sleep", tags=["plugins"]) │ 14: │ 15: WHO = "Dashboard (sleep-inhibit)" │ 16: WHY = "dashboard: keep system awake" │ 17: BLOCK_MODES = ("block", "block-weak") │ 18: │ 19: _holder: asyncio.subprocess.Process | None = None │ 20: _toggle_lock = asyncio.Lock() │ 21: │ 22: │ 23: async def _list() -> tuple[list[dict[str, Any]], str]: │ 24: try: │ 25: proc = await asyncio.create_subprocess_exec( │ 26: "systemd-inhibit", "--json=short", "--list", │ 27: stdout=asyncio.subprocess.PIPE, │ 28: stderr=asyncio.subprocess.PIPE, │ 29: ) │ 30: except OSError as e: │ 31: return [], str(e)[:200] │ 32: try: │ 33: out, err = await asyncio.wait_for(proc.communicate(), 5) │ 34: except TimeoutError: │ 35: try: │ 36: _ = proc.kill() │ 37: except ProcessLookupError: │ 38: pass │ 39: return [], "systemd-inhibit timed out" │ 40: if proc.returncode != 0: │ 41: return [], (err.decode(errors="replace").strip() or f"systemd-inhibit failed │ (rc={proc.returncode})")[:200] │ 42: try: │ 43: data = json.loads(out.decode(errors="replace")) │ 44: except ValueError: │ 45: return [], "could not parse systemd-inhibit output" │ 46: if not isinstance(data, list): │ 47: return [], "unexpected systemd-inhibit output" │ 48: items: list[dict[str, Any]] = [e for e in data if isinstance(e, dict)] │ 49: return items, "" │ 50: │ 51: │ 52: def _verdict(inhibitors: list[dict[str, Any]]) -> str: │ 53: for e in inhibitors: │ 54: whats = str(e.get("what", "")).split(":") │ 55: if "sleep" in whats and e.get("mod │ … [4562 more chars] │ │ tokens 2209 in 105 out 10066 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:46:52 • assistant • Qwen3.8-27B-Think @plan │ │ Next, let's check the templates: the plugins tab, the state/skeleton templates for llamacpp and │ sleep, the render function, and how GPU names are shortened in the overview. │ │ read /home/mac/Code/dashboard/templates/plugins.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/plugins.html" │ } │ out │ /home/mac/Code/dashboard/templates/plugins.html │ file │ │ 1:
│ 2: {% for item in items %} │ 3:
│ 4:

{{ item.p.title }}

│ 5:

{{ item.p.description }}

│ 6:
{{ item.body | safe }}
│ 7:
│ 8: {% else %} │ 9:
no plugins registered
│ 10: {% endfor %} │ 11:
│ │ (End of file - total 11 lines) │ │ read /home/mac/Code/dashboard/templates/plugins/llamacpp_state.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_state.html" │ } │ out │ /home/mac/Code/dashboard/templates/plugins/llamacpp_state.html │ file │ │ 1: {% if not reachable %} │ 2:
llama-server unreachable at {{ base_url }}{% │ if error %}: {{ error }}{% endif %}
│ 3:
start it in router mode: llama-server │ --models-dir /path/to/models
│ 4: {% else %} │ 5:
│ 6: │ 7: {{ "healthy" if health == "ok" else (health or "status │ unknown") }} │ 8: {{ base_url }} │ 9:
│ 10: {% if message %}
{{ message }}
{% endif %} │ 11: {% if error_msg %}
{{ error_msg }}
{% endif %} │ 12: │ 13:

Loaded models

│ 14: {% if loaded %} │ 15:
│ 16: {% for m in loaded %} │ 17:
│ 18: │ 19: {{ m.id }} │ 20: {{ m.state }}{% if │ m.failed %} (exit {{ m.exit_code }}){% endif %} │ 21: {% if m.progress is not none %}
{% endif %} │ 22: │ 23: │ 24: │ 25:
│ 26: {% endfor %} │ 27:
│ 28: {% else %} │ 29:
no models loaded
│ 30: {% endif %} │ 31: {% endif %} │ │ (End of file - total 31 lines) │ │ read /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html" │ } │ out │ /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html │ file │ │ 1:
│ 2:
│ 3: {% include "plugins/llamacpp_state.html" %} │ 4:
│ 5: {% if reachable %} │ 6:

Available models

│ 7: {% if available %} │ 8:
│ 9: │ 14: │ 15:
│ 16: {% else %} │ 17:
no unloaded models (is --models-dir set on the server?)
│ 18: {% endif %} │ 19: │ 20:
│ 21: │ 22:
│ 23: {% endif %} │ 24:
│ │ (End of file - total 24 lines) │ │ │ tokens 2407 in 148 out 12379 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:46:58 • assistant • Qwen3.8-27B-Think @plan │ │ Next, let's check how the plugins router (the one that assembles the plugin tab) works, the │ rendering, and also the shortening of GPU names in the overview. │ │ glob app/routers/*.py ok 0.0s │ in │ { │ "pattern": "app/routers/*.py" │ } │ out │ /home/mac/Code/dashboard/app/routers/overview.py │ /home/mac/Code/dashboard/app/routers/plugins.py │ /home/mac/Code/dashboard/app/routers/__init__.py │ /home/mac/Code/dashboard/app/routers/services.py │ /home/mac/Code/dashboard/app/routers/journal.py │ /home/mac/Code/dashboard/app/routers/processes.py │ /home/mac/Code/dashboard/app/routers/disks.py │ grep plugins ok 0.0s │ in │ { │ "pattern": "plugins", │ "path": "/home/mac/Code/dashboard/app/routers" │ } │ out │ Found 6 matches │ /home/mac/Code/dashboard/app/routers/plugins.py: │ Line 4: from app.plugins import PLUGINS, Plugin │ │ Line 7: router = APIRouter(prefix="/api/plugins", tags=["plugins"]) │ │ Line 11: async def plugins_index(): │ │ Line 19: return HTMLResponse(render("plugins.html", items=items)) │ │ │ /home/mac/Code/dashboard/app/routers/__init__.py: │ Line 1: from app.routers import disks, journal, overview, plugins, processes, services │ │ Line 3: __all__ = ["overview", "disks", "processes", "journal", "services", "plugins"] │ │ tokens 1304 in 113 out 14933 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:03 • assistant • Qwen3.8-27B-Think @plan │ │ Let's take a look at the plugin's router, overview's router, and how the GPU name is abbreviated │ on the overview card. Also, I'll check the sleep state/skeleton template for style reference. │ │ read /home/mac/Code/dashboard/app/routers/plugins.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/routers/plugins.py" │ } │ out │ /home/mac/Code/dashboard/app/routers/plugins.py │ file │ │ 1: from fastapi import APIRouter │ 2: from fastapi.responses import HTMLResponse │ 3: │ 4: from app.plugins import PLUGINS, Plugin │ 5: from app.render import render │ 6: │ 7: router = APIRouter(prefix="/api/plugins", tags=["plugins"]) │ 8: │ 9: │ 10: @router.get("") │ 11: async def plugins_index(): │ 12: items: list[dict[str, Plugin | str]] = [] │ 13: for p in PLUGINS: │ 14: try: │ 15: body = await p.skeleton() │ 16: except Exception as e: # noqa │ 17: body = f"
plugin error: {e}
" │ 18: items.append({"p": p, "body": body}) │ 19: return HTMLResponse(render("plugins.html", items=items)) │ │ (End of file - total 19 lines) │ │ read /home/mac/Code/dashboard/app/routers/overview.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/routers/overview.py" │ } │ out │ /home/mac/Code/dashboard/app/routers/overview.py │ file │ │ 1: import asyncio │ 2: import math │ 3: import socket │ 4: import time │ 5: from dataclasses import fields │ 6: from typing import Any │ 7: │ 8: import psutil │ 9: from fastapi import APIRouter, Request │ 10: from fastapi.responses import HTMLResponse, JSONResponse │ 11: │ 12: from app.collect import net as net_col │ 13: from app.config import get_settings │ 14: from app.render import render, uptime_str │ 15: from app.sample import Sample │ 16: │ 17: router = APIRouter(prefix="/api", tags=["overview"]) │ 18: │ 19: RowAgg = dict[str, float | int | None] │ 20: │ 21: │ 22: def _window(snap: list[Sample], max_points: int) -> list[tuple[float, dict[str, │ RowAgg]]]: │ 23: n = len(snap) │ 24: w = max(1, math.ceil(n / max_points)) │ 25: out: list[tuple[float, dict[str, RowAgg]]] = [] │ 26: for start in range(0, n, w): │ 27: chunk = snap[start : start + w] │ 28: vals: dict[str, list[int | float]] = {} │ 29: for sample in chunk: │ 30: for f in fields(sample): │ 31: if f.name == "ts": │ 32: continue │ 33: v = getattr(sample, f.name) │ 34: if isinstance(v, (int, float)) and not isinstance(v, bool): │ 35: vals.setdefault(f.name, []).append(v) │ 36: row: dict[str, RowAgg] = {} │ 37: for k, lst in vals.items(): │ 38: ints = all(isinstance(v, int) for v in lst) │ 39: avg = sum(lst) / len(lst) │ 40: row[k] = { │ 41: "avg": round(avg) if ints else round(avg, 1), │ 42: "min": min(lst) if ints else round(min(lst), 1), │ 43: "max": max(lst) if ints else round(max(lst), 1), │ 44: } │ 45: out.append((chunk[-1].ts, row)) │ 46: return out │ 47: │ 48: │ 49: @router.get("/overview") │ 50: async def overview(request: Request): │ 51: store = request.app.state.store │ 52: s = store.latest() or Sample() │ 53: mem_total = s.mem_total │ … [1925 more chars] │ read /home/mac/Code/dashboard/templates/plugins/sleep_state.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/plugins/sleep_state.html" │ } │ out │ /home/mac/Code/dashboard/templates/plugins/sleep_state.html │ file │ │ 1: {% if error %}
systemd-inhibit failed: {{ error }}
{% endif %} │ 2: {% if message %}
{{ message }}
{% endif %} │ 3:
│ 4: │ 5: {{ "sleep blocked" if verdict == "blocked" else "sleep │ allowed" }} │ 6: block-mode locks only — delay-mode locks are ignored │ 7:
│ 8: │ 12: {% if inhibitors %} │ 13:
│ 14: │ 15: │ 16: │ 17: {% for e in inhibitors %} │ 18: │ 19: │ 20: │ 21: │ 22: │ 23: │ 24: {% endfor %} │ 25: │ 26:
whowhatwhymode
{{ e.who }}{% if e.proc %} {{ │ e.proc }}{% endif %}{% for w in e.what.split(":") if w %}{{ w }} {% │ endfor %}{{ e.why }}{{ e.mode │ }}
│ 27:
│ 28: {% else %} │ 29:
no active block-mode inhibitors — the system may sleep
│ 30: {% endif %} │ │ (End of file - total 30 lines) │ │ │ tokens 249 in 149 out 16350 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:07 • assistant • Qwen3.8-27B-Think @plan │ │ Next, I need to check how the GPU name is being shortened in the overview card. `s.gpu_name` — │ let's take a look at the GPU collector. │ │ Now let me check how GPU names are gathered and shortened in the collector/overview: │ │ glob app/collect/*.py ok 0.0s │ in │ { │ "pattern": "app/collect/*.py" │ } │ out │ /home/mac/Code/dashboard/app/collect/net.py │ /home/mac/Code/dashboard/app/collect/power.py │ /home/mac/Code/dashboard/app/collect/__init__.py │ /home/mac/Code/dashboard/app/collect/mem.py │ /home/mac/Code/dashboard/app/collect/procs.py │ /home/mac/Code/dashboard/app/collect/gpu.py │ /home/mac/Code/dashboard/app/collect/disks.py │ /home/mac/Code/dashboard/app/collect/cpu.py │ grep gpu_name ok 0.0s │ in │ { │ "pattern": "gpu_name", │ "path": "/home/mac/Code/dashboard" │ } │ out │ Found 53 matches │ /home/mac/Code/dashboard/app/sample.py: │ Line 23: gpu_name: str = "no GPU detected" │ │ │ /home/mac/Code/dashboard/opencode/opencode_session_refactor_sample_storage_2026-08-30.txt: │ Line 289: │ 29: def _gpu_name() -> str: │ │ Line 1120: │ - `gpu_name` (str) │ │ Line 1394: │ `vram_pct: float | None`, `gpu_temp: float | None`, `gpu_name: str` │ │ Line 1458: │ | `gpu`, `vram_used/total`, `vram_pct`, `gpu_temp`, `gpu_name` | mixed | │ `gpu.py` | │ │ Line 1689: │ float | None = None\n gpu_name: str = \"no GPU detected\"\n │ battery: int | None = │ │ Line 1794: │ "gpu_name": _gpu_name(), │ │ Line 1860: │ else None,\n \"gpu_name\": _gpu_name(),\n }", │ │ Line 1901: │ float(temp),\n \"gpu_name\": name,\n }\n\n\ndef sample() -> │ dict[str, Any]:\n │ │ Line 1904: │ \"vram_pct\": None,\n \"gpu_temp\": None,\n │ \"gpu_name\": \"no GPU │ │ Line 2504: │ \"gpu\": s.get(\"gpu\"),\n \"gpu_name\": │ s.get(\"gpu_name\"),\n │ │ Line 3377: │ - Notably, `ts`, `gpu_name`, `battery_status`, `ac_online` are correctly │ EXCLUDED (ts │ │ │ /home/mac/Code/dashboard/opencode/opencode_session_chart_flicker_2026-08-30.txt: │ Line 128: │ 36: "gpu_name": s.get("gpu_name"), │ │ │ /home/mac/Code/dashboard/app/routers/overview.py: │ Line 69: "gpu_name": s.gpu_name, │ │ │ /home/mac/Code/dashboard/app/collect/gpu.py: │ Line 30: def _gpu_name() -> str: │ │ Line 80: s.gpu_name = _gpu_name() │ │ Line 123: s.gpu_name = name │ │ │ /home/mac/Code/dashboard/opencode/opencode_session_2026-08-30.txt: │ Line 1518: │ return f.read().strip()\n except OSError:\n return │ None\n\n\ndef _gpu_name() -> │ │ Line 2246: │ \"gpu_name\": s.get(\"gpu_name\"),\n \"gpu_temp\": │ s.get(\"gpu_temp\"),\n │ │ Line 2343: │
{{ c.gpu_name }}{% if c.gpu_temp is not none %} │ · {{ c.gpu_temp | │ │ Line 2347: │
{{ c.gpu_name │ … [2956 more chars] │ │ tokens 2194 in 127 out 16747 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:13 • assistant • Qwen3.8-27B-Think @plan │ │ The `opencode/` directory contains session logs, which are not part of the codebase. Let me read │ the GPU collector and check `_gpu_name` and the shortening logic. │ │ read /home/mac/Code/dashboard/app/collect/gpu.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/collect/gpu.py" │ } │ out │ /home/mac/Code/dashboard/app/collect/gpu.py │ file │ │ 1: import glob │ 2: import re │ 3: import shutil │ 4: import subprocess │ 5: │ 6: from app.sample import Sample │ 7: │ 8: _name_cache: str | None = None │ 9: │ 10: │ 11: def _read(path: str) -> str | None: │ 12: try: │ 13: with open(path) as f: │ 14: return f.read().strip() │ 15: except OSError: │ 16: return None │ 17: │ 18: │ 19: def _shorten(name: str) -> str: │ 20: name = re.sub(r"\s*\(rev.*\)$", "", name).strip() │ 21: groups = re.findall(r"\[([^\]]+)\]", name) │ 22: if len(groups) >= 2: │ 23: brand = groups[0] │ 24: series = groups[-1].split(" / ")[0] │ 25: model = name.split("]", 1)[1].split("[", 1)[0].strip() │ 26: return f"{brand} {model} ({series})".strip() │ 27: return name[:50] │ 28: │ 29: │ 30: def _gpu_name() -> str: │ 31: global _name_cache │ 32: if _name_cache is None: │ 33: _name_cache = "GPU" │ 34: if shutil.which("lspci"): │ 35: try: │ 36: out = subprocess.run( │ 37: ["lspci"], capture_output=True, text=True, timeout=5, check=False │ 38: ).stdout │ 39: for line in out.splitlines(): │ 40: if "VGA" in line or "3D controller" in line: │ 41: _name_cache = _shorten(line.split(":", 2)[-1].strip()) │ 42: break │ 43: except (OSError, subprocess.SubprocessError): │ 44: pass │ 45: return _name_cache │ 46: │ 47: │ 48: def _amd(s: Sample) -> bool: │ 49: devices = sorted(glob.glob("/sys/class/drm/card[0-9]*/device/gpu_busy_percent")) │ 50: if not devices: │ 51: return False │ 52: busy_sum = 0 │ 53: count = 0 │ 54: vram_used = 0 │ 55: vram_total = 0 │ 56: temps: list[float] = [] │ 57: for busy_path in devices: │ 58: dev = busy_path.rsplit("/", 1)[0] │ 59: try: │ 60: busy_sum += int(_read(busy_path) or 0) │ 61: count += 1 │ 62: │ … [2442 more chars] │ │ tokens 1926 in 76 out 19067 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:18 • assistant • Qwen3.8-27B-Think @plan │ │ Alright, now I understand the GPU name shortening: `_shorten()` in `app/collect/gpu.py` strips │ the "(rev ...)" suffix and converts `Brand [model] [series / ...]` → `Brand model (series)`. │ │ Now, the LACT plugin: │ - `lact cli list` lists the GPUs. I need to verify what the output format looks like. Let me │ check whether `lact` is installed in this environment. │ - `lact cli --gpu-id profile list` — lists the profiles │ - `lact cli --gpu-id profile get` — the currently active profile │ - `lact cli --gpu-id profile set ` │ │ The user is saying that the `--gpu-id` parameter "comes as the first parameter before the │ command." In other words, the command becomes `lact cli --gpu-id profile list` and so on. │ │ Let me check the actual output format of `lact` on this machine. I can run read-only commands to │ inspect the output — since it's read-only, it should be fine even in plan mode. `lact cli list` │ just lists GPUs, so it's read-only. │ │ Also, let me check the render function, the main.py where the plugin's open/close is called, and │ the config. │ │ Let me check the render function, main.py, and inspect the actual `lact` CLI output formats: │ │ read /home/mac/Code/dashboard/app/render.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/render.py" │ } │ out │ /home/mac/Code/dashboard/app/render.py │ file │ │ 1: from datetime import timedelta │ 2: from pathlib import Path │ 3: from typing import Any │ 4: │ 5: from jinja2 import Environment, FileSystemLoader, select_autoescape │ 6: │ 7: BASE = Path(__file__).resolve().parent.parent │ 8: │ 9: │ 10: def humanize(value: float | str | None) -> str: │ 11: if value is None: │ 12: return "—" │ 13: n = float(value) │ 14: for unit in ("B", "KiB", "MiB", "GiB", "TiB"): │ 15: if abs(n) < 1024 or unit == "TiB": │ 16: if unit == "B": │ 17: return f"{int(n)} B" │ 18: return f"{n:.1f} {unit}" │ 19: n /= 1024 │ 20: return f"{n:.1f} TiB" │ 21: │ 22: │ 23: def rate(value: float | str | None) -> str: │ 24: if value is None: │ 25: return "—" │ 26: n = float(value) │ 27: for unit in ("B/s", "KiB/s", "MiB/s", "GiB/s"): │ 28: if abs(n) < 1024 or unit == "GiB/s": │ 29: if unit == "B/s": │ 30: return f"{int(n)} B/s" │ 31: return f"{n:.1f} {unit}" │ 32: n /= 1024 │ 33: return f"{n:.1f} GiB/s" │ 34: │ 35: │ 36: def uptime_str(seconds: float | None) -> str: │ 37: if seconds is None: │ 38: return "—" │ 39: td = timedelta(seconds=int(seconds)) │ 40: days, rem = divmod(td.seconds, 86400) │ 41: hours, rem = divmod(rem, 3600) │ 42: minutes = rem // 60 │ 43: parts: list[str] = [] │ 44: if days: │ 45: parts.append(f"{days}d") │ 46: if days or hours: │ 47: parts.append(f"{hours}h") │ 48: parts.append(f"{minutes}m") │ 49: return " ".join(parts) │ 50: │ 51: │ 52: def pct(value: float | None) -> str: │ 53: if value is None: │ 54: return "—" │ 55: return f"{value:.0f}%" │ 56: │ 57: │ 58: env = Environment( │ 59: loader=FileSystemLoader(BASE / "templates"), │ 60: autoescape=select_autoescape(("html", "j2")), │ 61: ) │ 62: env.filters["humanize"] = humanize │ 63: env.filters["rate"] = rate │ 64: env.filters["uptime"] = uptime_str │ 65: env.filters["pct"] │ … [162 more chars] │ read /home/mac/Code/dashboard/main.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/main.py" │ } │ out │ /home/mac/Code/dashboard/main.py │ file │ │ 1: import uvicorn │ 2: │ 3: from app.config import get_settings │ 4: │ 5: if __name__ == "__main__": │ 6: s = get_settings() │ 7: uvicorn.run("app.main:app", host=s.host, port=s.port, log_level="warning") │ │ (End of file - total 7 lines) │ │ bash which lact && lact cli list 2>&1 | head -40 ok 0.0s │ in │ { │ "command": "which lact && lact cli list 2>&1 | head -40" │ } │ out │ /usr/bin/lact │ 0: 1002:1636-17AA:380D-0000:04:00.0 (Renoir [Radeon Vega Series / Radeon Vega Mobile │ Series]) [Integrated] │ │ tokens 1592 in 415 out 21069 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:30 • assistant • Qwen3.8-27B-Think @plan │ │ The output of `lact cli list` is as follows: │ ``` │ 0: 1002:1636-17AA:380D-0000:04:00.0 (Renoir [Radeon Vega Series / Radeon Vega Mobile Series]) │ [Integrated] │ ``` │ │ So the format is: `: ( [series]) []`. Let me parse this: │ - GPU ID: `0` │ - PCI: `1002:1636-17AA:380D-0000:04:00.0` │ - Name part: `Renoir [Radeon Vega Series / Radeon Vega Mobile Series]` │ - Type: `[Integrated]` │ │ The overview card shortens `AMD/ATI ... (Renoir [Radeon Vega Series])` into, for example, │ `Renoir (Radeon Vega Series)`. Let me check the output of lspci on this machine and see what the │ overview displays. │ │ Actually, the output format of lspci is: `04:00.0 VGA compatible controller: AMD/ATI Device │ [Renoir] [Radeon Vega Series / Radeon Vega Mobile Series] (rev xx)`. And `_shorten` produces │ `AMD/ATI Renoir (Radeon Vega Series)`. Hmm, wait: brand = groups[0] = "AMD/ATI"? No wait — the │ groups are `[Renoir]` and `[Radeon Vega Series / Radeon Vega Mobile Series]`, so │ brand=groups[0]="Renoir", series="Radeon Vega Series", model = │ name.split("]",1)[1].split("[",1)[0].strip() — hmm. │ │ Let me actually check what lspci displays on this machine. │ │ Let me check what the GPU card currently shows. Let me run `lspci | grep -E "VGA|3D │ controller"`. │ │ Next, `lact cli profile list` for GPU 0. And `lact cli profile get`. Let me run these read-only │ commands. │ │ bash lspci 2>/dev/null | grep -E "VGA|3D controller" ok 0.0s │ in │ { │ "command": "lspci 2>/dev/null | grep -E \"VGA|3D controller\"" │ } │ out 04:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Renoir [Radeon │ Vega Series / Radeon Vega Mobile Series] (rev c1) │ bash lact cli --gpu-id 0 profile list 2>&1; echo "---rc=$?"; lact cli --gpu-id 0 … ok 0.0s │ in │ { │ "command": "lact cli --gpu-id 0 profile list 2>&1; echo \"---rc=$?\"; lact cli --gpu-id 0 │ profile get 2>&1; echo \"---rc=$?\"" │ } │ out │ Default │ ---rc=0 │ Default │ ---rc=0 │ │ tokens 1014 in 564 out 23075 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:45 • assistant • Qwen3.8-27B-Think @plan │ │ So: │ - lspci line: `04:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Renoir │ [Radeon Vega Series / Radeon Vega Mobile Series] (rev c1)` │ - After `_shorten`: groups = ["AMD/ATI", "Radeon Vega Series / Radeon Vega Mobile Series"], │ brand = "AMD/ATI", series = "Radeon Vega Series", model = │ name.split("]",1)[1].split("[",1)[0].strip() — splitting "Advanced Micro Devices, Inc. │ [AMD/ATI] Renoir [Radeon Vega Series...]" by "]" → "Advanced Micro Devices, Inc. [AMD/ATI" │ then splitting by "[" → " Renoir " → "Renoir". So the result is: `AMD/ATI Renoir (Radeon Vega │ Series)`. │ │ Wait, but the earlier grep result from the session log showed `gpu_name: "AMD/ATI Renoir (Radeon │ Vega Series)"`. Good. │ │ - `lact cli list` output: `0: 1002:1636-17AA:380D-0000:04:00.0 (Renoir [Radeon Vega Series / │ Radeon Vega Mobile Series]) [Integrated]` │ - `lact cli --gpu-id 0 profile list`: `Default` (one profile per line? or one profile per line?) │ - `lact cli --gpu-id 0 profile get`: `Default` │ │ Let me check the lact CLI documentation for the output format of profile list. I'll check `lact │ cli profile list --help` and `lact cli --help`. Also, let me check how profile list output looks │ when there are multiple profiles — probably one per line. │ │ Let me check the help. │ │ bash lact cli --help 2>&1; echo ===; lact cli profile --help 2>&1; echo ===; lact… ok 0.0s │ in │ { │ "command": "lact cli --help 2>&1; echo ===; lact cli profile --help 2>&1; echo ===; lact │ cli profile list --help 2>&1" │ } │ out │ Run the CLI │ │ Usage: lact cli [OPTIONS] │ │ Commands: │ list List GPUs │ info Show GPU info │ stats Show GPU stats │ snapshot Generate debug snapshot │ power-limit Manage GPU power limit │ profile Manage profiles │ detach Detach the GPU from LACT (temporarily ignore it) │ reattach Reattach a previously detached GPU │ help Print this message or the help of the given subcommand(s) │ │ Options: │ -g, --gpu-id │ -h, --help Print help │ -V, --version Print version │ === │ Manage profiles │ │ Usage: lact cli profile [COMMAND] │ │ Commands: │ list List profiles │ get Current profile │ set Set profile │ auto-switch Manage profile auto switching │ help Print this message or the help of the given subcommand(s) │ │ Options: │ -h, --help Print help │ === │ List profiles │ │ Usage: lact cli profile list │ │ Options: │ -h, --help Print help │ bash lact cli list --help 2>&1; echo ===; lact --version 2>&1 ok 0.0s │ in │ { │ "command": "lact cli list --help 2>&1; echo ===; lact --version 2>&1" │ } │ out │ List GPUs │ │ Usage: lact cli list │ │ Options: │ -h, --help Print help │ === │ error: unexpected argument '--version' found │ │ Usage: lact [COMMAND] │ │ For more information, try '--help'. │ │ tokens 73 in 496 out 24653 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:47:57 • assistant • Qwen3.8-27B-Think @plan │ │ Now I understand the CLI. The output format of `lact cli list` is as follows: │ ``` │ 0: 1002:1636-17AA:380D-0000:04:00.0 (Renoir [Radeon Vega Series / Radeon Vega Mobile Series]) │ [Integrated] │ ``` │ │ Let's analyze the format: │ - `0` = GPU ID │ - `1002:1636-17AA:380D-0000:04:00.0` = PCI address / device identifier │ - `(Renoir [Radeon Vega Series / Radeon Vega Mobile Series])` = GPU name in parentheses │ - `[Integrated]` = type badge │ │ The user's request is: "Shorten the GPU names in the same way as the overview card." │ │ On the overview card, `_shorten` is used. Let's see how the name appears on the overview card. │ The `gpu_name` field is set from `_gpu_name()`, which reads the output of lspci and applies │ `_shorten` to it. │ │ The lspci output here is: │ `04:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Renoir [Radeon Vega │ Series / Radeon Vega Mobile Series] (rev c1)` │ │ So `_gpu_name()` extracts `line.split(":", 2)[-1].strip()`, i.e. `Advanced Micro Devices, Inc. │ [AMD/ATI] Renoir [Radeon Vega Series / Radeon Vega Mobile Series] (rev c1)`, and then applies │ `_shorten` to it. │ │ `_shorten`: │ - Strips ` (rev c1)` │ - groups = findall of `[...]` = `["AMD/ATI", "Radeon Vega Series / Radeon Vega Mobile Series"]` │ - len(groups) >= 2 → brand = "AMD/ATI", series = "Radeon Vega Series" (the first " / " segment │ of the last group), model = `name.split("]", 1)[1].split("[", 1)[0].strip()` │ │ Let's compute: after stripping rev, name = `Advanced Micro Devices, Inc. [AMD/ATI] Renoir │ [Radeon Vega Series / Radeon Vega Mobile Series]` │ - `name.split("]", 1)` → `["Advanced Micro Devices, Inc. [AMD/ATI", " Renoir [Radeon Vega Series │ / Radeon Vega Mobile Series]"]` │ - `[1]` = ` Renoir [Radeon Vega Series / Radeon Vega Mobile Series]` │ - `.split("[", 1)` → `[" Renoir ", "Radeon Vega Series / Radeon Vega Mobile Series]"]` │ - `[0].strip()` = `Renoir` │ │ So the result = `AMD/ATI Renoir (Radeon Vega Series)`. │ │ That's how it's shortened. Good. │ │ Now, in the case of LACT's `lact cli list`, the name inside th │ … [5667 more chars] │ │ Let me look at the overview template and config to complete my understanding: │ │ read /home/mac/Code/dashboard/templates/overview.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/overview.html" │ } │ out │ /home/mac/Code/dashboard/templates/overview.html │ file │ │ 1:
│ 2: {% macro bar(pct) %}{% if pct is not none %}
{% │ endif %}{% endmacro %} │ 3: {% macro barrow(label, pct, cls) %}{% if pct is not none %}
{{ label }}
{% endif %}{% endmacro %} │ 4:
│ 5:
CPU / GPU
│ 6:
{{ (c.cpu | default(0, true)) | round(1) }}%
│ 7: {{ barrow("CPU", c.cpu) }} │ 8: {{ barrow("GPU", c.gpu, "gpu") }} │ 9: {% if c.cpu_temp is not none or c.gpu_temp is not none %} │ 10:
│ 11: {% if c.cpu_temp is not none %}CPU {{ c.cpu_temp | round(0) | int }}°C{% │ endif %} │ 12: {% if c.cpu_temp is not none and c.gpu_temp is not none %} ·{% endif %} │ 13: {% if c.gpu_temp is not none %}GPU {{ c.gpu_temp | round(0) | int }}°C{% │ endif %} │ 14:
│ 15: {% endif %} │ 16:
load {{ (c.load1 | default(0, true)) | round(2) }} · {{ │ c.cores }} cores
│ 17:
│ 18:
│ 19:
Memory
│ 20:
{{ c.mem_used | humanize }} / {{ │ c.mem_total | humanize }} ({{ (c.mem_pct | default(0, true)) | round(0) | int │ }}%)
│ 21: {{ bar(c.mem_pct) }} │ 22:
│ 23:
Swap {% if c.swap_total %}{{ c.swap_used | humanize }} │ / {{ c.swap_total | humanize }} ({{ (c.swap_pct | default(0, true)) | │ … [2464 more chars] │ read /home/mac/Code/dashboard/app/config.py ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/app/config.py" │ } │ out │ /home/mac/Code/dashboard/app/config.py │ file │ │ 1: from functools import lru_cache │ 2: │ 3: from pydantic_settings import BaseSettings, SettingsConfigDict │ 4: │ 5: │ 6: class Settings(BaseSettings): │ 7: model_config = SettingsConfigDict(env_prefix="DASH_", env_file=".env", │ extra="ignore") │ 8: │ 9: host: str = "127.0.0.1" │ 10: port: int = 8501 │ 11: sample_interval: float = 2.0 │ 12: retention_minutes: int = 60 │ 13: chart_max_points: int = 200 │ 14: │ 15: llama_base_url: str = "http://127.0.0.1:8080" │ 16: llama_api_key: str = "" │ 17: llama_timeout: float = 4.0 │ 18: │ 19: @property │ 20: def history_maxlen(self) -> int: │ 21: return max(10, int(self.retention_minutes * 60 / self.sample_interval)) │ 22: │ 23: │ 24: @lru_cache │ 25: def get_settings() -> Settings: │ 26: return Settings() │ │ (End of file - total 26 lines) │ │ │ tokens 305 in 2307 out 25223 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:48:51 • assistant • Qwen3.8-27B-Think @plan │ │ Hmm, interesting — the overview.html in this repo version doesn't display gpu_name? Wait, in the │ session log `{{ c.gpu_name }}` was displayed inside the card. But the current overview.html │ doesn't include gpu_name at all. Let me double-check... Lines 18-30 are the Memory card. There's │ no GPU card that displays gpu_name. Hmm, wait — but overview.py passes gpu_name. Maybe the │ gpu_name display was removed, or it's on a different line. Let me grep for gpu_name in the │ templates. │ │ From the earlier grep: `templates/overview.html` didn't come up in the gpu_name matches (only │ app/routers/overview.py:69 and session logs). So the current overview template doesn't render │ gpu_name. Hmm. │ │ Wait, let me grep again — the earlier grep pattern `gpu_name` matched 53 places, all inside app/ │ and the opencode session files. Nothing inside templates/. So the overview card currently │ doesn't display the GPU name? │ │ Hmm, but the user says "shorten the GPU name the same way as the overview card." Maybe the GPU │ name display is elsewhere — maybe there's a "GPU" card? Let me grep "card-label" in │ overview.html: CPU / GPU, Memory, Battery, Network, Uptime. The CPU/GPU card doesn't display a │ name. │ │ Hmm, wait. Maybe I misread. Let me re-check the git log / git status to see if this is the │ latest state. Or maybe the user is referring to the `_shorten` function inside │ app/collect/gpu.py that's used for the overview (even if the template currently doesn't display │ it — or maybe the user wants it displayed). Let me check git log to understand the state of the │ repo. │ │ bash git log --oneline -10 && git status --short ok 0.0s │ in │ { │ "command": "git log --oneline -10 && git status --short", │ "workdir": "/home/mac/Code/dashboard" │ } │ out │ 14f44f2 Move opencode traces to subdir │ e8a3171 Implement sleep inhibitor plugin │ a3b5bcf Inline service information into the table to make it more accessible │ bd6a503 Refactor: Store samples in a Sample Dataclass instead of loose dicts │ f92984b Bugfix: When interacting with a plugin fragment the automatic reload interfered with │ user actions │ 23341d8 Bugfix: Cursor for journal tab not applied correctly causing duplicated entries │ 9fa4e15 Bugfix: Flickering overview charts because of bad choice of point reducing method │ 6fdfde8 Initial commit │ grep GPU|gpu ok 0.0s │ in │ { │ "pattern": "GPU|gpu", │ "path": "/home/mac/Code/dashboard/templates", │ "include": "*.html" │ } │ out │ Found 9 matches │ /home/mac/Code/dashboard/templates/index.html: │ Line 27:

CPU / GPU %

│ │ │ /home/mac/Code/dashboard/templates/overview.html: │ Line 5:
CPU / GPU
│ │ Line 8: {{ barrow("GPU", c.gpu, "gpu") }} │ │ Line 9: {% if c.cpu_temp is not none or c.gpu_temp is not none %} │ │ Line 12: {% if c.cpu_temp is not none and c.gpu_temp is not none %} ·{% │ endif %} │ │ Line 13: {% if c.gpu_temp is not none %}GPU {{ c.gpu_temp | round(0) | int │ }}°C{% endif %} │ │ │ /home/mac/Code/dashboard/templates/processes.html: │ Line 18: {% for col, label in [("pid", "PID"), ("name", "Name"), ("user", │ "User"), ("cpu", "CPU%"), ("mem_pct", "MEM%"), ("rss", "RSS"), ("gpu", "GPU"), ("io_read", │ "IO read"), ("io_write", "IO write")] %} │ │ Line 19: │ │ Line 34: {% if p.gpu is not none %}{{ p.gpu }} MB{% else %}—{% endif %} │ │ tokens 1975 in 486 out 27834 cached 0 written $0.0000 tool-calls │ 2026-08-30 21:49:08 • assistant • Qwen3.8-27B-Think @plan │ │ The current overview.html doesn't display gpu_name — the "shortening on the overview card" │ refers to the `_shorten()` function in `app/collect/gpu.py`, which is used for `Sample.gpu_name` │ (the value that the overview card would display / was intended to display). In fact, looking at │ the session logs, at some point the overview did display `{{ c.gpu_name }}`. In the current │ code, the template no longer renders it, but the shortening logic in │ `app/collect/gpu.py:_shorten` is "the shortening on the overview card." │ │ So the plan: the LACT plugin should parse the lines of `lact cli list`, and for each GPU shorten │ the name in parentheses using the same `_shorten` logic as `app/collect/gpu.py`. │ │ Now, the LACT name format is: `(Renoir [Radeon Vega Series / Radeon Vega Mobile Series])` — one │ bracket group. The current `_shorten` returns `name[:50]` when there is only one group. Applying │ `_shorten` to `Renoir [Radeon Vega Series / Radeon Vega Mobile Series]` would give back the │ whole string (49 characters). Hmm. │ │ Options: │ 1. Extend `_shorten` in `app/collect/gpu.py` to also handle the single-group case: `model │ [series / ...]` → `model (series)`. Then import it into the LACT plugin. This changes the shared │ function but preserves the "same as the overview card" behavior — both use the same shortening. │ 2. Reuse `_gpu_name` — no, that's lspci-based and single-GPU. │ │ I think extending `_shorten` to handle the one-group case is clean and matches the user's │ request. Let's verify: applying the extended `_shorten` to the lspci name `Advanced Micro │ Devices, Inc. [AMD/ATI] Renoir [Radeon Vega Series / Radeon Vega Mobile Series]` → 2 groups → │ `AMD/ATI Renoir (Radeon Vega Series)`. No change. │ │ Applying it to the LACT name `Renoir [Radeon Vega Series / Radeon Vega Mobile Series]` → 1 group │ → model = `Renoir`, series = `Radeon Vega Series` → `Renoir (Radeon Vega Series)`. │ │ This is consistent. I'll propose this in the plan. │ │ Next, the plugin design: │ │ **Files:** │ 1. `app/plugins/lact.py` — new p │ … [14609 more chars] │ │ read /home/mac/Code/dashboard/templates/index.html ok 0.0s │ in │ { │ "filePath": "/home/mac/Code/dashboard/templates/index.html" │ } │ out │ /home/mac/Code/dashboard/templates/index.html │ file │ │ 1: │ 2: │ 3: │ 4: │ 5: │ 6: {{ hostname }} │ 7: │ 8: │ 9: │ 10: │ 11: │ 12:
│ 13:

{{ hostname }}

│ 14: │ 22:
│ 23:
│ 24:
│ 25:
│ 26:
│ 27:

CPU / GPU %

│ 28:

Memory / VRAM %

│ 29:

Disk I/O

│ 30:
│ 31:
│ 32: │ 33: │ 36: │ 37: