claude-desktop/ROADMAP.md

# Claude Desktop — Roadmap

Stand: 14.04.2026

## Aktueller Status

### Implementiert (Phase 1-4)

| Feature | Status | Commit |
|---------|--------|--------|
| Tauri 2.0 + SvelteKit 5 App | ✅ | Initial |
| Claude Agent SDK Integration | ✅ | Phase 2 |
| Live-Streaming Text im Chat | ✅ | Phase 2 |
| SQLite Persistierung | ✅ | Phase 3 |
| Guard-Rails System | ✅ | Phase 3 |
| Claude Bridge (Node.js) | ✅ | Phase 3 |
| 4-Panel Layout (PaneForge) | ✅ | Phase 4 |
| Tab-Switching | ✅ | Phase 4 |
| Markdown-Rendering | ✅ | Phase 4 |
| Activity Panel (Tool-Tracking) | ✅ | Phase 4 |
| Memory Panel | ✅ | Phase 4 |
| Audit Log Panel | ✅ | Phase 4 |
| Agent-View | ✅ | Phase 4 |
| Modell-Auswahl (Haiku/Sonnet/Opus) | ✅ | 433e2de |
| Session-Historie persistent | ✅ | 4ba14a5 |
| STOPP-Button + Escape-Shortcut | ✅ | Vorhanden |
| Token/Kosten-Anzeige im Footer | ✅ | Vorhanden |
| Modell-Badge (Titlebar + Footer) | ✅ | 9129163 |
| Tray-Icon mit Menu | ✅ | 3c6da3b |

---

## Phase 5: Subagent-Hierarchie (KRITISCH)

### Problem
Der aktuelle `claude-bridge.js` behandelt nur einen Main-Agent. Wenn Claude das Task-Tool nutzt und Subagents (Explore, Plan, Bash) spawnt, werden diese **nicht angezeigt**.

### Ziel
```
┌─ Main Agent (claude-opus-4)
│  ├─ Explore Agent (Codebase durchsuchen)
│  │  └─ Tool: Grep "handleError"
│  └─ Plan Agent (Implementierung planen)
│     └─ Tool: Read README.md
```

### Aufgaben

- [ ] **scripts/claude-bridge.js**
  - [ ] `subagent_start` Event-Handler hinzufugen
  - [ ] `subagent_stop` Event-Handler hinzufugen
  - [ ] `parentAgentId` und `depth` im Event-Payload senden

- [ ] **src-tauri/src/claude.rs**
  - [ ] `AgentEvent` Struct erweitern: `parent_id: Option<String>`
  - [ ] Hierarchie-Info an Frontend weitergeben

- [ ] **src/lib/stores/app.ts**
  - [ ] `Agent` Interface erweitern:
    ```typescript
    interface Agent {
      id: string;
      parentAgentId?: string;  // NEU
      depth: number;           // NEU: 0 = Main, 1 = Subagent, etc.
      type: 'main' | 'explore' | 'plan' | 'bash';
      // ...
    }
    ```

- [ ] **src/lib/components/AgentView.svelte**
  - [ ] Baumansicht mit Einruckung implementieren
  - [ ] Linien zwischen Parent/Child
  - [ ] Subagent-Badge anzeigen
  - [ ] Collapsed/Expanded State pro Agent

### Verifikation
```bash
# App starten, Prompt eingeben der Task-Tool triggert
# Prufen: AgentView zeigt verschachtelte Hierarchie
```

---

## Phase 6: Session-Management Verbesserungen

### Problem
1. Session wird nur geladen wenn SessionList-Panel sichtbar ist
2. `agentId` geht bei DB-Speicherung verloren
3. Kein Compacting — alte Sessions werden unbegrenzt gross
4. `claude_session_id` wird nicht fur SDK-Fortsetzung genutzt

### Aufgaben

- [ ] **src/routes/+layout.svelte**
  - [ ] Session-Auto-Load bei App-Start (nicht nur in SessionList)
  ```typescript
  onMount(async () => {
    const active = await invoke('get_active_session');
    if (active) {
      currentSessionId.set(active.id);
      const messages = await invoke('load_messages', { sessionId: active.id });
      setMessagesFromDb(messages);
    }
  });
  ```

