Merge pull request 'feat(share): render colors in the shared terminal — 0.24.0' (#20 ) from feat/share-terminal into main

Reviewed-on: #20
feat(share): terminal-only sharing, bigger + full-screen — 0.25.0
2026-05-22 08:05:12 +00:00 · 2026-05-22 10:04:52 +02:00 · 2026-05-22 10:00:23 +02:00 · 2026-05-22 07:55:47 +00:00 · 2026-05-22 09:55:36 +02:00 · 2026-05-22 07:47:26 +00:00
35 changed files with 1774 additions and 671 deletions
@@ -5,6 +5,87 @@ 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.25.0] - 2026-05-22
 ### Changed
 - **Share is now terminal-only (D23, amends D16).** The Share page is a single shared-terminal
  experience: the host shares their shell, the guest watches and may type **only if the host
  ticks "Allow the guest to type"** (otherwise read-only). The terminal is larger and either
  side can pop it **full-screen** (Esc to exit).
 ### Removed
 - The read-only **stats view** (live sensors/health/inventory over the relay) and the
  `rigdoctor share serve` HTTP server — the shared terminal replaces them. (`core/share.py`
  removed; the `share` CLI command is gone.)
 ## [0.24.0] - 2026-05-22
 ### Added
 - **Shared terminal is now in color.** The terminal view renders pyte's per-cell foreground/
  background, bold, and reverse, so the host's real shell keeps its theming — fish, `ls`,
  `git`, prompts, etc. look the same as locally (the session already runs the host's `$SHELL`
  with its config and `TERM=xterm-256color`; only the rendering was monochrome).
 ## [0.23.0] - 2026-05-22
 ### Added
 - **Crash-logger trigger modes (M9 / D6)** via `systemd --user`, no root: **manual**,
  **always-on** (a background service records continuously), and **game-launch** (auto-records
  while a Steam game runs). Set it from **Settings → Recording trigger** or
  `rigdoctor service mode <manual|always-on|game-launch>`; `rigdoctor service status` shows it.
  `core/service.py` writes/enables the user units.
 - **Zero-config game-launch watcher** (`core/watcher.py`, `rigdoctor watch`) — polls Steam's
  RunningAppID and brackets a focused capture around the running game (the D12 fallback for users
  who don't add the `wrap` launch option; the wrapper stays the precise primary path).
 ## [0.22.0] - 2026-05-22
 ### Added
 - **M6 breadth.** Environment checks now also report **GPU PowerMizer** mode (NVIDIA, X — flags
  Adaptive/Auto and suggests Prefer-Max-Performance), the **Wine** version, and the **Steam
  client** version.
 - **Non-Steam launchers.** Lutris (its SQLite library) and Heroic (Epic + GOG JSON stores) are
  detected (`core/launchers.py`) and listed on the Games page and `rigdoctor games`, tagged by
  launcher. You can Run Diagnostic on them too (records while you play; auto-launch stays
  Steam-only).
 ### Notes
 - The zero-config game watcher (D12 fallback) is deferred to the M9 trigger-mode work, where the
  service integration lives.
 ## [0.21.0] - 2026-05-22
 ### Added
 - **Live monitor TUI (M2).** `rigdoctor monitor` is now a proper **curses** dashboard:
  current / session-min / session-max per sensor, grouped by subsystem, with temperature and
  utilization **color bands** (and GPU-lost flagged red). `q` quits, `r` resets the session
  min/max. Falls back to a plain full-screen redraw on a non-TTY (`--plain` forces it). The
  terminal face of the same live data the GUI dashboard graphs. Completes the Monitoring bundle.
 ## [0.20.0] - 2026-05-22
 ### Changed
 - **Reorganized navigation** into grouped sidebar sections — **Monitor** (Dashboard) ·
  **Diagnose** (Games, Recordings, System Health, Tuning) · **System** (Inventory) · **App**
  (Settings, Share) — so it's clear where to go.
 - **Renames for clarity:** *Health → System Health* (it's the overall 7-day system scan, not
  per-game), *Environment → Tuning* (gaming tunables + fixes), *Logs → Recordings*,
  *Setup → Settings*.
 - **Settings** absorbed **Notifications** (alerts) — app configuration (components/deps, alerts,
  account access, uninstall) now lives in one page; Notifications is no longer a separate item.
 - **Recordings** is now a hub: pick which captured log to view (always-on capture, last
  diagnostic, or a preserved crash), **Analyze crash** in place, alongside the recorder controls.
 ## [0.19.0] - 2026-05-22
 ### Added
 - **System-tray applet (M11, D13).** A tray icon whose menu shows live **CPU / GPU temp** and
  **memory used/total**, a **status line** (Normal / Hot / GPU not responding), and is led by a
  **Run Diagnostic** submenu (pick a detected game → the guided session), plus **Open dashboard**,
  **Start/Stop recording**, **Snapshot (copy)**, and **Quit**. It reuses the dashboard's sample
  stream (no extra sampling). With a tray present, **closing the window hides to the tray** (Quit
  exits); `rigdoctor-gui --tray` starts hidden for autostart. Needs a tray host — on GNOME the
  AppIndicator extension; degrades to a no-op if none is available. Completes the Desktop UI bundle.
 - **GUI smoke tests**: construct `MainWindow` headless and exercise the tray, so a startup crash
  fails the build (closes the gap that let the 0.18.0 import regression ship).
 ## [0.18.2] - 2026-05-22
 ### Fixed
 - **GUI wouldn't start** (0.18.0 regression): the recording indicator used a wrong relative
  import (`from .core` → `rigdoctor.gui.core`, which doesn't exist), crashing `MainWindow` on
  launch. Corrected to `from ..core`.
 ## [0.18.1] - 2026-05-22
 ### Changed
 - Recording badge: dropped the sample count (not useful at a glance) — it now shows just
@@ -239,9 +239,19 @@ consent." That milestone lands here, **scoped tightly to stay safe**:
  the apply UI is an additive convenience in the GUI, not the only path. Installing optional
  tools (GameMode/MangoHud/cpupower) reuses the M9 installer and is likewise one-click.
 ### D23 — Session sharing scoped to a shared terminal only — *DECIDED 2026-05-22; amends D16*
 D16's escalating ladder (export → read-only stats view → terminal) is **cut down to just the
 shared terminal.** Rationale: the terminal is the only mode the owner wants; the stats view
 duplicated what the GUI already shows and added surface area. Concretely:
 - **Removed:** the read-only stats view + its HTTP server (`core/share.py`, `rigdoctor share
  serve`) and the (never-built) bundle export. The `share` CLI command is gone.
 - **Kept & finished:** the relay **shared terminal** (host PTY of `$SHELL`) — now color-rendered
  (preserves fish/ls/git theming), full-screen-able, with the guest read-only unless the host
  ticks "Allow the guest to type" (the D9 consent exception). Account-gated by the Gitea token.
 ## Open
-None currently — all tracked decisions (D1–D22) are resolved. New questions will be added
+None currently — all tracked decisions (D1–D23) are resolved. New questions will be added
 here as they arise. Remaining detail to flesh out during build: the tray's supporting-action
 set (D13), per-module apt package names, M12's tunnel/token specifics, and M13's
 update mechanism (APT repo vs. self-installed `.deb`).
@@ -11,14 +11,14 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
 | M1 | Sensor core | Essential | none (nvidia-smi, sysfs) | all (NVIDIA first) | P0 | ✅ |
 | M3 | Crash-capture logger | Essential | none (opt: smartmontools) | all (NVIDIA first) | P0 | ✅ |
 | M4 | Health report (log scan) | Essential | none (opt: smartmontools) | all (NVIDIA first) | P0 | ✅ |
-| M2 | Live monitor (TUI) | Monitoring | none (stdlib curses) | all | P1 | ⬜ |
+| 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 | 🟨 |
 | M10 | Desktop GUI | Desktop UI | **python3-pyside6** | all | P2 | ✅ |
-| M11 | Tray / menu-bar applet | Desktop UI | **python3-pyside6** (+ AppIndicator on GNOME) | all | P2 | ⬜ |
+| M11 | Tray / menu-bar applet | Desktop UI | **python3-pyside6** (+ AppIndicator on GNOME) | all | P2 | ✅ |
 | M9 | Installer | (meta) | none | all | P1 | 🟨 |
-| M12 | Session sharing / remote assist | Sharing | none (Tier 3: tmate/sshx) | all | P3 | 🟨 |
+| M12 | Session sharing (shared terminal) | Sharing | none (relay) | all | P3 | ✅ |
 | M13 | Auto-update | (core) | none (stdlib; user-local file swap) | all | P3 | ✅ |
 | ~~M7~~ | ~~Stress / repro~~ | — | — | — | — | ❌ dropped (D7) |
@@ -41,7 +41,10 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
  findings (see SPEC §4). *Implemented:* journalctl scan (Xid/panic/OOM/MCE/AER/thermal/amdgpu),
  SMART, NVIDIA driver-mismatch, journald-persistence + live-temp checks; `rigdoctor report`
  (text/JSON) + GUI Health tab. GPU-firmware verification deferred.
- **M2 Live monitor** — depends on M1; the terminal "HWMonitor for Linux" face. Stdlib-only.
+- **M2 Live monitor** — the terminal "HWMonitor for Linux" face. *Implemented (`tui.py`):*
  `rigdoctor monitor` is a stdlib **curses** dashboard — current / session-min / session-max
  per sensor, grouped by subsystem, with temperature & utilization color bands; `q` quits,
  `r` resets the min/max. Falls back to a plain redraw on a non-TTY (`--plain` forces it).
 - **M5 / M6 Diagnostics** — inventory export + gaming-env checks; M6 flags risky settings and
  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
@@ -64,19 +67,26 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
  banner → results dialog). **Auto-capture** via the D12 wrapper (`rigdoctor wrap %command%`,
  `core/wrap.py`; GUI "Auto-capture…" helper). **Hard crashes are detected** (capture left
  without a clean stop) and flagged on next launch with a crash-boot kernel-log analysis
-  (`pending_crash`/`analyze_crash` + `health.check_previous_boot`). *Pending:* non-Steam
+  (`pending_crash`/`analyze_crash` + `health.check_previous_boot`). **Non-Steam launchers**
-  launchers (Lutris/Heroic), GPU power-profile (PowerMizer) checks, and the zero-config watcher.
+  (Lutris SQLite + Heroic JSON, `core/launchers.py`) are detected and listed alongside Steam
  games; env checks also cover **GPU PowerMizer** (X), **Wine** and **Steam-client** versions.
  *Pending:* the zero-config watcher (D12 fallback) — landing with M9's trigger-mode work.
 - **M8 Alerting** — threshold/event notifications; integrates with the tray applet (M11).
- **M10 Desktop GUI** — PySide6 graphical front-end over the core engine (dashboard, log
+- **M10 Desktop GUI** — PySide6 graphical front-end over the core engine. Optional; adds the
-  browser, report viewer, logger controls). Optional; adds the Qt dependency. *Bootstrapped
+  Qt dependency. Dark-themed window with a **grouped sidebar** (Monitor / Diagnose / System /
-  early (ahead of its Phase 4 slot) at the user's request:* dark-themed window with sidebar
+  App) over: **Dashboard** (live history graphs + per-subsystem cards), **Games** (M6 detection
-  nav, a live dashboard (circular gauges + collapsible per-subsystem cards, temperature-
+  + Run Diagnostic), **Recordings** (recorder controls + view/report any captured log + analyze
-  colored values), and a **Recording/Logs page** with full M3 controls (start/stop/status +
+  a crash), **System Health** (M4 scan), **Tuning** (M6 gaming tunables + fixes), **Inventory**
-  post-crash report). Health/Inventory remain placeholders until M4/M5. GUI-first per D17.
+  (M5), **Settings** (components/deps + alerts + account + uninstall), and **Share** (M12). A
- **M11 Tray applet** — `QSystemTrayIcon` menu-bar applet. Dropdown shows live M1 readouts
+  global recording badge shows on every page. GUI-first per D17.
-  (CPU temp, GPU temp, memory used/total, status dot) and is led by a **Run Diagnostic**
+- **M11 Tray applet** — `QSystemTrayIcon` menu-bar applet. *Implemented (`gui/tray.py`, D13):*
-  action (the guided diagnostic session), plus Open dashboard / Start-Stop recording /
+  the menu shows live M1 readouts (CPU temp, GPU temp, memory used/total) + a status line
-  Snapshot / Quit (D13). Optional; shares the Qt dependency with M10.
+  (Normal / Hot / GPU not responding), led by a **Run Diagnostic** submenu (per detected game →
  the guided session), plus Open dashboard / Start-Stop recording / Snapshot-copy / Quit. It
  shares the dashboard's sample stream (no extra sampling) and drives the existing MainWindow
  flows. With a tray present, closing the window **hides to the tray** (Quit exits); `rigdoctor-gui
  --tray` starts hidden for autostart. Optional; shares the Qt dependency with M10. *Needs a tray
  host* — on GNOME that means the AppIndicator extension; degrades to no-op if none is available.
 - **M9 Installer** — interactive wizard layered on the `.deb` (D8); apt-first dependency
  resolution; enables the logger service and trigger mode. *Implemented (first cut):* distro/
  package-manager/GPU detection (`core/sysenv`), an optional-component catalog (`core/catalog`),
@@ -86,12 +96,13 @@ Status: ⬜ not started · 🟦 designing · 🟨 in progress · ✅ done
  **`.run`** (pure-Python self-extractor, `packaging/make_run.py`, built by CI). *Pending:*
  config/module selection + `systemd --user`
  service enable.
- **M12 Session sharing / remote assist** (D16) — let a helper inspect a user's machine, in
+- **M12 Session sharing / remote assist** (D16, scoped to terminal-only by **D23**) — a single
-  an escalating ladder: (1) **diagnostic bundle export** (inventory + recent log + report,
+  mode: a **host-consented shared terminal** over the relay. The host shares a real PTY running
-  one-way), (2) **live read-only view** over a user-chosen tunnel (Tailscale/cloudflared/SSH,
+  their `$SHELL` (colors/theming preserved — fish etc.); the guest watches live and can type
-  no hosted relay), (3) **gated interactive terminal** wrapping tmate/sshx (read-only by
+  **only if the host allows it** (otherwise read-only) — a deliberate, consent-gated exception
-  default; read-write only on explicit consent — a deliberate exception to D9). Per-session
+  to D9. The host reads along and can type too (e.g. a sudo password, which stays local). Either
-  consent, ephemeral revocable tokens, audit log.
+  side can pop the terminal **full-screen**. Account-gated by the Gitea token. *The earlier
  read-only stats view and `share serve` (Tier 1/2) were removed.*
 - **M13 Auto-update** (D18) — *check + auth implemented:* updates are **gated to Gitea account
  holders** via a Personal Access Token, stored **encrypted in the OS keyring** (`secret-tool`)
  with a 0600-file fallback (`config.load_token`/`save_token`/`token_backend`). `core/updates`
@@ -22,7 +22,8 @@ Ubuntu + NVIDIA first; `.deb` distribution (see `DECISIONS.md`).
  last readings + a plausible cause.
 ## Phase 2 — Live monitor (terminal)
- [ ] M2 TUI dashboard (current/min/max, grouped, throttle highlighting)
+- [x] M2 TUI dashboard (`rigdoctor monitor`, `tui.py`): curses, current/min/max grouped by
      subsystem with temp/usage color bands; q quit / r reset; plain-redraw fallback on non-TTY
 - [ ] M8 basic alerting (overheat/throttle/GPU-lost notifications)
 ## Phase 3 — Diagnostics breadth
@@ -33,13 +34,17 @@ Ubuntu + NVIDIA first; `.deb` distribution (see `DECISIONS.md`).
      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.
+      Also: GPU PowerMizer (X), Wine + Steam-client versions, and non-Steam launchers
      (Lutris/Heroic, `core/launchers.py`). *Pending:* the zero-config watcher (D12 fallback,
      lands with M9's trigger-mode work).
 - [ ] SMART integration (smartmontools if present)
 ## Phase 4 — Desktop UI & installer
- [ ] M10 desktop GUI (PySide6: dashboard, log browser, report viewer, logger controls)
+- [x] M10 desktop GUI (PySide6: dashboard w/ history graphs, logs, health, games, environment,
- [ ] M11 tray / menu-bar applet (QSystemTrayIcon: live M1 readouts + Run Diagnostic +
+      inventory, setup, notifications, share)
-      supporting actions — D13)
+- [x] M11 tray / menu-bar applet (`gui/tray.py`: live CPU/GPU temp + memory readouts, status
      line, Run Diagnostic submenu per game, Open dashboard / Start-Stop recording / Snapshot /
      Quit — D13; close-to-tray, `--tray` autostart). Needs a tray host (AppIndicator on GNOME).
 - [~] Guided diagnostic session (pick game → focused M3 capture → M4 scan → findings),
      shared by tray/GUI/CLI — *core + CLI + GUI done* (`core/diagnostic.py`, `rigdoctor
      diagnose start/status/finish`, and a **Run Diagnostic** button per game on the GUI Games
@@ -56,9 +61,11 @@ Ubuntu + NVIDIA first; `.deb` distribution (see `DECISIONS.md`).
      watcher (Steam RunningAppID + /proc), GameMode hook, and the always-on `systemd --user`
      service.
 - [~] M9 interactive installer — *done:* distro/GPU detection + optional-dependency install
-      (`rigdoctor install`, GUI Setup tab); **user-local `install.sh` + self-extracting `.run`**
+      (`rigdoctor install`, GUI Settings); **user-local `install.sh` + self-extracting `.run`**
-      (no-root venv install, handles python3-venv prereq, CI-built). *Pending:* module-selection
+      (no-root venv install, handles python3-venv prereq, CI-built); **`systemd --user` trigger
-      config + `systemd --user` service enable + trigger-mode pick.
+      modes** (`core/service.py`, `rigdoctor service mode manual|always-on|game-launch` + GUI
      Settings "Recording trigger") incl. the zero-config **game-launch watcher**
      (`core/watcher.py`, `rigdoctor watch`). *Pending:* module-selection config during install.
 - [ ] `.deb` packaging (D8) declaring per-bundle deps incl. python3-pyside6 for Desktop UI
 ## Phase 5 — Breadth (later)
@@ -72,14 +79,12 @@ Ubuntu + NVIDIA first; `.deb` distribution (see `DECISIONS.md`).
      NVIDIA persistence, PCIe ASPM, swappiness, THP) via a single pkexec prompt, no reboot.
      GRUB-based fixes + CPU mitigations remain suggestion-only.
-## Phase 6 — Session sharing / remote assist  (M12, D16)
+## Phase 6 — Session sharing / remote assist  (M12, D16 → scoped to terminal-only by D23)
-Escalating ladder, built in order:
+- [x] **Shared terminal** — a real PTY (host's `$SHELL`) shared over the relay, color-rendered
- [ ] Tier 1: `share export` — diagnostic bundle (inventory + recent log + report); B opens
+      (pyte), full-screen-able; the guest watches and may type only on host consent (D9
-      it in RigDoctor. One-way, safest.
+      exception); host reads along + can type (sudo). The single share mode.
- [x] Tier 2: live read-only view — `rigdoctor share serve` (stdlib HTTP, token-gated:
+- [removed] The read-only stats view (`share serve`) and bundle export — dropped per D23; the
-      sensors + health + inventory). Remote = user-chosen tunnel; GUI controls still to add.
+      shared terminal is the only sharing mode.
 - [x] Tier 3: host-consented interactive terminal — a real PTY shell shared over the relay
      (own `pty`, pyte-rendered guest), off by default; host reads along + can type (sudo).
 > **Out of scope:** stress/repro module (D7); multi-distro support and packaging beyond
 > Ubuntu/apt + `.deb` (D15) — a thin seam is kept but not built out.
@@ -144,15 +144,13 @@ bundles with descriptions and the exact packages each needs → resolve & instal
 mode. Delivered with the user-local install (and the optional `.deb`) (D8). Module
 list/bundling is final per D14.
-### M12 — Session sharing / remote assist (D16)
+### M12 — Session sharing / remote assist (D16, scoped to terminal-only by D23)
-Lets a user (A) grant a helper (B) inspection access, as an escalating, consent-driven
+Lets a user (A) grant a helper (B) a **shared terminal** over the relay: A shares a real PTY
-ladder: (1) **diagnostic bundle export** (inventory + recent capture log + report, one-way);
+running their shell; B watches live and may type **only if A allows it** (otherwise read-only)
-(2) **live read-only view** of the dashboard + logs over a user-chosen tunnel
+— a deliberate, consent-gated exception to the read-only stance (D9). A reads along and can
-(Tailscale/cloudflared/SSH — no RigDoctor-hosted relay); (3) **gated interactive terminal**
+type too (e.g. a sudo password, which stays local and is never sent to B). Account-gated by the
-wrapping an existing tool (tmate/sshx), read-only by default, read-write only on explicit
+Gitea token; per-session share code. The shared terminal preserves colors/theming and can be
-consent. Per-session consent, ephemeral revocable tokens, permission escalation (view ≠
+viewed full-screen. *(The earlier read-only stats view / bundle export were dropped — D23.)*
 shell), and a session audit log. Tier 3 is a deliberate, consent-gated exception to the
 read-only stance (D9). Built in Phase 6.
 ## 5. Non-functional requirements
 - **Zero hard deps for the core/CLI/daemon** — Python stdlib + tools already present. **Qt
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "rigdoctor"
-version = "0.18.1"
+version = "0.25.0"
 description = "Modular hardware monitoring & crash diagnostics for Linux gamers."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -1,3 +1,3 @@
 """RigDoctor — modular hardware monitoring & crash diagnostics for Linux gamers."""
-__version__ = "0.18.1"
+__version__ = "0.25.0"
@@ -44,17 +44,10 @@ def cmd_snapshot(args) -> int:
 def cmd_monitor(args) -> int:
    from .tui import run
    interval = args.interval or load_config()["interval"]
-    try:
+    return run(interval, plain=getattr(args, "plain", False))
        for sample in _sampler().stream(interval=interval):
            # Basic full-screen redraw; the rich TUI (M2) comes later.
            print("\033[2J\033[H", end="")
            print(f"RigDoctor — live  (every {interval:g}s, Ctrl-C to quit)\n")
            print(render_snapshot(sample))
            sys.stdout.flush()
    except KeyboardInterrupt:
        print()
    return 0
 def cmd_gui(args) -> int:
@@ -296,12 +289,6 @@ def cmd_uninstall(args) -> int:
    return 0
 def cmd_share_serve(args) -> int:
    from .core import share
    return share.serve(host=args.host, port=args.port)
 def cmd_collect_priv(args) -> int:
    """Internal: emit root-only data (SMART + dmidecode) as JSON, run via pkexec at launch."""
    from dataclasses import asdict
@@ -423,6 +410,34 @@ def cmd_wrap(args) -> int:
    return wrap.run(args.command)
 def cmd_watch(args) -> int:
    from .core import watcher
    interval = args.interval or load_config().get("interval", 1.0)
    print("Watching for a running Steam game (Ctrl-C to stop)…")
    return watcher.watch(interval=max(2.0, interval))
 def cmd_service(args) -> int:
    from .core import service
    sub = args.service_cmd or "status"
    if sub == "mode":
        ok, msg = service.apply_mode(args.mode)
        print(f"Trigger mode set to '{args.mode}'.")
        if not ok and msg:
            print(f"  note: {msg}")
        return 0 if ok or not service.available() else 1
    info = service.status()
    print(f"Trigger mode:    {info['mode']}")
    print(f"systemd --user:  {'available' if info['available'] else 'not available'}")
    if info["available"]:
        print(f"  recorder service: {'active' if info.get('recorder_active') else 'inactive'}")
        print(f"  watcher service:  {'active' if info.get('watch_active') else 'inactive'}")
    return 0
 def cmd_gameenv(args) -> int:
    from dataclasses import asdict
@@ -438,34 +453,41 @@ def cmd_gameenv(args) -> int:
 def cmd_games(args) -> int:
-    from .core import steam
+    from dataclasses import asdict
    from .core import launchers, steam
    selected = steam.selected_library_paths()
-    if not selected:
+    result = steam.rescan() if selected else None
-        print("No Steam libraries selected to scan.")
+    steam_games = result.games if result else []
-        print("  See them with:   rigdoctor games libraries")
+    extra = launchers.scan()  # non-Steam (Lutris/Heroic)
-        print("  Then enable one: rigdoctor games libraries --enable <path>  (or --all)")
+    all_games = list(steam_games) + list(extra)
        return 1
    result = steam.rescan()
    if args.json:
        from dataclasses import asdict
    if args.json:
        print(json.dumps({
-            "scanned_at": result.scanned_at,
+            "scanned_at": result.scanned_at if result else None,
-            "new_appids": result.new_appids,
+            "new_appids": result.new_appids if result else [],
-            "games": [asdict(g) for g in result.games],
+            "games": [asdict(g) for g in all_games],
        }, indent=2, ensure_ascii=False))
        return 0
-    if not result.games:
+
-        print("No games found in the selected Steam libraries.")
+    if not all_games:
        if not selected:
            print("No Steam libraries selected and no non-Steam games found.")
            print("  Pick a Steam library: rigdoctor games libraries --enable <path>  (or --all)")
            return 1
        print("No games found.")
        return 0
-    new = set(result.new_appids)
+
-    print(f"{len(result.games)} game(s) across {len(selected)} librar(y/ies):\n")
+    new = set(result.new_appids) if result else set()
-    for g in result.games:
+    print(f"{len(all_games)} game(s):\n")
-        flag = " NEW" if g.appid in new else ""
+    for g in all_games:
-        print(f"  {g.name:<48} {steam.human_size(g.size_bytes):>9}{flag}")
+        tag = " NEW" if g.appid in new else ""
-    if new:
+        src = "" if g.launcher == "steam" else f"  [{g.launcher}]"
-        print(f"\n{len(new)} newly-installed since the last scan.")
+        size = steam.human_size(g.size_bytes) if g.size_bytes else ""
        print(f"  {g.name:<46}{src:<10} {size:>9}{tag}")
    if not selected:
        print("\n(no Steam libraries selected — `rigdoctor games libraries --all` to add them)")
    return 0
@@ -516,8 +538,9 @@ def build_parser() -> argparse.ArgumentParser:
    sp.add_argument("--json", action="store_true", help="output JSON instead of text")
    sp.set_defaults(func=cmd_snapshot)
-    mp = sub.add_parser("monitor", help="live-refreshing sensor view")
+    mp = sub.add_parser("monitor", help="live monitor TUI (current/min/max, M2)")
    mp.add_argument("-n", "--interval", type=float, default=None, help="refresh interval (s)")
    mp.add_argument("--plain", action="store_true", help="plain redraw instead of the curses UI")
    mp.set_defaults(func=cmd_monitor)
    sub.add_parser("gui", help="launch the desktop GUI (needs PySide6)").set_defaults(func=cmd_gui)
@@ -571,13 +594,6 @@ def build_parser() -> argparse.ArgumentParser:
    cp = sub.add_parser("collect-priv", help=argparse.SUPPRESS)  # internal: run via pkexec
    cp.set_defaults(func=cmd_collect_priv)
    share_p = sub.add_parser("share", help="session sharing (M12)")
    share_sub = share_p.add_subparsers(dest="share_cmd", required=True)
    serve_p = share_sub.add_parser("serve", help="serve a read-only live view (token-gated)")
    serve_p.add_argument("--host", default="127.0.0.1", help="bind address (use 0.0.0.0 + a tunnel for remote)")
    serve_p.add_argument("--port", type=int, default=8765, help="port")
    serve_p.set_defaults(func=cmd_share_serve)
    inv = sub.add_parser("inventory", help="system inventory (M5): export hardware/OS details")
    inv.add_argument("--json", action="store_true", help="output JSON")
    inv.add_argument("--markdown", action="store_true", help="output Markdown (for forum/bug reports)")
@@ -617,6 +633,18 @@ def build_parser() -> argparse.ArgumentParser:
    wrap_p.add_argument("command", nargs=argparse.REMAINDER,
                        help="the game command — use `rigdoctor wrap %%command%%` in Steam")
    wrap_p.set_defaults(func=cmd_wrap)
    watch_p = sub.add_parser("watch", help="auto-capture while a Steam game runs (game-launch trigger)")
    watch_p.add_argument("-n", "--interval", type=float, default=None, help="poll interval (s)")
    watch_p.set_defaults(func=cmd_watch)
    svc_p = sub.add_parser("service", help="crash-logger trigger mode + systemd --user service (M9/D6)")
    svc_sub = svc_p.add_subparsers(dest="service_cmd")
    svc_sub.add_parser("status", help="show the trigger mode and service state").set_defaults(func=cmd_service)
    mode_p = svc_sub.add_parser("mode", help="set the trigger mode")
    mode_p.add_argument("mode", choices=("manual", "always-on", "game-launch"))
    mode_p.set_defaults(func=cmd_service)
    svc_p.set_defaults(func=cmd_service, service_cmd=None)
    return p
@@ -154,6 +154,7 @@ DEFAULTS: dict = {
    "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
    "trigger_mode": "manual",     # crash-logger trigger (D6): manual | always-on | game-launch
 }
@@ -71,6 +71,32 @@ def check_pcie_aspm() -> list[Finding]:
 # --- NVIDIA persistence mode (seed-case relevant) -------------------------------------
 def check_gpu_powermizer() -> list[Finding]:
    """NVIDIA PowerMizer preferred-performance mode (X only, via nvidia-settings)."""
    if shutil.which("nvidia-settings") is None or not os.environ.get("DISPLAY"):
        return []
    try:
        proc = subprocess.run(
            ["nvidia-settings", "-q", "[gpu:0]/GPUPowerMizerMode", "-t"],
            capture_output=True, text=True, timeout=10,
        )
    except (subprocess.SubprocessError, OSError):
        return []
    raw = proc.stdout.strip().splitlines()[0].strip() if proc.stdout.strip() else ""
    if not raw.isdigit():  # no X target / Wayland / query failed — skip quietly
        return []
    names = {0: "Adaptive", 1: "Prefer Maximum Performance", 2: "Auto"}
    name = names.get(int(raw), f"mode {raw}")
    if int(raw) == 1:
        return [Finding(OK, "GPU", f"GPU PowerMizer: {name}", "The GPU prefers maximum performance.")]
    return [Finding(
        INFO, "GPU", f"GPU PowerMizer: {name}",
        "Adaptive/Auto can downclock the GPU between load spikes, hurting frame consistency.",
        "Prefer max performance (X only, resets on reboot): "
        "`nvidia-settings -a '[gpu:0]/GPUPowerMizerMode=1'`.",
    )]
 def check_gpu_persistence() -> list[Finding]:
    if shutil.which("nvidia-smi") is None:
        return []
@@ -235,6 +261,34 @@ def check_mitigations() -> list[Finding]:
 # --- Proton versions (informational) --------------------------------------------------
 def check_wine() -> list[Finding]:
    """System Wine version (used by Lutris / non-Proton games)."""
    if shutil.which("wine") is None:
        return []
    try:
        proc = subprocess.run(["wine", "--version"], capture_output=True, text=True, timeout=10)
    except (subprocess.SubprocessError, OSError):
        return []
    ver = proc.stdout.strip().split()[0] if proc.stdout.strip() else ""
    if not ver:
        return []
    return [Finding(
        INFO, "Tools", f"Wine: {ver}",
        "System Wine — used by Lutris and non-Proton titles.",
        "Steam games generally run best on Proton; keep Wine current for native/Lutris use.",
    )]
 def check_steam_client() -> list[Finding]:
    """Installed Steam client package version."""
    from . import steam
    ver = steam.client_version()
    if not ver:
        return []
    return [Finding(INFO, "Tools", f"Steam client: {ver}", "The installed Steam package version.")]
 def check_proton() -> list[Finding]:
    from . import steam
@@ -259,6 +313,7 @@ def run_gameenv_checks() -> list[Finding]:
    findings: list[Finding] = []
    findings += check_pcie_aspm()
    findings += check_gpu_persistence()
    findings += check_gpu_powermizer()
    findings += check_cpu_governor()
    findings += check_gamemode()
    findings += check_mangohud()
@@ -267,5 +322,7 @@ def run_gameenv_checks() -> list[Finding]:
    findings += check_thp()
    findings += check_mitigations()
    findings += check_proton()
    findings += check_wine()
    findings += check_steam_client()
    findings.sort(key=lambda f: _ORDER.get(f.severity, 9))
    return findings
@@ -0,0 +1,89 @@
 """Non-Steam game detection (M6): Lutris + Heroic installed games.
 Reads each launcher's own install records (Lutris' SQLite library, Heroic's JSON stores),
 returning the same `steam.Game` shape tagged with the launcher. Stdlib only; every reader
 degrades to [] if the launcher isn't installed or its files can't be parsed.
 """
 from __future__ import annotations
 import json
 import os
 import sqlite3
 from pathlib import Path
 from .steam import Game
 LUTRIS_DB = Path(os.path.expanduser("~/.local/share/lutris/pga.db"))
 HEROIC_DIR = Path(os.path.expanduser("~/.config/heroic"))
 def _lutris_games() -> list[Game]:
    db = LUTRIS_DB
    if not db.exists():
        return []
    games: list[Game] = []
    try:
        con = sqlite3.connect(f"file:{db}?mode=ro", uri=True)  # read-only
        try:
            rows = con.execute(
                "SELECT name, slug FROM games WHERE installed = 1 AND name IS NOT NULL"
            ).fetchall()
        finally:
            con.close()
    except (sqlite3.Error, OSError):
        return []
    for name, slug in rows:
        if name:
            games.append(Game(appid=slug or "", name=str(name), library="", installdir="",
                              launcher="lutris"))
    return games
 def _read_json(path: Path):
    try:
        return json.loads(path.read_text())
    except (OSError, ValueError):
        return None
 def _heroic_games() -> list[Game]:
    base = HEROIC_DIR
    if not base.is_dir():
        return []
    games: list[Game] = []
    # Epic / Legendary: {app_name: {"title": ..., ...}}
    epic = _read_json(base / "legendaryConfig" / "legendary" / "installed.json")
    if isinstance(epic, dict):
        for app_name, info in epic.items():
            if isinstance(info, dict):
                games.append(Game(appid=str(app_name), name=info.get("title") or str(app_name),
                                  library="", installdir="", launcher="heroic"))
    # GOG: {"installed": [{"appName", "install_path", "title"?}]}
    gog = _read_json(base / "gog_store" / "installed.json")
    entries = gog.get("installed") if isinstance(gog, dict) else None
    if isinstance(entries, list):
        for e in entries:
            if not isinstance(e, dict):
                continue
            install_path = e.get("install_path") or ""
            title = e.get("title") or os.path.basename(install_path.rstrip("/")) or str(e.get("appName", ""))
            if title:
                games.append(Game(appid=str(e.get("appName", "")), name=title, library="",
                                  installdir="", launcher="heroic"))
    return games
 def scan() -> list[Game]:
    """Installed non-Steam games (Lutris + Heroic), de-duplicated, sorted by name."""
    seen: set[tuple[str, str]] = set()
    out: list[Game] = []
    for game in _lutris_games() + _heroic_games():
        key = (game.launcher, game.name)
        if key in seen:
            continue
        seen.add(key)
        out.append(game)
    return sorted(out, key=lambda g: g.name.lower())
@@ -0,0 +1,118 @@
 """`systemd --user` services for the crash logger + game watcher (M9 / D6 trigger modes).
 Three trigger modes (D6): **manual** (no service — start/stop by hand), **always-on** (a user
 service samples continuously, bounded by log rotation), and **game-launch** (a watcher service
 auto-brackets a capture around each game). No root: everything is a `systemd --user` unit in
 ``~/.config/systemd/user``. Degrades gracefully when systemd isn't available.
 """
 from __future__ import annotations
 import os
 import shutil
 import subprocess
 import sys
 from pathlib import Path
 from .. import config
 UNIT_DIR = Path(os.path.expanduser("~/.config/systemd/user"))
 RECORDER_UNIT = "rigdoctor-recorder.service"
 WATCH_UNIT = "rigdoctor-watch.service"
 MODES = ("manual", "always-on", "game-launch")
 _UNITS = {
    RECORDER_UNIT: ("RigDoctor crash-capture recorder (always-on)", ["record", "run"]),
    WATCH_UNIT: ("RigDoctor game-launch watcher", ["watch"]),
 }
 def available() -> bool:
    return shutil.which("systemctl") is not None
 def _rigdoctor_bin() -> str:
    exe = Path(sys.executable).with_name("rigdoctor")  # next to the venv python
    if exe.exists():
        return str(exe)
    return shutil.which("rigdoctor") or "rigdoctor"
 def _systemctl(*args: str) -> tuple[int, str]:
    try:
        proc = subprocess.run(["systemctl", "--user", *args],
                              capture_output=True, text=True, timeout=20)
        return proc.returncode, (proc.stdout + proc.stderr).strip()
    except (OSError, subprocess.SubprocessError) as exc:
        return 1, str(exc)
 def unit_text(description: str, args: list[str]) -> str:
    exec_cmd = " ".join([_rigdoctor_bin(), *args])
    return (
        "[Unit]\n"
        f"Description={description}\n\n"
        "[Service]\n"
        "Type=simple\n"
        f"ExecStart={exec_cmd}\n"
        "Restart=on-failure\n"
        "RestartSec=5\n\n"
        "[Install]\n"
        "WantedBy=default.target\n"
    )
 def install_units() -> None:
    """Write/refresh both unit files and reload systemd (idempotent)."""
    UNIT_DIR.mkdir(parents=True, exist_ok=True)
    for name, (desc, args) in _UNITS.items():
        (UNIT_DIR / name).write_text(unit_text(desc, args))
    _systemctl("daemon-reload")
 def is_active(name: str) -> bool:
    return _systemctl("is-active", name)[0] == 0
 def is_enabled(name: str) -> bool:
    return _systemctl("is-enabled", name)[0] == 0
 def _enable(name: str) -> tuple[int, str]:
    return _systemctl("enable", "--now", name)
 def _disable(name: str) -> tuple[int, str]:
    return _systemctl("disable", "--now", name)
 def apply_mode(mode: str) -> tuple[bool, str]:
    """Reconcile the user services to `mode` and persist it. Returns (ok, message)."""
    if mode not in MODES:
        return False, f"Unknown trigger mode: {mode}"
    if not available():
        config.update_config(trigger_mode=mode)
        return False, "systemd --user isn't available — mode saved, but no service was changed."
    install_units()
    if mode == "always-on":
        _disable(WATCH_UNIT)
        rc, out = _enable(RECORDER_UNIT)
    elif mode == "game-launch":
        _disable(RECORDER_UNIT)
        rc, out = _enable(WATCH_UNIT)
    else:  # manual
        _disable(RECORDER_UNIT)
        _disable(WATCH_UNIT)
        rc, out = 0, ""
    config.update_config(trigger_mode=mode)
    return rc == 0, out
 def status() -> dict:
    """Current trigger mode (config) + live service states (best-effort)."""
    cfg = config.load_config()
    info = {"available": available(), "mode": cfg.get("trigger_mode", "manual")}
    if info["available"]:
        info["recorder_active"] = is_active(RECORDER_UNIT)
        info["watch_active"] = is_active(WATCH_UNIT)
    return info
@@ -1,194 +0,0 @@
 """Session sharing (M12, Tier 2): a read-only live view over a local HTTP server.
 Serves the live sensor snapshot + health report + inventory, **read-only**, gated by a
 random share token. Bind to localhost for local testing, or to all interfaces behind a
 user-chosen tunnel (Tailscale / cloudflared / SSH) for remote help. No actions, no terminal.
 """
 from __future__ import annotations
 import json
 import secrets
 from dataclasses import asdict
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import parse_qs, urlparse
 from .sampler import Sampler
 from .sources import available_sources
 _PAGE = """<!doctype html>
 <html><head><meta charset="utf-8"><title>RigDoctor — shared</title>
 <style>
 body{background:#101216;color:#e6e8eb;font-family:system-ui,sans-serif;margin:0;padding:24px}
 h1{font-size:20px;margin:0 0 4px} h2{font-size:14px;color:#8b929c;margin:18px 0 6px}
 .card{background:#1b1f26;border:1px solid #2a2f39;border-radius:12px;padding:16px;margin:14px 0}
 table{width:100%;border-collapse:collapse} td{padding:3px 0;font-size:14px}
 td.v{text-align:right;font-weight:600} .muted{color:#8b929c}
 .critical{color:#f87171} .warning{color:#fb923c} .ok{color:#4ade80} .info{color:#8b929c}
 .badge{display:inline-block;background:#38bdf8;color:#06222e;border-radius:6px;padding:1px 8px;font-size:12px;font-weight:700}
 </style></head><body>
 <h1>RigDoctor <span class="badge">read-only share</span></h1>
 <p class="muted">A live view shared by the machine's owner. You can look, not change anything.</p>
 <div class="card"><div id="live">loading…</div></div>
 <div class="card"><h2 style="margin-top:0">Health</h2><div id="health">loading…</div></div>
 <div class="card"><h2 style="margin-top:0">Inventory</h2><div id="inv">loading…</div></div>
 <script>
 const T=new URLSearchParams(location.search).get('t');
 const j=async p=>(await fetch(p+'?t='+encodeURIComponent(T))).json();
 const fmt=(v,u)=>v==null?'N/A':(u==='\\u00b0C'?(+v).toFixed(1)+' °C':(u?v+' '+u:v));
 async function live(){try{const d=await j('/api/snapshot');let h='';
  for(const[g,items]of Object.entries(d.groups)){h+='<h2>'+g.toUpperCase()+'</h2><table>';
   for(const it of items)h+='<tr><td class="muted">'+it.name+'</td><td class="v">'+fmt(it.value,it.unit)+'</td></tr>';
   h+='</table>';}document.getElementById('live').innerHTML=h;}catch(e){}}
 async function once(){try{const r=await j('/api/report');
   document.getElementById('health').innerHTML=r.map(f=>'<div><span class="'+f.severity+'">['+f.severity.toUpperCase()+']</span> '+f.category+': '+f.title+'</div>').join('')||'no findings';}catch(e){}
  try{const inv=await j('/api/inventory');let h='';
   for(const[s,kv]of Object.entries(inv)){h+='<h2>'+s+'</h2><table>';
    for(const[k,v]of Object.entries(kv))h+='<tr><td class="muted">'+k+'</td><td class="v">'+v+'</td></tr>';
    h+='</table>';}document.getElementById('inv').innerHTML=h;}catch(e){}}
 live();once();setInterval(live,2000);
 </script></body></html>"""
 def _snapshot(sampler: Sampler) -> dict:
    sample = sampler.sample()
    groups: dict[str, list] = {}
    for r in sample.readings:
        if r.metric == "name":
            item = {"name": "device", "value": r.label, "unit": ""}
        else:
            item = {"name": (r.label + " " + r.metric).strip() if r.label else r.metric,
                    "value": r.value, "unit": r.unit}
        groups.setdefault(r.source, []).append(item)
    return {"ts": sample.ts, "groups": groups}
 def _report() -> list:
    from .health import run_health_checks
    return [asdict(f) for f in run_health_checks()]
 def _inventory() -> dict:
    from .inventory import collect, to_dict
    return to_dict(collect())
 # --- Relay (M12) frames: a host streams these; a guest renders them. -----------------
 def host_full_frame(sampler: Sampler) -> str:
    """Initial frame: live snapshot + health report + inventory."""
    return json.dumps({"type": "full", "snapshot": _snapshot(sampler),
                       "report": _report(), "inventory": _inventory()})
 def host_snapshot_frame(sampler: Sampler) -> str:
    """Recurring frame: just the live snapshot."""
    return json.dumps({"type": "snapshot", "snapshot": _snapshot(sampler)})
 def _fmt(value, unit: str) -> str:
    if value is None:
        return "N/A"
    if unit == "°C":
        try:
            return f"{float(value):.1f} °C"
        except (TypeError, ValueError):
            return str(value)
    return f"{value} {unit}".strip()
 def guest_html(snapshot: dict | None, report: list | None, inventory: dict | None) -> str:
    """Render a received frame as read-only dark HTML for the guest's view."""
    import html as _html
    def esc(x) -> str:
        return _html.escape(str(x))
    out = ['<div style="font-family:sans-serif;color:#e6e8eb">']
    if snapshot:
        for group, items in snapshot.get("groups", {}).items():
            out.append(f'<h3 style="color:#8b929c">{esc(group).upper()}</h3><table width="100%">')
            for it in items:
                out.append(f'<tr><td style="color:#8b929c">{esc(it.get("name"))}</td>'
                           f'<td align="right"><b>{esc(_fmt(it.get("value"), it.get("unit", "")))}</b></td></tr>')
            out.append("</table>")
    if report:
        out.append('<h3 style="color:#8b929c">HEALTH</h3>')
        colors = {"critical": "#f87171", "warning": "#fb923c", "ok": "#4ade80"}
        for f in report:
            sev = f.get("severity", "info")
            out.append(f'<div><span style="color:{colors.get(sev, "#8b929c")}">[{esc(sev).upper()}]</span> '
                       f'{esc(f.get("category"))}: {esc(f.get("title"))}</div>')
    if inventory:
        out.append('<h3 style="color:#8b929c">INVENTORY</h3>')
        for section, kv in inventory.items():
            out.append(f'<h4 style="margin:6px 0;color:#8b929c">{esc(section)}</h4><table width="100%">')
            for k, v in kv.items():
                out.append(f'<tr><td style="color:#8b929c">{esc(k)}</td><td align="right"><b>{esc(v)}</b></td></tr>')
            out.append("</table>")
    out.append("</div>")
    return "".join(out)
 class _Handler(BaseHTTPRequestHandler):
    def log_message(self, *args):  # quiet
        pass
    def _authed(self, query: dict) -> bool:
        return secrets.compare_digest(query.get("t", [""])[0], self.server.token)
    def _send(self, code: int, ctype: str, body: bytes) -> None:
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)
    def do_GET(self) -> None:  # noqa: N802
        parsed = urlparse(self.path)
        if not self._authed(parse_qs(parsed.query)):
            self._send(403, "text/plain", b"Forbidden: missing or invalid share token")
            return
        if parsed.path == "/":
            self._send(200, "text/html; charset=utf-8", _PAGE.encode())
        elif parsed.path == "/api/snapshot":
            self._send(200, "application/json", json.dumps(_snapshot(self.server.sampler)).encode())
        elif parsed.path == "/api/report":
            self._send(200, "application/json", json.dumps(_report()).encode())
        elif parsed.path == "/api/inventory":
            self._send(200, "application/json", json.dumps(_inventory()).encode())
        else:
            self._send(404, "text/plain", b"Not found")
 class _Server(ThreadingHTTPServer):
    daemon_threads = True
    def __init__(self, addr, token: str):
        super().__init__(addr, _Handler)
        self.token = token
        self.sampler = Sampler(available_sources())
 def make_server(host: str = "127.0.0.1", port: int = 0, token: str | None = None) -> tuple[_Server, str]:
    token = token or secrets.token_urlsafe(16)
    return _Server((host, port), token), token
 def serve(host: str = "127.0.0.1", port: int = 8765) -> int:
    srv, token = make_server(host, port)
    url = f"http://{host}:{srv.server_address[1]}/?t={token}"
    print(
        f"Sharing a read-only live view at:\n  {url}\n\n"
        "Anyone with this URL (and network access to this host) can VIEW your sensors,\n"
        "health report, and inventory — read-only. For remote help, expose it via a tunnel\n"
        "(Tailscale / cloudflared / `ssh -R`). Press Ctrl-C to stop sharing.",
        flush=True,
    )
    try:
        srv.serve_forever()
    except KeyboardInterrupt:
        print("\nStopped sharing.")
    finally:
        srv.shutdown()
    return 0
@@ -58,10 +58,11 @@ class SteamLibrary:
 class Game:
    appid: str
    name: str
-    library: str       # library path the game lives in
+    library: str       # library path the game lives in (Steam)
    installdir: str    # folder name under <library>/steamapps/common
    size_bytes: int = 0
    last_updated: int = 0  # epoch seconds (acf LastUpdated), 0 if unknown
    launcher: str = "steam"  # "steam" | "lutris" | "heroic"
 # --- VDF (Valve Data Format) parsing --------------------------------------------------
@@ -313,7 +314,8 @@ def cached_games() -> list[Game]:
    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", [])]
+    # Only pass keys present in the record so dataclass defaults fill any new fields.
    return [Game(**{k: g[k] for k in Game.__dataclass_fields__ if k in g}) for g in cache.get("games", [])]
 def rescan(cfg: dict | None = None) -> ScanResult:
@@ -353,6 +355,21 @@ def acknowledge_new() -> None:
 # --- formatting -----------------------------------------------------------------------
 def client_version() -> str | None:
    """The installed Steam package version (apt), or None — best-effort, offline."""
    if shutil.which("dpkg-query") is None:
        return None
    for pkg in ("steam-installer", "steam-launcher", "steam"):
        try:
            proc = subprocess.run(["dpkg-query", "-W", "-f=${Version}", pkg],
                                  capture_output=True, text=True, timeout=10)
        except (subprocess.SubprocessError, OSError):
            continue
        if proc.returncode == 0 and proc.stdout.strip():
            return proc.stdout.strip()
    return None
 def launch_game(appid: str) -> bool:
    """Best-effort: ask Steam to launch a game by appid (steam:// URL). Non-blocking."""
    if not appid:
@@ -0,0 +1,107 @@
 """Zero-config game-launch watcher (D12 fallback): poll Steam's RunningAppID and
 auto-bracket a focused capture around the running game.
 For users who won't add the `rigdoctor wrap %command%` launch option. Less precise than the
 wrapper (it depends on Steam writing RunningAppID to registry.vdf, and only covers Steam), so
 the wrapper stays the primary mechanism. Stdlib only; safe to run as a `systemd --user` service
 (the game-launch trigger mode).
 """
 from __future__ import annotations
 import os
 import signal
 import time
 from pathlib import Path
 from . import reccontrol, steam
 from .steam import _parse_vdf
 _REGISTRY_CANDIDATES = ("~/.steam/registry.vdf", "~/.steam/steam/registry.vdf")
 def _registry_path() -> Path | None:
    for cand in _REGISTRY_CANDIDATES:
        p = Path(os.path.expanduser(cand))
        if p.exists():
            return p
    return None
 def _find_key(data: dict, key: str):
    """Recursively find a (case-insensitive) scalar key in nested VDF dicts."""
    target = key.lower()
    for k, v in data.items():
        if isinstance(v, dict):
            found = _find_key(v, key)
            if found is not None:
                return found
        elif k.lower() == target:
            return v
    return None
 def running_appid() -> int:
    """The Steam appid currently running (0 if none / unknown)."""
    path = _registry_path()
    if path is None:
        return 0
    try:
        data = _parse_vdf(path.read_text(encoding="utf-8", errors="replace"))
    except OSError:
        return 0
    raw = _find_key(data, "RunningAppID")
    try:
        return int(raw)
    except (TypeError, ValueError):
        return 0
 def transition(prev: int, current: int) -> str | None:
    """'start' when a game begins, 'stop' when it ends, else None."""
    if current and not prev:
        return "start"
    if prev and not current:
        return "stop"
    return None
 def _name_for(appid: int) -> str:
    target = str(appid)
    for g in steam.cached_games() or steam.scan_games(steam.selected_library_paths()):
        if g.appid == target:
            return g.name
    return f"Steam app {appid}"
 def watch(interval: float = 5.0) -> int:
    """Poll for a running Steam game and bracket a capture around it. Blocks until signalled."""
    from . import diagnostic
    stop = {"flag": False}
    def _on_signal(_sig, _frame):
        stop["flag"] = True
    signal.signal(signal.SIGTERM, _on_signal)
    signal.signal(signal.SIGINT, _on_signal)
    prev = 0
    started = False
    while not stop["flag"]:
        current = running_appid()
        action = transition(prev, current)
        if action == "start" and not reccontrol.running_pid():
            started = diagnostic.start(game=_name_for(current)) is not None
        elif action == "stop" and started:
            reccontrol.stop_background()
            started = False
        prev = current
        # Sleep in small slices so a stop signal is handled promptly.
        slept = 0.0
        while slept < interval and not stop["flag"]:
            time.sleep(min(0.25, interval - slept))
            slept += 0.25
    if started:
        reccontrol.stop_background()
    return 0
@@ -30,7 +30,13 @@ def main(argv: list[str] | None = None) -> int:
    interval = float(load_config().get("interval", 1.0))
    window = MainWindow(interval=interval)
-    window.show()
+    # `--tray` starts hidden to the system tray (for autostart); if no tray is available,
    # fall back to showing the window so the app is never invisible-and-unreachable.
    args = argv if argv is not None else sys.argv
    if "--tray" in args and window.tray_available():
        window.start_minimized_note()
    else:
        window.show()
    return app.exec()
@@ -46,7 +46,7 @@ class EnvironmentPage(QWidget):
        root.setSpacing(16)
        header = QHBoxLayout()
-        title = QLabel("Environment")
+        title = QLabel("Tuning")
        title.setObjectName("PageTitle")
        header.addWidget(title)
        header.addStretch(1)
@@ -88,6 +88,7 @@ class GamesPage(QWidget):
        self._diag_done.connect(self._on_diag_done)
        self._busy = False
        self._new_appids: set[str] = set()
        self._extra_games: list = []  # non-Steam (Lutris/Heroic), appended after a scan
        self._diag_game: str | None = None
        root = QVBoxLayout(self)
@@ -213,7 +214,7 @@ class GamesPage(QWidget):
        threading.Thread(target=self._work, daemon=True).start()
    def _work(self) -> None:
-        from ..core import steam
+        from ..core import launchers, steam
        try:
            selected = {os.path.realpath(p) for p in steam.selected_library_paths()}
@@ -223,6 +224,10 @@ class GamesPage(QWidget):
                for lib in steam.discover_libraries()
            ]
            self._libraries_ready.emit(libs)
            try:
                self._extra_games = launchers.scan()  # Lutris / Heroic (non-Steam)
            except Exception:
                self._extra_games = []
            self._scanned.emit(steam.rescan())
        except Exception:
            self._scanned.emit(None)
@@ -265,11 +270,13 @@ class GamesPage(QWidget):
            self._status.setText("scan failed")
            return
        self._new_appids = set(result.new_appids)
-        self._populate_games(result.games, self._new_appids)
+        games = list(result.games) + list(self._extra_games)
        self._populate_games(games, self._new_appids)
        new = len(self._new_appids)
        suffix = f"  ·  {new} new" if new else ""
        non_steam = f"  ·  {len(self._extra_games)} non-Steam" if self._extra_games else ""
        self._status.setText(
-            f"{len(result.games)} games  ·  {time.strftime('%H:%M:%S')}{suffix}"
+            f"{len(games)} games  ·  {time.strftime('%H:%M:%S')}{suffix}{non_steam}"
        )
        self.new_count_changed.emit(new)
@@ -293,12 +300,17 @@ class GamesPage(QWidget):
            return
        for g in games:
            launcher = getattr(g, "launcher", "steam")
            if launcher != "steam":
                sublabel, appid = launcher.title(), ""  # non-Steam: can't steam:// launch it
            else:
                sublabel, appid = (os.path.basename(g.library.rstrip("/")) or g.library), g.appid
            self._list.addWidget(_game_row(
                g.name,
-                os.path.basename(g.library.rstrip("/")) or g.library,
+                sublabel,
                steam.human_size(g.size_bytes),
                g.appid in new_appids,
-                appid=g.appid,
+                appid=appid,
                on_diagnose=self._start_diagnostic,
            ))
        self._list.addStretch(1)
@@ -32,7 +32,7 @@ class HealthPage(QWidget):
        root.setSpacing(16)
        header = QHBoxLayout()
-        title = QLabel("Health")
+        title = QLabel("System Health")
        title.setObjectName("PageTitle")
        header.addWidget(title)
        header.addStretch(1)
@@ -6,9 +6,10 @@ import html
 import os
 import sys
 import threading
 from pathlib import Path
 from PySide6.QtCore import Qt, QProcess, QTimer, Signal
-from PySide6.QtGui import QTextDocument
+from PySide6.QtGui import QIcon, QTextDocument
 from PySide6.QtWidgets import (
    QApplication,
    QButtonGroup,
@@ -20,6 +21,7 @@ from PySide6.QtWidgets import (
    QMessageBox,
    QPushButton,
    QStackedWidget,
    QSystemTrayIcon,
    QTextEdit,
    QVBoxLayout,
    QWidget,
@@ -33,14 +35,23 @@ from .environment_page import EnvironmentPage
 from .games_page import GamesPage
 from .health_page import HealthPage
 from .inventory_page import InventoryPage
 from .notifications_page import NotificationsPage
 from .recorder_page import RecorderPage
 from .setup_page import SetupPage
 from .share_page import SharePage
 from .theme import ACCENT, CRIT, GOOD, MUTED, TEXT
 from .tray import TrayIcon
 from .worker import SamplerWorker
-_NAV_ITEMS = ["Dashboard", "Logs", "Health", "Games", "Environment", "Inventory", "Setup", "Notifications", "Share"]
+# Sidebar grouped by intent. Each page name maps to a widget built in __init__; the stack is
 # filled in this order, so _PAGES.index(name) is the stack index.
 _NAV = [
    ("Monitor", ["Dashboard"]),
    ("Diagnose", ["Games", "Recordings", "System Health", "Tuning"]),
    ("System", ["Inventory"]),
    ("App", ["Settings", "Share"]),
 ]
 _PAGES = [name for _section, names in _NAV for name in names]
 _ICON = Path(__file__).parent / "assets" / "rigdoctor.svg"
 class MainWindow(QMainWindow):
@@ -75,18 +86,21 @@ class MainWindow(QMainWindow):
        self.environment_page = EnvironmentPage()
        self.inventory_page = InventoryPage()
        self.setup_page = SetupPage()
-        self.notifications_page = NotificationsPage()
+        self.setup_page.changed.connect(self._apply_alert_settings)
        self.notifications_page.changed.connect(self._apply_alert_settings)
        self.share_page = SharePage()
-        self._stack.addWidget(self.dashboard)            # 0 Dashboard
+        # Page name → widget; the stack is filled in _PAGES order so indices line up.
-        self._stack.addWidget(self.recorder_page)        # 1 Logs
+        self._pages = {
-        self._stack.addWidget(self.health_page)          # 2 Health
+            "Dashboard": self.dashboard,
-        self._stack.addWidget(self.games_page)           # 3 Games
+            "Games": self.games_page,
-        self._stack.addWidget(self.environment_page)     # 4 Environment
+            "Recordings": self.recorder_page,
-        self._stack.addWidget(self.inventory_page)       # 5 Inventory
+            "System Health": self.health_page,
-        self._stack.addWidget(self.setup_page)           # 6 Setup
+            "Tuning": self.environment_page,
-        self._stack.addWidget(self.notifications_page)   # 7 Notifications
+            "Inventory": self.inventory_page,
-        self._stack.addWidget(self.share_page)           # 8 Share
+            "Settings": self.setup_page,
            "Share": self.share_page,
        }
        for name in _PAGES:
            self._stack.addWidget(self._pages[name])
        content_layout.addWidget(self._stack)
        layout.addWidget(self._build_sidebar())
@@ -136,6 +150,22 @@ class MainWindow(QMainWindow):
        self._rec_timer.start()
        self._update_recording()
        # System-tray applet (M11) — optional; only when the desktop offers a tray. When
        # present, closing the window hides to the tray instead of quitting.
        self._tray = None
        self._quitting = False
        self._tray_hint_shown = False
        if QSystemTrayIcon.isSystemTrayAvailable():
            icon = self.windowIcon() if not self.windowIcon().isNull() else QIcon(str(_ICON))
            self._tray = TrayIcon(
                self, icon,
                gpu_alert=float(cfg.get("gpu_temp_alert", 90.0)),
                cpu_alert=float(cfg.get("cpu_temp_alert", 95.0)),
            )
            self._worker.sampled.connect(self._tray.update_sample)
            self._tray.show()
            QApplication.instance().setQuitOnLastWindowClosed(False)
    def _build_sidebar(self) -> QFrame:
        bar = QFrame()
        bar.setObjectName("Sidebar")
@@ -166,16 +196,22 @@ class MainWindow(QMainWindow):
        group = QButtonGroup(self)
        group.setExclusive(True)
        self._nav_buttons: dict[str, QPushButton] = {}
-        for i, name in enumerate(_NAV_ITEMS):
+        for section, names in _NAV:
-            btn = QPushButton(name)
+            header = QLabel(section.upper())
-            btn.setObjectName("NavButton")
+            header.setObjectName("NavSection")
-            btn.setCheckable(True)
+            v.addSpacing(8)
-            btn.setCursor(Qt.CursorShape.PointingHandCursor)
+            v.addWidget(header)
-            btn.setChecked(i == 0)
+            for name in names:
-            btn.clicked.connect(lambda _checked, idx=i: self._stack.setCurrentIndex(idx))
+                idx = _PAGES.index(name)
-            group.addButton(btn, i)
+                btn = QPushButton(name)
-            v.addWidget(btn)
+                btn.setObjectName("NavButton")
-            self._nav_buttons[name] = btn
+                btn.setCheckable(True)
                btn.setCursor(Qt.CursorShape.PointingHandCursor)
                btn.setChecked(idx == 0)
                btn.clicked.connect(lambda _checked, i=idx: self._stack.setCurrentIndex(i))
                group.addButton(btn, idx)
                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>')
@@ -262,8 +298,46 @@ class MainWindow(QMainWindow):
        self.health_page._run()
        self.inventory_page._run()
    # --- tray-driven actions (M11) ----------------------------------------------------
    def show_page(self, name: str) -> None:
        """Bring the window forward on a given page (used by the tray)."""
        if name in self._nav_buttons:
            self._stack.setCurrentIndex(_PAGES.index(name))
            self._nav_buttons[name].setChecked(True)
        self.showNormal()
        self.raise_()
        self.activateWindow()
    def show_dashboard(self) -> None:
        self.show_page("Dashboard")
    def tray_available(self) -> bool:
        return self._tray is not None
    def start_minimized_note(self) -> None:
        """Started hidden to the tray (autostart) — let the user know it's there."""
        if self._tray is not None:
            self._tray_hint_shown = True
            self._tray.showMessage(
                "RigDoctor", "Running in the tray — right-click the icon for actions.",
                QSystemTrayIcon.MessageIcon.Information, 4000,
            )
    def run_diagnostic(self, name: str, appid: str) -> None:
        self.show_page("Games")
        self.games_page._start_diagnostic(name, appid)
    def quit_app(self) -> None:
        self._quitting = True
        self._worker.stop()
        self.share_page.shutdown()
        if self._tray is not None:
            self._tray.hide()
        QApplication.instance().quit()
    def _update_recording(self) -> None:
-        from .core import diagnostic
+        from ..core import diagnostic
        status = diagnostic.active()
        if not status:
@@ -359,6 +433,19 @@ class MainWindow(QMainWindow):
            self._update_label.setText("up-to-date")
    def closeEvent(self, event) -> None:  # noqa: N802 (Qt override)
        # With a tray, closing the window hides it (the app keeps running for the tray
        # readouts + any capture); Quit from the tray menu exits for real.
        if self._tray is not None and not self._quitting:
            event.ignore()
            self.hide()
            if not self._tray_hint_shown:
                self._tray_hint_shown = True
                self._tray.showMessage(
                    "RigDoctor",
                    "Still running in the tray — right-click the icon for actions or Quit.",
                    QSystemTrayIcon.MessageIcon.Information, 5000,
                )
            return
        self._worker.stop()
        self.share_page.shutdown()
        super().closeEvent(event)
@@ -1,108 +0,0 @@
 """Notifications page (M8 config): user-configurable alert settings."""
 from __future__ import annotations
 from PySide6.QtCore import Qt, Signal
 from PySide6.QtWidgets import (
    QCheckBox,
    QDoubleSpinBox,
    QFrame,
    QGridLayout,
    QHBoxLayout,
    QLabel,
    QPushButton,
    QVBoxLayout,
    QWidget,
 )
 from ..config import load_config, update_config
 from ..core import alerts
 class NotificationsPage(QWidget):
    changed = Signal()  # settings saved — main window re-applies them live
    def __init__(self) -> None:
        super().__init__()
        self.setObjectName("Page")
        root = QVBoxLayout(self)
        root.setContentsMargins(20, 18, 20, 18)
        root.setSpacing(16)
        title = QLabel("Notifications")
        title.setObjectName("PageTitle")
        root.addWidget(title)
        card = QFrame()
        card.setObjectName("Card")
        v = QVBoxLayout(card)
        v.setContentsMargins(16, 14, 16, 14)
        v.setSpacing(10)
        head = QLabel("Alerts")
        head.setStyleSheet("font-weight: 700; background: transparent;")
        v.addWidget(head)
        self._enabled = QCheckBox("Enable desktop notifications")
        v.addWidget(self._enabled)
        grid = QGridLayout()
        grid.setHorizontalSpacing(12)
        grid.setColumnStretch(2, 1)
        self._gpu = self._spin()
        self._cpu = self._spin()
        grid.addWidget(QLabel("GPU temperature alert"), 0, 0)
        grid.addWidget(self._gpu, 0, 1)
        grid.addWidget(QLabel("CPU temperature alert"), 1, 0)
        grid.addWidget(self._cpu, 1, 1)
        v.addLayout(grid)
        note = QLabel("GPU-lost and new-version alerts are included whenever notifications are enabled.")
        note.setObjectName("Muted")
        note.setWordWrap(True)
        v.addWidget(note)
        buttons = QHBoxLayout()
        save = QPushButton("Save")
        save.setObjectName("PrimaryButton")
        save.clicked.connect(self._save)
        test = QPushButton("Send test")
        test.clicked.connect(self._test)
        buttons.addWidget(save)
        buttons.addWidget(test)
        buttons.addStretch(1)
        v.addLayout(buttons)
        self._status = QLabel("")
        self._status.setObjectName("Muted")
        v.addWidget(self._status)
        root.addWidget(card)
        root.addStretch(1)
        self._load()
    @staticmethod
    def _spin() -> QDoubleSpinBox:
        spin = QDoubleSpinBox()
        spin.setRange(40, 110)
        spin.setDecimals(0)
        spin.setSingleStep(1)
        spin.setSuffix(" °C")
        return spin
    def _load(self) -> None:
        cfg = load_config()
        self._enabled.setChecked(bool(cfg.get("alerts_enabled", True)))
        self._gpu.setValue(float(cfg.get("gpu_temp_alert", 90.0)))
        self._cpu.setValue(float(cfg.get("cpu_temp_alert", 95.0)))
    def _save(self) -> None:
        update_config(
            alerts_enabled=self._enabled.isChecked(),
            gpu_temp_alert=self._gpu.value(),
            cpu_temp_alert=self._cpu.value(),
        )
        self.changed.emit()
        self._status.setText("Saved.")
    def _test(self) -> None:
        ok = alerts.notify("RigDoctor", "Test notification — alerts are working.")
        self._status.setText("Test notification sent." if ok else "notify-send not found — install libnotify-bin (Setup).")
@@ -1,16 +1,19 @@
-"""Recording & Logs page (M3 in the GUI): start/stop/status + post-crash report.
+"""Recordings page (M3 in the GUI): recorder controls + view/report any captured log.
-Drives the same background recorder as the CLI via core.reccontrol, so the GUI and
+Drives the same background recorder as the CLI via core.reccontrol, and surfaces the
-`rigdoctor record …` are interchangeable.
+captured data — the always-on log, the last guided diagnostic, and a preserved hard-crash
 (which can be analyzed in place). One place to see what was captured and what it means.
 """
 from __future__ import annotations
 import threading
 import time
-from PySide6.QtCore import Qt, QTimer, QUrl
+from PySide6.QtCore import Qt, QTimer, QUrl, Signal
 from PySide6.QtGui import QDesktopServices, QFont
 from PySide6.QtWidgets import (
    QComboBox,
    QDoubleSpinBox,
    QFrame,
    QHBoxLayout,
@@ -25,6 +28,7 @@ from .. import config
 from ..core import reccontrol
 from ..core.crashlog import summarize
 from ..render import format_headline, render_summary
 from .diagnostic_dialog import DiagnosticDialog
 from .theme import GOOD, MUTED, WARN
@@ -45,31 +49,30 @@ def _fmt_time(value, fmt="%Y-%m-%d %H:%M:%S") -> str:
 class RecorderPage(QWidget):
    _analyzed = Signal(object)  # DiagnosticResult from a crash analysis
    def __init__(self) -> None:
        super().__init__()
        self.setObjectName("Page")
        self._analyzed.connect(self._show_analysis)
        root = QVBoxLayout(self)
        root.setContentsMargins(20, 18, 20, 18)
        root.setSpacing(16)
-        title = QLabel("Recording")
+        title = QLabel("Recordings")
        title.setObjectName("PageTitle")
        root.addWidget(title)
        # --- Status + controls -------------------------------------------------
        status_card, status_layout = _panel("Status")
        self._state = QLabel("○ Not recording")
        self._state.setStyleSheet(f"color: {MUTED}; font-weight: 700; background: transparent;")
        status_layout.addWidget(self._state)
        self._info = QLabel("")
        self._info.setObjectName("Muted")
        status_layout.addWidget(self._info)
        self._latest = QLabel("")
        status_layout.addWidget(self._latest)
        self._warn = QLabel("")
        self._warn.setStyleSheet(f"color: {WARN}; font-weight: 600; background: transparent;")
        self._warn.setVisible(False)
@@ -97,19 +100,20 @@ class RecorderPage(QWidget):
        status_layout.addLayout(controls)
        root.addWidget(status_card)
-        # --- Report ------------------------------------------------------------
+        # --- Captured logs -----------------------------------------------------
-        report_card = QFrame()
+        report_card, report_layout = _panel("Captured logs")
        report_card.setObjectName("Card")
        report_layout = QVBoxLayout(report_card)
        report_layout.setContentsMargins(16, 14, 16, 14)
        report_layout.setSpacing(10)
        header = QHBoxLayout()
-        report_title = QLabel("Post-crash report")
+        header.addWidget(QLabel("Show:"))
-        report_title.setStyleSheet("font-weight: 700; background: transparent;")
+        self._source = QComboBox()
-        header.addWidget(report_title)
+        self._source.currentIndexChanged.connect(self._load_report)
-        header.addStretch(1)
+        header.addWidget(self._source, 1)
        self._analyze_btn = QPushButton("Analyze crash")
        self._analyze_btn.setObjectName("ActionButton")
        self._analyze_btn.clicked.connect(self._analyze_crash)
        self._analyze_btn.setVisible(False)
        header.addWidget(self._analyze_btn)
        refresh_btn = QPushButton("Refresh")
-        refresh_btn.clicked.connect(self._load_report)
+        refresh_btn.clicked.connect(self._refresh_sources)
        header.addWidget(refresh_btn)
        report_layout.addLayout(header)
@@ -121,13 +125,12 @@ class RecorderPage(QWidget):
        report_layout.addWidget(self._report)
        root.addWidget(report_card, 1)
        # Poll recorder status once a second (reflects CLI-driven sessions too).
        self._timer = QTimer(self)
        self._timer.setInterval(1000)
        self._timer.timeout.connect(self._refresh_status)
        self._timer.start()
        self._refresh_status()
-        self._load_report()
+        self._refresh_sources()
    # --- actions ---------------------------------------------------------------
    def _on_start(self) -> None:
@@ -139,12 +142,56 @@ class RecorderPage(QWidget):
        self._stop_btn.setEnabled(False)
        reccontrol.stop_background()
        QTimer.singleShot(600, self._refresh_status)
-        QTimer.singleShot(900, self._load_report)
+        QTimer.singleShot(900, self._refresh_sources)
    def _open_folder(self) -> None:
        config.LOG_DIR.mkdir(parents=True, exist_ok=True)
        QDesktopServices.openUrl(QUrl.fromLocalFile(str(config.LOG_DIR)))
    # --- captured logs ---------------------------------------------------------
    def _refresh_sources(self) -> None:
        from ..core import diagnostic
        current = self._source.currentData()
        self._source.blockSignals(True)
        self._source.clear()
        self._source.addItem("Always-on capture", str(config.LOG_FILE))
        if config.DIAG_LOG.exists():
            self._source.addItem("Last diagnostic", str(config.DIAG_LOG))
        if config.DIAG_CRASH.exists():
            self._source.addItem("Crash (unanalyzed)", str(config.DIAG_CRASH))
        # keep the previous selection if it's still present
        idx = self._source.findData(current) if current else -1
        self._source.setCurrentIndex(idx if idx >= 0 else 0)
        self._source.blockSignals(False)
        self._analyze_btn.setVisible(diagnostic.pending_crash() is not None)
        self._load_report()
    def _load_report(self) -> None:
        path = self._source.currentData() or str(config.LOG_FILE)
        summary = summarize(path, last_n=10)
        self._report.setPlainText(render_summary(summary, log_path=path))
    def _analyze_crash(self) -> None:
        self._analyze_btn.setEnabled(False)
        self._report.setPlainText("Analyzing the crash (final readings + system logs)…")
        threading.Thread(target=self._work_analyze, daemon=True).start()
    def _work_analyze(self) -> None:
        from ..core import diagnostic
        try:
            result = diagnostic.analyze_crash()
        except Exception:
            result = None
        self._analyzed.emit(result)
    def _show_analysis(self, result) -> None:
        self._analyze_btn.setEnabled(True)
        if result is not None:
            DiagnosticDialog(result, self).exec()
        self._refresh_sources()
    # --- refresh ---------------------------------------------------------------
    def _refresh_status(self) -> None:
        pid = reccontrol.running_pid()
@@ -162,8 +209,10 @@ class RecorderPage(QWidget):
        self._interval.setEnabled(not running)
        if status:
            game = status.get("game")
            game_line = f"Game: {game}    " if game else ""
            self._info.setText(
-                f"Samples: {status.get('samples', 0)}    "
+                f"{game_line}Samples: {status.get('samples', 0)}    "
                f"Started: {_fmt_time(status.get('started'))}    "
                f"Updated: {_fmt_time(status.get('updated'), '%H:%M:%S')}\n"
                f"Log: {status.get('log', config.LOG_FILE)}"
@@ -179,7 +228,3 @@ class RecorderPage(QWidget):
            self._info.setText("No recording yet. Press “Start recording”.")
            self._latest.setText("")
            self._warn.setVisible(False)
    def _load_report(self) -> None:
        summary = summarize(config.LOG_FILE, last_n=10)
        self._report.setPlainText(render_summary(summary, log_path=config.LOG_FILE))
@@ -1,4 +1,4 @@
-"""Setup page (M9 in the GUI): show environment + optional components, install missing."""
+"""Settings page: components/deps, alerts (M8), account access (token), and uninstall."""
 from __future__ import annotations
@@ -8,7 +8,11 @@ from PySide6.QtCore import Qt, QUrl, Signal
 from PySide6.QtGui import QDesktopServices
 from PySide6.QtWidgets import (
    QApplication,
    QCheckBox,
    QComboBox,
    QDoubleSpinBox,
    QFrame,
    QGridLayout,
    QHBoxLayout,
    QLabel,
    QLineEdit,
@@ -21,7 +25,7 @@ from PySide6.QtWidgets import (
 )
 from .. import config
-from ..core import installer, sysenv, uninstall, updates
+from ..core import alerts, installer, service, sysenv, uninstall, updates
 from .theme import GOOD, MUTED, WARN
@@ -49,18 +53,21 @@ _BACKEND_DESC = {
 class SetupPage(QWidget):
    _installed = Signal(int, str)
    _upd_state = Signal(object)
    _mode_applied = Signal(object)  # (mode, ok, message) from a trigger-mode change
    changed = Signal()  # alert settings saved — main window re-applies them live
    def __init__(self) -> None:
        super().__init__()
        self.setObjectName("Page")
        self._installed.connect(self._on_installed)
        self._upd_state.connect(self._on_upd_state)
        self._mode_applied.connect(self._on_mode_applied)
        root = QVBoxLayout(self)
        root.setContentsMargins(20, 18, 20, 18)
        root.setSpacing(16)
-        title = QLabel("Setup")
+        title = QLabel("Settings")
        title.setObjectName("PageTitle")
        root.addWidget(title)
@@ -70,7 +77,7 @@ class SetupPage(QWidget):
        env_layout.addWidget(self._env)
        root.addWidget(env_card)
-        comp_card, comp_layout = _panel("Optional components")
+        comp_card, comp_layout = _panel("Components & dependencies")
        self._components = QVBoxLayout()
        self._components.setSpacing(6)
        comp_layout.addLayout(self._components)
@@ -86,6 +93,68 @@ class SetupPage(QWidget):
        comp_layout.addLayout(controls)
        root.addWidget(comp_card)
        # Alerts (M8) — folded in from the old Notifications page.
        alerts_card, alerts_layout = _panel("Notifications")
        self._alerts_enabled = QCheckBox("Enable desktop notifications")
        alerts_layout.addWidget(self._alerts_enabled)
        grid = QGridLayout()
        grid.setHorizontalSpacing(12)
        grid.setColumnStretch(2, 1)
        self._gpu_alert = self._spin()
        self._cpu_alert = self._spin()
        grid.addWidget(QLabel("GPU temperature alert"), 0, 0)
        grid.addWidget(self._gpu_alert, 0, 1)
        grid.addWidget(QLabel("CPU temperature alert"), 1, 0)
        grid.addWidget(self._cpu_alert, 1, 1)
        alerts_layout.addLayout(grid)
        alerts_note = QLabel("GPU-lost and new-version alerts are included whenever notifications are enabled.")
        alerts_note.setObjectName("Muted")
        alerts_note.setWordWrap(True)
        alerts_layout.addWidget(alerts_note)
        alerts_buttons = QHBoxLayout()
        save_alerts = QPushButton("Save")
        save_alerts.setObjectName("PrimaryButton")
        save_alerts.clicked.connect(self._save_alerts)
        test_alerts = QPushButton("Send test")
        test_alerts.clicked.connect(self._test_alerts)
        alerts_buttons.addWidget(save_alerts)
        alerts_buttons.addWidget(test_alerts)
        alerts_buttons.addStretch(1)
        self._alerts_status = QLabel("")
        self._alerts_status.setObjectName("Muted")
        alerts_buttons.addWidget(self._alerts_status)
        alerts_layout.addLayout(alerts_buttons)
        root.addWidget(alerts_card)
        # Recording trigger (M9 / D6): when the crash logger runs.
        trig_card, trig_layout = _panel("Recording trigger")
        trig_desc = QLabel(
            "When the crash logger runs (uses a systemd --user service):\n"
            "•  Manual — you start/stop it yourself.\n"
            "•  Always-on — a background service records continuously.\n"
            "•  Game-launch — auto-records while a Steam game is running."
        )
        trig_desc.setObjectName("Muted")
        trig_desc.setWordWrap(True)
        trig_layout.addWidget(trig_desc)
        trig_row = QHBoxLayout()
        self._trigger = QComboBox()
        self._trigger.addItems(list(service.MODES))
        apply_trigger = QPushButton("Apply")
        apply_trigger.setObjectName("PrimaryButton")
        apply_trigger.clicked.connect(self._apply_trigger)
        trig_row.addWidget(self._trigger, 1)
        trig_row.addWidget(apply_trigger)
        trig_layout.addLayout(trig_row)
        self._trigger_status = QLabel("")
        self._trigger_status.setObjectName("Muted")
        self._trigger_status.setWordWrap(True)
        trig_layout.addWidget(self._trigger_status)
        if not service.available():
            apply_trigger.setEnabled(False)
            self._trigger_status.setText("systemd --user isn't available on this system.")
        root.addWidget(trig_card)
        # Account access (M13/M12): one Gitea token gates updates and session sharing.
        upd_card, upd_layout = _panel("Account access")
        hint = QLabel("A Gitea access token unlocks updates and session sharing. "
@@ -115,7 +184,7 @@ class SetupPage(QWidget):
        self._output = QTextEdit()
        self._output.setObjectName("Report")
        self._output.setReadOnly(True)
-        self._output.setMinimumHeight(180)
+        self._output.setMinimumHeight(160)
        self._output.setVisible(False)
        root.addWidget(self._output)
        root.addStretch(1)
@@ -129,8 +198,57 @@ class SetupPage(QWidget):
        root.addLayout(danger)
        self._refresh()
        self._load_alerts()
        self._trigger.setCurrentText(config.load_config().get("trigger_mode", "manual"))
        self._refresh_update_status()
    # --- recording trigger (M9) -----------------------------------------------
    def _apply_trigger(self) -> None:
        mode = self._trigger.currentText()
        self._trigger_status.setText(f"Applying “{mode}”… (may take a moment)")
        threading.Thread(target=self._work_trigger, args=(mode,), daemon=True).start()
    def _work_trigger(self, mode: str) -> None:
        ok, msg = service.apply_mode(mode)
        self._mode_applied.emit((mode, ok, msg))
    def _on_mode_applied(self, result) -> None:
        mode, ok, msg = result
        if ok:
            self._trigger_status.setText(f"Recording trigger set to “{mode}”.")
        else:
            self._trigger_status.setText(f"“{mode}” saved. {msg}")
    # --- alerts (M8) ----------------------------------------------------------
    @staticmethod
    def _spin() -> QDoubleSpinBox:
        spin = QDoubleSpinBox()
        spin.setRange(40, 110)
        spin.setDecimals(0)
        spin.setSingleStep(1)
        spin.setSuffix(" °C")
        return spin
    def _load_alerts(self) -> None:
        cfg = config.load_config()
        self._alerts_enabled.setChecked(bool(cfg.get("alerts_enabled", True)))
        self._gpu_alert.setValue(float(cfg.get("gpu_temp_alert", 90.0)))
        self._cpu_alert.setValue(float(cfg.get("cpu_temp_alert", 95.0)))
    def _save_alerts(self) -> None:
        config.update_config(
            alerts_enabled=self._alerts_enabled.isChecked(),
            gpu_temp_alert=self._gpu_alert.value(),
            cpu_temp_alert=self._cpu_alert.value(),
        )
        self.changed.emit()
        self._alerts_status.setText("Saved.")
    def _test_alerts(self) -> None:
        ok = alerts.notify("RigDoctor", "Test notification — alerts are working.")
        self._alerts_status.setText(
            "Test sent." if ok else "notify-send not found — install libnotify-bin above.")
    def _uninstall(self) -> None:
        box = QMessageBox(self)
        box.setIcon(QMessageBox.Icon.Warning)
@@ -1,9 +1,10 @@
-"""Share page (M12): host or join a shared session over the relay.
+"""Share page (M12): a shared **terminal** session over the relay.
-Guest sees the host's live sensors + health + inventory (read-only). If the host enables it,
+The host shares a real PTY running their shell; the guest watches it live and — only if the
-a full **PTY terminal** is shared: the guest types and the commands run on the host (as the
+host ticks "Allow the guest to type" — can run commands (as the host's user). The host reads
-host's user), the host reads along, and the host can type too — e.g. a sudo password, which
+along and can type too, e.g. a sudo password, which stays local and is never sent to the guest.
-stays local and is never sent to the guest.
+This is the only share mode (the old read-only stats view was removed). Either terminal can be
 popped full-screen.
 """
 from __future__ import annotations
@@ -11,7 +12,8 @@ from __future__ import annotations
 import base64
 import json
-from PySide6.QtCore import Qt, QSocketNotifier, QTimer, QUrl
+from PySide6.QtCore import Qt, QSocketNotifier, QUrl
 from PySide6.QtGui import QKeySequence, QShortcut
 from PySide6.QtWebSockets import QWebSocket
 from PySide6.QtWidgets import (
    QCheckBox,
@@ -20,16 +22,12 @@ from PySide6.QtWidgets import (
    QLabel,
    QLineEdit,
    QPushButton,
    QTextEdit,
    QVBoxLayout,
    QWidget,
 )
 from ..config import load_config, load_token
 from ..core import share
 from ..core.pty_session import PtySession
 from ..core.sampler import Sampler
 from ..core.sources import available_sources
 from .terminal_widget import TerminalView
@@ -57,16 +55,13 @@ class SharePage(QWidget):
    def __init__(self) -> None:
        super().__init__()
        self.setObjectName("Page")
        self._sampler = Sampler(available_sources())
        self._host_ws: QWebSocket | None = None
        self._guest_ws: QWebSocket | None = None
        self._pty: PtySession | None = None
        self._pty_notifier: QSocketNotifier | None = None
-        self._last_report = None
+        self._guest_can_type = False
-        self._last_inv = None
+        self._fs: QWidget | None = None
-        self._timer = QTimer(self)
+        self._fs_state = None
        self._timer.setInterval(2000)
        self._timer.timeout.connect(self._stream)
        root = QVBoxLayout(self)
        root.setContentsMargins(20, 18, 20, 18)
@@ -74,19 +69,19 @@ class SharePage(QWidget):
        title = QLabel("Share")
        title.setObjectName("PageTitle")
        root.addWidget(title)
-        root.addWidget(self._build_host())
+        root.addWidget(self._build_host(), 1)
        root.addWidget(self._build_guest(), 1)
    # ------------------------------------------------------------------ host
    def _build_host(self) -> QFrame:
-        card, v = _card("Start a shared session")
+        card, v = _card("Host a terminal session")
-        self._host_status = QLabel("Let someone with an account view your machine, read-only.")
+        self._host_status = QLabel("Share a live terminal with someone who has an account.")
        self._host_status.setObjectName("Muted")
        self._host_status.setWordWrap(True)
        v.addWidget(self._host_status)
        row = QHBoxLayout()
-        self._start_btn = QPushButton("Start shared session")
+        self._start_btn = QPushButton("Start session")
        self._start_btn.setObjectName("PrimaryButton")
        self._start_btn.clicked.connect(self._start_host)
        self._stop_btn = QPushButton("Stop")
@@ -95,28 +90,33 @@ class SharePage(QWidget):
        self._code_label = QLabel("")
        self._code_label.setStyleSheet("font-weight:700; font-size:18px; color:#38bdf8; background:transparent;")
        self._code_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
        self._host_fs_btn = QPushButton("Full screen")
        self._host_fs_btn.setEnabled(False)
        self._host_fs_btn.clicked.connect(lambda: self._enter_fullscreen(self._host_term))
        row.addWidget(self._start_btn)
        row.addWidget(self._stop_btn)
        row.addSpacing(12)
        row.addWidget(self._code_label)
        row.addStretch(1)
        row.addWidget(self._host_fs_btn)
        v.addLayout(row)
-        self._allow_term = QCheckBox("Allow remote terminal — the guest runs commands as your user (you read along; you can type too, e.g. a sudo password)")
+        self._allow_input = QCheckBox(
-        self._allow_term.setStyleSheet("color:#fb923c; background:transparent;")
+            "Allow the guest to type — they run commands as your user (off = they only watch)")
-        self._allow_term.toggled.connect(self._toggle_terminal)
+        self._allow_input.setStyleSheet("color:#fb923c; background:transparent;")
-        v.addWidget(self._allow_term)
+        self._allow_input.toggled.connect(self._send_terminal_state)
        v.addWidget(self._allow_input)
        self._host_term = TerminalView()
        self._host_term.keys.connect(lambda b: self._pty.write(b) if self._pty else None)
        self._host_term.resized.connect(lambda r, c: self._pty.set_size(r, c) if self._pty else None)
        self._host_term.setVisible(False)
-        v.addWidget(self._host_term)
+        v.addWidget(self._host_term, 1)
        return card
    def _start_host(self) -> None:
        if not load_token():
-            self._host_status.setText("Set a Gitea access token in Setup → Account access first.")
+            self._host_status.setText("Set a Gitea access token in Settings → Account access first.")
            return
        self._host_status.setText("Connecting to the relay…")
        self._start_btn.setEnabled(False)
@@ -135,37 +135,25 @@ class SharePage(QWidget):
        if data.get("error"):
            self._host_status.setText(f"Rejected: {data['error']}")
            return
-        if "code" in data:  # relay handshake
+        if "code" in data:  # relay handshake → start the terminal immediately
            self._code_label.setText(data["code"])
-            self._host_status.setText(f"Sharing as {data.get('user', '?')} — give this code to whoever should view your machine.")
+            self._host_status.setText(
                f"Sharing as {data.get('user', '?')} — give this code to whoever should connect.")
            self._stop_btn.setEnabled(True)
            self._host_ws.sendTextMessage(share.host_full_frame(self._sampler))
            self._send_terminal_state()
            if self._allow_term.isChecked():
                self._start_pty()
            self._timer.start()
            return
        kind = data.get("type")  # frames forwarded from a guest
        if kind == "req_full":
            # A guest just joined — send a full frame AND the current terminal state, so a
            # guest that joins *after* the host enabled the terminal still gets access.
            self._host_ws.sendTextMessage(share.host_full_frame(self._sampler))
            self._send_terminal_state()
        elif kind == "pty_in" and self._pty:
            self._pty.write(base64.b64decode(data["data"]))
        elif kind == "pty_resize" and self._pty:
            self._pty.set_size(int(data["rows"]), int(data["cols"]))
    def _toggle_terminal(self, on: bool) -> None:
        if on and self._host_ws and self._code_label.text():
            self._start_pty()
-        elif not on:
+            self._send_terminal_state()
-            self._stop_pty()
+            return
-        self._send_terminal_state()
+        kind = data.get("type")
        if kind == "req_full":  # a guest joined — tell them their typing permission
            self._send_terminal_state()
        elif kind == "pty_in" and self._pty and self._allow_input.isChecked():
            self._pty.write(base64.b64decode(data["data"]))
        elif kind == "pty_resize" and self._pty and self._allow_input.isChecked():
            self._pty.set_size(int(data["rows"]), int(data["cols"]))
    def _send_terminal_state(self) -> None:
        if self._host_ws and self._code_label.text():
-            self._host_ws.sendTextMessage(json.dumps({"type": "terminal", "enabled": self._allow_term.isChecked()}))
+            self._host_ws.sendTextMessage(json.dumps({"type": "terminal", "enabled": self._allow_input.isChecked()}))
    def _start_pty(self) -> None:
        if self._pty:
@@ -176,15 +164,15 @@ class SharePage(QWidget):
        self._pty_notifier.activated.connect(self._on_pty_output)
        self._host_term.reset()
        self._host_term.setVisible(True)
        self._host_fs_btn.setEnabled(True)
        self._host_term.setFocus()
    def _on_pty_output(self) -> None:
        if not self._pty:
            return
        data = self._pty.read()
-        if not data:  # shell exited / EOF
+        if not data:  # shell exited
-            self._stop_pty()
+            self._stop_host()
            self._send_terminal_state()
            self._allow_term.setChecked(False)
            return
        self._host_term.feed(data)
        if self._host_ws:
@@ -198,13 +186,9 @@ class SharePage(QWidget):
            self._pty.close()
            self._pty = None
        self._host_term.setVisible(False)
-
+        self._host_fs_btn.setEnabled(False)
    def _stream(self) -> None:
        if self._host_ws:
            self._host_ws.sendTextMessage(share.host_snapshot_frame(self._sampler))
    def _stop_host(self) -> None:
        self._timer.stop()
        self._stop_pty()
        if self._host_ws:
            self._host_ws.close()
@@ -215,7 +199,6 @@ class SharePage(QWidget):
        self._host_status.setText("Stopped sharing.")
    def _host_closed(self) -> None:
        self._timer.stop()
        self._stop_pty()
        self._start_btn.setEnabled(True)
        self._stop_btn.setEnabled(False)
@@ -225,7 +208,7 @@ class SharePage(QWidget):
    # ----------------------------------------------------------------- guest
    def _build_guest(self) -> QFrame:
-        card, v = _card("Join a shared session")
+        card, v = _card("Join a terminal session")
        row = QHBoxLayout()
        self._code_input = QLineEdit()
        self._code_input.setPlaceholderText("Enter share code")
@@ -237,37 +220,31 @@ class SharePage(QWidget):
        self._leave_btn = QPushButton("Leave")
        self._leave_btn.setEnabled(False)
        self._leave_btn.clicked.connect(self._leave)
        self._guest_fs_btn = QPushButton("Full screen")
        self._guest_fs_btn.setEnabled(False)
        self._guest_fs_btn.clicked.connect(lambda: self._enter_fullscreen(self._guest_term))
        row.addWidget(self._code_input)
        row.addWidget(self._join_btn)
        row.addWidget(self._leave_btn)
        row.addStretch(1)
        row.addWidget(self._guest_fs_btn)
        v.addLayout(row)
        self._guest_status = QLabel("")
        self._guest_status.setObjectName("Muted")
        self._guest_status.setWordWrap(True)
        v.addWidget(self._guest_status)
        self._view = QTextEdit()
        self._view.setObjectName("Report")
        self._view.setReadOnly(True)
        self._view.setVisible(False)
        self._view.setMinimumHeight(200)
        v.addWidget(self._view)
        self._term_label = QLabel("")
        self._term_label.setObjectName("Muted")
        self._term_label.setVisible(False)
        v.addWidget(self._term_label)
        self._guest_term = TerminalView()
        self._guest_term.keys.connect(self._guest_key)
        self._guest_term.resized.connect(self._guest_resize)
        self._guest_term.setVisible(False)
-        v.addWidget(self._guest_term)
+        v.addWidget(self._guest_term, 1)
        return card
    def _join(self) -> None:
        code = self._code_input.text().strip().upper()
        if not load_token():
-            self._guest_status.setText("Set a Gitea access token in Setup → Account access first.")
+            self._guest_status.setText("Set a Gitea access token in Settings → Account access first.")
            return
        if not code:
            self._guest_status.setText("Enter a share code.")
@@ -290,46 +267,40 @@ class SharePage(QWidget):
            self._guest_status.setText(data["error"])
            return
        if "joined" in data:
-            self._guest_status.setText(f"Viewing {data.get('host', '?')}'s machine — read-only.")
+            self._guest_status.setText(f"Connected to {data.get('host', '?')}'s terminal — watching.")
            self._leave_btn.setEnabled(True)
-            self._view.setVisible(True)
+            self._guest_fs_btn.setEnabled(True)
            self._guest_term.reset()
            self._guest_term.setVisible(True)
            self._guest_ws.sendTextMessage(json.dumps({"type": "req_full"}))
            return
        kind = data.get("type")
-        if kind in ("full", "snapshot"):
+        if kind == "terminal":
-            if kind == "full":
+            self._guest_can_type = bool(data.get("enabled"))
-                self._last_report = data.get("report")
+            self._guest_status.setText(
-                self._last_inv = data.get("inventory")
+                "You can type — your keystrokes run on the host's machine."
-            self._view.setHtml(share.guest_html(data.get("snapshot"), self._last_report, self._last_inv))
+                if self._guest_can_type else "Read-only — watching the host's terminal.")
-        elif kind == "terminal":
+            if self._guest_can_type:
-            self._set_terminal_visible(bool(data.get("enabled")))
+                self._guest_term.setFocus()
                self._guest_resize(*self._guest_term.grid())
        elif kind == "pty":
            self._guest_term.feed(base64.b64decode(data["data"]))
    def _set_terminal_visible(self, enabled: bool) -> None:
        self._term_label.setVisible(True)
        self._term_label.setText("Terminal enabled by host — your keystrokes run on their machine. Click here and type."
                                 if enabled else "Terminal not enabled by the host.")
        self._guest_term.setVisible(enabled)
        if enabled:
            self._guest_term.reset()
            self._guest_resize(*self._guest_term.grid())
            self._guest_term.setFocus()
    def _guest_key(self, data: bytes) -> None:
-        if self._guest_ws:
+        if self._guest_ws and self._guest_can_type:
            self._guest_ws.sendTextMessage(json.dumps({"type": "pty_in", "data": _b64(data)}))
    def _guest_resize(self, rows: int, cols: int) -> None:
-        if self._guest_ws:
+        if self._guest_ws and self._guest_can_type:
            self._guest_ws.sendTextMessage(json.dumps({"type": "pty_resize", "rows": rows, "cols": cols}))
    def _leave(self) -> None:
        if self._guest_ws:
            self._guest_ws.close()
            self._guest_ws = None
-        for w in (self._view, self._term_label, self._guest_term):
+        self._guest_term.setVisible(False)
-            w.setVisible(False)
+        self._guest_fs_btn.setEnabled(False)
        self._guest_can_type = False
        self._leave_btn.setEnabled(False)
        self._join_btn.setEnabled(True)
        self._guest_status.setText("Left the session.")
@@ -337,11 +308,40 @@ class SharePage(QWidget):
    def _guest_closed(self) -> None:
        self._join_btn.setEnabled(True)
        self._leave_btn.setEnabled(False)
-        if self._view.isVisible():
+        if self._guest_term.isVisible():
            self._guest_status.setText("Session ended (host disconnected).")
    # --------------------------------------------------------------- full screen
    def _enter_fullscreen(self, term: TerminalView) -> None:
        if self._fs is not None:
            return
        parent_layout = term.parentWidget().layout()
        self._fs_state = (parent_layout, parent_layout.indexOf(term), term)
        self._fs = QWidget()
        self._fs.setStyleSheet("background:#0d0f13;")
        lay = QVBoxLayout(self._fs)
        lay.setContentsMargins(0, 0, 0, 0)
        lay.setSpacing(0)
        hint = QLabel("Esc to exit full screen")
        hint.setObjectName("Muted")
        hint.setStyleSheet("padding:4px 10px; background:#15181e;")
        lay.addWidget(hint)
        lay.addWidget(term, 1)
        QShortcut(QKeySequence(Qt.Key.Key_Escape), self._fs, activated=self._leave_fullscreen)
        self._fs.showFullScreen()
        term.setFocus()
    def _leave_fullscreen(self) -> None:
        if self._fs is None:
            return
        parent_layout, index, term = self._fs_state
        parent_layout.insertWidget(index, term)
        self._fs.close()
        self._fs = None
        self._fs_state = None
        term.setFocus()
    def shutdown(self) -> None:
        self._timer.stop()
        self._stop_pty()
        for ws in (self._host_ws, self._guest_ws):
            if ws:
@@ -1,30 +1,66 @@
-"""A minimal terminal view: renders PTY output via pyte and emits keystrokes (M12, Tier 3).
+"""A terminal view: renders PTY output via pyte (with colors) and emits keystrokes (M12).
 Used by both sides of a shared session — the host (mirrors its local PTY, can also type, e.g.
-a sudo password) and the guest (renders the streamed PTY, sends keystrokes). Monochrome for
+a sudo password) and the guest (renders the streamed PTY, sends keystrokes). Renders pyte's
-now; cursor addressing / layout (vim, top) work via pyte.
+per-cell foreground/background/bold/reverse so the host's real shell (e.g. fish) keeps its
 colors and theming; cursor addressing (vim, top) works via pyte. Scrollback is preserved.
 """
 from __future__ import annotations
 import html as _html
 import pyte
 from PySide6.QtCore import Qt, Signal
-from PySide6.QtGui import QFontDatabase, QFontMetrics, QTextCursor
+from PySide6.QtGui import QFontDatabase, QFontMetrics
-from PySide6.QtWidgets import QPlainTextEdit
+from PySide6.QtWidgets import QTextEdit
 # ANSI named colors → RGB (a dark, modern palette). pyte also yields 6-hex strings for
 # 256-color / truecolor, which we pass through, and "default" which maps to the theme.
 _FG_DEFAULT = "#d6dae0"
 _BG_DEFAULT = "#0d0f13"
 _NAMED = {
    "black": "#2a2f39", "red": "#f87171", "green": "#4ade80", "brown": "#e5c07b",
    "yellow": "#e5c07b", "blue": "#60a5fa", "magenta": "#c084fc", "cyan": "#38bdf8",
    "white": "#d6dae0",
 }
 _BRIGHT = {  # bold brightens the standard 8
    "black": "#5b626c", "red": "#fca5a5", "green": "#86efac", "brown": "#fde68a",
    "yellow": "#fde68a", "blue": "#93c5fd", "magenta": "#d8b4fe", "cyan": "#7dd3fc",
    "white": "#ffffff",
 }
 _HISTORY_RENDER = 400  # cap scrollback rows rendered per frame (perf)
-class TerminalView(QPlainTextEdit):
+def _color(name: str, default: str, bright: bool) -> str:
    if name == "default":
        return default
    table = _BRIGHT if bright else _NAMED
    if name in table:
        return table[name]
    if len(name) == 6:  # pyte 256/truecolor as a hex string
        try:
            int(name, 16)
            return "#" + name
        except ValueError:
            pass
    return default
 class TerminalView(QTextEdit):
    keys = Signal(bytes)        # user keystrokes -> bytes for the PTY
    resized = Signal(int, int)  # rows, cols
    def __init__(self, rows: int = 24, cols: int = 80):
        super().__init__()
-        self.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        self.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
        self.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
        self.setUndoRedoEnabled(False)
-        self.setMinimumHeight(260)
+        self.setReadOnly(False)  # we capture keys ourselves; no local editing
        self.setStyleSheet(f"QTextEdit {{ background: {_BG_DEFAULT}; border: none; }}")
        self.setMinimumHeight(320)
        self._rows, self._cols = rows, cols
-        self._screen = pyte.HistoryScreen(cols, rows, history=1000, ratio=0.5)
+        self._screen = pyte.HistoryScreen(cols, rows, history=2000, ratio=0.5)
        self._stream = pyte.ByteStream(self._screen)
    def grid(self) -> tuple[int, int]:
@@ -38,24 +74,51 @@ class TerminalView(QPlainTextEdit):
        self._screen.reset()
        self._render()
-    def _row_text(self, row) -> str:
+    # --- rendering ---------------------------------------------------------------------
-        return "".join(row[x].data for x in range(self._cols)).rstrip()
+    def _span(self, style, text: str) -> str:
        fg_name, bg_name, bold, reverse = style
        fg = _color(fg_name, _FG_DEFAULT, bold)
        bg = _color(bg_name, _BG_DEFAULT, False)
        if reverse:
            fg, bg = bg, fg
        esc = _html.escape(text, quote=False).replace(" ", "&nbsp;")
        weight = "font-weight:bold;" if bold else ""
        return f'<span style="color:{fg};background:{bg};{weight}">{esc}</span>'
    def _row_html(self, row, cursor_x) -> str:
        out: list[str] = []
        buf: list[str] = []
        cur_style = None
        for x in range(self._cols):
            ch = row[x]
            reverse = ch.reverse
            if cursor_x is not None and x == cursor_x and self.hasFocus():
                reverse = not reverse  # block cursor = inverted cell
            style = (ch.fg, ch.bg, ch.bold, reverse)
            if style != cur_style:
                if buf:
                    out.append(self._span(cur_style, "".join(buf)))
                    buf = []
                cur_style = style
            buf.append(ch.data or " ")
        if buf:
            out.append(self._span(cur_style, "".join(buf)))
        return "".join(out)
    def _render(self) -> None:
        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)))
+        history = list(self._screen.history.top)[-_HISTORY_RENDER:]
-        if at_bottom:  # follow output; place caret at the real (row, col)
+        lines = [self._row_html(r, None) for r in history]
-            cursor = self.textCursor()
+        cur_y = self._screen.cursor.y
-            cursor.movePosition(QTextCursor.MoveOperation.Start)
+        for y in range(self._rows):
-            cursor.movePosition(QTextCursor.MoveOperation.Down, QTextCursor.MoveMode.MoveAnchor, len(history) + self._screen.cursor.y)
+            cursor_x = self._screen.cursor.x if y == cur_y else None
-            cursor.movePosition(QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.MoveAnchor, self._screen.cursor.x)
+            lines.append(self._row_html(self._screen.buffer[y], cursor_x))
-            self.setTextCursor(cursor)
+        self.setHtml('<div style="white-space:pre;line-height:100%;">' + "<br>".join(lines) + "</div>")
-            self.ensureCursorVisible()
+
-        else:  # user scrolled up to read — keep their place
+        bar.setValue(bar.maximum() if at_bottom else prev)
            bar.setValue(prev)
    def resizeEvent(self, event):  # noqa: N802 (Qt override)
        super().resizeEvent(event)
@@ -77,6 +77,7 @@ QPushButton#NavButton {{
 }}
 QPushButton#NavButton:hover {{ background: {CARD}; color: {TEXT}; }}
 QPushButton#NavButton:checked {{ background: {CARD}; color: #ffffff; font-weight: 600; }}
 QLabel#NavSection {{ color: {MUTED}; font-size: 10px; font-weight: 800; letter-spacing: 1px; padding: 2px 12px 0; }}
 #Card {{ background: {CARD}; border: 1px solid {CARD_BORDER}; border-radius: 12px; }}
 QPushButton#CardHeader {{
@@ -0,0 +1,144 @@
 """System-tray applet (M11, D13): live readouts + quick actions over the shared engine.
 A QSystemTrayIcon whose menu shows at-a-glance CPU/GPU temp + memory and a status dot, led
 by **Run Diagnostic** (the guided session), plus Open dashboard / Start-Stop recording /
 Snapshot / Quit. It consumes the same sample stream as the dashboard (no extra sampling) and
 drives the existing MainWindow flows — one engine, another front-end.
 """
 from __future__ import annotations
 from PySide6.QtWidgets import QApplication, QMenu, QSystemTrayIcon
 from ..core import reccontrol
 def _gpu_temp(sample):
    for r in sample.readings:
        if r.source == "gpu" and r.metric == "temp" and r.label == "" and r.value is not None:
            return r.value
    return None
 def _cpu_temp(sample):
    temps = [r for r in sample.readings if r.source == "cpu" and r.metric == "temp" and r.value is not None]
    for r in temps:
        low = r.label.lower()
        if low.startswith("package") or "tctl" in low or "tdie" in low:
            return r.value
    return max((r.value for r in temps), default=None)
 def _memory(sample):
    used = total = pct = None
    for r in sample.readings:
        if r.source == "memory":
            if r.metric == "used":
                used = r.value
            elif r.metric == "total":
                total = r.value
            elif r.metric == "used_pct":
                pct = r.value
    return used, total, pct
 def _gpu_lost(sample) -> bool:
    return any(r.source == "gpu" and r.metric == "status" and r.label == "query-timeout"
               for r in sample.readings)
 class TrayIcon(QSystemTrayIcon):
    def __init__(self, window, icon, gpu_alert: float = 90.0, cpu_alert: float = 95.0) -> None:
        super().__init__(icon, window)
        self._window = window
        self._gpu_alert = gpu_alert
        self._cpu_alert = cpu_alert
        self._last = None
        self.setToolTip("RigDoctor")
        menu = QMenu()
        self._status_act = self._readout(menu, "● starting…")
        self._cpu_act = self._readout(menu, "CPU temp: —")
        self._gpu_act = self._readout(menu, "GPU temp: —")
        self._mem_act = self._readout(menu, "Memory: —")
        menu.addSeparator()
        self._diag_menu = menu.addMenu("Run Diagnostic")
        self._diag_menu.aboutToShow.connect(self._rebuild_diag_menu)
        menu.addAction("Open dashboard", self._window.show_dashboard)
        self._rec_act = menu.addAction("Start recording", self._toggle_record)
        menu.addAction("Snapshot (copy)", self._snapshot)
        menu.addSeparator()
        menu.addAction("Quit", self._window.quit_app)
        menu.aboutToShow.connect(self._refresh_actions)
        self.setContextMenu(menu)
        self.activated.connect(self._on_activated)
    @staticmethod
    def _readout(menu: QMenu, text: str):
        act = menu.addAction(text)
        act.setEnabled(False)  # display-only line
        return act
    def _on_activated(self, reason) -> None:
        if reason in (QSystemTrayIcon.ActivationReason.Trigger,
                      QSystemTrayIcon.ActivationReason.DoubleClick):
            self._window.show_dashboard()
    def update_sample(self, sample) -> None:
        self._last = sample
        cpu, gpu = _cpu_temp(sample), _gpu_temp(sample)
        used, total, pct = _memory(sample)
        self._cpu_act.setText(f"CPU temp: {cpu:.0f} °C" if cpu is not None else "CPU temp: —")
        self._gpu_act.setText(f"GPU temp: {gpu:.0f} °C" if gpu is not None else "GPU temp: —")
        if used is not None and total is not None:
            extra = f"  ({pct:.0f}%)" if pct is not None else ""
            self._mem_act.setText(f"Memory: {used:.1f} / {total:.1f} GB{extra}")
        else:
            self._mem_act.setText("Memory: —")
        if _gpu_lost(sample):
            self._status_act.setText("● GPU not responding")
        elif (gpu is not None and gpu >= self._gpu_alert) or (cpu is not None and cpu >= self._cpu_alert):
            self._status_act.setText("● Hot — over alert threshold")
        else:
            self._status_act.setText("● Normal")
        bits = []
        if cpu is not None:
            bits.append(f"CPU {cpu:.0f}°C")
        if gpu is not None:
            bits.append(f"GPU {gpu:.0f}°C")
        self.setToolTip("RigDoctor" + ("  —  " + "  ".join(bits) if bits else ""))
    def _refresh_actions(self) -> None:
        self._rec_act.setText("Stop recording" if reccontrol.running_pid() else "Start recording")
    def _toggle_record(self) -> None:
        if reccontrol.running_pid():
            reccontrol.stop_background()
        else:
            reccontrol.start_background()
    def _rebuild_diag_menu(self) -> None:
        from ..core import steam
        self._diag_menu.clear()
        games = steam.cached_games()
        if not games:
            self._diag_menu.addAction("Open Games to pick a game…",
                                      lambda: self._window.show_page("Games"))
            return
        for g in games[:20]:
            self._diag_menu.addAction(
                g.name,
                lambda _checked=False, name=g.name, appid=g.appid: self._window.run_diagnostic(name, appid),
            )
    def _snapshot(self) -> None:
        if self._last is None:
            return
        from ..render import render_snapshot
        QApplication.clipboard().setText(render_snapshot(self._last))
        self.showMessage("RigDoctor", "Snapshot copied to clipboard.",
                         QSystemTrayIcon.MessageIcon.Information, 4000)
@@ -0,0 +1,170 @@
 """Live monitor TUI (M2): a curses HWMonitor-style terminal dashboard.
 Shows current / session-min / session-max per sensor, grouped by subsystem, with
 temperature and utilization color bands. stdlib `curses` only; falls back to a plain
 full-screen redraw when stdout isn't a TTY (piped/SSH-without-tty). Keys: q quit, r reset
 the session min/max. The terminal face of the same live data the GUI dashboard graphs.
 """
 from __future__ import annotations
 import curses
 import sys
 import time
 from .core.sample import Reading, Sample
 from .core.sampler import Sampler
 from .core.sources import available_sources
 from .render import _GROUP_ORDER, _GROUP_TITLES, format_raw, metric_label, render_snapshot
 # Color-band thresholds (mirror the GUI dashboard so both faces agree).
 TEMP_COLD, TEMP_WARN, TEMP_CRIT = 50.0, 78.0, 88.0
 USAGE_WARN, USAGE_CRIT = 85.0, 95.0
 _USAGE_METRICS = {"util", "used_pct", "mem_util", "load"}
 def band(r: Reading) -> str:
    """Color band for a reading: cold | good | warn | crit | normal | na."""
    if r.source == "gpu" and r.metric == "status":  # GPU-lost / query timeout
        return "crit"
    if r.value is None:
        return "na"
    if r.unit == "°C":
        if r.value >= TEMP_CRIT:
            return "crit"
        if r.value >= TEMP_WARN:
            return "warn"
        if r.value >= TEMP_COLD:
            return "good"
        return "cold"
    if r.unit == "%" and r.metric in _USAGE_METRICS:
        if r.value >= USAGE_CRIT:
            return "crit"
        if r.value >= USAGE_WARN:
            return "warn"
        return "good"
    return "normal"
 def track(stats: dict[str, tuple[float, float]], sample: Sample) -> None:
    """Fold a sample's readings into {key: (min, max)} session extremes."""
    for r in sample.readings:
        if r.value is None:
            continue
        lo, hi = stats.get(r.key, (r.value, r.value))
        stats[r.key] = (min(lo, r.value), max(hi, r.value))
 # --- curses front-end -----------------------------------------------------------------
 _BAND_PAIR = {"cold": 1, "good": 2, "warn": 3, "crit": 4}
 def _init_colors() -> None:
    try:
        curses.start_color()
        curses.use_default_colors()
        curses.init_pair(1, curses.COLOR_CYAN, -1)
        curses.init_pair(2, curses.COLOR_GREEN, -1)
        curses.init_pair(3, curses.COLOR_YELLOW, -1)
        curses.init_pair(4, curses.COLOR_RED, -1)
    except curses.error:
        pass
 def _attr(band_name: str) -> int:
    pair = _BAND_PAIR.get(band_name)
    if not pair:
        return curses.A_NORMAL
    attr = curses.color_pair(pair)
    return attr | curses.A_BOLD if band_name == "crit" else attr
 def _draw(stdscr, sample: Sample, stats: dict, interval: float) -> None:
    stdscr.erase()
    height, width = stdscr.getmaxyx()
    def put(y: int, x: int, text: str, attr: int = curses.A_NORMAL) -> None:
        if 0 <= y < height and 0 <= x < width:
            try:
                stdscr.addnstr(y, x, text, max(0, width - x - 1), attr)
            except curses.error:
                pass
    put(0, 0, f"RigDoctor — live monitor   every {interval:g}s", curses.A_BOLD)
    put(1, 0, "q quit    r reset min/max", curses.A_DIM)
    groups = sample.by_source()
    order = [k for k in _GROUP_ORDER if k in groups] + [k for k in groups if k not in _GROUP_ORDER]
    name_w, col_w = 24, 11
    y = 3
    for key in order:
        if y >= height:
            break
        put(y, 0, _GROUP_TITLES.get(key, key.title()), curses.A_BOLD)
        y += 1
        put(y, 2, f"{'sensor':<{name_w}}{'current':>{col_w}}{'min':>{col_w}}{'max':>{col_w}}", curses.A_DIM)
        y += 1
        for r in groups[key]:
            if y >= height:
                break
            if r.metric == "name":  # device identity line
                put(y, 2, str(r.label), curses.A_DIM)
                y += 1
                continue
            lo, hi = stats.get(r.key, (r.value, r.value))
            put(y, 2, f"{metric_label(r):<{name_w}}")
            put(y, 2 + name_w, f"{format_raw(r.value, r.unit):>{col_w}}", _attr(band(r)))
            put(y, 2 + name_w + col_w, f"{format_raw(lo, r.unit):>{col_w}}", curses.A_DIM)
            put(y, 2 + name_w + 2 * col_w, f"{format_raw(hi, r.unit):>{col_w}}", curses.A_DIM)
            y += 1
        y += 1
    stdscr.refresh()
 def _loop(stdscr, sampler: Sampler, interval: float) -> None:
    curses.curs_set(0)
    stdscr.nodelay(True)
    _init_colors()
    stats: dict[str, tuple[float, float]] = {}
    latest = sampler.sample()
    track(stats, latest)
    next_sample = time.monotonic() + interval
    while True:
        ch = stdscr.getch()
        if ch in (ord("q"), ord("Q")):
            return
        if ch in (ord("r"), ord("R")):
            stats.clear()
            track(stats, latest)
        now = time.monotonic()
        if now >= next_sample:
            latest = sampler.sample()
            track(stats, latest)
            next_sample = now + interval
        _draw(stdscr, latest, stats, interval)
        time.sleep(0.05)  # keep key handling responsive without busy-spinning
 def _run_plain(sampler: Sampler, interval: float) -> int:
    """Fallback for non-TTY output: clear + reprint each tick (no curses)."""
    try:
        for sample in sampler.stream(interval=interval):
            print("\033[2J\033[H", end="")
            print(f"RigDoctor — live  (every {interval:g}s, Ctrl-C to quit)\n")
            print(render_snapshot(sample))
            sys.stdout.flush()
    except KeyboardInterrupt:
        print()
    return 0
 def run(interval: float, plain: bool = False) -> int:
    sampler = Sampler(available_sources())
    if plain or not sys.stdout.isatty():
        return _run_plain(sampler, interval)
    try:
        curses.wrapper(_loop, sampler, interval)
    except curses.error:  # terminal can't do curses — degrade gracefully
        return _run_plain(sampler, interval)
    return 0
@@ -0,0 +1,69 @@
 """GUI smoke tests: construct the real widgets so a startup crash fails the build.
 These run headless (offscreen) and skip cleanly if PySide6 isn't installed (the core/CLI
 test suite stays Qt-free). Constructing MainWindow is the check that would have caught the
 0.18.0 bad-import regression that broke launch.
 """
 import os
 import time
 import unittest
 os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
 try:
    from PySide6.QtGui import QIcon
    from PySide6.QtWidgets import QApplication, QWidget
    HAVE_QT = True
 except ImportError:
    HAVE_QT = False
@unittest.skipUnless(HAVE_QT, "PySide6 not installed")
 class GuiSmokeTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.app = QApplication.instance() or QApplication([])
    def test_main_window_constructs(self):
        from unittest import mock
        from rigdoctor.core import updates
        from rigdoctor.gui import main_window as mw
        # Avoid construction side effects: no pkexec elevation, no network update check.
        with mock.patch("rigdoctor.core.elevation.available", return_value=False), \
             mock.patch.object(updates, "update_state", return_value=(updates.UP_TO_DATE, None, "")):
            window = mw.MainWindow()
        try:
            self.assertEqual(len(window._nav_buttons), len(mw._PAGES))
            self.assertEqual(set(window._nav_buttons), set(mw._PAGES))
        finally:
            window._worker.stop()
    def test_tray_readouts_update(self):
        from rigdoctor.core.sample import Reading, Sample
        from rigdoctor.gui.tray import TrayIcon
        class StubWindow(QWidget):
            def show_dashboard(self): ...
            def show_page(self, name): ...
            def run_diagnostic(self, name, appid): ...
            def quit_app(self): ...
        tray = TrayIcon(StubWindow(), QIcon())
        tray.update_sample(Sample(time.time(), [
            Reading("gpu", "temp", 72.0, "°C", ""),
            Reading("cpu", "temp", 65.0, "°C", "Package id 0"),
            Reading("memory", "used", 14.2, "GB"),
            Reading("memory", "total", 31.0, "GB"),
            Reading("memory", "used_pct", 46.0, "%"),
        ]))
        self.assertIn("72", tray._gpu_act.text())
        self.assertIn("65", tray._cpu_act.text())
        self.assertIn("14.2 / 31.0 GB", tray._mem_act.text())
        self.assertEqual(tray._status_act.text(), "● Normal")
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,67 @@
 """Tests for M6 non-Steam game detection (Lutris SQLite + Heroic JSON)."""
 import json
 import sqlite3
 import tempfile
 import unittest
 from pathlib import Path
 from unittest import mock
 from rigdoctor.core import launchers
 class LutrisTests(unittest.TestCase):
    def test_reads_installed_games_only(self):
        with tempfile.TemporaryDirectory() as d:
            db = Path(d) / "pga.db"
            con = sqlite3.connect(db)
            con.execute("CREATE TABLE games (id INTEGER, name TEXT, slug TEXT, installed INTEGER)")
            con.executemany(
                "INSERT INTO games VALUES (?, ?, ?, ?)",
                [(1, "Hades", "hades", 1), (2, "Hollow Knight", "hollow-knight", 1), (3, "Old Game", "old", 0)],
            )
            con.commit()
            con.close()
            with mock.patch.object(launchers, "LUTRIS_DB", db), \
                 mock.patch.object(launchers, "HEROIC_DIR", Path(d) / "nope"):
                games = launchers.scan()
            names = {g.name for g in games}
            self.assertEqual(names, {"Hades", "Hollow Knight"})
            self.assertTrue(all(g.launcher == "lutris" for g in games))
    def test_missing_db_is_empty(self):
        with tempfile.TemporaryDirectory() as d:
            with mock.patch.object(launchers, "LUTRIS_DB", Path(d) / "absent.db"), \
                 mock.patch.object(launchers, "HEROIC_DIR", Path(d) / "nope"):
                self.assertEqual(launchers.scan(), [])
 class HeroicTests(unittest.TestCase):
    def test_epic_and_gog(self):
        with tempfile.TemporaryDirectory() as d:
            base = Path(d) / "heroic"
            (base / "legendaryConfig" / "legendary").mkdir(parents=True)
            (base / "gog_store").mkdir(parents=True)
            (base / "legendaryConfig" / "legendary" / "installed.json").write_text(
                json.dumps({"abc123": {"title": "Control"}}))
            (base / "gog_store" / "installed.json").write_text(
                json.dumps({"installed": [{"appName": "777", "title": "The Witcher 3"}]}))
            with mock.patch.object(launchers, "LUTRIS_DB", Path(d) / "nope.db"), \
                 mock.patch.object(launchers, "HEROIC_DIR", base):
                names = {g.name for g in launchers.scan()}
            self.assertEqual(names, {"Control", "The Witcher 3"})
    def test_gog_title_falls_back_to_install_path(self):
        with tempfile.TemporaryDirectory() as d:
            base = Path(d) / "heroic"
            (base / "gog_store").mkdir(parents=True)
            (base / "gog_store" / "installed.json").write_text(
                json.dumps({"installed": [{"appName": "9", "install_path": "/games/Stardew Valley"}]}))
            with mock.patch.object(launchers, "LUTRIS_DB", Path(d) / "nope.db"), \
                 mock.patch.object(launchers, "HEROIC_DIR", base):
                names = {g.name for g in launchers.scan()}
            self.assertEqual(names, {"Stardew Valley"})
 if __name__ == "__main__":
    unittest.main()
@@ -1,38 +0,0 @@
 """Tests for M12 relay frames + guest HTML rendering (host/guest data shapes)."""
 import json
 import unittest
 from rigdoctor.core import share
 from rigdoctor.core.sampler import Sampler
 from rigdoctor.core.sources import available_sources
 class RelayFrameTests(unittest.TestCase):
    def setUp(self):
        self.sampler = Sampler(available_sources())
    def test_full_frame_shape(self):
        frame = json.loads(share.host_full_frame(self.sampler))
        self.assertEqual(frame["type"], "full")
        self.assertIn("groups", frame["snapshot"])
        self.assertIsInstance(frame["report"], list)
        self.assertIsInstance(frame["inventory"], dict)
    def test_snapshot_frame_shape(self):
        frame = json.loads(share.host_snapshot_frame(self.sampler))
        self.assertEqual(frame["type"], "snapshot")
        self.assertIn("groups", frame["snapshot"])
    def test_guest_html_renders(self):
        snap = {"groups": {"gpu": [{"name": "temp", "value": 51.0, "unit": "°C"}]}}
        report = [{"severity": "ok", "category": "Logs", "title": "No errors"}]
        inv = {"System": {"Kernel": "7.0.0"}}
        html = share.guest_html(snap, report, inv)
        self.assertIn("51.0 °C", html)
        self.assertIn("No errors", html)
        self.assertIn("Kernel", html)
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,58 @@
 """Tests for the M9 systemd --user trigger-mode service manager."""
 import unittest
 from unittest import mock
 from rigdoctor.core import service
 class UnitTextTests(unittest.TestCase):
    def test_unit_text_has_required_sections(self):
        txt = service.unit_text("RigDoctor recorder", ["record", "run"])
        self.assertIn("[Unit]", txt)
        self.assertIn("[Service]", txt)
        self.assertIn("ExecStart=", txt)
        self.assertIn("record run", txt)
        self.assertIn("WantedBy=default.target", txt)
 class ApplyModeTests(unittest.TestCase):
    def test_unknown_mode_rejected(self):
        ok, msg = service.apply_mode("turbo")
        self.assertFalse(ok)
        self.assertIn("Unknown", msg)
    def test_no_systemd_saves_mode_but_reports(self):
        with mock.patch.object(service, "available", return_value=False), \
             mock.patch.object(service.config, "update_config") as update:
            ok, msg = service.apply_mode("always-on")
        self.assertFalse(ok)
        self.assertIn("available", msg.lower())
        update.assert_called_once_with(trigger_mode="always-on")
    def test_always_on_enables_recorder_disables_watch(self):
        calls = []
        with mock.patch.object(service, "available", return_value=True), \
             mock.patch.object(service, "install_units"), \
             mock.patch.object(service, "_enable", side_effect=lambda n: calls.append(("enable", n)) or (0, "")), \
             mock.patch.object(service, "_disable", side_effect=lambda n: calls.append(("disable", n)) or (0, "")), \
             mock.patch.object(service.config, "update_config"):
            ok, _ = service.apply_mode("always-on")
        self.assertTrue(ok)
        self.assertIn(("enable", service.RECORDER_UNIT), calls)
        self.assertIn(("disable", service.WATCH_UNIT), calls)
    def test_manual_disables_both(self):
        disabled = []
        with mock.patch.object(service, "available", return_value=True), \
             mock.patch.object(service, "install_units"), \
             mock.patch.object(service, "_enable", return_value=(0, "")), \
             mock.patch.object(service, "_disable", side_effect=lambda n: disabled.append(n) or (0, "")), \
             mock.patch.object(service.config, "update_config"):
            ok, _ = service.apply_mode("manual")
        self.assertTrue(ok)
        self.assertEqual(set(disabled), {service.RECORDER_UNIT, service.WATCH_UNIT})
 if __name__ == "__main__":
    unittest.main()
@@ -1,46 +0,0 @@
 """Tests for M12 Tier 2 share server: token gating + endpoints."""
 import json
 import threading
 import unittest
 import urllib.error
 import urllib.request
 from rigdoctor.core import share
 class ShareServerTests(unittest.TestCase):
    def setUp(self):
        self.srv, self.token = share.make_server("127.0.0.1", 0)
        self.port = self.srv.server_address[1]
        self.thread = threading.Thread(target=self.srv.serve_forever, daemon=True)
        self.thread.start()
    def tearDown(self):
        self.srv.shutdown()
    def _url(self, path, token=None):
        q = f"?t={token}" if token else ""
        return f"http://127.0.0.1:{self.port}{path}{q}"
    def test_requires_token(self):
        with self.assertRaises(urllib.error.HTTPError) as cm:
            urllib.request.urlopen(self._url("/api/snapshot"), timeout=10)
        self.assertEqual(cm.exception.code, 403)
    def test_bad_token_rejected(self):
        with self.assertRaises(urllib.error.HTTPError) as cm:
            urllib.request.urlopen(self._url("/api/snapshot", "wrong"), timeout=10)
        self.assertEqual(cm.exception.code, 403)
    def test_snapshot_with_token(self):
        data = json.load(urllib.request.urlopen(self._url("/api/snapshot", self.token), timeout=10))
        self.assertIn("groups", data)
    def test_page_served(self):
        body = urllib.request.urlopen(self._url("/", self.token), timeout=10).read()
        self.assertIn(b"read-only share", body)
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,58 @@
 """Tests for the M2 live-monitor TUI logic (min/max tracking + color bands)."""
 import unittest
 from rigdoctor import tui
 from rigdoctor.core.sample import Reading, Sample
 def _temp(v):
    return Reading("gpu", "temp", v, "°C", "")
 class TrackTests(unittest.TestCase):
    def test_tracks_min_and_max(self):
        stats: dict = {}
        for v in (60.0, 80.0, 70.0, 55.0):
            tui.track(stats, Sample(0.0, [_temp(v)]))
        self.assertEqual(stats["gpu.temp"], (55.0, 80.0))
    def test_ignores_none_values(self):
        stats: dict = {}
        tui.track(stats, Sample(0.0, [_temp(None)]))
        self.assertEqual(stats, {})
    def test_keys_separate_by_label(self):
        stats: dict = {}
        tui.track(stats, Sample(0.0, [
            Reading("cpu", "temp", 50.0, "°C", "Core 0"),
            Reading("cpu", "temp", 70.0, "°C", "Core 1"),
        ]))
        self.assertEqual(stats["cpu.temp.Core 0"], (50.0, 50.0))
        self.assertEqual(stats["cpu.temp.Core 1"], (70.0, 70.0))
 class BandTests(unittest.TestCase):
    def test_temperature_bands(self):
        self.assertEqual(tui.band(_temp(40.0)), "cold")
        self.assertEqual(tui.band(_temp(60.0)), "good")
        self.assertEqual(tui.band(_temp(80.0)), "warn")
        self.assertEqual(tui.band(_temp(90.0)), "crit")
    def test_usage_bands(self):
        self.assertEqual(tui.band(Reading("gpu", "util", 50.0, "%")), "good")
        self.assertEqual(tui.band(Reading("gpu", "util", 88.0, "%")), "warn")
        self.assertEqual(tui.band(Reading("memory", "used_pct", 96.0, "%")), "crit")
    def test_non_metric_percentage_is_normal(self):
        self.assertEqual(tui.band(Reading("gpu", "fan", 100.0, "%")), "normal")
    def test_gpu_lost_is_crit(self):
        self.assertEqual(tui.band(Reading("gpu", "status", None, "", "query-timeout")), "crit")
    def test_missing_value_is_na(self):
        self.assertEqual(tui.band(Reading("gpu", "power", None, "W")), "na")
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,69 @@
 """Tests for the M9/D12 game-launch watcher (RunningAppID parse + transitions)."""
 import tempfile
 import unittest
 from pathlib import Path
 from unittest import mock
 from rigdoctor.core import watcher
 _REGISTRY = """"Registry"
 {
 \t"HKCU"
 \t{
 \t\t"Software"
 \t\t{
 \t\t\t"Valve"
 \t\t\t{
 \t\t\t\t"Steam"
 \t\t\t\t{
 \t\t\t\t\t"RunningAppID"\t\t"%s"
 \t\t\t\t}
 \t\t\t}
 \t\t}
 \t}
 }
 """
 class TransitionTests(unittest.TestCase):
    def test_transitions(self):
        self.assertEqual(watcher.transition(0, 570), "start")
        self.assertEqual(watcher.transition(570, 0), "stop")
        self.assertIsNone(watcher.transition(570, 570))
        self.assertIsNone(watcher.transition(0, 0))
 class FindKeyTests(unittest.TestCase):
    def test_case_insensitive_nested(self):
        data = {"Registry": {"HKCU": {"steam": {"runningappid": "42"}}}}
        self.assertEqual(watcher._find_key(data, "RunningAppID"), "42")
    def test_missing(self):
        self.assertIsNone(watcher._find_key({"a": {"b": "c"}}, "RunningAppID"))
 class RunningAppIdTests(unittest.TestCase):
    def _with_registry(self, content):
        d = tempfile.mkdtemp()
        path = Path(d) / "registry.vdf"
        path.write_text(content)
        return path
    def test_reads_running_appid(self):
        path = self._with_registry(_REGISTRY % "570")
        with mock.patch.object(watcher, "_registry_path", return_value=path):
            self.assertEqual(watcher.running_appid(), 570)
    def test_zero_when_idle(self):
        path = self._with_registry(_REGISTRY % "0")
        with mock.patch.object(watcher, "_registry_path", return_value=path):
            self.assertEqual(watcher.running_appid(), 0)
    def test_zero_when_no_registry(self):
        with mock.patch.object(watcher, "_registry_path", return_value=None):
            self.assertEqual(watcher.running_appid(), 0)
 if __name__ == "__main__":
    unittest.main()
Author	SHA1	Message	Date
jessey	bfbad9cbc6	Merge pull request 'feat(share): render colors in the shared terminal — 0.24.0' (#20 ) from feat/share-terminal into main release / release (push) Successful in 14s Details Reviewed-on: #20	2026-05-22 08:05:12 +00:00
jessey	2e545ff718	feat(share): terminal-only sharing, bigger + full-screen — 0.25.0 Scope M12 down to a single shared-terminal mode (D23, amends D16): - Share page rewritten terminal-only: host shares their PTY/shell; guest watches and may type only if the host ticks "Allow the guest to type" (read-only otherwise — the D9 consent exception). Terminal is larger; either side can pop it full-screen (Esc to exit). - Removed the read-only stats view + HTTP server (core/share.py) and the `rigdoctor share serve` CLI; deleted their tests. - Docs: D23 added; SPEC/MODULES/ROADMAP updated (M12 → done, terminal-only). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 10:04:52 +02:00
jessey	5e5dc2d54a	feat(share): render colors in the shared terminal — 0.24.0 The terminal view rendered monochrome (QPlainTextEdit.setPlainText), dropping pyte's per-cell attributes. Rewritten as a QTextEdit that renders fg/bg/bold/ reverse per cell (block cursor = inverted cell), preserving scrollback. The session already runs the host's $SHELL + config with TERM=xterm-256color, so fish/ls/git/prompts now look the same as locally. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 10:00:23 +02:00
jessey	7804893054	Merge pull request 'feat(m9): systemd --user trigger modes + game-launch watcher — 0.23.0' (#19 ) from feat/m9-installer into main release / release (push) Successful in 14s Details Reviewed-on: #19	2026-05-22 07:55:47 +00:00
jessey	bf3ac4af1a	feat(m9): systemd --user trigger modes + game-launch watcher — 0.23.0 D6 trigger modes, no root: - core/service.py: write/enable `systemd --user` units; apply_mode(manual/ always-on/game-launch) reconciles the recorder + watcher services; status(). - core/watcher.py + `rigdoctor watch`: poll Steam RunningAppID, auto-bracket a focused capture (D12 zero-config fallback; wrapper stays primary). - CLI `rigdoctor service status\|mode`; config `trigger_mode`. - GUI Settings: "Recording trigger" dropdown (Apply runs apply_mode off-thread). - Tests for unit generation, mode reconciliation, watcher transitions/parse. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:55:36 +02:00
jessey	e4a37176e1	Merge pull request 'feat(m6): PowerMizer + Wine/Steam versions + non-Steam launchers — 0.22.0' (#18 ) from feat/m6-leftovers into main release / release (push) Successful in 14s Details Reviewed-on: #18	2026-05-22 07:47:26 +00:00
jessey	67665974dc	feat(m6): PowerMizer + Wine/Steam versions + non-Steam launchers — 0.22.0 M6 leftovers (the watcher defers to M9's trigger-mode work): - gameenv: check_gpu_powermizer (NVIDIA, X; degrades when the gpu target won't resolve), check_wine (wine --version), check_steam_client (dpkg package version); steam.client_version() helper. - core/launchers.py: detect Lutris (read-only SQLite pga.db) and Heroic (Epic legendary + GOG JSON) installed games; Game gained a `launcher` field. - Games page + `rigdoctor games` list non-Steam games alongside Steam, tagged by launcher; Run Diagnostic works on them (auto-launch stays Steam-only). - Tests for launchers (synthetic Lutris db + Heroic json). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:46:42 +02:00
jessey	51b7ed69bd	Merge pull request 'feat: live monitor TUI (M2) — 0.21.0' (#17 ) from feat/m11-tray into main release / release (push) Successful in 15s Details Reviewed-on: #17	2026-05-22 07:38:17 +00:00
jessey	6fca2c9aba	feat: live monitor TUI (M2) — 0.21.0 Upgrade `rigdoctor monitor` from a basic redraw to a stdlib curses dashboard (tui.py): current / session-min / session-max per sensor, grouped by subsystem, with temperature & utilization color bands (GPU-lost flagged red). q quits, r resets min/max. Plain full-screen redraw fallback on a non-TTY (--plain forces it). Pure track()/band() helpers are unit-tested; curses path verified in a pty. Completes the Monitoring bundle (M2 + M8). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:37:57 +02:00
jessey	4c5a6547ec	Merge pull request 'refactor(gui): grouped navigation + clearer page names — 0.20.0' (#16 ) from feat/m11-tray into main release / release (push) Successful in 15s Details Reviewed-on: #16	2026-05-22 07:31:06 +00:00
jessey	587568e574	refactor(gui): grouped navigation + clearer page names — 0.20.0 Reshape the IA so it reads by intent instead of a flat pile of pages. - Grouped sidebar: Monitor / Diagnose / System / App (section headers). - Renames: Health → System Health, Environment → Tuning, Logs → Recordings, Setup → Settings. - Settings absorbs Notifications (alerts) as a section; Notifications dropped as a separate page (notifications_page.py removed; SetupPage gains the alerts card + `changed` signal wired to the live alert monitor). - Recordings is now a hub: a source dropdown to view any captured log (always-on / last diagnostic / preserved crash) + Analyze-crash in place, plus the recorder controls; status line now shows the captured game. - main_window nav is data-driven (_NAV groups → _PAGES order → stack); show_page, badges, and tray flows updated. GUI smoke test asserts the new page set. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:30:35 +02:00
jessey	cc84bbda88	Merge pull request 'feat(gui): system-tray applet (M11) + GUI smoke tests — 0.19.0' (#15 ) from feat/m11-tray into main release / release (push) Successful in 13s Details Reviewed-on: #15	2026-05-22 07:22:04 +00:00
jessey	75a4da7af3	feat(gui): system-tray applet (M11) + GUI smoke tests — 0.19.0 QSystemTrayIcon applet (gui/tray.py, D13): menu with live CPU/GPU temp + memory used/total, a status line, a Run Diagnostic submenu per detected game, plus Open dashboard / Start-Stop recording / Snapshot-copy / Quit. Reuses the dashboard's sample stream; drives existing MainWindow flows. - MainWindow creates the tray when one is available; closing the window hides to tray (Quit exits); setQuitOnLastWindowClosed(False) so dialogs don't quit it. - app: `--tray` starts hidden for autostart. - tests/test_gui_smoke.py: construct MainWindow headless + exercise the tray, so a startup crash (like the 0.18.0 import bug) fails the build. Skips if no PySide6. - docs: M10/M11 marked done in MODULES/ROADMAP. Completes the Desktop UI bundle (M10 + M11). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:21:37 +02:00
jessey	f95387c5b8	Merge pull request 'fix(gui): correct relative import that broke app startup — 0.18.2' (#14 ) from feat/m6-steam-detection into main release / release (push) Successful in 14s Details Reviewed-on: #14	2026-05-22 07:10:47 +00:00
jessey	1dc86121f6	fix(gui): correct relative import that broke app startup — 0.18.2 The recording indicator (0.18.0) used `from .core import diagnostic`, which resolves to the non-existent rigdoctor.gui.core and crashed MainWindow on launch. Fixed to `from ..core import diagnostic`. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 09:10:28 +02:00
`@@ -1,3 +1,3 @@`
	`"""RigDoctor — modular hardware monitoring & crash diagnostics for Linux gamers."""`	`"""RigDoctor — modular hardware monitoring & crash diagnostics for Linux gamers."""`

	`__version__ = "0.18.1"`	`__version__ = "0.25.0"`