Initial public upload from Projekte/ClaudeCodePanel

.codex/config.toml

@@ -0,0 +1,31 @@
+# Coding MCPs: project-local registration (2026-09-07).
+
+[mcp_servers.serena]
+command = "/home/smlflg/.local/share/coding-mcp/serena/.venv/bin/serena"
+args = ["start-mcp-server", "--context=codex", "--project", "/home/smlflg/Projekte/ClaudeCodePanel", "--enable-web-dashboard", "false", "--open-web-dashboard", "false", "--enable-gui-log-window", "false"]
+cwd = "/home/smlflg/Projekte/ClaudeCodePanel"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.serena.env]
+"SERENA_HOME" = "/home/smlflg/.local/share/coding-mcp/serena/state"
+
+[mcp_servers.gitnexus]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/gitnexus/node_modules/gitnexus/dist/cli/index.js", "mcp"]
+cwd = "/home/smlflg/Projekte/ClaudeCodePanel"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180
+
+[mcp_servers.gitnexus.env]
+"GITNEXUS_HOME" = "/home/smlflg/.local/share/coding-mcp/gitnexus/runtime"
+
+[mcp_servers.context7]
+command = "/home/smlflg/.nvm/versions/node/v24.13.0/bin/node"
+args = ["/home/smlflg/.local/share/coding-mcp/context7/node_modules/@upstash/context7-mcp/dist/index.js"]
+cwd = "/home/smlflg/Projekte/ClaudeCodePanel"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180

.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.pyc
+*.pyo
+*.backup-*
+*.bak
+.venv/
+venv/
+*.sqlite3
+*.db
+.env
+node_modules/
+.DS_Store
+*.egg-info/
+dist/
+build/
+CLAUDE.md
+REVIEW_*.md
+CLOUDBOT_RESEARCH.md

FOR_SMLFLG.md

@@ -0,0 +1,245 @@
+# ClaudeCodePanel — Wie dein Panel funktioniert
+
+## Die Kurzversion
+
+Dein Panel ist wie ein **Cockpit fuer Claude Code**. Statt 15 Terminal-Fenster
+und Config-Dateien zu jonglieren, hast du ein GTK3-Fenster mit 7 Tabs
+und ein Tray-Icon das immer da ist. Denk an ein Auto-Armaturenbrett:
+Tacho (Monitor), Bordcomputer (Hub), Fehlerlampen (Logs), Navigationsliste (Sessions).
+
+**Stack:** Python 3.12 + PyGObject (GTK3) + Catppuccin Theming + systemd Service
+
+---
+
+## Architektur — 14 Module
+
+### panel.py (2373 Zeilen) — Der Dirigent
+Das Hauptfenster. Baut alle Tabs zusammen, startet die Timer, verwaltet das Tray-Icon.
+Wie ein Dirigent: spielt selbst kein Instrument, aber koordiniert alle anderen.
+
+**Key:** `ControlPanel` Klasse mit `_build_*_tab()` Methoden, `_refresh_hub()`, `_refresh_monitor()`.
+
+### monitor.py (729 Zeilen) — Der Daten-Butler
+Holt alle Zahlen: Kosten, Top-Tools, aktive Sessions, Timeline.
+Hat einen TTL-Cache (30 Sekunden) — fragt nicht staendig die Festplatte.
+
+**Key:** `get_daily_cost()`, `get_top_tools()`, `get_active_sessions()`. Nutzt MyAIGame's `tui.data.*` Module.
+
+### log_viewer.py (435 Zeilen) — Der Protokollant
+Zeigt heutige Usage-Eintraege und Coaching-Log. Filterbar nach Tools/Errors/Hooks.
+
+**Key:** `build_logs_tab()`, `refresh_logs()`. Liest `~/.claude/usage/YYYY-MM-DD.jsonl`.
+
+### session_browser.py (1039 Zeilen) — Das Telefonbuch
+Alle Claude-Sessions durchsuchbar. Zeigt Projekt, Vorschau, Groesse. Resume-Button oeffnet kitty.
+
+**Key:** `build_sessions_tab()`, `_scan_all_sessions()`, `_on_resume_clicked()`.
+
+### process_manager.py (588 Zeilen) — Der Hausmeister
+Scannt `ps aux` nach Claude-relevanten Prozessen. Zeigt RAM, CPU, Uptime.
+Kill-Button pro Prozess + "Kill All Ghosts" fuer Prozesse >24h.
+
+**Key:** `build_processes_tab()`, `_scan_processes()`, Ghost-Detection via `/proc/<pid>/stat`.
+
+### theme.py (620 Zeilen) — Der Maler
+Erkennt ob COSMIC Desktop dunkel oder hell ist, generiert passendes CSS.
+Catppuccin Mocha (dark) / Latte (light). Wechselt live wenn du das System-Theme aenderst.
+
+**Key:** `is_dark_mode()` liest `~/.config/cosmic/com.system76.CosmicTheme.Mode/v1/is_dark`.
+`setup_theme_watcher()` nutzt `Gio.FileMonitor` fuer Live-Updates.
+
+### config_io.py (168 Zeilen) — Der Tresorwaerter
+Liest und schreibt `~/.claude/settings.json` **atomar** — nie direkt.
+Immer: Backup → Temp-Datei → `os.replace()`. So geht nie was kaputt.
+
+**Key:** `read_settings()`, `write_settings()`, `update_setting("key.path", value)`.
+
+### swarm_tab.py (974 Zeilen) — Der Lageplaner
+Zeigt die laufende Agent Team Pipeline in Echtzeit. Liest `~/.claude/teams/` und
+`~/.claude/tasks/` und stellt Scout→Weaver→Builder→Validator→Pruefer als Karten dar.
+
+**Key:** `build_swarm_tab()`, `_scan_teams()`, `_refresh_swarm()`.
+
+### swarm_visual.py (708 Zeilen) — Der Kartograf
+Generiert HTML-Seiten mit interaktiven Agent-Kommunikationsgraphen: Hub-and-Spoke-Layout,
+Bezier-Kurven, Partikel-Animationen. Wird von swarm_tab.py aufgerufen und in WebKit2 eingebettet.
+
+**Key:** `generate_swarm_html()`, Bezier + Partikel-Rendering via Canvas.
+
+### event_tab.py (426 Zeilen) — Der Horcher
+Live-Viewer fuer Hook-Events aus `~/.claude/events/YYYY-MM-DD.jsonl`. Filterbar
+nach Event-Typ, Auto-Scroll wenn neue Events reinkommen.
+
+**Key:** `build_events_tab()`, `_tail_events()`, Filter-Logik nach Typ/Quelle.
+
+### shortcut_counter_tab.py (450 Zeilen) — Der Strichlisten-Fuehrer
+Zeigt Keyboard-Shortcut-Statistiken aus der ShortcutCounter-Datenbank. Wie oft hast
+du Ctrl+C vs. Ctrl+Z genutzt? Welcher Shortcut spart am meisten Zeit?
+
+**Key:** `build_shortcut_tab()`, liest ShortcutCounter SQLite DB.
+
+### project_dashboard_tab.py (254 Zeilen) — Das Fenster
+Bettet das Project Dashboard als WebKit2-Webview direkt ins Panel ein, statt
+einen Browser oeffnen zu muessen. Ein Tab = ein komplettes Web-Dashboard.
+
+**Key:** `build_project_dashboard_tab()`, `WebKit2.WebView` Setup + Reload-Button.
+
+### utils.py (33 Zeilen) — Der Werkzeugkasten
+Kleine Hilfsfunktionen die ueberall gebraucht werden (Format-Helpers, Pfad-Utilities).
+Klein aber da wenn man ihn braucht.
+
+**Key:** Shared Utilities fuer alle anderen Module.
+
+### tools-gui/ (623 Zeilen) — Das Zweite Cockpit
+Separates GTK3-Fenster mit 3 eigenen Tabs: Kosten-Analyse, Session-Uebersicht, Tool-Statistiken.
+Laeuft als eigenstaendiges Fenster neben dem Hauptpanel (main.py + 3 Tab-Module).
+
+**Key:** `tools-gui/main.py` als Einstiegspunkt, 3 Tab-Module fuer costs/sessions/tools.
+
+---
+
+## Wie die Tabs zusammenhaengen
+
+```
+panel.py (Dirigent)
+  ├── importiert monitor.py        → liefert Daten fuer Hub + Monitor Tab
+  ├── importiert log_viewer.py     → baut Logs Tab
+  ├── importiert session_browser.py → baut Sessions Tab
+  ├── importiert process_manager.py → baut Prozesse Tab
+  ├── importiert swarm_tab.py      → baut Agent Swarm Tab
+  ├── importiert swarm_visual.py   → generiert Swarm-Graphen (HTML)
+  ├── importiert event_tab.py      → baut Events Tab
+  ├── importiert shortcut_counter_tab.py → baut Shortcut Counter Tab
+  ├── importiert project_dashboard_tab.py → baut Project Dashboard Tab (WebKit2)
+  ├── importiert theme.py          → CSS + Theme Watcher
+  └── importiert config_io.py      → Settings + Hooks Tabs lesen/schreiben Config
+```
+
+Jedes Modul ist **eigenstaendig** — kann theoretisch allein funktionieren.
+panel.py ist nur der Rahmen der sie zusammenbringt.
+
+---
+
+## Timer-System — Das Herzschlag-System
+
+Dein Panel hat 6 Timer die wie Herzschlaege funktionieren. Jeder Timer
+ruft periodisch eine Funktion auf die Daten aktualisiert:
+
+| Timer | Intervall | Funktion | Was wird aktualisiert? |
+|-------|-----------|----------|----------------------|
+| Hub | 30s | `_refresh_hub()` | Kosten, Top-Tools, Sessions |
+| Monitor-Start | 15s | `_start_monitor_timer()` | Startet Monitor-Timer |
+| Logs | 10s | `refresh_logs()` | Usage + Coaching Eintraege |
+| Sessions | 60s | `refresh_sessions()` | Session-Liste |
+| Prozesse | 30s | `refresh_processes()` | Prozess-Scan |
+| Monitor | 30s | `_refresh_monitor()` | Timeline, Skills |
+
+**Warum gestaffelt?** Damit nicht alle gleichzeitig feuern und die UI einfriert.
+Logs sind am schnellsten (10s) weil Usage-Daten sich oft aendern.
+Sessions am langsamsten (60s) weil sich Sessions selten aendern.
+
+**Was wenn ein Timer haengt?** Jeder Timer returned `True` um am Leben zu bleiben.
+Wenn einer Exception wirft, faengt `try/except` es ab und der Timer laeuft weiter.
+Worst case: ein Tab zeigt veraltete Daten, aber das Panel stuerzt nicht ab.
+
+---
+
+## Daten-Flow
+
+```
+~/.claude/usage/YYYY-MM-DD.jsonl  ──→  monitor.py (Cache 30s)  ──→  Hub Tab (Kosten, Tools)
+                                    └──→  log_viewer.py          ──→  Logs Tab (Eintraege)
+
+~/.claude/projects/*/  ────────────→  monitor.py + session_browser  ──→  Sessions Tab
+
+ps aux ────────────────────────────→  process_manager.py  ──→  Prozesse Tab
+
+~/.claude/settings.json  ──────────→  config_io.py  ──→  Settings + Hooks Tab
+```
+
+---
+
+## Theme-System
+
+1. **Detection:** Liest `~/.config/cosmic/com.system76.CosmicTheme.Mode/v1/is_dark`
+   - `true` → Catppuccin Mocha (dunkle Palette)
+   - `false` → Catppuccin Latte (helle Palette)
+   - Datei fehlt → Fallback auf GTK `gtk-application-prefer-dark-theme`
+
+2. **CSS:** `build_css(palette)` generiert ~150 Zeilen CSS aus der Palette
+
+3. **Live-Switch:** `Gio.FileMonitor` beobachtet die COSMIC Config-Datei.
+   Aendert sich das System-Theme, wird `apply_theme()` via `GLib.idle_add` aufgerufen.
+
+---
+
+## Config-System — Atomare Writes
+
+Warum nicht einfach `json.dump(data, open(file, "w"))`?
+Weil: wenn der Prozess mittendrin stirbt, hast du eine kaputte halbe Datei.
+
+**Stattdessen (config_io.py):**
+1. **Backup:** `settings.json` → `settings.json.backup-20260302-143000`
+2. **Temp:** Schreibe in `settings-XXXX.tmp` (gleicher Ordner)
+3. **Rename:** `os.replace(tmp, settings.json)` — atomar auf Linux!
+
+Entweder hast du die alte ODER die neue Datei. Nie eine kaputte.
+
+---
+
+## Sprint 2026-03-04 Learnings
+
+### Das Wichtigste zuerst: Deine vorherige Arbeit war solide.
+
+4 von 5 Warnings waren **bereits gefixt** bevor der Sprint anfing (Commit `67a4362`).
+Du hast einen 5-Agenten-Sprint geplant fuer... einen einzigen verbleibenden Fix (subprocess.run → Popen).
+Das Panel ist zu **95%+ fertig**. Was wirklich noch offen ist: 4 Suggestions (nice-to-have), kein Critical.
+
+### Muster: Erst schauen, dann planen.
+
+Tendency erkannt: Samuel plant gross (5 Agents, detaillierter PLAN-File) **bevor** er den aktuellen Stand prueft.
+Regel fuer dich: **`/check-state` vor jedem Sprint-Start.** Eine Minute Status-Check spart eine Stunde Overhead.
+
+Konkret: Bevor du Tasks erstellst, kurz pruefen:
+- Welche Punkte der Checkliste sind schon erledigt? (PLAN-File lesen)
+- Laeuft der Service gerade fehlerfrei? (`systemctl --user status claude-panel.service`)
+- Wie gross ist der echte Rueckstand? (1 Fix ≠ 5-Agenten-Aufwand)
+
+### Was gut lief (verstaerken!)
+
+- **Dokumentations-Disziplin:** PLAN-File erstellt, Review-Findings dokumentiert, Entscheidungen festgehalten. Das ist wertvoll.
+- **Commit-Hygiene:** Criticals sofort gefixt und committed. Kein "ich mach das spaeter".
+- **Code-Review Workflow:** Sonnet Review + MiniMax Zweitmeinung. Zwei Perspektiven fangen mehr.
+- **Architektur-Entscheidungen klar begruendet:** `**/*.jsonl` fuer rekursive Suche, `"anthropic"` Key-Aggregation, Fingerprint-Mechanismus — alles dokumentiert.
+
+### Was noch aussteht (die echte Restliste)
+
+Nur Suggestions, kein muss:
+1. `monitor.py:~662` — `sorted()` mit stat()-Lambda vereinfachen
+2. `log_viewer.py:~456` — unbenutzten `sort_model` Parameter entfernen
+3. `panel.py:~812` — `_DETECTOR_LAYOUT` Naming-Konvention
+4. `log_viewer.py` — Status-Farben aus Theme-Palette statt hardcoded
+
+Das Panel laeuft. Diese Fixes machen es sauberer, nicht funktionsfaehiger.
+
+---
+
+## Bekannte Gotchas
+
+1. **CPU Spin-Loop (GEFIXT):** `GLib.idle_add(refresh_logs)` mit `return True` =
+   Endlosschleife. Fix: One-Shot Wrapper mit `return False`. Regel: `idle_add`
+   Callbacks muessen IMMER `False` returnen.
+
+2. **Ghost-Prozesse:** MCP-Server (opencode-mcp, gemini-mcp) werden pro Session
+   gestartet aber nie beendet. Der Prozesse-Tab zeigt sie als "Ghosts" (>24h).
+
+3. **MyAIGame Dependency:** `monitor.py` importiert `tui.data.usage_reader` aus
+   `~/Projekte/MyAIGame/`. Wenn das Projekt nicht existiert, fallen Kosten-
+   und Tool-Statistiken auf Null zurueck (graceful fallback, kein Crash).
+
+4. **COSMIC-only Theme Detection:** Auf nicht-COSMIC-Desktops funktioniert nur
+   der GTK-Fallback. Die Catppuccin-Farben bleiben, aber Live-Switching nur per GTK.
+
+5. **Singleton Lock (GEFIXT):** Frueher konnten mehrere Panel-Instanzen gleichzeitig
+   laufen (systemd restart + manueller Start). Fix: `fcntl.flock` auf `/tmp/claude-panel.lock`.
+   Zweite Instanz erkennt Lock und beendet sich mit `sys.exit(0)`.

PLAN_2026-03-13_quickwins.md

@@ -0,0 +1,49 @@
+# Plan: ClaudeCodePanel Quick Wins
+
+Erstellt: 2026-03-13 — nach Deep Review + Performance Fixes
+
+## Erledigt
+
+- [x] `_scan_session_jsonls()` in Background Thread (437ms UI-Freeze eliminiert)
+- [x] `_scan_processes()` in Background Thread (39ms UI-Freeze eliminiert)
+- [x] Commit `3d4f46d` gepusht
+- [x] Baseline-Messungs-Regel in `~/.claude/CLAUDE.md` hinzugefügt
+- [x] Shortcuts-Tab: 43→108 Shortcuts (ClaudeCLI +16, ClaudeCLI_Vim +20, COSMIC +14, Workspaces +10)
+- [x] 7 falsche COSMIC-Beschreibungen korrigiert (waren GNOME-Defaults statt COSMIC)
+- [x] Case-insensitive Matching fix (DB: TAB vs Config: Tab)
+- [x] 2 neue Anti-Pattern-Regeln in CLAUDE.md
+- [x] Commits `20b7ba0` + `fd9b8ef` gepusht
+
+## Offen — Quick Wins (je <30 Min)
+
+### 1. `constants.py` extrahieren (10 Min)
+5 Module definieren PROJECTS_DIR, USAGE_DIR redundant:
+- `monitor.py:66-67`
+- `session_browser.py:40`
+- `log_viewer.py:19`
+- `config_io.py:14`
+
+Neues `constants.py` mit allen Pfaden, Module importieren daraus.
+
+### 2. `providers.jsonl` Cache-Sharing (15 Min)
+`log_viewer.py:172` liest `providers.jsonl` eigenständig.
+`monitor.py:600` cached dieselbe Datei bereits.
+Fix: log_viewer importiert monitor.get_provider_costs() oder neue
+monitor.get_provider_entries_today() Funktion.
+
+### 3. WebKit2 lazy-loading (30 Min)
+`swarm_tab.py` und `project_dashboard_tab.py` spawnen je einen WebProcess
+beim Start (~50-100MB RAM pro Stück). Fix: WebView erst bei Tab-Switch
+erstellen via `notebook.connect("switch-page", ...)`.
+
+## Offen — Features
+
+### 4. Ideen/Gedanken Tab (Parking Lot)
+- Codex baut das Parking Lot Backend (parking_lot mit park/unpark/park-list)
+- Panel braucht Tab zur Darstellung: Claude Code Plaene, eigene Plaene, geparkte Gedanken
+- Samuel gibt Pfade wenn Codex fertig ist — FRAGEN nicht selbst suchen
+- Existierendes Vorbild: `~/Projekte/MyAIGame/tui/adhs/parking.py` (SQLite-backed)
+
+### 5. Cloudbot Tab (groß)
+Vollständig recherchiert in `CLOUDBOT_RESEARCH.md`.
+MVP-Scope: Session Quality Scoring als `cloudbot_tab.py`.

README.md

@@ -0,0 +1,95 @@
+# Claude Code Panel
+
+A native GTK3 desktop panel for [Claude Code](https://claude.ai/code) on Linux. System tray icon, session browser, agent swarm monitor, cost tracking, event viewer — all in one place.
+
+Built for Pop!\_OS / COSMIC Desktop, works on any Linux with GTK3.
+
+## Features
+
+- **System Tray Icon** — always-on indicator with quick access menu (AyatanaAppIndicator)
+- **Hub Tab** — daily cost, top tools, active sessions at a glance
+- **Monitor Tab** — signal cards, usage timeline, provider cost breakdown, phase badge
+- **Session Browser** — search, filter, and resume sessions with one click
+- **Process Manager** — Claude-related processes (MCP servers, CLI), ghost detection, kill button
+- **Agent Swarm Tab** — live view of Agent Team pipelines (Scout → Weaver → Builder → Validator → Prüfer)
+- **Swarm Visual** — HTML agent communication graph (hub-and-spoke, Bézier curves, particles)
+- **Event Viewer** — live hook events from `~/.claude/events/` with filters + auto-scroll
+- **Shortcut Counter** — keyboard shortcut usage stats from ShortcutCounter DB
+- **Project Dashboard** — embedded WebKit2 view of project dashboards
+- **Log Viewer** — filterable usage + coaching log entries
+- **Settings & Hooks** — read/write Claude Code config with atomic file writes
+- **Cost Tracking** — daily token costs, 7-day bar chart, per-provider breakdown
+- **Light/Dark Mode** — auto-detects COSMIC Desktop theme, Catppuccin Mocha/Latte, live switching
+- **Singleton Lock** — only one instance runs at a time (fcntl.flock)
+- **Portrait Monitor** — auto-moves window to portrait display if available
+
+## Requirements
+
+- Python 3.10+
+- GTK 3.0
+- AyatanaAppIndicator3 (system tray)
+- WebKit2 (optional, for Project Dashboard tab)
+
+```bash
+# Pop!_OS / Ubuntu / Debian
+sudo apt install python3-gi gir1.2-gtk-3.0 gir1.2-ayatanaappindicator3-0.1 gir1.2-webkit2-4.1
+```
+
+## Installation
+
+```bash
+git clone https://github.com/smlfg/ClaudeCodePanel.git
+cd ClaudeCodePanel
+
+# Run directly
+python3 panel.py
+
+# Or install as systemd user service (auto-start on login)
+cp claude-panel.service ~/.config/systemd/user/
+systemctl --user daemon-reload
+systemctl --user enable --now claude-panel.service
+```
+
+## Architecture
+
+```
+panel.py (2373 LOC) — Main window, 7+ tabs, tray icon, singleton lock
+  ├── monitor.py (729)        — Data layer: costs, tools, sessions (TTL cache 30s)
+  ├── config_io.py (168)      — Atomic config read/write (backup → temp → rename)
+  ├── theme.py (620)          — COSMIC theme detection + Catppuccin CSS
+  ├── session_browser.py (1039) — Session list, search, resume
+  ├── process_manager.py (588)  — Process scan, ghost detection, kill
+  ├── log_viewer.py (435)       — Usage + coaching log viewer
+  ├── swarm_tab.py (974)        — Agent Team pipeline viewer
+  ├── swarm_visual.py (708)     — HTML agent communication graph
+  ├── event_tab.py (426)        — Live hook event viewer
+  ├── shortcut_counter_tab.py (450) — Keyboard shortcut stats
+  ├── project_dashboard_tab.py (254) — Embedded project dashboard (WebKit2)
+  └── utils.py (33)            — Helper functions
+```
+
+### tools-gui/ (separate window)
+
+```
+tools-gui/main.py (83)           — Standalone GTK3 window
+  ├── tabs/sessions_tab.py (146) — Session list with search
+  ├── tabs/costs_tab.py (216)    — Daily costs + 7-day bar chart (Cairo)
+  └── tabs/tools_tab.py (178)    — Tool + skill usage breakdown
+```
+
+**Total: ~9,700 LOC across 19 Python files.**
+
+## Theme System
+
+The panel auto-detects your desktop theme:
+
+- **COSMIC Desktop**: reads `~/.config/cosmic/com.system76.CosmicTheme.Mode/v1/is_dark`
+- **Other GTK desktops**: uses `gtk-application-prefer-dark-theme` setting
+
+Switching your system theme updates the panel in real-time (no restart needed).
+
+Color palettes: [Catppuccin Mocha](https://github.com/catppuccin/catppuccin) (dark) / [Catppuccin Latte](https://github.com/catppuccin/catppuccin) (light).
+
+## License
+
+MIT

brightness_tab.py

@@ -0,0 +1,807 @@
+#!/usr/bin/env python3
+"""Interactive Sonnenuhr control tab for ClaudeCodePanel."""
+
+from __future__ import annotations
+
+import json
+import socket
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk, Pango
+
+from theme import get_palette
+
+STATE_PATH = Path("/tmp/sonnenuhr-state.json")
+SOCKET_PATH = Path("/tmp/sonnenuhr.sock")
+SOCKET_TIMEOUT_SECONDS = 2.0
+SLIDER_DEBOUNCE_MS = 300
+OFFSET_MIN = -50
+OFFSET_MAX = 50
+
+# ---------------------------------------------------------------------------
+# Module-level widget refs
+# ---------------------------------------------------------------------------
+_header_label: Gtk.Label | None = None
+_mode_badge: Gtk.Label | None = None
+_refresh_button: Gtk.Button | None = None
+_timeline_bar: Gtk.ProgressBar | None = None
+_timeline_label: Gtk.Label | None = None
+_brightness_value: Gtk.Label | None = None
+_brightness_scale: Gtk.Scale | None = None
+_temp_value: Gtk.Label | None = None
+_temp_scale: Gtk.Scale | None = None
+_temp_rgb: Gtk.Label | None = None
+_displays_box: Gtk.Box | None = None
+_footer_update: Gtk.Label | None = None
+_footer_theme: Gtk.Label | None = None
+_footer_status: Gtk.Label | None = None
+
+_mode_buttons: dict[str, Gtk.RadioButton] = {}
+_theme_buttons: dict[str, Gtk.RadioButton] = {}
+_debounce_sources: dict[str, int] = {}
+_last_state: dict | None = None
+_ui_syncing = False
+_last_user_interaction: float = 0.0
+INTERACTION_COOLDOWN = 3.0  # seconds — skip periodic slider updates while user interacts
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _load_state() -> dict | None:
+    if not STATE_PATH.exists():
+        return None
+    try:
+        with STATE_PATH.open(encoding="utf-8") as fh:
+            data = json.load(fh)
+        return data if isinstance(data, dict) else None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _extract_state(payload: dict | None) -> dict | None:
+    if not isinstance(payload, dict):
+        return None
+    state = payload.get("state", payload)
+    return state if isinstance(state, dict) else None
+
+
+def _send_socket_command(command: dict) -> dict:
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.settimeout(SOCKET_TIMEOUT_SECONDS)
+        try:
+            sock.connect(str(SOCKET_PATH))
+            sock.sendall(json.dumps(command).encode() + b"\n")
+            sock.shutdown(socket.SHUT_WR)
+            response = b""
+            while True:
+                chunk = sock.recv(4096)
+                if not chunk:
+                    break
+                response += chunk
+        finally:
+            sock.close()
+    except OSError as exc:
+        return {"ok": False, "error": f"daemon not reachable: {exc}"}
+
+    if not response:
+        return {"ok": False, "error": "daemon returned empty response"}
+
+    try:
+        return json.loads(response.decode())
+    except json.JSONDecodeError as exc:
+        return {"ok": False, "error": f"invalid daemon response: {exc}"}
+
+
+def _schedule_command(key: str, callback, delay_ms: int = SLIDER_DEBOUNCE_MS) -> None:
+    source_id = _debounce_sources.pop(key, None)
+    if source_id:
+        GLib.source_remove(source_id)
+
+    def _fire() -> bool:
+        _debounce_sources.pop(key, None)
+        callback()
+        return False
+
+    _debounce_sources[key] = GLib.timeout_add(delay_ms, _fire)
+
+
+def _run_command_async(commands: list[dict] | dict, pending_text: str) -> None:
+    _set_status_text(pending_text, "busy")
+    command_list = commands if isinstance(commands, list) else [commands]
+
+    def worker() -> None:
+        last_result = {"ok": True}
+        for command in command_list:
+            last_result = _send_socket_command(command)
+            if not last_result.get("ok", True):
+                GLib.idle_add(_handle_command_result, None, last_result)
+                return
+
+        GLib.idle_add(_handle_command_result, _load_state(), last_result)
+
+    threading.Thread(
+        target=worker,
+        daemon=True,
+        name="claude-panel-sonnenuhr-command",
+    ).start()
+
+
+def _refresh_from_daemon_async(_button=None) -> None:
+    _set_status_text("Status wird geladen…", "busy")
+
+    def worker() -> None:
+        result = _send_socket_command({"cmd": "status"})
+        if result.get("ok", True) and "message" not in result:
+            result = dict(result)
+            result["message"] = "Status aktualisiert"
+        state = _extract_state(result) if result.get("ok", True) else None
+        if state is None:
+            state = _load_state()
+        GLib.idle_add(_handle_command_result, state, result)
+
+    threading.Thread(
+        target=worker,
+        daemon=True,
+        name="claude-panel-sonnenuhr-refresh",
+    ).start()
+
+
+def _handle_command_result(state: dict | None, result: dict) -> bool:
+    global _last_user_interaction
+    if result and not result.get("ok", True):
+        _set_status_text(result.get("error", "Unbekannter Fehler"), "error")
+        return False
+
+    # Clear cooldown — command response has fresh state from daemon
+    _last_user_interaction = 0.0
+    if state is not None:
+        _apply_state_to_ui(state, force=True)
+    else:
+        _apply_state_to_ui(_load_state(), force=True)
+
+    message = result.get("message") or "Einstellung übernommen"
+    _set_status_text(message, "ok")
+    return False
+
+
+def _set_status_text(text: str, tone: str = "dim") -> None:
+    if _footer_status is None:
+        return
+    palette = get_palette()
+    color = {
+        "ok": palette["green"],
+        "error": palette["red"],
+        "busy": palette["yellow"],
+        "dim": palette["dim"],
+    }.get(tone, palette["dim"])
+    escaped = GLib.markup_escape_text(text)
+    _footer_status.set_markup(
+        f'<span foreground="{color}" size="small">{escaped}</span>'
+    )
+
+
+def _fmt(iso: str | None, fmt: str = "%H:%M") -> str:
+    if not iso:
+        return "—"
+    try:
+        return datetime.fromisoformat(iso).strftime(fmt)
+    except (TypeError, ValueError):
+        return "—"
+
+
+def _day_progress(state: dict) -> float:
+    try:
+        sun = state["sun_times"]
+        sunrise = datetime.fromisoformat(sun["sunrise"])
+        sunset = datetime.fromisoformat(sun["sunset"])
+        now = datetime.now(tz=sunrise.tzinfo)
+        if now <= sunrise:
+            return 0.0
+        if now >= sunset:
+            return 1.0
+        return (now - sunrise).total_seconds() / (sunset - sunrise).total_seconds()
+    except Exception:
+        return 0.0
+
+
+def _section(title: str) -> Gtk.Box:
+    box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+    box.get_style_context().add_class("section-frame")
+    box.set_margin_bottom(10)
+    label = Gtk.Label(label=title)
+    label.get_style_context().add_class("section-title")
+    label.set_halign(Gtk.Align.START)
+    box.pack_start(label, False, False, 0)
+    return box
+
+
+def _lbl(markup: str, halign: Gtk.Align = Gtk.Align.START) -> Gtk.Label:
+    label = Gtk.Label()
+    label.set_markup(markup)
+    label.set_halign(halign)
+    label.set_xalign(0.0 if halign != Gtk.Align.END else 1.0)
+    return label
+
+
+def _build_radio_row(options: list[tuple[str, str]], callback) -> tuple[Gtk.Box, dict[str, Gtk.RadioButton]]:
+    row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
+    buttons: dict[str, Gtk.RadioButton] = {}
+    group: Gtk.RadioButton | None = None
+
+    for key, label in options:
+        button = Gtk.RadioButton.new_with_label_from_widget(group, label)
+        button.set_can_focus(False)
+        button.connect("toggled", callback, key)
+        row.pack_start(button, False, False, 0)
+        buttons[key] = button
+        if group is None:
+            group = button
+
+    return row, buttons
+
+
+def _set_fixed_controls_sensitive(enabled: bool) -> None:
+    if _refresh_button is not None:
+        _refresh_button.set_sensitive(True)
+    for button in _mode_buttons.values():
+        button.set_sensitive(enabled)
+    for button in _theme_buttons.values():
+        button.set_sensitive(enabled)
+    if _brightness_scale is not None:
+        _brightness_scale.set_sensitive(enabled)
+    if _temp_scale is not None:
+        _temp_scale.set_sensitive(enabled)
+
+
+def _set_brightness_value_markup(value: int) -> None:
+    if _brightness_value is None:
+        return
+    palette = get_palette()
+    _brightness_value.set_markup(
+        f'<span foreground="{palette["peach"]}" font_size="22000" font_weight="bold">'
+        f"{value}%</span>"
+    )
+
+
+def _set_temp_value_markup(value: int) -> None:
+    if _temp_value is None:
+        return
+    palette = get_palette()
+    _temp_value.set_markup(
+        f'<span foreground="{palette["yellow"]}" font_size="22000" font_weight="bold">'
+        f"{value} K</span>"
+    )
+
+
+def _on_mode_toggled(button: Gtk.RadioButton, mode: str) -> None:
+    global _last_user_interaction
+    if _ui_syncing or not button.get_active():
+        return
+    _last_user_interaction = time.monotonic()
+
+    if mode == "auto":
+        command = {"cmd": "auto"}
+    elif mode == "disabled":
+        command = {"cmd": "disable"}
+    else:
+        minutes = int((_last_state or {}).get("override_duration_minutes", 120))
+        command = {"cmd": "override", "minutes": minutes}
+
+    _run_command_async(command, "Modus wird gesetzt…")
+
+
+def _on_theme_toggled(button: Gtk.RadioButton, mode: str) -> None:
+    global _last_user_interaction
+    if _ui_syncing or not button.get_active():
+        return
+    _last_user_interaction = time.monotonic()
+    _run_command_async({"cmd": "theme", "mode": mode}, "Theme wird gesetzt…")
+
+
+def _on_global_brightness_changed(scale: Gtk.Scale) -> None:
+    global _last_user_interaction
+    if _ui_syncing:
+        return
+    _last_user_interaction = time.monotonic()
+
+    value = int(round(scale.get_value()))
+    _set_brightness_value_markup(value)
+    _schedule_command(
+        "global_brightness",
+        lambda: _run_command_async(
+            {"cmd": "set", "brightness": value},
+            "Globale Helligkeit wird gesetzt…",
+        ),
+    )
+
+
+def _on_global_temp_changed(scale: Gtk.Scale) -> None:
+    global _last_user_interaction
+    if _ui_syncing:
+        return
+    _last_user_interaction = time.monotonic()
+
+    value = int(round(scale.get_value() / 50.0) * 50)
+    _set_temp_value_markup(value)
+    _schedule_command(
+        "global_temp",
+        lambda: _run_command_async(
+            {"cmd": "color", "kelvin": value},
+            "Globale Farbtemperatur wird gesetzt…",
+        ),
+    )
+
+
+def _on_display_brightness_changed(
+    scale: Gtk.Scale,
+    display_name: str,
+    value_label: Gtk.Label,
+) -> None:
+    global _last_user_interaction
+    _last_user_interaction = time.monotonic()
+    value = int(round(scale.get_value()))
+    palette = get_palette()
+    value_label.set_markup(
+        f'<tt><span foreground="{palette["peach"]}" size="small">{value}%</span></tt>'
+    )
+    _schedule_command(
+        f"display-brightness:{display_name}",
+        lambda: _run_command_async(
+            {"cmd": "set_display", "display": display_name, "brightness": value},
+            f"{display_name} wird angepasst…",
+        ),
+    )
+
+
+def _on_display_offset_changed(
+    scale: Gtk.Scale,
+    display_name: str,
+    value_label: Gtk.Label,
+) -> None:
+    global _last_user_interaction
+    _last_user_interaction = time.monotonic()
+    value = int(round(scale.get_value()))
+    palette = get_palette()
+    value_label.set_markup(
+        f'<tt><span foreground="{palette["overlay"]}" size="small">{value:+d}</span></tt>'
+    )
+    _schedule_command(
+        f"display-offset:{display_name}",
+        lambda: _run_command_async(
+            {"cmd": "set_display_offset", "display": display_name, "offset": value},
+            f"{display_name} Korrektur wird gespeichert…",
+        ),
+        delay_ms=500,
+    )
+
+
+def _on_display_enabled_changed(
+    switch: Gtk.Switch,
+    _pspec,
+    display_name: str,
+) -> None:
+    global _last_user_interaction
+    _last_user_interaction = time.monotonic()
+    _run_command_async(
+        {
+            "cmd": "set_display_enabled",
+            "display": display_name,
+            "enabled": switch.get_active(),
+        },
+        f"{display_name} wird aktualisiert…",
+    )
+
+
+def _build_display_row(display: dict, palette: dict, base_brightness: int) -> Gtk.Box:
+    card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
+    card.get_style_context().add_class("section-frame")
+    card.set_margin_bottom(8)
+    card.set_margin_top(2)
+    card.set_margin_start(4)
+    card.set_margin_end(4)
+
+    display_name = display.get("name", "unknown")
+    connected = bool(display.get("connected", False))
+    enabled = bool(display.get("enabled", True))
+    brightness = display.get("brightness")
+    brightness = int(brightness) if isinstance(brightness, int) else base_brightness
+    offset = int(display.get("brightness_offset", 0))
+    rgb = display.get("rgb")
+
+    top = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    dot_color = palette["green"] if (connected and enabled) else (
+        palette["yellow"] if connected else palette["red"]
+    )
+    dot = "✓" if (connected and enabled) else ("○" if connected else "✗")
+    top.pack_start(
+        _lbl(f'<span foreground="{dot_color}">{dot}</span>'),
+        False,
+        False,
+        0,
+    )
+
+    name = _lbl(
+        f'<tt><span foreground="{palette["subtext1"]}" size="small">'
+        f"{GLib.markup_escape_text(display_name)}</span></tt>"
+    )
+    name.set_ellipsize(Pango.EllipsizeMode.MIDDLE)
+    name.set_max_width_chars(38)
+    top.pack_start(name, True, True, 0)
+
+    connected_text = "verbunden" if connected else "getrennt"
+    top.pack_end(
+        _lbl(
+            f'<span foreground="{dot_color}" size="small">{connected_text}</span>',
+            Gtk.Align.END,
+        ),
+        False,
+        False,
+        0,
+    )
+    card.pack_start(top, False, False, 0)
+
+    brightness_header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    brightness_header.pack_start(
+        _lbl(f'<span foreground="{palette["overlay"]}" size="small">Monitor-Helligkeit</span>'),
+        False,
+        False,
+        0,
+    )
+    brightness_value = _lbl(
+        f'<tt><span foreground="{palette["peach"]}" size="small">{brightness}%</span></tt>',
+        Gtk.Align.END,
+    )
+    brightness_header.pack_end(brightness_value, False, False, 0)
+    card.pack_start(brightness_header, False, False, 0)
+
+    brightness_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 100, 1)
+    brightness_scale.set_draw_value(False)
+    brightness_scale.set_value(float(brightness))
+    brightness_scale.connect(
+        "value-changed",
+        _on_display_brightness_changed,
+        display_name,
+        brightness_value,
+    )
+    card.pack_start(brightness_scale, False, False, 0)
+
+    offset_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
+    offset_row.pack_start(
+        _lbl(f'<span foreground="{palette["overlay"]}" size="small">Offset</span>'),
+        False,
+        False,
+        0,
+    )
+    offset_value = _lbl(
+        f'<tt><span foreground="{palette["overlay"]}" size="small">{offset:+d}</span></tt>'
+    )
+    offset_row.pack_end(offset_value, False, False, 0)
+    card.pack_start(offset_row, False, False, 0)
+
+    offset_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, OFFSET_MIN, OFFSET_MAX, 1)
+    offset_scale.set_draw_value(False)
+    offset_scale.set_value(float(offset))
+    offset_scale.connect(
+        "value-changed",
+        _on_display_offset_changed,
+        display_name,
+        offset_value,
+    )
+    card.pack_start(offset_scale, False, False, 0)
+
+    footer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    enabled_label = _lbl(
+        f'<span foreground="{palette["overlay"]}" size="small">aktiv</span>'
+    )
+    enabled_switch = Gtk.Switch()
+    enabled_switch.set_active(enabled)
+    enabled_switch.connect("notify::active", _on_display_enabled_changed, display_name)
+    footer.pack_start(enabled_label, False, False, 0)
+    footer.pack_start(enabled_switch, False, False, 0)
+
+    if rgb is not None and len(rgb) == 3:
+        footer.pack_end(
+            _lbl(
+                f'<tt><span foreground="{palette["dim"]}" size="small">'
+                f"RGB {rgb[0]}/{rgb[1]}/{rgb[2]}</span></tt>",
+                Gtk.Align.END,
+            ),
+            False,
+            False,
+            0,
+        )
+
+    card.pack_start(footer, False, False, 0)
+    return card
+
+
+def _apply_state_to_ui(state: dict | None, force: bool = False) -> None:
+    global _last_state, _ui_syncing
+
+    palette = get_palette()
+    offline = state is None
+    # Skip slider/display updates during periodic refresh if user recently interacted.
+    # Command-response refreshes pass force=True and always update.
+    skip_controls = not force and (time.monotonic() - _last_user_interaction) < INTERACTION_COOLDOWN
+    if not offline:
+        _last_state = state
+
+    if _header_label is not None:
+        _header_label.set_markup("<b>☀ Sonnenuhr</b>")
+
+    if offline:
+        if _mode_badge is not None:
+            _mode_badge.set_markup(
+                f'<span foreground="{palette["red"]}" size="small">● offline</span>'
+            )
+        if _timeline_label is not None:
+            _timeline_label.set_markup(
+                f'<span foreground="{palette["red"]}" size="small">Daemon nicht aktiv</span>'
+            )
+        if _timeline_bar is not None:
+            _timeline_bar.set_fraction(0.0)
+            _timeline_bar.set_text("—")
+        _set_brightness_value_markup(0)
+        _set_temp_value_markup(0)
+        if _temp_rgb is not None:
+            _temp_rgb.set_markup(f'<span foreground="{palette["dim"]}" size="small">—</span>')
+        if _footer_update is not None:
+            _footer_update.set_markup(
+                f'<span foreground="{palette["dim"]}" size="small">Letzte Aktualisierung: —</span>'
+            )
+        if _footer_theme is not None:
+            _footer_theme.set_markup(
+                f'<span foreground="{palette["dim"]}" size="small">Theme: —</span>'
+            )
+        if _displays_box is not None:
+            for child in _displays_box.get_children():
+                _displays_box.remove(child)
+            _displays_box.pack_start(
+                _lbl(f'<span foreground="{palette["dim"]}">Keine Displays</span>'),
+                False,
+                False,
+                0,
+            )
+            _displays_box.show_all()
+        _set_fixed_controls_sensitive(False)
+        return
+
+    mode = state.get("mode", "unknown")
+    brightness = int(state.get("brightness", 0))
+    color_temp = int(state.get("color_temp", 6500))
+    sun = state.get("sun_times", {})
+    is_daytime = bool(state.get("is_daytime", False))
+    displays = state.get("displays", [])
+    theme_name = state.get("theme", "—")
+    theme_locked = bool(state.get("theme_locked", False))
+    theme_auto_switch = bool(state.get("theme_auto_switch", True))
+    override_minutes = int(state.get("override_duration_minutes", 120))
+
+    if _mode_badge is not None:
+        badge_color = {
+            "auto": palette["green"],
+            "override": palette["yellow"],
+            "disabled": palette["red"],
+        }.get(mode, palette["red"])
+        _mode_badge.set_markup(
+            f'<span foreground="{badge_color}" size="small">● {mode}</span>'
+        )
+
+    if _timeline_label is not None:
+        day_text = "☀ Tag" if is_daytime else "☾ Nacht"
+        _timeline_label.set_markup(
+            f'<span foreground="{palette["overlay"]}" size="small">'
+            f"↑ {_fmt(sun.get('sunrise'))}  {day_text}  ↓ {_fmt(sun.get('sunset'))}</span>"
+        )
+    if _timeline_bar is not None:
+        _timeline_bar.set_fraction(_day_progress(state))
+        _timeline_bar.set_text(f"{_fmt(sun.get('sunrise'))} → {_fmt(sun.get('sunset'))}")
+
+    _set_brightness_value_markup(brightness)
+    _set_temp_value_markup(color_temp)
+
+    rgb = next((d.get("rgb") for d in displays if d.get("rgb") is not None), None)
+    if _temp_rgb is not None:
+        rgb_text = f"RGB: {rgb[0]} / {rgb[1]} / {rgb[2]}" if rgb else "—"
+        _temp_rgb.set_markup(
+            f'<span foreground="{palette["overlay"]}" size="small">{rgb_text}</span>'
+        )
+
+    _ui_syncing = True
+    try:
+        _set_fixed_controls_sensitive(True)
+        if not skip_controls:
+            if _brightness_scale is not None:
+                _brightness_scale.set_value(float(brightness))
+            if _temp_scale is not None:
+                _temp_scale.set_value(float(color_temp))
+
+            for key, button in _mode_buttons.items():
+                button.set_active(key == mode)
+
+            selected_theme = "auto" if not theme_locked else theme_name
+            for key, button in _theme_buttons.items():
+                button.set_active(key == selected_theme)
+    finally:
+        _ui_syncing = False
+
+    if _displays_box is not None and not skip_controls:
+        for child in _displays_box.get_children():
+            _displays_box.remove(child)
+        if displays:
+            for display in displays:
+                _displays_box.pack_start(
+                    _build_display_row(display, palette, brightness),
+                    False,
+                    False,
+                    0,
+                )
+        else:
+            _displays_box.pack_start(
+                _lbl(f'<span foreground="{palette["dim"]}">Keine Displays gefunden</span>'),
+                False,
+                False,
+                0,
+            )
+        _displays_box.show_all()
+
+    if _footer_update is not None:
+        _footer_update.set_markup(
+            f'<span foreground="{palette["dim"]}" size="small">'
+            f"Letzte Aktualisierung: {_fmt(state.get('last_update'), '%H:%M:%S')}</span>"
+        )
+    if _footer_theme is not None:
+        theme_mode = "gesperrt" if theme_locked else "auto"
+        suffix = "" if theme_locked or theme_auto_switch else ", Wechsel aus"
+        _footer_theme.set_markup(
+            f'<span foreground="{palette["dim"]}" size="small">'
+            f"Theme: {theme_name} ({theme_mode}{suffix}) · Override: {override_minutes} min</span>"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Refresh
+# ---------------------------------------------------------------------------
+
+def _do_refresh() -> bool:
+    _apply_state_to_ui(_load_state())
+    return False
+
+
+def refresh_brightness(_tab=None) -> bool:
+    GLib.idle_add(_do_refresh)
+    return True
+
+
+def build_brightness_tab() -> Gtk.ScrolledWindow:
+    global _header_label, _mode_badge, _refresh_button, _timeline_bar, _timeline_label
+    global _brightness_value, _brightness_scale, _temp_value, _temp_scale, _temp_rgb
+    global _displays_box, _footer_update, _footer_theme, _footer_status
+    global _mode_buttons, _theme_buttons
+
+    scrolled = Gtk.ScrolledWindow()
+    scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    scrolled.set_hexpand(True)
+    scrolled.set_vexpand(True)
+
+    root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+    root.set_margin_top(10)
+    root.set_margin_bottom(10)
+    root.set_margin_start(10)
+    root.set_margin_end(10)
+    scrolled.add(root)
+
+    palette = get_palette()
+
+    header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    header.set_margin_bottom(8)
+    _header_label = _lbl("<b>☀ Sonnenuhr</b>")
+    attrs = Pango.AttrList()
+    attrs.insert(Pango.attr_scale_new(1.1))
+    _header_label.set_attributes(attrs)
+    header.pack_start(_header_label, True, True, 0)
+
+    _mode_badge = _lbl(
+        f'<span foreground="{palette["dim"]}" size="small">● lade…</span>',
+        Gtk.Align.END,
+    )
+    header.pack_end(_mode_badge, False, False, 0)
+
+    _refresh_button = Gtk.Button(label="Aktualisieren")
+    _refresh_button.set_can_focus(False)
+    _refresh_button.connect("clicked", _refresh_from_daemon_async)
+    header.pack_end(_refresh_button, False, False, 0)
+    root.pack_start(header, False, False, 0)
+
+    timeline = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    timeline.get_style_context().add_class("section-frame")
+    timeline.set_margin_bottom(10)
+    _timeline_label = _lbl(
+        f'<span foreground="{palette["overlay"]}" size="small">Lade…</span>',
+        Gtk.Align.CENTER,
+    )
+    timeline.pack_start(_timeline_label, False, False, 0)
+    _timeline_bar = Gtk.ProgressBar()
+    _timeline_bar.set_show_text(True)
+    _timeline_bar.set_fraction(0.0)
+    _timeline_bar.set_text("—")
+    timeline.pack_start(_timeline_bar, False, False, 0)
+    root.pack_start(timeline, False, False, 0)
+
+    mode_section = _section("Modus")
+    mode_row, _mode_buttons = _build_radio_row(
+        [("auto", "Auto"), ("override", "Override"), ("disabled", "Disabled")],
+        _on_mode_toggled,
+    )
+    mode_section.pack_start(mode_row, False, False, 0)
+    root.pack_start(mode_section, False, False, 0)
+
+    theme_section = _section("Theme")
+    theme_row, _theme_buttons = _build_radio_row(
+        [("dark", "Dark"), ("light", "Light"), ("auto", "Auto")],
+        _on_theme_toggled,
+    )
+    theme_section.pack_start(theme_row, False, False, 0)
+    root.pack_start(theme_section, False, False, 0)
+
+    brightness_section = _section("Globale Helligkeit")
+    _brightness_value = _lbl(
+        f'<span foreground="{palette["peach"]}" font_size="22000" font_weight="bold">—</span>'
+    )
+    brightness_section.pack_start(_brightness_value, False, False, 0)
+    _brightness_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 100, 1)
+    _brightness_scale.set_draw_value(False)
+    _brightness_scale.set_value(0)
+    _brightness_scale.connect("value-changed", _on_global_brightness_changed)
+    brightness_section.pack_start(_brightness_scale, False, False, 0)
+    root.pack_start(brightness_section, False, False, 0)
+
+    temp_section = _section("Globale Farbtemperatur")
+    _temp_value = _lbl(
+        f'<span foreground="{palette["yellow"]}" font_size="22000" font_weight="bold">—</span>'
+    )
+    temp_section.pack_start(_temp_value, False, False, 0)
+    _temp_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 2700, 6500, 50)
+    _temp_scale.set_draw_value(False)
+    _temp_scale.set_value(6500)
+    _temp_scale.connect("value-changed", _on_global_temp_changed)
+    temp_section.pack_start(_temp_scale, False, False, 0)
+    _temp_rgb = _lbl(f'<span foreground="{palette["overlay"]}" size="small">—</span>')
+    temp_section.pack_start(_temp_rgb, False, False, 0)
+    root.pack_start(temp_section, False, False, 0)
+
+    displays_section = _section("Displays")
+    _displays_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+    displays_section.pack_start(_displays_box, False, False, 0)
+    root.pack_start(displays_section, False, False, 0)
+
+    separator = Gtk.Separator()
+    separator.set_margin_top(4)
+    separator.set_margin_bottom(6)
+    root.pack_start(separator, False, False, 0)
+
+    _footer_update = _lbl(
+        f'<span foreground="{palette["dim"]}" size="small">Letzte Aktualisierung: —</span>'
+    )
+    root.pack_start(_footer_update, False, False, 0)
+    _footer_theme = _lbl(
+        f'<span foreground="{palette["dim"]}" size="small">Theme: —</span>'
+    )
+    root.pack_start(_footer_theme, False, False, 0)
+    _footer_status = _lbl(
+        f'<span foreground="{palette["dim"]}" size="small">Bereit</span>'
+    )
+    root.pack_start(_footer_status, False, False, 0)
+
+    GLib.idle_add(_do_refresh)
+    scrolled.show_all()
+    return scrolled