- [ ] **src-tauri/src/db.rs**
  - [ ] `agent_id` Spalte in `messages` Tabelle
  - [ ] Migration fur bestehende Daten
  - [ ] `compact_session(session_id, keep_last_n)` Funktion
  - [ ] `archive_messages(session_id, before_timestamp)` Funktion

- [ ] **src/lib/stores/app.ts**
  - [ ] `DbMessage` Interface: `agent_id?: string`
  - [ ] `messageToDb()` anpassen

- [ ] **Compacting-Logik**
  - [ ] Bei > 50 Nachrichten: Altere zusammenfassen
  - [ ] Summary-Nachricht: "Bisheriger Kontext: ..."
  - [ ] Original-Nachrichten in `messages_archive` Tabelle

- [ ] **Claude-Session-ID nutzen**
  - [ ] Bei `send_message`: Session-ID an SDK ubergeben
  - [ ] `--resume` Flag nutzen fur Fortsetzung

### Verifikation
```bash
# App starten → Letzte Session automatisch geladen (ohne SessionList)
# 100 Nachrichten senden → Compacting aktiv
# App beenden → Neu starten → Exakt gleicher Stand
```

---

## Phase 7: UI-Verbesserungen

### Features die fehlen (Standard bei ChatGPT, Claude.ai, Cursor)

| Feature | Prioritat |
|---------|-----------|
| Nachricht bearbeiten | Hoch |
| Antwort regenerieren | Hoch |
| Code-Block Copy-Button | Hoch |
| Diff-View fur Anderungen | Hoch |
| File-Preview inline | Mittel |
| Conversation Fork | Niedrig |

### Aufgaben

- [ ] **src/lib/components/MessageBubble.svelte** (oder ChatPanel)
  - [ ] Edit-Button bei User-Nachrichten
  - [ ] Regenerate-Button bei Assistant-Nachrichten
  - [ ] Inline-Editor fur Nachrichtenbearbeitung

- [ ] **src/lib/components/CodeBlock.svelte** (NEU)
  - [ ] Syntax-Highlighting (bereits via marked?)
  - [ ] Copy-Button oben rechts
  - [ ] Sprache anzeigen
  - [ ] Zeilennummern optional

- [ ] **src/lib/components/DiffView.svelte** (NEU)
  - [ ] Split-View: Alt | Neu
  - [ ] Unified-View: +/- Zeilen
  - [ ] Syntax-Highlighting
  - [ ] Wird bei Edit-Tool-Results angezeigt

- [ ] **src/lib/components/FilePreview.svelte** (NEU)
  - [ ] Bei Read-Tool: Dateiinhalt inline anzeigen
  - [ ] Collapsible (eingeklappt by default)
  - [ ] Syntax-Highlighting nach Dateiendung

- [ ] **Keyboard Shortcuts**
  - [ ] Cmd/Ctrl+Enter = Senden
  - [ ] Cmd/Ctrl+Shift+Enter = Senden ohne Tools
  - [ ] Cmd/Ctrl+K = Input fokussieren

### Verifikation
```bash
# User-Nachricht bearbeiten → Neue Antwort generiert
# Code-Block → Copy-Button kopiert in Clipboard
# Edit-Tool → Diff-View zeigt Anderungen
```

---

## Phase 8: Claude-DB Integration

### Problem
Die App hat keinen direkten Zugriff auf die zentrale Wissensbasis (`claude` DB auf 192.168.155.1).

### Ziel
- Wissensbasis durchsuchen direkt in der App
- Erkenntnisse speichern ("Das merken")
- Skills/Hooks/Patterns aus DB laden

### Aufgaben

- [ ] **src-tauri/src/knowledge.rs** (NEU)
  - [ ] MySQL-Verbindung zu claude-db
  - [ ] `search_knowledge(query)` — Volltextsuche
  - [ ] `save_knowledge(entry)` — Neuer Eintrag
  - [ ] `get_sticky_context()` — Fur Claude-Prompt

- [ ] **src-tauri/src/lib.rs**
  - [ ] Knowledge-Modul registrieren
  - [ ] Tauri-Commands exportieren

- [ ] **src/lib/components/KnowledgePanel.svelte** (NEU)
  - [ ] Suchfeld fur Wissensbasis
  - [ ] Ergebnisliste mit Titel, Tags, Preview
  - [ ] Detail-View fur einzelnen Eintrag

