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:

    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

# 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)

  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

# 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

# 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

# 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)

  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

# 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)

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

# 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

# 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):

-- 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

# 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