ROADMAP.md

@@ -32,7 +32,6 @@ Stand: 14.04.2026
 | **UI: Code-Copy, Edit, Regenerate (Phase 7)** | ✅ | 9d837ef |
 | **Session-Management (Phase 6)** | ✅ | abaf4eb |
 | **Claude-DB Integration (Phase 8)** | ✅ | e6bd0de |
-| **Context-Management (Phase 9)** | ✅ | eb91e54 |
 
 ---
 
@@ -185,9 +184,7 @@ Die App hat keinen direkten Zugriff auf die zentrale Wissensbasis (`claude` DB a
 
 ---
 
-## Phase 9: Intelligentes Context-Management ✅ ERLEDIGT
-
-> **Commit:** eb91e54 (14.04.2026)
+## Phase 9: Intelligentes Context-Management (WICHTIG)
 
 ### Das Problem: Context-Verlust nach Compacting
 
@@ -220,52 +217,108 @@ Compacting ist **notwendig** (Token-Limit, Kosten, Latenz), aber dabei geht krit
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### Implementiert
+### Aufgaben
 
-- ✅ **src-tauri/src/context.rs** (NEU)
-  - `StickyContext` Struct (Schicht 1) — User-Info, Credentials, Projekt, Regeln
-  - `ProjectContext` Struct (Schicht 2) — Entscheidungen, TODOs, Insights
-  - `ExtractedContext` — Kontext vor Compacting extrahieren
-  - `render()` Methoden für System-Prompt-Integration
-  - Token-Schätzung mit `estimate_tokens()`
+- [ ] **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
 
-- ✅ **Datenbank-Schema** (SQLite)
-  - `sticky_context` Tabelle (key, value, priority)
-  - `compacting_archive` Tabelle (Entscheidungen, TODOs, etc.)
-  - `context_failures` Tabelle (für Prompt-Optimierung)
+- [ ] **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
 
-- ✅ **Tauri-Commands**
-  - `get_sticky_context()` — Schicht 1 laden
-  - `set_sticky_context()` — Eintrag setzen
-  - `remove_sticky_context()` — Eintrag löschen
-  - `get_project_context()` — Schicht 2 aus Archiv
-  - `extract_context_before_compacting()` — Kritisches extrahieren
-  - `log_context_failure()` — Fehler loggen
-  - `get_full_context()` — Kombinierter Prompt
-  - `list_sticky_context()` — Alle Einträge auflisten
+- [ ] **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()`
 
-- ✅ **src/lib/components/ContextPanel.svelte** (NEU)
-  - Sticky-Context-Einträge anzeigen/bearbeiten
-  - Eintrags-Typen: User-Info, Regeln, Credentials, Projekt
-  - Prioritäts-Management (1=kritisch bis 4=niedrig)
-  - Vorschau des gerenderten Context
-  - Token-Anzeige
+- [ ] **Datenbank-Schema** (SQLite lokal)
+  ```sql
+  CREATE TABLE sticky_context (
+    key TEXT PRIMARY KEY,
+    value TEXT,
+    priority INT  -- 1=kritisch, niemals entfernen
+  );
 
-- ✅ **src/routes/+page.svelte**
-  - Neuer Tab "📌 Context" im rechten Panel
+  CREATE TABLE compacting_archive (
+    id INTEGER PRIMARY KEY,
+    session_id TEXT,
+    extracted_at TEXT,
+    decisions JSON,
+    open_questions JSON,
+    key_insights JSON
+  );
+  ```
 
-### Noch offen (niedrigere Priorität)
+- [ ] **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)
 
-- [ ] **Bridge-Integration** — Context bei jedem API-Call injizieren
-- [ ] **Auto-Extraction vor Compacting** — Hook automatisch auslösen
-- [ ] **Validation** — Prüfen ob Claude den Context nutzt
-- [ ] **Wissens-Hints** — On-demand aus claude-db laden
+### 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
-# Context-Panel öffnen → Einträge hinzufügen
-# Vorschau → <critical-context> Tags sichtbar
-# Token-Anzeige zeigt ~200 Token
+# Lange Session (>100 Nachrichten) → Compacting passiert
+# Danach: Zugänge noch bekannt? Projekt-Kontext da?
+# Tool aufrufen → Relevante Hints erscheinen?
 ```
 
 ---
@@ -1195,4 +1248,3 @@ CARGO_TARGET_DIR=/tmp/claude-desktop-target nix-shell --run "npx tauri build"
 | 14.04.2026 | 9d837ef | **Phase 7:** UI Code-Copy, Edit, Regenerate |
 | 14.04.2026 | abaf4eb | **Phase 6:** Session-Management, Auto-Load, Compacting |
 | 14.04.2026 | e6bd0de | **Phase 8:** Claude-DB Integration, KnowledgePanel |
-| 14.04.2026 | eb91e54 | **Phase 9:** Context-Management, ContextPanel |

src-tauri/src/context.rs

@@ -1,591 +0,0 @@
-// Claude Desktop — Intelligentes Context-Management
-// Drei-Schichten-Gedächtnis für kritischen Kontext
-
-use serde::{Deserialize, Serialize};
-use std::sync::{Arc, Mutex};
-use tauri::{AppHandle, Manager};
-
-use crate::db::{Database, DbState};
-
-/// Schicht 1: Immer präsent (~200 Token)
-/// Wird bei JEDEM API-Call als System-Prompt gesendet
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct StickyContext {
-    /// User-Infos (Name, Firma)
-    pub user_info: Option<String>,
-    /// Komprimierte Zugänge (ohne Passwörter!)
-    pub active_credentials: Vec<CredentialHint>,
-    /// Aktuelles Projekt
-    pub current_project: Option<ProjectInfo>,
-    /// Kritische Regeln
-    pub critical_rules: Vec<String>,
-}
-
-/// Zugangs-Hint (ohne sensible Daten!)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CredentialHint {
-    pub name: String,
-    pub host: String,
-    pub db_or_path: Option<String>,
-    /// Wann automatisch injizieren (Regex-Pattern)
-    pub inject_pattern: Option<String>,
-}
-
-/// Projekt-Info (kompakt)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProjectInfo {
-    pub id: String,
-    pub name: String,
-    pub current_phase: Option<String>,
-    pub working_dir: Option<String>,
-}
-
-/// Schicht 2: Projekt-Kontext (~500 Token)
-/// Wird nach Compacting neu injiziert
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct ProjectContext {
-    /// Komprimiertes CLAUDE.md
-    pub claude_md_summary: Option<String>,
-    /// Architektur-Entscheidungen
-    pub decisions: Vec<Decision>,
-    /// Offene TODOs
-    pub open_todos: Vec<String>,
-    /// Wichtige Erkenntnisse
-    pub key_insights: Vec<String>,
-}
-
-/// Eine Architektur-Entscheidung
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Decision {
-    pub topic: String,
-    pub decision: String,
-    pub reason: Option<String>,
-}
-
-/// Extrahierter Kontext vor Compacting
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ExtractedContext {
-    pub session_id: String,
-    pub extracted_at: String,
-    pub decisions: Vec<Decision>,
-    pub open_questions: Vec<String>,
-    pub key_insights: Vec<String>,
-    pub mentioned_files: Vec<String>,
-    pub mentioned_tools: Vec<String>,
-}
-
-/// Wissens-Hint (Schicht 3, on-demand)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct KnowledgeHint {
-    pub title: String,
-    pub content: String,
-    pub relevance: f64,
-}
-
-impl StickyContext {
-    /// Rendert Schicht 1 als System-Prompt-Teil
-    pub fn render(&self) -> String {
-        let mut parts = Vec::new();
-
-        if let Some(ref user) = self.user_info {
-            parts.push(format!("**User:** {}", user));
-        }
-
-        if let Some(ref proj) = self.current_project {
-            let phase = proj.current_phase.as_deref().unwrap_or("unbekannt");
-            parts.push(format!("**Projekt:** {} (Phase: {})", proj.name, phase));
-            if let Some(ref dir) = proj.working_dir {
-                parts.push(format!("**Arbeitsverzeichnis:** {}", dir));
-            }
-        }
-
-        if !self.active_credentials.is_empty() {
-            parts.push("**Verfügbare Zugänge (NICHT nachfragen!):**".to_string());
-            for cred in &self.active_credentials {
-                let db_part = cred.db_or_path.as_deref().map(|d| format!(" / {}", d)).unwrap_or_default();
-                parts.push(format!("- {}: {}{}", cred.name, cred.host, db_part));
-            }
-        }
-
-        if !self.critical_rules.is_empty() {
-            parts.push("**Kritische Regeln:**".to_string());
-            for rule in &self.critical_rules {
-                parts.push(format!("- {}", rule));
-            }
-        }
-
-        if parts.is_empty() {
-            return String::new();
-        }
-
-        format!("<critical-context>\n{}\n</critical-context>", parts.join("\n"))
-    }
-
-    /// Geschätzte Token-Anzahl
-    pub fn estimate_tokens(&self) -> usize {
-        // Grobe Schätzung: ~4 Zeichen pro Token
-        self.render().len() / 4
-    }
-}
-
-impl ProjectContext {
-    /// Rendert Schicht 2 als System-Reminder
-    pub fn render(&self) -> String {
-        let mut parts = Vec::new();
-
-        if let Some(ref summary) = self.claude_md_summary {
-            parts.push(format!("**Projekt-Kontext:**\n{}", summary));
-        }
-
-        if !self.decisions.is_empty() {
-            parts.push("**Getroffene Entscheidungen:**".to_string());
-            for dec in &self.decisions {
-                let reason = dec.reason.as_deref().map(|r| format!(" ({})", r)).unwrap_or_default();
-                parts.push(format!("- {}: {}{}", dec.topic, dec.decision, reason));
-            }
-        }
-
-        if !self.open_todos.is_empty() {
-            parts.push("**Offene TODOs:**".to_string());
-            for todo in &self.open_todos {
-                parts.push(format!("- [ ] {}", todo));
-            }
-        }
-
-        if !self.key_insights.is_empty() {
-            parts.push("**Wichtige Erkenntnisse:**".to_string());
-            for insight in &self.key_insights {
-                parts.push(format!("- {}", insight));
-            }
-        }
-
-        if parts.is_empty() {
-            return String::new();
-        }
-
-        format!("<project-context>\n{}\n</project-context>", parts.join("\n\n"))
-    }
-
-    /// Geschätzte Token-Anzahl
-    pub fn estimate_tokens(&self) -> usize {
-        self.render().len() / 4
-    }
-}
-
-// ============ Datenbank-Erweiterungen ============
-
-impl Database {
-    /// Erstellt die Context-Tabellen
-    pub fn create_context_tables(&self) -> rusqlite::Result<()> {
-        self.conn.execute_batch(
-            "
-            -- Sticky Context (Schicht 1)
-            CREATE TABLE IF NOT EXISTS sticky_context (
-                key TEXT PRIMARY KEY,
-                value TEXT NOT NULL,
-                priority INTEGER DEFAULT 2,
-                updated_at TEXT NOT NULL
-            );
-
-            -- Compacting-Archiv
-            CREATE TABLE IF NOT EXISTS compacting_archive (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                extracted_at TEXT NOT NULL,
-                decisions TEXT,
-                open_questions TEXT,
-                key_insights TEXT,
-                mentioned_files TEXT,
-                mentioned_tools TEXT
-            );
-            CREATE INDEX IF NOT EXISTS idx_archive_session ON compacting_archive(session_id);
-
-            -- Context-Failures (für Prompt-Optimierung)
-            CREATE TABLE IF NOT EXISTS context_failures (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                timestamp TEXT NOT NULL,
-                context_type TEXT NOT NULL,
-                expected TEXT,
-                actual TEXT,
-                resolved INTEGER DEFAULT 0
-            );
-            CREATE INDEX IF NOT EXISTS idx_failures_session ON context_failures(session_id);
-            "
-        )?;
-        Ok(())
-    }
-
-    /// Speichert einen Sticky-Context-Eintrag
-    pub fn save_sticky_context(&self, key: &str, value: &str, priority: i32) -> rusqlite::Result<()> {
-        self.conn.execute(
-            "INSERT OR REPLACE INTO sticky_context (key, value, priority, updated_at)
-             VALUES (?1, ?2, ?3, ?4)",
-            rusqlite::params![key, value, priority, chrono::Local::now().to_rfc3339()],
-        )?;
-        Ok(())
-    }
-
-    /// Lädt alle Sticky-Context-Einträge
-    pub fn load_sticky_context(&self) -> rusqlite::Result<Vec<(String, String, i32)>> {
-        let mut stmt = self.conn.prepare(
-            "SELECT key, value, priority FROM sticky_context ORDER BY priority ASC"
-        )?;
-        let entries = stmt.query_map([], |row| {
-            Ok((row.get(0)?, row.get(1)?, row.get(2)?))
-        })?.collect::<rusqlite::Result<Vec<_>>>()?;
-        Ok(entries)
-    }
-
-    /// Löscht einen Sticky-Context-Eintrag
-    pub fn delete_sticky_context(&self, key: &str) -> rusqlite::Result<()> {
-        self.conn.execute("DELETE FROM sticky_context WHERE key = ?1", rusqlite::params![key])?;
-        Ok(())
-    }
-
-    /// Archiviert extrahierten Kontext vor Compacting
-    pub fn archive_context(&self, extracted: &ExtractedContext) -> rusqlite::Result<()> {
-        self.conn.execute(
-            "INSERT INTO compacting_archive (id, session_id, extracted_at, decisions, open_questions, key_insights, mentioned_files, mentioned_tools)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
-            rusqlite::params![
-                uuid::Uuid::new_v4().to_string(),
-                extracted.session_id,
-                extracted.extracted_at,
-                serde_json::to_string(&extracted.decisions).ok(),
-                serde_json::to_string(&extracted.open_questions).ok(),
-                serde_json::to_string(&extracted.key_insights).ok(),
-                serde_json::to_string(&extracted.mentioned_files).ok(),
-                serde_json::to_string(&extracted.mentioned_tools).ok(),
-            ],
-        )?;
-        Ok(())
-    }
-
-    /// Lädt archivierten Kontext einer Session
-    pub fn load_archived_context(&self, session_id: &str) -> rusqlite::Result<Option<ExtractedContext>> {
-        let result = self.conn.query_row(
-            "SELECT session_id, extracted_at, decisions, open_questions, key_insights, mentioned_files, mentioned_tools
-             FROM compacting_archive WHERE session_id = ?1 ORDER BY extracted_at DESC LIMIT 1",
-            rusqlite::params![session_id],
-            |row| {
-                let decisions: Option<String> = row.get(2)?;
-                let questions: Option<String> = row.get(3)?;
-                let insights: Option<String> = row.get(4)?;
-                let files: Option<String> = row.get(5)?;
-                let tools: Option<String> = row.get(6)?;
-
-                Ok(ExtractedContext {
-                    session_id: row.get(0)?,
-                    extracted_at: row.get(1)?,
-                    decisions: decisions.and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default(),
-                    open_questions: questions.and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default(),
-                    key_insights: insights.and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default(),
-                    mentioned_files: files.and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default(),
-                    mentioned_tools: tools.and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default(),
-                })
-            },
-        );
-        match result {
-            Ok(ctx) => Ok(Some(ctx)),
-            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Speichert einen Context-Failure
-    pub fn log_context_failure(
-        &self,
-        session_id: &str,
-        context_type: &str,
-        expected: &str,
-        actual: &str,
-    ) -> rusqlite::Result<()> {
-        self.conn.execute(
-            "INSERT INTO context_failures (id, session_id, timestamp, context_type, expected, actual)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
-            rusqlite::params![
-                uuid::Uuid::new_v4().to_string(),
-                session_id,
-                chrono::Local::now().to_rfc3339(),
-                context_type,
-                expected,
-                actual,
-            ],
-        )?;
-        Ok(())
-    }
-}
-
-// ============ Tauri Commands ============
-
-/// Sticky Context laden (Schicht 1)
-#[tauri::command]
-pub async fn get_sticky_context(app: AppHandle) -> Result<StickyContext, String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    // Context-Tabellen erstellen falls nicht vorhanden
-    let _ = db.create_context_tables();
-
-    let entries = db.load_sticky_context().map_err(|e| e.to_string())?;
-
-    let mut ctx = StickyContext::default();
-
-    for (key, value, _priority) in entries {
-        match key.as_str() {
-            "user_info" => ctx.user_info = Some(value),
-            k if k.starts_with("cred:") => {
-                if let Ok(cred) = serde_json::from_str::<CredentialHint>(&value) {
-                    ctx.active_credentials.push(cred);
-                }
-            }
-            k if k.starts_with("project:") => {
-                if let Ok(proj) = serde_json::from_str::<ProjectInfo>(&value) {
-                    ctx.current_project = Some(proj);
-                }
-            }
-            k if k.starts_with("rule:") => {
-                ctx.critical_rules.push(value);
-            }
-            _ => {}
-        }
-    }
-
-    Ok(ctx)
-}
-
-/// Sticky Context Eintrag setzen
-#[tauri::command]
-pub async fn set_sticky_context(
-    app: AppHandle,
-    key: String,
-    value: String,
-    priority: Option<i32>,
-) -> Result<(), String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    let _ = db.create_context_tables();
-
-    db.save_sticky_context(&key, &value, priority.unwrap_or(2))
-        .map_err(|e| e.to_string())?;
-
-    println!("📌 Sticky Context gesetzt: {}", key);
-    Ok(())
-}
-
-/// Sticky Context Eintrag löschen
-#[tauri::command]
-pub async fn remove_sticky_context(app: AppHandle, key: String) -> Result<(), String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    db.delete_sticky_context(&key).map_err(|e| e.to_string())?;
-
-    println!("🗑️ Sticky Context entfernt: {}", key);
-    Ok(())
-}
-
-/// Projekt-Kontext laden (Schicht 2)
-#[tauri::command]
-pub async fn get_project_context(
-    app: AppHandle,
-    session_id: String,
-) -> Result<ProjectContext, String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    let _ = db.create_context_tables();
-
-    // Versuche archivierten Kontext zu laden
-    if let Ok(Some(archived)) = db.load_archived_context(&session_id) {
-        let mut ctx = ProjectContext::default();
-        ctx.decisions = archived.decisions;
-        ctx.key_insights = archived.key_insights;
-        ctx.open_todos = archived.open_questions; // open_questions als TODOs verwenden
-        return Ok(ctx);
-    }
-
-    Ok(ProjectContext::default())
-}
-
-/// Kontext vor Compacting extrahieren
-#[tauri::command]
-pub async fn extract_context_before_compacting(
-    app: AppHandle,
-    session_id: String,
-    messages_json: String,
-) -> Result<ExtractedContext, String> {
-    // Nachrichten parsen
-    let messages: Vec<serde_json::Value> = serde_json::from_str(&messages_json)
-        .map_err(|e| e.to_string())?;
-
-    let mut extracted = ExtractedContext {
-        session_id: session_id.clone(),
-        extracted_at: chrono::Local::now().to_rfc3339(),
-        decisions: Vec::new(),
-        open_questions: Vec::new(),
-        key_insights: Vec::new(),
-        mentioned_files: Vec::new(),
-        mentioned_tools: Vec::new(),
-    };
-
-    // Einfache Extraktion aus Nachrichten
-    for msg in &messages {
-        let content = msg.get("content").and_then(|c| c.as_str()).unwrap_or("");
-
-        // Entscheidungen finden (Muster: "Entscheidung:", "Wir nehmen", "Ich verwende")
-        if content.contains("Entscheidung:") || content.contains("Wir nehmen") || content.contains("Ich verwende") {
-            // Vereinfachte Extraktion
-            let lines: Vec<&str> = content.lines()
-                .filter(|l| l.contains("Entscheidung") || l.contains("verwende") || l.contains("nehmen"))
-                .take(3)
-                .collect();
-            for line in lines {
-                if line.len() > 10 && line.len() < 200 {
-                    extracted.decisions.push(Decision {
-                        topic: "Architektur".to_string(),
-                        decision: line.trim().to_string(),
-                        reason: None,
-                    });
-                }
-            }
-        }
-
-        // Offene Fragen finden (Muster: "TODO", "FIXME", "?")
-        if content.contains("TODO") || content.contains("FIXME") {
-            let lines: Vec<&str> = content.lines()
-                .filter(|l| l.contains("TODO") || l.contains("FIXME"))
-                .take(5)
-                .collect();
-            for line in lines {
-                if line.len() > 5 && line.len() < 200 {
-                    extracted.open_questions.push(line.trim().to_string());
-                }
-            }
-        }
-
-        // Dateien extrahieren (vereinfacht: Pfade mit /)
-        for word in content.split_whitespace() {
-            if word.contains('/') && word.contains('.') && word.len() < 100 {
-                let clean = word.trim_matches(|c| c == '"' || c == '\'' || c == '`' || c == '(' || c == ')');
-                if !extracted.mentioned_files.contains(&clean.to_string()) {
-                    extracted.mentioned_files.push(clean.to_string());
-                }
-            }
-        }
-    }
-
-    // Archivieren
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-    let _ = db.create_context_tables();
-    let _ = db.archive_context(&extracted);
-
-    println!("📦 Kontext extrahiert: {} Entscheidungen, {} TODOs, {} Dateien",
-        extracted.decisions.len(),
-        extracted.open_questions.len(),
-        extracted.mentioned_files.len()
-    );
-
-    Ok(extracted)
-}
-
-/// Context-Failure loggen (für Prompt-Optimierung)
-#[tauri::command]
-pub async fn log_context_failure(
-    app: AppHandle,
-    session_id: String,
-    context_type: String,
-    expected: String,
-    actual: String,
-) -> Result<(), String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    let _ = db.create_context_tables();
-
-    db.log_context_failure(&session_id, &context_type, &expected, &actual)
-        .map_err(|e| e.to_string())?;
-
-    println!("⚠️ Context-Failure geloggt: {} (erwartet: {}, tatsächlich: {})",
-        context_type, expected, actual);
-    Ok(())
-}
-
-/// Kombinierter System-Prompt aus Schicht 1+2
-#[tauri::command]
-pub async fn get_full_context(
-    app: AppHandle,
-    session_id: Option<String>,
-) -> Result<String, String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    let _ = db.create_context_tables();
-
-    // Schicht 1: Sticky Context
-    let entries = db.load_sticky_context().map_err(|e| e.to_string())?;
-    let mut sticky = StickyContext::default();
-
-    for (key, value, _priority) in entries {
-        match key.as_str() {
-            "user_info" => sticky.user_info = Some(value),
-            k if k.starts_with("cred:") => {
-                if let Ok(cred) = serde_json::from_str::<CredentialHint>(&value) {
-                    sticky.active_credentials.push(cred);
-                }
-            }
-            k if k.starts_with("project:") => {
-                if let Ok(proj) = serde_json::from_str::<ProjectInfo>(&value) {
-                    sticky.current_project = Some(proj);
-                }
-            }
-            k if k.starts_with("rule:") => {
-                sticky.critical_rules.push(value);
-            }
-            _ => {}
-        }
-    }
-
-    // Schicht 2: Projekt-Kontext (falls Session angegeben)
-    let mut project = ProjectContext::default();
-    if let Some(ref sid) = session_id {
-        if let Ok(Some(archived)) = db.load_archived_context(sid) {
-            project.decisions = archived.decisions;
-            project.key_insights = archived.key_insights;
-            project.open_todos = archived.open_questions;
-        }
-    }
-
-    // Kombinieren
-    let sticky_rendered = sticky.render();
-    let project_rendered = project.render();
-
-    let mut full = String::new();
-    if !sticky_rendered.is_empty() {
-        full.push_str(&sticky_rendered);
-    }
-    if !project_rendered.is_empty() {
-        if !full.is_empty() {
-            full.push_str("\n\n");
-        }
-        full.push_str(&project_rendered);
-    }
-
-    Ok(full)
-}
-
-/// Liste alle Sticky-Context-Einträge auf
-#[tauri::command]
-pub async fn list_sticky_context(
-    app: AppHandle,
-) -> Result<Vec<(String, String, i32)>, String> {
-    let state = app.state::<DbState>();
-    let db = state.lock().unwrap();
-
-    let _ = db.create_context_tables();
-
-    db.load_sticky_context().map_err(|e| e.to_string())
-}