- [ ] **"Das merken" Feature**
  - [ ] Button in Chat bei wichtigen Erkenntnissen
  - [ ] Modal: Kategorie, Tags, Titel eingeben
  - [ ] Speichert in `knowledge` Tabelle

- [ ] **Sticky Context**
  - [ ] Beim Chat-Start: Sticky-Eintrage laden
  - [ ] Als System-Prompt an Claude senden

### Verifikation
```bash
# Wissensbasis durchsuchen → Ergebnisse in App
# "Das merken" klicken → Eintrag in claude.knowledge
# Neuer Chat → Sticky Context wird geladen
```

---

## Phase 9: Intelligentes Context-Management (WICHTIG)

### Das Problem: Context-Verlust nach Compacting

Compacting ist **notwendig** (Token-Limit, Kosten, Latenz), aber dabei geht kritischer Kontext verloren:
- Zugänge (DB-Hosts, API-Keys)
- Projekt-Kontext (CLAUDE.md)
- Getroffene Entscheidungen
- Aktuelle Aufgabe

### Lösung: Drei-Schichten-Gedächtnis

```
┌─────────────────────────────────────────────────────────────┐
│  SCHICHT 1: IMMER PRÄSENT (~200 Token)                      │
│  • User-Info (Name, Firma)                                  │
│  • Aktive Zugänge (komprimiert)                             │
│  • Aktuelle Projekt-ID + Phase                              │
│  → Bei JEDEM API-Call dabei                                 │
├─────────────────────────────────────────────────────────────┤
│  SCHICHT 2: PROJEKT-KONTEXT (~500 Token)                    │
│  • CLAUDE.md (komprimiert)                                  │
│  • Architektur-Entscheidungen                               │
│  • Offene TODOs                                             │
│  → Nach Compacting neu injiziert                            │
├─────────────────────────────────────────────────────────────┤
│  SCHICHT 3: WISSENS-HINTS (on-demand)                       │
│  • Relevante DB-Einträge                                    │
│  • Ähnliche Probleme/Lösungen                               │
│  → Bei Tool-Aufrufen automatisch geladen                    │
└─────────────────────────────────────────────────────────────┘
```

### Aufgaben

- [ ] **src-tauri/src/context.rs** (NEU)
  - [ ] `StickyContext` Struct (Schicht 1)
  - [ ] `ProjectContext` Struct (Schicht 2)
  - [ ] `get_sticky_context()` → ~200 Token
  - [ ] `get_project_context(project_id)` → ~500 Token
  - [ ] `extract_critical_before_compacting()` → JSON

- [ ] **src-tauri/src/credentials.rs** (NEU)
  - [ ] Credentials aus DB laden (verschlüsselt)
  - [ ] `inject_for_context(tool_name)` → Zugang wenn nötig
  - [ ] Credentials NIE im Chat-Verlauf speichern

- [ ] **scripts/claude-bridge.js**
  - [ ] Schicht 1 bei jedem `query()` Call als System-Prompt
  - [ ] Hook vor Compacting: `extract_critical_before_compacting()`
  - [ ] Hook nach Compacting: `restore_critical_context()`

- [ ] **Datenbank-Schema** (SQLite lokal)
  ```sql
  CREATE TABLE sticky_context (
    key TEXT PRIMARY KEY,
    value TEXT,
    priority INT  -- 1=kritisch, niemals entfernen
  );

  CREATE TABLE compacting_archive (
    id INTEGER PRIMARY KEY,
    session_id TEXT,
    extracted_at TEXT,
    decisions JSON,
    open_questions JSON,
    key_insights JSON
  );
  ```

- [ ] **Pre-Tool-Hook: Wissens-Hints**
  - [ ] Bei Tool-Aufruf: Schlüsselwörter extrahieren
  - [ ] Claude-DB nach relevantem Wissen durchsuchen
  - [ ] Als `<knowledge-hint>` injizieren (max 200 Token)

### Wichtig: Nicht ALLES wiederherstellen!

```
❌ FALSCH: 130.000 Token zurück injizieren
   → Sofort wieder Compacting → Endlosschleife

✅ RICHTIG: 700 Token kritischen Kontext
   Schicht 1: 200 Token (Zugänge, User)
   Schicht 2: 500 Token (Projekt, Entscheidungen)
```

