Initial public upload from Projekte/CodexDashBoard

.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/CodexDashBoard", "--enable-web-dashboard", "false", "--open-web-dashboard", "false", "--enable-gui-log-window", "false"]
+cwd = "/home/smlflg/Projekte/CodexDashBoard"
+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/CodexDashBoard"
+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/CodexDashBoard"
+enabled = true
+startup_timeout_sec = 120
+tool_timeout_sec = 180

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+dist/
+build/
+*.egg-info/
+*.log
+

.hermes/plans/2026-04-22_155500-codex-dashboard-100-punkte-plan.md

@@ -0,0 +1,254 @@
+# CodexDashBoard — 100-Punkte-Plan v2
+
+> Für Hermes: Dies ist ein priorisierter Arbeitsplan für das Projekt. Fokus: lokal nutzbar machen, System-Dependencies stabilisieren, Packaging fertigziehen, echte Dashboard-Funktionen verdrahten und den Scope Codex-first halten.
+
+Ziel:
+Ein lokal installierbares, stabiles Linux-Dashboard für Codex auf Linux bauen, das Sessions, Prozesse und Logs zuverlässig zeigt. Claude-nahe Funktionen werden in v0.2 nur unterstützt, wenn sie klar optional sind oder vollständig fertig implementiert werden.
+
+Architektur:
+Read-only Data Layer, GTK3-UI, klare Trennung zwischen Datenzugriff, Prozessbeobachtung und UI-Rendering. Packaging so aufsetzen, dass Dev ohne GUI-Stack funktioniert und GUI mit expliziten System-Dependencies sauber installierbar ist. Import- und Startup-Pfade müssen auch ohne `gi` kontrolliert und mit verständlicher Fehlermeldung enden.
+
+Tech Stack:
+Python >=3.10 (laut `pyproject.toml`), GTK3/PyGObject, SQLite, systemd user service, Desktop launcher, pytest.
+
+Prioritäten:
+- P0: Packaging, import-sicherer Startup, Codex-Kernviews (Sessions/Processes/Logs), README-Installationsgenauigkeit
+- P1: Tray, systemd, Desktop-Datei, Operability auf Pop!_OS/Ubuntu
+- P2: Claude/Agent-Ops/Recovery nur optional oder vollständig fertig
+
+---
+
+## Phase 1 — Produktbild und Scope klären
+
+1. Projektziel in einem Satz formulieren.
+2. Scope-Gate setzen: v0.2 ist Codex-first.
+3. Entscheiden: Claude-Views für v0.2 verstecken, entfernen oder vollständig liefern.
+4. Zielnutzer definieren: nur lokal auf Linux.
+5. v0.2-Scope mit P0/P1/P2 festlegen.
+6. Nicht-Ziele explizit auflisten.
+7. Read-only-Grenze definieren.
+8. Erlaubte Side-Effects definieren.
+9. Recovery-Use-Cases definieren.
+10. Erfolgskriterien für „lokal nutzbar“ messbar festlegen.
+
+## Phase 2 — Dependency-Triage
+
+11. Aktuelle Installationsfehler dokumentieren.
+12. Fehlende Systempakete für PyGObject bestätigen.
+13. Prüfen, welches Paket `girepository-2.0` liefert.
+14. Prüfen, welches Paket `gobject-introspection-1.0` liefert.
+15. Prüfen, ob `pkg-config` vorhanden ist.
+16. Prüfen, ob `libgtk-3-dev` nötig ist.
+17. Prüfen, ob `libcairo2-dev` nötig ist.
+18. Prüfen, ob Ayatana-Indikator-Dev-Pakete nötig sind.
+19. Installationsmatrix für Ubuntu/Pop!_OS notieren.
+20. Minimal- vs Voll-Installationspfad definieren.
+
+## Phase 3 — Packaging stabilisieren
+
+21. Python-Dev-Install ohne GUI verifizieren.
+22. GUI-Extrastruktur in `pyproject.toml` prüfen.
+23. Optionales Extra `gui` beibehalten oder anpassen.
+24. Optionales Extra `dev` prüfen.
+25. Optionales Extra `all` erwägen.
+26. README-Installationspfade vereinheitlichen.
+27. System-Dependencies in README ergänzen.
+28. Installationsfehler mit klaren Hinweisen dokumentieren.
+29. `pip install -e '.[gui]'` nach Dependency-Fix testen.
+30. Paket-Metadaten auf Konsistenz prüfen.
+
+## Phase 4 — Runtime-Robustheit
+
+31. Entry-Point so umbauen, dass fehlendes `gi` nicht beim Import crasht.
+32. Freundliche Fehlermeldung bei fehlendem GTK ergänzen.
+33. Freundliche Fehlermeldung bei fehlendem Ayatana ergänzen.
+34. Startverhalten ohne Tray sauber definieren.
+35. Startverhalten ohne Codex-DB sauber definieren.
+36. Startverhalten ohne Claude-Verzeichnisse sauber definieren.
+37. Logging-Pfade verifizieren.
+38. Singleton-Lock-Verhalten testen.
+39. Fehlerdialog oder Terminal-Output-Strategie festlegen.
+40. App-Start ohne Crashes verifizieren.
+
+## Phase 5 — Datenmodell prüfen
+
+41. `codex_data.py` vollständig gegen echtes DB-Schema prüfen.
+42. `claude_data.py` gegen echte Dateistrukturen prüfen.
+43. Ungültige JSON/JSONL-Dateien robuster behandeln.
+44. Leere Felder im Datenmodell sauber normalisieren.
+45. Zeitstempel-Fallbacks vereinheitlichen.
+46. Suchfelder für Threads prüfen.
+47. Suchfelder für Claude-Tasks prüfen.
+48. Log-Limits und Sortierung validieren.
+49. Große Datenmengen auf Performance prüfen.
+50. Read-only-Verträge im Code dokumentieren.
+
+## Phase 6 — UI-Verdrahtung und Scope-Entscheidung
+
+51. Alle angelegten Views in `app.py` inventarisieren.
+52. Alle referenzierten aber undefinierten Callbacks in `app.py` finden.
+53. Alle fehlenden Refresh-Methoden in `app.py` finden.
+54. Alle fehlenden Render-Methoden in `app.py` finden.
+55. Entscheiden: unfertige Claude-Views in v0.2 verstecken/entfernen.
+56. Falls behalten: `Claude Tasks`-View vollständig verdrahten.
+57. Falls behalten: `Agent Ops`- und `Recovery`-View vollständig verdrahten.
+58. Sichtbarkeitsbasiertes Refresh für alle Tabs einführen.
+59. Statuszeile pro View konsistent aktualisieren.
+60. Leere Zustände für jede View gestalten.
+
+## Phase 7 — Prozesse und Process Monitor
+
+61. Prozess-Keywords auf Relevanz prüfen.
+62. Falsch-positive Prozessmatches minimieren.
+63. Entscheiden: `Agent Ops` behalten oder als `Process Monitor` benennen.
+64. Sortierung nach stale/ram/cpu validieren.
+65. Prozessdetails um CWD und Uptime verlässlich machen.
+66. Safe-terminate-Flow mit Bestätigung testen.
+67. Prozessliste periodisch refreshen.
+68. Falls behalten: Familienstatistik mit klaren Acceptance Criteria ergänzen.
+69. Stale-Prozesse visuell hervorheben.
+70. Recovery-Hinweise aus Prozessstatus ableiten.
+
+## Phase 8 — Sessions, Logs, Tasks
+
+71. Overview-Metriken exakt definieren und dann umsetzen.
+72. Sessions-Liste für Codex optimieren.
+73. Falls Claude in Scope: Claude-Sessions optional einblendbar machen.
+74. Logs-Suche auf definierte Felder und Sortierung festlegen.
+75. Log-Detailansicht mit Acceptance Criteria definieren.
+76. Task-Gruppierung pro Projekt testen.
+77. Blocked/Active/Completed visuell unterscheiden.
+78. Event-Zusammenfassungen mit Maxlänge/Fallback-Regeln definieren.
+79. Quick-Actions pro Session prüfen.
+80. Open-folder/resume-Aktionen absichern.
+
+## Phase 9 — Tests und Verifikation
+
+81. Fehlende Tests für `claude_data.py` hinzufügen.
+82. Tests für Packaging-Extras erweitern.
+83. Tests für Runtime-Importfehler und fehlendes `gi` ergänzen.
+84. Tests für leere/malformte Claude-Dateien ergänzen.
+85. Smoke-Test/Guard für fehlende UI-Callbacks und Methoden ergänzen.
+86. Tests für Prozess-Familienzuordnung ergänzen.
+87. Tests für Recovery-Hinweise ergänzen.
+88. `pytest -q` als Basis-Check etablieren.
+89. `python3 -m compileall src tests` als Check etablieren.
+90. Manuelle Smoke-Checkliste für GUI erstellen.
+
+## Phase 10 — Distribution und Polishing
+
+91. systemd-User-Service als Basis-Operability testen.
+92. Desktop-Datei als Basis-Operability validieren.
+93. Icon/Name/Klassen konsistent machen.
+94. README-Screenshots oder Text-Flow verbessern.
+95. Installationsanleitung für Pop!_OS ergänzen.
+96. Troubleshooting-Sektion schreiben.
+97. Konkurrenzvergleich in Produktpositionierung übersetzen.
+98. v0.2-Milestone mit Prioritäten festziehen.
+99. Release-Checkliste definieren.
+100. Erste lokal nutzbare Beta mit klarem Scope schneiden.
+
+---
+
+## Kompakte Checkliste zum Abhaken
+
+[ ] 1. Produktziel klar
+[ ] 2. Codex-first Scope gesetzt
+[ ] 3. Claude-Support entschieden
+[ ] 4. Linux-Ziel klar
+[ ] 5. v0.2-Scope mit Prioritäten definiert
+[ ] 6. Nicht-Ziele definiert
+[ ] 7. Read-only-Regeln definiert
+[ ] 8. Side-Effects definiert
+[ ] 9. Recovery-Use-Cases klar
+[ ] 10. Erfolgskriterien messbar
+[ ] 11. Installationsfehler dokumentiert
+[ ] 12. GI-Root-Cause bestätigt
+[ ] 13. `girepository-2.0` Paket gefunden
+[ ] 14. `gobject-introspection-1.0` Paket gefunden
+[ ] 15. `pkg-config` geprüft
+[ ] 16. GTK-Dev-Bedarf geprüft
+[ ] 17. Cairo-Dev-Bedarf geprüft
+[ ] 18. Ayatana-Bedarf geprüft
+[ ] 19. Paketmatrix notiert
+[ ] 20. Minimal/Voll-Pfad definiert
+[ ] 21. Dev-Install ok
+[ ] 22. `gui`-Extra geprüft
+[ ] 23. `gui`-Extra sinnvoll
+[ ] 24. `dev`-Extra sinnvoll
+[ ] 25. `all`-Extra bewertet
+[ ] 26. README konsistent
+[ ] 27. Sysdeps dokumentiert
+[ ] 28. Fehlermeldungen dokumentiert
+[ ] 29. GUI-Install getestet
+[ ] 30. Metadaten konsistent
+[ ] 31. Import ohne `gi` crasht nicht
+[ ] 32. GTK-Fehler freundlich
+[ ] 33. Ayatana-Fehler freundlich
+[ ] 34. Kein-Tray-Verhalten ok
+[ ] 35. Keine-Codex-DB ok
+[ ] 36. Keine-Claude-Daten ok
+[ ] 37. Logging ok
+[ ] 38. Lock ok
+[ ] 39. Fehlerstrategie klar
+[ ] 40. Start ohne Crash
+[ ] 41. Codex-Schema geprüft
+[ ] 42. Claude-Dateien geprüft
+[ ] 43. JSON-Fehler robust
+[ ] 44. Leere Felder sauber
+[ ] 45. Zeitstempel sauber
+[ ] 46. Thread-Suche validiert
+[ ] 47. Task-Suche validiert
+[ ] 48. Logs validiert
+[ ] 49. Performance geprüft
+[ ] 50. Read-only dokumentiert
+[ ] 51. Views inventarisiert
+[ ] 52. Fehlende Callbacks gefunden
+[ ] 53. Fehlende Refreshes gefunden
+[ ] 54. Fehlende Renderer gefunden
+[ ] 55. Unfertige Claude-Views entschieden
+[ ] 56. Claude Tasks ggf. fertig
+[ ] 57. Agent Ops/Recovery ggf. fertig
+[ ] 58. Sichtbarkeits-Refresh komplett
+[ ] 59. Statuszeile konsistent
+[ ] 60. Empty States gut
+[ ] 61. Keywords geprüft
+[ ] 62. False Positives reduziert
+[ ] 63. Monitor-Begriff entschieden
+[ ] 64. Sortierung validiert
+[ ] 65. Details verlässlich
+[ ] 66. Terminate-Flow sicher
+[ ] 67. Prozess-Refresh ok
+[ ] 68. Familienstatistik klar definiert
+[ ] 69. Stale-Hinweise gut
+[ ] 70. Recovery aus Prozessen ableitbar
+[ ] 71. Overview-Metriken definiert
+[ ] 72. Sessions gut
+[ ] 73. Claude-Sessions ggf. steuerbar
+[ ] 74. Logs-Suche spezifiziert
+[ ] 75. Log-Detailansicht klar
+[ ] 76. Task-Gruppierung ok
+[ ] 77. Statusfarben sinnvoll
+[ ] 78. Event-Summaries spezifiziert
+[ ] 79. Quick-Actions geprüft
+[ ] 80. Resume/Open abgesichert
+[ ] 81. Claude-Tests da
+[ ] 82. Packaging-Tests erweitert
+[ ] 83. Importfehler-Tests da
+[ ] 84. Malformed-Datei-Tests da
+[ ] 85. UI-Smoke-Guard da
+[ ] 86. Prozess-Familien-Tests da
+[ ] 87. Recovery-Tests da
+[ ] 88. Pytest-Check etabliert
+[ ] 89. Compileall-Check etabliert
+[ ] 90. GUI-Smoke-Checkliste da
+[ ] 91. systemd getestet
+[ ] 92. Desktop-Datei validiert
+[ ] 93. Naming konsistent
+[ ] 94. README verbessert
+[ ] 95. Pop!_OS-Guide da
+[ ] 96. Troubleshooting da
+[ ] 97. Positionierung klar
+[ ] 98. Milestone fest
+[ ] 99. Release-Checkliste da
+[ ] 100. Beta gebaut

.hermes/plans/2026-04-22_155500-codex-dashboard-p0-v3.md

