Merge pull request 'feat: gaming environment checks engine (M6) + notification icon — 0.9.0' (#3) from feat/m6-steam-detection into main

Reviewed-on: #3

CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to RigDoctor are recorded here. Format follows
 (`MAJOR.MINOR.PATCH`, pre-1.0). `__version__` and `pyproject.toml` must match the git
 release tag (so the auto-updater, D18, can compare versions).
 
+## [0.9.0] - 2026-05-22
+### Added
+- **Gaming environment checks (M6) — the evaluate-and-suggest engine.** A new read-only report
+  (D9) that flags system settings which hurt gaming stability/performance and gives the exact fix
+  command. Checks: **PCIe ASPM**, **NVIDIA persistence mode**, **CPU governor** (the three that
+  map to the seed-case GPU bus-drop / Xid 79), GameMode, MangoHud, `vm.swappiness`, shader disk
+  cache, Transparent HugePages, CPU mitigations, and installed Proton versions.
+  - **CLI:** `rigdoctor gameenv` (text or `--json`).
+  - **GUI:** a new **Environment** page (findings cards, auto-runs on open), reusing the M4
+    health-report card style via a shared `finding_card` widget.
+### Fixed
+- **Notification icon** now uses the RigDoctor icon (matching the app/dock) instead of a generic
+  stock icon — resolved from the installed icon theme, the bundled asset, then a stock fallback.
+
+## [0.8.0] - 2026-05-22
+### Added
+- **Gaming environment checks (M6) — Steam game detection.** RigDoctor now finds your Steam
+  libraries (across multiple drives, via `libraryfolders.vdf`) and the games installed in each
+  (parsing `appmanifest_*.acf` — stdlib only, no Steam tooling needed). Runtimes, Proton builds,
+  and redistributables are filtered out.
+  - **Opt-in libraries:** detected libraries are listed with a per-library game count; you check
+    the ones to scan. Nothing is scanned until you pick a library.
+  - **Background scan on every launch:** the GUI rescans the selected libraries in the background
+    when it opens and flags games installed since the last scan with a **NEW** badge plus a count
+    on the **Games** sidebar item (cleared when you view the page). Results are cached
+    (`~/.local/state/rigdoctor/games.json`) so the list shows instantly.
+  - **CLI:** `rigdoctor games` lists detected games; `rigdoctor games libraries
+    [--enable PATH | --disable PATH | --all]` lists/selects libraries (headless-complete, D17).
+- Config now supports list values (TOML arrays); `steam_libraries` records the selected libraries.
+
+## [0.7.3] - 2026-05-21
+### Fixed
+- Shared terminal now has **scrollback** — large output (e.g. `ls -la`) can be scrolled up to
+  read; it keeps a history buffer and only auto-scrolls to the bottom when you're already there.
+
 ## [0.7.2] - 2026-05-21
 ### Changed
 - Removed the GUI **Inventory** tab — use the CLI `rigdoctor inventory` instead. (Inventory is

docs/MODULES.md

@@ -14,7 +14,7 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
 | M2 | Live monitor (TUI) | Monitoring | none (stdlib curses) | all | P1 | ⬜ |
 | M8 | Alerting | Monitoring | libnotify (opt) | all | P2 | 🟨 |
 | M5 | System inventory | Diagnostics | none (opt: lm-sensors, dmidecode) | all | P1 | 🟨 |
-| M6 | Gaming env checks | Diagnostics | none | all | P2 | ⬜ |
+| M6 | Gaming env checks | Diagnostics | none | all | P2 | 🟨 |
 | M10 | Desktop GUI | Desktop UI | **python3-pyside6** | all | P2 | 🟨 |
 | M11 | Tray / menu-bar applet | Desktop UI | **python3-pyside6** (+ AppIndicator on GNOME) | all | P2 | ⬜ |
 | M9 | Installer | (meta) | none | all | P1 | 🟨 |
@@ -41,7 +41,19 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
   (text/JSON) + GUI Health tab. GPU-firmware verification deferred.
 - **M2 Live monitor** — depends on M1; the terminal "HWMonitor for Linux" face. Stdlib-only.
 - **M5 / M6 Diagnostics** — inventory export + gaming-env checks; M6 flags risky settings and
-  suggests the fix command but does not apply it (D9).
+  suggests the fix command but does not apply it (D9). *M6 implemented (Steam detection first —
+  the D12 "pick a game" foundation):* discovers Steam installs + all library folders
+  (`libraryfolders.vdf`, multi-drive) and the games in each (`appmanifest_*.acf`), filtering
+  runtimes/Proton/redistributables — stdlib only. **Libraries are opt-in** (`steam_libraries`
+  config); the GUI **Games** page lists them with per-library counts and rescans in the
+  background on every launch, badging games installed since the last scan (cached in
+  `state/games.json`). CLI: `rigdoctor games` / `games libraries [--enable|--disable|--all]`.
+  *Env-check engine implemented* (`core/gameenv.py`): a read-only findings report (reusing the
+  M4 `Finding` model) over PCIe ASPM, NVIDIA persistence mode, CPU governor (the three seed-case
+  contributors to GPU bus-drop / Xid 79), GameMode, MangoHud, swappiness, shader cache, THP, CPU
+  mitigations, and installed Proton versions — each with the suggested fix command (D9). CLI
+  `rigdoctor gameenv`; GUI **Environment** page. *Pending:* non-Steam launchers (Lutris/Heroic)
+  and per-GPU power-profile (PowerMizer) checks.
 - **M8 Alerting** — threshold/event notifications; integrates with the tray applet (M11).
 - **M10 Desktop GUI** — PySide6 graphical front-end over the core engine (dashboard, log
   browser, report viewer, logger controls). Optional; adds the Qt dependency. *Bootstrapped

docs/ROADMAP.md

@@ -27,7 +27,13 @@ Ubuntu + NVIDIA first; `.deb` distribution (see `DECISIONS.md`).
 
 ## Phase 3 — Diagnostics breadth
 - [ ] M5 system inventory + exportable report
-- [ ] M6 gaming environment checks (suggest-only)
+- [~] M6 gaming environment checks (suggest-only) — *Steam game/library detection done*
+      (multi-library `libraryfolders.vdf` discovery + `appmanifest` scan, opt-in libraries,
+      launch-time background rescan with new-game badge; CLI `rigdoctor games`, GUI Games page).
+      This is also the D12 "pick a game" foundation. *Env-check engine done* (`rigdoctor gameenv`
+      + GUI Environment page): PCIe ASPM, NVIDIA persistence, CPU governor, GameMode, MangoHud,
+      swappiness, shader cache, THP, mitigations, Proton versions — read-only with fix commands.
+      *Pending:* non-Steam launchers (Lutris/Heroic) + GPU power-profile (PowerMizer) checks.
 - [ ] SMART integration (smartmontools if present)
 
 ## Phase 4 — Desktop UI & installer

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rigdoctor"
-version = "0.7.2"
+version = "0.9.0"
 description = "Modular hardware monitoring & crash diagnostics for Linux gamers."
 readme = "README.md"
 requires-python = ">=3.11"

src/rigdoctor/__init__.py

@@ -1,3 +1,3 @@
 """RigDoctor — modular hardware monitoring & crash diagnostics for Linux gamers."""
 
-__version__ = "0.7.2"
+__version__ = "0.9.0"

src/rigdoctor/cli.py

@@ -345,6 +345,87 @@ def cmd_report(args) -> int:
     return 0
 
 
+def cmd_gameenv(args) -> int:
+    from dataclasses import asdict
+
+    from .core.gameenv import run_gameenv_checks
+    from .render import render_health
+
+    findings = run_gameenv_checks()
+    if args.json:
+        print(json.dumps([asdict(f) for f in findings], indent=2, ensure_ascii=False))
+    else:
+        print(render_health(findings, title="Gaming environment"))
+    return 0
+
+
+def cmd_games(args) -> int:
+    from .core import steam
+
+    selected = steam.selected_library_paths()
+    if not selected:
+        print("No Steam libraries selected to scan.")
+        print("  See them with:   rigdoctor games libraries")
+        print("  Then enable one: rigdoctor games libraries --enable <path>  (or --all)")
+        return 1
+    result = steam.rescan()
+    if args.json:
+        from dataclasses import asdict
+
+        print(json.dumps({
+            "scanned_at": result.scanned_at,
+            "new_appids": result.new_appids,
+            "games": [asdict(g) for g in result.games],
+        }, indent=2, ensure_ascii=False))
+        return 0
+    if not result.games:
+        print("No games found in the selected Steam libraries.")
+        return 0
+    new = set(result.new_appids)
+    print(f"{len(result.games)} game(s) across {len(selected)} librar(y/ies):\n")
+    for g in result.games:
+        flag = " NEW" if g.appid in new else ""
+        print(f"  {g.name:<48} {steam.human_size(g.size_bytes):>9}{flag}")
+    if new:
+        print(f"\n{len(new)} newly-installed since the last scan.")
+    return 0
+
+
+def cmd_games_libraries(args) -> int:
+    from .core import steam
+
+    discovered = steam.discover_libraries()
+    selected = {os.path.realpath(p) for p in steam.selected_library_paths()}
+
+    # --all / --enable / --disable adjust the selection, then we list the result.
+    if args.all or args.enable or args.disable:
+        if args.all:
+            selected = {lib.path for lib in discovered}
+        for raw in args.enable or []:
+            selected.add(os.path.realpath(os.path.expanduser(raw)))
+        for raw in args.disable or []:
+            selected.discard(os.path.realpath(os.path.expanduser(raw)))
+        config.update_config(steam_libraries=sorted(selected))
+
+    if not discovered:
+        print("No Steam libraries detected (is Steam installed?).")
+        return 1
+    if args.json:
+        print(json.dumps([
+            {"path": lib.path, "label": lib.label, "selected": lib.path in selected,
+             "games": len(steam.scan_library(lib.path))}
+            for lib in discovered
+        ], indent=2, ensure_ascii=False))
+        return 0
+    print("Steam libraries (checked = scanned for games):\n")
+    for lib in discovered:
+        mark = "x" if lib.path in selected else " "
+        count = len(steam.scan_library(lib.path))
+        label = f"  [{lib.label}]" if lib.label else ""
+        print(f"  [{mark}] {lib.path}{label}  ({count} games)")
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(
         prog="rigdoctor",
@@ -423,6 +504,21 @@ def build_parser() -> argparse.ArgumentParser:
     inv.add_argument("--markdown", action="store_true", help="output Markdown (for forum/bug reports)")
     inv.add_argument("-o", "--output", default=None, help="write to a file instead of stdout")
     inv.set_defaults(func=cmd_inventory)
+
+    games_p = sub.add_parser("games", help="Steam game & library detection (M6)")
+    games_p.add_argument("--json", action="store_true", help="output JSON")
+    games_p.set_defaults(func=cmd_games)
+    games_sub = games_p.add_subparsers(dest="games_cmd")
+    lib_p = games_sub.add_parser("libraries", help="list/select Steam libraries to scan")
+    lib_p.add_argument("--enable", action="append", metavar="PATH", help="scan this library (repeatable)")
+    lib_p.add_argument("--disable", action="append", metavar="PATH", help="stop scanning this library (repeatable)")
+    lib_p.add_argument("--all", action="store_true", help="scan all detected libraries")
+    lib_p.add_argument("--json", action="store_true", help="output JSON")
+    lib_p.set_defaults(func=cmd_games_libraries)
+
+    env_p = sub.add_parser("gameenv", help="gaming environment checks (M6): flag stability/perf settings")
+    env_p.add_argument("--json", action="store_true", help="output JSON instead of text")
+    env_p.set_defaults(func=cmd_gameenv)
     return p
 
 

src/rigdoctor/config.py

@@ -27,6 +27,10 @@ STATUS_FILE = STATE_DIR / "recorder.json"
 PID_FILE = STATE_DIR / "recorder.pid"
 SPAWN_LOG = STATE_DIR / "recorder.out"
 
+# Gaming environment / game detection (M6) — cached Steam game scan (mutable state,
+# not config: refreshed by the background scan on every launch).
+GAMES_FILE = STATE_DIR / "games.json"
+
 # Update access token (M13) — gates updates to Gitea account holders (D18).
 # Stored in the OS keyring (Secret Service / GNOME Keyring) via `secret-tool` when
 # available — encrypted at rest, unlocked with the login session — else a 0600 file.
@@ -143,6 +147,7 @@ DEFAULTS: dict = {
     "gpu_temp_alert": 90.0,       # °C — alert when GPU reaches this
     "cpu_temp_alert": 95.0,       # °C — alert when CPU reaches this
     "relay_url": "wss://rigdoctor.jesseyvanofferen.com",  # session-sharing relay (M12)
+    "steam_libraries": [],        # Steam library paths to scan for games (M6); empty = none picked yet
 }
 
 
@@ -165,6 +170,8 @@ def _toml_value(value) -> str:
         return "true" if value else "false"
     if isinstance(value, (int, float)):
         return repr(value)
+    if isinstance(value, (list, tuple)):
+        return "[" + ", ".join(_toml_value(v) for v in value) + "]"
     return '"' + str(value).replace("\\", "\\\\").replace('"', '\\"') + '"'
 
 

src/rigdoctor/core/alerts.py

@@ -10,24 +10,42 @@ from __future__ import annotations
 import shutil
 import subprocess
 import time
+from pathlib import Path
 
+from ..config import DATA_DIR
 from .sample import Sample
 
 APP_NAME = "RigDoctor"
-_ICON = "utilities-system-monitor"
+_STOCK_ICON = "utilities-system-monitor"
+# The RigDoctor icon, so notifications match the app/dock icon. Prefer the copy that
+# desktop integration installs into the icon theme (~/.local/share/icons/...); fall back to
+# the bundled asset for source/dev runs, then to a stock icon if neither is present.
+_INSTALLED_ICON = DATA_DIR.parent / "icons" / "hicolor" / "scalable" / "apps" / "rigdoctor.svg"
+_BUNDLED_ICON = Path(__file__).parents[1] / "gui" / "assets" / "rigdoctor.svg"
 
 
 def available() -> bool:
     return shutil.which("notify-send") is not None
 
 
+def _icon() -> str:
+    """Resolve the notification icon at call time (the themed copy may be installed late)."""
+    for path in (_INSTALLED_ICON, _BUNDLED_ICON):
+        try:
+            if path.exists():
+                return str(path)
+        except OSError:
+            pass
+    return _STOCK_ICON
+
+
 def notify(title: str, message: str, urgency: str = "normal") -> bool:
     """Send a desktop notification (best-effort). urgency: low|normal|critical."""
     if not available():
         return False
     try:
         subprocess.run(
-            ["notify-send", "-a", APP_NAME, "-u", urgency, "-i", _ICON, title, message],
+            ["notify-send", "-a", APP_NAME, "-u", urgency, "-i", _icon(), title, message],
             timeout=10,
             check=False,
         )

src/rigdoctor/core/gameenv.py

@@ -0,0 +1,259 @@
+"""Gaming environment checks (M6): evaluate system settings that affect gaming
+stability/performance and suggest the fix command — read-only (D9).
+
+Stdlib-only. Each check degrades gracefully (a missing file/tool yields no finding or an
+info finding, never an exception). The pure ``evaluate_*`` helpers are split from the IO
+that reads sysfs / runs tools, so they're unit-testable.
+
+Several checks target the seed case directly: an RTX 3070 falling off the PCIe bus under
+load (Xid 79). PCIe ASPM power-saving, NVIDIA persistence mode, and a power-saving CPU
+governor are the usual contributors to that class of drop-off / stutter.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from .health import INFO, OK, WARNING, Finding
+
+_ORDER = {"critical": 0, WARNING: 1, INFO: 2, OK: 3}
+
+
+def _read(path: str) -> str | None:
+    try:
+        return Path(path).read_text()
+    except OSError:
+        return None
+
+
+# --- PCIe ASPM (seed-case relevant) ---------------------------------------------------
+
+def _active_aspm(policy_text: str) -> str | None:
+    """The active ASPM policy is the bracketed token, e.g. '[default] performance ...'."""
+    m = re.search(r"\[(\w+)\]", policy_text)
+    return m.group(1) if m else None
+
+
+def evaluate_aspm(policy_text: str | None) -> Finding | None:
+    if not policy_text:
+        return None
+    active = _active_aspm(policy_text)
+    if active is None:
+        return None
+    if active in ("powersave", "powersupersave"):
+        return Finding(
+            WARNING, "PCIe", f"PCIe ASPM is in power-saving mode ({active})",
+            "Aggressive PCIe Active-State Power Management can cause the GPU to drop off the "
+            "bus under load (Xid 79) or stutter — the seed-case failure mode.",
+            "Disable ASPM via the kernel cmdline: add `pcie_aspm=off` (and optionally "
+            "`pcie_aspm.policy=performance`) in GRUB, then `sudo update-grub` and reboot.",
+        )
+    if active == "performance":
+        return Finding(OK, "PCIe", "PCIe ASPM set to performance", "ASPM power-saving is disabled.")
+    return Finding(
+        INFO, "PCIe", f"PCIe ASPM policy: {active}",
+        "ASPM is left to the kernel/BIOS default.",
+        "If you see GPU bus-drop events (Xid 79), try `pcie_aspm=off` on the kernel cmdline.",
+    )
+
+
+def check_pcie_aspm() -> list[Finding]:
+    f = evaluate_aspm(_read("/sys/module/pcie_aspm/parameters/policy"))
+    return [f] if f else []
+
+
+# --- NVIDIA persistence mode (seed-case relevant) -------------------------------------
+
+def check_gpu_persistence() -> list[Finding]:
+    if shutil.which("nvidia-smi") is None:
+        return []
+    try:
+        proc = subprocess.run(
+            ["nvidia-smi", "--query-gpu=persistence_mode", "--format=csv,noheader"],
+            capture_output=True, text=True, timeout=10,
+        )
+    except (subprocess.SubprocessError, OSError):
+        return []
+    state = proc.stdout.strip().splitlines()[0].strip() if proc.stdout.strip() else ""
+    if state.lower().startswith("disabled"):
+        return [Finding(
+            INFO, "GPU", "NVIDIA persistence mode is off",
+            "The driver unloads when no client is attached, adding latency on first GPU "
+            "access and churning state between game launches.",
+            "Enable it: `sudo nvidia-smi -pm 1` (per-boot), or enable the "
+            "`nvidia-persistenced` service to make it permanent.",
+        )]
+    if state.lower().startswith("enabled"):
+        return [Finding(OK, "GPU", "NVIDIA persistence mode on", "The driver stays resident.")]
+    return []
+
+
+# --- CPU governor ---------------------------------------------------------------------
+
+def evaluate_governor(governors: set[str]) -> Finding | None:
+    if not governors:
+        return None
+    shown = ", ".join(sorted(governors))
+    if governors == {"performance"}:
+        return Finding(OK, "CPU", "CPU governor: performance", "CPUs run at full clocks under load.")
+    if "powersave" in governors:
+        return Finding(
+            WARNING, "CPU", f"CPU governor set to power-saving ({shown})",
+            "A powersave governor caps CPU frequency and can bottleneck frame times.",
+            "Set performance: `sudo cpupower frequency-set -g performance` "
+            "(install `linux-tools-common`/`cpupower`), or install GameMode to switch it per-game.",
+        )
+    return Finding(
+        INFO, "CPU", f"CPU governor: {shown}",
+        "A dynamic governor scales with load; usually fine.",
+        "For the most consistent frame pacing, `performance` (or GameMode) avoids ramp-up lag.",
+    )
+
+
+def check_cpu_governor() -> list[Finding]:
+    govs: set[str] = set()
+    for p in Path("/sys/devices/system/cpu").glob("cpu*/cpufreq/scaling_governor"):
+        text = _read(str(p))
+        if text and text.strip():
+            govs.add(text.strip())
+    f = evaluate_governor(govs)
+    return [f] if f else []
+
+
+# --- GameMode / MangoHud --------------------------------------------------------------
+
+def check_gamemode() -> list[Finding]:
+    if shutil.which("gamemoderun") or shutil.which("gamemoded"):
+        return [Finding(
+            OK, "Tools", "Feral GameMode installed",
+            "GameMode can apply the performance governor and other tweaks while a game runs.",
+        )]
+    return [Finding(
+        INFO, "Tools", "GameMode not installed",
+        "GameMode auto-applies performance tweaks (governor, scheduling) for the duration of a game.",
+        "Install it: `sudo apt install gamemode`, then launch games with `gamemoderun %command%` "
+        "(or use a global Steam launch option).",
+    )]
+
+
+def check_mangohud() -> list[Finding]:
+    if shutil.which("mangohud"):
+        return [Finding(OK, "Tools", "MangoHud available", "In-game FPS/temps/frametime overlay is installed.")]
+    return [Finding(
+        INFO, "Tools", "MangoHud not installed",
+        "MangoHud overlays live FPS, frame times, and temps in-game — handy for spotting stutter.",
+        "Install it: `sudo apt install mangohud`, then launch with `mangohud %command%`.",
+    )]
+
+
+# --- vm.swappiness --------------------------------------------------------------------
+
+def evaluate_swappiness(value: int) -> Finding:
+    if value > 10:
+        return Finding(
+            INFO, "Memory", f"vm.swappiness is high ({value})",
+            "A high swappiness lets the kernel swap out memory eagerly, which can cause "
+            "hitching during gaming on systems with ample RAM.",
+            "Lower it: `sudo sysctl vm.swappiness=10` (persist in /etc/sysctl.d/99-rigdoctor.conf).",
+        )
+    return Finding(OK, "Memory", f"vm.swappiness is {value}", "Swapping is conservative.")
+
+
+def check_swappiness() -> list[Finding]:
+    text = _read("/proc/sys/vm/swappiness")
+    if text is None or not text.strip().isdigit():
+        return []
+    return [evaluate_swappiness(int(text.strip()))]
+
+
+# --- shader cache ---------------------------------------------------------------------
+
+def evaluate_shader_cache(env: dict) -> Finding:
+    disabled = (
+        env.get("__GL_SHADER_DISK_CACHE") == "0"
+        or env.get("MESA_SHADER_CACHE_DISABLE", "").lower() in ("1", "true")
+        or env.get("MESA_GLSL_CACHE_DISABLE", "").lower() in ("1", "true")
+    )
+    if disabled:
+        return Finding(
+            WARNING, "GPU", "Shader disk cache is disabled",
+            "With the shader cache off, shaders recompile every run — a common cause of "
+            "in-game stutter, especially on first encounters.",
+            "Unset the disabling variable (e.g. remove `__GL_SHADER_DISK_CACHE=0` / "
+            "`MESA_SHADER_CACHE_DISABLE`) from your environment / launch options.",
+        )
+    return Finding(OK, "GPU", "Shader disk cache enabled", "Compiled shaders are cached between runs (default).")
+
+
+def check_shader_cache() -> list[Finding]:
+    return [evaluate_shader_cache(os.environ)]
+
+
+# --- transparent hugepages / CPU mitigations (only when notable) ----------------------
+
+def check_thp() -> list[Finding]:
+    text = _read("/sys/kernel/mm/transparent_hugepage/enabled")
+    if not text:
+        return []
+    active = _active_aspm(text)  # same '[token]' format
+    if active == "never":
+        return [Finding(
+            INFO, "Memory", "Transparent HugePages disabled (never)",
+            "Some workloads benefit from THP; 'madvise' lets apps opt in without the downsides of 'always'.",
+            "Optional: `echo madvise | sudo tee /sys/kernel/mm/transparent_hugepage/enabled`.",
+        )]
+    return []
+
+
+def check_mitigations() -> list[Finding]:
+    cmdline = _read("/proc/cmdline") or ""
+    if "mitigations=off" in cmdline:
+        return [Finding(
+            INFO, "CPU", "CPU security mitigations are disabled",
+            "`mitigations=off` recovers some CPU performance at the cost of CPU-vulnerability "
+            "protections — a deliberate trade-off, noted here for awareness.",
+            "Remove `mitigations=off` from the kernel cmdline to restore protections.",
+        )]
+    return []
+
+
+# --- Proton versions (informational) --------------------------------------------------
+
+def check_proton() -> list[Finding]:
+    from . import steam
+
+    try:
+        versions = steam.proton_versions()
+    except Exception:
+        versions = []
+    if not versions:
+        return []
+    return [Finding(
+        INFO, "Tools", f"Proton: {len(versions)} version(s) installed",
+        ", ".join(versions),
+        "Steam picks the Proton version per game (Properties → Compatibility); "
+        "Proton Experimental often has the latest fixes.",
+    )]
+
+
+# --- aggregate ------------------------------------------------------------------------
+
+def run_gameenv_checks() -> list[Finding]:
+    """Run all environment checks, sorted by severity (worst first)."""
+    findings: list[Finding] = []
+    findings += check_pcie_aspm()
+    findings += check_gpu_persistence()
+    findings += check_cpu_governor()
+    findings += check_gamemode()
+    findings += check_mangohud()
+    findings += check_swappiness()
+    findings += check_shader_cache()
+    findings += check_thp()
+    findings += check_mitigations()
+    findings += check_proton()
+    findings.sort(key=lambda f: _ORDER.get(f.severity, 9))
+    return findings

src/rigdoctor/core/steam.py

@@ -0,0 +1,362 @@
+"""Steam library & game detection (M6, the Steam piece of D12 game detection).
+
+Discovers a user's Steam installs, the library folders they've configured (Steam tracks
+them all in ``libraryfolders.vdf``, so multiple libraries on multiple drives are covered),
+and the games installed in each (one ``appmanifest_<appid>.acf`` per app). Stdlib only —
+no Steam tooling required, every probe degrades gracefully.
+
+The set of libraries actually scanned is user-chosen (config ``steam_libraries``); nothing
+is scanned until the user opts a library in. Scan results are cached in ``games.json`` so the
+GUI can show the list instantly and the launch-time background scan can diff against it to
+flag newly-installed games.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from ..config import GAMES_FILE, load_config
+
+# Steam "apps" that aren't games: runtimes, Proton builds, redistributables. Filtered out of
+# scans by appid (known IDs) or by name prefix (covers future Proton/runtime versions).
+_TOOL_APPIDS = {
+    "228980",   # Steamworks Common Redistributables
+    "1070560",  # Steam Linux Runtime 1.0 (scout)
+    "1391110",  # Steam Linux Runtime 2.0 (soldier)
+    "1628350",  # Steam Linux Runtime 3.0 (sniper)
+    "1493710",  # Proton Experimental
+    "2180100",  # Proton Hotfix
+    "1826330",  # Proton EasyAntiCheat Runtime
+    "1161040",  # Proton BattlEye Runtime
+}
+_TOOL_NAME_PREFIXES = ("Proton", "Steam Linux Runtime", "Steamworks Common")
+
+# Where Steam may be installed (native + Flatpak + Snap). Symlinks (~/.steam/steam) are
+# resolved and de-duplicated by real path.
+_ROOT_CANDIDATES = (
+    "~/.steam/steam",
+    "~/.steam/root",
+    "~/.local/share/Steam",
+    "~/.var/app/com.valvesoftware.Steam/data/Steam",  # Flatpak
+    "~/snap/steam/common/.local/share/Steam",          # Snap
+)
+
+
+@dataclass
+class SteamLibrary:
+    path: str          # the library root (contains a steamapps/ dir)
+    label: str = ""    # Steam's label for the folder, if any
+
+
+@dataclass
+class Game:
+    appid: str
+    name: str
+    library: str       # library path the game lives in
+    installdir: str    # folder name under <library>/steamapps/common
+    size_bytes: int = 0
+    last_updated: int = 0  # epoch seconds (acf LastUpdated), 0 if unknown
+
+
+# --- VDF (Valve Data Format) parsing --------------------------------------------------
+# Minimal text-VDF reader: quoted "key" "value" pairs and "key" { ... } nesting. Enough
+# for libraryfolders.vdf and appmanifest_*.acf; ignores #base/#include and unquoted tokens.
+
+def _parse_vdf(text: str) -> dict:
+    pos = 0
+    n = len(text)
+
+    def skip_ws() -> None:
+        nonlocal pos
+        while pos < n:
+            c = text[pos]
+            if c in " \t\r\n":
+                pos += 1
+            elif c == "/" and pos + 1 < n and text[pos + 1] == "/":  # // line comment
+                while pos < n and text[pos] != "\n":
+                    pos += 1
+            else:
+                break
+
+    def read_string() -> str:
+        nonlocal pos
+        pos += 1  # opening quote
+        out = []
+        while pos < n:
+            c = text[pos]
+            if c == "\\" and pos + 1 < n:
+                nxt = text[pos + 1]
+                out.append({"n": "\n", "t": "\t", "\\": "\\", '"': '"'}.get(nxt, nxt))
+                pos += 2
+                continue
+            if c == '"':
+                pos += 1
+                break
+            out.append(c)
+            pos += 1
+        return "".join(out)
+
+    def parse_obj() -> dict:
+        nonlocal pos
+        obj: dict = {}
+        while True:
+            skip_ws()
+            if pos >= n or text[pos] == "}":
+                pos += 1  # consume closing brace (or run off the end)
+                return obj
+            if text[pos] != '"':  # skip unquoted/unsupported tokens defensively
+                pos += 1
+                continue
+            key = read_string()
+            skip_ws()
+            if pos < n and text[pos] == "{":
+                pos += 1
+                obj[key] = parse_obj()
+            elif pos < n and text[pos] == '"':
+                obj[key] = read_string()
+            else:  # malformed; bail on this key
+                obj[key] = ""
+        return obj
+
+    skip_ws()
+    if pos < n and text[pos] == '"':
+        root_key = read_string()
+        skip_ws()
+        if pos < n and text[pos] == "{":
+            pos += 1
+            return {root_key: parse_obj()}
+    return {}
+
+
+def _read_vdf(path: Path) -> dict:
+    try:
+        return _parse_vdf(path.read_text(encoding="utf-8", errors="replace"))
+    except OSError:
+        return {}
+
+
+# --- discovery ------------------------------------------------------------------------
+
+def steam_roots() -> list[Path]:
+    """Existing Steam install roots, de-duplicated by resolved path."""
+    seen: set[Path] = set()
+    roots: list[Path] = []
+    for cand in _ROOT_CANDIDATES:
+        p = Path(os.path.expanduser(cand))
+        if not p.exists():
+            continue
+        real = p.resolve()
+        if real in seen:
+            continue
+        seen.add(real)
+        roots.append(real)
+    return roots
+
+
+def _libraryfolders_vdf(root: Path) -> Path | None:
+    for rel in ("steamapps/libraryfolders.vdf", "config/libraryfolders.vdf"):
+        p = root / rel
+        if p.exists():
+            return p
+    return None
+
+
+def discover_libraries() -> list[SteamLibrary]:
+    """Every Steam library folder configured on this machine, de-duplicated by real path.
+
+    Reads each install's ``libraryfolders.vdf`` (which lists all drives/folders), and
+    always includes the install root itself as a fallback.
+    """
+    seen: set[Path] = set()
+    libs: list[SteamLibrary] = []
+
+    def add(path: Path, label: str = "") -> None:
+        if not (path / "steamapps").is_dir():
+            return
+        real = path.resolve()
+        if real in seen:
+            return
+        seen.add(real)
+        libs.append(SteamLibrary(path=str(real), label=label))
+
+    for root in steam_roots():
+        vdf = _libraryfolders_vdf(root)
+        folders = _read_vdf(vdf).get("libraryfolders", {}) if vdf else {}
+        if isinstance(folders, dict):
+            for entry in folders.values():
+                if isinstance(entry, dict) and entry.get("path"):
+                    add(Path(entry["path"]), entry.get("label", ""))
+        add(root)  # the install root is itself a library
+    return libs
+
+
+# --- game scanning --------------------------------------------------------------------
+
+def is_tool(appid: str, name: str) -> bool:
+    """True for non-game Steam apps (runtimes, Proton, redistributables)."""
+    if appid in _TOOL_APPIDS:
+        return True
+    return name.startswith(_TOOL_NAME_PREFIXES)
+
+
+def scan_library(library: str) -> list[Game]:
+    """Games installed in one library, parsed from its appmanifest_*.acf files."""
+    steamapps = Path(library) / "steamapps"
+    games: list[Game] = []
+    try:
+        manifests = sorted(steamapps.glob("appmanifest_*.acf"))
+    except OSError:
+        return games
+    for manifest in manifests:
+        state = _read_vdf(manifest).get("AppState", {})
+        if not isinstance(state, dict):
+            continue
+        # Steam treats VDF keys case-insensitively (e.g. "SizeOnDisk" but "lastupdated").
+        state = {k.lower(): v for k, v in state.items()}
+        appid = state.get("appid", "")
+        name = state.get("name", "").strip()
+        if not appid or not name or is_tool(appid, name):
+            continue
+        games.append(Game(
+            appid=appid,
+            name=name,
+            library=str(library),
+            installdir=state.get("installdir", ""),
+            size_bytes=_int(state.get("sizeondisk")),
+            last_updated=_int(state.get("lastupdated")),
+        ))
+    return games
+
+
+def scan_games(libraries: list[str]) -> list[Game]:
+    """All games across the given libraries, de-duplicated by appid, sorted by name."""
+    by_appid: dict[str, Game] = {}
+    for lib in libraries:
+        for game in scan_library(lib):
+            by_appid.setdefault(game.appid, game)  # first library wins on duplicates
+    return sorted(by_appid.values(), key=lambda g: g.name.lower())
+
+
+def _int(value) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def proton_versions() -> list[str]:
+    """Installed Proton compatibility-tool versions across all discovered libraries.
+
+    Proton builds are the appmanifests we filter out of game scans; here we surface them
+    for the M6 environment report. Returns unique names, newest-looking last.
+    """
+    names: set[str] = set()
+    for lib in discover_libraries():
+        try:
+            manifests = sorted((Path(lib.path) / "steamapps").glob("appmanifest_*.acf"))
+        except OSError:
+            continue
+        for manifest in manifests:
+            state = _read_vdf(manifest).get("AppState", {})
+            if isinstance(state, dict):
+                state = {k.lower(): v for k, v in state.items()}
+                name = state.get("name", "").strip()
+                if name.startswith("Proton"):
+                    names.add(name)
+    return sorted(names)
+
+
+# --- config-driven selection ----------------------------------------------------------
+
+def selected_library_paths(cfg: dict | None = None) -> list[str]:
+    """Library paths the user has opted in to scanning (config ``steam_libraries``)."""
+    cfg = cfg or load_config()
+    paths = cfg.get("steam_libraries") or []
+    return [str(p) for p in paths]
+
+
+# --- scan cache + new-game detection --------------------------------------------------
+
+@dataclass
+class ScanResult:
+    games: list[Game]
+    new_appids: list[str]   # newly-installed since the last scan (badge fuel)
+    scanned_at: float
+
+
+def load_cache() -> dict | None:
+    try:
+        return json.loads(GAMES_FILE.read_text())
+    except (OSError, ValueError):
+        return None
+
+
+def _save_cache(games: list[Game], known: set[str], new: list[str], when: float) -> None:
+    GAMES_FILE.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "scanned_at": when,
+        "known_appids": sorted(known),
+        "new_appids": new,
+        "games": [asdict(g) for g in games],
+    }
+    GAMES_FILE.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def cached_games() -> list[Game]:
+    """Games from the last scan (for instant display before a rescan finishes)."""
+    cache = load_cache()
+    if not cache:
+        return []
+    return [Game(**{k: g.get(k) for k in Game.__dataclass_fields__}) for g in cache.get("games", [])]
+
+
+def rescan(cfg: dict | None = None) -> ScanResult:
+    """Scan the selected libraries, diff against the cache, and persist the result.
+
+    Newly-installed games (appids never seen before) are reported in ``new_appids``. The
+    very first scan reports nothing as new (so the whole library isn't flagged at once);
+    unacknowledged new games carry forward until they're acknowledged or uninstalled.
+    """
+    games = scan_games(selected_library_paths(cfg))
+    current = {g.appid for g in games}
+    prev = load_cache()
+    if prev is None:
+        known: set[str] = set(current)  # first run: everything is "known", nothing new
+        new = []
+    else:
+        known = set(prev.get("known_appids", []))
+        carried = set(prev.get("new_appids", [])) & current  # still-unacknowledged & installed
+        new = sorted((current - known) | carried)
+        known |= current
+    when = time.time()
+    _save_cache(games, known, new, when)
+    return ScanResult(games=games, new_appids=new, scanned_at=when)
+
+
+def acknowledge_new() -> None:
+    """Clear the new-game badge (called when the user views the games list)."""
+    cache = load_cache()
+    if not cache or not cache.get("new_appids"):
+        return
+    cache["new_appids"] = []
+    try:
+        GAMES_FILE.write_text(json.dumps(cache, indent=2, ensure_ascii=False))
+    except OSError:
+        pass
+
+
+# --- formatting -----------------------------------------------------------------------
+
+def human_size(num_bytes: int) -> str:
+    if num_bytes <= 0:
+        return "—"
+    size = float(num_bytes)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.0f} {unit}" if unit in ("B", "KB") else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"

src/rigdoctor/gui/environment_page.py

@@ -0,0 +1,104 @@
+"""Environment page (M6 in the GUI): runs the gaming-environment checks as findings cards."""
+
+from __future__ import annotations
+
+import threading
+import time
+
+from PySide6.QtCore import Qt, QTimer, Signal
+from PySide6.QtWidgets import (
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .widgets import finding_card
+
+
+class EnvironmentPage(QWidget):
+    _result = Signal(object)  # list[Finding]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setObjectName("Page")
+        self._result.connect(self._render_findings)
+
+        root = QVBoxLayout(self)
+        root.setContentsMargins(20, 18, 20, 18)
+        root.setSpacing(16)
+
+        header = QHBoxLayout()
+        title = QLabel("Environment")
+        title.setObjectName("PageTitle")
+        header.addWidget(title)
+        header.addStretch(1)
+        self._status = QLabel("")
+        self._status.setObjectName("Muted")
+        header.addWidget(self._status)
+        self._run_btn = QPushButton("Run checks")
+        self._run_btn.setObjectName("PrimaryButton")
+        self._run_btn.clicked.connect(self._run)
+        header.addWidget(self._run_btn)
+        root.addLayout(header)
+
+        intro = QLabel(
+            "System settings that affect gaming stability and performance, with the suggested "
+            "fix command. RigDoctor only reports — it never changes anything."
+        )
+        intro.setObjectName("Muted")
+        intro.setWordWrap(True)
+        root.addWidget(intro)
+
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QFrame.Shape.NoFrame)
+        scroll.setStyleSheet("background: transparent;")
+        self._container = QWidget()
+        self._list = QVBoxLayout(self._container)
+        self._list.setContentsMargins(0, 0, 0, 0)
+        self._list.setSpacing(10)
+        self._list.setAlignment(Qt.AlignmentFlag.AlignTop)
+        scroll.setWidget(self._container)
+        root.addWidget(scroll, 1)
+
+        QTimer.singleShot(350, self._run)  # auto-run shortly after the window opens
+
+    def _run(self) -> None:
+        self._run_btn.setEnabled(False)
+        self._status.setText("Checking environment…")
+        threading.Thread(target=self._work, daemon=True).start()
+
+    def _work(self) -> None:
+        from ..core.gameenv import run_gameenv_checks
+
+        try:
+            findings = run_gameenv_checks()
+        except Exception:
+            findings = None
+        self._result.emit(findings)
+
+    def _render_findings(self, findings) -> None:
+        self._run_btn.setEnabled(True)
+        if findings is None:  # check failed — keep current results
+            self._status.setText("check failed")
+            return
+
+        while self._list.count():
+            item = self._list.takeAt(0)
+            w = item.widget()
+            if w is not None:
+                w.deleteLater()
+
+        crit = sum(1 for f in findings if f.severity == "critical")
+        warn = sum(1 for f in findings if f.severity == "warning")
+        self._status.setText(
+            f"{crit} critical · {warn} warning · {len(findings)} checks  ·  "
+            f"{time.strftime('%H:%M:%S')}"
+        )
+        for finding in findings:
+            self._list.addWidget(finding_card(finding))
+        self._list.addStretch(1)

src/rigdoctor/gui/games_page.py

@@ -0,0 +1,249 @@
+"""Games page (M6 in the GUI): pick Steam libraries and browse detected games.
+
+Libraries are opt-in — the user checks which ones to scan. The list is loaded from the
+cache instantly, then a background rescan refreshes it and flags games installed since the
+last scan (a "NEW" badge here + a count on the sidebar nav).
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+
+from PySide6.QtCore import Qt, QTimer, Signal
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..config import load_config, update_config
+from .theme import ACCENT, GOOD, MUTED
+
+
+def _game_row(name: str, sublabel: str, size: str, is_new: bool) -> QFrame:
+    card = QFrame()
+    card.setObjectName("Card")
+    h = QHBoxLayout(card)
+    h.setContentsMargins(16, 10, 16, 10)
+    h.setSpacing(10)
+
+    left = QVBoxLayout()
+    left.setSpacing(2)
+    title = QLabel(name)
+    title.setStyleSheet("font-weight: 600; background: transparent;")
+    title.setWordWrap(True)
+    left.addWidget(title)
+    if sublabel:
+        sub = QLabel(sublabel)
+        sub.setObjectName("Muted")
+        left.addWidget(sub)
+    h.addLayout(left, 1)
+
+    if is_new:
+        badge = QLabel("NEW")
+        badge.setStyleSheet(
+            f"color: {GOOD}; border: 1px solid {GOOD}; border-radius: 6px; "
+            f"padding: 1px 6px; font-weight: 700; background: transparent;"
+        )
+        h.addWidget(badge, 0, Qt.AlignmentFlag.AlignVCenter)
+
+    size_label = QLabel(size)
+    size_label.setObjectName("Muted")
+    size_label.setMinimumWidth(80)
+    size_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+    h.addWidget(size_label, 0)
+    return card
+
+
+class GamesPage(QWidget):
+    _libraries_ready = Signal(object)  # list[dict(path, label, count, selected)]
+    _scanned = Signal(object)          # steam.ScanResult
+    new_count_changed = Signal(int)    # newly-installed game count (for the nav badge)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setObjectName("Page")
+        self._libraries_ready.connect(self._render_libraries)
+        self._scanned.connect(self._render_games)
+        self._busy = False
+        self._new_appids: set[str] = set()
+
+        root = QVBoxLayout(self)
+        root.setContentsMargins(20, 18, 20, 18)
+        root.setSpacing(16)
+
+        header = QHBoxLayout()
+        title = QLabel("Games")
+        title.setObjectName("PageTitle")
+        header.addWidget(title)
+        header.addStretch(1)
+        self._status = QLabel("")
+        self._status.setObjectName("Muted")
+        header.addWidget(self._status)
+        self._rescan_btn = QPushButton("Rescan")
+        self._rescan_btn.setObjectName("PrimaryButton")
+        self._rescan_btn.clicked.connect(self.refresh)
+        header.addWidget(self._rescan_btn)
+        root.addLayout(header)
+
+        # Libraries (opt-in checkboxes)
+        lib_card = QFrame()
+        lib_card.setObjectName("Card")
+        lib_v = QVBoxLayout(lib_card)
+        lib_v.setContentsMargins(16, 12, 16, 12)
+        lib_v.setSpacing(6)
+        lib_head = QLabel("Steam libraries")
+        lib_head.setStyleSheet("font-weight: 700; background: transparent;")
+        lib_v.addWidget(lib_head)
+        self._lib_box = QVBoxLayout()
+        self._lib_box.setSpacing(6)
+        lib_v.addLayout(self._lib_box)
+        self._lib_hint = QLabel("Looking for Steam libraries…")
+        self._lib_hint.setObjectName("Muted")
+        self._lib_hint.setWordWrap(True)
+        lib_v.addWidget(self._lib_hint)
+        root.addWidget(lib_card)
+
+        # Games list
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QFrame.Shape.NoFrame)
+        scroll.setStyleSheet("background: transparent;")
+        self._container = QWidget()
+        self._list = QVBoxLayout(self._container)
+        self._list.setContentsMargins(0, 0, 0, 0)
+        self._list.setSpacing(8)
+        self._list.setAlignment(Qt.AlignmentFlag.AlignTop)
+        scroll.setWidget(self._container)
+        root.addWidget(scroll, 1)
+
+        self._load_cached()                       # instant display from the last scan
+        QTimer.singleShot(400, self.refresh)      # then rescan in the background on launch
+
+    # --- loading ----------------------------------------------------------------------
+
+    def _load_cached(self) -> None:
+        from ..core import steam
+
+        cache = steam.load_cache() or {}
+        self._new_appids = set(cache.get("new_appids", []))
+        games = steam.cached_games()
+        if games:
+            self._populate_games(games, self._new_appids)
+        self.new_count_changed.emit(len(self._new_appids))
+
+    def refresh(self) -> None:
+        if self._busy:
+            return
+        self._busy = True
+        self._rescan_btn.setEnabled(False)
+        self._status.setText("Scanning Steam libraries…")
+        threading.Thread(target=self._work, daemon=True).start()
+
+    def _work(self) -> None:
+        from ..core import steam
+
+        try:
+            selected = {os.path.realpath(p) for p in steam.selected_library_paths()}
+            libs = [
+                {"path": lib.path, "label": lib.label, "selected": lib.path in selected,
+                 "count": len(steam.scan_library(lib.path))}
+                for lib in steam.discover_libraries()
+            ]
+            self._libraries_ready.emit(libs)
+            self._scanned.emit(steam.rescan())
+        except Exception:
+            self._scanned.emit(None)
+
+    # --- rendering --------------------------------------------------------------------
+
+    def _render_libraries(self, libs) -> None:
+        while self._lib_box.count():
+            item = self._lib_box.takeAt(0)
+            w = item.widget()
+            if w is not None:
+                w.deleteLater()
+        if not libs:
+            self._lib_hint.setText("No Steam libraries detected. Is Steam installed?")
+            self._lib_hint.show()
+            return
+        self._lib_hint.hide()
+        for lib in libs:
+            label = lib["path"]
+            if lib["label"]:
+                label += f"  [{lib['label']}]"
+            cb = QCheckBox(f"{label}    ·  {lib['count']} games")
+            cb.setChecked(lib["selected"])
+            cb.toggled.connect(lambda checked, p=lib["path"]: self._toggle_library(p, checked))
+            self._lib_box.addWidget(cb)
+
+    def _toggle_library(self, path: str, checked: bool) -> None:
+        selected = {os.path.realpath(p) for p in (load_config().get("steam_libraries") or [])}
+        if checked:
+            selected.add(os.path.realpath(path))
+        else:
+            selected.discard(os.path.realpath(path))
+        update_config(steam_libraries=sorted(selected))
+        self.refresh()
+
+    def _render_games(self, result) -> None:
+        self._busy = False
+        self._rescan_btn.setEnabled(True)
+        if result is None:
+            self._status.setText("scan failed")
+            return
+        self._new_appids = set(result.new_appids)
+        self._populate_games(result.games, self._new_appids)
+        new = len(self._new_appids)
+        suffix = f"  ·  {new} new" if new else ""
+        self._status.setText(
+            f"{len(result.games)} games  ·  {time.strftime('%H:%M:%S')}{suffix}"
+        )
+        self.new_count_changed.emit(new)
+
+    def _populate_games(self, games, new_appids: set[str]) -> None:
+        from ..core import steam
+
+        while self._list.count():
+            item = self._list.takeAt(0)
+            w = item.widget()
+            if w is not None:
+                w.deleteLater()
+
+        if not games:
+            empty = QLabel(
+                "No games to show yet — check a Steam library above to scan it for games."
+            )
+            empty.setObjectName("Muted")
+            empty.setWordWrap(True)
+            self._list.addWidget(empty)
+            self._list.addStretch(1)
+            return
+
+        for g in games:
+            self._list.addWidget(_game_row(
+                g.name,
+                os.path.basename(g.library.rstrip("/")) or g.library,
+                steam.human_size(g.size_bytes),
+                g.appid in new_appids,
+            ))
+        self._list.addStretch(1)
+
+    # --- nav badge integration --------------------------------------------------------
+
+    def showEvent(self, event) -> None:  # noqa: N802 (Qt override)
+        # Viewing the list acknowledges the new games: clear the sidebar badge. The NEW
+        # tags stay on the rows for this session so the user can still spot them.
+        super().showEvent(event)
+        if self._new_appids:
+            from ..core import steam
+
+            threading.Thread(target=steam.acknowledge_new, daemon=True).start()
+            self.new_count_changed.emit(0)

src/rigdoctor/gui/health_page.py

@@ -16,40 +16,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from .theme import ACCENT, CRIT, GOOD, MUTED, WARN
-
-_SEV = {
-    "critical": ("CRITICAL", CRIT),
-    "warning": ("WARNING", WARN),
-    "info": ("INFO", MUTED),
-    "ok": ("OK", GOOD),
-}
-
-
-def _finding_widget(finding) -> QFrame:
-    label, color = _SEV.get(finding.severity, ("?", MUTED))
-    card = QFrame()
-    card.setObjectName("Card")
-    v = QVBoxLayout(card)
-    v.setContentsMargins(16, 12, 16, 12)
-    v.setSpacing(4)
-
-    head = QLabel(f"{label}  ·  {finding.category}: {finding.title}")
-    head.setStyleSheet(f"color: {color}; font-weight: 700; background: transparent;")
-    head.setWordWrap(True)
-    v.addWidget(head)
-
-    if finding.detail:
-        detail = QLabel(finding.detail)
-        detail.setObjectName("Muted")
-        detail.setWordWrap(True)
-        v.addWidget(detail)
-    if finding.suggestion:
-        suggestion = QLabel(f"→ {finding.suggestion}")
-        suggestion.setStyleSheet(f"color: {ACCENT}; background: transparent;")
-        suggestion.setWordWrap(True)
-        v.addWidget(suggestion)
-    return card
+from .widgets import finding_card
 
 
 class HealthPage(QWidget):
@@ -125,5 +92,5 @@ class HealthPage(QWidget):
             f"{time.strftime('%H:%M:%S')}"
         )
         for finding in findings:
-            self._list.addWidget(_finding_widget(finding))
+            self._list.addWidget(finding_card(finding))
         self._list.addStretch(1)

src/rigdoctor/gui/main_window.py

@@ -28,6 +28,8 @@ from .. import __version__
 from ..config import load_config
 from ..core import alerts, elevation, updates
 from .dashboard import Dashboard
+from .environment_page import EnvironmentPage
+from .games_page import GamesPage
 from .health_page import HealthPage
 from .notifications_page import NotificationsPage
 from .recorder_page import RecorderPage
@@ -36,7 +38,7 @@ from .share_page import SharePage
 from .theme import ACCENT, GOOD, MUTED
 from .worker import SamplerWorker
 
-_NAV_ITEMS = ["Dashboard", "Logs", "Health", "Setup", "Notifications", "Share"]
+_NAV_ITEMS = ["Dashboard", "Logs", "Health", "Games", "Environment", "Setup", "Notifications", "Share"]
 
 
 class MainWindow(QMainWindow):
@@ -66,6 +68,9 @@ class MainWindow(QMainWindow):
         self.dashboard = Dashboard()
         self.recorder_page = RecorderPage()
         self.health_page = HealthPage()
+        self.games_page = GamesPage()
+        self.games_page.new_count_changed.connect(self._set_games_badge)
+        self.environment_page = EnvironmentPage()
         self.setup_page = SetupPage()
         self.notifications_page = NotificationsPage()
         self.notifications_page.changed.connect(self._apply_alert_settings)
@@ -73,9 +78,11 @@ class MainWindow(QMainWindow):
         self._stack.addWidget(self.dashboard)            # 0 Dashboard
         self._stack.addWidget(self.recorder_page)        # 1 Logs
         self._stack.addWidget(self.health_page)          # 2 Health
-        self._stack.addWidget(self.setup_page)           # 3 Setup
-        self._stack.addWidget(self.notifications_page)   # 4 Notifications
-        self._stack.addWidget(self.share_page)           # 5 Share
+        self._stack.addWidget(self.games_page)           # 3 Games
+        self._stack.addWidget(self.environment_page)     # 4 Environment
+        self._stack.addWidget(self.setup_page)           # 5 Setup
+        self._stack.addWidget(self.notifications_page)   # 6 Notifications
+        self._stack.addWidget(self.share_page)           # 7 Share
         content_layout.addWidget(self._stack)
 
         layout.addWidget(self._build_sidebar())
@@ -135,6 +142,7 @@ class MainWindow(QMainWindow):
 
         group = QButtonGroup(self)
         group.setExclusive(True)
+        self._nav_buttons: dict[str, QPushButton] = {}
         for i, name in enumerate(_NAV_ITEMS):
             btn = QPushButton(name)
             btn.setObjectName("NavButton")
@@ -144,6 +152,7 @@ class MainWindow(QMainWindow):
             btn.clicked.connect(lambda _checked, idx=i: self._stack.setCurrentIndex(idx))
             group.addButton(btn, i)
             v.addWidget(btn)
+            self._nav_buttons[name] = btn
 
         v.addStretch(1)
         live = QLabel(f'<span style="color:{ACCENT};">●</span> <span style="color:{MUTED};">Live</span>')
@@ -229,6 +238,11 @@ class MainWindow(QMainWindow):
         # collected and used by the relay guest view + the CLI `rigdoctor inventory`.)
         self.health_page._run()
 
+    def _set_games_badge(self, count: int) -> None:
+        btn = self._nav_buttons.get("Games")
+        if btn is not None:
+            btn.setText(f"Games   ● {count}" if count > 0 else "Games")
+
     def _apply_alert_settings(self) -> None:
         cfg = load_config()
         self._alert_monitor.enabled = bool(cfg.get("alerts_enabled", True))

src/rigdoctor/gui/terminal_widget.py

@@ -24,7 +24,7 @@ class TerminalView(QPlainTextEdit):
         self.setUndoRedoEnabled(False)
         self.setMinimumHeight(260)
         self._rows, self._cols = rows, cols
-        self._screen = pyte.Screen(cols, rows)
+        self._screen = pyte.HistoryScreen(cols, rows, history=1000, ratio=0.5)
         self._stream = pyte.ByteStream(self._screen)
 
     def grid(self) -> tuple[int, int]:
@@ -38,15 +38,24 @@ class TerminalView(QPlainTextEdit):
         self._screen.reset()
         self._render()
 
+    def _row_text(self, row) -> str:
+        return "".join(row[x].data for x in range(self._cols)).rstrip()
+
     def _render(self) -> None:
-        self.setPlainText("\n".join(self._screen.display))
-        # Place the caret at the terminal's actual cursor (row, col) and keep it in view.
-        cursor = self.textCursor()
-        cursor.movePosition(QTextCursor.MoveOperation.Start)
-        cursor.movePosition(QTextCursor.MoveOperation.Down, QTextCursor.MoveMode.MoveAnchor, self._screen.cursor.y)
-        cursor.movePosition(QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.MoveAnchor, self._screen.cursor.x)
-        self.setTextCursor(cursor)
-        self.ensureCursorVisible()
+        bar = self.verticalScrollBar()
+        at_bottom = bar.value() >= bar.maximum() - 2
+        prev = bar.value()
+        history = [self._row_text(r) for r in self._screen.history.top]  # scrollback
+        self.setPlainText("\n".join(history + list(self._screen.display)))
+        if at_bottom:  # follow output; place caret at the real (row, col)
+            cursor = self.textCursor()
+            cursor.movePosition(QTextCursor.MoveOperation.Start)
+            cursor.movePosition(QTextCursor.MoveOperation.Down, QTextCursor.MoveMode.MoveAnchor, len(history) + self._screen.cursor.y)
+            cursor.movePosition(QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.MoveAnchor, self._screen.cursor.x)
+            self.setTextCursor(cursor)
+            self.ensureCursorVisible()
+        else:  # user scrolled up to read — keep their place
+            bar.setValue(prev)
 
     def resizeEvent(self, event):  # noqa: N802 (Qt override)
         super().resizeEvent(event)

src/rigdoctor/gui/widgets.py

@@ -16,7 +16,41 @@ from PySide6.QtWidgets import (
 
 from ..core.sample import Reading
 from ..render import format_value
-from .theme import MUTED, TEXT, TRACK, gauge_color, temp_color
+from .theme import ACCENT, CRIT, GOOD, MUTED, TEXT, TRACK, WARN, gauge_color, temp_color
+
+_SEV = {
+    "critical": ("CRITICAL", CRIT),
+    "warning": ("WARNING", WARN),
+    "info": ("INFO", MUTED),
+    "ok": ("OK", GOOD),
+}
+
+
+def finding_card(finding) -> QFrame:
+    """A card for one M4/M6 Finding (severity-colored title, detail, suggested fix)."""
+    label, color = _SEV.get(finding.severity, ("?", MUTED))
+    card = QFrame()
+    card.setObjectName("Card")
+    v = QVBoxLayout(card)
+    v.setContentsMargins(16, 12, 16, 12)
+    v.setSpacing(4)
+
+    head = QLabel(f"{label}  ·  {finding.category}: {finding.title}")
+    head.setStyleSheet(f"color: {color}; font-weight: 700; background: transparent;")
+    head.setWordWrap(True)
+    v.addWidget(head)
+
+    if finding.detail:
+        detail = QLabel(finding.detail)
+        detail.setObjectName("Muted")
+        detail.setWordWrap(True)
+        v.addWidget(detail)
+    if finding.suggestion:
+        suggestion = QLabel(f"→ {finding.suggestion}")
+        suggestion.setStyleSheet(f"color: {ACCENT}; background: transparent;")
+        suggestion.setWordWrap(True)
+        v.addWidget(suggestion)
+    return card
 
 
 class Card(QFrame):

src/rigdoctor/render.py

@@ -102,12 +102,12 @@ def _aggregate_peaks(maxima: dict) -> list[tuple[str, str, float, str, float, st
 _SEV_LABEL = {"critical": "CRITICAL", "warning": "WARNING", "info": "INFO", "ok": "OK"}
 
 
-def render_health(findings: list) -> str:
+def render_health(findings: list, title: str = "Health report") -> str:
     if not findings:
-        return "Health report: no findings."
+        return f"{title}: no findings."
     crit = sum(1 for f in findings if f.severity == "critical")
     warn = sum(1 for f in findings if f.severity == "warning")
-    lines = ["Health report", "", f"  {crit} critical · {warn} warning · {len(findings)} checks", ""]
+    lines = [title, "", f"  {crit} critical · {warn} warning · {len(findings)} checks", ""]
     for f in findings:
         lines.append(f"[{_SEV_LABEL.get(f.severity, '?')}] {f.category}: {f.title}")
         if f.detail:

tests/test_config.py

@@ -19,6 +19,16 @@ class ConfigTests(unittest.TestCase):
                 self.assertEqual(loaded["gpu_temp_alert"], 88.0)
                 self.assertEqual(loaded["update_check_minutes"], 5)
 
+    def test_list_value_round_trip(self):
+        with tempfile.TemporaryDirectory() as d:
+            cf = Path(d) / "config.toml"
+            with mock.patch.object(config, "CONFIG_FILE", cf), mock.patch.object(config, "CONFIG_DIR", Path(d)):
+                paths = ["/home/u/.local/share/Steam", "/mnt/games/SteamLibrary"]
+                config.update_config(steam_libraries=paths)
+                self.assertEqual(config.load_config()["steam_libraries"], paths)
+                config.update_config(steam_libraries=[])
+                self.assertEqual(config.load_config()["steam_libraries"], [])
+
     def test_update_config_merges_and_keeps_defaults(self):
         with tempfile.TemporaryDirectory() as d:
             cf = Path(d) / "config.toml"

tests/test_gameenv.py

@@ -0,0 +1,73 @@
+"""Tests for M6 gaming-environment checks (pure evaluators + aggregate smoke test)."""
+
+import unittest
+
+from rigdoctor.core import gameenv
+from rigdoctor.core.health import Finding
+
+
+class AspmTests(unittest.TestCase):
+    def test_powersave_is_warning(self):
+        f = gameenv.evaluate_aspm("[powersave] performance powersupersave\n")
+        self.assertEqual(f.severity, "warning")
+        self.assertEqual(f.category, "PCIe")
+
+    def test_performance_is_ok(self):
+        self.assertEqual(gameenv.evaluate_aspm("[performance] powersave powersupersave").severity, "ok")
+
+    def test_default_is_info(self):
+        self.assertEqual(gameenv.evaluate_aspm("[default] performance powersave").severity, "info")
+
+    def test_missing_is_none(self):
+        self.assertIsNone(gameenv.evaluate_aspm(None))
+        self.assertIsNone(gameenv.evaluate_aspm("no brackets here"))
+
+
+class GovernorTests(unittest.TestCase):
+    def test_performance_only_is_ok(self):
+        self.assertEqual(gameenv.evaluate_governor({"performance"}).severity, "ok")
+
+    def test_powersave_is_warning(self):
+        f = gameenv.evaluate_governor({"powersave"})
+        self.assertEqual(f.severity, "warning")
+        self.assertIn("cpupower", f.suggestion)
+
+    def test_dynamic_is_info(self):
+        self.assertEqual(gameenv.evaluate_governor({"schedutil"}).severity, "info")
+
+    def test_empty_is_none(self):
+        self.assertIsNone(gameenv.evaluate_governor(set()))
+
+
+class SwappinessTests(unittest.TestCase):
+    def test_high_is_info_with_suggestion(self):
+        f = gameenv.evaluate_swappiness(60)
+        self.assertEqual(f.severity, "info")
+        self.assertIn("swappiness", f.suggestion)
+
+    def test_low_is_ok(self):
+        self.assertEqual(gameenv.evaluate_swappiness(10).severity, "ok")
+
+
+class ShaderCacheTests(unittest.TestCase):
+    def test_disabled_nvidia_is_warning(self):
+        self.assertEqual(gameenv.evaluate_shader_cache({"__GL_SHADER_DISK_CACHE": "0"}).severity, "warning")
+
+    def test_disabled_mesa_is_warning(self):
+        self.assertEqual(gameenv.evaluate_shader_cache({"MESA_SHADER_CACHE_DISABLE": "true"}).severity, "warning")
+
+    def test_default_is_ok(self):
+        self.assertEqual(gameenv.evaluate_shader_cache({}).severity, "ok")
+
+
+class AggregateTests(unittest.TestCase):
+    def test_run_returns_sorted_findings(self):
+        findings = gameenv.run_gameenv_checks()
+        self.assertTrue(all(isinstance(f, Finding) for f in findings))
+        order = {"critical": 0, "warning": 1, "info": 2, "ok": 3}
+        sevs = [order.get(f.severity, 9) for f in findings]
+        self.assertEqual(sevs, sorted(sevs))  # worst-first
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_steam.py

@@ -0,0 +1,147 @@
+"""Tests for M6 Steam library & game detection (VDF parse, scan, tool filter, cache diff)."""
+
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from rigdoctor.core import steam
+
+_GAME_ACF = """"AppState"
+{{
+\t"appid"\t\t"{appid}"
+\t"name"\t\t"{name}"
+\t"installdir"\t\t"{installdir}"
+\t"SizeOnDisk"\t\t"{size}"
+\t"LastUpdated"\t\t"{updated}"
+}}
+"""
+
+_LIBRARYFOLDERS = """"libraryfolders"
+{{
+\t"0"
+\t{{
+\t\t"path"\t\t"{path}"
+\t\t"label"\t\t"Main"
+\t\t"apps"
+\t\t{{
+\t\t\t"570"\t\t"123"
+\t\t}}
+\t}}
+}}
+"""
+
+
+def _make_library(root: Path, games) -> Path:
+    """games: list of (appid, name, installdir, size, updated). Returns the library path."""
+    steamapps = root / "steamapps"
+    steamapps.mkdir(parents=True, exist_ok=True)
+    for appid, name, installdir, size, updated in games:
+        (steamapps / f"appmanifest_{appid}.acf").write_text(
+            _GAME_ACF.format(appid=appid, name=name, installdir=installdir, size=size, updated=updated)
+        )
+    return root
+
+
+class VdfTests(unittest.TestCase):
+    def test_parse_nested_and_pairs(self):
+        data = steam._parse_vdf(_GAME_ACF.format(
+            appid="570", name="Dota 2", installdir="dota 2 beta", size="15", updated="1700"))
+        state = data["AppState"]
+        self.assertEqual(state["appid"], "570")
+        self.assertEqual(state["name"], "Dota 2")
+        self.assertEqual(state["installdir"], "dota 2 beta")
+
+    def test_parse_handles_quotes_in_names(self):
+        acf = _GAME_ACF.format(appid="1", name="Baldur\\'s Gate 3", installdir="bg3", size="1", updated="1")
+        data = steam._parse_vdf(acf)
+        self.assertIn("Baldur", data["AppState"]["name"])
+
+    def test_parse_garbage_returns_empty(self):
+        self.assertEqual(steam._parse_vdf("not vdf at all"), {})
+
+
+class ToolFilterTests(unittest.TestCase):
+    def test_known_tool_appid(self):
+        self.assertTrue(steam.is_tool("228980", "Steamworks Common Redistributables"))
+
+    def test_proton_name_prefix(self):
+        self.assertTrue(steam.is_tool("9999999", "Proton 8.0"))
+        self.assertTrue(steam.is_tool("9999998", "Steam Linux Runtime 3.0 (sniper)"))
+
+    def test_real_game_is_not_a_tool(self):
+        self.assertFalse(steam.is_tool("570", "Dota 2"))
+
+
+class ScanTests(unittest.TestCase):
+    def test_scan_library_filters_tools(self):
+        with tempfile.TemporaryDirectory() as d:
+            lib = _make_library(Path(d), [
+                ("570", "Dota 2", "dota 2 beta", "15000000000", "1700000000"),
+                ("228980", "Steamworks Common Redistributables", "Steamworks Shared", "0", "0"),
+                ("1493710", "Proton Experimental", "Proton - Experimental", "0", "0"),
+            ])
+            games = steam.scan_library(str(lib))
+            names = {g.name for g in games}
+            self.assertEqual(names, {"Dota 2"})
+            self.assertEqual(games[0].size_bytes, 15000000000)
+
+    def test_scan_games_dedupes_and_sorts(self):
+        with tempfile.TemporaryDirectory() as d1, tempfile.TemporaryDirectory() as d2:
+            a = _make_library(Path(d1), [("10", "Zeta", "zeta", "1", "1"), ("20", "Alpha", "alpha", "1", "1")])
+            b = _make_library(Path(d2), [("20", "Alpha", "alpha", "1", "1")])  # dup appid 20
+            games = steam.scan_games([str(a), str(b)])
+            self.assertEqual([g.name for g in games], ["Alpha", "Zeta"])  # sorted, deduped
+
+
+class DiscoverTests(unittest.TestCase):
+    def test_discover_reads_libraryfolders(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d) / "Steam"
+            (root / "steamapps").mkdir(parents=True)
+            extra = Path(d) / "Extra"
+            (extra / "steamapps").mkdir(parents=True)
+            (root / "steamapps" / "libraryfolders.vdf").write_text(
+                _LIBRARYFOLDERS.format(path=str(extra)))
+            with mock.patch.object(steam, "steam_roots", return_value=[root]):
+                libs = steam.discover_libraries()
+            paths = {lib.path for lib in libs}
+            self.assertIn(str(root.resolve()), paths)   # root itself
+            self.assertIn(str(extra.resolve()), paths)  # the configured extra library
+
+
+class CacheDiffTests(unittest.TestCase):
+    def _rescan(self, lib, games_file, cfg):
+        with mock.patch.object(steam, "GAMES_FILE", games_file):
+            return steam.rescan(cfg=cfg)
+
+    def test_first_scan_has_no_new_then_added_game_is_new(self):
+        with tempfile.TemporaryDirectory() as d:
+            lib = _make_library(Path(d) / "lib", [("10", "Alpha", "alpha", "1", "1")])
+            games_file = Path(d) / "games.json"
+            cfg = {"steam_libraries": [str(lib)]}
+
+            first = self._rescan(lib, games_file, cfg)
+            self.assertEqual(first.new_appids, [])  # first run flags nothing as new
+
+            # Install a second game; it should be flagged new on the next scan.
+            _make_library(lib, [("10", "Alpha", "alpha", "1", "1"), ("20", "Beta", "beta", "1", "1")])
+            second = self._rescan(lib, games_file, cfg)
+            self.assertEqual(second.new_appids, ["20"])
+            self.assertEqual({g.name for g in second.games}, {"Alpha", "Beta"})
+
+    def test_acknowledge_clears_new(self):
+        with tempfile.TemporaryDirectory() as d:
+            lib = _make_library(Path(d) / "lib", [("10", "Alpha", "alpha", "1", "1")])
+            games_file = Path(d) / "games.json"
+            cfg = {"steam_libraries": [str(lib)]}
+            self._rescan(lib, games_file, cfg)
+            _make_library(lib, [("10", "Alpha", "alpha", "1", "1"), ("20", "Beta", "beta", "1", "1")])
+            self._rescan(lib, games_file, cfg)
+            with mock.patch.object(steam, "GAMES_FILE", games_file):
+                steam.acknowledge_new()
+                self.assertEqual(steam.load_cache()["new_appids"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()