### Enforcement: Sicherstellen dass Claude den Kontext NUTZT

**Problem:** Injizierter Kontext kann ignoriert werden (Lost in the Middle, keine Anweisung)

**Lösung 1: Position**
- Schicht 1 → System Prompt (höchste Priorität)
- Schicht 2 → Letzter System-Reminder vor User-Nachricht (Recency Bias)

**Lösung 2: Explizite Anweisungen**
```
<critical-context>
Du MUSST folgende Zugänge verwenden (NICHT nachfragen!):
- DB: 192.168.155.11 / dolibarr_test
Diese Daten sind AKTUELL und KORREKT.
</critical-context>
```

**Lösung 3: Validierung nach Antwort**
- [ ] `validateResponse()` in claude-bridge.js
- [ ] Prüft: Hat Claude nach Infos gefragt die injiziert waren?
- [ ] Wenn ja: Automatisch Retry mit Korrektur-Hinweis

**Lösung 4: Feedback-Loop**
- [ ] `context_failures` Tabelle in SQLite
- [ ] Speichert wenn Kontext ignoriert wurde
- [ ] Pattern erkennen → Prompts verbessern

### Aufgaben (Enforcement)

- [ ] **scripts/claude-bridge.js**
  - [ ] System Prompt Builder mit `<critical-context>` Tags
  - [ ] Schicht 1 am Anfang, Schicht 2 am Ende
  - [ ] `validateResponse()` nach jeder Antwort
  - [ ] Auto-Retry bei Kontext-Ignorierung (max 1x)

- [ ] **src-tauri/src/db.rs**
  - [ ] `context_failures` Tabelle
  - [ ] `log_context_failure(session_id, context, expected, actual)`
  - [ ] `get_failure_patterns()` für Prompt-Optimierung

- [ ] **UI: Warnung bei Regel-Verletzung**
  - [ ] Toast/Banner wenn Claude Regel ignoriert
  - [ ] Option: "Erneut versuchen mit Hinweis"

### Verifikation
```bash
# Lange Session (>100 Nachrichten) → Compacting passiert
# Danach: Zugänge noch bekannt? Projekt-Kontext da?
# Tool aufrufen → Relevante Hints erscheinen?
```

---

## Phase 10: Sprach-Interface (Optional)

### Technologie-Stack

| Komponente | Technologie | Ort |
|------------|-------------|-----|
| Speech-to-Text | Whisper.cpp | Lokal |
| Voice Activity Detection | Silero VAD | Lokal |
| Text-to-Speech | OpenAI TTS API | Cloud |
| Audio-Capture | Web Audio API | Browser |

### Aufgaben

- [ ] **Whisper Integration**
  - [ ] whisper.cpp als Tauri-Sidecar oder WASM
  - [ ] Streaming-Transkription
  - [ ] Deutsch-Modell (small oder medium)

- [ ] **VAD (Voice Activity Detection)**
  - [ ] Erkennt wann User aufhort zu sprechen
  - [ ] Pause > 1.5s → Nachricht senden

- [ ] **TTS (Text-to-Speech)**
  - [ ] OpenAI TTS API Integration
  - [ ] Streaming-Wiedergabe
  - [ ] Interrupt bei User-Sprache

- [ ] **UI**
  - [ ] Mikrofon-Button in Chat
  - [ ] Pegel-Anzeige
  - [ ] Transkript live anzeigen

### Aufwand
Gross — eigenes Teilprojekt, 2-3 Wochen

---

## Phase 11: Multi-Agent-Architektur (Context-Einsparung)

### Die drei Agent-Modi (einstellbar!)

```
┌─────────────────────────────────────────────────────────────┐
│  MODUS A: SOLO (Standard für kleine Aufgaben)               │
│  Main macht alles selbst, keine Subagents                   │
│  → Kein Overhead, schnell, für Triviales                    │
├─────────────────────────────────────────────────────────────┤
│  MODUS B: HANDLANGER (Main denkt, Rest führt aus)           │
│  Main: "Lies Datei X, such Y, gib Zeilen 10-20"             │
│  Sub: Führt EXAKT aus, denkt NICHT selbst                   │
│  → Für komplexe Aufgaben mit viel Koordination              │
├─────────────────────────────────────────────────────────────┤
│  MODUS C: AUTONOME EXPERTEN (jeder denkt selbst)            │
│  Main: "Implementiere Feature X"                            │
│  Research: Plant SELBST wie er sucht                        │
│  Implement: Plant SELBST die Architektur                    │
│  → Für parallelisierbare Aufgaben, Experten-Wissen          │
└─────────────────────────────────────────────────────────────┘
```