@@ -0,0 +1,103 @@
+# CodexDashBoard — P0-Plan v3
+
+> Fokus: nur der kritische Pfad bis zu einer lokal nutzbaren, stabil startbaren CodexDashBoard-Basis.
+
+Ziel:
+Eine lokal installierbare Linux-App, die ohne Import-Crash startet, klare Fehlermeldungen bei fehlenden GUI-Systemabhängigkeiten zeigt und die Kernansichten Sessions, Prozesse und Logs für Codex zuverlässig bereitstellt.
+
+Definition of Done für P0:
+- `python3 -m pip install -e '.[dev]'` funktioniert
+- README dokumentiert nötige Systempakete für GUI
+- Start ohne `gi` crasht nicht beim Import, sondern endet mit verständlicher Meldung
+- Start mit erfüllten Abhängigkeiten öffnet die App
+- Codex-Kernviews funktionieren: Overview, Sessions, Processes, Logs
+- `python3 -m pytest -q` grün
+- `python3 -m compileall src tests` grün
+
+Kritischer Pfad:
+1. Scope einfrieren
+2. Dependency-Root-Cause dokumentieren
+3. Import-sicheren Startup bauen
+4. README/Packaging angleichen
+5. Kernviews verifizieren
+6. Tests ergänzen
+7. Smoke-Test durchführen
+
+---
+
+## Die ersten 10 Tasks zum sofort Ausführen
+
+### Task 1 — Scope einfrieren
+Acceptance Criteria:
+- v0.2 ist Codex-first schriftlich festgehalten
+- Unfertige Claude-Views sind als out-of-scope oder optional markiert
+
+### Task 2 — GUI-Systemabhängigkeiten exakt ermitteln
+Acceptance Criteria:
+- Liste der nötigen apt-Pakete steht fest
+- `girepository-2.0` Root Cause ist dokumentiert
+
+### Task 3 — README um Systempakete ergänzen
+Acceptance Criteria:
+- README enthält einen GUI-Install-Block für Pop!_OS/Ubuntu
+- README trennt klar zwischen `.[dev]` und `.[gui]`
+
+### Task 4 — Entry-Point gegen `gi`-Import-Crash absichern
+Acceptance Criteria:
+- `python3 -m codex_dashboard` ohne `gi` zeigt verständliche Fehlermeldung
+- Prozess endet kontrolliert mit non-zero exit code
+
+### Task 5 — App-Importstruktur bereinigen
+Acceptance Criteria:
+- `__main__.py` importiert nicht unkontrolliert GTK-lastige Module
+- GUI-Importe passieren erst im geschützten Startup-Pfad
+
+### Task 6 — No-GUI-Startup testen
+Acceptance Criteria:
+- automatischer Test deckt fehlendes `gi` ab
+- Fehlermeldung ist stabil und verständlich
+
+### Task 7 — Kernviews inventarisieren und Scope kürzen
+Acceptance Criteria:
+- Für P0 bleiben nur Overview, Sessions, Processes, Logs aktiv
+- Nicht fertige Views sind versteckt oder entfernt
+
+### Task 8 — Kernviews manuell durchtesten
+Acceptance Criteria:
+- Keine Crashes beim Wechsel zwischen Kernviews
+- Leere Zustände funktionieren ohne Daten
+
+### Task 9 — Test-Suite und Compileall grün halten
+Acceptance Criteria:
+- `python3 -m pytest -q` grün
+- `python3 -m compileall src tests` grün
+
+### Task 10 — P0-Smoke-Checkliste abhaken
+Acceptance Criteria:
+- Installation dokumentiert
+- Startpfade verifiziert
+- Kernviews verifiziert
+- bekannte Restpunkte notiert
+
+---
+
+## P0-Checkliste
+
+[ ] 1. v0.2 Codex-first eingefroren
+[ ] 2. Claude-Views Scope-Entscheidung getroffen
+[ ] 3. GI-Systempakete identifiziert
+[ ] 4. README-Systempakete ergänzt
+[ ] 5. Dev/GUI-Install sauber getrennt
+[ ] 6. `gi`-Import-Crash verhindert
+[ ] 7. Freundliche Fehlermeldung vorhanden
+[ ] 8. Entry-Point abgesichert
+[ ] 9. Kernviews auf P0 reduziert
+[ ] 10. Overview funktioniert
+[ ] 11. Sessions funktioniert
+[ ] 12. Processes funktioniert
+[ ] 13. Logs funktioniert
+[ ] 14. Leere Zustände funktionieren
+[ ] 15. Tests grün
+[ ] 16. Compileall grün
+[ ] 17. Smoke-Test grün
+[ ] 18. Restpunkte dokumentiert

.hermes_async/jobs/audit-2026-05-03-codexdashboard-crash-risk/result.json

@@ -0,0 +1,60 @@
+{
+  "job_id": "audit-2026-05-03-codexdashboard-crash-risk",
+  "status": "succeeded_bounded_pass_2",
+  "objective": "Implement crash-risk regression tests, startup fanout fixes, service throttling, process-scan determinism, and refresh coalescing without starting GUI or systemd service.",
+  "changed_files": [
+    "/home/smlflg/Projekte/CodexDashBoard/tests/test_crash_safety.py",
+    "/home/smlflg/Projekte/CodexDashBoard/tests/test_processes.py",
+    "/home/smlflg/Projekte/CodexDashBoard/src/codex_dashboard/codex_data.py",
+    "/home/smlflg/Projekte/CodexDashBoard/src/codex_dashboard/app.py",
+    "/home/smlflg/Projekte/CodexDashBoard/src/codex_dashboard/processes.py",
+    "/home/smlflg/Projekte/CodexDashBoard/systemd/codex-dashboard.service",
+    "/home/smlflg/Projekte/CodexDashBoard/.hermes_async/jobs/audit-2026-05-03-codexdashboard-crash-risk/result.json"
+  ],
+  "tests_run": [
+    {
+      "command": "python -m pytest tests/test_crash_safety.py -q",
+      "red_status_before_fix": "4 failed, 1 passed",
+      "failure_modes": [
+        "locked DB path exceeded 0.75s",
+        "CodexDashboard.__init__ called refresh_all",
+        "refresh_all refreshed every view at once",
+        "systemd service had Restart=on-failure RestartSec=5 / Burst=5"
+      ]
+    },
+    {
+      "command": "python -m pytest tests/test_processes.py::test_scan_processes_reads_proc_metadata_for_live_ps -q",
+      "red_status_before_fix": "failed: live ps scan returned cwd='' because read_proc_metadata was disabled after ps_output was populated",
+      "green_status_after_fix": "1 passed"
+    },
+    {
+      "command": "python -m pytest tests/test_crash_safety.py::test_refresh_methods_use_in_flight_guard_instead_of_raw_threads tests/test_crash_safety.py::test_in_flight_guard_discards_key_when_refresh_done -q",
+      "red_status_before_fix": "2 failed: refresh methods used raw _run_bg and _run_refresh_once helper did not exist",
+      "green_status_after_fix": "2 passed"
+    },
+    {
+      "command": "python -m pytest -q && python -m compileall -q src tests",
+      "status": "passed",
+      "summary": "16 passed in 0.28s; compileall passed"
+    }
+  ],
+  "fixes": [
+    "Reduced SQLite read-only timeout from 0.35s to 0.05s so locked DB refresh fails fast.",
+    "Changed startup from refresh_all() to _refresh_visible() to avoid constructor fanout across all views.",
+    "Changed refresh_all() to delegate to _refresh_visible() rather than refreshing all views at once.",
+    "Added _refresh_in_flight set and _run_refresh_once() so duplicate refresh requests per view are coalesced while a worker is active.",
+    "Updated refresh_overview, refresh_sessions, refresh_processes, and refresh_logs to use _run_refresh_once instead of raw _run_bg.",
+    "Made scan_processes(ps_output=...) deterministic by not reading live /proc metadata for supplied test ps output.",
+    "Preserved live scan /proc metadata by tracking whether ps_output was originally supplied before populating it from subprocess.run.",
+    "Changed user service restart throttling from RestartSec=5/StartLimitBurst=5 to RestartSec=30/StartLimitBurst=3."
+  ],
+  "root_cause_status": "bounded_verified_not_full_crash_verified",
+  "verifier_note": "Regression-test and code-level crash-risk claims are verified. The historical PC crash remains not fully root-cause-proven because no GUI/service run and no kernel/OOM/journal evidence were collected.",
+  "remaining_risks": [
+    "No real GTK GUI smoke test was run, intentionally, to avoid reproducing the reported PC crash.",
+    "No journalctl/kernel/OOM logs were inspected, so the historical PC crash remains unproven.",
+    "Coalescing is protected by static/AST tests; a future controlled GUI or fake-GTK runtime test would increase confidence."
+  ],
+  "human_review_needed": true,
+  "next_action": "Review diff. If acceptable, run a controlled headless/GUI smoke in a guarded environment before enabling or starting the user service."
+}

README.md

@@ -0,0 +1,57 @@
+# CodexDashBoard
+
+Lightweight native dashboard for Codex on Linux.
+
+The goal is not to clone the existing Claude Code panel. This project keeps the
+surface small and stable:
+
+- recent Codex threads from `~/.codex/state_5.sqlite`
+- Codex-related processes
+- recent Codex logs
+- quick actions for resume, open folder, refresh, and safe process stop
+
+Current v0.2 scope is Codex-first. Unfinished Claude-specific views are not part
+of the shipped P0 UI.
+
+## GUI System Dependencies
+
+On Ubuntu / Pop!_OS install the required GTK / GI development packages first:
+
+```bash
+sudo apt-get update
+sudo apt-get install -y \
+  libgirepository-2.0-dev \
+  gobject-introspection \
+  libgtk-3-dev \
+  libcairo2-dev \
+  pkg-config
+```
+
+## Run
+
+```bash
+cd /home/smlflg/Projekte/CodexDashBoard
+python3 -m pip install -e '.[gui]'
+python3 -m codex_dashboard
+```
+
+## Test
+
+```bash
+cd /home/smlflg/Projekte/CodexDashBoard
+python3 -m pip install -e '.[dev]'
+python3 -m pytest
+python3 -m compileall src tests
+```
+
+## Install As User Service
+
+```bash
+cp systemd/codex-dashboard.service ~/.config/systemd/user/
+cp desktop/codex-dashboard.desktop ~/.local/share/applications/
+systemctl --user daemon-reload
+systemctl --user enable --now codex-dashboard.service
+```
+
+The app logs to `~/.cache/codex-dashboard.log`.
+

artifacts/codex-audit/repo-audit.md

@@ -0,0 +1,53 @@
+# Repo audit: CodexDashBoard
+
+Job: work-2026-05-04-codexdashboard-audit
+Scope: read-only audit of /home/smlflg/Projekte/CodexDashBoard; source code not intentionally modified.
+
+## Repository shape
+
+CodexDashBoard is a small Python GTK3 desktop dashboard for Codex on Linux. The shipped UI is Codex-first with Overview, Sessions, Processes, and Logs views.
+
+Key files inspected:
+- README.md: documents GUI system packages, editable install, tests, and user service install.
+- docs/PLAN.md: defines v1 scope and stability rules.
+- pyproject.toml: package metadata; Python >=3.10; optional extras `gui` = PyGObject and `dev` = pytest.
+- src/codex_dashboard/app.py: GTK UI, tray integration, refresh orchestration, process stop/resume/open-folder actions.
+- src/codex_dashboard/codex_data.py: read-only SQLite data access for Codex state/logs.
+- src/codex_dashboard/processes.py: ps/proc process scanner and SIGTERM helper.
+- src/codex_dashboard/bootstrap.py: startup guard for missing GTK/PyGObject imports.
+- src/codex_dashboard/claude_data.py: Claude data helpers present but not wired into current P0 UI.
+- tests/: 5 test modules covering data access, process scanning, startup packaging, crash-safety invariants.
+- systemd/codex-dashboard.service and desktop/codex-dashboard.desktop: local-path launch entries.
+
+## Commands run
+
+- `python3 -m pytest` from repo root: PASSED, 16 tests.
+- `python3 -m compileall -q src tests` from repo root: PASSED.
+- `git status --short` from repo root: repository contents appear untracked in this checkout, so git cannot currently distinguish source changes from baseline.
+
+## Main findings
+
+1. Current tests pass quickly and cover several previous crash-risk themes: missing/locked SQLite DBs, refresh fan-out control, restart policy, optional GUI dependency, and WebKit exclusion.
+2. The data layer is intentionally tolerant: missing or locked Codex DBs return empty results/stats rather than crashing, using SQLite URI read-only mode and a very short timeout.
+3. The GUI keeps refreshes scoped to the visible view and uses `_refresh_in_flight` guards to avoid concurrent duplicate refreshes.
+4. Potentially unfinished code remains in `claude_data.py`; README/PLAN say Claude-specific views are outside shipped P0 UI, but this module is not tested and could confuse future maintenance.
+5. Process scanning still includes broad non-Codex keywords such as `claude`, `gemini`, and MCP servers despite the product being Codex-first. This may be intentional context, but it broadens the blast radius for display and termination actions.
+6. GUI behavior is mostly untested because tests avoid importing GTK. That is useful for headless CI but leaves click wiring, row rendering, dialogs, tray behavior, search debounce behavior, and xdg-open/resume flows uncovered.
+7. Packaging/install assets are hard-coded to `/home/smlflg/Projekte/CodexDashBoard`, which works for this machine but is brittle if copied, relocated, or packaged.
+8. Error handling favors silent empty lists for SQLite errors. This prevents crashes but may hide schema drift, permission issues, or corrupted databases from the user.
+9. The repo appears not to have tracked files in this checkout (`git status --short` reports all inspected content as untracked). That makes auditability and future change review risky.
+
+## High-value next tasks
+
+1. Add schema-drift tests and visible error reporting for Codex SQLite access.
+2. Add headless GTK/unit tests or an adapter layer for UI render and action wiring.
+3. Narrow and document process matching/termination scope for Codex-first behavior.
+4. Replace hard-coded install paths with templated/generated service and desktop entries.
+5. Decide whether to remove, hide behind feature flags, or test/document `claude_data.py`.
+
+## Audit limitations
+
+- No dependency installation was performed.
+- No GUI was launched to avoid side effects in a desktop session.
+- No commits, pushes, deletes, or source edits were performed intentionally.
+- Git baseline is unclear because the checkout reports all files as untracked.

artifacts/codex-audit/result.json

@@ -0,0 +1,42 @@
+{
+  "job_id": "work-2026-05-04-codexdashboard-audit",
+  "status": "complete",
+  "objective": "Read-only audit of /home/smlflg/Projekte/CodexDashBoard: identify unfinished/risky areas, missing tests, brittle code paths, and top 5 high-value next tasks.",
+  "changed_files": [
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/repo-audit.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/top-tasks.json",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/test-gaps.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/risk-scan.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/result.json"
+  ],
+  "artifact_paths": [
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/repo-audit.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/top-tasks.json",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/test-gaps.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/risk-scan.md",
+    "/home/smlflg/Projekte/CodexDashBoard/artifacts/codex-audit/result.json"
+  ],
+  "verifier": {
+    "command": "test -s artifacts/codex-audit/repo-audit.md && test -s artifacts/codex-audit/top-tasks.json && test -s artifacts/codex-audit/test-gaps.md && test -s artifacts/codex-audit/risk-scan.md && test -s artifacts/codex-audit/result.json",
+    "exit_code": 0
+  },
+  "passed_checks": [
+    "python3 -m pytest: 16 passed",
+    "python3 -m compileall -q src tests: passed",
+    "required artifact verifier: passed"
+  ],
+  "failed_checks": [],
+  "top_next_actions": [
+    "Add Codex SQLite schema-drift coverage and user-visible data errors",
+    "Introduce testable UI adapter seams for GTK actions and row rendering",
+    "Tighten and document process matching and termination scope",
+    "Make service and desktop launch assets relocatable",
+    "Resolve Claude helper module status"
+  ],
+  "needs_human": false,
+  "next_action": "Parent/owner should review artifacts and choose one of the top-ranked tasks; no further worker action pending.",
+  "notes": [
+    "No dependencies were installed and no GUI was launched.",
+    "Git status showed all repo content as untracked in this checkout, limiting baseline auditability."
+  ]
+}

artifacts/codex-audit/risk-scan.md