claude-panel.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Name=Claude Code Panel
+Comment=Control Panel fuer Claude Code — Settings, Hooks, Sessions, Skills
+Exec=python3 /home/smlflg/Projekte/ClaudeCodePanel/panel.py
+Icon=preferences-system
+Terminal=false
+Type=Application
+Categories=Development;Settings;
+Keywords=claude;code;settings;panel;ai;
+StartupWMClass=claude-code-panel

claude-panel.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Claude Code Control Panel (GTK3 + Tray Icon)
+After=graphical-session.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/python3 /home/smlflg/Projekte/ClaudeCodePanel/panel.py
+Restart=on-failure
+RestartSec=5
+StartLimitIntervalSec=60
+StartLimitBurst=5
+
+[Install]
+WantedBy=default.target

config_io.py

@@ -0,0 +1,168 @@
+"""Config I/O for Claude Code Control Panel.
+
+Reads and writes ~/.claude/settings.json with atomic operations (backup + tmp + rename).
+Also handles hook configuration and coaching script parameters.
+"""
+
+import json
+import os
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+SETTINGS_PATH = Path.home() / ".claude" / "settings.json"
+COACH_SCRIPT = Path.home() / ".claude" / "hooks" / "coaching" / "coach-git-test.sh"
+
+
+def read_settings() -> dict:
+    """Read and parse ~/.claude/settings.json."""
+    if not SETTINGS_PATH.exists():
+        return {}
+    with SETTINGS_PATH.open() as f:
+        return json.load(f)
+
+
+def write_settings(settings: dict) -> None:
+    """Atomically write settings.json (backup + tmp + rename)."""
+    # Create backup
+    if SETTINGS_PATH.exists():
+        backup = SETTINGS_PATH.with_suffix(
+            f".json.backup-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+        )
+        shutil.copy2(SETTINGS_PATH, backup)
+
+    # Write to temp file, then atomic rename
+    fd, tmp_path = tempfile.mkstemp(
+        dir=SETTINGS_PATH.parent, suffix=".tmp", prefix="settings-"
+    )
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(settings, f, indent=2, ensure_ascii=False)
+            f.write("\n")
+        os.replace(tmp_path, SETTINGS_PATH)
+    except Exception:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise
+
+
+def update_setting(key_path: str, value) -> dict:
+    """Update a nested key in settings.json using dot notation.
+
+    Example: update_setting("env.SLASH_COMMAND_TOOL_CHAR_BUDGET", "15000")
+    """
+    settings = read_settings()
+    keys = key_path.split(".")
+    obj = settings
+    for key in keys[:-1]:
+        if key not in obj:
+            obj[key] = {}
+        obj = obj[key]
+    obj[keys[-1]] = value
+    write_settings(settings)
+    return settings
+
+
+def read_hook_list() -> list[dict]:
+    """Extract all hooks from settings.json as a flat list.
+
+    Returns list of dicts with:
+        event, group_index, matcher, command, timeout, async_, short_name
+    """
+    settings = read_settings()
+    hooks_config = settings.get("hooks", {})
+    result = []
+
+    for event_name, hook_groups in hooks_config.items():
+        for group_idx, group in enumerate(hook_groups):
+            matcher = group.get("matcher", "")
+            for hook in group.get("hooks", []):
+                command = hook.get("command", "")
+                short_name = _derive_hook_name(command)
+                result.append({
+                    "event": event_name,
+                    "group_index": group_idx,
+                    "matcher": matcher,
+                    "command": command,
+                    "timeout": hook.get("timeout", 10),
+                    "async_": hook.get("async", False),
+                    "short_name": short_name,
+                })
+    return result
+
+
+def _derive_hook_name(command: str) -> str:
+    """Extract a readable name from a hook command path."""
+    parts = command.strip().split()
+    for part in reversed(parts):
+        if "/" in part:
+            name = Path(part).stem
+            return name.replace("_", " ").replace("-", " ").title()
+    return command[:30]
+
+
+def update_hook(event: str, group_index: int, field: str, value) -> dict:
+    """Update a specific hook parameter in settings.json.
+
+    field can be: 'timeout', 'async'
+    """
+    settings = read_settings()
+    hooks_config = settings.get("hooks", {})
+
+    if event not in hooks_config:
+        raise KeyError(f"Event '{event}' not found in hooks config")
+    if group_index >= len(hooks_config[event]):
+        raise IndexError(f"Group index {group_index} out of range")
+
+    group = hooks_config[event][group_index]
+    for hook in group.get("hooks", []):
+        if field == "timeout":
+            hook["timeout"] = value
+        elif field == "async":
+            if value:
+                hook["async"] = True
+            elif "async" in hook:
+                del hook["async"]
+
+    write_settings(settings)
+    return settings
+
+
+def read_coaching_rate_limit() -> int:
+    """Read RATE_LIMIT_SECONDS from coach-git-test.sh."""
+    if not COACH_SCRIPT.exists():
+        return 300
+    with COACH_SCRIPT.open() as f:
+        for line in f:
+            if line.strip().startswith("RATE_LIMIT_SECONDS="):
+                try:
+                    return int(line.split("=", 1)[1].strip().split("#")[0].strip())
+                except ValueError:
+                    return 300
+    return 300
+
+
+def write_coaching_rate_limit(seconds: int) -> None:
+    """Update RATE_LIMIT_SECONDS in coach-git-test.sh."""
+    if not COACH_SCRIPT.exists():
+        return
+
+    lines = COACH_SCRIPT.read_text().splitlines(keepends=True)
+    new_lines = []
+    for line in lines:
+        if line.strip().startswith("RATE_LIMIT_SECONDS="):
+            new_lines.append(f"RATE_LIMIT_SECONDS={seconds}   # {seconds // 60} minutes\n")
+        else:
+            new_lines.append(line)
+
+    # Atomic write
+    fd, tmp = tempfile.mkstemp(dir=COACH_SCRIPT.parent, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.writelines(new_lines)
+        os.replace(tmp, COACH_SCRIPT)
+    except Exception:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
+        raise

event_tab.py

@@ -0,0 +1,426 @@
+"""Event tab widget for Claude Code Control Panel.
+
+Live hook event viewer with filtering and auto-scroll.
+Reads from ~/.claude/events/YYYY-MM-DD.jsonl (day-file tracking).
+Auto-refreshes via external timer calling refresh_events().
+"""
+
+import json
+from datetime import date, datetime
+from pathlib import Path
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GLib, Pango
+
+from theme import get_palette
+from utils import idle_once
+
+EVENTS_DIR = Path.home() / ".claude" / "events"
+
+_MAX_ROWS = 500
+
+# Module-level widget references
+_list_box = None
+_filter_combo = None
+_search_entry = None
+_auto_scroll_btn = None
+_scrolled_window = None
+_stats_label = None
+
+# State
+_rows = []           # list of parsed event dicts (most recent last)
+_file_offset = 0     # byte offset into current day file
+_current_day = None  # date string "YYYY-MM-DD" of last read
+
+# All known hook event types (for filter combo population)
+_KNOWN_TYPES = [
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "UserPromptSubmit",
+    "SubagentStart",
+    "SubagentStop",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact",
+    "Notification",
+    "PermissionRequest",
+    "Stop",
+]
+
+
+def _type_color(event_type: str) -> str:
+    """Return palette hex color for a given event type badge."""
+    p = get_palette()
+    mapping = {
+        "PreToolUse": p["accent"],
+        "PostToolUse": p["green"],
+        "PostToolUseFailure": p["red"],
+        "UserPromptSubmit": p["mauve"],
+        "SubagentStart": p["peach"],
+        "SubagentStop": p["yellow"],
+        "SessionStart": p["teal"],
+        "SessionEnd": p["teal"],
+        "PreCompact": p["peach"],
+        "Notification": p["lavender"],
+        "PermissionRequest": p["red"],
+        "Stop": p["dim"],
+    }
+    return mapping.get(event_type, p["overlay"])
+
+
+def build_events_tab() -> Gtk.ScrolledWindow:
+    """Build the Events tab widget."""
+    global _list_box, _filter_combo, _search_entry, _auto_scroll_btn
+    global _scrolled_window, _stats_label
+
+    outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+
+    # --- Toolbar ---
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.get_style_context().add_class("log-toolbar")
+    toolbar.set_margin_top(8)
+    toolbar.set_margin_bottom(6)
+    toolbar.set_margin_start(10)
+    toolbar.set_margin_end(10)
+
+    filter_label = Gtk.Label(label="Type:")
+    toolbar.pack_start(filter_label, False, False, 0)
+
+    _filter_combo = Gtk.ComboBoxText()
+    _filter_combo.append_text("All")
+    for t in _KNOWN_TYPES:
+        _filter_combo.append_text(t)
+    _filter_combo.set_active(0)
+    _filter_combo.connect("changed", _on_filter_changed)
+    toolbar.pack_start(_filter_combo, False, False, 0)
+
+    session_label = Gtk.Label(label="Session:")
+    toolbar.pack_start(session_label, False, False, 0)
+
+    _search_entry = Gtk.SearchEntry()
+    _search_entry.set_placeholder_text("session ID...")
+    _search_entry.set_size_request(140, -1)
+    _search_entry.connect("search-changed", _on_filter_changed)
+    toolbar.pack_start(_search_entry, False, False, 0)
+
+    # Spacer
+    spacer = Gtk.Label(label="")
+    spacer.set_hexpand(True)
+    toolbar.pack_start(spacer, True, True, 0)
+
+    _stats_label = Gtk.Label(label="")
+    _stats_label.set_xalign(1.0)
+    _stats_label.get_style_context().add_class("log-stats")
+    toolbar.pack_start(_stats_label, False, False, 0)
+
+    _auto_scroll_btn = Gtk.ToggleButton(label="Auto-scroll")
+    _auto_scroll_btn.set_active(True)
+    toolbar.pack_start(_auto_scroll_btn, False, False, 0)
+
+    clear_btn = Gtk.Button(label="Clear")
+    clear_btn.connect("clicked", _on_clear_clicked)
+    toolbar.pack_start(clear_btn, False, False, 0)
+
+    outer.pack_start(toolbar, False, False, 0)
+    outer.pack_start(
+        Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 0
+    )
+
+    # --- Scrolled list ---
+    _scrolled_window = Gtk.ScrolledWindow()
+    _scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    _scrolled_window.set_vexpand(True)
+
+    _list_box = Gtk.ListBox()
+    _list_box.set_selection_mode(Gtk.SelectionMode.NONE)
+    _scrolled_window.add(_list_box)
+
+    outer.pack_start(_scrolled_window, True, True, 0)
+
+    # Wrap in a ScrolledWindow for the tab API contract
+    wrapper = Gtk.ScrolledWindow()
+    wrapper.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER)
+    wrapper.add(outer)
+
+    idle_once(refresh_events)
+    return wrapper
+
+
+def refresh_events() -> bool:
+    """Called by panel.py timer (2s). Reads new JSONL lines. Returns True to keep timer."""
+    global _file_offset, _current_day, _rows
+
+    if _list_box is None:
+        return True
+
+    try:
+        today_str = date.today().isoformat()
+
+        # Day rollover — reset offset
+        if _current_day != today_str:
+            _file_offset = 0
+            _current_day = today_str
+
+        today_file = EVENTS_DIR / f"{today_str}.jsonl"
+        if not today_file.exists():
+            _update_stats()
+            return True
+
+        new_events = []
+        try:
+            with today_file.open("rb") as f:
+                f.seek(_file_offset)
+                while True:
+                    line = f.readline()
+                    if not line:
+                        break
+                    _file_offset = f.tell()
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                        new_events.append(data)
+                    except json.JSONDecodeError:
+                        continue
+        except OSError:
+            return True
+
+        if not new_events:
+            return True
+
+        for event in new_events:
+            _rows.append(event)
+
+        # Trim to max rows
+        if len(_rows) > _MAX_ROWS:
+            excess = len(_rows) - _MAX_ROWS
+            _rows = _rows[excess:]
+            # Remove oldest rows from list_box
+            children = _list_box.get_children()
+            for i in range(min(excess, len(children))):
+                _list_box.remove(children[i])
+
+        # Add new rows to list_box
+        active_type = _current_filter_type()
+        session_filter = _current_session_filter()
+        for event in new_events:
+            if _event_matches(event, active_type, session_filter):
+                row = _build_row(event)
+                _list_box.add(row)
+
+        _list_box.show_all()
+        _update_stats()
+
+        # Auto-scroll
+        if _auto_scroll_btn is not None and _auto_scroll_btn.get_active():
+            _scroll_to_bottom()
+
+    except Exception:
+        pass
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Row building
+# ---------------------------------------------------------------------------
+
+def _build_row(event: dict) -> Gtk.ListBoxRow:
+    """Create a single ListBoxRow from an event dict."""
+    row = Gtk.ListBoxRow()
+    row.set_activatable(False)
+
+    hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
+    hbox.set_margin_top(3)
+    hbox.set_margin_bottom(3)
+    hbox.set_margin_start(8)
+    hbox.set_margin_end(8)
+
+    # Time label
+    time_str = _parse_time(event)
+    time_lbl = Gtk.Label(label=time_str)
+    time_lbl.set_size_request(65, -1)
+    time_lbl.set_xalign(0.0)
+    time_lbl.get_style_context().add_class("log-time")
+    hbox.pack_start(time_lbl, False, False, 0)
+
+    # Type badge (colored via Pango markup)
+    event_type = event.get("hook_event_name", event.get("type", "Unknown"))
+    color = _type_color(event_type)
+    badge = Gtk.Label()
+    badge.set_markup(f'<span foreground="{color}" font_weight="bold">{GLib.markup_escape_text(event_type)}</span>')
+    badge.set_size_request(160, -1)
+    badge.set_xalign(0.0)
+    badge.set_ellipsize(Pango.EllipsizeMode.END)
+    hbox.pack_start(badge, False, False, 0)
+
+    # Session ID (first 8 chars)
+    session_id = event.get("session_id", "")
+    session_short = session_id[:8] if session_id else "—"
+    session_lbl = Gtk.Label(label=session_short)
+    session_lbl.set_size_request(72, -1)
+    session_lbl.set_xalign(0.0)
+    session_lbl.get_style_context().add_class("log-time")
+    hbox.pack_start(session_lbl, False, False, 0)
+
+    # Detail text
+    detail = _event_detail(event)
+    detail_lbl = Gtk.Label(label=detail)
+    detail_lbl.set_hexpand(True)
+    detail_lbl.set_xalign(0.0)
+    detail_lbl.set_ellipsize(Pango.EllipsizeMode.END)
+    detail_lbl.get_style_context().add_class("log-detail")
+    hbox.pack_start(detail_lbl, True, True, 0)
+
+    row.add(hbox)
+
+    # Tooltip: full event JSON summary
+    tooltip_parts = []
+    if session_id:
+        tooltip_parts.append(f"session: {session_id}")
+    tool = event.get("tool_name") or event.get("tool")
+    if tool:
+        tooltip_parts.append(f"tool: {tool}")
+    if tooltip_parts:
+        row.set_tooltip_text(" | ".join(tooltip_parts))
+
+    return row
+
+
+def _parse_time(event: dict) -> str:
+    """Extract HH:MM:SS from event timestamp."""
+    ts = event.get("timestamp", event.get("time", ""))
+    if not ts:
+        return ""
+    try:
+        dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        return dt.astimezone().strftime("%H:%M:%S")
+    except (ValueError, TypeError):
+        return ts[:8] if len(ts) >= 8 else ts
+
+
+def _event_detail(event: dict) -> str:
+    """Extract a human-readable detail string from an event."""
+    # Tool name takes priority
+    tool = event.get("tool_name") or event.get("tool")
+    if tool:
+        path = event.get("tool_input", {}).get("path", "") if isinstance(event.get("tool_input"), dict) else ""
+        if path:
+            home = str(Path.home())
+            if path.startswith(home + "/"):
+                path = "~/" + path[len(home) + 1:]
+            return f"{tool}  {path}"
+        return tool
+
+    # Fallback: pick meaningful fields
+    for key in ("message", "text", "prompt", "summary", "reason", "content"):
+        val = event.get(key, "")
+        if val and isinstance(val, str):
+            return val[:120]
+
+    # Last resort: show non-meta keys
+    skip = {"timestamp", "time", "session_id", "hook_event_name", "type"}
+    parts = []
+    for k, v in event.items():
+        if k not in skip and not k.startswith("_"):
+            parts.append(f"{k}={v!r}")
+        if len(parts) >= 4:
+            break
+    return "  ".join(parts)[:120]
+
+
+# ---------------------------------------------------------------------------
+# Filtering
+# ---------------------------------------------------------------------------
+
+def _current_filter_type() -> str | None:
+    if _filter_combo is None:
+        return None
+    active = _filter_combo.get_active_text() or "All"
+    return None if active == "All" else active
+
+
+def _current_session_filter() -> str:
+    if _search_entry is None:
+        return ""
+    return (_search_entry.get_text() or "").strip().lower()
+
+
+def _event_matches(event: dict, filter_type: str | None, session_filter: str) -> bool:
+    if filter_type is not None:
+        etype = event.get("hook_event_name", event.get("type", ""))
+        if etype != filter_type:
+            return False
+    if session_filter:
+        sid = (event.get("session_id", "") or "").lower()
+        if session_filter not in sid:
+            return False
+    return True
+
+
+def _on_filter_changed(_widget):
+    """Rebuild visible rows when filter combo or search entry changes."""
+    _rebuild_list()
+
+
+def _rebuild_list():
+    """Clear and re-populate list_box from _rows with current filters."""
+    if _list_box is None:
+        return
+    for child in _list_box.get_children():
+        _list_box.remove(child)
+
+    active_type = _current_filter_type()
+    session_filter = _current_session_filter()
+
+    for event in _rows:
+        if _event_matches(event, active_type, session_filter):
+            row = _build_row(event)
+            _list_box.add(row)
+
+    _list_box.show_all()
+    _update_stats()
+
+    if _auto_scroll_btn is not None and _auto_scroll_btn.get_active():
+        _scroll_to_bottom()
+
+
+# ---------------------------------------------------------------------------
+# Actions
+# ---------------------------------------------------------------------------
+
+def _on_clear_clicked(_btn):
+    global _rows, _file_offset
+    _rows = []
+    _file_offset = 0  # re-read from start on next refresh (soft clear)
+    if _list_box is not None:
+        for child in _list_box.get_children():
+            _list_box.remove(child)
+    _update_stats()
+
+
+def _scroll_to_bottom():
+    if _scrolled_window is None:
+        return
+    adj = _scrolled_window.get_vadjustment()
+    if adj is not None:
+        GLib.idle_add(_do_scroll, adj)
+
+
+def _do_scroll(adj) -> bool:
+    adj.set_value(adj.get_upper() - adj.get_page_size())
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+def _update_stats():
+    if _stats_label is None:
+        return
+    total = len(_rows)
+    now = datetime.now().strftime("%H:%M")
+    _stats_label.set_text(f"{total} events | {now}")

log_viewer.py

@@ -0,0 +1,435 @@
+"""Log viewer widget for Claude Code Control Panel.
+
+Card-based log viewer with filtering and cost tracking.
+Reads today's usage JSONL + provider costs + coaching log.
+Auto-refreshes via external timer calling refresh_logs().
+"""
+
+import json
+from collections import deque
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GLib, Pango
+
+from utils import idle_once
+
+USAGE_DIR = Path.home() / ".claude" / "usage"
+COACHING_LOG = Path.home() / ".claude" / "hooks" / "coaching" / "coaching_log.md"
+PROVIDERS_FILE = USAGE_DIR / "providers.jsonl"
+
+_MAX_ENTRIES = 500
+
+# Module-level widget references
+_filter_combo = None
+_search_entry = None
+_stats_label = None
+_cards_container = None
+_last_entries = []
+_last_fingerprint = ("", 0)
+
+
+def build_logs_tab() -> Gtk.ScrolledWindow:
+    """Build and return the Logs tab widget."""
+    global _filter_combo, _search_entry, _stats_label, _cards_container
+
+    outer = Gtk.ScrolledWindow()
+    outer.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+
+    main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
+    main_box.set_margin_top(10)
+    main_box.set_margin_bottom(10)
+    main_box.set_margin_start(10)
+    main_box.set_margin_end(10)
+
+    # --- Toolbar ---
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.get_style_context().add_class("log-toolbar")
+
+    filter_label = Gtk.Label(label="Filter:")
+    toolbar.pack_start(filter_label, False, False, 0)
+
+    _filter_combo = Gtk.ComboBoxText()
+    for label in ["Alle", "Tools", "LLM", "Errors", "Hooks"]:
+        _filter_combo.append_text(label)
+    _filter_combo.set_active(0)
+    _filter_combo.connect("changed", _on_filter_changed)
+    toolbar.pack_start(_filter_combo, False, False, 0)
+
+    _search_entry = Gtk.SearchEntry()
+    _search_entry.set_placeholder_text("Suche...")
+    _search_entry.set_size_request(160, -1)
+    _search_entry.connect("search-changed", _on_filter_changed)
+    toolbar.pack_start(_search_entry, False, False, 0)
+
+    _stats_label = Gtk.Label(label="")
+    _stats_label.set_xalign(1.0)
+    _stats_label.set_hexpand(True)
+    _stats_label.get_style_context().add_class("log-stats")
+    toolbar.pack_start(_stats_label, True, True, 0)
+
+    main_box.pack_start(toolbar, False, False, 0)
+    main_box.pack_start(
+        Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, False, 0
+    )
+
+    # --- Inner scroll for cards ---
+    inner_scroll = Gtk.ScrolledWindow()
+    inner_scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    inner_scroll.set_vexpand(True)
+
+    _cards_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+    inner_scroll.add(_cards_container)
+
+    main_box.pack_start(inner_scroll, True, True, 0)
+    outer.add(main_box)
+
+    idle_once(refresh_logs)
+    return outer
+
+
+def refresh_logs() -> bool:
+    """Refresh log data from disk. Returns True to keep timer alive."""
+    global _last_fingerprint, _last_entries
+    try:
+        if _cards_container is None:
+            return True
+
+        entries = _read_usage_entries() + _read_coaching_entries() + _read_provider_costs_today()
+        entries.sort(key=lambda e: e.get("_sort_key", ""), reverse=True)
+        entries = entries[:_MAX_ENTRIES]
+
+        fingerprint = (entries[0].get("_sort_key", "") if entries else "", len(entries))
+        if fingerprint == _last_fingerprint:
+            _update_stats(entries)
+            return True
+
+        _last_entries = entries
+        _last_fingerprint = fingerprint
+        _rebuild_cards()
+        _update_stats(entries)
+    except Exception:
+        pass
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Data reading
+# ---------------------------------------------------------------------------
+
+def _read_usage_entries() -> list:
+    """Read today's usage JSONL (tool calls)."""
+    today_file = USAGE_DIR / f"{date.today().isoformat()}.jsonl"
+    if not today_file.exists():
+        return []
+
+    entries = []
+    try:
+        with today_file.open() as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                    ts = data.get("time", data.get("timestamp", ""))
+                    data["_sort_key"] = ts
+                    data["_type"] = "tool"
+                    entries.append(data)
+                except json.JSONDecodeError:
+                    continue
+    except OSError:
+        pass
+    return entries
+
+
+def _read_coaching_entries() -> list:
+    """Read last 20 lines from coaching log as hook entries."""
+    if not COACHING_LOG.exists():
+        return []
+
+    entries = []
+    try:
+        with COACHING_LOG.open() as f:
+            last_lines = deque(f, maxlen=20)
+        for line in last_lines:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            entries.append({
+                "_type": "hook",
+                "_sort_key": "",
+                "text": line,
+            })
+    except OSError:
+        pass
+    return entries
+
+
+def _read_provider_costs_today() -> list:
+    """Read today's provider entries from providers.jsonl."""
+    today = date.today().isoformat()
+    if not PROVIDERS_FILE.exists():
+        return []
+    entries = []
+    try:
+        with PROVIDERS_FILE.open() as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                    ts = data.get("time", data.get("timestamp", ""))
+                    if ts[:10] == today:
+                        data["_sort_key"] = ts
+                        data["_type"] = "llm"
+                        entries.append(data)
+                except json.JSONDecodeError:
+                    continue
+    except OSError:
+        pass
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Row building
+# ---------------------------------------------------------------------------
+
+def _entry_to_row(entry: dict) -> dict:
+    """Convert an entry dict to a row dict."""
+    etype = entry.get("_type", "tool")
+    sort_key = entry.get("_sort_key", "")
+
+    # Parse timestamp
+    ts_raw = entry.get("time", entry.get("timestamp", sort_key))
+    time_str = ""
+    if ts_raw:
+        try:
+            dt = datetime.fromisoformat(ts_raw.replace("Z", "+00:00"))
+            time_str = dt.astimezone().strftime("%H:%M:%S")
+        except (ValueError, TypeError):
+            time_str = ts_raw[:8]
+
+    if etype == "tool":
+        tool = entry.get("tool", "?")
+        file_path = entry.get("file", "")
+        cmd_cat = entry.get("cmd_cat", "")
+        detail = file_path or cmd_cat or ""
+        _home_prefix = str(Path.home()) + "/"
+        if detail.startswith(_home_prefix):
+            detail = "~/" + detail[len(_home_prefix):]
+        tooltip = f"{tool} {file_path or cmd_cat or ''}".strip()
+        cost_f = 0.0
+        cost_str = ""
+        if entry.get("error"):
+            status = "✗"
+            row_type = "error"
+        else:
+            status = "✓"
+            row_type = "tool"
+
+    elif etype == "llm":
+        provider = entry.get("provider", "?")
+        model = entry.get("model", "")
+        tool = f"{provider}/{model}" if model else provider
+        try:
+            cost_f = float(entry.get("cost_usd", 0.0))
+        except (TypeError, ValueError):
+            cost_f = 0.0
+        cost_str = f"${cost_f:.4f}" if cost_f else ""
+        try:
+            elapsed = float(entry.get("elapsed_s", 0))
+            detail = f"{elapsed:.1f}s" if elapsed else ""
+        except (TypeError, ValueError):
+            elapsed = 0
+            detail = ""
+        tooltip = f"{provider} {model} cost={cost_str}".strip()
+        status = "—"
+        row_type = "llm"
+
+    elif etype == "hook":
+        tool = "HOOK"
+        text = entry.get("text", "")
+        detail = text[:80]
+        tooltip = text
+        cost_f = 0.0
+        cost_str = ""
+        status = "—"
+        row_type = "hook"
+
+    else:
+        tool = etype
+        detail = ""
+        tooltip = ""
+        cost_f = 0.0
+        cost_str = ""
+        status = "—"
+        row_type = etype
+
+    return {
+        "time_str": time_str,
+        "tool": tool,
+        "detail": detail,
+        "cost_str": cost_str,
+        "status": status,
+        "row_type": row_type,
+        "tooltip": tooltip,
+        "cost_f": cost_f,
+        "sort_key": sort_key,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Card building
+# ---------------------------------------------------------------------------
+
+def _build_card(row: dict) -> Gtk.Box:
+    """Create a single HBox card widget from a row dict."""
+    row_type = row["row_type"]
+
+    card = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
+    ctx = card.get_style_context()
+    ctx.add_class("log-card")
+    ctx.add_class(f"log-card-{row_type}")
+
+    if row["tooltip"]:
+        card.set_tooltip_text(row["tooltip"])
+
+    # Time label — fixed 65px
+    time_lbl = Gtk.Label(label=row["time_str"])
+    time_lbl.set_size_request(65, -1)
+    time_lbl.set_xalign(0.0)
+    time_lbl.get_style_context().add_class("log-time")
+    card.pack_start(time_lbl, False, False, 0)
+
+    # Tool label — fixed 120px, ellipsize
+    tool_lbl = Gtk.Label(label=row["tool"])
+    tool_lbl.set_size_request(120, -1)
+    tool_lbl.set_xalign(0.0)
+    tool_lbl.set_ellipsize(Pango.EllipsizeMode.END)
+    tool_lbl.get_style_context().add_class("log-tool-name")
+    card.pack_start(tool_lbl, False, False, 0)
+
+    # Detail label — hexpand, ellipsize
+    detail_lbl = Gtk.Label(label=row["detail"])
+    detail_lbl.set_hexpand(True)
+    detail_lbl.set_xalign(0.0)
+    detail_lbl.set_ellipsize(Pango.EllipsizeMode.END)
+    detail_lbl.get_style_context().add_class("log-detail")
+    card.pack_start(detail_lbl, True, True, 0)
+
+    # Status label — fixed 20px
+    status = row["status"]
+    status_lbl = Gtk.Label(label=status)
+    status_lbl.set_size_request(20, -1)
+    status_lbl.set_xalign(0.5)
+    status_ctx = status_lbl.get_style_context()
+    if status == "✓":
+        status_ctx.add_class("log-status-ok")
+    elif status == "✗":
+        status_ctx.add_class("log-status-error")
+    else:
+        status_ctx.add_class("log-status-neutral")
+    card.pack_start(status_lbl, False, False, 0)
+
+    # Cost label — fixed 65px, right-aligned
+    cost_lbl = Gtk.Label(label=row["cost_str"])
+    cost_lbl.set_size_request(65, -1)
+    cost_lbl.set_xalign(1.0)
+    cost_lbl.get_style_context().add_class("log-cost")
+    card.pack_start(cost_lbl, False, False, 0)
+
+    return card
+
+
+def _rebuild_cards():
+    """Clear and rebuild the cards container from _last_entries."""
+    if _cards_container is None:
+        return
+    for child in _cards_container.get_children():
+        _cards_container.remove(child)
+
+    filtered = _filter_entries(_last_entries)
+    for entry in filtered:
+        row = _entry_to_row(entry)
+        card = _build_card(row)
+        _cards_container.pack_start(card, False, False, 0)
+    _cards_container.show_all()
+
+
+# ---------------------------------------------------------------------------
+# Filtering
+# ---------------------------------------------------------------------------
+
+def _filter_entries(entries: list) -> list:
+    """Filter entries by combo selection and search text."""
+    if _filter_combo is None:
+        return entries
+
+    active = _filter_combo.get_active_text() or "Alle"
+    type_map = {
+        "Alle": None,
+        "Tools": "tool",
+        "LLM": "llm",
+        "Errors": "error",
+        "Hooks": "hook",
+    }
+    filter_type = type_map.get(active)
+
+    search_text = ""
+    if _search_entry is not None:
+        search_text = (_search_entry.get_text() or "").lower().strip()
+
+    result = []
+    for entry in entries:
+        etype = entry.get("_type", "tool")
+        # For error filtering: match on entry error field
+        if filter_type == "error":
+            if not entry.get("error"):
+                continue
+        elif filter_type is not None:
+            if etype != filter_type:
+                continue
+
+        if search_text:
+            tool_val = (entry.get("tool", "") or entry.get("provider", "") or etype or "").lower()
+            detail_val = (
+                entry.get("file", "") or
+                entry.get("cmd_cat", "") or
+                entry.get("text", "") or
+                entry.get("model", "") or
+                ""
+            ).lower()
+            if search_text not in tool_val and search_text not in detail_val:
+                continue
+
+        result.append(entry)
+    return result
+
+
+def _on_filter_changed(_widget):
+    """Rebuild cards when combo or search entry changes."""
+    _rebuild_cards()
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+def _update_stats(entries: list):
+    if _stats_label is None:
+        return
+    tool_count = sum(1 for e in entries if e.get("_type") == "tool")
+    error_count = sum(1 for e in entries if e.get("error"))
+    total_cost = sum(e.get("cost_usd", 0.0) for e in entries if e.get("_type") == "llm")
+    now = datetime.now().strftime("%H:%M")
+    parts = [f"{tool_count} calls"]
+    if error_count:
+        parts.append(f"{error_count} errors")
+    if total_cost:
+        parts.append(f"${total_cost:.3f}")
+    parts.append(now)
+    _stats_label.set_text(" | ".join(parts))

monitor.py

@@ -0,0 +1,802 @@
+"""Monitor data layer for Claude Code Control Panel.
+
+Reads usage data, active sessions, missed skills, and recent sessions.
+Gracefully falls back when data sources are unavailable.
+
+Performance: TTL cache (30s) prevents redundant disk I/O.
+Single combined scan for active + recent sessions.
+Session previews cached permanently (content never changes).
+Sidecar socket queries refresh asynchronously to avoid blocking GTK.
+"""
+
+import importlib.util
+import json
+import logging
+import threading
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+log = logging.getLogger("claude_panel.monitor")
+
+
+def _load_usage_reader():
+    """Load usage_reader from MyAIGame if available, without sys.path manipulation."""
+    module_path = Path.home() / "Projekte" / "MyAIGame" / "tui" / "data" / "usage_reader.py"
+    if not module_path.is_file():
+        return None
+    spec = importlib.util.spec_from_file_location("usage_reader", module_path)
+    if spec is None or spec.loader is None:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _load_skill_tracker():
+    """Load skill_tracker from MyAIGame if available, without sys.path manipulation."""
+    module_path = Path.home() / "Projekte" / "MyAIGame" / "tui" / "data" / "skill_tracker.py"
+    if not module_path.is_file():
+        return None
+    spec = importlib.util.spec_from_file_location("skill_tracker", module_path)
+    if spec is None or spec.loader is None:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# Try loading TUI data modules via explicit importlib (avoids sys.path DLL-hijacking)
+_usage_reader_mod = None
+try:
+    _usage_reader_mod = _load_usage_reader()
+    _HAS_USAGE_READER = _usage_reader_mod is not None
+except Exception:
+    log.warning("usage_reader not available"); _HAS_USAGE_READER = False
+
+_skill_tracker_mod = None
+try:
+    _skill_tracker_mod = _load_skill_tracker()
+    _HAS_SKILL_TRACKER = _skill_tracker_mod is not None
+except Exception:
+    log.warning("skill_tracker not available"); _HAS_SKILL_TRACKER = False
+
+
+PROJECTS_DIR = Path.home() / ".claude" / "projects"
+USAGE_DIR = Path.home() / ".claude" / "usage"
+
+# ---------------------------------------------------------------------------
+# TTL Cache — 30s for data that changes, permanent for session previews
+# ---------------------------------------------------------------------------
+_CACHE_TTL_SECONDS = 30
+_cache = {}       # key -> value
+_cache_ts = {}    # key -> timestamp
+_preview_cache = {}  # path_str -> preview text (permanent, content never changes)
+_sidecar_lock = threading.Lock()
+_sidecar_refresh_in_flight = False
+_jsonl_scan_lock = threading.Lock()
+_jsonl_scan_in_flight = False
+
+
+def _cache_get(key):
+    """Return cached value if still within TTL, else None."""
+    if key in _cache and (time.time() - _cache_ts.get(key, 0)) < _CACHE_TTL_SECONDS:
+        return _cache[key]
+    return None
+
+
+def _cache_set(key, value, ttl=None):
+    """Store value in TTL cache. Optional custom ttl in seconds."""
+    _cache[key] = value
+    if ttl is not None:
+        _cache_ts[key] = time.time() - (_CACHE_TTL_SECONDS - ttl)
+    else:
+        _cache_ts[key] = time.time()
+
+
+# ---------------------------------------------------------------------------
+# Anthropic token pricing (per 1M tokens) — Claude 4.x / 4.5 generation
+# model_id -> (input_$/1M, cache_write_$/1M, cache_read_$/1M, output_$/1M)
+# Source: https://docs.anthropic.com/en/docs/about-claude/models (March 2026)
+# ---------------------------------------------------------------------------
+ANTHROPIC_PRICING = {
+    "claude-opus-4-6":   (5.00, 6.25, 0.50, 25.0),
+    "claude-sonnet-4-6": (3.00, 3.75, 0.30, 15.0),
+    "claude-haiku-4-5-20251001":  (1.00, 1.25, 0.10,  5.0),
+}
+DEFAULT_PRICING = (5.00, 6.25, 0.50, 25.0)  # Opus as conservative fallback
+
+
+# ---------------------------------------------------------------------------
+# Combined JSONL scanner — single pass for tokens + skills (cached 30s)
+# ---------------------------------------------------------------------------
+def _default_jsonl_scan() -> dict:
+    """Return empty result structure for JSONL scan."""
+    return {"tokens_by_date": {}, "models_by_date": {}, "skills_by_date": {}}
+
+
+def _do_jsonl_scan(days: int, cache_key: str) -> None:
+    """Heavy JSONL scan — runs in background thread, stores result in cache."""
+    global _jsonl_scan_in_flight
+    try:
+        result = _do_jsonl_scan_inner(days)
+        _cache_set(cache_key, result)
+    except Exception:
+        log.exception("background JSONL scan failed")
+    finally:
+        with _jsonl_scan_lock:
+            _jsonl_scan_in_flight = False
+
+
+def _scan_session_jsonls(days: int = 1) -> dict:
+    """Non-blocking JSONL scan. Returns cached/stale data immediately,
+    kicks off background thread on cache miss (like get_sidecar_status).
+    """
+    global _jsonl_scan_in_flight
+
+    cache_key = f"jsonl_scan_{days}"
+    cached = _cache_get(cache_key)
+    if cached is not None:
+        return cached
+
+    stale = _cache.get(cache_key, _default_jsonl_scan())
+
+    with _jsonl_scan_lock:
+        if not _jsonl_scan_in_flight:
+            _jsonl_scan_in_flight = True
+            threading.Thread(
+                target=_do_jsonl_scan,
+                args=(days, cache_key),
+                daemon=True,
+                name="claude-panel-jsonl-scan",
+            ).start()
+
+    return stale
+
+
+def _do_jsonl_scan_inner(days: int = 1) -> dict:
+    """Single-pass scan of session JSONLs for tokens AND skills.
+
+    Returns: {
+        "tokens_by_date": {"2026-03-03": {"input": N, "cache_create": N, "cache_read": N, "output": N, "cost": F}},
+        "skills_by_date": {"2026-03-03": {"research": 3, "chef": 5}},
+    }
+    """
+    from collections import defaultdict
+
+    now = time.time()
+    cutoff_ts = now - (days * 86400)
+
+    tokens_by_date = defaultdict(lambda: {"input": 0, "cache_create": 0, "cache_read": 0, "output": 0, "cost": 0.0})
+    # Per-model breakdown: date -> model_tier -> {input, cache_create, cache_read, output, cost}
+    tokens_by_date_model = defaultdict(lambda: defaultdict(
+        lambda: {"input": 0, "cache_create": 0, "cache_read": 0, "output": 0, "cost": 0.0}
+    ))
+    skills_by_date = defaultdict(lambda: defaultdict(int))
+    sessions_by_date = defaultdict(set)
+
+    if not PROJECTS_DIR.exists():
+        return _default_jsonl_scan()
+
+    # Collect last usage per requestId to avoid streaming duplication.
+    # Streaming responses emit multiple usage objects per request — only
+    # the final one contains the cumulative (correct) token counts.
+    # Key: requestId -> (date_str, model_id, usage_dict, file_path)
+    request_usage = {}
+
+    for project_dir in PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.glob("**/*.jsonl"):
+            try:
+                mtime = f.stat().st_mtime
+            except (OSError, PermissionError):
+                continue
+            if mtime < cutoff_ts:
+                continue
+
+            try:
+                with f.open() as fh:
+                    for line in fh:
+                        has_usage = '"usage"' in line
+                        has_skill = '"name":"Skill"' in line or '"name": "Skill"' in line
+                        if not has_usage and not has_skill:
+                            continue
+                        try:
+                            entry = json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+
+                        # Extract date from timestamp
+                        ts = entry.get("timestamp", "")
+                        if not ts:
+                            continue
+                        date_str = ts[:10]  # "2026-03-03T..." -> "2026-03-03"
+
+                        msg = entry.get("message", {})
+
+                        # --- Token usage (dedup by requestId) ---
+                        if has_usage:
+                            usage = msg.get("usage")
+                            rid = entry.get("requestId", "")
+                            if usage and rid:
+                                model_id = msg.get("model", "")
+                                # Always overwrite — last entry per requestId wins
+                                request_usage[rid] = (date_str, model_id, usage, str(f))
+
+                        # --- Skill usage ---
+                        if has_skill:
+                            content = msg.get("content", [])
+                            if isinstance(content, list):
+                                for block in content:
+                                    if isinstance(block, dict) and block.get("name") == "Skill":
+                                        skill_input = block.get("input", {})
+                                        skill_name = skill_input.get("skill", "unknown")
+                                        skills_by_date[date_str][skill_name] += 1
+            except (OSError, PermissionError):
+                continue
+
+    # Aggregate deduplicated usage into date buckets (total + per-model)
+    for date_str, model_id, usage, file_path in request_usage.values():
+        rate_in, rate_write, rate_read, rate_out = ANTHROPIC_PRICING.get(model_id, DEFAULT_PRICING)
+
+        inp = usage.get("input_tokens", 0)
+        cache_create = usage.get("cache_creation_input_tokens", 0)
+        cache_read = usage.get("cache_read_input_tokens", 0)
+        out = usage.get("output_tokens", 0)
+
+        cost = (inp * rate_in
+                + cache_create * rate_write
+                + cache_read * rate_read
+                + out * rate_out) / 1_000_000
+
+        # Total bucket
+        bucket = tokens_by_date[date_str]
+        bucket["input"] += inp
+        bucket["cache_create"] += cache_create
+        bucket["cache_read"] += cache_read
+        bucket["output"] += out
+        bucket["cost"] += cost
+
+        # Per-model bucket (derive tier from model_id)
+        if "opus" in model_id:
+            tier = "opus"
+        elif "sonnet" in model_id:
+            tier = "sonnet"
+        elif "haiku" in model_id:
+            tier = "haiku"
+        else:
+            tier = "opus"  # conservative fallback
+        mb = tokens_by_date_model[date_str][tier]
+        mb["input"] += inp
+        mb["cache_create"] += cache_create
+        mb["cache_read"] += cache_read
+        mb["output"] += out
+        mb["cost"] += cost
+
+        sessions_by_date[date_str].add(file_path)
+
+    # Convert defaultdicts to regular dicts and add session counts
+    tokens_dict = {}
+    for d, bucket in tokens_by_date.items():
+        tokens_dict[d] = {
+            "input": bucket["input"],
+            "cache_create": bucket["cache_create"],
+            "cache_read": bucket["cache_read"],
+            "output": bucket["output"],
+            "cost": round(bucket["cost"], 6),
+            "sessions": len(sessions_by_date.get(d, set())),
+        }
+
+    # Convert per-model defaultdicts
+    models_dict = {}
+    for d, model_map in tokens_by_date_model.items():
+        models_dict[d] = {tier: dict(b) for tier, b in model_map.items()}
+
+    return {
+        "tokens_by_date": tokens_dict,
+        "models_by_date": models_dict,
+        "skills_by_date": {k: dict(v) for k, v in skills_by_date.items()},
+    }
+
+
+# ---------------------------------------------------------------------------
+# Cost & Tools
+# ---------------------------------------------------------------------------
+def get_anthropic_session_cost() -> dict:
+    """Get real API token costs from session JSONL files for today (cached 30s).
+
+    Parses ~/.claude/projects/*/*.jsonl for actual Anthropic API usage data,
+    with model-specific pricing and cache token breakdown.
+    """
+    cached = _cache_get("anthropic_session_cost")
+    if cached is not None:
+        return cached
+
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    scan = _scan_session_jsonls(days=1)
+    bucket = scan["tokens_by_date"].get(today, {})
+
+    # Per-model breakdown for today
+    models_today = scan["models_by_date"].get(today, {})
+    models = {}
+    for tier, mb in models_today.items():
+        models[tier] = {
+            "cost_usd": round(mb.get("cost", 0.0), 4),
+            "input_tokens": mb.get("input", 0) + mb.get("cache_create", 0),
+            "cache_read_tokens": mb.get("cache_read", 0),
+            "output_tokens": mb.get("output", 0),
+        }
+
+    result = {
+        "cost_usd": round(bucket.get("cost", 0.0), 4),
+        "input_tokens": bucket.get("input", 0) + bucket.get("cache_create", 0),
+        "cache_read_tokens": bucket.get("cache_read", 0),
+        "output_tokens": bucket.get("output", 0),
+        "sessions": bucket.get("sessions", 0),
+        "models": models,
+    }
+    _cache_set("anthropic_session_cost", result)
+    return result
+
+
+def _get_tool_call_stats() -> dict:
+    """Get tool call count and unique tool count from usage-tracker data."""
+    if not _HAS_USAGE_READER:
+        return {"total_calls": 0, "unique_tools": 0}
+    try:
+        summary = _usage_reader_mod.get_daily_summary()
+        return {
+            "total_calls": summary.get("total_calls", 0),
+            "unique_tools": summary.get("unique_tools", 0),
+        }
+    except Exception:
+        log.exception("get_skill_usage")
+        return {"total_calls": 0, "unique_tools": 0}
+
+
+def get_daily_cost() -> dict:
+    """Get today's cost summary based on real token data (cached 30s)."""
+    cached = _cache_get("daily_cost")
+    if cached is not None:
+        return cached
+
+    provider_costs = get_provider_costs()
+    total = sum(provider_costs.values())
+
+    # Tool-call count for statistics (not for cost calculation)
+    tool_stats = _get_tool_call_stats()
+
+    result = {
+        "cost_estimate_usd": round(total, 4),
+        "total_calls": tool_stats["total_calls"],
+        "unique_tools": tool_stats["unique_tools"],
+        "source": "token-based",
+    }
+    _cache_set("daily_cost", result)
+    return result
+
+
+def get_top_tools(n: int = 5) -> list[tuple[str, int]]:
+    """Get top N tools by usage count today (cached 30s)."""
+    cached = _cache_get(f"top_tools_{n}")
+    if cached is not None:
+        return cached
+    if not _HAS_USAGE_READER:
+        return []
+    try:
+        result = _usage_reader_mod.get_top_n(n)
+    except Exception:
+        log.exception("get_top_tools")
+        result = []
+    _cache_set(f"top_tools_{n}", result)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Sessions — single combined scan, shared cache
+# ---------------------------------------------------------------------------
+def _scan_sessions():
+    """Single scan of all session files. Returns (active_list, all_files_sorted).
+
+    active_list: sessions modified in last hour, sorted by age.
+    all_files_sorted: (Path, os.stat_result, Path) tuples sorted by mtime desc.
+    """
+    cached = _cache_get("session_scan")
+    if cached is not None:
+        return cached
+
+    active = []
+    all_files = []
+    if not PROJECTS_DIR.exists():
+        result = (active, all_files)
+        _cache_set("session_scan", result)
+        return result
+
+    now = time.time()
+    for project_dir in PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.glob("**/*.jsonl"):
+            try:
+                stat = f.stat()
+            except (OSError, PermissionError):
+                continue
+
+            age_hours = (now - stat.st_mtime) / 3600
+            if age_hours < 1:
+                active.append({
+                    "project": project_dir.name[:40],
+                    "file": f.name,
+                    "session_id": f.stem,
+                    "age_min": int(age_hours * 60),
+                })
+
+            all_files.append((f, stat, project_dir))
+
+    active.sort(key=lambda s: s["age_min"])
+    all_files.sort(key=lambda x: x[1].st_mtime, reverse=True)
+
+    result = (active, all_files)
+    _cache_set("session_scan", result)
+    return result
+
+
+def get_active_sessions() -> list[dict]:
+    """Scan ~/.claude/projects/ for recently active sessions (last hour)."""
+    active, _ = _scan_sessions()
+    return active
+
+
+def get_recent_sessions(n: int = 5) -> list[dict]:
+    """Get n most recent session files across all projects for resume dropdown."""
+    _, all_files = _scan_sessions()
+    sessions = []
+    for f, stat, project_dir in all_files[:n]:
+        preview = _get_session_preview(f)
+        project_name = project_dir.name.replace("-home-smlflg-", "").replace("-home-smlflg", "~")
+        if not project_name or project_name == "~":
+            project_name = "Home"
+
+        sessions.append({
+            "path": str(f),
+            "project": project_name,
+            "session_id": f.stem,
+            "mtime": stat.st_mtime,
+            "time_str": datetime.fromtimestamp(stat.st_mtime).strftime("%d.%m %H:%M"),
+            "preview": preview,
+        })
+    return sessions
+
+
+def _get_session_preview(path: Path, max_len: int = 60) -> str:
+    """Extract first user message from session JSONL as preview text.
+
+    Cached permanently — session content doesn't change after creation.
+    """
+    key = str(path)
+    if key in _preview_cache:
+        return _preview_cache[key]
+
+    result = "(keine Vorschau)"
+    try:
+        with path.open() as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    if entry.get("type") == "user":
+                        msg = entry.get("message", {})
+                        content = msg.get("content", "")
+                        if isinstance(content, list):
+                            for block in content:
+                                if isinstance(block, dict) and block.get("type") == "text":
+                                    content = block.get("text", "")
+                                    break
+                            else:
+                                content = str(content)
+                        if isinstance(content, str):
+                            content = content.strip().split("\n")[0]
+                            if len(content) > max_len:
+                                content = content[:max_len] + "..."
+                            result = content
+                            break
+                except json.JSONDecodeError:
+                    continue
+    except (OSError, PermissionError):
+        pass
+
+    _preview_cache[key] = result
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Skill Usage (from session JSONLs)
+# ---------------------------------------------------------------------------
+def get_skill_usage(days: int = 1) -> dict[str, dict[str, int]]:
+    """Get skill usage counts grouped by date.
+
+    Returns: {"2026-03-03": {"research": 3, "chef": 5, ...}, ...}
+    """
+    cached = _cache_get(f"skill_usage_{days}")
+    if cached is not None:
+        return cached
+
+    scan = _scan_session_jsonls(days=days)
+    result = scan["skills_by_date"]
+    _cache_set(f"skill_usage_{days}", result)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Skills (missed skills from MyAIGame tracker)
+# ---------------------------------------------------------------------------
+def get_missed_skills() -> list[dict]:
+    """Get today's missed skill suggestions."""
+    if not _HAS_SKILL_TRACKER:
+        return []
+    try:
+        return _skill_tracker_mod.get_missed_today()
+    except Exception:
+        log.exception("get_missed_skills_summary")
+        return []
+
+
+def get_missed_skills_summary() -> list[tuple[str, int]]:
+    """Get missed skills grouped by skill name with counts (cached 30s)."""
+    cached = _cache_get("missed_skills")
+    if cached is not None:
+        return cached
+    missed = get_missed_skills()
+    if not missed:
+        result = []
+    else:
+        counts = Counter(m.get("suggested_skill", "?") for m in missed)
+        result = counts.most_common(10)
+    _cache_set("missed_skills", result)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Timeline
+# ---------------------------------------------------------------------------
+def get_usage_timeline() -> list[dict]:
+    """Get usage data by date (last 7 days, cached 30s).
+
+    Combines tool-call counts from usage-tracker JSONL files with
+    real token costs from session JSONL files (model-specific pricing).
+    """
+    cached = _cache_get("usage_timeline")
+    if cached is not None:
+        return cached
+
+    # 1. Collect call counts per day from usage-tracker JSONL
+    calls_by_date: dict[str, int] = {}
+    if USAGE_DIR.exists():
+        for f in sorted(USAGE_DIR.glob("????-??-??.jsonl"), reverse=True)[:7]:
+            count = 0
+            try:
+                with f.open() as fh:
+                    for line in fh:
+                        if line.strip():
+                            count += 1
+            except OSError:
+                pass
+            calls_by_date[f.stem] = count
+
+    # 2. Real token costs from session JSONLs (7-day scan)
+    scan = _scan_session_jsonls(days=7)
+    tokens_by_date = scan["tokens_by_date"]
+
+    # 3. Merge: all dates from both sources, sorted desc, limit 7
+    all_dates = sorted(set(calls_by_date) | set(tokens_by_date), reverse=True)[:7]
+    timeline = []
+    for date_str in all_dates:
+        calls = calls_by_date.get(date_str, 0)
+        bucket = tokens_by_date.get(date_str, {})
+        cost = bucket.get("cost", 0.0)
+        inp = bucket.get("input", 0) + bucket.get("cache_create", 0)
+        cache_read = bucket.get("cache_read", 0)
+        out = bucket.get("output", 0)
+        timeline.append({
+            "date": date_str,
+            "calls": calls,
+            "cost_est": round(cost, 4),
+            "input_tokens": inp,
+            "cache_read_tokens": cache_read,
+            "output_tokens": out,
+        })
+
+    _cache_set("usage_timeline", timeline)
+    return timeline
+
+
+def get_provider_costs() -> dict[str, float]:
+    """Get today's cost breakdown by provider (cached 30s).
+
+    Anthropic: real API tokens from session JSONLs (model-specific pricing).
+    Others: from ~/.claude/usage/providers.jsonl (minimax, codex, gemini).
+    """
+    cached = _cache_get("provider_costs")
+    if cached is not None:
+        return cached
+
+    # 1. Anthropic: per-model costs from session JSONLs
+    anthropic = get_anthropic_session_cost()
+    costs: dict[str, float] = {}
+    for tier in ("opus", "sonnet", "haiku"):
+        tier_cost = anthropic.get("models", {}).get(tier, {}).get("cost_usd", 0.0)
+        if tier_cost > 0:
+            costs[tier] = tier_cost
+
+    # 2. Other providers: from providers.jsonl
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    providers_file = USAGE_DIR / "providers.jsonl"
+    if providers_file.exists():
+        try:
+            with providers_file.open() as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                        entry_date = entry.get("time", "")[:10]
+                        if entry_date == today:
+                            provider = entry.get("provider", "unknown")
+                            cost = entry.get("cost_usd", 0.0)
+                            costs[provider] = costs.get(provider, 0.0) + cost
+                    except (json.JSONDecodeError, KeyError):
+                        continue
+        except OSError:
+            pass
+
+    # Round all values
+    costs = {k: round(v, 6) for k, v in costs.items()}
+
+    _cache_set("provider_costs", costs)
+    return costs
+
+
+def format_cost(usd: float) -> str:
+    """Format USD cost for display."""
+    if usd < 0.01:
+        return f"${usd:.4f}"
+    return f"${usd:.2f}"
+
+
+# ---------------------------------------------------------------------------
+# Sidecar Watcher — queries Sidecar V6 daemon via /tmp/sidecar-v6.sock
+# ---------------------------------------------------------------------------
+
+
+def _category_to_severity(category: str) -> str:
+    """Map V6 mechanism category to UI severity level."""
+    if category == "safety":
+        return "critical"
+    if category in ("adhs", "context"):
+        return "warning"
+    return "info"
+
+
+def _default_sidecar_status() -> dict:
+    return {
+        "running": False,
+        "sessions": 0,
+        "active_findings": [],
+        "detectors": {},
+        "mechanisms_list": [],
+        "mechanisms_total": 0,
+        "mechanisms_active": 0,
+        "phase": "",
+    }
+
+
+def _query_sidecar_status() -> dict:
+    """Query Sidecar V6 daemon via Unix socket (blocking worker helper)."""
+    result = _default_sidecar_status()
+    sock_path = Path("/tmp/sidecar-v6.sock")
+    if not sock_path.exists():
+        return result
+
+    try:
+        import socket as sock_mod
+
+        def _query(request: dict) -> dict:
+            s = sock_mod.socket(sock_mod.AF_UNIX, sock_mod.SOCK_STREAM)
+            # Keep timeouts tight so a wedged sidecar cannot pile up worker
+            # threads even though we no longer block GTK.
+            s.settimeout(0.75)
+            try:
+                s.connect(str(sock_path))
+                s.sendall(json.dumps(request).encode())
+                s.shutdown(sock_mod.SHUT_WR)  # signal EOF so daemon responds
+                data = b""
+                while True:
+                    chunk = s.recv(65536)
+                    if not chunk:
+                        break
+                    data += chunk
+                return json.loads(data.decode().strip())
+            finally:
+                s.close()
+
+        # Query status
+        status_resp = _query({"type": "ctl", "cmd": "status"})
+        result["running"] = True
+
+        session_data = status_resp.get("session", {})
+        result["phase"] = session_data.get("phase", "")
+
+        # Count V6 session files
+        v6_sessions = list(Path("/tmp").glob("sidecar-v6-ses-*.json"))
+        result["sessions"] = len(v6_sessions)
+
+        # Query ranking for mechanism info
+        try:
+            ranking_resp = _query({"type": "ctl", "cmd": "ranking"})
+            result["mechanisms_total"] = ranking_resp.get("total", 0)
+            result["mechanisms_active"] = ranking_resp.get("active", 0)
+
+            # Build detectors dict for UI (panel.py, swarm_tab.py)
+            mechanisms = ranking_resp.get("mechanisms", [])
+            detectors = {}
+            for m in mechanisms:
+                name = m.get("name", "")
+                if not name:
+                    continue
+                detectors[name] = {
+                    "active": m.get("active", False),
+                    "severity": _category_to_severity(m.get("category", "")),
+                    "count": m.get("fire_count", 0),
+                    "last_seen": m.get("last_seen", ""),
+                }
+            result["detectors"] = detectors
+            result["mechanisms_list"] = mechanisms  # full data for Monitor tab
+            result["active_findings"] = [
+                n for n, d in detectors.items() if d["active"]
+            ][:10]
+        except Exception:
+            pass  # ranking query is optional
+
+    except Exception:
+        log.exception("sidecar v6 query")
+
+    return result
+
+
+def _refresh_sidecar_status_async(cache_key: str) -> None:
+    """Refresh sidecar status in a background thread."""
+    global _sidecar_refresh_in_flight
+    try:
+        _cache_set(cache_key, _query_sidecar_status(), ttl=10)
+    finally:
+        with _sidecar_lock:
+            _sidecar_refresh_in_flight = False
+
+
+def get_sidecar_status() -> dict:
+    """Return the latest known Sidecar V6 status without blocking GTK."""
+    global _sidecar_refresh_in_flight
+
+    cache_key = "sidecar_status"
+    cached = _cache_get(cache_key)
+    if cached is not None:
+        return cached
+
+    stale = _cache.get(cache_key, _default_sidecar_status())
+
+    with _sidecar_lock:
+        if not _sidecar_refresh_in_flight:
+            _sidecar_refresh_in_flight = True
+            threading.Thread(
+                target=_refresh_sidecar_status_async,
+                args=(cache_key,),
+                daemon=True,
+                name="claude-panel-sidecar",
+            ).start()
+
+    return stale

process_manager.py

@@ -0,0 +1,611 @@
+#!/usr/bin/env python3
+"""Process Manager — GTK3 widget module for Claude Code Control Panel.
+
+Provides build_processes_tab() returning a Gtk.ScrolledWindow with:
+- List of all Claude-relevant processes (opencode-mcp, gemini-mcp, claude CLI, etc.)
+- Per-process: PID, name, RAM (MB), CPU%, uptime, start date
+- Kill button per process row with confirmation dialog
+- "Kill All Ghosts" button (kills processes older than 24h)
+- Summary stats at top: total processes, total RAM, ghost count
+- Auto-refresh every 30s via GLib timer
+
+Theme: Catppuccin Mocha (dark) / Latte (light) via theme.py
+"""
+
+import logging
+import os
+import signal
+import subprocess
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+log = logging.getLogger("claude_panel.process_manager")
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk, Pango
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+from theme import get_palette, hex_to_pango_rgb
+from utils import idle_once, short_name_from_path, HOME, CLK_TCK
+
+GHOST_HOURS = 24  # processes older than this are "ghosts"
+
+# Process name keywords to detect Claude-relevant processes
+PROCESS_KEYWORDS = [
+    "opencode-mcp",
+    "opencode",
+    "gemini-mcp",
+    "server-filesystem",
+    "server-memory",
+    "server-github",
+    "server-postgres",
+    "claude",
+    "codex",
+    "mcp-server",
+]
+
+# ---------------------------------------------------------------------------
+# Module-level state (kept between refreshes)
+# ---------------------------------------------------------------------------
+_list_box: Gtk.ListBox | None = None
+_stats_label: Gtk.Label | None = None
+_all_processes: list[dict] = []
+
+
+# ---------------------------------------------------------------------------
+# Process scanning
+# ---------------------------------------------------------------------------
+
+def _scan_processes() -> list[dict]:
+    """Run ps aux and filter for Claude-relevant processes.
+
+    Returns list of dicts with: pid, name, cpu, ram_mb, start_str, uptime_h, is_ghost
+    """
+    processes = []
+    try:
+        result = subprocess.run(
+            ["ps", "aux", "--no-headers"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            return processes
+
+        now = time.time()
+
+        for line in result.stdout.splitlines():
+            parts = line.split(None, 10)
+            if len(parts) < 11:
+                continue
+
+            # ps aux columns: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
+            try:
+                pid = int(parts[1])
+                cpu = float(parts[2])
+                rss_kb = int(parts[5])
+                tty = parts[6]         # e.g. "pts/33" or "?"
+                start_str = parts[8]   # e.g. "10:30" or "Feb12"
+                time_str = parts[9]    # cumulative CPU time e.g. "0:00"
+                command = parts[10]
+            except (ValueError, IndexError):
+                continue
+
+            # Check if this process matches any keyword
+            cmd_lower = command.lower()
+            matched_keyword = None
+            for kw in PROCESS_KEYWORDS:
+                if kw in cmd_lower:
+                    matched_keyword = kw
+                    break
+            if matched_keyword is None:
+                continue
+
+            # Skip self (the ps command or this Python process)
+            if pid == os.getpid():
+                continue
+
+            # Derive display name from command
+            name = _derive_name(command, matched_keyword, pid)
+
+            # RAM in MB
+            ram_mb = rss_kb / 1024
+
+            # Estimate process age via /proc/<pid>/stat if available
+            uptime_h = _get_uptime_hours(pid, now)
+
+            is_ghost = uptime_h >= GHOST_HOURS
+
+            processes.append({
+                "pid": pid,
+                "name": name,
+                "command": command[:80],
+                "cpu": cpu,
+                "ram_mb": ram_mb,
+                "tty": tty if tty != "?" else "",
+                "start_str": start_str,
+                "uptime_h": uptime_h,
+                "is_ghost": is_ghost,
+            })
+
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    # Sort: ghosts first, then by RAM desc
+    processes.sort(key=lambda p: (-p["is_ghost"], -p["ram_mb"]))
+    return processes
+
+
+_FRIENDLY_NAMES = {
+    "opencode-mcp": "OpenCode MCP",
+    "opencode": "OpenCode Server",
+    "gemini-mcp": "Gemini MCP",
+    "server-filesystem": "Filesystem MCP",
+    "server-memory": "Memory MCP",
+    "server-github": "GitHub MCP",
+    "codex": "Codex CLI",
+    "mcp-server": "MCP Server",
+}
+
+
+def _get_cwd_project(pid: int) -> str:
+    """Try to read the CWD of a process and extract a project name."""
+    try:
+        cwd = os.readlink(f"/proc/{pid}/cwd")
+        name = short_name_from_path(cwd)
+        return "" if name == "Home" else name
+    except OSError:
+        return ""
+
+
+def _derive_name(command: str, keyword: str, pid: int = 0) -> str:
+    """Derive a friendly display name from the full command string."""
+    # Special handling for claude CLI — try to show project context
+    if keyword == "claude":
+        # Check if resumed session (-r flag)
+        resumed = " -r" in command or "\x00-r" in command
+        project = _get_cwd_project(pid) if pid else ""
+        if project:
+            return f"Claude CLI — {project}"
+        return "Claude CLI (resumed)" if resumed else "Claude CLI"
+
+    # Check friendly name table (normalize mcp- prefix for lookup)
+    lookup = keyword.removeprefix("mcp-") if keyword not in _FRIENDLY_NAMES else keyword
+    if lookup in _FRIENDLY_NAMES:
+        return _FRIENDLY_NAMES[lookup]
+
+    # Fallback: executable basename
+    parts = command.split()
+    if not parts:
+        return keyword
+
+    exe_base = Path(parts[0]).name
+
+    name_map = {
+        "node": f"node/{keyword}",
+        "python3": f"python/{keyword}",
+        "python": f"python/{keyword}",
+    }
+
+    if exe_base in name_map:
+        return name_map[exe_base]
+
+    return exe_base if exe_base else keyword
+
+
+def _get_uptime_hours(pid: int, now: float) -> float:
+    """Estimate process uptime in hours via /proc/<pid>/stat."""
+    try:
+        with open(f"/proc/{pid}/stat") as f:
+            stat_data = f.read().split()
+        # Field 22 (index 21) is starttime in clock ticks since boot
+        starttime_ticks = int(stat_data[21])
+        clk_tck = CLK_TCK
+
+        with open("/proc/uptime") as f:
+            boot_seconds_ago = float(f.read().split()[0])
+
+        # Process start time as seconds since epoch
+        process_start = now - boot_seconds_ago + (starttime_ticks / clk_tck)
+        uptime_seconds = now - process_start
+        return max(0.0, uptime_seconds / 3600)
+    except (OSError, ValueError, IndexError):
+        return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Summary stats
+# ---------------------------------------------------------------------------
+
+def _compute_stats(processes: list[dict]) -> str:
+    total = len(processes)
+    total_ram = sum(p["ram_mb"] for p in processes)
+    ghosts = sum(1 for p in processes if p["is_ghost"])
+    return (
+        f"{total} Prozesse  |  RAM: {total_ram:.0f} MB  |  "
+        f"Ghosts (>{GHOST_HOURS}h): {ghosts}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Kill helpers
+# ---------------------------------------------------------------------------
+
+def _kill_process(pid: int, parent_widget: Gtk.Widget) -> bool:
+    """Send SIGTERM to pid. Returns True if successful."""
+    try:
+        os.kill(pid, signal.SIGTERM)
+        return True
+    except ProcessLookupError:
+        _show_error(parent_widget, f"Prozess {pid} nicht gefunden (bereits beendet?)")
+        return False
+    except PermissionError:
+        _show_error(parent_widget, f"Keine Berechtigung, Prozess {pid} zu beenden.")
+        return False
+    except OSError as e:
+        _show_error(parent_widget, f"Fehler beim Beenden von {pid}: {e}")
+        return False
+
+
+def _show_error(parent: Gtk.Widget, msg: str) -> None:
+    """Show a simple error dialog."""
+    toplevel = parent.get_toplevel()
+    dialog = Gtk.MessageDialog(
+        transient_for=toplevel if isinstance(toplevel, Gtk.Window) else None,
+        flags=0,
+        message_type=Gtk.MessageType.ERROR,
+        buttons=Gtk.ButtonsType.OK,
+        text=msg,
+    )
+    dialog.run()
+    dialog.destroy()
+
+
+def _confirm_kill(parent: Gtk.Widget, pid: int, name: str) -> bool:
+    """Show confirmation dialog. Returns True if user confirmed."""
+    toplevel = parent.get_toplevel()
+    dialog = Gtk.MessageDialog(
+        transient_for=toplevel if isinstance(toplevel, Gtk.Window) else None,
+        flags=0,
+        message_type=Gtk.MessageType.WARNING,
+        buttons=Gtk.ButtonsType.YES_NO,
+        text=f"Prozess beenden?",
+    )
+    dialog.format_secondary_text(f"PID {pid} — {name}\n\nSignal: SIGTERM")
+    response = dialog.run()
+    dialog.destroy()
+    return response == Gtk.ResponseType.YES
+
+
+def _confirm_kill_ghosts(parent: Gtk.Widget, count: int) -> bool:
+    """Show confirmation dialog for killing all ghost processes."""
+    toplevel = parent.get_toplevel()
+    dialog = Gtk.MessageDialog(
+        transient_for=toplevel if isinstance(toplevel, Gtk.Window) else None,
+        flags=0,
+        message_type=Gtk.MessageType.WARNING,
+        buttons=Gtk.ButtonsType.YES_NO,
+        text=f"Alle Ghosts beenden?",
+    )
+    dialog.format_secondary_text(
+        f"{count} Prozesse aelter als {GHOST_HOURS}h werden per SIGTERM beendet."
+    )
+    response = dialog.run()
+    dialog.destroy()
+    return response == Gtk.ResponseType.YES
+
+
+# ---------------------------------------------------------------------------
+# Row builder
+# ---------------------------------------------------------------------------
+
+def _ram_color(ram_mb: float) -> str:
+    """Return theme-aware color based on RAM usage."""
+    p = get_palette()
+    if ram_mb < 100:
+        return p["green"]
+    elif ram_mb < 300:
+        return p["peach"]
+    else:
+        return p["red"]
+
+
+def _format_uptime(hours: float) -> str:
+    if hours < 1:
+        return f"{int(hours * 60)}m"
+    elif hours < 24:
+        return f"{hours:.1f}h"
+    else:
+        days = int(hours // 24)
+        remaining_h = int(hours % 24)
+        return f"{days}d {remaining_h}h"
+
+
+def _build_process_row(proc: dict, parent_widget: Gtk.Widget) -> Gtk.ListBoxRow:
+    """Build a single styled ListBoxRow for one process."""
+    row = Gtk.ListBoxRow()
+    row.set_name("process-row")
+
+    # Outer box with padding
+    outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    outer.set_margin_top(6)
+    outer.set_margin_bottom(6)
+    outer.set_margin_start(10)
+    outer.set_margin_end(10)
+    row.add(outer)
+
+    # Left: name + command stacked vertically
+    info_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+    info_box.set_hexpand(True)
+    outer.pack_start(info_box, True, True, 0)
+
+    # Process name — bold, ghost shown in red
+    name_label = Gtk.Label(label=proc["name"])
+    name_label.set_halign(Gtk.Align.START)
+    name_label.set_ellipsize(Pango.EllipsizeMode.END)
+    name_label.set_max_width_chars(35)
+    name_attrs = Pango.AttrList()
+    name_attrs.insert(Pango.attr_weight_new(Pango.Weight.BOLD))
+    if proc["is_ghost"]:
+        # Red tint for ghost processes (theme-aware)
+        r, g, b = hex_to_pango_rgb(get_palette()["red"])
+        name_attrs.insert(Pango.attr_foreground_new(r, g, b))
+    name_label.set_attributes(name_attrs)
+    info_box.pack_start(name_label, False, False, 0)
+
+    # Command preview — dimmed, smaller
+    cmd_label = Gtk.Label(label=proc["command"])
+    cmd_label.set_halign(Gtk.Align.START)
+    cmd_label.set_ellipsize(Pango.EllipsizeMode.END)
+    cmd_label.set_max_width_chars(50)
+    cmd_label.get_style_context().add_class("stat-label")
+    cmd_attrs = Pango.AttrList()
+    cmd_attrs.insert(Pango.attr_scale_new(0.82))
+    cmd_label.set_attributes(cmd_attrs)
+    info_box.pack_start(cmd_label, False, False, 0)
+
+    # Middle: PID + uptime
+    pid_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+    pid_box.set_valign(Gtk.Align.CENTER)
+    outer.pack_start(pid_box, False, False, 0)
+
+    pid_text = f"PID {proc['pid']}"
+    if proc.get("tty"):
+        pid_text += f"  {proc['tty']}"
+    pid_label = Gtk.Label(label=pid_text)
+    pid_label.get_style_context().add_class("stat-label")
+    pid_attrs = Pango.AttrList()
+    pid_attrs.insert(Pango.attr_scale_new(0.85))
+    pid_label.set_attributes(pid_attrs)
+    pid_box.pack_start(pid_label, False, False, 0)
+
+    uptime_label = Gtk.Label(label=_format_uptime(proc["uptime_h"]))
+    uptime_label.get_style_context().add_class("stat-label")
+    uptime_attrs = Pango.AttrList()
+    uptime_attrs.insert(Pango.attr_scale_new(0.82))
+    uptime_label.set_attributes(uptime_attrs)
+    pid_box.pack_start(uptime_label, False, False, 0)
+
+    # Right: RAM + CPU + Kill button
+    meta_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    meta_box.set_valign(Gtk.Align.CENTER)
+    outer.pack_start(meta_box, False, False, 0)
+
+    # RAM + CPU on one line
+    stats_line = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
+    meta_box.pack_start(stats_line, False, False, 0)
+
+    ram_label = Gtk.Label(label=f"{proc['ram_mb']:.0f} MB")
+    ram_attrs = Pango.AttrList()
+    ram_attrs.insert(Pango.attr_scale_new(0.85))
+    # Color code RAM
+    r, g, b = hex_to_pango_rgb(_ram_color(proc["ram_mb"]))
+    ram_attrs.insert(Pango.attr_foreground_new(r, g, b))
+    ram_label.set_attributes(ram_attrs)
+    stats_line.pack_start(ram_label, False, False, 0)
+
+    cpu_label = Gtk.Label(label=f"CPU {proc['cpu']:.1f}%")
+    cpu_label.get_style_context().add_class("stat-label")
+    cpu_attrs = Pango.AttrList()
+    cpu_attrs.insert(Pango.attr_scale_new(0.85))
+    cpu_label.set_attributes(cpu_attrs)
+    stats_line.pack_start(cpu_label, False, False, 0)
+
+    # Kill button
+    kill_btn = Gtk.Button(label="Kill")
+    kill_btn.get_style_context().add_class("destructive-action")
+    kill_btn.set_tooltip_text(f"SIGTERM an PID {proc['pid']} senden")
+    pid = proc["pid"]
+    name = proc["name"]
+
+    def on_kill_clicked(_btn: Gtk.Button, _pid: int = pid, _name: str = name) -> None:
+        if _confirm_kill(_btn, _pid, _name):
+            _kill_process(_pid, _btn)
+            idle_once(refresh_processes)
+
+    kill_btn.connect("clicked", on_kill_clicked)
+    meta_box.pack_start(kill_btn, False, False, 0)
+
+    row._process_data = proc  # type: ignore[attr-defined]
+    row.show_all()
+    return row
+
+
+# ---------------------------------------------------------------------------
+# Populate / refresh the list
+# ---------------------------------------------------------------------------
+
+def _populate_list_box(processes: list[dict]) -> bool:
+    """Clear and re-populate the ListBox. Returns False (idle_add one-shot)."""
+    global _all_processes
+    _all_processes = processes
+
+    if _list_box is None:
+        return False
+
+    for child in _list_box.get_children():
+        _list_box.remove(child)
+
+    if not processes:
+        empty_label = Gtk.Label(label="Keine Claude-relevanten Prozesse gefunden.")
+        empty_label.get_style_context().add_class("stat-label")
+        empty_label.set_margin_top(20)
+        _list_box.add(empty_label)
+    else:
+        for proc in processes:
+            row = _build_process_row(proc, _list_box)
+            _list_box.add(row)
+
+    _list_box.show_all()
+
+    if _stats_label is not None:
+        _stats_label.set_text(_compute_stats(processes))
+
+    return False  # one-shot for idle_add
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+_refresh_in_flight = False
+_refresh_lock = threading.Lock()
+
+
+def _refresh_processes_thread() -> None:
+    """Scan processes in background thread, push result to GTK via idle_add."""
+    global _refresh_in_flight
+    try:
+        processes = _scan_processes()
+        GLib.idle_add(_populate_list_box, processes)
+    except Exception:
+        log.exception("refresh processes (background)")
+    finally:
+        with _refresh_lock:
+            _refresh_in_flight = False
+
+
+def refresh_processes() -> bool:
+    """Re-scan processes in background thread. Returns True to keep GLib timer alive."""
+    global _refresh_in_flight
+    with _refresh_lock:
+        if _refresh_in_flight:
+            return True
+        _refresh_in_flight = True
+    threading.Thread(
+        target=_refresh_processes_thread,
+        daemon=True,
+        name="claude-panel-process-scan",
+    ).start()
+    return True  # keep timer running
+
+
+def build_processes_tab() -> Gtk.ScrolledWindow:
+    """Build and return the Processes tab widget (Gtk.ScrolledWindow)."""
+    global _list_box, _stats_label
+
+    # Root: ScrolledWindow -> main VBox
+    scrolled = Gtk.ScrolledWindow()
+    scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    scrolled.set_hexpand(True)
+    scrolled.set_vexpand(True)
+
+    main_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+    main_vbox.set_margin_top(8)
+    main_vbox.set_margin_bottom(8)
+    main_vbox.set_margin_start(8)
+    main_vbox.set_margin_end(8)
+    scrolled.add(main_vbox)
+
+    # Toolbar: title + Kill All Ghosts + refresh button
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.set_margin_bottom(6)
+    main_vbox.pack_start(toolbar, False, False, 0)
+
+    title_label = Gtk.Label(label="Prozesse")
+    title_label.get_style_context().add_class("section-title")
+    title_attrs = Pango.AttrList()
+    title_attrs.insert(Pango.attr_weight_new(Pango.Weight.BOLD))
+    title_attrs.insert(Pango.attr_scale_new(1.1))
+    title_label.set_attributes(title_attrs)
+    title_label.set_halign(Gtk.Align.START)
+    toolbar.pack_start(title_label, False, False, 0)
+
+    # Spacer
+    spacer = Gtk.Box()
+    spacer.set_hexpand(True)
+    toolbar.pack_start(spacer, True, True, 0)
+
+    # Kill All Ghosts button
+    kill_ghosts_btn = Gtk.Button(label=f"Kill All Ghosts (>{GHOST_HOURS}h)")
+    kill_ghosts_btn.get_style_context().add_class("destructive-action")
+    kill_ghosts_btn.set_tooltip_text(f"Alle Prozesse aelter als {GHOST_HOURS}h per SIGTERM beenden")
+
+    def on_kill_ghosts_clicked(_btn: Gtk.Button) -> None:
+        ghosts = [p for p in _all_processes if p["is_ghost"]]
+        if not ghosts:
+            return
+        if _confirm_kill_ghosts(_btn, len(ghosts)):
+            for p in ghosts:
+                _kill_process(p["pid"], _btn)
+            idle_once(refresh_processes)
+
+    kill_ghosts_btn.connect("clicked", on_kill_ghosts_clicked)
+    toolbar.pack_start(kill_ghosts_btn, False, False, 0)
+
+    # Refresh button
+    refresh_btn = Gtk.Button()
+    refresh_icon = Gtk.Image.new_from_icon_name("view-refresh-symbolic", Gtk.IconSize.BUTTON)
+    refresh_btn.add(refresh_icon)
+    refresh_btn.set_tooltip_text("Prozessliste aktualisieren")
+    refresh_btn.connect("clicked", lambda _b: refresh_processes())
+    toolbar.pack_start(refresh_btn, False, False, 0)
+
+    # Stats bar
+    stats_frame = Gtk.Frame()
+    stats_frame.set_margin_bottom(8)
+    main_vbox.pack_start(stats_frame, False, False, 0)
+
+    _stats_label = Gtk.Label(label="Lade Prozesse...")
+    _stats_label.get_style_context().add_class("stat-label")
+    _stats_label.set_margin_top(6)
+    _stats_label.set_margin_bottom(6)
+    _stats_label.set_margin_start(10)
+    _stats_label.set_margin_end(10)
+    _stats_label.set_halign(Gtk.Align.START)
+    stats_frame.add(_stats_label)
+
+    # Column headers
+    header_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    header_box.set_margin_start(10)
+    header_box.set_margin_end(10)
+    header_box.set_margin_bottom(4)
+    main_vbox.pack_start(header_box, False, False, 0)
+
+    for col_label, expand in [("Name / Befehl", True), ("PID / Uptime", False), ("RAM / CPU / Kill", False)]:
+        lbl = Gtk.Label(label=col_label)
+        lbl.get_style_context().add_class("stat-label")
+        col_attrs = Pango.AttrList()
+        col_attrs.insert(Pango.attr_weight_new(Pango.Weight.BOLD))
+        col_attrs.insert(Pango.attr_scale_new(0.85))
+        lbl.set_attributes(col_attrs)
+        lbl.set_halign(Gtk.Align.START)
+        header_box.pack_start(lbl, expand, expand, 0)
+
+    # ListBox for processes
+    _list_box = Gtk.ListBox()
+    _list_box.set_selection_mode(Gtk.SelectionMode.NONE)
+    _list_box.get_style_context().add_class("view")
+    main_vbox.pack_start(_list_box, True, True, 0)
+
+    idle_once(lambda: _populate_list_box(_scan_processes()))
+
+    scrolled.show_all()
+    return scrolled

project_dashboard_tab.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""Project Dashboard Tab — WebKit2 WebView embedding the Project Dashboard.
+
+Provides build_project_dashboard_tab() returning a Gtk.Box with:
+- Toolbar: Reload, Open in Browser, Rescan, server status
+- WebKit2 WebView loading http://localhost:5222
+- Auto-starts uvicorn server if not running
+"""
+
+import subprocess
+import os
+from pathlib import Path
+
+LOG_DIR = Path.home() / ".cache" / "project-dashboard"
+LOG_FILE = LOG_DIR / "server.log"
+
+import gi
+gi.require_version("Gtk", "3.0")
+gi.require_version("WebKit2", "4.1")
+from gi.repository import Gtk, GLib, WebKit2
+from theme import get_palette
+
+DASHBOARD_PORT = 5222
+DASHBOARD_URL = f"http://localhost:{DASHBOARD_PORT}"
+DASHBOARD_DIR = Path.home() / "Projekte" / "ProjectDashboard"
+VENV_PYTHON = DASHBOARD_DIR / ".venv" / "bin" / "python3"
+
+# Module-level refs for refresh
+_webview = None
+_status_label = None
+_spinner = None
+_server_proc = None
+_retry_count = 0
+
+
+def _server_healthy(port: int) -> bool:
+    """Check if the dashboard server responds."""
+    try:
+        import urllib.request
+        with urllib.request.urlopen(
+            f"http://127.0.0.1:{port}/api/stats", timeout=2
+        ) as resp:
+            return resp.status == 200
+    except Exception:
+        return False
+
+
+def _ensure_server():
+    """Start the uvicorn dashboard server if not already running."""
+    global _server_proc
+    if _server_healthy(DASHBOARD_PORT):
+        return True
+
+    if not DASHBOARD_DIR.exists():
+        return False
+
+    python = str(VENV_PYTHON) if VENV_PYTHON.exists() else "python3"
+    main_py = DASHBOARD_DIR / "main.py"
+    if not main_py.exists():
+        return False
+
+    try:
+        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        log_fh = open(LOG_FILE, "a", encoding="utf-8")
+        _server_proc = subprocess.Popen(
+            [python, "-m", "uvicorn", "main:app",
+             "--host", "127.0.0.1", "--port", str(DASHBOARD_PORT)],
+            cwd=str(DASHBOARD_DIR),
+            stdout=log_fh,
+            stderr=log_fh,
+            preexec_fn=os.setpgrp,
+        )
+        return True
+    except Exception:
+        return False
+
+
+def _update_status(connected: bool):
+    """Update the status label and spinner."""
+    if _status_label is None:
+        return
+    ctx = _status_label.get_style_context()
+    ctx.remove_class("swarm-status-connected")
+    ctx.remove_class("swarm-status-disconnected")
+    if connected:
+        ctx.add_class("swarm-status-connected")
+        _status_label.set_text("● Verbunden")
+        if _spinner is not None:
+            _spinner.stop()
+    else:
+        ctx.add_class("swarm-status-disconnected")
+        _status_label.set_text("● Getrennt")
+        if _spinner is not None:
+            _spinner.start()
+
+
+def build_project_dashboard_tab() -> Gtk.Box:
+    """Build and return the Project Dashboard tab widget."""
+    global _webview, _status_label, _spinner
+
+    box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+
+    # --- Toolbar ---
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.set_margin_start(8)
+    toolbar.set_margin_end(8)
+    toolbar.set_margin_top(6)
+    toolbar.set_margin_bottom(4)
+    toolbar.get_style_context().add_class("swarm-toolbar")
+
+    reload_btn = Gtk.Button(label="⟳ Reload")
+    reload_btn.set_tooltip_text("Dashboard neu laden")
+    reload_btn.connect("clicked", _on_reload)
+    reload_btn.get_style_context().add_class("swarm-btn")
+    toolbar.pack_start(reload_btn, False, False, 0)
+
+    browser_btn = Gtk.Button(label="↗ Browser")
+    browser_btn.set_tooltip_text("Im Browser oeffnen")
+    browser_btn.connect("clicked", _on_open_browser)
+    browser_btn.get_style_context().add_class("swarm-btn")
+    toolbar.pack_start(browser_btn, False, False, 0)
+
+    rescan_btn = Gtk.Button(label="⟳ Rescan")
+    rescan_btn.set_tooltip_text("Alle Projekte neu scannen")
+    rescan_btn.connect("clicked", _on_rescan)
+    rescan_btn.get_style_context().add_class("swarm-btn")
+    toolbar.pack_start(rescan_btn, False, False, 0)
+
+    _spinner = Gtk.Spinner()
+    toolbar.pack_end(_spinner, False, False, 0)
+
+    _status_label = Gtk.Label()
+    _status_label.set_xalign(1.0)
+    toolbar.pack_end(_status_label, False, False, 4)
+
+    url_label = Gtk.Label(label=DASHBOARD_URL)
+    url_label.get_style_context().add_class("swarm-url")
+    url_label.set_xalign(1.0)
+    toolbar.pack_end(url_label, False, False, 8)
+
+    box.pack_start(toolbar, False, False, 0)
+
+    # --- Separator ---
+    box.pack_start(Gtk.Separator(), False, False, 0)
+
+    # --- WebView ---
+    _webview = WebKit2.WebView()
+
+    settings = _webview.get_settings()
+    settings.set_enable_javascript(True)
+    settings.set_enable_developer_extras(False)
+    settings.set_hardware_acceleration_policy(
+        WebKit2.HardwareAccelerationPolicy.NEVER
+    )
+
+    # Start server and load
+    _ensure_server()
+
+    if _server_healthy(DASHBOARD_PORT):
+        _webview.load_uri(DASHBOARD_URL)
+        _update_status(True)
+    else:
+        _update_status(False)
+        p = get_palette()
+        _webview.load_html(
+            f'<html><body style="background:{p["bg"]};color:{p["text"]};font-family:system-ui;'
+            'display:flex;align-items:center;justify-content:center;height:100vh;'
+            'flex-direction:column;gap:12px">'
+            '<div style="font-size:24px;opacity:0.4">⟳</div>'
+            '<div>Project Dashboard startet...</div>'
+            f'<div style="font-size:12px;color:{p["overlay"]}">Automatischer Retry alle 2s</div>'
+            '</body></html>',
+            None
+        )
+        GLib.timeout_add_seconds(2, _retry_load)
+
+    box.pack_start(_webview, True, True, 0)
+
+    return box
+
+
+def _retry_load() -> bool:
+    """Retry loading the dashboard URL."""
+    global _retry_count
+    _retry_count += 1
+    if _server_healthy(DASHBOARD_PORT):
+        _retry_count = 0
+        if _webview:
+            _webview.load_uri(DASHBOARD_URL)
+        _update_status(True)
+        return False
+    elif _retry_count >= 15:
+        _retry_count = 0
+        if _webview:
+            log_hint = str(LOG_FILE)
+            p = get_palette()
+            _webview.load_html(
+                f'<html><body style="background:{p["bg"]};color:{p["red"]};font-family:system-ui;'
+                'display:flex;align-items:center;justify-content:center;height:100vh;'
+                'flex-direction:column;gap:12px">'
+                '<div style="font-size:24px">Server-Fehler</div>'
+                f'<div style="font-size:12px;color:{p["overlay"]}">Log: {log_hint}</div>'
+                f'<button onclick="location.reload()" style="background:{p["card"]};color:{p["text"]};'
+                f'border:1px solid {p["border"]};border-radius:6px;padding:8px 16px;cursor:pointer;'
+                'font-size:13px;margin-top:8px">Retry</button>'
+                '</body></html>',
+                None
+            )
+        _update_status(False)
+        return False
+    else:
+        _ensure_server()
+        return True
+
+
+def _on_reload(_btn):
+    """Reload the WebView."""
+    if _webview:
+        _webview.reload()
+
+
+def _on_open_browser(_btn):
+    """Open dashboard in default browser."""
+    try:
+        subprocess.Popen(
+            ["xdg-open", DASHBOARD_URL],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except Exception:
+        pass
+
+
+def _on_rescan(_btn):
+    """Trigger a rescan via the API and reload."""
+    try:
+        import urllib.request
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{DASHBOARD_PORT}/rescan", method="POST"
+        )
+        urllib.request.urlopen(req, timeout=10)
+    except Exception:
+        pass
+    if _webview:
+        _webview.reload()
+
+
+def refresh_project_dashboard() -> bool:
+    """Check server health — called by GLib timer from panel.py."""
+    connected = _server_healthy(DASHBOARD_PORT)
+    _update_status(connected)
+    if not connected:
+        _ensure_server()
+    return True  # keep timer alive

requirements.txt

@@ -0,0 +1 @@
+PyGObject>=3.42

session_browser.py

@@ -0,0 +1,1039 @@
+#!/usr/bin/env python3
+"""Session Browser — GTK3 widget module for Claude Code Control Panel.
+
+Provides build_sessions_tab() returning a Gtk.ScrolledWindow with:
+- Full session list from ~/.claude/projects/ (last 20 by mtime)
+- Search/filter by project name or preview text
+- Per-session resume button (kitty -e claude -r SESSION_ID)
+- Stats bar: total sessions, sessions in last hour, unique projects
+- Refresh button to re-scan
+
+Theme: Catppuccin Mocha (dark) / Latte (light) via theme.py
+"""
+
+import html as html_mod
+import json
+import logging
+import re
+import shlex
+import subprocess
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+log = logging.getLogger("claude_panel.session_browser")
+
+# Module-level metadata cache: path → (mtime, meta_dict)
+_meta_cache: dict[str, tuple[float, dict]] = {}
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk, Pango
+
+from utils import idle_once, short_name_from_path, HOME
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+PROJECTS_DIR = Path(HOME) / ".claude" / "projects"
+
+# Colors are handled by CSS classes defined in theme.py
+
+# ---------------------------------------------------------------------------
+# Module-level state (kept between refreshes)
+# Grouped into a single namespace dict to avoid scattered globals.
+# ---------------------------------------------------------------------------
+_state: dict = {
+    "list_box": None,       # Gtk.ListBox | None
+    "stats_label": None,    # Gtk.Label | None
+    "search_entry": None,   # Gtk.SearchEntry | None
+    "all_sessions": [],     # list[dict]
+    "search_mode": False,   # True when in grep search mode
+    "debounce_id": None,    # GLib timeout source ID for debounce
+    "batch_id": None,       # GLib idle source ID for batch insertion
+}
+
+# Cancellation token for the background grep thread.
+# Replaced with a fresh Event each time a new search starts.
+_search_cancel: threading.Event = threading.Event()
+
+
+# ---------------------------------------------------------------------------
+# Session scanning helpers
+# ---------------------------------------------------------------------------
+
+def _format_size(size_bytes: int) -> str:
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+
+_PREVIEW_SKIP_PREFIXES = (
+    "[Request interrupted",
+    "Implement the following plan",
+    "<local-command-caveat>",
+    "<command-name>",
+)
+
+
+def _get_session_meta(path: Path, max_len: int = 120) -> dict:
+    """Read metadata from JSONL file: preview text, cwd, slug.
+
+    Uses a module-level mtime cache — unchanged files are never re-read.
+    For files under 512KB: reads all lines ONCE, extracts first 30 + last 10.
+    For large files (>=512KB): reads first 30 lines + subprocess tail for last 10.
+    """
+    path_str = str(path)
+    try:
+        stat = path.stat()
+        mtime = stat.st_mtime
+        file_size = stat.st_size
+    except OSError:
+        return {"preview": "(keine Vorschau)", "cwd": "", "slug": ""}
+
+    # Cache hit — file unchanged since last read
+    cached = _meta_cache.get(path_str)
+    if cached is not None and cached[0] == mtime:
+        return cached[1]
+
+    slug: str = ""
+    cwd: str = ""
+    preview: str = ""
+
+    try:
+        if file_size < 512 * 1024:
+            # Single read — extract head and tail from the same list
+            with path.open(encoding="utf-8", errors="replace") as f:
+                all_lines = f.readlines()
+            head_lines = all_lines[:30]
+            tail_lines = all_lines[-10:] if len(all_lines) > 30 else []
+        else:
+            # Large file: read first 30 lines + subprocess tail
+            head_lines = []
+            with path.open(encoding="utf-8", errors="replace") as f:
+                for _ in range(30):
+                    line = f.readline()
+                    if not line:
+                        break
+                    head_lines.append(line)
+            try:
+                result = subprocess.run(
+                    ["tail", "-n", "10", str(path)],
+                    capture_output=True, text=True, timeout=2
+                )
+                tail_lines = result.stdout.splitlines(keepends=True)
+            except (subprocess.TimeoutExpired, OSError):
+                tail_lines = []
+
+        all_sample = head_lines + tail_lines
+
+        for line in all_sample:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if not slug and entry.get("slug"):
+                slug = entry["slug"]
+            if not cwd and entry.get("cwd"):
+                cwd = entry["cwd"]
+
+            if preview:
+                if cwd and slug:
+                    break
+                continue
+
+            if entry.get("type") != "user":
+                continue
+
+            msg = entry.get("message", {})
+            content = msg.get("content", "")
+            if isinstance(content, list):
+                text_blocks = [
+                    block.get("text", "")
+                    for block in content
+                    if isinstance(block, dict)
+                    and block.get("type") == "text"
+                    and "<local-command-caveat>" not in block.get("text", "")
+                ]
+                if text_blocks:
+                    content = text_blocks[0]
+                else:
+                    continue
+            if not isinstance(content, str):
+                continue
+            content = content.strip()
+            if any(content.startswith(p) for p in _PREVIEW_SKIP_PREFIXES):
+                if content.startswith("Implement the following plan"):
+                    for plan_line in content.split("\n"):
+                        plan_line = plan_line.strip()
+                        if plan_line.startswith("# "):
+                            title = plan_line[2:].strip()
+                            if title.lower().startswith("plan:"):
+                                title = title[5:].strip()
+                            if len(title) > max_len:
+                                title = title[:max_len] + "..."
+                            preview = title
+                            break
+                continue
+            first_line = content.split("\n")[0]
+            if len(first_line) > max_len:
+                first_line = first_line[:max_len] + "..."
+            preview = first_line
+    except (OSError, PermissionError):
+        pass
+
+    if not preview:
+        preview = slug if slug else "(keine Vorschau)"
+    result = {"preview": preview, "cwd": cwd, "slug": slug}
+    _meta_cache[path_str] = (mtime, result)
+    return result
+
+
+def _get_session_status(path: Path, mtime: float, now: float) -> str:
+    """Determine session status from last JSONL entry.
+
+    Returns:
+        "working"  — Claude is actively processing (last entry is tool_use or user msg)
+        "ready"    — Claude finished, waiting for user input
+        "idle"     — session not recently active
+    """
+    age = now - mtime
+    if age > 120:
+        return "idle"
+
+    # Read last non-empty line of JSONL (seek from end for speed)
+    try:
+        size = path.stat().st_size
+        if size == 0:
+            return "idle"
+        # Read last 4KB — enough for the final JSONL line
+        read_size = min(size, 4096)
+        with path.open("rb") as f:
+            f.seek(-read_size, 2)
+            tail = f.read().decode("utf-8", errors="replace")
+        lines = [l for l in tail.strip().splitlines() if l.strip()]
+        if not lines:
+            return "idle"
+        last_line = lines[-1]
+        try:
+            entry = json.loads(last_line)
+        except json.JSONDecodeError:
+            # If last line is corrupt, check second-to-last
+            if len(lines) >= 2:
+                try:
+                    entry = json.loads(lines[-2])
+                except json.JSONDecodeError:
+                    return "ready" if age < 120 else "idle"
+            else:
+                return "ready" if age < 120 else "idle"
+
+        entry_type = entry.get("type", "")
+        msg = entry.get("message", {})
+
+        # User message → Claude is about to process
+        if entry_type == "user":
+            return "working"
+
+        # Assistant message → check for tool_use (Claude still working)
+        if entry_type == "assistant":
+            content = msg.get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_use":
+                        return "working"
+            # Check stop_reason — tool_use means Claude wants to call a tool
+            stop = msg.get("stop_reason", "")
+            if stop == "tool_use":
+                return "working"
+            # end_turn or max_tokens → Claude is done
+            return "ready"
+
+        # Tool result → Claude is processing
+        if entry_type == "tool_result":
+            return "working"
+
+        # Fallback: if very recent mtime, likely working
+        return "working" if age < 5 else "ready"
+
+    except (OSError, PermissionError):
+        return "ready" if age < 120 else "idle"
+
+
+def _build_project_info(path: Path, session_cwd: str) -> tuple[str, str]:
+    """Derive (project_name, short_name) from a session's CWD or parent dir name.
+
+    Shared by _scan_all_sessions() and _grep_sessions() to avoid duplicated logic.
+    Returns (project_name, short_name).
+    """
+    short_name = short_name_from_path(session_cwd)
+    if session_cwd and session_cwd != HOME:
+        project_name = session_cwd.replace(HOME, "~", 1)
+    else:
+        # Fallback: derive project from JSONL parent dir name
+        # e.g. "-home-smlflg-Projekte-ClaudeCodePanel" → "ClaudeCodePanel"
+        dir_name = path.parent.name  # encoded path
+        parts = dir_name.split("-")
+        # Strip leading home-user prefix
+        # "-home-smlflg-Projekte-Foo" → ["", "home", "smlflg", "Projekte", "Foo"]
+        meaningful = [p for p in parts if p and p not in ("home", "smlflg")]
+        if meaningful:
+            short_name = meaningful[-1]
+            project_name = "~/" + "/".join(meaningful)
+        else:
+            project_name = "Home"
+    return project_name, short_name
+
+
+def _scan_all_sessions() -> list[dict]:
+    """Scan ~/.claude/projects/ and return session dicts sorted by mtime desc.
+
+    Caps at 200 most-recently-modified JSONL files to bound scan time on
+    large installations (2800+ files). Older sessions remain accessible
+    via fulltext search (_grep_sessions).
+    """
+    sessions: list[dict] = []
+
+    if not PROJECTS_DIR.exists():
+        return sessions
+
+    # Collect all JSONL paths first, then sort by mtime and cap at 200
+    all_files: list[Path] = []
+    for project_dir in PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.glob("*.jsonl"):
+            all_files.append(f)
+
+    # Sort newest-first and limit to 200 — avoids scanning all 2800+ files
+    all_files = sorted(all_files, key=lambda p: p.stat().st_mtime, reverse=True)[:200]
+
+    now = time.time()
+    for f in all_files:
+        try:
+            stat = f.stat()
+            meta = _get_session_meta(f)
+            project_name, short_name = _build_project_info(f, meta["cwd"])
+            status = _get_session_status(f, stat.st_mtime, now)
+            sessions.append(
+                {
+                    "path": str(f),
+                    "project": project_name,
+                    "short_name": short_name,
+                    "session_id": f.stem,
+                    "mtime": stat.st_mtime,
+                    "size": stat.st_size,
+                    "time_str": datetime.fromtimestamp(stat.st_mtime).strftime(
+                        "%d.%m %H:%M"
+                    ),
+                    "preview": meta["preview"],
+                    "slug": meta["slug"],
+                    "status": status,
+                }
+            )
+        except (OSError, PermissionError):
+            continue
+
+    sessions.sort(key=lambda s: s["mtime"], reverse=True)
+    return sessions
+
+
+def _grep_sessions(query: str) -> list[dict]:
+    """Fulltext search across all session files using grep -l -i.
+
+    Returns matching session dicts with snippet context.
+    Runs synchronously (~0.3s for 649 files).
+    """
+    if not PROJECTS_DIR.exists():
+        return []
+
+    # Collect all JSONL files
+    all_files = []
+    for project_dir in PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.glob("*.jsonl"):
+            all_files.append(str(f))
+
+    if not all_files:
+        return []
+
+    # grep -l -i for matching files
+    try:
+        result = subprocess.run(
+            ["grep", "-l", "-i", "--", query] + all_files,
+            capture_output=True, text=True, timeout=10
+        )
+        matching_files = [f for f in result.stdout.splitlines() if f.strip()]
+    except (subprocess.TimeoutExpired, OSError):
+        return []
+
+    if not matching_files:
+        return []
+
+    # Batch grep -c for match counts (one subprocess for all files)
+    counts: dict[str, int] = {}
+    try:
+        count_result = subprocess.run(
+            ["grep", "-i", "-c", "--", query] + matching_files,
+            capture_output=True, text=True, timeout=10
+        )
+        for line in count_result.stdout.splitlines():
+            # Format: filepath:count
+            if ":" in line:
+                fpath, _, cnt = line.rpartition(":")
+                try:
+                    counts[fpath] = int(cnt)
+                except ValueError:
+                    pass
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    # Build session dicts for matching files
+    now = time.time()
+    query_lower = query.lower()
+    sessions = []
+    for filepath in matching_files:
+        path = Path(filepath)
+        try:
+            stat = path.stat()
+            meta = _get_session_meta(path)
+            project_name, short_name = _build_project_info(path, meta["cwd"])
+            status = _get_session_status(path, stat.st_mtime, now)
+
+            sessions.append({
+                "path": filepath,
+                "project": project_name,
+                "short_name": short_name,
+                "session_id": path.stem,
+                "mtime": stat.st_mtime,
+                "size": stat.st_size,
+                "time_str": datetime.fromtimestamp(stat.st_mtime).strftime("%d.%m %H:%M"),
+                "preview": meta["preview"],
+                "status": status,
+                "snippet": "",
+                "match_count": counts.get(filepath, 0),
+            })
+        except (OSError, PermissionError):
+            continue
+
+    sessions.sort(key=lambda s: s["mtime"], reverse=True)
+
+    # Extract snippets: one batched grep -m1 -H for top 50 results
+    top_files = [s["path"] for s in sessions[:50]]
+    if top_files:
+        snippet_map: dict[str, str] = {}
+        try:
+            snip_result = subprocess.run(
+                ["grep", "-i", "-m", "1", "-H", "--", query] + top_files,
+                capture_output=True, text=True, timeout=10
+            )
+            for line in snip_result.stdout.splitlines():
+                # Format: filepath:json_line (split on first : after filepath)
+                # JSONL paths contain no colons, so first : is the separator
+                sep = line.find(".jsonl:")
+                if sep < 0:
+                    continue
+                fpath = line[:sep + 6]  # include ".jsonl"
+                raw = line[sep + 7:]    # skip ":"
+                if fpath not in snippet_map:
+                    snippet_map[fpath] = raw.strip()
+        except (subprocess.TimeoutExpired, OSError):
+            snippet_map = {}
+
+        for session in sessions[:50]:
+            raw = snippet_map.get(session["path"], "")
+            if not raw:
+                continue
+            try:
+                obj = json.loads(raw)
+                msg = obj.get("message", {})
+                content = msg.get("content", "") if isinstance(msg, dict) else ""
+                if isinstance(content, list):
+                    texts = [b.get("text", "") for b in content
+                             if isinstance(b, dict) and b.get("type") == "text"]
+                    content = " ".join(texts)
+                if not isinstance(content, str):
+                    content = ""
+                if query_lower not in content.lower():
+                    content = json.dumps(obj, ensure_ascii=False)
+            except (json.JSONDecodeError, AttributeError):
+                content = raw
+            if query_lower in content.lower():
+                idx = content.lower().find(query_lower)
+                start = max(0, idx - 60)
+                end = min(len(content), idx + len(query) + 60)
+                snippet = content[start:end].replace("\n", " ").strip()
+                for char in ('"', '{', '}', '\\'):
+                    snippet = snippet.replace(char, ' ')
+                snippet = " ".join(snippet.split())
+                if start > 0:
+                    snippet = "…" + snippet
+                if end < len(content):
+                    snippet = snippet + "…"
+                session["snippet"] = snippet
+
+    return sessions
+
+
+# ---------------------------------------------------------------------------
+# Stats helper
+# ---------------------------------------------------------------------------
+
+def _compute_stats(sessions: list[dict], now: float | None = None) -> str:
+    total = len(sessions)
+    if now is None:
+        now = time.time()
+    working = sum(1 for s in sessions if s.get("status") == "working")
+    ready = sum(1 for s in sessions if s.get("status") == "ready")
+    recent = sum(1 for s in sessions if now - s["mtime"] < 3600)
+    projects = len({s["project"] for s in sessions})
+    parts = [f"{total} Sessions"]
+    if working:
+        parts.append(f"{working} arbeitet")
+    if ready:
+        parts.append(f"{ready} bereit")
+    parts.append(f"{recent} in letzter Stunde")
+    parts.append(f"{projects} Projekte")
+    return "  |  ".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Row builder
+# ---------------------------------------------------------------------------
+
+def _build_session_row(session: dict, now: float | None = None) -> Gtk.ListBoxRow:
+    """Build a single styled ListBoxRow for one session."""
+    if now is None:
+        now = time.time()
+    row = Gtk.ListBoxRow()
+    row.set_name("session-row")
+    row.get_style_context().add_class("session-row")
+
+    status = session.get("status", "idle")
+    is_active = status in ("working", "ready")
+    if status == "working":
+        row.get_style_context().add_class("session-row-working")
+    elif status == "ready":
+        row.get_style_context().add_class("session-row-ready")
+
+    # Outer box
+    outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
+    outer.set_margin_top(4)
+    outer.set_margin_bottom(4)
+    outer.set_margin_start(8)
+    outer.set_margin_end(10)
+    row.add(outer)
+
+    # Left: short name + preview + full path stacked vertically
+    info_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
+    info_box.set_hexpand(True)
+    outer.pack_start(info_box, True, True, 0)
+
+    # Short project name — bold, dedicated class
+    name_label = Gtk.Label(label=session["short_name"])
+    name_label.set_halign(Gtk.Align.START)
+    name_label.set_ellipsize(Pango.EllipsizeMode.END)
+    name_label.set_max_width_chars(45)
+    name_label.get_style_context().add_class("session-project")
+    info_box.pack_start(name_label, False, False, 0)
+
+    # Subtitle: slug (e.g. "Wild Crafting Sutton") or first 80 chars of preview
+    raw_slug = session.get("slug", "")
+    if raw_slug:
+        subtitle_text = raw_slug.replace("-", " ").title()
+    else:
+        raw_preview = session.get("preview", "")
+        subtitle_text = raw_preview[:80] + ("…" if len(raw_preview) > 80 else "")
+    if subtitle_text:
+        subtitle_label = Gtk.Label(label=subtitle_text)
+        subtitle_label.set_halign(Gtk.Align.START)
+        subtitle_label.set_ellipsize(Pango.EllipsizeMode.END)
+        subtitle_label.set_max_width_chars(70)
+        subtitle_label.get_style_context().add_class("session-meta")
+        subtitle_attrs = Pango.AttrList()
+        subtitle_attrs.insert(Pango.attr_scale_new(0.88))
+        subtitle_label.set_attributes(subtitle_attrs)
+        info_box.pack_start(subtitle_label, False, False, 0)
+
+    # Preview — Subtext1 for better contrast
+    preview_label = Gtk.Label(label=session["preview"])
+    preview_label.set_halign(Gtk.Align.START)
+    preview_label.set_ellipsize(Pango.EllipsizeMode.END)
+    preview_label.set_max_width_chars(90)
+    preview_label.get_style_context().add_class("session-preview")
+    info_box.pack_start(preview_label, False, False, 0)
+
+    # Project path — always shown for context
+    path_label = Gtk.Label(label=session["project"])
+    path_label.set_halign(Gtk.Align.START)
+    path_label.set_ellipsize(Pango.EllipsizeMode.END)
+    path_label.set_max_width_chars(70)
+    path_label.get_style_context().add_class("session-meta")
+    path_attrs = Pango.AttrList()
+    path_attrs.insert(Pango.attr_scale_new(0.82))
+    path_label.set_attributes(path_attrs)
+    info_box.pack_start(path_label, False, False, 0)
+
+    # Right: meta info + resume button
+    meta_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    meta_box.set_valign(Gtk.Align.CENTER)
+    outer.pack_start(meta_box, False, False, 0)
+
+    # Status badge for active sessions
+    if status == "working":
+        badge = Gtk.Label(label="ARBEITET")
+        badge.get_style_context().add_class("session-working-badge")
+        badge.set_halign(Gtk.Align.END)
+        meta_box.pack_start(badge, False, False, 0)
+    elif status == "ready":
+        badge = Gtk.Label(label="BEREIT")
+        badge.get_style_context().add_class("session-ready-badge")
+        badge.set_halign(Gtk.Align.END)
+        meta_box.pack_start(badge, False, False, 0)
+
+    # Date/time + size — dimmed metadata
+    meta_line = Gtk.Label(label=f"{session['time_str']}  {_format_size(session['size'])}")
+    meta_line.set_halign(Gtk.Align.END)
+    meta_line.get_style_context().add_class("session-meta")
+    meta_box.pack_start(meta_line, False, False, 0)
+
+    # Resume button — custom styled
+    resume_btn = Gtk.Button(label="Resume")
+    resume_btn.set_tooltip_text(f"claude -r {session['session_id']}")
+    resume_btn.get_style_context().add_class("session-resume")
+    session_id = session["session_id"]
+    resume_btn.connect("clicked", _on_resume_clicked, session_id)
+    meta_box.pack_start(resume_btn, False, False, 0)
+
+    # Store session data on row for filtering
+    row._session_data = session  # type: ignore[attr-defined]
+
+    row.show_all()
+    return row
+
+
+def _build_search_row(session: dict, query: str, now: float | None = None) -> Gtk.ListBoxRow:
+    """Build a ListBoxRow for a search result with snippet + highlighting."""
+    if now is None:
+        now = time.time()
+    row = Gtk.ListBoxRow()
+    row.set_name("session-row")
+    row.get_style_context().add_class("session-row")
+    row.get_style_context().add_class("session-row-search")
+
+    # Outer box
+    outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
+    outer.set_margin_top(4)
+    outer.set_margin_bottom(4)
+    outer.set_margin_start(8)
+    outer.set_margin_end(10)
+    row.add(outer)
+
+    # Left: short name + preview + snippet + path
+    info_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
+    info_box.set_hexpand(True)
+    outer.pack_start(info_box, True, True, 0)
+
+    # Short project name
+    name_label = Gtk.Label(label=session["short_name"])
+    name_label.set_halign(Gtk.Align.START)
+    name_label.set_ellipsize(Pango.EllipsizeMode.END)
+    name_label.set_max_width_chars(45)
+    name_label.get_style_context().add_class("session-project")
+    info_box.pack_start(name_label, False, False, 0)
+
+    # Preview
+    preview_label = Gtk.Label(label=session["preview"])
+    preview_label.set_halign(Gtk.Align.START)
+    preview_label.set_ellipsize(Pango.EllipsizeMode.END)
+    preview_label.set_max_width_chars(90)
+    preview_label.get_style_context().add_class("session-preview")
+    info_box.pack_start(preview_label, False, False, 0)
+
+    # Snippet with Pango markup highlighting
+    snippet = session.get("snippet", "")
+    if snippet and query:
+        # Escape markup characters first, then highlight
+        safe_snippet = html_mod.escape(snippet)
+        safe_query = html_mod.escape(query)
+        # Case-insensitive highlight
+        highlighted = re.sub(
+            re.escape(safe_query),
+            lambda m: f"<b>{m.group()}</b>",
+            safe_snippet,
+            flags=re.IGNORECASE
+        )
+        snippet_label = Gtk.Label()
+        snippet_label.set_markup(highlighted)
+        snippet_label.set_halign(Gtk.Align.START)
+        snippet_label.set_ellipsize(Pango.EllipsizeMode.END)
+        snippet_label.set_max_width_chars(100)
+        snippet_label.get_style_context().add_class("session-snippet")
+        info_box.pack_start(snippet_label, False, False, 0)
+
+    # Project path
+    path_label = Gtk.Label(label=session["project"])
+    path_label.set_halign(Gtk.Align.START)
+    path_label.set_ellipsize(Pango.EllipsizeMode.END)
+    path_label.set_max_width_chars(70)
+    path_label.get_style_context().add_class("session-meta")
+    path_attrs = Pango.AttrList()
+    path_attrs.insert(Pango.attr_scale_new(0.82))
+    path_label.set_attributes(path_attrs)
+    info_box.pack_start(path_label, False, False, 0)
+
+    # Right: match badge + meta + resume button
+    meta_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    meta_box.set_valign(Gtk.Align.CENTER)
+    outer.pack_start(meta_box, False, False, 0)
+
+    # Match count badge
+    match_count = session.get("match_count", 0)
+    if match_count > 0:
+        badge = Gtk.Label(label=f"{match_count} Treffer")
+        badge.get_style_context().add_class("session-match-badge")
+        badge.set_halign(Gtk.Align.END)
+        meta_box.pack_start(badge, False, False, 0)
+
+    # Date/time + size
+    meta_line = Gtk.Label(label=f"{session['time_str']}  {_format_size(session['size'])}")
+    meta_line.set_halign(Gtk.Align.END)
+    meta_line.get_style_context().add_class("session-meta")
+    meta_box.pack_start(meta_line, False, False, 0)
+
+    # Resume button
+    resume_btn = Gtk.Button(label="Resume")
+    resume_btn.set_tooltip_text(f"claude -r {session['session_id']}")
+    resume_btn.get_style_context().add_class("session-resume")
+    session_id = session["session_id"]
+    resume_btn.connect("clicked", _on_resume_clicked, session_id)
+    meta_box.pack_start(resume_btn, False, False, 0)
+
+    row._session_data = session
+    row.show_all()
+    return row
+
+
+def _on_resume_clicked(_btn: Gtk.Button, session_id: str) -> None:
+    """Launch kitty terminal with claude -r SESSION_ID."""
+    try:
+        # List-form Popen (not shell=True) is safe against injection regardless of
+        # special characters in session_id — each element is passed as a literal argument.
+        subprocess.Popen(
+            ["kitty", "-e", "claude", "-r", session_id],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except FileNotFoundError:
+        # kitty not found — fallback terminal uses shell=False list form too.
+        # shlex.quote is applied to session_id only for the shell=True bash -c string.
+        try:
+            subprocess.Popen(
+                ["x-terminal-emulator", "-e", "bash", "-c", f"claude -r {shlex.quote(session_id)}"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except FileNotFoundError:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Filter function for Gtk.ListBox
+# ---------------------------------------------------------------------------
+
+def _filter_func(row: Gtk.ListBoxRow) -> bool:
+    """Return True if row matches current search query."""
+    if _state["search_mode"]:
+        return True  # grep already filtered — show all rows
+    if _state["search_entry"] is None:
+        return True
+    query = _state["search_entry"].get_text().strip().lower()
+    if not query:
+        return True
+    session = getattr(row, "_session_data", None)
+    if session is None:
+        return True
+    return (
+        query in session.get("short_name", "").lower()
+        or query in session["project"].lower()
+        or query in session["preview"].lower()
+        or query in session["session_id"].lower()
+    )
+
+
+# ---------------------------------------------------------------------------
+# Populate / refresh the list
+# ---------------------------------------------------------------------------
+
+def _populate_list_box(sessions: list[dict]) -> None:
+    """Clear and re-populate the ListBox with new session rows."""
+    # Cancel any running batch insertion from search mode
+    if _state["batch_id"] is not None:
+        GLib.source_remove(_state["batch_id"])
+        _state["batch_id"] = None
+
+    _state["all_sessions"] = sessions
+
+    if _state["list_box"] is None:
+        return
+
+    # Remove all existing children
+    for child in _state["list_box"].get_children():
+        _state["list_box"].remove(child)
+
+    # Add all rows
+    now = time.time()
+    for session in sessions:
+        row = _build_session_row(session, now)
+        _state["list_box"].add(row)
+
+    _state["list_box"].show_all()
+
+    # Update stats bar
+    if _state["stats_label"] is not None:
+        _state["stats_label"].set_text(_compute_stats(sessions, now))
+
+
+# ---------------------------------------------------------------------------
+# Search logic (debounced, two-mode)
+# ---------------------------------------------------------------------------
+
+def _on_search_changed(_entry: Gtk.SearchEntry) -> None:
+    """Handle search text changes with 300ms debounce."""
+    # Cancel previous debounce timer
+    if _state["debounce_id"] is not None:
+        GLib.source_remove(_state["debounce_id"])
+        _state["debounce_id"] = None
+
+    # Cancel any running batch insertion
+    if _state["batch_id"] is not None:
+        GLib.source_remove(_state["batch_id"])
+        _state["batch_id"] = None
+
+    query = _state["search_entry"].get_text().strip()
+
+    if len(query) < 3:
+        # Short query or empty: switch back to browse mode
+        if _state["search_mode"]:
+            _state["search_mode"] = False
+            _populate_list_box(_state["all_sessions"])
+        else:
+            # Just filter existing rows
+            if _state["list_box"] is not None:
+                _state["list_box"].invalidate_filter()
+        return
+
+    # Debounce: schedule grep search after 300ms
+    _state["debounce_id"] = GLib.timeout_add(300, _execute_search, query)
+
+
+def _show_search_status(message: str) -> None:
+    """Clear the ListBox and show a status message placeholder. GTK-thread only."""
+    if _state["list_box"] is None:
+        return
+
+    # Cancel any running batch insertion first
+    if _state["batch_id"] is not None:
+        GLib.source_remove(_state["batch_id"])
+        _state["batch_id"] = None
+
+    for child in _state["list_box"].get_children():
+        _state["list_box"].remove(child)
+
+    placeholder = Gtk.Label(label=message)
+    placeholder.get_style_context().add_class("session-meta")
+    placeholder.set_margin_top(16)
+    placeholder.set_margin_bottom(16)
+    row = Gtk.ListBoxRow()
+    row.set_activatable(False)
+    row.add(placeholder)
+    row.show_all()
+    _state["list_box"].add(row)
+    _state["list_box"].show_all()
+
+
+def _display_search_results(results: list, query: str) -> bool:
+    """Populate the ListBox with search results in batches. GTK-thread only.
+
+    Called via GLib.idle_add from the background worker thread.
+    Returns False (one-shot).
+    """
+    if _state["list_box"] is None:
+        return False
+
+    # Clear the "Suche..." placeholder (and any stale rows)
+    for child in _state["list_box"].get_children():
+        _state["list_box"].remove(child)
+
+    # Update stats bar
+    if _state["stats_label"] is not None:
+        total_matches = sum(s.get("match_count", 0) for s in results)
+        _state["stats_label"].set_text(
+            f"{len(results)} Sessions gefunden  |  {total_matches} Treffer gesamt  |  Suche: \"{query}\""
+        )
+
+    if not results:
+        _state["list_box"].show_all()
+        return False
+
+    # Cancel any previous batch insertion
+    if _state["batch_id"] is not None:
+        GLib.source_remove(_state["batch_id"])
+        _state["batch_id"] = None
+
+    # Batch-insert via idle_add
+    now = time.time()
+    it = iter(results)
+
+    def _insert_batch() -> bool:
+        BATCH = 30
+        try:
+            for _ in range(BATCH):
+                session = next(it)
+                row = _build_search_row(session, query, now)
+                _state["list_box"].add(row)
+            _state["list_box"].show_all()
+            return True  # more rows pending
+        except StopIteration:
+            _state["list_box"].show_all()
+            _state["batch_id"] = None
+            return False  # done
+
+    _state["batch_id"] = GLib.idle_add(_insert_batch)
+    return False  # one-shot
+
+
+def _execute_search(query: str) -> bool:
+    """Kick off a non-blocking grep search. Returns False (one-shot GLib timer)."""
+    global _search_cancel
+
+    _state["debounce_id"] = None
+    _state["search_mode"] = True
+
+    # Signal any previous background search to abort early
+    _search_cancel.set()
+    cancel = threading.Event()
+    _search_cancel = cancel
+
+    # Immediate visual feedback — clears the list and shows "Suche..."
+    _show_search_status("Suche…")
+
+    def _worker() -> None:
+        if cancel.is_set():
+            return
+        results = _grep_sessions(query)
+        if cancel.is_set():
+            return
+        GLib.idle_add(_display_search_results, results, query)
+
+    thread = threading.Thread(target=_worker, daemon=True)
+    thread.start()
+
+    return False  # one-shot timer
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def refresh_sessions() -> bool:
+    """Re-scan sessions and update the UI. Returns True to keep GLib timer alive."""
+    try:
+        sessions = _scan_all_sessions()
+        GLib.idle_add(_populate_list_box, sessions)
+    except Exception:
+        log.exception("refresh sessions")
+    return True  # keep timer running
+
+
+def build_sessions_tab() -> Gtk.ScrolledWindow:
+    """Build and return the Sessions tab widget (Gtk.ScrolledWindow)."""
+
+    # -----------------------------------------------------------------------
+    # Root: ScrolledWindow → main VBox
+    # -----------------------------------------------------------------------
+    scrolled = Gtk.ScrolledWindow()
+    scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    scrolled.set_hexpand(True)
+    scrolled.set_vexpand(True)
+
+    main_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+    main_vbox.set_margin_top(8)
+    main_vbox.set_margin_bottom(8)
+    main_vbox.set_margin_start(8)
+    main_vbox.set_margin_end(8)
+    scrolled.add(main_vbox)
+
+    # -----------------------------------------------------------------------
+    # Toolbar: title + search + refresh button
+    # -----------------------------------------------------------------------
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.set_margin_bottom(6)
+    main_vbox.pack_start(toolbar, False, False, 0)
+
+    title_label = Gtk.Label(label="Sessions")
+    title_label.get_style_context().add_class("section-title")
+    title_attrs = Pango.AttrList()
+    title_attrs.insert(Pango.attr_weight_new(Pango.Weight.BOLD))
+    title_attrs.insert(Pango.attr_scale_new(1.1))
+    title_label.set_attributes(title_attrs)
+    title_label.set_halign(Gtk.Align.START)
+    toolbar.pack_start(title_label, False, False, 0)
+
+    # Spacer
+    spacer = Gtk.Box()
+    spacer.set_hexpand(True)
+    toolbar.pack_start(spacer, True, True, 0)
+
+    # Search entry
+    _state["search_entry"] = Gtk.SearchEntry()
+    _state["search_entry"].set_placeholder_text("Projekt oder Inhalt suchen…")
+    _state["search_entry"].set_size_request(220, -1)
+    toolbar.pack_start(_state["search_entry"], False, False, 0)
+
+    # Refresh button
+    refresh_btn = Gtk.Button()
+    refresh_icon = Gtk.Image.new_from_icon_name("view-refresh-symbolic", Gtk.IconSize.BUTTON)
+    refresh_btn.add(refresh_icon)
+    refresh_btn.set_tooltip_text("Sessions neu einlesen")
+    refresh_btn.connect("clicked", lambda _b: refresh_sessions())
+    toolbar.pack_start(refresh_btn, False, False, 0)
+
+    # -----------------------------------------------------------------------
+    # Stats pill (rounded bar instead of frame)
+    # -----------------------------------------------------------------------
+    _state["stats_label"] = Gtk.Label(label="Lade Sessions…")
+    _state["stats_label"].get_style_context().add_class("session-stats")
+    _state["stats_label"].set_margin_top(2)
+    _state["stats_label"].set_margin_bottom(8)
+    _state["stats_label"].set_halign(Gtk.Align.START)
+    main_vbox.pack_start(_state["stats_label"], False, False, 0)
+
+    # -----------------------------------------------------------------------
+    # ListBox for sessions
+    # -----------------------------------------------------------------------
+    _state["list_box"] = Gtk.ListBox()
+    _state["list_box"].set_selection_mode(Gtk.SelectionMode.NONE)
+    _state["list_box"].set_filter_func(_filter_func)
+    _state["list_box"].get_style_context().add_class("view")
+    main_vbox.pack_start(_state["list_box"], True, True, 0)
+
+    # Connect search to filter
+    _state["search_entry"].connect("search-changed", _on_search_changed)
+
+    # -----------------------------------------------------------------------
+    # Initial load (non-blocking via idle_add)
+    # -----------------------------------------------------------------------
+    idle_once(lambda: _populate_list_box(_scan_all_sessions()))
+
+    scrolled.show_all()
+    return scrolled

shortcut_counter_tab.py

@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+"""Shortcut Counter Tab — GTK3 widget for ClaudeCodePanel.
+
+Reads directly from ~/.local/share/shortcut-counter/shortcuts.db (read-only).
+Refreshes every 30s via GLib timer registered in panel.py.
+
+Provides:
+    build_shortcut_counter_tab() -> Gtk.ScrolledWindow
+    refresh_shortcut_counter(tab) -> bool
+"""
+
+import sqlite3
+import tomllib
+from datetime import datetime
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk, Pango
+
+from theme import get_palette, hex_to_pango_rgb
+
+# ---------------------------------------------------------------------------
+# DB path (XDG)
+# ---------------------------------------------------------------------------
+_DB_PATH = Path.home() / ".local" / "share" / "shortcut-counter" / "shortcuts.db"
+
+# Config path for "unused" recommendations
+_CONFIG_PATH = Path.home() / "Projekte" / "ShortcutCounter" / "config.toml"
+
+# Thresholds
+_MASTERED = 50
+_LEARNING_MIN = 1
+
+# ---------------------------------------------------------------------------
+# Module-level widget refs (stable outer structure)
+# ---------------------------------------------------------------------------
+_header_label: Gtk.Label | None = None
+_progress_bar: Gtk.ProgressBar | None = None
+_cards_container: Gtk.Box | None = None   # replaces TreeView
+_learn_box: Gtk.Box | None = None
+
+
+# ---------------------------------------------------------------------------
+# Data loading
+# ---------------------------------------------------------------------------
+
+def _load_rows() -> list[dict]:
+    """Read all rows from shortcuts.db. Returns [] if DB missing."""
+    if not _DB_PATH.exists():
+        return []
+    try:
+        # Read raw values instead of sqlite3's TIMESTAMP converter. The
+        # shortcut counter stores ISO timestamps with a "T" separator, which
+        # sqlite3's default converter rejects.
+        conn = sqlite3.connect(f"file:{_DB_PATH}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            "SELECT combo, count, last_used, category FROM shortcuts ORDER BY count DESC"
+        ).fetchall()
+        conn.close()
+        return [dict(r) for r in rows]
+    except (sqlite3.OperationalError, sqlite3.DatabaseError):
+        return []
+
+
+def _load_config() -> dict[str, list[dict]]:
+    """Load shortcut config with descriptions. Returns {} on any error."""
+    if not _CONFIG_PATH.exists():
+        return {}
+    try:
+        with open(_CONFIG_PATH, "rb") as f:
+            cfg = tomllib.load(f)
+        result = {}
+        for cat_name, cat_data in cfg.get("shortcuts", {}).items():
+            items = cat_data.get("items", [])
+            result[cat_name] = [{"combo": it["combo"], "desc": it.get("desc", "")} for it in items]
+        return result
+    except Exception:
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# Status helpers
+# ---------------------------------------------------------------------------
+
+def _status_label(count: int) -> str:
+    if count >= _MASTERED:
+        return "Mastered"
+    elif count >= _LEARNING_MIN:
+        return "Learning"
+    else:
+        return "Not Used"
+
+
+def _status_css_class(count: int) -> str:
+    if count >= _MASTERED:
+        return "sc-badge-mastered"
+    elif count >= _LEARNING_MIN:
+        return "sc-badge-learning"
+    else:
+        return "sc-badge-unused"
+
+
+def _fmt_last_used(last_used) -> str:
+    if last_used is None:
+        return "—"
+    if isinstance(last_used, datetime):
+        return last_used.strftime("%d.%m %H:%M")
+    try:
+        dt = datetime.fromisoformat(str(last_used))
+        return dt.strftime("%d.%m %H:%M")
+    except (ValueError, TypeError):
+        return str(last_used)[:10]
+
+
+def _find_category(combo: str, config: dict[str, list[dict]]) -> str:
+    """Try to find category for a combo via config dict."""
+    for cat_name, items in config.items():
+        if any(it["combo"].lower() == combo.lower() for it in items):
+            return cat_name
+    return "Sonstige"
+
+
+# ---------------------------------------------------------------------------
+# Card builders
+# ---------------------------------------------------------------------------
+
+def _build_shortcut_row(r: dict, p: dict) -> Gtk.Box:
+    """Build one horizontal shortcut row inside a category card."""
+    row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    row.set_margin_top(2)
+    row.set_margin_bottom(2)
+
+    # Combo label (monospace bold)
+    combo_lbl = Gtk.Label(label=r["combo"])
+    combo_lbl.set_halign(Gtk.Align.START)
+    combo_lbl.set_markup(
+        f'<tt><b>{GLib.markup_escape_text(r["combo"])}</b></tt>'
+    )
+    combo_lbl.set_width_chars(18)
+    combo_lbl.set_xalign(0.0)
+    row.pack_start(combo_lbl, False, False, 0)
+
+    # Description label (dim, between combo and count)
+    desc = r.get("desc", "")
+    desc_lbl = Gtk.Label()
+    desc_lbl.set_markup(
+        f'<span foreground="{p["dim"]}" size="small">{GLib.markup_escape_text(desc)}</span>'
+    )
+    desc_lbl.set_width_chars(26)
+    desc_lbl.set_xalign(0.0)
+    desc_lbl.set_halign(Gtk.Align.START)
+    row.pack_start(desc_lbl, False, False, 0)
+
+    # Count badge (dim text)
+    count_lbl = Gtk.Label(label=str(r["count"]))
+    count_lbl.set_markup(
+        f'<span foreground="{p["overlay"]}" size="small">{r["count"]}×</span>'
+    )
+    row.pack_start(count_lbl, False, False, 0)
+
+    # Status badge
+    status_lbl = Gtk.Label(label=_status_label(r["count"]))
+    status_lbl.get_style_context().add_class(_status_css_class(r["count"]))
+    row.pack_start(status_lbl, False, False, 0)
+
+    # Last-used (right-aligned, dim)
+    last_lbl = Gtk.Label()
+    last_lbl.set_markup(
+        f'<span foreground="{p["dim"]}" size="small">{_fmt_last_used(r.get("last_used"))}</span>'
+    )
+    last_lbl.set_halign(Gtk.Align.END)
+    row.pack_end(last_lbl, False, False, 0)
+
+    return row
+
+
+def _build_category_card(cat_name: str, cat_rows: list[dict], p: dict) -> Gtk.Box:
+    """Build a full category card widget."""
+    card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    card.get_style_context().add_class("sc-card")
+
+    # Category header: bold name + progress "X/Y"
+    mastered = sum(1 for r in cat_rows if r["count"] >= _MASTERED)
+    used = sum(1 for r in cat_rows if r["count"] >= _LEARNING_MIN)
+    total = len(cat_rows)
+
+    header = Gtk.Label()
+    header.set_markup(
+        f'<b>{GLib.markup_escape_text(cat_name)}</b>  '
+        f'<span foreground="{p["overlay"]}" size="small">'
+        f'{mastered} mastered · {used}/{total} used</span>'
+    )
+    header.set_halign(Gtk.Align.START)
+    header.set_margin_bottom(4)
+    card.pack_start(header, False, False, 0)
+
+    # Shortcut rows sorted by count desc
+    for r in sorted(cat_rows, key=lambda x: -x["count"]):
+        card.pack_start(_build_shortcut_row(r, p), False, False, 0)
+
+    return card
+
+
+def _build_learn_card(combo: str, desc: str, cat_name: str, p: dict) -> Gtk.Box:
+    """Build a single Learn Next card."""
+    card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+    card.get_style_context().add_class("sc-learn-card")
+
+    combo_lbl = Gtk.Label()
+    combo_lbl.set_markup(
+        f'<tt><b><span foreground="{p["text"]}">'
+        f'{GLib.markup_escape_text(combo)}</span></b></tt>'
+    )
+    combo_lbl.set_halign(Gtk.Align.START)
+    combo_lbl.get_style_context().add_class("section-title")
+    card.pack_start(combo_lbl, False, False, 0)
+
+    if desc:
+        desc_lbl = Gtk.Label()
+        desc_lbl.set_markup(
+            f'<span foreground="{p["text"]}" size="small">'
+            f'{GLib.markup_escape_text(desc)}</span>'
+        )
+        desc_lbl.set_halign(Gtk.Align.START)
+        card.pack_start(desc_lbl, False, False, 0)
+
+    cat_lbl = Gtk.Label()
+    cat_lbl.set_markup(
+        f'<span foreground="{p["dim"]}" size="small">'
+        f'{GLib.markup_escape_text(cat_name)}</span>'
+    )
+    cat_lbl.set_halign(Gtk.Align.START)
+    card.pack_start(cat_lbl, False, False, 0)
+
+    return card
+
+
+# ---------------------------------------------------------------------------
+# UI update (always called on GTK main thread via idle_add)
+# ---------------------------------------------------------------------------
+
+def _do_refresh() -> bool:
+    """Actual UI update — must run on GTK thread. Returns False (one-shot)."""
+    rows = _load_rows()
+    config = _load_config()
+    p = get_palette()
+
+    # Flat list of all configured items for counting and lookup
+    all_config_items = [it for items in config.values() for it in items]
+    total_config = len(all_config_items)
+    used_count = sum(1 for r in rows if r["count"] >= _LEARNING_MIN)
+    mastered_count = sum(1 for r in rows if r["count"] >= _MASTERED)
+
+    # --- Header ---
+    if _header_label is not None:
+        if total_config > 0:
+            _header_label.set_markup(
+                f'<b>Shortcut Counter</b>  '
+                f'<span foreground="{p["green"]}">{mastered_count} Mastered</span>  '
+                f'<span foreground="{p["yellow"]}">{used_count} Learning</span>  '
+                f'<span foreground="{p["overlay"]}">/ {total_config} konfiguriert</span>'
+            )
+        else:
+            _header_label.set_markup(
+                f'<b>Shortcut Counter</b>  '
+                f'<span foreground="{p["overlay"]}">{len(rows)} gespeichert</span>'
+            )
+
+    # --- Progress bar ---
+    if _progress_bar is not None:
+        if total_config > 0:
+            frac = min(used_count / total_config, 1.0)
+            _progress_bar.set_fraction(frac)
+            _progress_bar.set_text(
+                f"{used_count} / {total_config} mindestens 1x benutzt ({frac*100:.0f}%)"
+            )
+        else:
+            _progress_bar.set_fraction(0.0)
+            _progress_bar.set_text("Keine Config-Datei gefunden")
+
+    # --- Category cards ---
+    if _cards_container is not None:
+        for child in _cards_container.get_children():
+            _cards_container.remove(child)
+
+        # Build desc lookup: combo -> desc from config (case-insensitive)
+        desc_lookup: dict[str, str] = {
+            it["combo"].lower(): it["desc"] for it in all_config_items
+        }
+
+        # Group DB rows by category, enriching with desc from config
+        categories: dict[str, list[dict]] = {}
+        for r in rows:
+            cat = r.get("category") or "Sonstige"
+            enriched = dict(r)
+            enriched["desc"] = desc_lookup.get(r["combo"].lower(), "")
+            categories.setdefault(cat, []).append(enriched)
+
+        # Add config items never used (not in DB)
+        db_combos = {r["combo"].lower() for r in rows}
+        for cat_name, items in config.items():
+            for it in items:
+                if it["combo"].lower() not in db_combos:
+                    categories.setdefault(cat_name, []).append({
+                        "combo": it["combo"],
+                        "desc": it["desc"],
+                        "count": 0,
+                        "last_used": None,
+                        "category": cat_name,
+                    })
+
+        mastered_items: list[dict] = []  # collect individually mastered shortcuts
+        for cat_name, cat_rows in sorted(categories.items()):
+            learning = [r for r in cat_rows if r["count"] < _MASTERED]
+            mastered = [r for r in cat_rows if r["count"] >= _MASTERED]
+            # Tag mastered items with their category for the expander
+            for m in mastered:
+                m["_cat"] = cat_name
+                mastered_items.append(m)
+            # Only build a card if there are non-mastered items
+            if learning:
+                card = _build_category_card(cat_name, learning, p)
+                _cards_container.pack_start(card, False, False, 0)
+
+        if mastered_items:
+            expander = Gtk.Expander()
+            expander.set_label(f"Mastered ({len(mastered_items)} Shortcuts)")
+            expander.set_expanded(False)
+            exp_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+            # Group mastered items by category inside the expander
+            from itertools import groupby
+            for cat, items in groupby(
+                sorted(mastered_items, key=lambda r: r.get("_cat", "")),
+                key=lambda r: r.get("_cat", ""),
+            ):
+                cat_card = _build_category_card(cat, list(items), p)
+                exp_box.pack_start(cat_card, False, False, 0)
+            expander.add(exp_box)
+            _cards_container.pack_start(expander, False, False, 0)
+
+        _cards_container.show_all()
+
+    # --- Learn Next section ---
+    if _learn_box is not None:
+        for child in _learn_box.get_children():
+            _learn_box.remove(child)
+
+        lbl = Gtk.Label()
+        lbl.set_markup(
+            f'<b>Learn Next</b>  '
+            f'<span foreground="{p["overlay"]}">Top 3 ungenutzte Shortcuts</span>'
+        )
+        lbl.set_halign(Gtk.Align.START)
+        lbl.set_margin_bottom(4)
+        _learn_box.pack_start(lbl, False, False, 0)
+
+        db_combos = {r["combo"].lower() for r in rows}
+        unused = [
+            it for it in all_config_items
+            if it["combo"].lower() not in db_combos
+            or next((r["count"] for r in rows if r["combo"].lower() == it["combo"].lower()), 0) == 0
+        ]
+
+        if unused:
+            for it in unused[:3]:
+                cat = _find_category(it["combo"], config)
+                card = _build_learn_card(it["combo"], it["desc"], cat, p)
+                _learn_box.pack_start(card, False, False, 0)
+        else:
+            done = Gtk.Label()
+            done.set_markup(
+                f'<span foreground="{p["green"]}">'
+                f'Alle konfigurierten Shortcuts mindestens 1x benutzt!</span>'
+            )
+            done.set_halign(Gtk.Align.START)
+            _learn_box.pack_start(done, False, False, 0)
+
+        _learn_box.show_all()
+
+    return False  # one-shot
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def refresh_shortcut_counter(_tab=None) -> bool:
+    """Called by GLib timer from panel.py. Schedules UI update via idle_add."""
+    GLib.idle_add(_do_refresh)
+    return True  # keep timer alive
+
+
+def build_shortcut_counter_tab() -> Gtk.ScrolledWindow:
+    """Build and return the Shortcut Counter tab widget."""
+    global _header_label, _progress_bar, _cards_container, _learn_box
+
+    scrolled = Gtk.ScrolledWindow()
+    scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+    scrolled.set_hexpand(True)
+    scrolled.set_vexpand(True)
+
+    vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+    vbox.set_margin_top(10)
+    vbox.set_margin_bottom(10)
+    vbox.set_margin_start(10)
+    vbox.set_margin_end(10)
+    scrolled.add(vbox)
+
+    p = get_palette()
+
+    # --- Header ---
+    _header_label = Gtk.Label()
+    _header_label.set_markup(
+        f'<b>Shortcut Counter</b>  <span foreground="{p["overlay"]}">Lade...</span>'
+    )
+    _header_label.set_halign(Gtk.Align.START)
+    _header_label.set_margin_bottom(6)
+    header_attrs = Pango.AttrList()
+    header_attrs.insert(Pango.attr_scale_new(1.1))
+    _header_label.set_attributes(header_attrs)
+    vbox.pack_start(_header_label, False, False, 0)
+
+    # --- Progress bar ---
+    _progress_bar = Gtk.ProgressBar()
+    _progress_bar.set_show_text(True)
+    _progress_bar.set_fraction(0.0)
+    _progress_bar.set_text("Lade...")
+    _progress_bar.set_margin_bottom(10)
+    vbox.pack_start(_progress_bar, False, False, 0)
+
+    # --- Category cards container ---
+    _cards_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    _cards_container.set_margin_bottom(8)
+    vbox.pack_start(_cards_container, False, False, 0)
+
+    # --- Learn Next section ---
+    sep = Gtk.Separator()
+    sep.set_margin_top(4)
+    sep.set_margin_bottom(8)
+    vbox.pack_start(sep, False, False, 0)
+
+    _learn_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    vbox.pack_start(_learn_box, False, False, 0)
+
+    # Initial load
+    GLib.idle_add(_do_refresh)
+
+    scrolled.show_all()
+    return scrolled

swarm_tab.py

@@ -0,0 +1,974 @@
+#!/usr/bin/env python3
+"""Swarm Tab — Native GTK3 view for Agent Teams.
+
+Reads directly from ~/.claude/teams/ and ~/.claude/tasks/ —
+no WebKit, no Flask server needed.
+
+Provides build_swarm_tab() and refresh_swarm() with the same API
+as the old WebKit-based version.
+"""
+
+import json
+import threading
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+gi.require_version("WebKit2", "4.1")
+from gi.repository import Gtk, GLib, Gio, Pango, WebKit2
+
+from theme import get_palette
+from monitor import (
+    get_anthropic_session_cost,
+    get_provider_costs,
+    get_active_sessions,
+    get_sidecar_status,
+)
+from swarm_visual import generate_comm_graph
+
+SWARM_HTML = Path.home() / ".agent" / "diagrams" / "agent-swarm-live.html"
+
+TEAMS_DIR = Path.home() / ".claude" / "teams"
+TASKS_DIR = Path.home() / ".claude" / "tasks"
+EVENTS_DIR = Path.home() / ".claude" / "events"
+
+# Events file offset tracking (like event_tab.py)
+_events_file_offset: int = 0
+_events_current_day: str = ""
+
+# Gio.FileMonitor ref (prevent GC)
+_event_file_monitor: Gio.FileMonitor | None = None
+
+# Module-level refs for refresh
+_webview_ready: bool = False
+_team_flow: Gtk.FlowBox | None = None
+_task_list: Gtk.ListBox | None = None
+_msg_list: Gtk.ListBox | None = None
+_team_selector: Gtk.ComboBoxText | None = None
+_status_label: Gtk.Label | None = None
+_selected_team: str | None = None
+_refreshing: bool = False
+_stack: Gtk.Stack | None = None
+_webview: WebKit2.WebView | None = None
+
+
+# ---------------------------------------------------------------------------
+# Data layer
+# ---------------------------------------------------------------------------
+
+def _load_teams() -> list[dict]:
+    """Load all team configs from ~/.claude/teams/*/config.json."""
+    teams = []
+    if not TEAMS_DIR.exists():
+        return teams
+    for team_dir in sorted(TEAMS_DIR.iterdir()):
+        if not team_dir.is_dir():
+            continue
+        config = team_dir / "config.json"
+        if not config.exists():
+            continue
+        try:
+            data = json.loads(config.read_text(encoding="utf-8"))
+            name = data.get("name", team_dir.name)
+            members = data.get("members", [])
+            # Count tasks
+            task_dir = TASKS_DIR / team_dir.name
+            task_count = 0
+            active_tasks = 0
+            if task_dir.exists():
+                for tf in task_dir.glob("*.json"):
+                    try:
+                        td = json.loads(tf.read_text(encoding="utf-8"))
+                        if td.get("metadata", {}).get("_internal"):
+                            continue
+                        task_count += 1
+                        if td.get("status") == "in_progress":
+                            mtime = tf.stat().st_mtime
+                            if (time.time() - mtime) < 7200:  # 2h
+                                active_tasks += 1
+                    except (json.JSONDecodeError, OSError):
+                        pass
+            teams.append({
+                "name": name,
+                "dir_name": team_dir.name,
+                "members": len(members),
+                "member_names": [m.get("name", "?") for m in members],
+                "tasks": task_count,
+                "active_tasks": active_tasks,
+                "active": active_tasks > 0,
+                "created": data.get("createdAt", 0),
+            })
+        except (json.JSONDecodeError, OSError):
+            continue
+    return teams
+
+
+def _load_tasks(team_name: str) -> list[dict]:
+    """Load tasks for a specific team."""
+    tasks = []
+    task_dir = TASKS_DIR / team_name
+    if not task_dir.exists():
+        return tasks
+    for tf in sorted(task_dir.glob("*.json"), key=lambda f: f.stem.zfill(10)):
+        try:
+            data = json.loads(tf.read_text(encoding="utf-8"))
+            # Skip internal task-assignment tasks
+            if data.get("metadata", {}).get("_internal"):
+                continue
+            tasks.append({
+                "id": data.get("id", tf.stem),
+                "subject": data.get("subject", "(kein Titel)"),
+                "description": data.get("description", "")[:120],
+                "status": data.get("status", "pending"),
+                "owner": data.get("owner", "(unassigned)"),
+            })
+        except (json.JSONDecodeError, OSError):
+            continue
+    # Sort: in_progress first, then pending, then completed
+    order = {"in_progress": 0, "pending": 1, "completed": 2}
+    tasks.sort(key=lambda t: order.get(t["status"], 9))
+    return tasks
+
+
+def _collect_comm_data(team_name: str) -> dict:
+    """Collect per-member status and new messages for live updates."""
+    team_dir = TEAMS_DIR / team_name
+    config_path = team_dir / "config.json"
+    if not config_path.exists():
+        return {"members": [], "tasks": []}
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+    members = []
+    for m in config.get("members", []):
+        name = m.get("name", "?")
+        inbox = team_dir / "inboxes" / f"{name}.json"
+        msg_count = 0
+        last_msg_time = ""
+        if inbox.exists():
+            try:
+                msgs = json.loads(inbox.read_text(encoding="utf-8"))
+                if isinstance(msgs, list):
+                    # Filter internal messages
+                    real = [x for x in msgs if not any(
+                        k in x.get("text", "") for k in
+                        ['"type":"task_assignment"', '"type":"shutdown_request"',
+                         '"type":"idle_notification"'])]
+                    msg_count = len(real)
+                    if real:
+                        last_msg_time = real[-1].get("timestamp", "")
+            except (json.JSONDecodeError, OSError):
+                pass
+        is_recent = False
+        if last_msg_time:
+            try:
+                ts = datetime.fromisoformat(last_msg_time.replace("Z", "+00:00"))
+                is_recent = (datetime.now(ts.tzinfo) - ts).total_seconds() < 120
+            except (ValueError, AttributeError):
+                pass
+        members.append({
+            "name": name,
+            "status": "working" if is_recent else "idle",
+            "msg_count": msg_count,
+            "last_msg": last_msg_time,
+        })
+
+    tasks = []
+    for t in _load_tasks(team_name):
+        tasks.append({
+            "id": t["id"],
+            "subject": t["subject"],
+            "status": t["status"],
+            "owner": t.get("owner", ""),
+        })
+
+    # Collect new messages for the log
+    all_msgs = []
+    inbox_dir = team_dir / "inboxes"
+    if inbox_dir.exists():
+        for mf in inbox_dir.glob("*.json"):
+            try:
+                data = json.loads(mf.read_text(encoding="utf-8"))
+                if not isinstance(data, list):
+                    continue
+                recipient = mf.stem
+                for msg in data:
+                    text = msg.get("text", "")
+                    if any(k in text for k in ['"type":"task_assignment"',
+                                                '"type":"shutdown_request"',
+                                                '"type":"idle_notification"']):
+                        continue
+                    ts_str = msg.get("timestamp", "")
+                    try:
+                        ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                        time_fmt = ts.strftime("%H:%M")
+                    except (ValueError, AttributeError):
+                        time_fmt = "??:??"
+                    all_msgs.append({
+                        "time": time_fmt,
+                        "sender": msg.get("from", "?"),
+                        "recipient": recipient,
+                        "text": text[:90].replace("\n", " "),
+                        "timestamp": ts_str,
+                    })
+            except (json.JSONDecodeError, OSError):
+                continue
+    all_msgs.sort(key=lambda m: m.get("timestamp", ""), reverse=True)
+
+    return {"members": members, "tasks": tasks, "new_messages": all_msgs[:5],
+            "events": []}
+
+
+def _load_messages(team_name: str, limit: int = 10) -> list[dict]:
+    """Load recent messages from team inboxes."""
+    messages = []
+    inbox_dir = TEAMS_DIR / team_name / "inboxes"
+    if not inbox_dir.exists():
+        return messages
+    for mf in inbox_dir.glob("*.json"):
+        try:
+            data = json.loads(mf.read_text(encoding="utf-8"))
+            if not isinstance(data, list):
+                continue
+            recipient = mf.stem
+            for msg in data:
+                # Skip internal task assignments and shutdown requests
+                text = msg.get("text", "")
+                if '"type":"task_assignment"' in text or '"type":"shutdown_request"' in text:
+                    continue
+                ts_str = msg.get("timestamp", "")
+                try:
+                    ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                    time_fmt = ts.strftime("%H:%M")
+                    sort_key = ts.timestamp()
+                except (ValueError, AttributeError):
+                    time_fmt = "??:??"
+                    sort_key = 0
+                sender = msg.get("from", "?")
+                # Truncate text for preview
+                preview = text[:100].replace("\n", " ")
+                if len(text) > 100:
+                    preview += "..."
+                messages.append({
+                    "time": time_fmt,
+                    "sort_key": sort_key,
+                    "sender": sender,
+                    "recipient": recipient,
+                    "preview": preview,
+                })
+        except (json.JSONDecodeError, OSError):
+            continue
+    messages.sort(key=lambda m: m["sort_key"], reverse=True)
+    return messages[:limit]
+
+
+# ---------------------------------------------------------------------------
+# Event feed — reads hook events from ~/.claude/events/YYYY-MM-DD.jsonl
+# ---------------------------------------------------------------------------
+
+_INTERESTING_EVENTS = {
+    "PostToolUse", "PreToolUse", "UserPromptSubmit",
+    "SubagentStart", "SubagentStop", "SubagentComplete",
+}
+
+
+def _read_recent_events(limit: int = 20) -> list[dict]:
+    """Read recent interesting events from today's event log.
+
+    Uses file offset tracking to only read new data (like event_tab.py).
+    """
+    global _events_file_offset, _events_current_day
+
+    today = datetime.now().strftime("%Y-%m-%d")
+    event_file = EVENTS_DIR / f"{today}.jsonl"
+
+    if not event_file.exists():
+        return []
+
+    # Day rollover — seek near end instead of reading from byte 0
+    if today != _events_current_day:
+        file_size = event_file.stat().st_size
+        _events_file_offset = max(0, file_size - 50_000)
+        _events_current_day = today
+
+    new_lines = []
+    try:
+        with open(event_file, "r", encoding="utf-8") as f:
+            f.seek(_events_file_offset)
+            new_lines = f.readlines()
+            _events_file_offset = f.tell()
+    except OSError:
+        pass
+
+    # Cap at last 100 lines to avoid processing stale history on day rollover
+    if len(new_lines) > 100:
+        new_lines = new_lines[-100:]
+
+    events = []
+    for line in new_lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            ev = json.loads(line)
+            et = ev.get("event_type") or ev.get("hook_event_name", "")
+            if et in _INTERESTING_EVENTS:
+                events.append({
+                    "type": et,
+                    "tool": ev.get("tool_name", ""),
+                    "time": ev.get("logged_iso", ""),
+                    "session": ev.get("session_id", "")[:8],
+                    "agent": ev.get("tool_input", {}).get("agentName", ""),
+                })
+        except json.JSONDecodeError:
+            pass
+
+    # Return only the last `limit` events
+    return events[-limit:]
+
+
+def _update_events_ui(events: list[dict]) -> bool:
+    """Push events to the WebKit view on the GTK main thread. idle_add callback."""
+    if not (_stack and _stack.get_visible_child_name() == "visual"
+            and _webview and _webview_ready):
+        return False
+    js = f"if(typeof updateEvents==='function')updateEvents({json.dumps(events, ensure_ascii=True)})"
+    _webview.run_javascript(js, None, None, None)
+    return False  # one-shot: do not repeat
+
+
+def _read_events_async() -> None:
+    """Read events in background thread, update UI via idle_add."""
+    def _worker():
+        events = _read_recent_events(20)
+        if events:
+            GLib.idle_add(_update_events_ui, events)
+
+    thread = threading.Thread(target=_worker, daemon=True)
+    thread.start()
+
+
+# ---------------------------------------------------------------------------
+# Live data collection for WebKit visual view
+# ---------------------------------------------------------------------------
+
+def _collect_live_data() -> dict:
+    """Collect live data from monitor.py + local team/task files.
+
+    Returns a dict matching the JSON structure that updateSwarm() expects.
+    """
+    cost_data = get_anthropic_session_cost()
+    provider_costs = get_provider_costs()
+    active_sessions = get_active_sessions()
+    sidecar = get_sidecar_status()
+    teams = _load_teams()
+
+    # Cost bars (percentage relative to reasonable daily max)
+    OPUS_MAX = 5.0
+    SONNET_MAX = 10.0
+    HAIKU_MAX = 2.0
+    GEMINI_MAX = 1.0
+
+    models = cost_data.get("models", {})
+    opus_cost = models.get("opus", {}).get("cost_usd", 0.0)
+    sonnet_cost = models.get("sonnet", {}).get("cost_usd", 0.0)
+    haiku_cost = models.get("haiku", {}).get("cost_usd", 0.0)
+    gemini_cost = provider_costs.get("gemini", 0.0)
+
+    # Node statuses
+    active_task_count = sum(t["active_tasks"] for t in teams)
+    sidecar_firing = any(
+        d.get("active") for d in sidecar.get("detectors", {}).values()
+    )
+
+    # Build tasks list from all teams
+    all_tasks = []
+    for team in teams:
+        for task in _load_tasks(team["dir_name"]):
+            task["team"] = team["dir_name"]
+            all_tasks.append(task)
+
+    return {
+        "agents": {
+            "opus": {
+                "status": "working" if any(
+                    s.get("model", "").startswith("claude-opus") for s in active_sessions
+                ) else "idle",
+                "cost_usd": opus_cost,
+                "cost_pct": min(100, round(opus_cost / OPUS_MAX * 100, 1)),
+            },
+            "sonnet": {
+                "status": "working" if any(
+                    s.get("model", "").startswith("claude-sonnet") for s in active_sessions
+                ) else "idle",
+                "cost_usd": sonnet_cost,
+                "cost_pct": min(100, round(sonnet_cost / SONNET_MAX * 100, 1)),
+            },
+            "haiku": {
+                "status": "working" if any(
+                    s.get("model", "").startswith("claude-haiku") for s in active_sessions
+                ) else "idle",
+                "cost_usd": haiku_cost,
+                "cost_pct": min(100, round(haiku_cost / HAIKU_MAX * 100, 1)),
+            },
+        },
+        "gemini": {
+            "status": "working" if gemini_cost > 0 else "idle",
+            "cost_usd": gemini_cost,
+            "cost_pct": min(100, round(gemini_cost / GEMINI_MAX * 100, 1)),
+        },
+        "sidecar": {
+            "status": "working" if sidecar_firing else "idle",
+            "overall_severity": sidecar.get("overall_severity", "none"),
+            "active_detectors": [
+                name for name, d in sidecar.get("detectors", {}).items()
+                if d.get("active")
+            ],
+            "hook_events": sidecar.get("hook_events", 0),
+        },
+        "teams": [
+            {
+                "name": t["name"],
+                "dir_name": t["dir_name"],
+                "members": t["member_names"],
+                "status": "working" if t["active_tasks"] > 0 else "idle",
+                "tasks_total": t["tasks"],
+                "tasks_active": t["active_tasks"],
+            }
+            for t in teams
+        ],
+        "tasks": [
+            {
+                "id": task["id"],
+                "subject": task["subject"],
+                "status": task["status"],
+                "owner": task.get("owner", ""),
+                "team": task.get("team", ""),
+            }
+            for task in all_tasks
+        ],
+        "total_cost_usd": cost_data.get("cost_usd", 0.0),
+        "active_agent_count": len(active_sessions),
+        "events": [],
+    }
+
+
+# ---------------------------------------------------------------------------
+# UI builders
+# ---------------------------------------------------------------------------
+
+def _build_team_card(team: dict) -> Gtk.Box:
+    """Build a single team card widget."""
+    card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+    card.get_style_context().add_class("sc-card")
+    card.set_size_request(180, -1)
+
+    # Team name
+    name_label = Gtk.Label(label=team["name"])
+    name_label.set_halign(Gtk.Align.START)
+    name_label.get_style_context().add_class("session-project")
+    card.pack_start(name_label, False, False, 0)
+
+    # Stats line
+    stats = f"{team['members']} Agents  |  {team['tasks']} Tasks"
+    stats_label = Gtk.Label(label=stats)
+    stats_label.set_halign(Gtk.Align.START)
+    stats_label.get_style_context().add_class("session-meta")
+    card.pack_start(stats_label, False, False, 0)
+
+    # Active indicator
+    if team["active"]:
+        dot = Gtk.Label(label=f"\u25cf Aktiv ({team['active_tasks']} laufen)")
+        dot.get_style_context().add_class("swarm-status-connected")
+    else:
+        dot = Gtk.Label(label="\u25cb Idle")
+        dot.get_style_context().add_class("swarm-status-disconnected")
+    dot.set_halign(Gtk.Align.START)
+    card.pack_start(dot, False, False, 0)
+
+    return card
+
+
+def _build_task_row(task: dict) -> Gtk.ListBoxRow:
+    """Build a single task row."""
+    row = Gtk.ListBoxRow()
+    row.get_style_context().add_class("swarm-task-row")
+
+    hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    hbox.set_margin_top(4)
+    hbox.set_margin_bottom(4)
+    hbox.set_margin_start(8)
+    hbox.set_margin_end(8)
+    row.add(hbox)
+
+    # Status icon
+    status = task["status"]
+    if status == "in_progress":
+        icon_text = "\u25cf"
+        badge_class = "swarm-badge-progress"
+    elif status == "completed":
+        icon_text = "\u2713"
+        badge_class = "swarm-badge-completed"
+    else:
+        icon_text = "\u25cb"
+        badge_class = "swarm-badge-pending"
+
+    icon = Gtk.Label(label=icon_text)
+    icon.get_style_context().add_class(badge_class)
+    icon.set_size_request(20, -1)
+    hbox.pack_start(icon, False, False, 0)
+
+    # Task subject
+    subject = Gtk.Label(label=task["subject"])
+    subject.set_halign(Gtk.Align.START)
+    subject.set_ellipsize(Pango.EllipsizeMode.END)
+    subject.set_max_width_chars(50)
+    subject.set_hexpand(True)
+    subject.get_style_context().add_class("session-preview")
+    hbox.pack_start(subject, True, True, 0)
+
+    # Status badge text
+    status_text = status.upper().replace("_", " ")
+    badge = Gtk.Label(label=status_text)
+    badge.get_style_context().add_class(badge_class)
+    badge.set_halign(Gtk.Align.END)
+    hbox.pack_start(badge, False, False, 0)
+
+    row.show_all()
+    return row
+
+
+def _build_message_row(msg: dict) -> Gtk.ListBoxRow:
+    """Build a single message row."""
+    row = Gtk.ListBoxRow()
+    row.get_style_context().add_class("swarm-message")
+
+    hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    hbox.set_margin_top(2)
+    hbox.set_margin_bottom(2)
+    hbox.set_margin_start(8)
+    hbox.set_margin_end(8)
+    row.add(hbox)
+
+    # Timestamp
+    time_label = Gtk.Label(label=msg["time"])
+    time_label.get_style_context().add_class("log-time")
+    time_label.set_size_request(40, -1)
+    hbox.pack_start(time_label, False, False, 0)
+
+    # Sender -> Recipient
+    route = Gtk.Label(label=f"{msg['sender']} \u2192 {msg['recipient']}")
+    route.get_style_context().add_class("session-meta")
+    route.set_size_request(160, -1)
+    route.set_halign(Gtk.Align.START)
+    route.set_ellipsize(Pango.EllipsizeMode.END)
+    hbox.pack_start(route, False, False, 0)
+
+    # Preview
+    preview = Gtk.Label(label=msg["preview"])
+    preview.set_halign(Gtk.Align.START)
+    preview.set_ellipsize(Pango.EllipsizeMode.END)
+    preview.set_hexpand(True)
+    preview.get_style_context().add_class("session-preview")
+    hbox.pack_start(preview, True, True, 0)
+
+    row.show_all()
+    return row
+
+
+# ---------------------------------------------------------------------------
+# Refresh logic
+# ---------------------------------------------------------------------------
+
+def _refresh_content() -> None:
+    """Refresh all swarm content based on selected team."""
+    global _selected_team, _refreshing
+    if _refreshing:
+        return
+    _refreshing = True
+    try:
+        _refresh_content_inner()
+    finally:
+        _refreshing = False
+
+
+def _refresh_content_inner() -> None:
+    """Actual refresh logic — guarded by _refreshing flag."""
+    global _selected_team
+
+    teams = _load_teams()
+
+    # Update status
+    if _status_label:
+        total = len(teams)
+        active = sum(1 for t in teams if t["active"])
+        _status_label.set_text(f"{total} Teams, {active} aktiv")
+
+    # Update team cards
+    if _team_flow:
+        for child in _team_flow.get_children():
+            _team_flow.remove(child)
+        for team in teams:
+            card = _build_team_card(team)
+            flow_child = Gtk.FlowBoxChild()
+            flow_child.add(card)
+            flow_child.show_all()
+            _team_flow.add(flow_child)
+        _team_flow.show_all()
+
+    # Update selector
+    if _team_selector:
+        current = _team_selector.get_active_text()
+        _team_selector.remove_all()
+        _team_selector.append_text("Alle Teams")
+        for team in teams:
+            _team_selector.append_text(team["dir_name"])
+        # Restore selection
+        if current:
+            model = _team_selector.get_model()
+            for i, row in enumerate(model):
+                if row[0] == current:
+                    _team_selector.set_active(i)
+                    break
+            else:
+                _team_selector.set_active(0)
+        else:
+            _team_selector.set_active(0)
+
+    active_text = _team_selector.get_active_text() if _team_selector else None
+    if active_text and active_text != "Alle Teams":
+        _selected_team = active_text
+    else:
+        _selected_team = None
+
+    # Update tasks
+    if _task_list:
+        for child in _task_list.get_children():
+            _task_list.remove(child)
+        if _selected_team:
+            tasks = _load_tasks(_selected_team)
+        else:
+            # All teams
+            tasks = []
+            for team in teams:
+                for t in _load_tasks(team["dir_name"]):
+                    t["_team"] = team["dir_name"]
+                    tasks.append(t)
+            order = {"in_progress": 0, "pending": 1, "completed": 2}
+            tasks.sort(key=lambda t: order.get(t["status"], 9))
+        for task in tasks:
+            _task_list.add(_build_task_row(task))
+        _task_list.show_all()
+
+    # Update messages
+    if _msg_list:
+        for child in _msg_list.get_children():
+            _msg_list.remove(child)
+        if _selected_team:
+            messages = _load_messages(_selected_team)
+        else:
+            messages = []
+            for team in teams:
+                messages.extend(_load_messages(team["dir_name"], limit=5))
+            messages.sort(key=lambda m: m["sort_key"], reverse=True)
+            messages = messages[:10]
+        for msg in messages:
+            _msg_list.add(_build_message_row(msg))
+        _msg_list.show_all()
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def _update_visual_for_team() -> None:
+    """Load comm graph HTML for the selected team, or fallback HTML for all."""
+    if not _stack or _stack.get_visible_child_name() != "visual" or not _webview:
+        return
+    active_text = _team_selector.get_active_text() if _team_selector else None
+    if active_text and active_text != "Alle Teams":
+        html = generate_comm_graph(active_text)
+        _webview.load_html(html, None)
+    elif SWARM_HTML.exists():
+        _webview.load_uri(SWARM_HTML.as_uri())
+
+
+def _on_load_changed(webview, event):
+    """Track when WebKit page has finished loading."""
+    global _webview_ready
+    if event == WebKit2.LoadEvent.FINISHED:
+        _webview_ready = True
+
+
+def _build_visual_view() -> Gtk.Widget:
+    """Build the WebKit visual view loading agent-swarm-live.html."""
+    global _webview
+
+    _webview = WebKit2.WebView()
+    settings = _webview.get_settings()
+    settings.set_enable_javascript(True)
+    settings.set_enable_developer_extras(False)
+    settings.set_hardware_acceleration_policy(
+        WebKit2.HardwareAccelerationPolicy.NEVER
+    )
+    _webview.connect("load-changed", _on_load_changed)
+
+    if SWARM_HTML.exists():
+        _webview.load_uri(SWARM_HTML.as_uri())
+    else:
+        p = get_palette()
+        _webview.load_html(
+            f'<html><body style="background:{p["bg"]};color:{p["text"]};font-family:system-ui;'
+            'display:flex;align-items:center;justify-content:center;height:100vh">'
+            f'<div>agent-swarm-live.html nicht gefunden<br>'
+            f'<small style="color:{p["overlay"]}">{SWARM_HTML}</small></div>'
+            '</body></html>',
+            None,
+        )
+
+    return _webview
+
+
+def build_swarm_tab() -> Gtk.Box:
+    """Build and return the Swarm tab widget."""
+    global _team_flow, _task_list, _msg_list, _team_selector, _status_label, _stack
+
+    box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+
+    # --- Toolbar ---
+    toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+    toolbar.set_margin_start(8)
+    toolbar.set_margin_end(8)
+    toolbar.set_margin_top(6)
+    toolbar.set_margin_bottom(4)
+    toolbar.get_style_context().add_class("swarm-toolbar")
+
+    title = Gtk.Label(label="Swarm")
+    title.get_style_context().add_class("section-title")
+    title_attrs = Pango.AttrList()
+    title_attrs.insert(Pango.attr_weight_new(Pango.Weight.BOLD))
+    title_attrs.insert(Pango.attr_scale_new(1.1))
+    title.set_attributes(title_attrs)
+    toolbar.pack_start(title, False, False, 0)
+
+    # View toggle: Daten / Visual
+    view_toggle = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
+    view_toggle.get_style_context().add_class("linked")
+
+    btn_data = Gtk.ToggleButton(label="Daten")
+    btn_visual = Gtk.ToggleButton(label="Visual")
+    btn_data.set_active(True)
+    btn_data.get_style_context().add_class("swarm-btn")
+    btn_visual.get_style_context().add_class("swarm-btn")
+
+    def _on_toggle_data(btn):
+        if btn.get_active():
+            btn_visual.set_active(False)
+            if _stack:
+                _stack.set_visible_child_name("data")
+        elif not btn_visual.get_active():
+            btn.set_active(True)
+
+    def _on_toggle_visual(btn):
+        if btn.get_active():
+            btn_data.set_active(False)
+            if _stack:
+                _stack.set_visible_child_name("visual")
+                _update_visual_for_team()
+        elif not btn_data.get_active():
+            btn.set_active(True)
+
+    btn_data.connect("toggled", _on_toggle_data)
+    btn_visual.connect("toggled", _on_toggle_visual)
+    view_toggle.pack_start(btn_data, False, False, 0)
+    view_toggle.pack_start(btn_visual, False, False, 0)
+    toolbar.pack_start(view_toggle, False, False, 4)
+
+    # Team selector
+    _team_selector = Gtk.ComboBoxText()
+    _team_selector.append_text("Alle Teams")
+    _team_selector.set_active(0)
+    def _on_team_changed(_selector):
+        _refresh_content()
+        _update_visual_for_team()
+    _team_selector.connect("changed", _on_team_changed)
+    toolbar.pack_start(_team_selector, False, False, 4)
+
+    # Spacer
+    spacer = Gtk.Box()
+    spacer.set_hexpand(True)
+    toolbar.pack_start(spacer, True, True, 0)
+
+    _status_label = Gtk.Label(label="")
+    _status_label.get_style_context().add_class("session-stats")
+    toolbar.pack_end(_status_label, False, False, 4)
+
+    reload_btn = Gtk.Button(label="\u27f3 Refresh")
+    reload_btn.get_style_context().add_class("swarm-btn")
+    def _on_refresh(_):
+        if _stack and _stack.get_visible_child_name() == "visual" and _webview:
+            _webview.reload()
+        else:
+            _refresh_content()
+    reload_btn.connect("clicked", _on_refresh)
+    toolbar.pack_end(reload_btn, False, False, 0)
+
+    box.pack_start(toolbar, False, False, 0)
+    box.pack_start(Gtk.Separator(), False, False, 0)
+
+    # --- Stack: Data view + Visual view ---
+    _stack = Gtk.Stack()
+    _stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
+    _stack.set_transition_duration(200)
+
+    # Data view (native GTK)
+    scrolled = Gtk.ScrolledWindow()
+    scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+
+    content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+    content.set_margin_top(8)
+    content.set_margin_bottom(8)
+    content.set_margin_start(8)
+    content.set_margin_end(8)
+
+    # --- Team overview (FlowBox) ---
+    team_label = Gtk.Label(label="Teams")
+    team_label.set_halign(Gtk.Align.START)
+    team_label.get_style_context().add_class("section-title")
+    content.pack_start(team_label, False, False, 0)
+
+    _team_flow = Gtk.FlowBox()
+    _team_flow.set_min_children_per_line(1)
+    _team_flow.set_max_children_per_line(5)
+    _team_flow.set_selection_mode(Gtk.SelectionMode.NONE)
+    _team_flow.set_homogeneous(True)
+    content.pack_start(_team_flow, False, False, 0)
+
+    # --- Tasks ---
+    task_label = Gtk.Label(label="Tasks")
+    task_label.set_halign(Gtk.Align.START)
+    task_label.set_margin_top(8)
+    task_label.get_style_context().add_class("section-title")
+    content.pack_start(task_label, False, False, 0)
+
+    _task_list = Gtk.ListBox()
+    _task_list.set_selection_mode(Gtk.SelectionMode.NONE)
+    content.pack_start(_task_list, False, False, 0)
+
+    # --- Messages ---
+    msg_label = Gtk.Label(label="Messages (letzte 10)")
+    msg_label.set_halign(Gtk.Align.START)
+    msg_label.set_margin_top(8)
+    msg_label.get_style_context().add_class("section-title")
+    content.pack_start(msg_label, False, False, 0)
+
+    _msg_list = Gtk.ListBox()
+    _msg_list.set_selection_mode(Gtk.SelectionMode.NONE)
+    content.pack_start(_msg_list, False, False, 0)
+
+    scrolled.add(content)
+    _stack.add_named(scrolled, "data")
+
+    # Visual view (WebKit)
+    _stack.add_named(_build_visual_view(), "visual")
+
+    box.pack_start(_stack, True, True, 0)
+
+    # Initial load + event file monitor
+    GLib.idle_add(_refresh_content)
+    GLib.idle_add(_setup_event_monitor)
+
+    return box
+
+
+def _push_events_to_webview() -> None:
+    """Read new events and push them to the WebKit visual view via JS."""
+    if not (_stack and _stack.get_visible_child_name() == "visual"
+            and _webview and _webview_ready):
+        return
+    events = _read_recent_events(20)
+    if not events:
+        return
+    js = f"if(typeof updateEvents==='function')updateEvents({json.dumps(events, ensure_ascii=True)})"
+    _webview.run_javascript(js, None, None, None)
+
+
+def _on_events_file_changed(_monitor, file, _other, event_type) -> None:
+    """Gio.FileMonitor callback — fires on every append to the JSONL file."""
+    if event_type not in (Gio.FileMonitorEvent.CHANGED, Gio.FileMonitorEvent.CHANGES_DONE_HINT):
+        return
+    # Schedule on GLib main loop (file monitor callback may be on any thread)
+    GLib.idle_add(_push_events_to_webview)
+
+
+def _setup_event_monitor() -> None:
+    """Set up Gio.FileMonitor on today's event JSONL file.
+
+    Called once from build_swarm_tab(). Re-called on day rollover from refresh_swarm().
+    """
+    global _event_file_monitor, _events_current_day, _events_file_offset
+
+    today = datetime.now().strftime("%Y-%m-%d")
+    if _events_current_day == today and _event_file_monitor is not None:
+        return  # already monitoring today's file
+
+    # Cancel previous monitor
+    if _event_file_monitor is not None:
+        _event_file_monitor.cancel()
+        _event_file_monitor = None
+
+    _events_current_day = today
+    _events_file_offset = 0
+
+    event_file = EVENTS_DIR / f"{today}.jsonl"
+    if not event_file.exists():
+        # File doesn't exist yet — check again on next timer tick
+        return
+
+    try:
+        gfile = Gio.File.new_for_path(str(event_file))
+        _event_file_monitor = gfile.monitor_file(Gio.FileMonitorFlags.NONE, None)
+        _event_file_monitor.connect("changed", _on_events_file_changed)
+    except GLib.Error:
+        pass
+
+
+def refresh_swarm() -> bool:
+    """Called by GLib timer from panel.py every 30s.
+
+    Handles team/task data refresh + day rollover for event monitor.
+    Event updates are pushed instantly via Gio.FileMonitor (no polling).
+    """
+    # Skip if swarm tab is not visible (MiniMax M1 fix)
+    if _stack and not _stack.get_mapped():
+        return True
+
+    # Re-check event monitor (handles day rollover + late file creation)
+    _setup_event_monitor()
+
+    try:
+        _refresh_content()
+        # Async event read — offloaded to background thread
+        _read_events_async()
+        # Also update visual view if visible and ready
+        if (
+            _stack
+            and _stack.get_visible_child_name() == "visual"
+            and _webview
+            and _webview_ready
+        ):
+            active_text = _team_selector.get_active_text() if _team_selector else None
+            if active_text and active_text != "Alle Teams":
+                # Comm graph: inject updateGraph() with live data
+                data = _collect_comm_data(active_text)
+                js = f"if(typeof updateGraph==='function')updateGraph({json.dumps(data, ensure_ascii=True)})"
+                _webview.run_javascript(js, None, None, None)
+            else:
+                # Generic swarm view: inject updateSwarm()
+                data = _collect_live_data()
+                js = f"if(typeof updateSwarm==='function')updateSwarm({json.dumps(data, ensure_ascii=True)})"
+                _webview.run_javascript(js, None, None, None)
+    except Exception:
+        pass
+    return True  # keep timer alive

swarm_visual.py

@@ -0,0 +1,708 @@
+#!/usr/bin/env python3
+"""Swarm Visual — HTML generator for live agent communication graphs.
+
+Generates a self-contained HTML page with hub-and-spoke layout showing
+real team members, their connections via bezier curves, animated particles
+with trail effects, and live-updating status.
+"""
+
+import json
+import math
+from datetime import datetime, timezone
+from html import escape as _esc
+from pathlib import Path
+
+TEAMS_DIR = Path.home() / ".claude" / "teams"
+TASKS_DIR = Path.home() / ".claude" / "tasks"
+
+# Color mapping for member.color -> CSS hex
+COLOR_MAP = {
+    "pink": "#f5a0c0",
+    "green": "#98c379",
+    "cyan": "#56b6c2",
+    "blue": "#61afef",
+    "purple": "#c678dd",
+    "yellow": "#e5c07b",
+    "red": "#e06c75",
+    "orange": "#d19a66",
+}
+
+MODEL_BADGE = {
+    "claude-opus-4-6": ("opus", "#c678dd"),
+    "opus": ("opus", "#c678dd"),
+    "claude-sonnet-4-6": ("sonnet", "#61afef"),
+    "sonnet": ("sonnet", "#61afef"),
+    "claude-haiku-4-5": ("haiku", "#98c379"),
+    "haiku": ("haiku", "#98c379"),
+}
+
+
+def _is_recent(ts_str: str, seconds: int = 120) -> bool:
+    if not ts_str:
+        return False
+    try:
+        ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+        return (datetime.now(timezone.utc) - ts).total_seconds() < seconds
+    except (ValueError, AttributeError):
+        return False
+
+
+def _load_inbox(team_dir: Path, member_name: str) -> list[dict]:
+    inbox = team_dir / "inboxes" / f"{member_name}.json"
+    if not inbox.exists():
+        return []
+    try:
+        data = json.loads(inbox.read_text(encoding="utf-8"))
+        if not isinstance(data, list):
+            return []
+        return [
+            m for m in data
+            if not any(k in m.get("text", "") for k in
+                       ['"type":"task_assignment"', '"type":"shutdown_request"',
+                        '"type":"idle_notification"'])
+        ]
+    except (json.JSONDecodeError, OSError):
+        return []
+
+
+def _load_tasks(team_name: str) -> list[dict]:
+    tasks = []
+    task_dir = TASKS_DIR / team_name
+    if not task_dir.exists():
+        return tasks
+    for tf in sorted(task_dir.glob("*.json"), key=lambda f: f.stem.zfill(10)):
+        try:
+            data = json.loads(tf.read_text(encoding="utf-8"))
+            if data.get("metadata", {}).get("_internal"):
+                continue
+            tasks.append(data)
+        except (json.JSONDecodeError, OSError):
+            continue
+    return tasks
+
+
+def generate_comm_graph(team_name: str) -> str:
+    """Generate a complete HTML comm graph for a team."""
+    team_dir = TEAMS_DIR / team_name
+    config_path = team_dir / "config.json"
+    if not config_path.exists():
+        return f"<html><body style='background:#080c10;color:#e6edf3;padding:2em'>Team '{_esc(team_name)}' nicht gefunden.</body></html>"
+
+    try:
+        config = json.loads(config_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return f"<html><body style='background:#080c10;color:#e6edf3;padding:2em'>Team '{_esc(team_name)}' config fehlerhaft.</body></html>"
+    members = config.get("members", [])
+    if not members:
+        return f"<html><body style='background:#080c10;color:#e6edf3;padding:2em'>Team '{_esc(team_name)}' hat keine Members.</body></html>"
+
+    # Separate lead from other members
+    lead = None
+    others = []
+    for m in members:
+        if m.get("agentType") == "team-lead" or m.get("name") == "team-lead":
+            lead = m
+        else:
+            others.append(m)
+    if not lead and members:
+        lead = members[0]
+        others = members[1:]
+
+    # Collect inbox data per member
+    member_data = []
+    for m in [lead] + others:
+        name = m.get("name", "?")
+        msgs = _load_inbox(team_dir, name)
+        model_key = m.get("model", "")
+        model_info = MODEL_BADGE.get(model_key, (model_key, "#8b949e"))
+        color = COLOR_MAP.get(m.get("color", ""), "#8b949e")
+        last_ts = msgs[-1].get("timestamp", "") if msgs else ""
+        member_data.append({
+            "name": name,
+            "model": model_info[0],
+            "model_color": model_info[1],
+            "color": color,
+            "agent_type": m.get("agentType", ""),
+            "msg_count": len(msgs),
+            "status": "working" if _is_recent(last_ts, 120) else "idle",
+            "last_msgs": msgs[-3:] if msgs else [],
+            "is_lead": m == lead,
+            "has_recent": _is_recent(last_ts, 300),
+        })
+
+    # Load tasks
+    tasks = _load_tasks(team_name)
+
+    # Collect all messages chronologically
+    all_msgs = []
+    for m in members:
+        name = m.get("name", "?")
+        for msg in _load_inbox(team_dir, name):
+            msg["_to"] = name
+            all_msgs.append(msg)
+    all_msgs.sort(key=lambda x: x.get("timestamp", ""))
+    recent_msgs = all_msgs[-10:]
+
+    # Layout: lead in center, others in circle
+    cx, cy = 400, 270
+    radius = 190
+    n = len(others)
+    positions = {}
+    positions[lead.get("name", "?")] = (cx, cy)
+    for i, m in enumerate(others):
+        angle = -math.pi / 2 + (2 * math.pi * i / max(n, 1))
+        x = cx + radius * math.cos(angle)
+        y = cy + radius * math.sin(angle)
+        positions[m.get("name", "?")] = (x, y)
+
+    lead_name = lead.get("name", "?")
+
+    # Build SVG bezier connections
+    svg_paths = []
+    for md in member_data:
+        if md["is_lead"]:
+            continue
+        lx, ly = positions[lead_name]
+        mx, my = positions[md["name"]]
+        # Control point: offset perpendicular to midpoint
+        midx, midy = (lx + mx) / 2, (ly + my) / 2
+        dx, dy = mx - lx, my - ly
+        length = math.sqrt(dx * dx + dy * dy) or 1
+        # Perpendicular offset (30px)
+        px, py = -dy / length * 30, dx / length * 30
+        cpx, cpy = midx + px, midy + py
+        active_class = "conn-active" if md["has_recent"] else "conn"
+        svg_paths.append(
+            f'<path class="{active_class}" id="path-{md["name"]}" '
+            f'data-from="{lead_name}" data-to="{md["name"]}" '
+            f'd="M {lx} {ly} Q {cpx:.1f} {cpy:.1f} {mx:.1f} {my:.1f}" '
+            f'stroke="{md["color"]}" stroke-width="2" fill="none" stroke-opacity="0.3"/>'
+        )
+
+    # Build node HTML
+    node_html_parts = []
+    for md in member_data:
+        x, y = positions[md["name"]]
+        assigned_task = next((t for t in tasks if t.get("owner") == md["name"]), None)
+        task_html = ""
+        if assigned_task:
+            st = assigned_task.get("status", "pending")
+            st_color = {"completed": "#98c379", "in_progress": "#e5c07b"}.get(st, "#8b949e")
+            desc_preview = _esc(assigned_task.get("description", "")[:100].replace('\n', ' '))
+            subj = _esc(assigned_task.get("subject", "")[:60])
+            task_html = f'''
+            <div class="node-task">
+              <span class="task-status" style="color:{st_color}">{st.upper().replace("_"," ")}</span>
+              {subj}
+              <div class="task-desc">{desc_preview}</div>
+            </div>'''
+
+        msg_html = ""
+        if md["last_msgs"]:
+            msg_items = ""
+            for msg in md["last_msgs"]:
+                sender = _esc(msg.get("from", "?"))
+                text = _esc(msg.get("text", "")[:80].replace("\n", " "))
+                msg_items += f'<div class="detail-msg"><b>{sender}:</b> {text}</div>'
+            msg_html = f'<div class="node-messages">{msg_items}</div>'
+
+        status_class = "status-working" if md["status"] == "working" else "status-idle"
+
+        safe_name = _esc(md['name'])
+        # Use data attribute for JS to avoid quote-breaking in onclick
+        node_html_parts.append(f'''
+        <div class="node" id="node-{safe_name}" data-name="{safe_name}"
+             style="left:{x-70}px;top:{y-40}px;--node-color:{md['color']}"
+             onclick="toggleDetail(this.dataset.name)"
+             onmouseenter="highlightConn(this.dataset.name,true)"
+             onmouseleave="highlightConn(this.dataset.name,false)">
+          <div class="node-header">
+            <span class="status-dot {status_class}" id="dot-{safe_name}"></span>
+            <span class="node-name">{safe_name}</span>
+            <span class="model-badge" style="background:{md['model_color']}20;color:{md['model_color']}">{md['model']}</span>
+          </div>
+          <div class="node-meta">
+            <span class="agent-type">{md['agent_type']}</span>
+            <span class="msg-badge" id="badge-{safe_name}">{md['msg_count']}</span>
+          </div>
+          <div class="node-detail" id="detail-{safe_name}">
+            <div class="detail-inner">
+            {task_html}
+            {msg_html}
+            </div>
+          </div>
+        </div>''')
+
+    # Task stream
+    order = {"in_progress": 0, "pending": 1, "completed": 2}
+    tasks.sort(key=lambda t: order.get(t.get("status", ""), 9))
+    task_stream_items = ""
+    for t in tasks[:8]:
+        st = t.get("status", "pending")
+        st_icon = {"completed": "&#10003;", "in_progress": "&#9679;"}.get(st, "&#9675;")
+        st_color = {"completed": "#98c379", "in_progress": "#e5c07b"}.get(st, "#8b949e")
+        owner = _esc(t.get("owner", ""))
+        task_stream_items += f'''
+        <div class="stream-item">
+          <span style="color:{st_color}">{st_icon}</span>
+          <span class="stream-subject">{_esc(t.get("subject","")[:50])}</span>
+          <span class="stream-owner">{owner}</span>
+        </div>'''
+
+    # Message log
+    msg_log_items = ""
+    for msg in reversed(recent_msgs):
+        sender = _esc(msg.get("from", "?"))
+        recipient = _esc(msg.get("_to", "?"))
+        text = _esc(msg.get("text", "")[:90].replace("\n", " "))
+        ts = msg.get("timestamp", "")
+        try:
+            time_fmt = datetime.fromisoformat(ts.replace("Z", "+00:00")).strftime("%H:%M")
+        except (ValueError, AttributeError):
+            time_fmt = "??:??"
+        msg_log_items += f'''
+        <div class="log-item">
+          <span class="log-time">{time_fmt}</span>
+          <span class="log-route">{sender} &rarr; {recipient}</span>
+          <span class="log-text">{text}</span>
+        </div>'''
+
+    html = f'''<!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="UTF-8">
+<title>Comm Graph &mdash; {_esc(team_name)}</title>
+<style>
+* {{ box-sizing: border-box; margin: 0; padding: 0; }}
+:root {{
+  --bg: #080c10;
+  --surface: #0d1117;
+  --surface-2: #161b22;
+  --surface-3: #1c2333;
+  --border: rgba(255,255,255,0.06);
+  --border-bright: rgba(255,255,255,0.14);
+  --text: #e6edf3;
+  --text-dim: #8b949e;
+  --text-muted: #484f58;
+  --mono: 'Space Mono', 'SF Mono', 'Fira Code', monospace;
+  --sans: system-ui, -apple-system, sans-serif;
+}}
+body {{ font-family: var(--sans); background: var(--bg); color: var(--text); overflow-x: hidden; }}
+
+.header {{ text-align: center; padding: 14px 0 6px; }}
+.header h2 {{ font-size: 15px; font-weight: 600; letter-spacing: 0.5px; }}
+.header .sub {{ font-size: 11px; color: var(--text-dim); margin-top: 2px; }}
+
+/* ---- GRAPH AREA with dot grid ---- */
+.graph-area {{
+  position: relative; width: 800px; height: 540px; margin: 0 auto;
+  background-image: radial-gradient(circle, rgba(255,255,255,0.025) 1px, transparent 1px);
+  background-size: 24px 24px;
+  border-top: 1px solid var(--border);
+  border-bottom: 1px solid var(--border);
+}}
+svg.connections {{
+  position: absolute; top: 0; left: 0; width: 800px; height: 540px;
+  pointer-events: none; z-index: 1;
+}}
+
+/* ---- CONNECTIONS ---- */
+.conn, .conn-active {{
+  transition: stroke-opacity 0.3s, filter 0.3s;
+}}
+.conn-active {{
+  stroke-opacity: 0.5;
+  stroke-dasharray: 6 4;
+  animation: dash 1.5s linear infinite;
+}}
+.conn-highlight {{
+  stroke-opacity: 0.85 !important;
+  stroke-width: 3 !important;
+  filter: url(#glow);
+}}
+@keyframes dash {{
+  to {{ stroke-dashoffset: -20; }}
+}}
+
+/* ---- NODES ---- */
+.node {{
+  position: absolute; width: 140px; padding: 10px 12px;
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: 10px; cursor: pointer; z-index: 2;
+  border-left: 3px solid var(--node-color);
+  transition: box-shadow 0.25s ease, transform 0.2s ease, border-color 0.3s;
+}}
+.node:hover {{
+  transform: translateY(-4px) scale(1.03);
+  border-color: var(--node-color);
+  box-shadow:
+    0 8px 25px color-mix(in srgb, var(--node-color) 20%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--node-color) 15%, transparent);
+}}
+.node-header {{ display: flex; align-items: center; gap: 6px; margin-bottom: 4px; }}
+.node-name {{
+  font-weight: 600; font-size: 12px; flex: 1;
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}}
+.model-badge {{
+  font-size: 9px; padding: 1px 5px; border-radius: 4px;
+  font-weight: 600; text-transform: uppercase; letter-spacing: 0.3px;
+}}
+.status-dot {{
+  width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0;
+  transition: background-color 0.4s, box-shadow 0.4s;
+}}
+.status-working {{
+  background: #98c379;
+  box-shadow: 0 0 8px #98c37988;
+  animation: pulse 2s ease-in-out infinite;
+}}
+.status-idle {{ background: #484f58; }}
+@keyframes pulse {{ 0%,100% {{ opacity: 1; }} 50% {{ opacity: 0.4; }} }}
+
+.node-meta {{ display: flex; justify-content: space-between; align-items: center; }}
+.agent-type {{ font-size: 10px; color: var(--text-dim); }}
+.msg-badge {{
+  font-size: 10px; background: var(--surface-2); padding: 1px 6px;
+  border-radius: 8px; color: var(--text-dim); min-width: 18px; text-align: center;
+}}
+
+/* ---- NODE DETAIL (expandable) ---- */
+.node-detail {{
+  display: grid; grid-template-rows: 0fr;
+  transition: grid-template-rows 0.3s ease-out, padding 0.3s;
+  overflow: hidden; margin-top: 0; padding-top: 0;
+  border-top: 1px solid transparent;
+}}
+.node-detail > .detail-inner {{ min-height: 0; }}
+.node-detail.open {{
+  grid-template-rows: 1fr;
+  margin-top: 8px; padding-top: 8px;
+  border-top-color: var(--border);
+}}
+.node-task {{ font-size: 11px; margin-bottom: 6px; line-height: 1.4; }}
+.task-status {{ font-size: 9px; font-weight: 700; margin-right: 4px; }}
+.task-desc {{ color: var(--text-dim); font-size: 10px; margin-top: 2px; }}
+.node-messages {{ font-size: 10px; }}
+.detail-msg {{ margin-bottom: 4px; color: var(--text-dim); line-height: 1.3; }}
+.detail-msg b {{ color: var(--text); font-weight: 500; }}
+
+/* ---- BOTTOM PANELS ---- */
+.bottom {{
+  display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 16px;
+  padding: 14px 20px; max-width: 800px; margin: 0 auto;
+}}
+.section-title {{
+  font-size: 10px; font-weight: 600; text-transform: uppercase;
+  letter-spacing: 1.2px; color: var(--text-muted); margin-bottom: 8px;
+}}
+.stream-item {{
+  display: flex; gap: 8px; align-items: baseline; font-size: 12px;
+  padding: 4px 0; border-bottom: 1px solid var(--border);
+}}
+.stream-subject {{ flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }}
+.stream-owner {{ color: var(--text-dim); font-size: 11px; font-family: var(--mono); }}
+.log-item {{
+  display: flex; gap: 8px; font-size: 11px; padding: 3px 0;
+  border-bottom: 1px solid var(--border);
+}}
+.log-time {{ color: var(--text-muted); flex-shrink: 0; font-family: var(--mono); font-size: 10px; }}
+.log-route {{
+  color: var(--text-dim); flex-shrink: 0; width: 140px;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  font-family: var(--mono); font-size: 10px;
+}}
+.log-text {{ flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }}
+
+/* ---- EVENT TICKER ---- */
+.event-item {{
+  display: flex; gap: 6px; align-items: baseline; font-size: 11px;
+  padding: 3px 0; border-bottom: 1px solid var(--border);
+  font-family: var(--mono);
+  animation: event-flash 0.6s ease-out;
+}}
+.event-time {{ color: var(--text-muted); flex-shrink: 0; font-size: 10px; }}
+.event-type {{ flex-shrink: 0; font-size: 9px; font-weight: 600; padding: 1px 4px; border-radius: 3px; }}
+.event-type-PostToolUse {{ background: #e5c07b20; color: #e5c07b; }}
+.event-type-SubagentStart {{ background: #98c37920; color: #98c379; }}
+.event-type-SubagentStop {{ background: #e06c7520; color: #e06c75; }}
+.event-type-UserPromptSubmit {{ background: #61afef20; color: #61afef; }}
+.event-detail {{ flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: var(--text-dim); }}
+@keyframes event-flash {{
+  0% {{ background: rgba(255,255,255,0.06); }}
+  100% {{ background: transparent; }}
+}}
+.activity-flash {{
+  animation: glow-flash 0.8s ease-out;
+}}
+@keyframes glow-flash {{
+  0% {{ box-shadow: 0 0 20px var(--node-color); }}
+  100% {{ box-shadow: none; }}
+}}
+</style>
+</head>
+<body>
+<div class="header">
+  <h2>{_esc(team_name)}</h2>
+  <div class="sub">{len(members)} Agents &middot; {len(tasks)} Tasks &middot; {sum(1 for md in member_data if md["status"]=="working")} active</div>
+</div>
+
+<div class="graph-area" id="graph">
+  <svg class="connections" id="svg-conn">
+    <defs>
+      <filter id="glow">
+        <feGaussianBlur stdDeviation="4" result="blur"/>
+        <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
+      </filter>
+      <filter id="particle-glow">
+        <feGaussianBlur stdDeviation="2.5" result="blur"/>
+        <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
+      </filter>
+    </defs>
+    {"".join(svg_paths)}
+  </svg>
+  {"".join(node_html_parts)}
+</div>
+
+<div class="bottom">
+  <div>
+    <div class="section-title">Tasks</div>
+    <div id="task-stream">{task_stream_items}</div>
+  </div>
+  <div>
+    <div class="section-title">Messages</div>
+    <div id="msg-log">{msg_log_items}</div>
+  </div>
+  <div>
+    <div class="section-title">Live Events</div>
+    <div id="event-ticker"></div>
+  </div>
+</div>
+
+<script>
+function toggleDetail(name) {{
+  var el = document.getElementById('detail-' + name);
+  if (el) el.classList.toggle('open');
+}}
+
+// Connection highlight on node hover — also highlights ALL paths for team-lead (W1 fix)
+function highlightConn(name, on) {{
+  var path = document.getElementById('path-' + name);
+  if (path) {{
+    if (on) path.classList.add('conn-highlight');
+    else path.classList.remove('conn-highlight');
+  }} else {{
+    // Team-lead has no single path — highlight all connections
+    document.querySelectorAll('[id^="path-"]').forEach(function(p) {{
+      if (on) p.classList.add('conn-highlight');
+      else p.classList.remove('conn-highlight');
+    }});
+  }}
+}}
+
+// Escape HTML to prevent XSS in dynamic updates (C1 fix)
+function esc(s) {{ var d = document.createElement('div'); d.textContent = s; return d.innerHTML; }}
+
+// Bezier point interpolation
+function bezierPoint(t, x0, y0, cpx, cpy, x1, y1) {{
+  var u = 1 - t;
+  return {{
+    x: u*u*x0 + 2*u*t*cpx + t*t*x1,
+    y: u*u*y0 + 2*u*t*cpy + t*t*y1
+  }};
+}}
+
+// Parse path "M x0 y0 Q cpx cpy x1 y1" — with null guard (C2 fix)
+function parsePath(pathEl) {{
+  var d = pathEl.getAttribute('d');
+  if (!d) return null;
+  var nums = d.match(/-?[\\d.]+/g);
+  if (!nums || nums.length < 6) return null;
+  nums = nums.map(Number);
+  return {{ x0: nums[0], y0: nums[1], cpx: nums[2], cpy: nums[3], x1: nums[4], y1: nums[5] }};
+}}
+
+// Particle with trail effect — cleanup on abort (W4 fix)
+function animateParticle(memberName, reverse) {{
+  var pathEl = document.getElementById('path-' + memberName);
+  if (!pathEl) return;
+  var pp = parsePath(pathEl);
+  if (!pp) return;
+  var color = pathEl.getAttribute('stroke');
+  var svg = document.getElementById('svg-conn');
+  if (!svg) return;
+
+  var circles = [];
+  var sizes = [5, 3.5, 2.5, 1.5];
+  var opacities = [0.95, 0.6, 0.35, 0.15];
+  for (var i = 0; i < 4; i++) {{
+    var c = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+    c.setAttribute('r', sizes[i]);
+    c.setAttribute('fill', color);
+    c.setAttribute('opacity', '0');
+    if (i === 0) c.setAttribute('filter', 'url(#particle-glow)');
+    svg.appendChild(c);
+    circles.push(c);
+  }}
+
+  var start = null, dur = 1400;
+  var trailOffsets = [0, 0.04, 0.09, 0.15];
+  var cancelled = false;
+
+  function cleanup() {{ circles.forEach(function(c) {{ if (c.parentNode) c.remove(); }}); }}
+
+  function step(ts) {{
+    if (cancelled) {{ cleanup(); return; }}
+    if (!start) start = ts;
+    var progress = Math.min((ts - start) / dur, 1);
+
+    for (var i = 0; i < circles.length; i++) {{
+      var t = progress - trailOffsets[i];
+      if (t < 0 || t > 1) {{
+        circles[i].setAttribute('opacity', '0');
+        continue;
+      }}
+      var actualT = reverse ? 1 - t : t;
+      var pt = bezierPoint(actualT, pp.x0, pp.y0, pp.cpx, pp.cpy, pp.x1, pp.y1);
+      circles[i].setAttribute('cx', pt.x);
+      circles[i].setAttribute('cy', pt.y);
+      var fadeOut = 1 - progress * 0.5;
+      circles[i].setAttribute('opacity', opacities[i] * fadeOut);
+    }}
+
+    if (progress < 1) requestAnimationFrame(step);
+    else cleanup();
+  }}
+  requestAnimationFrame(step);
+
+  // Cancel on page unload to prevent orphaned circles (W4)
+  window.addEventListener('beforeunload', function() {{ cancelled = true; cleanup(); }}, {{ once: true }});
+}}
+
+// Initial demo particles
+setTimeout(function() {{
+  var names = {json.dumps([md["name"] for md in member_data if not md["is_lead"]])};
+  names.forEach(function(n, i) {{
+    setTimeout(function() {{ animateParticle(n, Math.random() > 0.5); }}, i * 600);
+  }});
+}}, 800);
+
+// Track message counts for particle triggers
+var lastMsgCounts = {json.dumps({md["name"]: md["msg_count"] for md in member_data})};
+
+function updateGraph(data) {{
+  if (!data || !data.members) return;
+  data.members.forEach(function(m) {{
+    var dot = document.getElementById('dot-' + m.name);
+    if (dot) {{
+      dot.className = 'status-dot ' + (m.status === 'working' ? 'status-working' : 'status-idle');
+    }}
+    var badge = document.getElementById('badge-' + m.name);
+    if (badge) badge.textContent = m.msg_count;
+
+    // Fire particles for new messages
+    var prev = lastMsgCounts[m.name] || 0;
+    if (m.msg_count > prev) {{
+      var count = Math.min(m.msg_count - prev, 3);
+      for (var i = 0; i < count; i++) {{
+        (function(idx) {{
+          setTimeout(function() {{ animateParticle(m.name, true); }}, idx * 500);
+        }})(i);
+      }}
+    }}
+    lastMsgCounts[m.name] = m.msg_count;
+  }});
+
+  if (data.tasks) {{
+    var html = '';
+    var order = {{"in_progress":0,"pending":1,"completed":2}};
+    data.tasks.sort(function(a,b) {{ return (order[a.status]||9) - (order[b.status]||9); }});
+    data.tasks.slice(0,8).forEach(function(t) {{
+      var subj = (t.subject || '').substring(0,50);
+      var icon = t.status==='completed'?'&#10003;':t.status==='in_progress'?'&#9679;':'&#9675;';
+      var col = t.status==='completed'?'#98c379':t.status==='in_progress'?'#e5c07b':'#8b949e';
+      html += '<div class="stream-item"><span style="color:'+col+'">'+icon+'</span>'
+        + '<span class="stream-subject">'+esc(subj)+'</span>'
+        + '<span class="stream-owner">'+esc(t.owner||'')+'</span></div>';
+    }});
+    document.getElementById('task-stream').innerHTML = html;
+  }}
+
+  if (data.new_messages && data.new_messages.length) {{
+    var log = document.getElementById('msg-log');
+    data.new_messages.forEach(function(msg) {{
+      var div = document.createElement('div');
+      div.className = 'log-item';
+      div.innerHTML = '<span class="log-time">'+esc(msg.time||'')+'</span>'
+        + '<span class="log-route">'+esc(msg.sender||'')+' &rarr; '+esc(msg.recipient||'')+'</span>'
+        + '<span class="log-text">'+esc((msg.text||'').substring(0,90))+'</span>';
+      log.prepend(div);
+    }});
+    while (log.children.length > 10) log.removeChild(log.lastChild);
+  }}
+}}
+
+// --- LIVE EVENTS ---
+var seenEventCount = 0;
+
+function updateEvents(events) {{
+  if (!events || !events.length) return;
+  var ticker = document.getElementById('event-ticker');
+  if (!ticker) return;
+
+  // Only show new events (compare count)
+  var newEvents = events.slice(seenEventCount);
+  seenEventCount = events.length;
+
+  newEvents.forEach(function(ev) {{
+    var div = document.createElement('div');
+    div.className = 'event-item';
+    var typeClass = 'event-type-' + (ev.type || '').replace(/[^a-zA-Z]/g, '');
+    var detail = ev.tool || ev.agent || ev.session || '';
+    div.innerHTML = '<span class="event-time">' + esc(ev.time || '') + '</span>'
+      + '<span class="event-type ' + typeClass + '">' + esc(ev.type || '') + '</span>'
+      + '<span class="event-detail">' + esc(detail) + '</span>';
+    ticker.prepend(div);
+
+    // Trigger particle burst for PostToolUse
+    if (ev.type === 'PostToolUse') {{
+      var names = {json.dumps([md["name"] for md in member_data if not md["is_lead"]])};
+      var working = names.filter(function(n) {{
+        var dot = document.getElementById('dot-' + n);
+        return dot && dot.classList.contains('status-working');
+      }});
+      if (working.length > 0) {{
+        var target = working[Math.floor(Math.random() * working.length)];
+        animateParticle(target, Math.random() > 0.5);
+      }}
+    }}
+
+    // Flash node on SubagentStart
+    if (ev.type === 'SubagentStart' && ev.agent) {{
+      var node = document.getElementById('node-' + ev.agent);
+      if (node) {{
+        node.classList.add('activity-flash');
+        setTimeout(function() {{ node.classList.remove('activity-flash'); }}, 800);
+      }}
+      var dot = document.getElementById('dot-' + ev.agent);
+      if (dot) {{
+        dot.className = 'status-dot status-working';
+      }}
+    }}
+
+    // Dim node on SubagentStop
+    if (ev.type === 'SubagentStop' && ev.agent) {{
+      var dot = document.getElementById('dot-' + ev.agent);
+      if (dot) {{
+        dot.className = 'status-dot status-idle';
+      }}
+    }}
+  }});
+
+  // Keep ticker to max 20 items
+  while (ticker.children.length > 20) ticker.removeChild(ticker.lastChild);
+}}
+</script>
+</body>
+</html>'''
+    return html

test_monitor.py

@@ -0,0 +1,67 @@
+import time
+import unittest
+from unittest.mock import patch
+
+import monitor
+
+
+class MonitorTests(unittest.TestCase):
+    def setUp(self) -> None:
+        monitor._cache.clear()
+        monitor._cache_ts.clear()
+        monitor._sidecar_refresh_in_flight = False
+
+    def tearDown(self) -> None:
+        monitor._cache.clear()
+        monitor._cache_ts.clear()
+        monitor._sidecar_refresh_in_flight = False
+
+    def test_get_sidecar_status_returns_fresh_cache_without_thread(self) -> None:
+        expected = {"running": True, "phase": "testing"}
+        monitor._cache["sidecar_status"] = expected
+        monitor._cache_ts["sidecar_status"] = time.time()
+
+        with patch("monitor.threading.Thread") as thread_cls:
+            result = monitor.get_sidecar_status()
+
+        self.assertEqual(result, expected)
+        thread_cls.assert_not_called()
+
+    def test_get_sidecar_status_returns_stale_value_and_starts_background_refresh(self) -> None:
+        stale = {"running": True, "phase": "implementation"}
+        monitor._cache["sidecar_status"] = stale
+        monitor._cache_ts["sidecar_status"] = 0
+
+        started = []
+
+        class FakeThread:
+            def __init__(self, target=None, args=(), daemon=None, name=None):
+                self.target = target
+                self.args = args
+                self.daemon = daemon
+                self.name = name
+
+            def start(self) -> None:
+                started.append((self.target, self.args, self.daemon, self.name))
+
+        with patch("monitor.threading.Thread", FakeThread):
+            result = monitor.get_sidecar_status()
+
+        self.assertEqual(result, stale)
+        self.assertEqual(len(started), 1)
+        self.assertTrue(monitor._sidecar_refresh_in_flight)
+
+    def test_get_sidecar_status_only_starts_one_refresh_thread(self) -> None:
+        monitor._cache["sidecar_status"] = {"running": False}
+        monitor._cache_ts["sidecar_status"] = 0
+        monitor._sidecar_refresh_in_flight = True
+
+        with patch("monitor.threading.Thread") as thread_cls:
+            result = monitor.get_sidecar_status()
+
+        self.assertEqual(result, {"running": False})
+        thread_cls.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

test_shortcut_counter.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""Tests for shortcut_counter_tab.py
+
+Run with: python3 -m pytest test_shortcut_counter.py -v
+or:        python3 test_shortcut_counter.py
+"""
+
+import sqlite3
+import sys
+import tempfile
+import tomllib
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+# ---------------------------------------------------------------------------
+# Test 1: Import check (no GTK required)
+# ---------------------------------------------------------------------------
+
+def test_import():
+    """Module must be importable without crashing.
+    GTK may not be available in CI — mock gi before importing."""
+    # Mock gi and GTK so the import doesn't need a display
+    gi_mock = MagicMock()
+    gtk_mock = MagicMock()
+    glib_mock = MagicMock()
+    pango_mock = MagicMock()
+
+    sys.modules.setdefault("gi", gi_mock)
+    sys.modules.setdefault("gi.repository", MagicMock())
+    sys.modules.setdefault("gi.repository.Gtk", gtk_mock)
+    sys.modules.setdefault("gi.repository.GLib", glib_mock)
+    sys.modules.setdefault("gi.repository.Pango", pango_mock)
+    sys.modules.setdefault("theme", MagicMock(
+        get_palette=lambda: {
+            "text": "#cdd6f4", "overlay": "#6c7086", "dim": "#585b70",
+            "green": "#a6e3a1", "yellow": "#f9e2af",
+        },
+        hex_to_pango_rgb=lambda h: (0, 0, 0),
+    ))
+
+    import importlib
+    import shortcut_counter_tab as sct
+    importlib.reload(sct)  # reload with mocks in place
+
+    assert hasattr(sct, "build_shortcut_counter_tab"), "build_shortcut_counter_tab missing"
+    assert hasattr(sct, "refresh_shortcut_counter"), "refresh_shortcut_counter missing"
+    assert callable(sct.build_shortcut_counter_tab)
+    assert callable(sct.refresh_shortcut_counter)
+    print("PASS  test_import")
+
+
+# ---------------------------------------------------------------------------
+# Test 2: _load_rows — DB missing → returns []
+# ---------------------------------------------------------------------------
+
+def test_load_rows_missing_db():
+    """_load_rows must return [] when the DB file does not exist."""
+    import shortcut_counter_tab as sct
+
+    with patch.object(sct, "_DB_PATH", Path("/nonexistent/path/shortcuts.db")):
+        rows = sct._load_rows()
+
+    assert rows == [], f"Expected [], got {rows}"
+    print("PASS  test_load_rows_missing_db")
+
+
+# ---------------------------------------------------------------------------
+# Test 3: _load_rows — real SQLite DB
+# ---------------------------------------------------------------------------
+
+def test_load_rows_with_db():
+    """_load_rows must return dicts with expected keys from a real SQLite file."""
+    import shortcut_counter_tab as sct
+
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = Path(f.name)
+
+    try:
+        conn = sqlite3.connect(str(db_path))
+        conn.execute(
+            "CREATE TABLE shortcuts "
+            "(combo TEXT, count INTEGER, last_used TEXT, category TEXT)"
+        )
+        conn.execute(
+            "INSERT INTO shortcuts VALUES (?, ?, ?, ?)",
+            ("Ctrl+C", 42, "2026-03-04T10:00:00", "Editing"),
+        )
+        conn.execute(
+            "INSERT INTO shortcuts VALUES (?, ?, ?, ?)",
+            ("Ctrl+V", 5, None, "Editing"),
+        )
+        conn.commit()
+        conn.close()
+
+        with patch.object(sct, "_DB_PATH", db_path):
+            rows = sct._load_rows()
+
+        assert len(rows) == 2, f"Expected 2 rows, got {len(rows)}"
+        # Should be sorted by count DESC
+        assert rows[0]["combo"] == "Ctrl+C", f"First row should be Ctrl+C (count 42), got {rows[0]['combo']}"
+        assert rows[0]["count"] == 42
+        assert rows[1]["combo"] == "Ctrl+V"
+        # Keys present
+        for key in ("combo", "count", "last_used", "category"):
+            assert key in rows[0], f"Key '{key}' missing from row"
+
+        print("PASS  test_load_rows_with_db")
+    finally:
+        db_path.unlink(missing_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Test 3b: _load_rows — TIMESTAMP column with ISO "T" values
+# ---------------------------------------------------------------------------
+
+def test_load_rows_timestamp_iso_values():
+    """_load_rows must tolerate TIMESTAMP columns storing ISO strings."""
+    import shortcut_counter_tab as sct
+
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = Path(f.name)
+
+    try:
+        conn = sqlite3.connect(str(db_path))
+        conn.execute(
+            "CREATE TABLE shortcuts "
+            "(combo TEXT, count INTEGER, first_seen TIMESTAMP, last_used TIMESTAMP, category TEXT)"
+        )
+        conn.execute(
+            "INSERT INTO shortcuts (combo, count, first_seen, last_used, category) "
+            "VALUES (?, ?, ?, ?, ?)",
+            ("Super+L", 10, "2026-04-03T18:00:00", "2026-04-03T18:10:00", "COSMIC"),
+        )
+        conn.commit()
+        conn.close()
+
+        with patch.object(sct, "_DB_PATH", db_path):
+            rows = sct._load_rows()
+
+        assert len(rows) == 1, f"Expected 1 row, got {len(rows)}"
+        assert rows[0]["combo"] == "Super+L"
+        assert rows[0]["last_used"] == "2026-04-03T18:10:00"
+        print("PASS  test_load_rows_timestamp_iso_values")
+    finally:
+        db_path.unlink(missing_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Test 4: _load_config — config missing → returns {}
+# ---------------------------------------------------------------------------
+
+def test_load_config_missing():
+    """_load_config must return {} when config.toml does not exist."""
+    import shortcut_counter_tab as sct
+
+    with patch.object(sct, "_CONFIG_PATH", Path("/nonexistent/config.toml")):
+        config = sct._load_config()
+
+    assert config == {}, f"Expected {{}}, got {config}"
+    print("PASS  test_load_config_missing")
+
+
+# ---------------------------------------------------------------------------
+# Test 5: _load_config — real TOML file with [[items]] format
+# ---------------------------------------------------------------------------
+
+def test_load_config_with_file():
+    """_load_config must parse shortcuts and descriptions from a TOML config."""
+    import shortcut_counter_tab as sct
+
+    toml_content = b"""
+[[shortcuts.Editing.items]]
+combo = "Ctrl+C"
+desc = "Kopieren"
+
+[[shortcuts.Editing.items]]
+combo = "Ctrl+V"
+desc = "Einfuegen"
+
+[[shortcuts.Editing.items]]
+combo = "Ctrl+Z"
+desc = "Rueckgaengig"
+
+[[shortcuts.Navigation.items]]
+combo = "Ctrl+Tab"
+desc = "Tab wechseln"
+
+[[shortcuts.Navigation.items]]
+combo = "Alt+F4"
+desc = "Fenster schliessen"
+"""
+    with tempfile.NamedTemporaryFile(suffix=".toml", delete=False) as f:
+        f.write(toml_content)
+        cfg_path = Path(f.name)
+
+    try:
+        with patch.object(sct, "_CONFIG_PATH", cfg_path):
+            config = sct._load_config()
+
+        assert "Editing" in config, f"Expected 'Editing' category, got {list(config.keys())}"
+        assert "Navigation" in config, f"Expected 'Navigation' category"
+        assert len(config["Editing"]) == 3, f"Expected 3 Editing items, got {len(config['Editing'])}"
+        assert len(config["Navigation"]) == 2, f"Expected 2 Navigation items, got {len(config['Navigation'])}"
+        # Check structure of items
+        first = config["Editing"][0]
+        assert first["combo"] == "Ctrl+C", f"Expected Ctrl+C, got {first['combo']}"
+        assert first["desc"] == "Kopieren", f"Expected 'Kopieren', got {first['desc']}"
+        # Check lookup works
+        all_combos = [it["combo"] for items in config.values() for it in items]
+        assert "Ctrl+C" in all_combos
+        assert "Alt+F4" in all_combos
+        print("PASS  test_load_config_with_file")
+    finally:
+        cfg_path.unlink(missing_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Test 6: _status_label thresholds
+# ---------------------------------------------------------------------------
+
+def test_status_label():
+    """_status_label must return correct labels for count thresholds."""
+    import shortcut_counter_tab as sct
+
+    assert sct._status_label(0) == "Not Used"
+    assert sct._status_label(1) == "Learning"
+    assert sct._status_label(49) == "Learning"
+    assert sct._status_label(50) == "Mastered"
+    assert sct._status_label(100) == "Mastered"
+    print("PASS  test_status_label")
+
+
+# ---------------------------------------------------------------------------
+# Test 7: _fmt_last_used edge cases
+# ---------------------------------------------------------------------------
+
+def test_fmt_last_used():
+    """_fmt_last_used must handle None, ISO strings, and datetime objects."""
+    from datetime import datetime
+    import shortcut_counter_tab as sct
+
+    assert sct._fmt_last_used(None) == "—"
+    assert sct._fmt_last_used("2026-03-04T10:30:00") == "04.03 10:30"
+
+    dt = datetime(2026, 3, 4, 10, 30)
+    assert sct._fmt_last_used(dt) == "04.03 10:30"
+    print("PASS  test_fmt_last_used")
+
+
+# ---------------------------------------------------------------------------
+# Test 8: Widget creation (GTK required — skipped if no display)
+# ---------------------------------------------------------------------------
+
+def test_build_tab_gtk():
+    """build_shortcut_counter_tab must return a Gtk.ScrolledWindow.
+
+    Skipped if no GTK display is available (e.g. headless CI).
+    Uses hasattr check to avoid isinstance() issues with mocked types.
+    """
+    # Clean up any mocks from test_import so real GTK is loaded
+    for key in list(sys.modules.keys()):
+        if key in ("gi.repository.Gtk", "gi.repository.GLib", "gi.repository.Pango",
+                   "theme", "shortcut_counter_tab"):
+            sys.modules.pop(key, None)
+
+    try:
+        import gi
+        gi.require_version("Gtk", "3.0")
+        from gi.repository import Gtk
+        ok, _ = Gtk.init_check(None)
+        if not ok:
+            print("SKIP  test_build_tab_gtk (Gtk.init_check failed — no display)")
+            return
+    except Exception as e:
+        print(f"SKIP  test_build_tab_gtk (no GTK display: {e})")
+        return
+
+    import importlib
+    import shortcut_counter_tab
+    importlib.reload(shortcut_counter_tab)
+
+    tab = shortcut_counter_tab.build_shortcut_counter_tab()
+    # Check widget type by name to avoid isinstance() failures with stale mocks
+    type_name = type(tab).__name__
+    assert type_name == "ScrolledWindow", f"Expected ScrolledWindow, got {type_name}"
+    print("PASS  test_build_tab_gtk")
+
+
+# ---------------------------------------------------------------------------
+# Runner
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    tests = [
+        test_import,
+        test_load_rows_missing_db,
+        test_load_rows_with_db,
+        test_load_rows_timestamp_iso_values,
+        test_load_config_missing,
+        test_load_config_with_file,
+        test_status_label,
+        test_fmt_last_used,
+        test_build_tab_gtk,
+    ]
+    failed = []
+    for t in tests:
+        try:
+            t()
+        except Exception as e:
+            print(f"FAIL  {t.__name__}: {e}")
+            failed.append(t.__name__)
+
+    print()
+    if failed:
+        print(f"FAILED: {', '.join(failed)}")
+        sys.exit(1)
+    else:
+        print(f"All {len(tests)} tests passed.")

theme.py

@@ -0,0 +1,620 @@
+#!/usr/bin/env python3
+"""Theme detection + CSS generation for Claude Code Control Panel.
+
+Supports COSMIC Desktop light/dark switching.
+Detection: COSMIC is_dark config → GTK Settings fallback.
+Palettes: Catppuccin Mocha (dark) / Catppuccin Latte (light).
+"""
+
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gio, GLib, Gtk
+
+# ---------------------------------------------------------------------------
+# COSMIC config path
+# ---------------------------------------------------------------------------
+_COSMIC_IS_DARK = Path.home() / ".config/cosmic/com.system76.CosmicTheme.Mode/v1/is_dark"
+
+# ---------------------------------------------------------------------------
+# Palettes
+# ---------------------------------------------------------------------------
+DARK = {
+    "name": "dark",
+    "bg": "#1e1e2e",
+    "mantle": "#181825",
+    "card": "#313244",
+    "border": "#45475a",
+    "text": "#cdd6f4",
+    "subtext1": "#bac2de",
+    "dim": "#6c7086",
+    "overlay": "#a6adc8",
+    "accent": "#89b4fa",
+    "mauve": "#cba6f7",
+    "lavender": "#b4befe",
+    "green": "#a6e3a1",
+    "yellow": "#f9e2af",
+    "red": "#f38ba8",
+    "teal": "#94e2d5",
+    "peach": "#fab387",
+    # Derived
+    "accent_hover_bg": "rgba(137,180,250,0.2)",
+    "mauve_hover_bg": "rgba(203,166,247,0.2)",
+    "green_hover_bg": "rgba(166,227,161,0.2)",
+    "yellow_hover_bg": "rgba(249,226,175,0.2)",
+    "resume_text": "#1e1e2e",
+}
+
+LIGHT = {
+    "name": "light",
+    "bg": "#eff1f5",
+    "mantle": "#e6e9ef",
+    "card": "#dce0e8",
+    "border": "#ccd0da",
+    "text": "#4c4f69",
+    "subtext1": "#5c5f77",
+    "dim": "#7c7f93",
+    "overlay": "#8c8fa1",
+    "accent": "#1e66f5",
+    "mauve": "#8839ef",
+    "lavender": "#7287fd",
+    "green": "#1a7f12",
+    "yellow": "#c65d06",
+    "red": "#d20f39",
+    "teal": "#127a80",
+    "peach": "#e64d00",
+    # Derived
+    "accent_hover_bg": "rgba(30,102,245,0.12)",
+    "mauve_hover_bg": "rgba(136,57,239,0.12)",
+    "green_hover_bg": "rgba(64,160,43,0.12)",
+    "yellow_hover_bg": "rgba(223,142,29,0.12)",
+    "resume_text": "#eff1f5",
+}
+
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+def is_dark_mode() -> bool:
+    """Detect dark mode: COSMIC config first, GTK Settings fallback."""
+    try:
+        content = _COSMIC_IS_DARK.read_text().strip().lower()
+        return content == "true"
+    except (OSError, ValueError):
+        pass
+    settings = Gtk.Settings.get_default()
+    if settings is None:
+        return True  # safe fallback
+    return settings.get_property("gtk-application-prefer-dark-theme")
+
+
+def get_palette() -> dict[str, str]:
+    """Return the active color palette."""
+    return DARK if is_dark_mode() else LIGHT
+
+
+def hex_to_pango_rgb(hex_color: str) -> tuple[int, int, int]:
+    """Convert '#rrggbb' to Pango 16-bit (r, g, b) tuple."""
+    return (
+        int(hex_color[1:3], 16) * 257,
+        int(hex_color[3:5], 16) * 257,
+        int(hex_color[5:7], 16) * 257,
+    )
+
+
+# ---------------------------------------------------------------------------
+# CSS generation
+# ---------------------------------------------------------------------------
+
+def build_css(p: dict[str, str] | None = None) -> bytes:
+    """Generate panel CSS from a palette dict. Auto-detects if p is None."""
+    if p is None:
+        p = get_palette()
+    return f"""
+window {{
+    background-color: {p["bg"]};
+}}
+
+.panel-header {{
+    font-size: 18px;
+    font-weight: bold;
+    color: {p["text"]};
+}}
+
+.stat-value {{
+    font-size: 22px;
+    font-weight: bold;
+    color: {p["accent"]};
+}}
+
+.stat-label {{
+    font-size: 11px;
+    color: {p["overlay"]};
+}}
+
+.shortcut-btn {{
+    padding: 8px 12px;
+    border-radius: 8px;
+    background: {p["card"]};
+    color: {p["text"]};
+    border: 1px solid {p["border"]};
+    min-width: 90px;
+}}
+
+.shortcut-btn:hover {{
+    background: {p["border"]};
+}}
+
+.shortcut-service {{ border-color: {p["accent"]}; }}
+.shortcut-service:hover {{ border-color: {p["accent"]}; background: {p["accent_hover_bg"]}; }}
+.shortcut-docs {{ border-color: {p["yellow"]}; }}
+.shortcut-docs:hover {{ border-color: {p["yellow"]}; background: {p["yellow_hover_bg"]}; }}
+.shortcut-folder {{ border-color: {p["green"]}; }}
+.shortcut-folder:hover {{ border-color: {p["green"]}; background: {p["green_hover_bg"]}; }}
+.shortcut-config {{ border-color: {p["mauve"]}; }}
+.shortcut-config:hover {{ border-color: {p["mauve"]}; background: {p["mauve_hover_bg"]}; }}
+
+.session-row {{
+    padding: 8px 10px;
+    border-radius: 8px;
+    background: transparent;
+    border-left: 3px solid {p["mauve"]};
+    margin: 3px 0;
+}}
+
+.session-row:hover {{
+    background: {p["card"]};
+}}
+
+.session-row-working {{
+    border-left: 3px solid {p["yellow"]};
+    background: {p["yellow_hover_bg"]};
+}}
+
+.session-row-working:hover {{
+    background: {p["yellow_hover_bg"]};
+}}
+
+.session-row-ready {{
+    border-left: 3px solid {p["green"]};
+    background: {p["green_hover_bg"]};
+}}
+
+.session-row-ready:hover {{
+    background: {p["green_hover_bg"]};
+}}
+
+.session-working-badge {{
+    background: {p["yellow_hover_bg"]};
+    color: {p["yellow"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.session-ready-badge {{
+    background: {p["green_hover_bg"]};
+    color: {p["green"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.session-project {{
+    font-size: 13px;
+    font-weight: bold;
+    color: {p["text"]};
+}}
+
+.session-preview {{
+    font-size: 11px;
+    color: {p["subtext1"]};
+}}
+
+.session-meta {{
+    font-size: 10px;
+    color: {p["dim"]};
+    letter-spacing: 0.02em;
+}}
+
+.session-resume {{
+    padding: 4px 14px;
+    border-radius: 6px;
+    background: {p["accent"]};
+    color: {p["resume_text"]};
+    font-weight: bold;
+    font-size: 11px;
+    border: none;
+}}
+
+.session-resume:hover {{
+    background: {p["lavender"]};
+}}
+
+.session-stats {{
+    border-radius: 20px;
+    background: {p["card"]};
+    padding: 6px 14px;
+    color: {p["teal"]};
+    font-size: 11px;
+    letter-spacing: 0.02em;
+}}
+
+.section-frame {{
+    border: 1px solid {p["border"]};
+    border-radius: 8px;
+    padding: 10px;
+}}
+
+.section-title {{
+    font-weight: bold;
+    color: {p["text"]};
+    font-size: 13px;
+}}
+
+.monitor-value {{
+    font-family: monospace;
+    color: {p["green"]};
+}}
+
+.cost-value {{
+    font-family: monospace;
+    font-size: 20px;
+    font-weight: bold;
+    color: {p["yellow"]};
+}}
+
+.status-bar {{
+    background: {p["mantle"]};
+    padding: 6px 12px;
+}}
+
+.status-saved {{
+    color: {p["green"]};
+    font-weight: bold;
+}}
+
+.status-error {{
+    color: {p["red"]};
+    font-weight: bold;
+}}
+
+notebook header {{
+    background: {p["mantle"]};
+}}
+
+notebook tab {{
+    padding: 8px 16px;
+    color: {p["overlay"]};
+}}
+
+notebook tab:checked {{
+    color: {p["accent"]};
+    border-bottom: 2px solid {p["accent"]};
+}}
+
+.watcher-dot-critical {{ color: {p["red"]}; font-size: 16px; }}
+.watcher-dot-warning {{ color: {p["yellow"]}; font-size: 16px; }}
+.watcher-dot-info {{ color: {p["accent"]}; font-size: 16px; }}
+.watcher-dot-inactive {{ color: {p["dim"]}; font-size: 16px; }}
+.watcher-name {{ font-family: monospace; font-size: 11px; color: {p["subtext1"]}; }}
+
+.phase-badge {{
+    font-family: monospace;
+    font-size: 12px;
+    font-weight: bold;
+    padding: 4px 10px;
+    border-radius: 12px;
+    color: {p["text"]};
+}}
+.phase-badge-exploration {{ background: rgba(137,180,250,0.25); color: {p["accent"]}; }}
+.phase-badge-implementation {{ background: rgba(166,227,161,0.25); color: {p["green"]}; }}
+.phase-badge-testing {{ background: rgba(249,226,175,0.25); color: {p["yellow"]}; }}
+.phase-badge-debugging {{ background: rgba(243,139,168,0.25); color: {p["red"]}; }}
+
+.signal-card {{
+    border-radius: 8px;
+    background: {p["card"]};
+    border: 1px solid {p["border"]};
+    padding: 12px;
+}}
+.cost-value {{
+    font-family: monospace;
+    font-size: 20px;
+    font-weight: bold;
+    color: {p["yellow"]};
+}}
+.mon-stat-value {{
+    font-family: monospace;
+    font-size: 16px;
+    font-weight: bold;
+    color: {p["accent"]};
+}}
+.stat-sublabel {{
+    font-size: 11px;
+    color: {p["subtext1"]};
+}}
+
+.sc-card {{
+    border-radius: 8px;
+    background: {p["card"]};
+    border: 1px solid {p["border"]};
+    padding: 10px;
+    margin: 4px 0;
+}}
+
+.sc-badge-mastered {{
+    background: {p["green_hover_bg"]};
+    color: {p["green"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.sc-badge-learning {{
+    background: {p["yellow_hover_bg"]};
+    color: {p["yellow"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.sc-badge-unused {{
+    background: rgba(243,139,168,0.2);
+    color: {p["red"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.sc-learn-card {{
+    border-left: 3px solid {p["red"]};
+    padding: 8px 12px;
+    border-radius: 6px;
+    background: {p["card"]};
+    margin: 3px 0;
+}}
+
+.sc-learn-card:hover {{
+    background: {p["border"]};
+}}
+
+/* --- Log Viewer --- */
+.log-toolbar {{
+    background: {p["mantle"]};
+    border-radius: 8px;
+    padding: 6px 10px;
+}}
+
+.log-card {{
+    background: {p["card"]};
+    border-radius: 6px;
+    border: 1px solid {p["border"]};
+    padding: 6px 10px;
+    margin: 1px 0;
+}}
+
+.log-card:hover {{
+    background: {p["border"]};
+}}
+
+.log-card-tool {{ border-left: 3px solid {p["green"]}; }}
+.log-card-llm {{ border-left: 3px solid {p["accent"]}; }}
+.log-card-error {{ border-left: 3px solid {p["red"]}; }}
+.log-card-hook {{ border-left: 3px solid {p["mauve"]}; }}
+
+.log-time {{
+    font-family: monospace;
+    font-size: 10px;
+    color: {p["dim"]};
+}}
+
+.log-tool-name {{
+    font-family: monospace;
+    font-size: 11px;
+    font-weight: bold;
+    color: {p["text"]};
+}}
+
+.log-detail {{
+    font-size: 11px;
+    color: {p["subtext1"]};
+}}
+
+.log-cost {{
+    font-family: monospace;
+    font-size: 11px;
+    color: {p["yellow"]};
+}}
+
+.log-status-ok {{ color: {p["green"]}; }}
+.log-status-error {{ color: {p["red"]}; }}
+.log-status-neutral {{ color: {p["dim"]}; }}
+
+.log-stats {{
+    font-size: 11px;
+    color: {p["overlay"]};
+}}
+
+/* --- Swarm Tab --- */
+.swarm-toolbar {{
+    background: {p["mantle"]};
+    border-radius: 8px;
+    padding: 6px 10px;
+}}
+
+.swarm-btn {{
+    background: {p["card"]};
+    border-radius: 6px;
+    border: 1px solid {p["border"]};
+    padding: 4px 12px;
+    color: {p["text"]};
+}}
+
+.swarm-btn:hover {{
+    background: {p["border"]};
+}}
+
+.swarm-status-connected {{
+    color: {p["green"]};
+    font-weight: bold;
+}}
+
+.swarm-status-disconnected {{
+    color: {p["red"]};
+    font-weight: bold;
+}}
+
+.swarm-url {{
+    font-family: monospace;
+    font-size: 11px;
+    color: {p["dim"]};
+}}
+
+/* --- Swarm Native Tab --- */
+.swarm-task-row {{
+    padding: 4px 8px;
+    border-radius: 6px;
+    background: transparent;
+    margin: 1px 0;
+}}
+
+.swarm-task-row:hover {{
+    background: {p["card"]};
+}}
+
+.swarm-badge-progress {{
+    color: {p["accent"]};
+    font-weight: bold;
+    font-size: 11px;
+}}
+
+.swarm-badge-completed {{
+    color: {p["green"]};
+    font-weight: bold;
+    font-size: 11px;
+}}
+
+.swarm-badge-pending {{
+    color: {p["dim"]};
+    font-weight: bold;
+    font-size: 11px;
+}}
+
+.swarm-message {{
+    padding: 2px 8px;
+    border-radius: 4px;
+    background: transparent;
+    margin: 1px 0;
+}}
+
+.swarm-message:hover {{
+    background: {p["card"]};
+}}
+
+.session-snippet {{
+    font-family: monospace;
+    font-size: 10px;
+    color: {p["subtext1"]};
+    padding: 2px 0;
+}}
+
+.session-match-badge {{
+    background: {p["accent_hover_bg"]};
+    color: {p["accent"]};
+    border-radius: 12px;
+    padding: 2px 8px;
+    font-size: 10px;
+    font-weight: bold;
+}}
+
+.session-row-search {{
+    border-left: 3px solid {p["accent"]};
+}}
+
+/* --- Monitor Tab Enhancements --- */
+.mon-tool-bar {{
+    min-height: 8px;
+}}
+.mon-tool-bar trough {{
+    min-height: 8px;
+    background: {p["border"]};
+    border-radius: 4px;
+}}
+.mon-tool-bar progress {{
+    min-height: 8px;
+    background: {p["accent"]};
+    border-radius: 4px;
+}}
+.mon-expander {{
+    color: {p["subtext1"]};
+    font-size: 11px;
+}}
+.mon-expander title {{
+    color: {p["subtext1"]};
+}}
+""".encode()
+
+
+# ---------------------------------------------------------------------------
+# Theme watcher
+# ---------------------------------------------------------------------------
+
+_css_provider: Gtk.CssProvider | None = None
+_file_monitor = None  # prevent GC
+
+
+def apply_theme(provider: Gtk.CssProvider | None = None) -> None:
+    """(Re-)apply CSS based on current theme. Stores provider for reuse."""
+    global _css_provider
+    if provider is not None:
+        _css_provider = provider
+    if _css_provider is None:
+        return
+    _css_provider.load_from_data(build_css())
+
+
+def setup_theme_watcher(provider: Gtk.CssProvider) -> None:
+    """Watch for COSMIC dark/light changes and re-apply CSS automatically."""
+    global _css_provider, _file_monitor
+    _css_provider = provider
+
+    # Watch COSMIC config file (or parent dir if file doesn't exist yet)
+    if _COSMIC_IS_DARK.exists():
+        gio_file = Gio.File.new_for_path(str(_COSMIC_IS_DARK))
+        try:
+            _file_monitor = gio_file.monitor_file(Gio.FileMonitorFlags.NONE, None)
+            _file_monitor.connect("changed", _on_cosmic_theme_changed)
+        except Exception:
+            pass
+    elif _COSMIC_IS_DARK.parent.exists():
+        # Watch parent dir so we detect when the file is created
+        gio_dir = Gio.File.new_for_path(str(_COSMIC_IS_DARK.parent))
+        try:
+            _file_monitor = gio_dir.monitor_directory(Gio.FileMonitorFlags.NONE, None)
+            _file_monitor.connect("changed", _on_cosmic_theme_changed)
+        except Exception:
+            pass
+
+    # Also watch GTK settings as fallback
+    settings = Gtk.Settings.get_default()
+    if settings:
+        settings.connect("notify::gtk-application-prefer-dark-theme", _on_gtk_theme_changed)
+        settings.connect("notify::gtk-theme-name", _on_gtk_theme_changed)
+
+
+def _on_cosmic_theme_changed(_monitor, _file, _other, event_type) -> None:
+    if event_type in (Gio.FileMonitorEvent.CHANGES_DONE_HINT, Gio.FileMonitorEvent.CREATED):
+        GLib.idle_add(apply_theme)
+
+
+def _on_gtk_theme_changed(*_args) -> None:
+    GLib.idle_add(apply_theme)

tools-gui/main.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Claude Code Tools — GTK3 standalone GUI.
+
+Session history, cost tracking, and tool/skill usage analytics.
+Data source: monitor.py from ClaudeCodePanel (TTL-cached, 30s).
+"""
+
+import sys
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk
+
+# Import shared base
+sys.path.insert(0, str(Path.home() / "Projekte" / "shared-gui"))
+from gui_base import BaseApp
+
+# Import monitor for status bar info
+sys.path.insert(0, str(Path.home() / "Projekte" / "ClaudeCodePanel"))
+from monitor import get_daily_cost, format_cost, get_recent_sessions
+
+from tabs.sessions_tab import SessionsTab
+from tabs.costs_tab import CostsTab
+from tabs.tools_tab import ToolsTab
+
+
+class ToolsApp(BaseApp):
+    """Main Claude Code Tools application."""
+
+    def __init__(self):
+        super().__init__("Claude Code Tools", 800, 600, icon_name="utilities-system-monitor")
+
+        self._sessions_tab = SessionsTab()
+        self._costs_tab = CostsTab()
+        self._tools_tab = ToolsTab()
+
+        self._build_ui()
+
+        # Initial load
+        GLib.idle_add(self._refresh_all)
+
+        # Auto-refresh every 30 seconds (matches monitor.py TTL cache)
+        self.start_refresh(30, self._refresh_all)
+
+    def _build_ui(self):
+        # Refresh button in header
+        ref_btn = Gtk.Button(label="Refresh")
+        ref_btn.get_style_context().add_class("shortcut-btn")
+        ref_btn.connect("clicked", lambda _: self._refresh_all())
+        self.add_header_widget(ref_btn)
+
+        # Notebook with 3 tabs
+        notebook = Gtk.Notebook()
+        notebook.append_page(self._sessions_tab, Gtk.Label(label="Sessions"))
+        notebook.append_page(self._costs_tab, Gtk.Label(label="Costs"))
+        notebook.append_page(self._tools_tab, Gtk.Label(label="Tools"))
+
+        self.content_box.pack_start(notebook, True, True, 0)
+
+    def _refresh_all(self) -> bool:
+        """Refresh all tabs and status bar."""
+        self._sessions_tab.refresh()
+        self._costs_tab.refresh()
+        self._tools_tab.refresh()
+
+        # Update status bar
+        daily = get_daily_cost()
+        cost = format_cost(daily.get("cost_estimate_usd", 0))
+        sessions = get_recent_sessions(n=100)
+        self.set_status(f"{len(sessions)} sessions | {cost} today")
+
+        return True  # keep timer
+
+
+def main():
+    app = ToolsApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

tools-gui/tabs/costs_tab.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Costs Tab — Daily cost stats + 7-day bar chart (Cairo) + tool rankings."""
+
+import math
+import sys
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk
+
+sys.path.insert(0, str(Path.home() / "Projekte" / "ClaudeCodePanel"))
+from theme import get_palette
+from monitor import get_daily_cost, get_usage_timeline, get_provider_costs, get_top_tools, format_cost
+
+
+class CostsTab(Gtk.Box):
+    """Cost overview with stats, bar chart, and tool rankings."""
+
+    def __init__(self):
+        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        self.set_margin_top(12)
+        self.set_margin_start(12)
+        self.set_margin_end(12)
+
+        self._stat_labels: dict[str, Gtk.Label] = {}
+        self._timeline_data: list[dict] = []
+        self._chart_area = None
+        self._tools_box = None
+        self._providers_box = None
+
+        self._build_ui()
+
+    def _build_ui(self):
+        p = get_palette()
+
+        # --- Stats row ---
+        stats_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=20)
+        stats_box.get_style_context().add_class("base-card")
+
+        for key, label in [("today", "Today"), ("calls", "Calls"), ("tools", "Tools")]:
+            vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+            val_lbl = Gtk.Label(label="--")
+            val_lbl.get_style_context().add_class("stat-value" if key == "today" else "monitor-value")
+            vbox.pack_start(val_lbl, False, False, 0)
+            name_lbl = Gtk.Label(label=label)
+            name_lbl.get_style_context().add_class("stat-label")
+            vbox.pack_start(name_lbl, False, False, 0)
+            stats_box.pack_start(vbox, True, True, 0)
+            self._stat_labels[key] = val_lbl
+
+        self.pack_start(stats_box, False, False, 0)
+
+        # --- Bar chart (7 days) ---
+        chart_label = Gtk.Label()
+        chart_label.set_markup('<b>Last 7 Days</b>')
+        chart_label.set_halign(Gtk.Align.START)
+        chart_label.get_style_context().add_class("section-title")
+        self.pack_start(chart_label, False, False, 0)
+
+        self._chart_area = Gtk.DrawingArea()
+        self._chart_area.set_size_request(-1, 120)
+        self._chart_area.connect("draw", self._draw_chart)
+        self.pack_start(self._chart_area, False, False, 0)
+
+        # --- Provider costs ---
+        prov_label = Gtk.Label()
+        prov_label.set_markup('<b>Provider Costs</b>')
+        prov_label.set_halign(Gtk.Align.START)
+        prov_label.get_style_context().add_class("section-title")
+        self.pack_start(prov_label, False, False, 0)
+
+        self._providers_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        self._providers_box.get_style_context().add_class("base-card")
+        self.pack_start(self._providers_box, False, False, 0)
+
+        # --- Top tools ---
+        tools_label = Gtk.Label()
+        tools_label.set_markup('<b>Top Tools</b>')
+        tools_label.set_halign(Gtk.Align.START)
+        tools_label.get_style_context().add_class("section-title")
+        self.pack_start(tools_label, False, False, 0)
+
+        self._tools_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        self._tools_box.get_style_context().add_class("base-card")
+        self.pack_start(self._tools_box, False, False, 0)
+
+    def refresh(self) -> None:
+        """Reload cost data from monitor.py."""
+        p = get_palette()
+
+        # Daily cost
+        daily = get_daily_cost()
+        cost = daily.get("cost_estimate_usd", 0)
+        self._stat_labels["today"].set_text(format_cost(cost))
+        self._stat_labels["calls"].set_text(str(daily.get("total_calls", 0)))
+        self._stat_labels["tools"].set_text(str(daily.get("unique_tools", 0)))
+
+        # Timeline for chart
+        self._timeline_data = get_usage_timeline()
+        self._chart_area.queue_draw()
+
+        # Provider costs
+        for child in self._providers_box.get_children():
+            self._providers_box.remove(child)
+
+        providers = get_provider_costs()
+        if providers:
+            for prov, cost_val in sorted(providers.items(), key=lambda x: -x[1]):
+                row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+                name_lbl = Gtk.Label()
+                name_lbl.set_markup(f'<tt>{GLib.markup_escape_text(prov)}</tt>')
+                name_lbl.set_xalign(0)
+                name_lbl.set_width_chars(15)
+                row.pack_start(name_lbl, False, False, 0)
+                cost_lbl = Gtk.Label()
+                cost_lbl.set_markup(
+                    f'<span foreground="{p["yellow"]}" font_family="monospace">{format_cost(cost_val)}</span>'
+                )
+                cost_lbl.set_halign(Gtk.Align.END)
+                row.pack_end(cost_lbl, False, False, 0)
+                self._providers_box.pack_start(row, False, False, 0)
+        else:
+            lbl = Gtk.Label()
+            lbl.set_markup(f'<span foreground="{p["dim"]}">No cost data yet</span>')
+            self._providers_box.pack_start(lbl, False, False, 0)
+
+        self._providers_box.show_all()
+
+        # Top tools
+        for child in self._tools_box.get_children():
+            self._tools_box.remove(child)
+
+        top = get_top_tools(n=8)
+        if top:
+            for tool_name, count in top:
+                row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+                name_lbl = Gtk.Label()
+                name_lbl.set_markup(f'<tt>{GLib.markup_escape_text(tool_name)}</tt>')
+                name_lbl.set_xalign(0)
+                name_lbl.set_width_chars(20)
+                row.pack_start(name_lbl, False, False, 0)
+                count_lbl = Gtk.Label()
+                count_lbl.set_markup(
+                    f'<span foreground="{p["accent"]}" font_family="monospace">{count}</span>'
+                )
+                row.pack_end(count_lbl, False, False, 0)
+                self._tools_box.pack_start(row, False, False, 0)
+        else:
+            lbl = Gtk.Label()
+            lbl.set_markup(f'<span foreground="{p["dim"]}">No tool data yet</span>')
+            self._tools_box.pack_start(lbl, False, False, 0)
+
+        self._tools_box.show_all()
+
+    def _draw_chart(self, widget, cr):
+        """Draw 7-day bar chart using Cairo."""
+        p = get_palette()
+        width = widget.get_allocated_width()
+        height = widget.get_allocated_height()
+
+        data = list(reversed(self._timeline_data))  # oldest first for left-to-right
+        if not data:
+            # Draw placeholder
+            cr.set_source_rgba(*_hex_rgb(p["dim"]), 0.5)
+            cr.select_font_face("monospace", 0, 0)
+            cr.set_font_size(11)
+            cr.move_to(width / 2 - 40, height / 2)
+            cr.show_text("No data yet")
+            return False
+
+        n = len(data)
+        max_cost = max((d.get("cost_est", 0) for d in data), default=1) or 0.01
+        bar_width = max(20, (width - 40) / n - 8)
+        gap = 8
+
+        x_start = 20
+        chart_height = height - 30  # leave room for labels
+
+        for i, d in enumerate(data):
+            cost = d.get("cost_est", 0)
+            bar_h = max(2, (cost / max_cost) * (chart_height - 10))
+            x = x_start + i * (bar_width + gap)
+            y = chart_height - bar_h
+
+            # Bar
+            r, g, b = _hex_rgb(p["accent"])
+            cr.set_source_rgba(r, g, b, 0.7)
+            cr.rectangle(x, y, bar_width, bar_h)
+            cr.fill()
+
+            # Date label
+            cr.set_source_rgba(*_hex_rgb(p["dim"]), 1)
+            cr.select_font_face("monospace", 0, 0)
+            cr.set_font_size(9)
+            date_str = d.get("date", "")[-5:]  # MM-DD
+            cr.move_to(x, height - 4)
+            cr.show_text(date_str)
+
+            # Cost label on top of bar
+            cr.set_source_rgba(*_hex_rgb(p["text"]), 1)
+            cr.set_font_size(9)
+            cr.move_to(x, y - 3)
+            cr.show_text(format_cost(cost))
+
+        return False
+
+
+def _hex_rgb(hex_color: str) -> tuple[float, float, float]:
+    """Convert #rrggbb to (r, g, b) floats 0-1."""
+    return (
+        int(hex_color[1:3], 16) / 255,
+        int(hex_color[3:5], 16) / 255,
+        int(hex_color[5:7], 16) / 255,
+    )

tools-gui/tabs/sessions_tab.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Sessions Tab — Recent sessions with search and sort."""
+
+import sys
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk
+
+sys.path.insert(0, str(Path.home() / "Projekte" / "ClaudeCodePanel"))
+from theme import get_palette
+from monitor import get_recent_sessions
+
+
+class SessionsTab(Gtk.Box):
+    """Sessions list with search filter and sort options."""
+
+    def __init__(self):
+        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=6)
+        self.set_margin_top(8)
+        self.set_margin_start(12)
+        self.set_margin_end(12)
+
+        self._sessions: list[dict] = []
+        self._filter_text = ""
+        self._sort_key = "mtime"
+
+        self._build_ui()
+
+    def _build_ui(self):
+        # Toolbar: search + sort
+        toolbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
+        toolbar.get_style_context().add_class("base-toolbar")
+
+        search = Gtk.SearchEntry()
+        search.set_placeholder_text("Filter by project...")
+        search.connect("search-changed", self._on_filter_changed)
+        toolbar.pack_start(search, True, True, 0)
+
+        sort_combo = Gtk.ComboBoxText()
+        sort_combo.append("mtime", "Newest first")
+        sort_combo.append("project", "By project")
+        sort_combo.set_active(0)
+        sort_combo.connect("changed", self._on_sort_changed)
+        toolbar.pack_start(sort_combo, False, False, 0)
+
+        self.pack_start(toolbar, False, False, 0)
+
+        # Scrolled list
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        scrolled.set_vexpand(True)
+
+        self._listbox = Gtk.ListBox()
+        self._listbox.set_selection_mode(Gtk.SelectionMode.NONE)
+        scrolled.add(self._listbox)
+        self.pack_start(scrolled, True, True, 0)
+
+    def refresh(self) -> None:
+        """Reload session data from monitor.py."""
+        self._sessions = get_recent_sessions(n=20)
+        self._rebuild_list()
+
+    def _rebuild_list(self):
+        p = get_palette()
+
+        for child in self._listbox.get_children():
+            self._listbox.remove(child)
+
+        sessions = self._sessions
+        if self._filter_text:
+            ft = self._filter_text.lower()
+            sessions = [s for s in sessions if ft in s.get("project", "").lower()
+                        or ft in s.get("preview", "").lower()]
+
+        if self._sort_key == "project":
+            sessions = sorted(sessions, key=lambda s: s.get("project", "").lower())
+
+        if not sessions:
+            row = Gtk.ListBoxRow()
+            lbl = Gtk.Label()
+            lbl.set_markup(f'<span foreground="{p["dim"]}">No sessions found.</span>')
+            lbl.set_margin_top(20)
+            row.add(lbl)
+            self._listbox.add(row)
+            self._listbox.show_all()
+            return
+
+        for s in sessions:
+            row = Gtk.ListBoxRow()
+            row.add(self._build_session_row(s, p))
+            self._listbox.add(row)
+
+        self._listbox.show_all()
+
+    def _build_session_row(self, s: dict, p: dict) -> Gtk.Box:
+        hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+        hbox.get_style_context().add_class("session-row")
+        hbox.set_margin_top(2)
+        hbox.set_margin_bottom(2)
+
+        # Left: project + preview
+        left = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+
+        proj_lbl = Gtk.Label()
+        proj_lbl.set_markup(
+            f'<span font_weight="bold">{GLib.markup_escape_text(s.get("project", "?"))}</span>'
+        )
+        proj_lbl.set_xalign(0)
+        proj_lbl.get_style_context().add_class("session-project")
+        left.pack_start(proj_lbl, False, False, 0)
+
+        preview = s.get("preview", "")
+        if preview:
+            prev_lbl = Gtk.Label()
+            prev_lbl.set_markup(
+                f'<span foreground="{p["subtext1"]}" size="small">'
+                f'{GLib.markup_escape_text(preview)}</span>'
+            )
+            prev_lbl.set_xalign(0)
+            prev_lbl.set_line_wrap(True)
+            prev_lbl.set_max_width_chars(60)
+            left.pack_start(prev_lbl, False, False, 0)
+
+        hbox.pack_start(left, True, True, 0)
+
+        # Right: time
+        time_lbl = Gtk.Label()
+        time_lbl.set_markup(
+            f'<span foreground="{p["dim"]}" size="small">'
+            f'{GLib.markup_escape_text(s.get("time_str", ""))}</span>'
+        )
+        time_lbl.set_valign(Gtk.Align.CENTER)
+        hbox.pack_end(time_lbl, False, False, 0)
+
+        return hbox
+
+    def _on_filter_changed(self, entry):
+        self._filter_text = entry.get_text()
+        self._rebuild_list()
+
+    def _on_sort_changed(self, combo):
+        self._sort_key = combo.get_active_id() or "mtime"
+        self._rebuild_list()

tools-gui/tabs/tools_tab.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Tools Tab — Tool usage breakdown + skill usage."""
+
+import sys
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import GLib, Gtk
+
+sys.path.insert(0, str(Path.home() / "Projekte" / "ClaudeCodePanel"))
+from theme import get_palette
+from monitor import get_top_tools, get_skill_usage, get_missed_skills_summary
+
+
+class ToolsTab(Gtk.Box):
+    """Tool + skill usage display."""
+
+    def __init__(self):
+        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        self.set_margin_top(12)
+        self.set_margin_start(12)
+        self.set_margin_end(12)
+
+        self._tools_box = None
+        self._skills_box = None
+        self._missed_box = None
+
+        self._build_ui()
+
+    def _build_ui(self):
+        p = get_palette()
+
+        # --- Tool usage ---
+        tools_lbl = Gtk.Label()
+        tools_lbl.set_markup('<b>Tool Usage (Today)</b>')
+        tools_lbl.set_halign(Gtk.Align.START)
+        tools_lbl.get_style_context().add_class("section-title")
+        self.pack_start(tools_lbl, False, False, 0)
+
+        self._tools_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        self._tools_box.get_style_context().add_class("base-card")
+        self.pack_start(self._tools_box, False, False, 0)
+
+        # --- Skill usage ---
+        skills_lbl = Gtk.Label()
+        skills_lbl.set_markup('<b>Skill Usage (Today)</b>')
+        skills_lbl.set_halign(Gtk.Align.START)
+        skills_lbl.get_style_context().add_class("section-title")
+        self.pack_start(skills_lbl, False, False, 0)
+
+        self._skills_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        self._skills_box.get_style_context().add_class("base-card")
+        self.pack_start(self._skills_box, False, False, 0)
+
+        # --- Missed skills ---
+        missed_lbl = Gtk.Label()
+        missed_lbl.set_markup('<b>Missed Skills</b>')
+        missed_lbl.set_halign(Gtk.Align.START)
+        missed_lbl.get_style_context().add_class("section-title")
+        self.pack_start(missed_lbl, False, False, 0)
+
+        self._missed_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        self._missed_box.get_style_context().add_class("base-card")
+        self.pack_start(self._missed_box, False, False, 0)
+
+    def refresh(self) -> None:
+        """Reload tool/skill data from monitor.py."""
+        p = get_palette()
+
+        # Tool usage
+        self._clear_box(self._tools_box)
+        tools = get_top_tools(n=15)
+        if tools:
+            max_count = tools[0][1] if tools else 1
+            for name, count in tools:
+                row = self._build_bar_row(name, count, max_count, p["accent"], p)
+                self._tools_box.pack_start(row, False, False, 0)
+        else:
+            self._add_empty(self._tools_box, "No tool data yet", p)
+        self._tools_box.show_all()
+
+        # Skill usage
+        self._clear_box(self._skills_box)
+        skills = get_skill_usage(days=1)
+        if skills:
+            # Flatten today's skills
+            from datetime import datetime
+            today = datetime.now().strftime("%Y-%m-%d")
+            today_skills = skills.get(today, {})
+            if today_skills:
+                sorted_skills = sorted(today_skills.items(), key=lambda x: -x[1])
+                max_s = sorted_skills[0][1] if sorted_skills else 1
+                for name, count in sorted_skills:
+                    row = self._build_bar_row(name, count, max_s, p["mauve"], p)
+                    self._skills_box.pack_start(row, False, False, 0)
+            else:
+                self._add_empty(self._skills_box, "No skills used today", p)
+        else:
+            self._add_empty(self._skills_box, "No skill data yet", p)
+        self._skills_box.show_all()
+
+        # Missed skills
+        self._clear_box(self._missed_box)
+        missed = get_missed_skills_summary()
+        if missed:
+            for name, count in missed[:8]:
+                row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+                name_lbl = Gtk.Label()
+                name_lbl.set_markup(f'<tt>{GLib.markup_escape_text(name)}</tt>')
+                name_lbl.set_xalign(0)
+                name_lbl.set_width_chars(20)
+                row.pack_start(name_lbl, False, False, 0)
+                count_lbl = Gtk.Label()
+                count_lbl.set_markup(
+                    f'<span foreground="{p["red"]}" size="small">{count} missed</span>'
+                )
+                row.pack_end(count_lbl, False, False, 0)
+                self._missed_box.pack_start(row, False, False, 0)
+        else:
+            self._add_empty(self._missed_box, "No missed skills", p)
+        self._missed_box.show_all()
+
+    def _build_bar_row(self, name: str, count: int, max_count: int, bar_color: str, p: dict) -> Gtk.Box:
+        """Build a row with name, count, and a proportional bar."""
+        row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+
+        name_lbl = Gtk.Label()
+        name_lbl.set_markup(f'<tt>{GLib.markup_escape_text(name)}</tt>')
+        name_lbl.set_xalign(0)
+        name_lbl.set_width_chars(20)
+        row.pack_start(name_lbl, False, False, 0)
+
+        # Visual bar
+        bar = Gtk.DrawingArea()
+        frac = count / max_count if max_count > 0 else 0
+        bar.set_size_request(max(4, int(frac * 150)), 12)
+        bar.connect("draw", self._draw_mini_bar, bar_color)
+        bar.set_valign(Gtk.Align.CENTER)
+        row.pack_start(bar, False, False, 0)
+
+        count_lbl = Gtk.Label()
+        count_lbl.set_markup(
+            f'<span foreground="{p["overlay"]}" font_family="monospace" size="small">{count}</span>'
+        )
+        row.pack_start(count_lbl, False, False, 0)
+
+        return row
+
+    @staticmethod
+    def _draw_mini_bar(widget, cr, color_hex):
+        width = widget.get_allocated_width()
+        height = widget.get_allocated_height()
+        r = int(color_hex[1:3], 16) / 255
+        g = int(color_hex[3:5], 16) / 255
+        b = int(color_hex[5:7], 16) / 255
+        cr.set_source_rgba(r, g, b, 0.6)
+        # Rounded rectangle
+        radius = 3
+        cr.arc(radius, radius, radius, 3.14159, 1.5 * 3.14159)
+        cr.arc(width - radius, radius, radius, 1.5 * 3.14159, 0)
+        cr.arc(width - radius, height - radius, radius, 0, 0.5 * 3.14159)
+        cr.arc(radius, height - radius, radius, 0.5 * 3.14159, 3.14159)
+        cr.close_path()
+        cr.fill()
+        return False
+
+    @staticmethod
+    def _clear_box(box):
+        for child in box.get_children():
+            box.remove(child)
+
+    @staticmethod
+    def _add_empty(box, text, p):
+        lbl = Gtk.Label()
+        lbl.set_markup(f'<span foreground="{p["dim"]}">{text}</span>')
+        box.pack_start(lbl, False, False, 0)

utils.py

@@ -0,0 +1,33 @@
+"""Shared utilities for Claude Code Control Panel."""
+
+import os
+from pathlib import Path
+
+from gi.repository import GLib
+
+# Cached constants — avoid per-call computation
+HOME = str(Path.home())
+CLK_TCK: int = os.sysconf("SC_CLK_TCK")
+
+
+def idle_once(fn, *args):
+    """Schedule fn(*args) as a one-shot GLib.idle_add (won't re-schedule)."""
+    def _wrapper():
+        fn(*args)
+        return False
+    GLib.idle_add(_wrapper)
+
+
+def short_name_from_path(cwd: str) -> str:
+    """Extract short project name from a path.
+
+    Examples:
+        "/home/smlflg"                          → "Home"
+        "/home/smlflg/Projekte/ClaudeCodePanel" → "ClaudeCodePanel"
+        "/home/smlflg/Erdhügel"                 → "Erdhügel"
+        "/media/smlflg/writable"                → "writable"
+    """
+    if cwd == HOME or not cwd:
+        return "Home"
+    last = cwd.rstrip("/").rsplit("/", 1)[-1]
+    return last if last else "Home"