### Wann welcher Modus?

| Aufgabe | Modus | Grund |
|---------|-------|-------|
| "Fix Typo in Zeile 42" | Solo | Trivial |
| "Lies 50 Dateien, finde Bug" | Handlanger | Main koordiniert |
| "Implementiere OAuth2 komplett" | Experten | Jeder Teil braucht Planung |
| "Erkläre den Code" | Solo | Nur Analyse |

### Automatische Modus-Wahl (optional)

```javascript
function chooseMode(task) {
  const tokens = estimateTokens(task);
  const complexity = analyzeComplexity(task);

  if (tokens < 1000 && complexity === 'simple') return 'solo';
  if (complexity === 'coordination_heavy') return 'handlanger';
  if (complexity === 'parallelizable') return 'experten';
  return 'solo'; // Default
}
```

### Agent-Typen (für Modus B+C)

| Agent | Aufgabe | Modus B (Handlanger) | Modus C (Experte) |
|-------|---------|---------------------|-------------------|
| **Research** | Code durchsuchen | "Lies X, gib Y" | "Finde selbst was relevant ist" |
| **Implement** | Code schreiben | "Schreib exakt das" | "Implementiere nach Best Practices" |
| **Test** | Testen | "Führe diese Tests aus" | "Schreib und führe passende Tests" |
| **Review** | Prüfen | "Prüfe auf X, Y, Z" | "Finde selbst Probleme" |

### Aufgaben

- [ ] **scripts/claude-bridge.js**
  - [ ] `spawnSubAgent(type, task, maxTokens)` Funktion
  - [ ] `summarizeResult(result, maxTokens)` — Ergebnis komprimieren
  - [ ] Orchestrator-Modus: Main Agent delegiert automatisch

- [ ] **Orchestrator-Prompt**
  ```
  Du bist ein ORCHESTRATOR. Du machst NICHT selbst die Arbeit.
  Für jede Aufgabe:
  1. Analysiere was nötig ist
  2. Delegiere an passenden Sub-Agent
  3. Warte auf ZUSAMMENFASSUNG (nicht rohe Daten)
  4. Entscheide nächsten Schritt

  Sub-Agents: Research, Implement, Test, Review
  ```

- [ ] **Sub-Agent-Prompts**
  - [ ] Research: "Fasse Ergebnisse in max 500 Token zusammen"
  - [ ] Implement: "Berichte nur: welche Dateien, was geändert"
  - [ ] Test: "Berichte nur: passed/failed, Fehlerursache"

- [ ] **UI: Agent-Modus Einstellung**
  - [ ] Settings: Dropdown "Agent-Modus" (Solo / Handlanger / Experten / Auto)
  - [ ] "Auto" wählt basierend auf Aufgaben-Komplexität
  - [ ] Anzeige in Footer welcher Modus aktiv

- [ ] **UI: Agent-Delegation anzeigen**
  - [ ] AgentView zeigt: Main → Sub-Agent Delegation
  - [ ] Bei Handlanger: Exakte Anweisung sichtbar
  - [ ] Bei Experten: Agent's eigene Planung sichtbar
  - [ ] Ergebnis-Zusammenfassung pro Agent

### Verifikation
```bash
# Große Aufgabe starten
# Prüfen: Main Agent delegiert statt selbst zu arbeiten
# Prüfen: Sub-Agent Ergebnisse sind komprimiert
# Prüfen: Main Agent Context bleibt klein
```

---

## Phase 12: Hook-System für Automatisierung

### Konzept

Hooks die automatisch bei bestimmten Events laufen:

| Hook | Wann | Was |
|------|------|-----|
| `SessionStart` | App startet | Schicht 1+2 laden |
| `PreToolUse` | Vor jedem Tool | Wissens-Hints aus DB |
| `PostToolUse` | Nach Tool | Bei Fehler → Pattern speichern |
| `BeforeCompacting` | Vor Komprimierung | Kritisches extrahieren |
| `AfterCompacting` | Nach Komprimierung | Schicht 1+2 injizieren |