@@ -0,0 +1,92 @@
+# Risk scan
+
+## Risk level summary
+
+Overall observed risk: moderate.
+
+The codebase is small and has useful crash-safety tests, but several risks remain around silent data failures, GUI code not covered by tests, broad process matching connected to termination actions, hard-coded local install paths, and unclear repository tracking state.
+
+## Findings
+
+### R1. Silent SQLite failures can mask broken data access
+
+Severity: high
+Files: src/codex_dashboard/codex_data.py, src/codex_dashboard/app.py
+
+`list_threads`, `get_stats`, and `list_logs` catch FileNotFoundError/sqlite3.Error and return empty results. This protects the UI from crashes and is consistent with stability rules, but a schema change or permission/corruption issue appears identical to "no data". The UI currently renders empty-state rows/status messages rather than explicit degraded-state diagnostics.
+
+Recommended next step: preserve crash-safety while returning/reporting a lightweight error state that the UI can show and tests can assert.
+
+### R2. Process scanner has broad matching connected to stop actions
+
+Severity: high
+Files: src/codex_dashboard/processes.py, src/codex_dashboard/app.py
+
+The dashboard is documented as Codex-first, but `PROCESS_KEYWORDS` includes Claude, Gemini, OpenCode, and MCP terms. The Processes view exposes a stop button for every scanned item after a confirmation dialog. Broad substring matching can produce false positives or include non-Codex tools unexpectedly.
+
+Recommended next step: define a family/stoppable policy, make Codex the safest default, and add false-positive tests.
+
+### R3. GUI action paths are brittle and mostly untested
+
+Severity: medium-high
+Files: src/codex_dashboard/app.py
+
+GTK-specific rendering, tray integration, status updates, and button callbacks are not directly tested. Important subprocess paths include `xdg-open`, `codex resume`, and optional `kitty`. `_open_path` has no OSError guard; `_resume_thread` guards OSError after constructing commands.
+
+Recommended next step: extract side-effect adapters or command builders so they can be tested without launching GUI processes.
+
+### R4. Hard-coded local paths in install assets
+
+Severity: medium
+Files: systemd/codex-dashboard.service, desktop/codex-dashboard.desktop, README.md
+
+Service and desktop files point to `/home/smlflg/Projekte/CodexDashBoard`. This is acceptable for a personal local checkout but risky for reuse, relocation, or packaging. It can also become stale if the repo moves.
+
+Recommended next step: generate these files from templates or document them as local examples only.
+
+### R5. Untracked repository state reduces auditability
+
+Severity: medium
+Evidence: `git status --short` reported all repository contents as untracked.
+
+Because files are not tracked in this checkout, future audits cannot reliably use git diffs to separate intentional changes, generated files, or stale artifacts. This also makes it hard to verify that this read-only audit did not alter non-artifact files beyond command-generated caches.
+
+Recommended next step: establish a clean tracked baseline or intentionally document this as an unversioned local project.
+
+### R6. Claude helper module is unfinished relative to product scope
+
+Severity: medium
+Files: src/codex_dashboard/claude_data.py, docs/PLAN.md, README.md
+
+The plan says unfinished Claude-specific views stay hidden/out of scope. `claude_data.py` is still substantial and untested. It may be harmless dead code, but it adds maintenance and future regression surface.
+
+Recommended next step: remove it, mark it as experimental, or add tests if it is expected to remain maintained.
+
+### R7. Singleton lock uses fixed /tmp path
+
+Severity: low-medium
+Files: src/codex_dashboard/paths.py, src/codex_dashboard/app.py
+
+`LOCK_PATH = /tmp/codex-dashboard.lock` is simple but global per host/user namespace rather than per-user runtime directory. On multi-user systems or stale lock edge cases, behavior may be surprising. `flock` mitigates stale lock content because locks release with fd close, but path placement is still coarse.
+
+Recommended next step: consider XDG_RUNTIME_DIR or a per-user lock path.
+
+### R8. No explicit lint/static typing configuration
+
+Severity: low
+Files: pyproject.toml
+
+There is no ruff/mypy/pyright configuration. The small codebase may not need it yet, but GTK callback-heavy code benefits from static checks and import hygiene.
+
+Recommended next step: add lightweight linting once dependency/tooling policy is decided.
+
+## Positive controls observed
+
+- Tests pass: 16/16.
+- Compileall passes for src and tests.
+- PyGObject is optional in packaging, improving headless testability.
+- Startup has a friendly missing-GI message.
+- SQLite is opened read-only with a short timeout.
+- Refreshes are limited to visible views and guarded against duplicate in-flight work.
+- Process stop asks for confirmation.
+- systemd restart policy includes a non-aggressive RestartSec and burst limit.

artifacts/codex-audit/test-gaps.md

@@ -0,0 +1,70 @@
+# Test gaps
+
+## Existing test coverage observed
+
+Test modules inspected:
+- tests/test_codex_data.py
+- tests/test_processes.py
+- tests/test_startup.py
+- tests/test_packaging.py
+- tests/test_crash_safety.py
+
+Commands run:
+- `python3 -m pytest`: 16 passed.
+- `python3 -m compileall -q src tests`: passed.
+
+Covered areas:
+- Codex thread listing hides archived sessions by default.
+- Archived search path works.
+- Missing state DB returns zero stats.
+- Locked SQLite DBs return quickly without exceptions.
+- Process scanner filters simple ps output and reads /proc metadata in mocked live mode.
+- Uptime formatting.
+- Optional GUI dependency packaging.
+- Missing GI/GTK startup message.
+- Refresh fan-out and in-flight guards via AST tests.
+- systemd restart policy guard.
+- WebKit exclusion.
+
+## Important gaps
+
+1. GUI behavior is mostly untested.
+   - No tests instantiate/render rows under GTK.
+   - No tests validate button wiring for resume/open-folder/stop.
+   - No tests cover tray menu behavior, close-to-tray behavior, or status text transitions.
+   - No tests cover search entry behavior beyond data-layer query filtering.
+
+2. SQLite schema-drift handling is under-tested.
+   - The locked-DB test uses a minimal table that triggers sqlite errors safely, but there are no explicit tests for real Codex schema changes.
+   - Missing columns, renamed columns, null-heavy rows, unexpected timestamp units, or invalid token types are not separately asserted.
+   - `list_logs` has no normal-path fixture test for logs_2.sqlite structure.
+
+3. Silent failure behavior is untested from the UI perspective.
+   - Data functions return empty lists/stats on sqlite errors. No tests assert whether the UI can tell "no sessions" apart from "database unreadable".
+
+4. Process matching false positives are under-tested.
+   - Current tests use simple positive/negative lines.
+   - No tests cover command arguments, paths, or filenames containing keywords accidentally.
+   - No tests define which process families should be stoppable in a Codex-first dashboard.
+
+5. Destructive process action is minimally covered.
+   - `terminate_process` directly sends SIGTERM, but no tests cover `_confirm_stop` wiring with mocked dialog response and mocked termination.
+   - No test ensures the app never stops its own dashboard process from the UI list beyond scanner-level filtering.
+
+6. Packaging/install behavior is lightly checked only.
+   - No tests for desktop entry correctness beyond WebKit absence.
+   - No tests that hard-coded service paths match current repo or installed package entry points.
+   - No console_scripts entry point exists to test.
+
+7. Claude data helpers have no tests.
+   - `claude_data.py` includes JSON, JSONL, grouping, stats, session, and event parsing helpers but is not covered by the current test suite.
+   - If this module stays in scope, it needs malformed-input and large-directory tests. If it is intentionally out of P0 scope, the repo should clarify that.
+
+## Suggested next test additions
+
+- `tests/test_logs_data.py`: fixture logs database; normal listing, search, missing/corrupt DB behavior.
+- `tests/test_schema_drift.py`: expected Codex schema variants; missing/renamed columns; invalid/null values.
+- `tests/test_process_false_positives.py`: keyword-in-path/argument cases and family/stoppable policy.
+- `tests/test_ui_actions.py`: command construction and stop confirmation with GTK/subprocess/os.kill mocked or moved behind adapter functions.
+- `tests/test_install_assets.py`: service/desktop paths, relocatability assumptions, package launch entry point if added.
+- `tests/test_claude_data.py` only if Claude helpers remain maintained code.

artifacts/codex-audit/top-tasks.json

@@ -0,0 +1,79 @@
+[
+  {
+    "rank": 1,
+    "title": "Add Codex SQLite schema-drift coverage and user-visible data errors",
+    "why": "The app currently converts FileNotFoundError/sqlite3.Error into empty lists or zero stats. That prevents crashes but can silently hide DB schema changes, permission failures, or corrupt data.",
+    "suggested_checks": [
+      "test missing expected columns in threads/logs tables",
+      "test malformed timestamp/token fields",
+      "test UI/status layer can distinguish no data from data access error"
+    ],
+    "files_to_touch_later": [
+      "src/codex_dashboard/codex_data.py",
+      "src/codex_dashboard/app.py",
+      "tests/test_codex_data.py",
+      "tests/test_crash_safety.py"
+    ]
+  },
+  {
+    "rank": 2,
+    "title": "Introduce testable UI adapter seams for GTK actions and row rendering",
+    "why": "Headless tests cover startup/import safety but not most GUI behavior: buttons, dialogs, row contents, tray menu, refresh status updates, or xdg-open/resume command construction.",
+    "suggested_checks": [
+      "unit-test command construction for resume/open-folder without launching processes",
+      "test stop action confirmation path with mocked terminate_process",
+      "test visible-child refresh routing and status text behavior"
+    ],
+    "files_to_touch_later": [
+      "src/codex_dashboard/app.py",
+      "tests/"
+    ]
+  },
+  {
+    "rank": 3,
+    "title": "Tighten and document process matching and termination scope",
+    "why": "The process scanner is used by a UI with stop buttons, but it matches broad keywords including claude, gemini, opencode, and MCP servers although the product is described as Codex-first.",
+    "suggested_checks": [
+      "test false-positive commands such as filenames or arguments containing codex/claude substrings",
+      "add family filters or safer default for stoppable processes",
+      "document why non-Codex families are included if retained"
+    ],
+    "files_to_touch_later": [
+      "src/codex_dashboard/processes.py",
+      "src/codex_dashboard/app.py",
+      "tests/test_processes.py"
+    ]
+  },
+  {
+    "rank": 4,
+    "title": "Make service and desktop launch assets relocatable",
+    "why": "systemd and desktop files contain hard-coded absolute paths for this checkout. That is brittle for other users, relocated clones, or packaging.",
+    "suggested_checks": [
+      "generate files from templates or document local-only nature",
+      "test ExecStart/Exec paths are not stale",
+      "consider console_scripts entry point for installed package launch"
+    ],
+    "files_to_touch_later": [
+      "pyproject.toml",
+      "systemd/codex-dashboard.service",
+      "desktop/codex-dashboard.desktop",
+      "README.md"
+    ]
+  },
+  {
+    "rank": 5,
+    "title": "Resolve Claude helper module status",
+    "why": "README and PLAN say unfinished Claude-specific views are not shipped, yet src/codex_dashboard/claude_data.py remains substantial and untested. This increases maintenance surface and ambiguity.",
+    "suggested_checks": [
+      "decide keep/remove/feature-flag",
+      "if kept, add focused tests for malformed JSONL, bad task JSON, and large directories",
+      "make README explicitly state why Claude data helpers exist"
+    ],
+    "files_to_touch_later": [
+      "src/codex_dashboard/claude_data.py",
+      "tests/",
+      "README.md",
+      "docs/PLAN.md"
+    ]
+  }
+]

artifacts/codex-implement/sqlite-error-tests/diff-summary.md

@@ -0,0 +1,26 @@
+# Diff summary
+
+Implemented narrow SQLite DB error visibility coverage and minimal production seam.
+
+Changed files:
+- `src/codex_dashboard/codex_data.py`
+  - Added `DataAccessError` and `DataResult` result seam.
+  - Added `list_threads_result()` and `list_logs_result()` to preserve non-crashing list APIs while exposing schema/data access errors to callers.
+  - Added optional `DashboardStats.error` so stats schema drift is distinguishable from a missing/empty database.
+  - Missing DB remains non-error empty/zero state for existing behavior.
+- `src/codex_dashboard/app.py`
+  - Session refresh now uses `list_threads_result()` and shows `Session database error: ...` when a DB/schema error is reported.
+  - Log refresh now uses `list_logs_result()` and shows `Log database error: ...` when a DB/schema error is reported.
+- `tests/test_codex_data.py`
+  - Added failing-first schema drift and malformed row coverage for Codex state.sqlite.
+  - Added stats schema drift error visibility coverage.
+- `tests/test_logs_data.py`
+  - Added normal logs_2.sqlite fixture/search coverage.
+  - Added logs schema drift error visibility coverage.
+- `tests/test_data_error_visibility.py`
+  - Added AST-level guard that session/log refresh code distinguishes DB errors from empty data.
+
+TDD evidence:
+- Initial focused test run after writing tests failed with missing `list_threads_result` / `list_logs_result` imports.
+- After minimal source changes, focused tests passed: `10 passed in 0.08s`.
+- Full validation passed: `23 passed in 0.32s`; compileall passed.

artifacts/codex-implement/sqlite-error-tests/result.json

@@ -0,0 +1,37 @@
+{
+  "job_id": "work-2026-05-04-codexdashboard-sqlite-error-tests",
+  "status": "completed",
+  "repo": "/home/smlflg/Projekte/CodexDashBoard",
+  "tdd": {
+    "failing_tests_first": {
+      "command": "python3 -m pytest tests/test_codex_data.py tests/test_logs_data.py tests/test_data_error_visibility.py",
+      "exit_code": 2,
+      "expected_failure": "ImportError: missing list_threads_result and list_logs_result before implementation"
+    },
+    "focused_tests": {
+      "command": "python3 -m pytest tests/test_codex_data.py tests/test_logs_data.py tests/test_data_error_visibility.py",
+      "exit_code": 0,
+      "result": "10 passed in 0.08s"
+    },
+    "full_suite": {
+      "command": "python3 -m pytest && python3 -m compileall -q src tests",
+      "exit_code": 0,
+      "result": "23 passed in 0.32s; compileall passed"
+    }
+  },
+  "files_modified": [
+    "src/codex_dashboard/codex_data.py",
+    "src/codex_dashboard/app.py",
+    "tests/test_codex_data.py"
+  ],
+  "files_created": [
+    "tests/test_logs_data.py",
+    "tests/test_data_error_visibility.py",
+    "artifacts/codex-implement/sqlite-error-tests/result.json",
+    "artifacts/codex-implement/sqlite-error-tests/diff-summary.md"
+  ],
+  "notes": [
+    "No commit, push, merge, dependency install, or unrelated refactor performed.",
+    "Repository baseline appears untracked in git status; changes were limited to allowed paths."
+  ]
+}

artifacts/codex-validate/sqlite-tests-validation.json

@@ -0,0 +1,114 @@
+{
+  "job_id": "work-2026-05-04-codexdashboard-validate-sqlite-tests",
+  "status": "validated",
+  "validated_at": "2026-05-04",
+  "objective": "Validate that adding tests for SQLite schema drift / visible DB errors is narrow enough and identify exact files/tests. No implementation.",
+  "repo": "/home/smlflg/Projekte/CodexDashBoard",
+  "audit_input": "artifacts/codex-audit/result.json",
+  "current_checks": [
+    {
+      "command": "python3 -m pytest",
+      "exit_code": 0,
+      "result": "16 passed in 0.28s"
+    }
+  ],
+  "evidence": [
+    "Audit top task rank 1 is 'Add Codex SQLite schema-drift coverage and user-visible data errors'.",
+    "src/codex_dashboard/codex_data.py:list_threads catches FileNotFoundError/sqlite3.Error and returns []; get_stats returns zero DashboardStats; list_logs returns [].",
+    "src/codex_dashboard/app.py refresh handlers treat returned empty lists/stats as successful refreshes and render 'No Codex sessions found' or 'No Codex logs found', so DB errors are not currently distinguishable from no data.",
+    "tests/test_codex_data.py currently covers normal state.sqlite listing and missing stats DB only.",
+    "tests/test_crash_safety.py currently covers locked/minimal DB returning empty quickly, but not real schema drift, malformed values, normal logs DB, or visible DB error state."
+  ],
+  "recommended_scope": {
+    "size": "small_to_medium",
+    "narrow_enough": true,
+    "summary": "Keep the implementation limited to Codex SQLite data access error reporting and focused data-layer/UI-status tests. Do not combine with process matching, launch assets, GTK action refactors, or Claude helper cleanup.",
+    "phases": [
+      "Add focused failing tests for state.sqlite schema drift and logs_2.sqlite fixtures.",
+      "Add/adjust a minimal data-access result/error seam so SQLite schema/permission/corruption failures remain crash-safe but are visible to callers.",
+      "Add a narrow UI/status test seam or AST-level guard proving sessions/log refresh can present a data-access error distinct from empty data."
+    ],
+    "out_of_scope": [
+      "GTK row rendering and button behavior beyond DB-error status visibility",
+      "process scanner false-positive policy",
+      "systemd/desktop relocatability",
+      "Claude data helpers",
+      "dependency installation or broad GUI integration testing"
+    ],
+    "production_code_likely_needs_change": true,
+    "production_change_reason": "Tests can be added first, but user-visible DB errors cannot pass with tests alone because current codex_data functions collapse sqlite3.Error into empty results/zero stats and app.py marks those refreshes successful. A minimal non-crashing error state or result wrapper is likely needed."
+  },
+  "files_to_touch": [
+    {
+      "path": "src/codex_dashboard/codex_data.py",
+      "purpose": "Likely add minimal error-reporting/data-result seam while preserving no-crash behavior for FileNotFoundError/sqlite3.Error."
+    },
+    {
+      "path": "src/codex_dashboard/app.py",
+      "purpose": "Likely teach refresh/status layer to distinguish empty data from data access errors for sessions/logs/overview."
+    },
+    {
+      "path": "tests/test_codex_data.py",
+      "purpose": "Add focused state.sqlite schema drift, malformed/null field, and stats error tests."
+    },
+    {
+      "path": "tests/test_logs_data.py",
+      "purpose": "New focused logs_2.sqlite fixture tests for normal list_logs/search and logs schema drift/corrupt DB handling."
+    },
+    {
+      "path": "tests/test_crash_safety.py",
+      "purpose": "Optionally keep/add crash-safety regression that DB failures return quickly and never raise; avoid broadening this file into schema fixture coverage."
+    },
+    {
+      "path": "tests/test_data_error_visibility.py",
+      "purpose": "Optional new narrow test module for app/status seam if UI visibility is not covered in codex_data tests."
+    }
+  ],
+  "tests_to_add": [
+    {
+      "file": "tests/test_codex_data.py",
+      "test": "test_list_threads_schema_drift_missing_timestamp_columns_reports_data_error",
+      "intent": "Create a threads table missing created_at_ms/updated_at_ms and/or created_at/updated_at expected by the SELECT; assert the failure is represented as a data access error, not silently indistinguishable from no sessions."
+    },
+    {
+      "file": "tests/test_codex_data.py",
+      "test": "test_list_threads_schema_drift_missing_search_columns_reports_data_error",
+      "intent": "Create a threads table missing title/first_user_message/cwd/git_branch and assert query/listing does not crash and exposes schema drift."
+    },
+    {
+      "file": "tests/test_codex_data.py",
+      "test": "test_list_threads_malformed_tokens_or_timestamps_are_bounded",
+      "intent": "Use non-integer/null-heavy tokens_used and timestamp fields; assert either safe coercion or explicit row/data error behavior is defined and tested."
+    },
+    {
+      "file": "tests/test_codex_data.py",
+      "test": "test_get_stats_schema_drift_reports_error_without_exception",
+      "intent": "Assert get_stats preserves crash safety while exposing database/schema failure instead of only DashboardStats(0,0,0,0,None)."
+    },
+    {
+      "file": "tests/test_logs_data.py",
+      "test": "test_list_logs_reads_codex_logs_fixture_and_searches",
+      "intent": "Create logs table with id, ts, ts_nanos, level, target, thread_id, module_path, feedback_log_body; assert ordering, timestamp ms conversion, shortening/search."
+    },
+    {
+      "file": "tests/test_logs_data.py",
+      "test": "test_list_logs_schema_drift_missing_expected_columns_reports_data_error",
+      "intent": "Create logs table missing module_path or feedback_log_body/ts_nanos; assert no exception and visible error state."
+    },
+    {
+      "file": "tests/test_data_error_visibility.py",
+      "test": "test_session_refresh_status_distinguishes_database_error_from_no_sessions",
+      "intent": "Using a headless seam/mocked data function or extracted presenter, assert DB error maps to an error/degraded status rather than '0 sessions' and 'No Codex sessions found'."
+    },
+    {
+      "file": "tests/test_data_error_visibility.py",
+      "test": "test_log_refresh_status_distinguishes_database_error_from_no_logs",
+      "intent": "Using the same seam, assert logs DB error maps to visible error status rather than '0 log rows' and 'No Codex logs found'."
+    }
+  ],
+  "verifier_command": "test -s artifacts/codex-validate/sqlite-tests-validation.json",
+  "notes": [
+    "No source code was changed by this validation worker.",
+    "The artifact recommends exact implementation/test scope only; it does not implement tests or production changes."
+  ]
+}

