Phase 9: Intelligentes Context-Management

- context.rs: Drei-Schichten-Gedächtnis (Sticky, Projekt, Wissens-Hints)
- StickyContext für kritische Infos (User, Credentials, Regeln)
- ProjectContext für Entscheidungen und TODOs nach Compacting
- DB-Schema: sticky_context, compacting_archive, context_failures
- ContextPanel.svelte: UI zur Verwaltung des Sticky Context
- Neuer Tab "Context" im rechten Panel

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

ROADMAP.md

@@ -32,6 +32,7 @@ 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)** | ✅ | (pending) |
 
 ---
 
@@ -184,7 +185,9 @@ Die App hat keinen direkten Zugriff auf die zentrale Wissensbasis (`claude` DB a
 
 ---
 
-## Phase 9: Intelligentes Context-Management (WICHTIG)
+## Phase 9: Intelligentes Context-Management ✅ ERLEDIGT
+
+> **Commit:** (pending)
 
 ### Das Problem: Context-Verlust nach Compacting
 
@@ -217,108 +220,52 @@ Compacting ist **notwendig** (Token-Limit, Kosten, Latenz), aber dabei geht krit
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### Aufgaben
+### Implementiert
 
-- [ ] **src-tauri/src/context.rs** (NEU)
+- ✅ **src-tauri/src/context.rs** (NEU)
-  - [ ] `StickyContext` Struct (Schicht 1)
+  - `StickyContext` Struct (Schicht 1) — User-Info, Credentials, Projekt, Regeln
-  - [ ] `ProjectContext` Struct (Schicht 2)
+  - `ProjectContext` Struct (Schicht 2) — Entscheidungen, TODOs, Insights
-  - [ ] `get_sticky_context()` → ~200 Token
+  - `ExtractedContext` — Kontext vor Compacting extrahieren
-  - [ ] `get_project_context(project_id)` → ~500 Token
+  - `render()` Methoden für System-Prompt-Integration
-  - [ ] `extract_critical_before_compacting()` → JSON
+  - Token-Schätzung mit `estimate_tokens()`
 
-- [ ] **src-tauri/src/credentials.rs** (NEU)
+- ✅ **Datenbank-Schema** (SQLite)
-  - [ ] Credentials aus DB laden (verschlüsselt)
+  - `sticky_context` Tabelle (key, value, priority)
-  - [ ] `inject_for_context(tool_name)` → Zugang wenn nötig
+  - `compacting_archive` Tabelle (Entscheidungen, TODOs, etc.)
-  - [ ] Credentials NIE im Chat-Verlauf speichern
+  - `context_failures` Tabelle (für Prompt-Optimierung)
 
-- [ ] **scripts/claude-bridge.js**
+- ✅ **Tauri-Commands**
-  - [ ] Schicht 1 bei jedem `query()` Call als System-Prompt
+  - `get_sticky_context()` — Schicht 1 laden
-  - [ ] Hook vor Compacting: `extract_critical_before_compacting()`
+  - `set_sticky_context()` — Eintrag setzen
-  - [ ] Hook nach Compacting: `restore_critical_context()`
+  - `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
 
-- [ ] **Datenbank-Schema** (SQLite lokal)
+- ✅ **src/lib/components/ContextPanel.svelte** (NEU)
-  ```sql
+  - Sticky-Context-Einträge anzeigen/bearbeiten
-  CREATE TABLE sticky_context (
+  - Eintrags-Typen: User-Info, Regeln, Credentials, Projekt
-    key TEXT PRIMARY KEY,
+  - Prioritäts-Management (1=kritisch bis 4=niedrig)
-    value TEXT,
+  - Vorschau des gerenderten Context
-    priority INT  -- 1=kritisch, niemals entfernen
+  - Token-Anzeige
-  );
 
-  CREATE TABLE compacting_archive (
+- ✅ **src/routes/+page.svelte**
-    id INTEGER PRIMARY KEY,
+  - Neuer Tab "📌 Context" im rechten Panel
-    session_id TEXT,
-    extracted_at TEXT,
-    decisions JSON,
-    open_questions JSON,
-    key_insights JSON
-  );
-  ```
 
-- [ ] **Pre-Tool-Hook: Wissens-Hints**
+### Noch offen (niedrigere Priorität)
-  - [ ] Bei Tool-Aufruf: Schlüsselwörter extrahieren
-  - [ ] Claude-DB nach relevantem Wissen durchsuchen
-  - [ ] Als `<knowledge-hint>` injizieren (max 200 Token)
 
-### Wichtig: Nicht ALLES wiederherstellen!
+- [ ] **Bridge-Integration** — Context bei jedem API-Call injizieren
-
+- [ ] **Auto-Extraction vor Compacting** — Hook automatisch auslösen
-```
+- [ ] **Validation** — Prüfen ob Claude den Context nutzt
-❌ FALSCH: 130.000 Token zurück injizieren
+- [ ] **Wissens-Hints** — On-demand aus claude-db laden
-   → 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
+# Context-Panel öffnen → Einträge hinzufügen
-# Danach: Zugänge noch bekannt? Projekt-Kontext da?
+# Vorschau → <critical-context> Tags sichtbar
-# Tool aufrufen → Relevante Hints erscheinen?
+# Token-Anzeige zeigt ~200 Token
 ```
 
 ---

src-tauri/src/context.rs

@@ -0,0 +1,591 @@
+// 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,6 +10,7 @@ use tauri::{
 
 mod audit;
 mod claude;
+mod context;
 mod db;
 mod guard;
 mod knowledge;
@@ -74,6 +75,15 @@ 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

@@ -0,0 +1,570 @@
+<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,6 +6,7 @@
 	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';
@@ -24,6 +25,7 @@
 
 	const rightTabs = [
 		{ id: 'agents', label: 'Agents', icon: '🤖' },
+		{ id: 'context', label: 'Context', icon: '📌' },
 		{ id: 'guards', label: 'Guard-Rails', icon: '🛡️' },
 		{ id: 'settings', label: 'Settings', icon: '⚙️' },
 	];
@@ -96,6 +98,8 @@
 		<div class="panel-content">
 			{#if activeRightTab === 'agents'}
 				<AgentView />
+			{:else if activeRightTab === 'context'}
+				<ContextPanel />
 			{:else if activeRightTab === 'guards'}
 				<GuardRailsPanel />
 			{:else if activeRightTab === 'settings'}