### Aufgaben

- [ ] **src-tauri/src/hooks.rs** (NEU)
  - [ ] `HookManager` Struct
  - [ ] `register_hook(event, callback)`
  - [ ] `fire_hook(event, payload)`

- [ ] **scripts/hooks/** (NEU)
  - [ ] `session-start.js` → Lädt Projekt-Kontext
  - [ ] `pre-tool.js` → Wissens-Hints aus claude-db
  - [ ] `post-tool.js` → Fehler-Patterns speichern
  - [ ] `before-compacting.js` → Kritisches extrahieren
  - [ ] `after-compacting.js` → Context wiederherstellen

- [ ] **UI: Hook-Konfiguration**
  - [ ] Settings-Panel: Hooks ein/ausschalten
  - [ ] Hook-Log im Audit-Panel

### Verifikation
```bash
# Session starten → Hook-Log zeigt "Kontext geladen"
# Tool aufrufen → Hook-Log zeigt "Wissens-Hints: 3 gefunden"
# Fehler provozieren → Pattern wird gespeichert
```

---

## Claude-DB Schema-Erweiterungen

Neue Tabellen für die zentrale Wissensbasis (192.168.155.1):

```sql
-- Projekt-Kontext (für Schicht 2)
CREATE TABLE project_context (
    id INT PRIMARY KEY AUTO_INCREMENT,
    project_id VARCHAR(100),
    type ENUM('claude_md', 'architecture', 'decision', 'todo', 'insight'),
    content TEXT,
    priority INT DEFAULT 5,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP NULL,
    INDEX idx_project (project_id)
);

-- Credentials (verschlüsselt)
CREATE TABLE credentials (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) UNIQUE,
    type ENUM('mysql', 'api', 'ssh', 'oauth'),
    value_encrypted BLOB,
    inject_pattern TEXT,  -- Regex: wann automatisch laden
    last_used TIMESTAMP
);

-- Compacting-Archive
CREATE TABLE compacting_archive (
    id INT PRIMARY KEY AUTO_INCREMENT,
    session_id VARCHAR(100),
    extracted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    decisions JSON,
    open_questions JSON,
    key_insights JSON,
    zugaenge JSON
);

-- Begriff-Cache (für schnelle Wissens-Hints)
CREATE TABLE concept_cache (
    concept VARCHAR(100) PRIMARY KEY,
    relevant_knowledge_ids JSON,
    last_queried TIMESTAMP,
    hit_count INT DEFAULT 0
);
```

---

## Nicht geplant / Zukunft

- [ ] Computer Use (VM mit Desktop)
- [ ] MCP-Server Integration in App
- [ ] Plugin-System
- [ ] Multi-User / Team-Features
- [ ] Cloud-Sync zwischen Geraten

---

## Technische Schulden

- [ ] Dead Code in `memory.rs` (MemorySystem struct ungenutzt)
- [ ] Warnings bei `cargo check` beheben
- [ ] TypeScript strict mode aktivieren
- [ ] E2E Tests mit Playwright
- [ ] CI/CD Pipeline (Forgejo Runner)

---

## Build & Entwicklung

```bash
# Entwicklung
cd "/mnt/17 - Entwicklungen/20 - Projekte/ClaudeDesktop"
CARGO_TARGET_DIR=/tmp/claude-desktop-target nix-shell --run "npx tauri dev"

# Produktion (AppImage)
CARGO_TARGET_DIR=/tmp/claude-desktop-target nix-shell --run "npx tauri build"
```

---

## Commits Ubersicht

| Datum | Commit | Beschreibung |
|-------|--------|--------------|
| 13.04.2026 | Initial | Grundgerust |
| 13.04.2026 | Phase 2 | Claude SDK + Events |
| 13.04.2026 | Phase 3 | SQLite, Guard-Rails, Bridge |
| 13.04.2026 | Phase 4 | Tabs, Markdown, UI |
| 14.04.2026 | 433e2de | Modell-Auswahl |
| 14.04.2026 | 4ba14a5 | Session-Historie |
| 14.04.2026 | 9129163 | Titlebar aufgeraumt |
| 14.04.2026 | 3c6da3b | Tray-Icon |