artifacts/codex-verify/sqlite-error-tests/result.json

@@ -0,0 +1,37 @@
+{
+  "job_id": "work-2026-05-04-codexdashboard-independent-verify",
+  "status": "passed",
+  "changed_files": [
+    "src/codex_dashboard/codex_data.py",
+    "src/codex_dashboard/app.py",
+    "tests/test_codex_data.py",
+    "tests/test_logs_data.py",
+    "tests/test_data_error_visibility.py",
+    "artifacts/codex-implement/sqlite-error-tests/result.json",
+    "artifacts/codex-implement/sqlite-error-tests/diff-summary.md"
+  ],
+  "checks": {
+    "repo_path": "/home/smlflg/Projekte/CodexDashBoard",
+    "git_diff_inspected": true,
+    "git_diff_note": "Repository has no HEAD commit; git status shows repository contents untracked, so changed_files were verified from implementation artifact and file inspection rather than a HEAD diff.",
+    "allowed_scope": true,
+    "pytest": {
+      "command": "python3 -m pytest",
+      "passed": true,
+      "result": "23 passed in 0.34s"
+    },
+    "compileall": {
+      "command": "python3 -m compileall -q src tests",
+      "passed": true
+    },
+    "implementation_artifacts_exist": true,
+    "error_visibility_covered": true,
+    "error_visibility_notes": [
+      "codex_data exposes DataResult/DataAccessError and preserves legacy empty-list behavior for missing databases.",
+      "tests cover state.sqlite schema drift, malformed token conversion, stats schema drift, logs_2.sqlite schema drift, normal log fixture/search behavior, and AST guards that session/log refresh status reports database errors separately from empty data.",
+      "app.py refresh_sessions and refresh_logs set explicit Session/Log database error status messages when result.error is present."
+    ]
+  },
+  "failed_checks": [],
+  "recommendation": "Accept implementation. Required verifier command passed, artifacts are present, and SQLite data-access errors are surfaced and tested for sessions/logs with data-layer coverage for state/log schema drift. Note: repository has no HEAD baseline, so independent scope verification is based on inspected files and implementation artifact rather than a git diff."
+}

desktop/codex-dashboard.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Name=Codex Dashboard
+Comment=Lightweight panel for Codex sessions, processes, and logs
+Exec=env PYTHONPATH=/home/smlflg/Projekte/CodexDashBoard/src python3 -m codex_dashboard
+Icon=utilities-system-monitor
+Terminal=false
+Type=Application
+Categories=Development;Utility;
+Keywords=codex;dashboard;panel;ai;
+StartupWMClass=codex-dashboard
+

docs/PLAN.md

@@ -0,0 +1,33 @@
+# CodexDashBoard Plan
+
+## Product Shape
+
+Build a smaller, steadier dashboard than the current Claude Code panel.
+
+CodexDashBoard should answer four questions quickly:
+
+- What is Codex doing right now?
+- What did I work on recently?
+- Which processes are alive or stale?
+- Where are the relevant logs?
+
+## v1 Scope
+
+- Native GTK3 app.
+- Sidebar navigation instead of many equal tabs.
+- Read-only access to Codex SQLite databases.
+- v0.2 ships Codex-first views only: Overview, Sessions, Processes, Logs.
+- Unfinished Claude-specific views stay hidden or out of scope until they are complete.
+- No WebKit embed.
+- No Claude settings, Claude hooks, swarm views, brightness tools, or unrelated
+  panels.
+- Process kill actions only with confirmation.
+
+## Stability Rules
+
+- Data layer must work without GTK.
+- Missing or locked Codex DBs must not crash the UI.
+- Poll visible views only.
+- Keep refreshes explicit and low-frequency.
+- Log errors to `~/.cache/codex-dashboard.log`.
+

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "codex-dashboard"
+version = "0.1.0"
+description = "Lightweight GTK dashboard for Codex sessions and processes"
+requires-python = ">=3.10"
+dependencies = []
+
+[project.optional-dependencies]
+gui = [
+  "PyGObject>=3.42",
+]
+dev = [
+  "pytest>=8",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

src/codex_dashboard/__init__.py

@@ -0,0 +1,4 @@
+"""Lightweight Codex dashboard package."""
+
+__version__ = "0.1.0"
+

src/codex_dashboard/__main__.py

@@ -0,0 +1,6 @@
+from .bootstrap import run
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())
+

src/codex_dashboard/app.py