src-tauri/src/lib.rs

@@ -10,7 +10,6 @@ use tauri::{
 
 mod audit;
 mod claude;
-mod context;
 mod db;
 mod guard;
 mod knowledge;
@@ -75,15 +74,6 @@ pub fn run() {
             knowledge::get_knowledge_categories,
             knowledge::get_recent_knowledge,
             knowledge::test_knowledge_connection,
-            // Context-Management
-            context::get_sticky_context,
-            context::set_sticky_context,
-            context::remove_sticky_context,
-            context::get_project_context,
-            context::extract_context_before_compacting,
-            context::log_context_failure,
-            context::get_full_context,
-            context::list_sticky_context,
         ])
         .setup(|app| {
             let handle = app.handle().clone();

src/lib/components/ContextPanel.svelte

@@ -1,570 +0,0 @@
-<script lang="ts">
-	import { onMount } from 'svelte';
-	import { invoke } from '@tauri-apps/api/core';
-
-	// Typen
-	interface StickyEntry {
-		key: string;
-		value: string;
-		priority: number;
-	}
-
-	interface CredentialHint {
-		name: string;
-		host: string;
-		db_or_path: string | null;
-		inject_pattern: string | null;
-	}
-
-	interface ProjectInfo {
-		id: string;
-		name: string;
-		current_phase: string | null;
-		working_dir: string | null;
-	}
-
-	// State
-	let entries = $state<StickyEntry[]>([]);
-	let loading = $state(false);
-	let fullContext = $state('');
-	let showAddDialog = $state(false);
-	let showPreview = $state(false);
-
-	// Neuer Eintrag
-	let newEntry = $state({
-		type: 'rule',
-		key: '',
-		value: '',
-		priority: 2
-	});
-
-	// Vordefinierte Entry-Typen
-	const entryTypes = [
-		{ id: 'user_info', label: 'User-Info', prefix: 'user_info', icon: '👤' },
-		{ id: 'rule', label: 'Kritische Regel', prefix: 'rule:', icon: '⚠️' },
-		{ id: 'cred', label: 'Zugang (Credential)', prefix: 'cred:', icon: '🔑' },
-		{ id: 'project', label: 'Projekt-Info', prefix: 'project:', icon: '📁' },
-	];
-
-	// Prioritäts-Labels
-	const priorityLabels: Record<number, string> = {
-		1: 'Kritisch (immer zuerst)',
-		2: 'Hoch',
-		3: 'Normal',
-		4: 'Niedrig'
-	};
-
-	onMount(async () => {
-		await loadEntries();
-	});
-
-	async function loadEntries() {
-		loading = true;
-		try {
-			const result: [string, string, number][] = await invoke('list_sticky_context');
-			entries = result.map(([key, value, priority]) => ({ key, value, priority }));
-
-			// Auch den gerenderten Context laden
-			fullContext = await invoke('get_full_context', { sessionId: null });
-		} catch (err) {
-			console.error('Fehler beim Laden:', err);
-		}
-		loading = false;
-	}
-
-	async function addEntry() {
-		if (!newEntry.value.trim()) return;
-
-		const type = entryTypes.find(t => t.id === newEntry.type);
-		let key = '';
-
-		if (newEntry.type === 'user_info') {
-			key = 'user_info';
-		} else if (newEntry.type === 'cred') {
-			// Credential als JSON speichern
-			const cred: CredentialHint = {
-				name: newEntry.key || 'Unbenannt',
-				host: newEntry.value,
-				db_or_path: null,
-				inject_pattern: null
-			};
-			key = `cred:${newEntry.key || 'default'}`;
-			newEntry.value = JSON.stringify(cred);
-		} else if (newEntry.type === 'project') {
-			const proj: ProjectInfo = {
-				id: newEntry.key || 'default',
-				name: newEntry.value,
-				current_phase: null,
-				working_dir: null
-			};
-			key = `project:${newEntry.key || 'current'}`;
-			newEntry.value = JSON.stringify(proj);
-		} else {
-			key = `${type?.prefix || ''}${newEntry.key || Date.now()}`;
-		}
-
-		try {
-			await invoke('set_sticky_context', {
-				key,
-				value: newEntry.value,
-				priority: newEntry.priority
-			});
-
-			// Reset und neu laden
-			newEntry = { type: 'rule', key: '', value: '', priority: 2 };
-			showAddDialog = false;
-			await loadEntries();
-		} catch (err) {
-			console.error('Fehler beim Speichern:', err);
-		}
-	}
-
-	async function removeEntry(key: string) {
-		try {
-			await invoke('remove_sticky_context', { key });
-			await loadEntries();
-		} catch (err) {
-			console.error('Fehler beim Löschen:', err);
-		}
-	}
-
-	function getEntryIcon(key: string): string {
-		if (key === 'user_info') return '👤';
-		if (key.startsWith('rule:')) return '⚠️';
-		if (key.startsWith('cred:')) return '🔑';
-		if (key.startsWith('project:')) return '📁';
-		return '📌';
-	}
-
-	function getEntryLabel(key: string): string {
-		if (key === 'user_info') return 'User-Info';
-		if (key.startsWith('rule:')) return key.replace('rule:', '');
-		if (key.startsWith('cred:')) return key.replace('cred:', '');
-		if (key.startsWith('project:')) return key.replace('project:', '');
-		return key;
-	}
-
-	function formatValue(key: string, value: string): string {
-		// JSON-Werte formatieren
-		try {
-			const parsed = JSON.parse(value);
-			if (key.startsWith('cred:')) {
-				return `${parsed.host}${parsed.db_or_path ? ' / ' + parsed.db_or_path : ''}`;
-			}
-			if (key.startsWith('project:')) {
-				return `${parsed.name}${parsed.current_phase ? ' (' + parsed.current_phase + ')' : ''}`;
-			}
-		} catch {
-			// Kein JSON, Wert direkt zurückgeben
-		}
-		return value.length > 100 ? value.slice(0, 100) + '...' : value;
-	}
-
-	function estimateTokens(text: string): number {
-		return Math.ceil(text.length / 4);
-	}
-</script>
-
-<div class="context-panel">
-	<div class="panel-header">
-		<h2>📌 Sticky Context</h2>
-		<div class="header-actions">
-			<button class="btn-preview" onclick={() => showPreview = !showPreview}>
-				{showPreview ? '📝 Liste' : '👁️ Vorschau'}
-			</button>
-		</div>
-	</div>
-
-	<div class="info-box">
-		<strong>Schicht 1:</strong> Diese Einträge werden bei JEDEM API-Call an Claude gesendet.
-		<br>
-		<span class="token-count">~{estimateTokens(fullContext)} Token</span>
-	</div>
-
-	{#if showPreview}
-		<!-- Vorschau des gerenderten Contexts -->
-		<div class="preview-box">
-			<pre>{fullContext || '(Kein Context konfiguriert)'}</pre>
-		</div>
-	{:else}
-		<!-- Eintrags-Liste -->
-		<div class="entries-list">
-			{#if loading}
-				<div class="loading">Lade...</div>
-			{:else if entries.length === 0}
-				<div class="empty-state">
-					Noch keine Einträge. Füge kritische Informationen hinzu,
-					die Claude immer kennen soll.
-				</div>
-			{:else}
-				{#each entries as entry}
-					<div class="entry-item">
-						<div class="entry-header">
-							<span class="entry-icon">{getEntryIcon(entry.key)}</span>
-							<span class="entry-key">{getEntryLabel(entry.key)}</span>
-							<span class="entry-priority" class:critical={entry.priority === 1}>
-								P{entry.priority}
-							</span>
-							<button class="btn-delete" onclick={() => removeEntry(entry.key)}>✕</button>
-						</div>
-						<div class="entry-value">{formatValue(entry.key, entry.value)}</div>
-					</div>
-				{/each}
-			{/if}
-		</div>
-	{/if}
-
-	<div class="actions">
-		<button class="btn-add" onclick={() => showAddDialog = true}>
-			+ Eintrag hinzufügen
-		</button>
-		<button class="btn-refresh" onclick={loadEntries} disabled={loading}>
-			🔄 Aktualisieren
-		</button>
-	</div>
-</div>
-
-<!-- Dialog: Neuer Eintrag -->
-{#if showAddDialog}
-	<div class="modal-overlay" onclick={() => showAddDialog = false}>
-		<div class="modal-content" onclick={(e) => e.stopPropagation()}>
-			<div class="modal-header">
-				<h3>📌 Neuer Sticky-Context-Eintrag</h3>
-				<button class="btn-close" onclick={() => showAddDialog = false}>✕</button>
-			</div>
-			<div class="modal-body">
-				<div class="form-group">
-					<label for="entry-type">Typ</label>
-					<select id="entry-type" bind:value={newEntry.type}>
-						{#each entryTypes as type}
-							<option value={type.id}>{type.icon} {type.label}</option>
-						{/each}
-					</select>
-				</div>
-
-				{#if newEntry.type !== 'user_info'}
-					<div class="form-group">
-						<label for="entry-key">
-							{#if newEntry.type === 'rule'}Name der Regel{:else if newEntry.type === 'cred'}Name des Zugangs{:else}ID{/if}
-						</label>
-						<input
-							id="entry-key"
-							type="text"
-							bind:value={newEntry.key}
-							placeholder={newEntry.type === 'cred' ? 'z.B. dolibarr-test' : 'z.B. keine-force-push'}
-						/>
-					</div>
-				{/if}
-
-				<div class="form-group">
-					<label for="entry-value">
-						{#if newEntry.type === 'user_info'}User-Info
-						{:else if newEntry.type === 'cred'}Host (z.B. 192.168.155.11)
-						{:else if newEntry.type === 'project'}Projektname
-						{:else}Regel-Text{/if}
-					</label>
-					<textarea
-						id="entry-value"
-						bind:value={newEntry.value}
-						rows="3"
-						placeholder={newEntry.type === 'user_info' ? 'Eddy, Elektroinstallationsbetrieb ALLES WATT LÄUFT' : ''}
-					></textarea>
-				</div>
-
-				<div class="form-group">
-					<label for="entry-priority">Priorität</label>
-					<select id="entry-priority" bind:value={newEntry.priority}>
-						{#each Object.entries(priorityLabels) as [val, label]}
-							<option value={Number(val)}>{label}</option>
-						{/each}
-					</select>
-				</div>
-
-				<div class="form-actions">
-					<button class="btn-cancel" onclick={() => showAddDialog = false}>
-						Abbrechen
-					</button>
-					<button
-						class="btn-confirm"
-						onclick={addEntry}
-						disabled={!newEntry.value.trim()}
-					>
-						💾 Speichern
-					</button>
-				</div>
-			</div>
-		</div>
-	</div>
-{/if}
-
-<style>
-	.context-panel {
-		padding: var(--spacing-md);
-		height: 100%;
-		display: flex;
-		flex-direction: column;
-	}
-
-	.panel-header {
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		margin-bottom: var(--spacing-sm);
-	}
-
-	.panel-header h2 {
-		font-size: 1rem;
-		font-weight: 600;
-	}
-
-	.btn-preview {
-		padding: 2px 8px;
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		font-size: 0.7rem;
-	}
-
-	.info-box {
-		padding: var(--spacing-sm);
-		background: rgba(59, 130, 246, 0.1);
-		border: 1px solid var(--accent);
-		border-radius: var(--radius-sm);
-		font-size: 0.75rem;
-		color: var(--text-secondary);
-		margin-bottom: var(--spacing-md);
-	}
-
-	.token-count {
-		color: var(--accent);
-		font-weight: 600;
-	}
-
-	.entries-list {
-		flex: 1;
-		overflow-y: auto;
-		display: flex;
-		flex-direction: column;
-		gap: var(--spacing-sm);
-	}
-
-	.loading, .empty-state {
-		text-align: center;
-		padding: var(--spacing-xl);
-		color: var(--text-secondary);
-		font-size: 0.875rem;
-	}
-
-	.entry-item {
-		padding: var(--spacing-sm);
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-	}
-
-	.entry-header {
-		display: flex;
-		align-items: center;
-		gap: var(--spacing-xs);
-		margin-bottom: var(--spacing-xs);
-	}
-
-	.entry-icon {
-		font-size: 0.9rem;
-	}
-
-	.entry-key {
-		flex: 1;
-		font-weight: 600;
-		font-size: 0.875rem;
-	}
-
-	.entry-priority {
-		font-size: 0.65rem;
-		padding: 1px 4px;
-		background: var(--bg-tertiary);
-		border-radius: var(--radius-sm);
-		color: var(--text-secondary);
-	}
-
-	.entry-priority.critical {
-		background: var(--error);
-		color: white;
-	}
-
-	.btn-delete {
-		width: 20px;
-		height: 20px;
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		background: transparent;
-		border-radius: var(--radius-sm);
-		font-size: 0.75rem;
-		color: var(--text-secondary);
-		opacity: 0.5;
-	}
-
-	.btn-delete:hover {
-		background: var(--error);
-		color: white;
-		opacity: 1;
-	}
-
-	.entry-value {
-		font-size: 0.75rem;
-		color: var(--text-secondary);
-		font-family: var(--font-mono);
-	}
-
-	.preview-box {
-		flex: 1;
-		overflow: auto;
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		padding: var(--spacing-sm);
-	}
-
-	.preview-box pre {
-		font-size: 0.75rem;
-		white-space: pre-wrap;
-		font-family: var(--font-mono);
-		color: var(--text-primary);
-		margin: 0;
-	}
-
-	.actions {
-		display: flex;
-		gap: var(--spacing-sm);
-		margin-top: var(--spacing-md);
-	}
-
-	.btn-add {
-		flex: 1;
-		padding: var(--spacing-sm);
-		background: var(--accent);
-		color: white;
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-		font-weight: 500;
-	}
-
-	.btn-refresh {
-		padding: var(--spacing-sm);
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-	}
-
-	/* Modal */
-	.modal-overlay {
-		position: fixed;
-		top: 0;
-		left: 0;
-		right: 0;
-		bottom: 0;
-		background: rgba(0, 0, 0, 0.7);
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		z-index: 100;
-	}
-
-	.modal-content {
-		background: var(--bg-primary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-lg);
-		max-width: 450px;
-		width: 90%;
-		overflow: hidden;
-	}
-
-	.modal-header {
-		display: flex;
-		justify-content: space-between;
-		align-items: center;
-		padding: var(--spacing-md);
-		border-bottom: 1px solid var(--border);
-	}
-
-	.modal-header h3 {
-		font-size: 1rem;
-		font-weight: 600;
-	}
-
-	.btn-close {
-		width: 28px;
-		height: 28px;
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		background: var(--bg-secondary);
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-		color: var(--text-secondary);
-	}
-
-	.modal-body {
-		padding: var(--spacing-md);
-	}
-
-	.form-group {
-		margin-bottom: var(--spacing-md);
-	}
-
-	.form-group label {
-		display: block;
-		font-size: 0.75rem;
-		font-weight: 500;
-		color: var(--text-secondary);
-		margin-bottom: var(--spacing-xs);
-	}
-
-	.form-group input,
-	.form-group select,
-	.form-group textarea {
-		width: 100%;
-		padding: var(--spacing-sm);
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-		color: var(--text-primary);
-	}
-
-	.form-group textarea {
-		resize: vertical;
-		font-family: var(--font-mono);
-	}
-
-	.form-actions {
-		display: flex;
-		gap: var(--spacing-sm);
-		justify-content: flex-end;
-		margin-top: var(--spacing-md);
-	}
-
-	.btn-cancel {
-		padding: var(--spacing-sm) var(--spacing-md);
-		background: var(--bg-secondary);
-		border: 1px solid var(--border);
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-	}
-
-	.btn-confirm {
-		padding: var(--spacing-sm) var(--spacing-md);
-		background: var(--accent);
-		color: white;
-		border-radius: var(--radius-sm);
-		font-size: 0.875rem;
-		font-weight: 500;
-	}
-
-	.btn-confirm:disabled {
-		background: var(--bg-tertiary);
-		color: var(--text-secondary);
-	}
-</style>

src/routes/+page.svelte

@@ -6,7 +6,6 @@
 	import AgentView from '$lib/components/AgentView.svelte';
 	import MemoryPanel from '$lib/components/MemoryPanel.svelte';
 	import KnowledgePanel from '$lib/components/KnowledgePanel.svelte';
-	import ContextPanel from '$lib/components/ContextPanel.svelte';
 	import AuditLog from '$lib/components/AuditLog.svelte';
 	import GuardRailsPanel from '$lib/components/GuardRailsPanel.svelte';
 	import SettingsPanel from '$lib/components/SettingsPanel.svelte';
@@ -25,7 +24,6 @@
 
 	const rightTabs = [
 		{ id: 'agents', label: 'Agents', icon: '🤖' },
-		{ id: 'context', label: 'Context', icon: '📌' },
 		{ id: 'guards', label: 'Guard-Rails', icon: '🛡️' },
 		{ id: 'settings', label: 'Settings', icon: '⚙️' },
 	];
@@ -98,8 +96,6 @@
 		<div class="panel-content">
 			{#if activeRightTab === 'agents'}
 				<AgentView />
-			{:else if activeRightTab === 'context'}
-				<ContextPanel />
 			{:else if activeRightTab === 'guards'}
 				<GuardRailsPanel />
 			{:else if activeRightTab === 'settings'}