@@ -0,0 +1,737 @@
+from __future__ import annotations
+
+import fcntl
+import logging
+import os
+import shutil
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+gi.require_version("Gdk", "3.0")
+from gi.repository import Gdk, GLib, Gtk, Pango
+
+try:
+    gi.require_version("AyatanaAppIndicator3", "0.1")
+    from gi.repository import AyatanaAppIndicator3
+except (ImportError, ValueError):
+    AyatanaAppIndicator3 = None
+
+from .codex_data import (
+    DashboardStats,
+    ThreadSummary,
+    format_time,
+    format_tokens,
+    list_logs_result,
+    list_threads,
+    list_threads_result,
+    get_stats,
+)
+from .paths import CACHE_LOG, CONFIG_TOML, LOCK_PATH
+from .processes import ProcessInfo, format_uptime, scan_processes, terminate_process
+
+
+log = logging.getLogger("codex_dashboard")
+_lock_file = None
+
+
+CSS = b"""
+window {
+  background: #0f172a;
+  color: #e2e8f0;
+}
+.topbar {
+  background: #111827;
+  border-bottom: 1px solid #1f2937;
+  padding: 10px 12px;
+}
+.app-title {
+  font-size: 18px;
+  font-weight: 700;
+  color: #f8fafc;
+}
+.muted {
+  color: #94a3b8;
+}
+.panel {
+  background: #0f172a;
+}
+.stat {
+  background: #111827;
+  border: 1px solid #1f2937;
+  border-radius: 10px;
+  padding: 12px;
+}
+.stat-value {
+  font-size: 22px;
+  font-weight: 700;
+  color: #f8fafc;
+}
+.badge,
+.badge-ok,
+.badge-warn,
+.badge-idle {
+  border-radius: 999px;
+  padding: 4px 10px;
+  font-weight: 600;
+}
+.badge {
+  background: #1e293b;
+  color: #cbd5e1;
+}
+.badge-ok {
+  background: #123a2b;
+  color: #86efac;
+}
+.badge-warn {
+  background: #3f2a12;
+  color: #fcd34d;
+}
+.badge-idle {
+  background: #1f2937;
+  color: #cbd5e1;
+}
+.row {
+  border: 1px solid transparent;
+  border-bottom: 1px solid #1e293b;
+  border-radius: 8px;
+  padding: 10px 12px;
+}
+.row:hover {
+  background: #111827;
+  border-color: #334155;
+}
+button {
+  border-radius: 8px;
+}
+entry {
+  border-radius: 8px;
+  background: #111827;
+  color: #e2e8f0;
+}
+"""
+
+
+def _setup_logging() -> None:
+    CACHE_LOG.parent.mkdir(parents=True, exist_ok=True)
+    logging.basicConfig(
+        filename=str(CACHE_LOG),
+        level=logging.INFO,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+
+
+def _acquire_singleton_lock() -> None:
+    global _lock_file
+    fd = os.open(LOCK_PATH, os.O_CREAT | os.O_WRONLY, 0o644)
+    _lock_file = os.fdopen(fd, "w")
+    try:
+        fcntl.flock(_lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        _lock_file.truncate(0)
+        _lock_file.write(str(os.getpid()))
+        _lock_file.flush()
+    except BlockingIOError:
+        log.warning("CodexDashBoard already running")
+        raise SystemExit(0)
+
+
+def _label(text: str = "", *, xalign: float = 0.0, css: str | None = None) -> Gtk.Label:
+    label = Gtk.Label(label=text, xalign=xalign)
+    label.set_ellipsize(Pango.EllipsizeMode.END)
+    if css:
+        label.get_style_context().add_class(css)
+    return label
+
+
+def _button(icon_name: str, tooltip: str) -> Gtk.Button:
+    button = Gtk.Button.new_from_icon_name(icon_name, Gtk.IconSize.BUTTON)
+    button.set_tooltip_text(tooltip)
+    return button
+
+
+def _clear_list(list_box: Gtk.ListBox) -> None:
+    for child in list_box.get_children():
+        list_box.remove(child)
+
+
+def _run_bg(work, done) -> None:
+    def worker():
+        try:
+            result = work()
+        except Exception as exc:  # pragma: no cover - UI guard
+            log.exception("background task failed")
+            result = exc
+        GLib.idle_add(done, result)
+
+    threading.Thread(target=worker, daemon=True).start()
+
+
+def _open_path(path: str | Path) -> None:
+    subprocess.Popen(["xdg-open", str(path)], start_new_session=True)
+
+
+class CodexDashboard(Gtk.Window):
+    def __init__(self) -> None:
+        super().__init__(title="CodexDashBoard")
+        self.set_default_size(940, 640)
+        self.set_resizable(True)
+        self.set_wmclass("codex-dashboard", "CodexDashBoard")
+
+        self._tray_indicator = None
+        self._session_query = ""
+        self._log_query = ""
+        self._include_archived = False
+
+        self._stats_labels: dict[str, Gtk.Label] = {}
+        self._refresh_in_flight: set[str] = set()
+        self._overview_sessions = Gtk.ListBox()
+        self._overview_processes = Gtk.ListBox()
+        self._sessions_list = Gtk.ListBox()
+        self._processes_list = Gtk.ListBox()
+        self._logs_list = Gtk.ListBox()
+        self._status = _label("Ready", css="muted")
+
+        self._setup_css()
+        self._build_ui()
+        self._build_tray()
+        self.connect("delete-event", self._on_delete)
+
+        GLib.timeout_add_seconds(30, self._refresh_visible)
+        self._refresh_visible()
+
+    def _setup_css(self) -> None:
+        provider = Gtk.CssProvider()
+        provider.load_from_data(CSS)
+        screen = Gdk.Screen.get_default()
+        Gtk.StyleContext.add_provider_for_screen(
+            screen,
+            provider,
+            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
+        )
+
+    def _build_ui(self) -> None:
+        root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+        self.add(root)
+
+        topbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
+        topbar.get_style_context().add_class("topbar")
+        root.pack_start(topbar, False, False, 0)
+
+        title = _label("CodexDashBoard", css="app-title")
+        topbar.pack_start(title, False, False, 0)
+        topbar.pack_start(self._status, True, True, 0)
+
+        config_button = _button("emblem-system-symbolic", "Open Codex config")
+        config_button.connect("clicked", lambda *_: _open_path(CONFIG_TOML))
+        topbar.pack_end(config_button, False, False, 0)
+
+        refresh_button = _button("view-refresh-symbolic", "Refresh")
+        refresh_button.connect("clicked", lambda *_: self.refresh_all())
+        topbar.pack_end(refresh_button, False, False, 0)
+
+        body = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
+        root.pack_start(body, True, True, 0)
+
+        self.stack = Gtk.Stack()
+        self.stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
+        self.stack.set_transition_duration(120)
+        self.stack.connect("notify::visible-child-name", lambda *_: self._refresh_visible())
+
+        sidebar = Gtk.StackSidebar()
+        sidebar.set_stack(self.stack)
+        sidebar.set_size_request(150, -1)
+        body.pack_start(sidebar, False, False, 0)
+        body.pack_start(self.stack, True, True, 0)
+
+        self.stack.add_titled(self._build_overview(), "overview", "Overview")
+        self.stack.add_titled(self._build_sessions(), "sessions", "Sessions")
+        self.stack.add_titled(self._build_processes(), "processes", "Processes")
+        self.stack.add_titled(self._build_logs(), "logs", "Logs")
+
+    def _build_overview(self) -> Gtk.Widget:
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.get_style_context().add_class("panel")
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
+        box.set_margin_top(14)
+        box.set_margin_bottom(14)
+        box.set_margin_start(14)
+        box.set_margin_end(14)
+        scrolled.add(box)
+
+        stats = Gtk.Grid(column_spacing=10, row_spacing=10)
+        box.pack_start(stats, False, False, 0)
+        for idx, (key, label_text) in enumerate(
+            [
+                ("threads", "Threads"),
+                ("recent", "Updated Last Hour"),
+                ("tokens", "Tokens"),
+                ("processes", "Agent Processes"),
+            ]
+        ):
+            card = self._stat_card(label_text)
+            stats.attach(card, idx % 3, idx // 3, 1, 1)
+            self._stats_labels[key] = card.value_label
+
+        box.pack_start(_label("Letzte 10 Codex Sessions", css="app-title"), False, False, 0)
+        box.pack_start(self._overview_sessions, False, False, 0)
+        box.pack_start(_label("Active Processes", css="app-title"), False, False, 0)
+        box.pack_start(self._overview_processes, False, False, 0)
+        return scrolled
+
+    def _stat_card(self, label_text: str) -> Gtk.Box:
+        card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+        card.get_style_context().add_class("stat")
+        card.set_hexpand(True)
+        value = _label("-", css="stat-value")
+        label = _label(label_text, css="muted")
+        card.pack_start(value, False, False, 0)
+        card.pack_start(label, False, False, 0)
+        card.value_label = value  # type: ignore[attr-defined]
+        return card
+
+    def _build_sessions(self) -> Gtk.Widget:
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        box.set_margin_top(10)
+        box.set_margin_bottom(10)
+        box.set_margin_start(10)
+        box.set_margin_end(10)
+
+        controls = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+        search = Gtk.SearchEntry()
+        search.set_placeholder_text("Search title, cwd, branch")
+        search.connect("search-changed", self._on_session_search)
+        controls.pack_start(search, True, True, 0)
+
+        archived = Gtk.CheckButton(label="Archived")
+        archived.connect("toggled", self._on_archived_toggled)
+        controls.pack_end(archived, False, False, 0)
+        box.pack_start(controls, False, False, 0)
+
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.add(self._sessions_list)
+        box.pack_start(scrolled, True, True, 0)
+        return box
+
+    def _build_processes(self) -> Gtk.Widget:
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        box.set_margin_top(10)
+        box.set_margin_bottom(10)
+        box.set_margin_start(10)
+        box.set_margin_end(10)
+        hint = _label(
+            "Codex-related processes. Stop actions ask first.",
+            css="muted",
+        )
+        box.pack_start(hint, False, False, 0)
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.add(self._processes_list)
+        box.pack_start(scrolled, True, True, 0)
+        return box
+
+    def _build_logs(self) -> Gtk.Widget:
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        box.set_margin_top(10)
+        box.set_margin_bottom(10)
+        box.set_margin_start(10)
+        box.set_margin_end(10)
+        search = Gtk.SearchEntry()
+        search.set_placeholder_text("Search logs")
+        search.connect("search-changed", self._on_log_search)
+        box.pack_start(search, False, False, 0)
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.add(self._logs_list)
+        box.pack_start(scrolled, True, True, 0)
+        return box
+
+    def _build_tray(self) -> None:
+        if AyatanaAppIndicator3 is None:
+            return
+        indicator = AyatanaAppIndicator3.Indicator.new(
+            "codex-dashboard",
+            "utilities-system-monitor",
+            AyatanaAppIndicator3.IndicatorCategory.APPLICATION_STATUS,
+        )
+        indicator.set_status(AyatanaAppIndicator3.IndicatorStatus.ACTIVE)
+        indicator.set_title("CodexDashBoard")
+
+        menu = Gtk.Menu()
+        show_item = Gtk.MenuItem(label="Show")
+        show_item.connect("activate", lambda *_: self._show_window())
+        menu.append(show_item)
+
+        refresh_item = Gtk.MenuItem(label="Refresh")
+        refresh_item.connect("activate", lambda *_: self.refresh_all())
+        menu.append(refresh_item)
+
+        menu.append(Gtk.SeparatorMenuItem())
+
+        quit_item = Gtk.MenuItem(label="Quit")
+        quit_item.connect("activate", lambda *_: Gtk.main_quit())
+        menu.append(quit_item)
+
+        menu.show_all()
+        indicator.set_menu(menu)
+        self._tray_indicator = indicator
+
+    def _show_window(self) -> None:
+        self.show_all()
+        self.present()
+
+    def _on_delete(self, *_args) -> bool:
+        if self._tray_indicator is not None:
+            self.hide()
+            return True
+        Gtk.main_quit()
+        return False
+
+    def _on_session_search(self, entry: Gtk.SearchEntry) -> None:
+        self._session_query = entry.get_text()
+        self.refresh_sessions()
+
+    def _on_archived_toggled(self, button: Gtk.CheckButton) -> None:
+        self._include_archived = button.get_active()
+        self.refresh_sessions()
+
+    def _on_log_search(self, entry: Gtk.SearchEntry) -> None:
+        self._log_query = entry.get_text()
+        self.refresh_logs()
+
+    def _refresh_visible(self) -> bool:
+        name = self.stack.get_visible_child_name()
+        if name == "sessions":
+            self.refresh_sessions()
+        elif name == "processes":
+            self.refresh_processes()
+        elif name == "logs":
+            self.refresh_logs()
+        else:
+            self.refresh_overview()
+        return True
+
+    def refresh_all(self) -> None:
+        self._refresh_visible()
+
+    def _run_refresh_once(self, key: str, work, done) -> None:
+        if key in self._refresh_in_flight:
+            self._set_status(f"{key.title()} refresh already running")
+            return
+        self._refresh_in_flight.add(key)
+
+        def wrapped_done(result):
+            try:
+                return done(result)
+            finally:
+                self._refresh_in_flight.discard(key)
+
+        _run_bg(work, wrapped_done)
+
+    def refresh_overview(self) -> None:
+        def work():
+            return get_stats(), list_threads(limit=10), scan_processes()
+
+        def done(result):
+            if isinstance(result, Exception):
+                self._set_status("Refresh failed")
+                return False
+            stats, threads, processes = result
+            self._render_overview(stats, threads, processes)
+            self._set_status("Overview refreshed")
+            return False
+
+        self._run_refresh_once("overview", work, done)
+
+    def refresh_sessions(self) -> None:
+        def work():
+            return list_threads_result(
+                query=self._session_query,
+                include_archived=self._include_archived,
+                limit=120,
+            )
+
+        def done(result):
+            if isinstance(result, Exception):
+                self._set_status("Session refresh failed")
+                return False
+            if result.error is not None:
+                self._render_threads(self._sessions_list, result.data)
+                self._set_status(f"Session database error: {result.error.message}")
+                return False
+            self._render_threads(self._sessions_list, result.data)
+            self._set_status(f"{len(result.data)} sessions")
+            return False
+
+        self._run_refresh_once("sessions", work, done)
+
+    def refresh_processes(self) -> None:
+        def done(result):
+            if isinstance(result, Exception):
+                self._set_status("Process refresh failed")
+                return False
+            self._render_processes(self._processes_list, result, full=True)
+            self._set_status(f"{len(result)} processes")
+            return False
+
+        self._run_refresh_once("processes", scan_processes, done)
+
+    def refresh_logs(self) -> None:
+        def work():
+            return list_logs_result(query=self._log_query, limit=150)
+
+        def done(result):
+            if isinstance(result, Exception):
+                self._set_status("Log refresh failed")
+                return False
+            if result.error is not None:
+                self._render_logs(result.data)
+                self._set_status(f"Log database error: {result.error.message}")
+                return False
+            self._render_logs(result.data)
+            self._set_status(f"{len(result.data)} log rows")
+            return False
+
+        self._run_refresh_once("logs", work, done)
+
+    def _render_overview(
+        self,
+        stats: DashboardStats,
+        threads: list[ThreadSummary],
+        processes: list[ProcessInfo],
+    ) -> None:
+        self._stats_labels["threads"].set_text(str(stats.thread_count))
+        self._stats_labels["recent"].set_text(str(stats.recent_hour_count))
+        self._stats_labels["tokens"].set_text(format_tokens(stats.total_tokens))
+        self._stats_labels["processes"].set_text(str(len(processes)))
+        active_cwds = {process.cwd for process in processes if process.cwd}
+        self._render_threads(
+            self._overview_sessions,
+            threads,
+            compact=True,
+            active_cwds=active_cwds,
+        )
+        self._render_processes(self._overview_processes, processes[:6], full=False)
+
+    def _render_threads(
+        self,
+        list_box: Gtk.ListBox,
+        threads: list[ThreadSummary],
+        *,
+        compact: bool = False,
+        active_cwds: set[str] | None = None,
+    ) -> None:
+        _clear_list(list_box)
+        if not threads:
+            list_box.add(self._empty_row("No Codex sessions found"))
+            list_box.show_all()
+            return
+        for thread in threads:
+            list_box.add(
+                self._thread_row(thread, compact=compact, active_cwds=active_cwds or set())
+            )
+        list_box.show_all()
+
+    def _thread_row(
+        self,
+        thread: ThreadSummary,
+        *,
+        compact: bool = False,
+        active_cwds: set[str] | None = None,
+    ) -> Gtk.ListBoxRow:
+        row = Gtk.ListBoxRow()
+        outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+        outer.get_style_context().add_class("row")
+        row.add(outer)
+
+        text_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
+        outer.pack_start(text_box, True, True, 0)
+
+        title_prefix = "Thema: " if compact else ""
+        title = _label(title_prefix + thread.title)
+        title.set_tooltip_text(thread.id)
+        text_box.pack_start(title, False, False, 0)
+
+        state_text, state_class = self._thread_state(thread, active_cwds or set())
+        meta_parts = [
+            "Stand: " + state_text,
+            "Update: " + format_time(thread.updated_ms),
+            "Projekt: " + (Path(thread.cwd).name if thread.cwd else "no cwd"),
+            thread.model or "model?",
+        ]
+        if thread.reasoning_effort:
+            meta_parts.append(thread.reasoning_effort)
+        if thread.git_branch:
+            meta_parts.append(thread.git_branch)
+        if not compact:
+            meta_parts.append(format_tokens(thread.tokens_used) + " tokens")
+        meta = _label("  |  ".join(meta_parts), css="muted")
+        text_box.pack_start(meta, False, False, 0)
+
+        badge = _label(state_text, xalign=0.5, css=state_class)
+        outer.pack_end(badge, False, False, 0)
+
+        if not compact:
+            open_button = _button("folder-open-symbolic", "Open folder")
+            open_button.connect("clicked", lambda *_: self._open_thread_folder(thread))
+            outer.pack_end(open_button, False, False, 0)
+
+            resume_button = _button("media-playback-start-symbolic", "Resume in terminal")
+            resume_button.connect("clicked", lambda *_: self._resume_thread(thread))
+            outer.pack_end(resume_button, False, False, 0)
+
+        return row
+
+    def _thread_state(self, thread: ThreadSummary, active_cwds: set[str]) -> tuple[str, str]:
+        if thread.archived:
+            return "Archived", "badge"
+        if thread.cwd and thread.cwd in active_cwds:
+            return "Running", "badge-ok"
+        age_ms = int(time.time() * 1000) - thread.updated_ms
+        if age_ms <= 10 * 60 * 1000:
+            return "Active", "badge-ok"
+        if age_ms <= 60 * 60 * 1000:
+            return "Recent", "badge-warn"
+        return "Idle", "badge-idle"
+
+    def _render_processes(
+        self,
+        list_box: Gtk.ListBox,
+        processes: list[ProcessInfo],
+        *,
+        full: bool,
+    ) -> None:
+        _clear_list(list_box)
+        if not processes:
+            list_box.add(self._empty_row("No Codex-related processes found"))
+            list_box.show_all()
+            return
+        for process in processes:
+            list_box.add(self._process_row(process, full=full))
+        list_box.show_all()
+
+    def _process_row(self, process: ProcessInfo, *, full: bool) -> Gtk.ListBoxRow:
+        row = Gtk.ListBoxRow()
+        outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
+        outer.get_style_context().add_class("row")
+        row.add(outer)
+
+        text_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
+        outer.pack_start(text_box, True, True, 0)
+
+        title = _label(f"{process.name}  pid {process.pid}")
+        title.set_tooltip_text(process.command)
+        text_box.pack_start(title, False, False, 0)
+
+        cwd = Path(process.cwd).name if process.cwd else "-"
+        meta = (
+            f"{process.ram_mb:.1f} MB  |  {process.cpu:.1f}% CPU  |  "
+            f"{format_uptime(process.uptime_seconds)}  |  {cwd}"
+        )
+        text_box.pack_start(_label(meta, css="muted"), False, False, 0)
+
+        if process.stale:
+            badge = _label("Stale", xalign=0.5, css="badge-warn")
+            outer.pack_end(badge, False, False, 0)
+
+        if full:
+            stop_button = _button("process-stop-symbolic", "Stop process")
+            stop_button.connect("clicked", lambda *_: self._confirm_stop(process))
+            outer.pack_end(stop_button, False, False, 0)
+
+        return row
+
+    def _render_logs(self, logs) -> None:
+        _clear_list(self._logs_list)
+        if not logs:
+            self._logs_list.add(self._empty_row("No Codex logs found"))
+            self._logs_list.show_all()
+            return
+        for entry in logs:
+            row = Gtk.ListBoxRow()
+            outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
+            outer.get_style_context().add_class("row")
+            row.add(outer)
+
+            header = _label(
+                f"{format_time(entry.ts_ms)}  |  {entry.level}  |  {entry.target}"
+            )
+            outer.pack_start(header, False, False, 0)
+            if entry.message:
+                outer.pack_start(_label(entry.message, css="muted"), False, False, 0)
+            elif entry.thread_id:
+                outer.pack_start(_label(entry.thread_id, css="muted"), False, False, 0)
+            self._logs_list.add(row)
+        self._logs_list.show_all()
+
+    def _empty_row(self, text: str) -> Gtk.ListBoxRow:
+        row = Gtk.ListBoxRow()
+        label = _label(text, css="muted")
+        label.set_margin_top(12)
+        label.set_margin_bottom(12)
+        label.set_margin_start(12)
+        label.set_margin_end(12)
+        row.add(label)
+        return row
+
+    def _resume_thread(self, thread: ThreadSummary) -> None:
+        codex = shutil.which("codex")
+        kitty = shutil.which("kitty")
+        cwd = thread.cwd if thread.cwd and Path(thread.cwd).is_dir() else str(Path.home())
+        if codex is None:
+            self._set_status("codex command not found")
+            return
+        if kitty:
+            cmd = [kitty, "-e", codex, "resume", thread.id]
+        else:
+            cmd = [codex, "resume", thread.id]
+        try:
+            subprocess.Popen(cmd, cwd=cwd, start_new_session=True)
+            self._set_status("Resume launched")
+        except OSError:
+            log.exception("resume failed")
+            self._set_status("Resume failed")
+
+    def _open_thread_folder(self, thread: ThreadSummary) -> None:
+        path = Path(thread.cwd)
+        if path.is_dir():
+            _open_path(path)
+            self._set_status("Folder opened")
+        else:
+            self._set_status("Folder missing")
+
+    def _confirm_stop(self, process: ProcessInfo) -> None:
+        dialog = Gtk.MessageDialog(
+            transient_for=self,
+            flags=0,
+            message_type=Gtk.MessageType.WARNING,
+            buttons=Gtk.ButtonsType.CANCEL,
+            text=f"Stop process {process.pid}?",
+        )
+        dialog.format_secondary_text(process.command)
+        dialog.add_button("Stop", Gtk.ResponseType.OK)
+        response = dialog.run()
+        dialog.destroy()
+        if response != Gtk.ResponseType.OK:
+            return
+        try:
+            terminate_process(process.pid)
+            self._set_status(f"Sent SIGTERM to {process.pid}")
+            self.refresh_processes()
+        except OSError:
+            log.exception("terminate failed")
+            self._set_status("Stop failed")
+
+    def _set_status(self, text: str) -> None:
+        self._status.set_text(text)
+
+
+def main() -> int:
+    _setup_logging()
+    _acquire_singleton_lock()
+    win = CodexDashboard()
+    win.connect("destroy", Gtk.main_quit)
+    win.show_all()
+    Gtk.main()
+    return 0

src/codex_dashboard/bootstrap.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+
+
+GUI_SYSTEM_PACKAGES = (
+    "libgirepository-2.0-dev",
+    "gobject-introspection",
+    "libgtk-3-dev",
+    "libcairo2-dev",
+    "pkg-config",
+)
+
+
+def format_missing_gi_message() -> str:
+    packages = " ".join(GUI_SYSTEM_PACKAGES)
+    return (
+        "CodexDashBoard needs PyGObject / GTK to start.\n"
+        "Install Ubuntu/Pop!_OS system packages:\n"
+        f"  sudo apt-get install -y {packages}\n"
+        "Then install the Python GUI extra:\n"
+        "  python3 -m pip install -e '.[gui]'"
+    )
+
+
+def run(app_main_loader: Callable[[], Callable[[], int]] | None = None, *, err=None) -> int:
+    err = sys.stderr.write if err is None else err
+    app_main_loader = load_app_main if app_main_loader is None else app_main_loader
+    try:
+        app_main = app_main_loader()
+    except ImportError as exc:
+        text = str(exc)
+        if "gi" in text or "Gtk" in text or "Gdk" in text or "Ayatana" in text:
+            err(format_missing_gi_message() + "\n")
+            return 1
+        raise
+    return app_main()
+
+
+def load_app_main() -> Callable[[], int]:
+    from .app import main
+
+    return main

src/codex_dashboard/claude_data.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+import json
+from pathlib import Path
+from typing import Any
+
+from .paths import CLAUDE_EVENTS_DIR, CLAUDE_PROJECTS_DIR, CLAUDE_TASKS_DIR
+
+
+@dataclass(frozen=True)
+class ClaudeTask:
+    group_id: str
+    id: str
+    subject: str
+    description: str
+    status: str
+    blocks: tuple[str, ...]
+    blocked_by: tuple[str, ...]
+    path: Path
+    updated_ms: int
+
+
+@dataclass(frozen=True)
+class ClaudeTaskGroup:
+    id: str
+    label: str
+    tasks: tuple[ClaudeTask, ...]
+    updated_ms: int
+
+
+@dataclass(frozen=True)
+class ClaudeStats:
+    task_count: int
+    pending_count: int
+    active_count: int
+    completed_count: int
+    blocked_count: int
+    latest_task: ClaudeTask | None
+
+
+@dataclass(frozen=True)
+class ClaudeEvent:
+    ts_ms: int
+    event_type: str
+    tool_name: str
+    cwd: str
+    session_id: str
+    summary: str
+
+
+@dataclass(frozen=True)
+class ClaudeSession:
+    id: str
+    project: str
+    path: Path
+    updated_ms: int
+
+
+def _shorten(text: str | None, limit: int = 160) -> str:
+    value = (text or "").strip().replace("\n", " ")
+    if len(value) <= limit:
+        return value
+    return value[: limit - 3].rstrip() + "..."
+
+
+def _as_str_list(value: Any) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        return ()
+    return tuple(str(item) for item in value if str(item).strip())
+
+
+def _load_json(path: Path) -> dict[str, Any] | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _safe_mtime_ms(path: Path) -> int:
+    try:
+        return int(path.stat().st_mtime * 1000)
+    except OSError:
+        return 0
+
+
+def _task_from_file(path: Path, group_id: str) -> ClaudeTask | None:
+    data = _load_json(path)
+    if data is None:
+        return None
+    task_id = str(data.get("id") or path.stem)
+    subject = _shorten(str(data.get("subject") or "(untitled task)"), 180)
+    description = _shorten(str(data.get("description") or ""), 260)
+    status = str(data.get("status") or "unknown").strip().lower() or "unknown"
+    return ClaudeTask(
+        group_id=group_id,
+        id=task_id,
+        subject=subject,
+        description=description,
+        status=status,
+        blocks=_as_str_list(data.get("blocks")),
+        blocked_by=_as_str_list(data.get("blockedBy")),
+        path=path,
+        updated_ms=_safe_mtime_ms(path),
+    )
+
+
+def _project_label_from_dir(name: str) -> str:
+    label = name
+    for prefix in ("-home-smlflg-Projekte-", "-home-smlflg-"):
+        if label.startswith(prefix):
+            label = label[len(prefix) :]
+            break
+    label = label.replace("--", "/").replace("-", " / ")
+    return label or name
+
+
+def _build_group_labels(projects_dir: Path) -> dict[str, str]:
+    if not projects_dir.is_dir():
+        return {}
+    labels: dict[str, str] = {}
+    try:
+        files = projects_dir.glob("*/*.jsonl")
+        for path in files:
+            labels.setdefault(path.stem, _project_label_from_dir(path.parent.name))
+    except OSError:
+        return {}
+    return labels
+
+
+def list_claude_tasks(
+    *,
+    tasks_dir: Path = CLAUDE_TASKS_DIR,
+    projects_dir: Path = CLAUDE_PROJECTS_DIR,
+    query: str = "",
+    limit: int = 200,
+) -> list[ClaudeTask]:
+    if not tasks_dir.is_dir():
+        return []
+
+    needle = query.strip().lower()
+    tasks: list[ClaudeTask] = []
+    try:
+        group_dirs = [path for path in tasks_dir.iterdir() if path.is_dir()]
+    except OSError:
+        return []
+
+    for group_dir in group_dirs:
+        try:
+            files = sorted(group_dir.glob("*.json"))
+        except OSError:
+            continue
+        for path in files:
+            task = _task_from_file(path, group_dir.name)
+            if task is None:
+                continue
+            searchable = " ".join(
+                [
+                    task.group_id,
+                    task.id,
+                    task.subject,
+                    task.description,
+                    task.status,
+                ]
+            ).lower()
+            if needle and needle not in searchable:
+                continue
+            tasks.append(task)
+
+    tasks.sort(key=lambda item: (-item.updated_ms, item.group_id, item.id))
+    return tasks[:limit]
+
+
+def group_claude_tasks(
+    tasks: list[ClaudeTask],
+    *,
+    projects_dir: Path = CLAUDE_PROJECTS_DIR,
+) -> list[ClaudeTaskGroup]:
+    labels = _build_group_labels(projects_dir)
+    grouped: dict[str, list[ClaudeTask]] = {}
+    for task in tasks:
+        grouped.setdefault(task.group_id, []).append(task)
+
+    groups = [
+        ClaudeTaskGroup(
+            id=group_id,
+            label=labels.get(group_id, group_id),
+            tasks=tuple(sorted(items, key=lambda item: (item.status, item.id))),
+            updated_ms=max((item.updated_ms for item in items), default=0),
+        )
+        for group_id, items in grouped.items()
+    ]
+    groups.sort(key=lambda item: (-item.updated_ms, item.label))
+    return groups
+
+
+def get_claude_stats(
+    *,
+    tasks_dir: Path = CLAUDE_TASKS_DIR,
+    projects_dir: Path = CLAUDE_PROJECTS_DIR,
+) -> ClaudeStats:
+    tasks = list_claude_tasks(tasks_dir=tasks_dir, projects_dir=projects_dir, limit=10_000)
+    pending = 0
+    active = 0
+    completed = 0
+    blocked = 0
+    for task in tasks:
+        status = task.status
+        if status in {"completed", "done", "closed"}:
+            completed += 1
+        elif status in {"active", "running", "in_progress", "in-progress"}:
+            active += 1
+        else:
+            pending += 1
+        if status == "blocked" or task.blocked_by:
+            blocked += 1
+    return ClaudeStats(
+        task_count=len(tasks),
+        pending_count=pending,
+        active_count=active,
+        completed_count=completed,
+        blocked_count=blocked,
+        latest_task=tasks[0] if tasks else None,
+    )
+
+
+def list_claude_sessions(
+    *,
+    projects_dir: Path = CLAUDE_PROJECTS_DIR,
+    limit: int = 20,
+) -> list[ClaudeSession]:
+    if not projects_dir.is_dir():
+        return []
+    sessions: list[ClaudeSession] = []
+    try:
+        files = projects_dir.glob("*/*.jsonl")
+        for path in files:
+            sessions.append(
+                ClaudeSession(
+                    id=path.stem,
+                    project=_project_label_from_dir(path.parent.name),
+                    path=path,
+                    updated_ms=_safe_mtime_ms(path),
+                )
+            )
+    except OSError:
+        return []
+    sessions.sort(key=lambda item: -item.updated_ms)
+    return sessions[:limit]
+
+
+def _event_summary(data: dict[str, Any]) -> str:
+    tool_input = data.get("tool_input")
+    if isinstance(tool_input, dict):
+        for key in ("description", "command", "file_path", "query"):
+            if tool_input.get(key):
+                return _shorten(str(tool_input[key]), 180)
+    tool_response = data.get("tool_response")
+    if isinstance(tool_response, dict):
+        for key in ("summary", "stdout", "stderr"):
+            if tool_response.get(key):
+                return _shorten(str(tool_response[key]), 180)
+    return ""
+
+
+def list_recent_claude_events(
+    *,
+    events_dir: Path = CLAUDE_EVENTS_DIR,
+    limit: int = 20,
+) -> list[ClaudeEvent]:
+    if not events_dir.is_dir():
+        return []
+    try:
+        files = sorted(events_dir.glob("*.jsonl"), key=lambda path: path.name, reverse=True)
+    except OSError:
+        return []
+
+    events: list[ClaudeEvent] = []
+    for path in files:
+        if len(events) >= limit:
+            break
+        try:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            continue
+        for line in reversed(lines):
+            if len(events) >= limit:
+                break
+            try:
+                data = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(data, dict):
+                continue
+            logged_ts = data.get("logged_ts")
+            try:
+                ts_ms = int(float(logged_ts) * 1000)
+            except (TypeError, ValueError):
+                ts_ms = _safe_mtime_ms(path)
+            events.append(
+                ClaudeEvent(
+                    ts_ms=ts_ms,
+                    event_type=str(data.get("event_type") or data.get("hook_event_name") or ""),
+                    tool_name=str(data.get("tool_name") or ""),
+                    cwd=str(data.get("cwd") or ""),
+                    session_id=str(data.get("session_id") or ""),
+                    summary=_event_summary(data),
+                )
+            )
+
+    events.sort(key=lambda item: -item.ts_ms)
+    return events[:limit]
+
+
+def format_claude_time(ms: int) -> str:
+    if not ms:
+        return "-"
+    return datetime.fromtimestamp(ms / 1000).strftime("%Y-%m-%d %H:%M")

src/codex_dashboard/codex_data.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+import sqlite3
+from typing import Iterable
+
+from .paths import LOGS_DB, STATE_DB, TUI_LOG
+
+
+@dataclass(frozen=True)
+class ThreadSummary:
+    id: str
+    title: str
+    cwd: str
+    model: str
+    reasoning_effort: str
+    tokens_used: int
+    archived: bool
+    source: str
+    git_branch: str
+    created_ms: int
+    updated_ms: int
+
+
+@dataclass(frozen=True)
+class LogEntry:
+    id: int
+    ts_ms: int
+    level: str
+    target: str
+    thread_id: str
+    message: str
+
+
+@dataclass(frozen=True)
+class DataAccessError:
+    source: str
+    path: Path
+    message: str
+
+
+@dataclass(frozen=True)
+class DataResult:
+    data: object
+    error: DataAccessError | None = None
+
+
+@dataclass(frozen=True)
+class DashboardStats:
+    thread_count: int
+    archived_count: int
+    total_tokens: int
+    recent_hour_count: int
+    latest_thread: ThreadSummary | None
+    error: DataAccessError | None = None
+
+
+def _data_error(source: str, path: Path, exc: BaseException) -> DataAccessError:
+    return DataAccessError(source=source, path=path, message=str(exc))
+
+
+def _connect_readonly(path: Path) -> sqlite3.Connection:
+    if not path.exists():
+        raise FileNotFoundError(path)
+    uri = f"file:{path}?mode=ro"
+    conn = sqlite3.connect(uri, uri=True, timeout=0.05)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _shorten(text: str | None, limit: int = 120) -> str:
+    value = (text or "").strip().replace("\n", " ")
+    if len(value) <= limit:
+        return value
+    return value[: limit - 3].rstrip() + "..."
+
+
+def _thread_from_row(row: sqlite3.Row) -> ThreadSummary:
+    title = row["title"] or row["first_user_message"] or "(untitled)"
+    return ThreadSummary(
+        id=row["id"],
+        title=_shorten(title),
+        cwd=row["cwd"] or "",
+        model=row["model"] or row["model_provider"] or "",
+        reasoning_effort=row["reasoning_effort"] or "",
+        tokens_used=int(row["tokens_used"] or 0),
+        archived=bool(row["archived"]),
+        source=row["source"] or "",
+        git_branch=row["git_branch"] or "",
+        created_ms=int(row["created_ms"] or 0),
+        updated_ms=int(row["updated_ms"] or 0),
+    )
+
+
+def list_threads(
+    *,
+    db_path: Path = STATE_DB,
+    query: str = "",
+    include_archived: bool = False,
+    limit: int = 80,
+) -> list[ThreadSummary]:
+    return list_threads_result(
+        db_path=db_path,
+        query=query,
+        include_archived=include_archived,
+        limit=limit,
+    ).data
+
+
+def list_threads_result(
+    *,
+    db_path: Path = STATE_DB,
+    query: str = "",
+    include_archived: bool = False,
+    limit: int = 80,
+) -> DataResult:
+    clauses = []
+    params: list[object] = []
+    if not include_archived:
+        clauses.append("archived = 0")
+    if query.strip():
+        needle = f"%{query.strip()}%"
+        clauses.append(
+            "(title LIKE ? OR first_user_message LIKE ? OR cwd LIKE ? OR git_branch LIKE ?)"
+        )
+        params.extend([needle, needle, needle, needle])
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    params.append(limit)
+
+    sql = f"""
+        SELECT
+            id,
+            title,
+            first_user_message,
+            cwd,
+            model,
+            model_provider,
+            reasoning_effort,
+            tokens_used,
+            archived,
+            source,
+            git_branch,
+            COALESCE(created_at_ms, created_at * 1000) AS created_ms,
+            COALESCE(updated_at_ms, updated_at * 1000) AS updated_ms
+        FROM threads
+        {where}
+        ORDER BY updated_ms DESC, id DESC
+        LIMIT ?
+    """
+    try:
+        with _connect_readonly(db_path) as conn:
+            return DataResult([_thread_from_row(row) for row in conn.execute(sql, params)])
+    except FileNotFoundError:
+        return DataResult([])
+    except (sqlite3.Error, TypeError, ValueError) as exc:
+        return DataResult([], _data_error("state.sqlite", db_path, exc))
+
+
+def get_stats(*, db_path: Path = STATE_DB) -> DashboardStats:
+    threads_result = list_threads_result(db_path=db_path, include_archived=False, limit=1)
+    threads = threads_result.data
+    try:
+        with _connect_readonly(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT
+                    COUNT(*) AS thread_count,
+                    SUM(CASE WHEN archived = 1 THEN 1 ELSE 0 END) AS archived_count,
+                    COALESCE(SUM(tokens_used), 0) AS total_tokens,
+                    SUM(
+                        CASE
+                            WHEN COALESCE(updated_at_ms, updated_at * 1000)
+                              >= (strftime('%s','now') * 1000 - 3600000)
+                            THEN 1 ELSE 0
+                        END
+                    ) AS recent_hour_count
+                FROM threads
+                """
+            ).fetchone()
+    except FileNotFoundError:
+        return DashboardStats(0, 0, 0, 0, None)
+    except sqlite3.Error as exc:
+        return DashboardStats(0, 0, 0, 0, None, _data_error("state.sqlite", db_path, exc))
+
+    return DashboardStats(
+        thread_count=int(row["thread_count"] or 0),
+        archived_count=int(row["archived_count"] or 0),
+        total_tokens=int(row["total_tokens"] or 0),
+        recent_hour_count=int(row["recent_hour_count"] or 0),
+        latest_thread=threads[0] if threads else None,
+        error=threads_result.error,
+    )
+
+
+def list_logs(
+    *,
+    db_path: Path = LOGS_DB,
+    query: str = "",
+    limit: int = 150,
+) -> list[LogEntry]:
+    return list_logs_result(db_path=db_path, query=query, limit=limit).data
+
+
+def list_logs_result(
+    *,
+    db_path: Path = LOGS_DB,
+    query: str = "",
+    limit: int = 150,
+) -> DataResult:
+    clauses = []
+    params: list[object] = []
+    if query.strip():
+        needle = f"%{query.strip()}%"
+        clauses.append(
+            "(target LIKE ? OR module_path LIKE ? OR feedback_log_body LIKE ? OR thread_id LIKE ?)"
+        )
+        params.extend([needle, needle, needle, needle])
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    params.append(limit)
+    sql = f"""
+        SELECT
+            id,
+            ts,
+            ts_nanos,
+            level,
+            target,
+            thread_id,
+            feedback_log_body
+        FROM logs
+        {where}
+        ORDER BY ts DESC, ts_nanos DESC, id DESC
+        LIMIT ?
+    """
+    try:
+        with _connect_readonly(db_path) as conn:
+            rows = conn.execute(sql, params).fetchall()
+    except FileNotFoundError:
+        return DataResult([])
+    except sqlite3.Error as exc:
+        return DataResult([], _data_error("logs_2.sqlite", db_path, exc))
+    try:
+        return DataResult([
+            LogEntry(
+                id=int(row["id"]),
+                ts_ms=int(row["ts"] or 0) * 1000 + int((row["ts_nanos"] or 0) / 1_000_000),
+                level=row["level"] or "",
+                target=row["target"] or "",
+                thread_id=row["thread_id"] or "",
+                message=_shorten(row["feedback_log_body"], 240),
+            )
+            for row in rows
+        ])
+    except (TypeError, ValueError, sqlite3.Error) as exc:
+        return DataResult([], _data_error("logs_2.sqlite", db_path, exc))
+
+
+def tail_tui_log(path: Path = TUI_LOG, lines: int = 80) -> list[str]:
+    if not path.exists():
+        return []
+    try:
+        data = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return []
+    return data[-lines:]
+
+
+def format_time(ms: int) -> str:
+    if not ms:
+        return "-"
+    return datetime.fromtimestamp(ms / 1000).strftime("%Y-%m-%d %H:%M")
+
+
+def format_tokens(value: int) -> str:
+    if value >= 1_000_000:
+        return f"{value / 1_000_000:.1f}M"
+    if value >= 1_000:
+        return f"{value / 1_000:.1f}k"
+    return str(value)
+
+
+def first_existing(paths: Iterable[Path]) -> Path | None:
+    for path in paths:
+        if path.exists():
+            return path
+    return None
+

src/codex_dashboard/paths.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+HOME = Path.home()
+CODEX_HOME = Path(os.environ.get("CODEX_HOME", HOME / ".codex")).expanduser()
+CLAUDE_HOME = Path(os.environ.get("CLAUDE_HOME", HOME / ".claude")).expanduser()
+STATE_DB = CODEX_HOME / "state_5.sqlite"
+LOGS_DB = CODEX_HOME / "logs_2.sqlite"
+HISTORY_JSONL = CODEX_HOME / "history.jsonl"
+TUI_LOG = CODEX_HOME / "log" / "codex-tui.log"
+CONFIG_TOML = CODEX_HOME / "config.toml"
+CLAUDE_TASKS_DIR = CLAUDE_HOME / "tasks"
+CLAUDE_EVENTS_DIR = CLAUDE_HOME / "events"
+CLAUDE_PROJECTS_DIR = CLAUDE_HOME / "projects"
+CLAUDE_SESSION_LOGS_DIR = CLAUDE_HOME / "session-logs"
+CACHE_LOG = HOME / ".cache" / "codex-dashboard.log"
+LOCK_PATH = Path("/tmp/codex-dashboard.lock")

src/codex_dashboard/processes.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import os
+import signal
+import subprocess
+import time
+
+
+PROCESS_KEYWORDS = (
+    "claudecodepanel",
+    "claude-code",
+    "claude code",
+    "claude",
+    "codex",
+    "opencode",
+    "mcp-server",
+    "server-filesystem",
+    "server-memory",
+    "server-github",
+    "gemini-mcp",
+    "gemini",
+)
+
+STALE_SECONDS = 24 * 3600
+CLK_TCK = os.sysconf(os.sysconf_names.get("SC_CLK_TCK", "SC_CLK_TCK"))
+
+
+@dataclass(frozen=True)
+class ProcessInfo:
+    pid: int
+    name: str
+    command: str
+    cpu: float
+    ram_mb: float
+    tty: str
+    cwd: str
+    uptime_seconds: float
+    stale: bool
+    family: str = "Agent"
+
+
+def _match_keyword(command: str) -> str | None:
+    lower = command.lower()
+    if "codex_dashboard" in lower or "codex-dashboard" in lower:
+        return None
+    for keyword in PROCESS_KEYWORDS:
+        if keyword in lower:
+            return keyword
+    return None
+
+
+def _friendly_name(command: str, keyword: str) -> str:
+    first = Path(command.split()[0]).name if command.split() else keyword
+    if keyword == "claudecodepanel":
+        return "Claude Panel"
+    if keyword in {"claude", "claude-code", "claude code"}:
+        return "Claude Code"
+    if keyword == "codex":
+        return "Codex CLI"
+    if keyword == "opencode":
+        return "OpenCode"
+    if keyword in {"gemini", "gemini-mcp"}:
+        return "Gemini"
+    if keyword.startswith("server-"):
+        return keyword.replace("server-", "").title() + " MCP"
+    if keyword == "mcp-server":
+        return "MCP Server"
+    if first in {"node", "python", "python3"}:
+        return f"{first}/{keyword}"
+    return first or keyword
+
+
+def _family(keyword: str) -> str:
+    if keyword in {"claude", "claude-code", "claude code", "claudecodepanel"}:
+        return "Claude"
+    if keyword == "codex":
+        return "Codex"
+    if keyword == "opencode":
+        return "OpenCode"
+    if "mcp" in keyword or keyword.startswith("server-"):
+        return "MCP"
+    if keyword.startswith("gemini"):
+        return "Gemini"
+    return "Agent"
+
+
+def _read_cwd(pid: int) -> str:
+    try:
+        return os.readlink(f"/proc/{pid}/cwd")
+    except OSError:
+        return ""
+
+
+def _read_uptime_seconds(pid: int, now: float | None = None) -> float:
+    now = time.time() if now is None else now
+    try:
+        stat_data = Path(f"/proc/{pid}/stat").read_text().split()
+        starttime_ticks = int(stat_data[21])
+        uptime = float(Path("/proc/uptime").read_text().split()[0])
+    except (OSError, ValueError, IndexError):
+        return 0.0
+    process_start = now - uptime + (starttime_ticks / CLK_TCK)
+    return max(0.0, now - process_start)
+
+
+def parse_ps_aux_line(
+    line: str, *, now: float | None = None, read_proc_metadata: bool = True
+) -> ProcessInfo | None:
+    parts = line.split(None, 10)
+    if len(parts) < 11:
+        return None
+    try:
+        pid = int(parts[1])
+        cpu = float(parts[2])
+        rss_kb = int(parts[5])
+    except ValueError:
+        return None
+    command = parts[10]
+    keyword = _match_keyword(command)
+    if keyword is None or pid == os.getpid():
+        return None
+    uptime_seconds = _read_uptime_seconds(pid, now) if read_proc_metadata else 0.0
+    return ProcessInfo(
+        pid=pid,
+        name=_friendly_name(command, keyword),
+        command=command,
+        cpu=cpu,
+        ram_mb=rss_kb / 1024,
+        tty="" if parts[6] == "?" else parts[6],
+        cwd=_read_cwd(pid) if read_proc_metadata else "",
+        uptime_seconds=uptime_seconds,
+        stale=uptime_seconds >= STALE_SECONDS,
+        family=_family(keyword),
+    )
+
+
+def scan_processes(*, ps_output: str | None = None) -> list[ProcessInfo]:
+    read_proc_metadata = ps_output is None
+    if ps_output is None:
+        try:
+            result = subprocess.run(
+                ["ps", "aux", "--no-headers"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return []
+        if result.returncode != 0:
+            return []
+        ps_output = result.stdout
+
+    processes = [
+        process
+        for line in ps_output.splitlines()
+        if (process := parse_ps_aux_line(
+            line, read_proc_metadata=read_proc_metadata
+        )) is not None
+    ]
+    processes.sort(key=lambda item: (-int(item.stale), -item.ram_mb, item.name))
+    return processes
+
+
+def terminate_process(pid: int) -> None:
+    os.kill(pid, signal.SIGTERM)
+
+
+def format_uptime(seconds: float) -> str:
+    if seconds < 60:
+        return "<1m"
+    minutes = int(seconds // 60)
+    if minutes < 60:
+        return f"{minutes}m"
+    hours = minutes // 60
+    if hours < 48:
+        return f"{hours}h"
+    return f"{hours // 24}d"

systemd/codex-dashboard.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=CodexDashBoard lightweight Codex panel
+After=graphical-session.target
+
+[Service]
+Type=simple
+WorkingDirectory=/home/smlflg/Projekte/CodexDashBoard
+Environment=PYTHONPATH=/home/smlflg/Projekte/CodexDashBoard/src
+ExecStart=/usr/bin/python3 -m codex_dashboard
+Restart=on-failure
+RestartSec=30
+StartLimitIntervalSec=60
+StartLimitBurst=3
+
+[Install]
+WantedBy=default.target
+

tests/test_codex_data.py

@@ -0,0 +1,177 @@
+from pathlib import Path
+import sqlite3
+
+from codex_dashboard.codex_data import get_stats, list_threads, list_threads_result
+
+
+def _make_state_db(path: Path) -> None:
+    conn = sqlite3.connect(path)
+    conn.execute(
+        """
+        CREATE TABLE threads (
+            id TEXT PRIMARY KEY,
+            rollout_path TEXT NOT NULL DEFAULT '',
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            source TEXT NOT NULL,
+            model_provider TEXT NOT NULL,
+            cwd TEXT NOT NULL,
+            title TEXT NOT NULL,
+            sandbox_policy TEXT NOT NULL DEFAULT '',
+            approval_mode TEXT NOT NULL DEFAULT '',
+            tokens_used INTEGER NOT NULL DEFAULT 0,
+            has_user_event INTEGER NOT NULL DEFAULT 0,
+            archived INTEGER NOT NULL DEFAULT 0,
+            archived_at INTEGER,
+            git_sha TEXT,
+            git_branch TEXT,
+            git_origin_url TEXT,
+            cli_version TEXT NOT NULL DEFAULT '',
+            first_user_message TEXT NOT NULL DEFAULT '',
+            agent_nickname TEXT,
+            agent_role TEXT,
+            memory_mode TEXT NOT NULL DEFAULT 'enabled',
+            model TEXT,
+            reasoning_effort TEXT,
+            agent_path TEXT,
+            created_at_ms INTEGER,
+            updated_at_ms INTEGER
+        )
+        """
+    )
+    rows = [
+        (
+            "new",
+            100,
+            200,
+            "codex",
+            "openai",
+            "/work/new",
+            "Newest task",
+            1200,
+            0,
+            "main",
+            "gpt-5.4",
+            "high",
+            100_000,
+            200_000,
+        ),
+        (
+            "old",
+            50,
+            60,
+            "codex",
+            "openai",
+            "/work/old",
+            "Old task",
+            300,
+            1,
+            "archive",
+            "gpt-5.4",
+            "medium",
+            50_000,
+            60_000,
+        ),
+    ]
+    conn.executemany(
+        """
+        INSERT INTO threads (
+            id, created_at, updated_at, source, model_provider, cwd, title,
+            tokens_used, archived, git_branch, model, reasoning_effort,
+            created_at_ms, updated_at_ms
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        rows,
+    )
+    conn.commit()
+    conn.close()
+
+
+def test_list_threads_hides_archived_by_default(tmp_path):
+    db = tmp_path / "state.sqlite"
+    _make_state_db(db)
+
+    threads = list_threads(db_path=db)
+
+    assert [thread.id for thread in threads] == ["new"]
+    assert threads[0].tokens_used == 1200
+    assert threads[0].reasoning_effort == "high"
+
+
+def test_list_threads_can_include_archived_and_search(tmp_path):
+    db = tmp_path / "state.sqlite"
+    _make_state_db(db)
+
+    threads = list_threads(db_path=db, include_archived=True, query="old")
+
+    assert [thread.id for thread in threads] == ["old"]
+
+
+def test_get_stats_handles_missing_db(tmp_path):
+    stats = get_stats(db_path=tmp_path / "missing.sqlite")
+
+    assert stats.thread_count == 0
+    assert stats.latest_thread is None
+    assert stats.error is None
+
+
+def test_list_threads_schema_drift_missing_timestamp_columns_reports_data_error(tmp_path):
+    db = tmp_path / "state.sqlite"
+    conn = sqlite3.connect(db)
+    conn.execute(
+        """
+        CREATE TABLE threads (
+            id TEXT PRIMARY KEY,
+            title TEXT,
+            first_user_message TEXT,
+            cwd TEXT,
+            model TEXT,
+            model_provider TEXT,
+            reasoning_effort TEXT,
+            tokens_used INTEGER,
+            archived INTEGER DEFAULT 0,
+            source TEXT,
+            git_branch TEXT
+        )
+        """
+    )
+    conn.execute("INSERT INTO threads (id, title, archived) VALUES ('t1', 'bad schema', 0)")
+    conn.commit()
+    conn.close()
+
+    result = list_threads_result(db_path=db)
+
+    assert result.data == []
+    assert result.error is not None
+    assert "created_at" in result.error.message or "updated_at" in result.error.message
+
+
+def test_list_threads_malformed_tokens_are_reported_without_exception(tmp_path):
+    db = tmp_path / "state.sqlite"
+    _make_state_db(db)
+    conn = sqlite3.connect(db)
+    conn.execute("UPDATE threads SET tokens_used = 'not-an-int' WHERE id = 'new'")
+    conn.commit()
+    conn.close()
+
+    result = list_threads_result(db_path=db)
+
+    assert result.data == []
+    assert result.error is not None
+    assert "not-an-int" in result.error.message
+
+
+def test_get_stats_schema_drift_reports_error_without_exception(tmp_path):
+    db = tmp_path / "state.sqlite"
+    conn = sqlite3.connect(db)
+    conn.execute("CREATE TABLE threads (id TEXT PRIMARY KEY, archived INTEGER DEFAULT 0)")
+    conn.commit()
+    conn.close()
+
+    stats = get_stats(db_path=db)
+
+    assert stats.thread_count == 0
+    assert stats.latest_thread is None
+    assert stats.error is not None
+    assert "tokens_used" in stats.error.message or "updated_at" in stats.error.message
+

tests/test_crash_safety.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+import ast
+import sqlite3
+import time
+
+from codex_dashboard.codex_data import get_stats, list_logs, list_threads
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+APP_PY = PROJECT_ROOT / "src" / "codex_dashboard" / "app.py"
+SERVICE_FILE = PROJECT_ROOT / "systemd" / "codex-dashboard.service"
+PYPROJECT = PROJECT_ROOT / "pyproject.toml"
+SRC_DIR = PROJECT_ROOT / "src"
+
+
+def _function_calls_in_method(source_path: Path, class_name: str, method_name: str) -> set[str]:
+    tree = ast.parse(source_path.read_text(encoding="utf-8"))
+    calls: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == class_name:
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and item.name == method_name:
+                    for child in ast.walk(item):
+                        if isinstance(child, ast.Call):
+                            func = child.func
+                            if isinstance(func, ast.Attribute):
+                                calls.add(func.attr)
+                            elif isinstance(func, ast.Name):
+                                calls.add(func.id)
+    return calls
+
+
+def test_locked_codex_db_returns_empty_fast_without_exception(tmp_path):
+    db = tmp_path / "state.sqlite"
+    owner = sqlite3.connect(db)
+    owner.execute(
+        "CREATE TABLE threads (id TEXT PRIMARY KEY, archived INTEGER DEFAULT 0, updated_at INTEGER DEFAULT 0, created_at INTEGER DEFAULT 0)"
+    )
+    owner.commit()
+    owner.execute("BEGIN EXCLUSIVE")
+
+    start = time.monotonic()
+    try:
+        threads = list_threads(db_path=db)
+        stats = get_stats(db_path=db)
+        logs = list_logs(db_path=db)
+    finally:
+        owner.rollback()
+        owner.close()
+    elapsed = time.monotonic() - start
+
+    assert threads == []
+    assert stats.thread_count == 0
+    assert stats.latest_thread is None
+    assert logs == []
+    assert elapsed < 0.75
+
+
+def test_startup_constructor_does_not_call_refresh_all():
+    calls = _function_calls_in_method(APP_PY, "CodexDashboard", "__init__")
+
+    assert "refresh_all" not in calls
+
+
+def test_refresh_all_does_not_refresh_every_view_at_once():
+    calls = _function_calls_in_method(APP_PY, "CodexDashboard", "refresh_all")
+    all_view_refreshes = {
+        "refresh_overview",
+        "refresh_sessions",
+        "refresh_processes",
+        "refresh_logs",
+    }
+
+    assert not all_view_refreshes.issubset(calls)
+
+
+def test_service_policy_does_not_create_aggressive_restart_loop():
+    lines = SERVICE_FILE.read_text(encoding="utf-8").splitlines()
+    settings = dict(
+        line.split("=", 1)
+        for line in lines
+        if line and not line.startswith("#") and "=" in line
+    )
+
+    restart = settings.get("Restart", "")
+    restart_sec_raw = settings.get("RestartSec", "0").rstrip("s")
+    restart_sec = int(restart_sec_raw) if restart_sec_raw.isdigit() else 0
+    burst = int(settings.get("StartLimitBurst", "999"))
+
+    assert restart in {"", "no", "on-abnormal"} or restart_sec >= 30
+    assert burst <= 3
+
+
+def test_refresh_methods_use_in_flight_guard_instead_of_raw_threads():
+    source = APP_PY.read_text(encoding="utf-8")
+    tree = ast.parse(source)
+    refresh_methods = {
+        "refresh_overview",
+        "refresh_sessions",
+        "refresh_processes",
+        "refresh_logs",
+    }
+    guarded_methods: set[str] = set()
+    raw_thread_methods: set[str] = set()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == "CodexDashboard":
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and item.name in refresh_methods:
+                    for child in ast.walk(item):
+                        if isinstance(child, ast.Call):
+                            func = child.func
+                            if isinstance(func, ast.Attribute) and func.attr == "_run_refresh_once":
+                                guarded_methods.add(item.name)
+                            if isinstance(func, ast.Name) and func.id == "_run_bg":
+                                raw_thread_methods.add(item.name)
+
+    assert guarded_methods == refresh_methods
+    assert raw_thread_methods == set()
+
+
+def test_in_flight_guard_discards_key_when_refresh_done():
+    source = APP_PY.read_text(encoding="utf-8")
+    tree = ast.parse(source)
+    helper = None
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == "_run_refresh_once":
+            helper = node
+            break
+
+    assert helper is not None
+    helper_source = ast.get_source_segment(source, helper) or ""
+    assert "_refresh_in_flight" in helper_source
+    assert ".add(" in helper_source
+    assert ".discard(" in helper_source
+    assert "finally" in helper_source
+
+
+def test_packaging_and_source_do_not_use_webkit():
+    checked = [PYPROJECT, SERVICE_FILE, *SRC_DIR.rglob("*.py")]
+    offenders = []
+    for path in checked:
+        text = path.read_text(encoding="utf-8", errors="replace").lower()
+        if "webkit" in text:
+            offenders.append(str(path.relative_to(PROJECT_ROOT)))
+
+    assert offenders == []

tests/test_data_error_visibility.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import ast
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+APP_PY = PROJECT_ROOT / "src" / "codex_dashboard" / "app.py"
+
+
+def _method_source(class_name: str, method_name: str) -> str:
+    source = APP_PY.read_text(encoding="utf-8")
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == class_name:
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and item.name == method_name:
+                    return ast.get_source_segment(source, item) or ""
+    raise AssertionError(f"missing {class_name}.{method_name}")
+
+
+def test_session_refresh_status_distinguishes_database_error_from_no_sessions():
+    source = _method_source("CodexDashboard", "refresh_sessions")
+
+    assert "list_threads_result" in source
+    assert ".error" in source
+    assert "Session database error" in source
+    assert "No Codex sessions found" not in source
+
+
+def test_log_refresh_status_distinguishes_database_error_from_no_logs():
+    source = _method_source("CodexDashboard", "refresh_logs")
+
+    assert "list_logs_result" in source
+    assert ".error" in source
+    assert "Log database error" in source
+    assert "No Codex logs found" not in source

tests/test_logs_data.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+import sqlite3
+
+from codex_dashboard.codex_data import list_logs, list_logs_result
+
+
+def _make_logs_db(path: Path) -> None:
+    conn = sqlite3.connect(path)
+    conn.execute(
+        """
+        CREATE TABLE logs (
+            id INTEGER PRIMARY KEY,
+            ts INTEGER NOT NULL,
+            ts_nanos INTEGER NOT NULL DEFAULT 0,
+            level TEXT NOT NULL DEFAULT '',
+            target TEXT NOT NULL DEFAULT '',
+            thread_id TEXT NOT NULL DEFAULT '',
+            module_path TEXT NOT NULL DEFAULT '',
+            feedback_log_body TEXT
+        )
+        """
+    )
+    conn.executemany(
+        """
+        INSERT INTO logs (id, ts, ts_nanos, level, target, thread_id, module_path, feedback_log_body)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        [
+            (1, 100, 123_000_000, "INFO", "codex_core", "thread-a", "core", "first message"),
+            (2, 101, 500_000_000, "WARN", "codex_ui", "thread-b", "ui", "needle message"),
+        ],
+    )
+    conn.commit()
+    conn.close()
+
+
+def test_list_logs_reads_codex_logs_fixture_and_searches(tmp_path):
+    db = tmp_path / "logs_2.sqlite"
+    _make_logs_db(db)
+
+    logs = list_logs(db_path=db, query="needle")
+
+    assert [entry.id for entry in logs] == [2]
+    assert logs[0].ts_ms == 101_500
+    assert logs[0].level == "WARN"
+    assert logs[0].thread_id == "thread-b"
+    assert logs[0].message == "needle message"
+
+
+def test_list_logs_schema_drift_missing_expected_columns_reports_data_error(tmp_path):
+    db = tmp_path / "logs_2.sqlite"
+    conn = sqlite3.connect(db)
+    conn.execute(
+        """
+        CREATE TABLE logs (
+            id INTEGER PRIMARY KEY,
+            ts INTEGER NOT NULL,
+            level TEXT,
+            target TEXT,
+            thread_id TEXT
+        )
+        """
+    )
+    conn.execute("INSERT INTO logs (id, ts, level, target, thread_id) VALUES (1, 100, 'INFO', 'target', 't')")
+    conn.commit()
+    conn.close()
+
+    result = list_logs_result(db_path=db)
+
+    assert result.data == []
+    assert result.error is not None
+    assert "ts_nanos" in result.error.message or "feedback_log_body" in result.error.message

tests/test_packaging.py

@@ -0,0 +1,14 @@
+import tomllib
+from pathlib import Path
+
+
+def test_gui_dependency_is_optional_for_dev_installs():
+    data = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))
+
+    project = data["project"]
+    dependencies = project.get("dependencies", [])
+    optional = project.get("optional-dependencies", {})
+
+    assert all(not dep.startswith("PyGObject") for dep in dependencies)
+    assert any(dep.startswith("PyGObject") for dep in optional["gui"])
+    assert any(dep.startswith("pytest") for dep in optional["dev"])

tests/test_processes.py

@@ -0,0 +1,49 @@
+from types import SimpleNamespace
+
+from codex_dashboard.processes import format_uptime, scan_processes
+
+
+def test_scan_processes_filters_codex_lines():
+    output = "\n".join(
+        [
+            "smlflg 101 0.0 0.1 1000 2048 ? S 10:00 0:00 codex",
+            "smlflg 102 0.0 0.1 1000 2048 ? S 10:00 0:00 bash",
+            "smlflg 103 1.5 0.2 1000 4096 pts/1 S 10:00 0:00 node mcp-server",
+        ]
+    )
+
+    processes = scan_processes(ps_output=output)
+
+    assert [process.pid for process in processes] == [103, 101]
+    assert processes[0].name in {"MCP Server", "node/mcp-server"}
+
+
+def test_scan_processes_reads_proc_metadata_for_live_ps(monkeypatch):
+    import codex_dashboard.processes as processes_module
+
+    output = "smlflg 4242 0.0 0.1 1000 2048 ? S 10:00 0:00 codex"
+
+    monkeypatch.setattr(
+        processes_module.subprocess,
+        "run",
+        lambda *_, **__: SimpleNamespace(returncode=0, stdout=output),
+    )
+    monkeypatch.setattr(processes_module.os, "getpid", lambda: 9999)
+    monkeypatch.setattr(processes_module, "_read_cwd", lambda pid: f"/work/{pid}")
+    monkeypatch.setattr(processes_module, "_read_uptime_seconds", lambda pid, now=None: 25 * 3600)
+
+    result = scan_processes()
+
+    assert len(result) == 1
+    assert result[0].pid == 4242
+    assert result[0].cwd == "/work/4242"
+    assert result[0].uptime_seconds == 25 * 3600
+    assert result[0].stale is True
+
+
+def test_format_uptime():
+    assert format_uptime(30) == "<1m"
+    assert format_uptime(600) == "10m"
+    assert format_uptime(7200) == "2h"
+    assert format_uptime(172800) == "2d"
+

tests/test_startup.py

@@ -0,0 +1,19 @@
+from codex_dashboard.bootstrap import format_missing_gi_message, run
+
+
+def test_format_missing_gi_message_mentions_required_packages():
+    message = format_missing_gi_message()
+
+    assert "PyGObject / GTK" in message
+    assert "python3 -m pip install -e '.[gui]'" in message
+    assert "libgirepository-2.0-dev" in message
+    assert "libgtk-3-dev" in message
+
+
+def test_run_returns_nonzero_when_gui_import_fails():
+    def _raise_import_error():
+        raise ImportError("No module named gi")
+
+    exit_code = run(_raise_import_error, err=lambda *_: None)
+
+    assert exit_code == 1

uv.lock

@@ -0,0 +1,195 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "codex-dashboard"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "pygobject" },
+]
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pygobject", specifier = ">=3.42" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8" },
+]
+provides-extras = ["dev"]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/de/0d2b39fb4af88a0258f3bac87dfcbb48e73fbdea4a2ed0e2213f9a4c2f9a/packaging-26.1.tar.gz", hash = "sha256:f042152b681c4bfac5cae2742a55e103d27ab2ec0f3d88037136b6bfe7c9c5de", size = 215519, upload-time = "2026-04-14T21:12:49.362Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/c2/920ef838e2f0028c8262f16101ec09ebd5969864e5a64c4c05fad0617c56/packaging-26.1-py3-none-any.whl", hash = "sha256:5d9c0669c6285e491e0ced2eee587eaf67b670d94a19e94e3984a481aba6802f", size = 95831, upload-time = "2026-04-14T21:12:47.56Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pycairo"
+version = "1.29.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/d9/1728840a22a4ef8a8f479b9156aa2943cd98c3907accd3849fb0d5f82bfd/pycairo-1.29.0.tar.gz", hash = "sha256:f3f7fde97325cae80224c09f12564ef58d0d0f655da0e3b040f5807bd5bd3142", size = 665871, upload-time = "2025-11-11T19:13:01.584Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/e2/c08847af2a103517f7785830706b6d1d55274494d76ab605eb744404c22f/pycairo-1.29.0-cp310-cp310-win32.whl", hash = "sha256:96c67e6caba72afd285c2372806a0175b1aa2f4537aa88fb4d9802d726effcd1", size = 751339, upload-time = "2025-11-11T19:11:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/36/2a934c6fd4f32d2011c4d9cc59a32e34e06a97dd9f4b138614078d39340b/pycairo-1.29.0-cp310-cp310-win_amd64.whl", hash = "sha256:65bddd944aee9f7d7d72821b1c87e97593856617c2820a78d589d66aa8afbd08", size = 845074, upload-time = "2025-11-11T19:11:27.111Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/f0/ee0a887d8c8a6833940263b7234aaa63d8d95a27d6130a9a053867ff057c/pycairo-1.29.0-cp310-cp310-win_arm64.whl", hash = "sha256:15b36aea699e2ff215cb6a21501223246032e572a3a10858366acdd69c81a1c8", size = 694758, upload-time = "2025-11-11T19:11:32.635Z" },
+    { url = "https://files.pythonhosted.org/packages/31/92/1b904087e831806a449502786d47d3a468e5edb8f65755f6bd88e8038e53/pycairo-1.29.0-cp311-cp311-win32.whl", hash = "sha256:12757ebfb304b645861283c20585c9204c3430671fad925419cba04844d6dfed", size = 751342, upload-time = "2025-11-11T19:11:37.386Z" },
+    { url = "https://files.pythonhosted.org/packages/db/09/a0ab6a246a7ede89e817d749a941df34f27a74bedf15551da51e86ae105e/pycairo-1.29.0-cp311-cp311-win_amd64.whl", hash = "sha256:3391532db03f9601c1cee9ebfa15b7d1db183c6020f3e75c1348cee16825934f", size = 845036, upload-time = "2025-11-11T19:11:43.408Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/b2/bf455454bac50baef553e7356d36b9d16e482403bf132cfb12960d2dc2e7/pycairo-1.29.0-cp311-cp311-win_arm64.whl", hash = "sha256:b69be8bb65c46b680771dc6a1a422b1cdd0cffb17be548f223e8cbbb6205567c", size = 694644, upload-time = "2025-11-11T19:11:48.599Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/28/6363087b9e60af031398a6ee5c248639eefc6cc742884fa2789411b1f73b/pycairo-1.29.0-cp312-cp312-win32.whl", hash = "sha256:91bcd7b5835764c616a615d9948a9afea29237b34d2ed013526807c3d79bb1d0", size = 751486, upload-time = "2025-11-11T19:11:54.451Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/d2/d146f1dd4ef81007686ac52231dd8f15ad54cf0aa432adaefc825475f286/pycairo-1.29.0-cp312-cp312-win_amd64.whl", hash = "sha256:3f01c3b5e49ef9411fff6bc7db1e765f542dc1c9cfed4542958a5afa3a8b8e76", size = 845383, upload-time = "2025-11-11T19:12:01.551Z" },
+    { url = "https://files.pythonhosted.org/packages/01/16/6e6f33bb79ec4a527c9e633915c16dc55a60be26b31118dbd0d5859e8c51/pycairo-1.29.0-cp312-cp312-win_arm64.whl", hash = "sha256:eafe3d2076f3533535ad4a361fa0754e0ee66b90e548a3a0f558fed00b1248f2", size = 694518, upload-time = "2025-11-11T19:12:06.561Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/21/3f477dc318dd4e84a5ae6301e67284199d7e5a2384f3063714041086b65d/pycairo-1.29.0-cp313-cp313-win32.whl", hash = "sha256:3eb382a4141591807073274522f7aecab9e8fa2f14feafd11ac03a13a58141d7", size = 750949, upload-time = "2025-11-11T19:12:12.198Z" },
+    { url = "https://files.pythonhosted.org/packages/43/34/7d27a333c558d6ac16dbc12a35061d389735e99e494ee4effa4ec6d99bed/pycairo-1.29.0-cp313-cp313-win_amd64.whl", hash = "sha256:91114e4b3fbf4287c2b0788f83e1f566ce031bda49cf1c3c3c19c3e986e95c38", size = 844149, upload-time = "2025-11-11T19:12:19.171Z" },
+    { url = "https://files.pythonhosted.org/packages/15/43/e782131e23df69e5c8e631a016ed84f94bbc4981bf6411079f57af730a23/pycairo-1.29.0-cp313-cp313-win_arm64.whl", hash = "sha256:09b7f69a5ff6881e151354ea092137b97b0b1f0b2ab4eb81c92a02cc4a08e335", size = 693595, upload-time = "2025-11-11T19:12:23.445Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/fa/87eaeeb9d53344c769839d7b2854db7ff2cd596211e00dd1b702eeb1838f/pycairo-1.29.0-cp314-cp314-win32.whl", hash = "sha256:69e2a7968a3fbb839736257bae153f547bca787113cc8d21e9e08ca4526e0b6b", size = 767198, upload-time = "2025-11-11T19:12:42.336Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/90/3564d0f64d0a00926ab863dc3c4a129b1065133128e96900772e1c4421f8/pycairo-1.29.0-cp314-cp314-win_amd64.whl", hash = "sha256:e91243437a21cc4c67c401eff4433eadc45745275fa3ade1a0d877e50ffb90da", size = 871579, upload-time = "2025-11-11T19:12:48.982Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/91/93632b6ba12ad69c61991e3208bde88486fdfc152be8cfdd13444e9bc650/pycairo-1.29.0-cp314-cp314-win_arm64.whl", hash = "sha256:b72200ea0e5f73ae4c788cd2028a750062221385eb0e6d8f1ecc714d0b4fdf82", size = 719537, upload-time = "2025-11-11T19:12:55.016Z" },
+    { url = "https://files.pythonhosted.org/packages/93/23/37053c039f8d3b9b5017af9bc64d27b680c48a898d48b72e6d6583cf0155/pycairo-1.29.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5e45fce6185f553e79e4ef1722b8e98e6cde9900dbc48cb2637a9ccba86f627a", size = 874015, upload-time = "2025-11-11T19:12:28.47Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/54/123f6239685f5f3f2edc123f1e38d2eefacebee18cf3c532d2f4bd51d0ef/pycairo-1.29.0-cp314-cp314t-win_arm64.whl", hash = "sha256:caba0837a4b40d47c8dfb0f24cccc12c7831e3dd450837f2a356c75f21ce5a15", size = 721404, upload-time = "2025-11-11T19:12:36.919Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pygobject"
+version = "3.56.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycairo" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/80/09247a2be28af2c2240132a0af6c1005a2b1d089242b13a2cd782d2de8d7/pygobject-3.56.2.tar.gz", hash = "sha256:b816098969544081de9eecedb94ad6ac59c77e4d571fe7051f18bebcec074313", size = 1409059, upload-time = "2026-03-25T16:14:04.008Z" }
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
+    { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
+    { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" },
+    { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" },
+    { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" },
+    { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" },
+    { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" },
+    { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" },
+    { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]