From 8312d2491208bae34390bef3d6259a72aa45ffc6 Mon Sep 17 00:00:00 2001
From: claude-dev <claude-dev@aegis-sight.de>
Date: Wed, 4 Mar 2026 17:53:18 +0100
Subject: [PATCH] Initial commit: AegisSight-Monitor (OSINT-Monitoringsystem)

---
 .gitignore                               |    6 +
 CLAUDE.md                                |  121 +
 data                                     |    1 +
 requirements.txt                         |   11 +
 setup_users.py                           |   63 +
 src/agents/analyzer.py                   |  169 +
 src/agents/claude_client.py              |   88 +
 src/agents/factchecker.py                |  143 +
 src/agents/orchestrator.py               |  893 +++++
 src/agents/researcher.py                 |  236 ++
 src/auth.py                              |  106 +
 src/config.py                            |   74 +
 src/database.py                          |  504 +++
 src/email_utils/__init__.py              |    0
 src/email_utils/rate_limiter.py          |  102 +
 src/email_utils/sender.py                |   54 +
 src/email_utils/templates.py             |  138 +
 src/feeds/rss_parser.py                  |  157 +
 src/main.py                              |  331 ++
 src/middleware/__init__.py               |    0
 src/middleware/license_check.py          |   51 +
 src/migration/__init__.py                |    0
 src/migration/migrate_to_multitenancy.py |  177 +
 src/models.py                            |  245 ++
 src/routers/auth.py                      |  276 ++
 src/routers/feedback.py                  |  115 +
 src/routers/incidents.py                 |  636 ++++
 src/routers/notifications.py             |   62 +
 src/routers/sources.py                   |  527 +++
 src/rss_parser.py                        |  102 +
 src/services/__init__.py                 |    0
 src/services/license_service.py          |  117 +
 src/source_rules.py                      |  680 ++++
 src/static/apple-touch-icon.png          |  Bin 0 -> 8787 bytes
 src/static/components.js                 |  444 +++
 src/static/css/style.css                 | 4027 ++++++++++++++++++++++
 src/static/dashboard.html                |  541 +++
 src/static/favicon-16x16.png             |  Bin 0 -> 568 bytes
 src/static/favicon-192x192.png           |  Bin 0 -> 9506 bytes
 src/static/favicon-32x32.png             |  Bin 0 -> 1314 bytes
 src/static/favicon-48x48.png             |  Bin 0 -> 2163 bytes
 src/static/favicon-512x512.png           |  Bin 0 -> 27209 bytes
 src/static/favicon.ico                   |  Bin 0 -> 590 bytes
 src/static/index.html                    |  212 ++
 src/static/js/api.js                     |  196 ++
 src/static/js/app.js                     | 2813 +++++++++++++++
 src/static/js/components.js              |  625 ++++
 src/static/js/layout.js                  |  282 ++
 src/static/js/ws.js                      |  105 +
 src/static/layout.js                     |  272 ++
 src/static/style.css                     | 3653 ++++++++++++++++++++
 51 files changed, 19355 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 CLAUDE.md
 create mode 120000 data
 create mode 100644 requirements.txt
 create mode 100644 setup_users.py
 create mode 100644 src/agents/analyzer.py
 create mode 100644 src/agents/claude_client.py
 create mode 100644 src/agents/factchecker.py
 create mode 100644 src/agents/orchestrator.py
 create mode 100644 src/agents/researcher.py
 create mode 100644 src/auth.py
 create mode 100644 src/config.py
 create mode 100644 src/database.py
 create mode 100644 src/email_utils/__init__.py
 create mode 100644 src/email_utils/rate_limiter.py
 create mode 100644 src/email_utils/sender.py
 create mode 100644 src/email_utils/templates.py
 create mode 100644 src/feeds/rss_parser.py
 create mode 100644 src/main.py
 create mode 100644 src/middleware/__init__.py
 create mode 100644 src/middleware/license_check.py
 create mode 100644 src/migration/__init__.py
 create mode 100644 src/migration/migrate_to_multitenancy.py
 create mode 100644 src/models.py
 create mode 100644 src/routers/auth.py
 create mode 100644 src/routers/feedback.py
 create mode 100644 src/routers/incidents.py
 create mode 100644 src/routers/notifications.py
 create mode 100644 src/routers/sources.py
 create mode 100644 src/rss_parser.py
 create mode 100644 src/services/__init__.py
 create mode 100644 src/services/license_service.py
 create mode 100644 src/source_rules.py
 create mode 100644 src/static/apple-touch-icon.png
 create mode 100644 src/static/components.js
 create mode 100644 src/static/css/style.css
 create mode 100644 src/static/dashboard.html
 create mode 100644 src/static/favicon-16x16.png
 create mode 100644 src/static/favicon-192x192.png
 create mode 100644 src/static/favicon-32x32.png
 create mode 100644 src/static/favicon-48x48.png
 create mode 100644 src/static/favicon-512x512.png
 create mode 100644 src/static/favicon.ico
 create mode 100644 src/static/index.html
 create mode 100644 src/static/js/api.js
 create mode 100644 src/static/js/app.js
 create mode 100644 src/static/js/components.js
 create mode 100644 src/static/js/layout.js
 create mode 100644 src/static/js/ws.js
 create mode 100644 src/static/layout.js
 create mode 100644 src/static/style.css

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1bf21af
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.env
+logs/
+data/
+.venv/
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..d910077
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,121 @@
+# OSINT Lagemonitor
+
+> Lokale Arbeitskopie für das OSINT-Monitor-Projekt auf Server `alt`
+
+## Übersicht
+
+```yaml
+projekt: osint-monitor
+url: https://osint.intelsight.de
+beschreibung: "OSINT-basiertes Lagemonitoring mit Claude-KI-Agenten"
+server: alt (91.99.192.14, User: claude-dev)
+pfad_server: /home/claude-dev/osint-monitor
+pfad_lokal: C:\Users\Administrator\Desktop\OSINT-monitor
+status: aktiv (systemd service läuft)
+```
+
+## Technologie-Stack
+
+```yaml
+backend:
+  framework: FastAPI (Python 3, venv /home/claude-dev/.venvs/osint/)
+  datenbank: SQLite (WAL-Modus, aiosqlite) @ /mnt/gitea/osint-data/osint.db
+  auth: JWT (HS256, bcrypt, 24h Ablauf)
+  scheduler: APScheduler (Auto-Refresh jede Minute + Cleanup stündlich)
+  websocket: FastAPI native
+  ki_agenten: Claude CLI (WebSearch + WebFetch Tools)
+  port: 8891 (localhost, Nginx Reverse Proxy)
+
+frontend:
+  typ: Vanilla JS (kein Framework)
+  design: AegisSight Dark Theme (Navy/Gold)
+  fonts: Poppins (Titel), Inter (Body)
+  echtzeit: WebSocket mit Auto-Reconnect
+```
+
+## Projektstruktur
+
+```yaml
+osint-monitor/:
+  CLAUDE.md: "Projektdokumentation"
+  requirements.txt: "Python-Abhängigkeiten"
+  setup_users.py: "Nutzer-Initialisierung (rac00n, ch33tah)"
+  data/: "Symlink -> /mnt/gitea/osint-data/ (SQLite DB)"
+  logs/: "Anwendungs-Logs"
+  src/:
+    main.py: "FastAPI App, WebSocket-Manager, Scheduler, Lifespan"
+    config.py: "Konfiguration (JWT, Claude CLI, RSS-Feeds, Excluded Sources)"
+    auth.py: "JWT-Authentifizierung (bcrypt, HTTPBearer)"
+    database.py: "SQLite Schema + Migrationen (8 Tabellen: users, incidents, articles, fact_checks, refresh_log, incident_snapshots, sources, notifications)"
+    models.py: "Pydantic Request/Response-Schemas (inkl. Source CRUD + Notifications)"
+    source_rules.py: "Dynamische Quellen-Regeln aus DB (RSS-Feeds + Blacklist)"
+    routers/:
+      auth.py: "POST /api/auth/login, GET /api/auth/me"
+      incidents.py: "CRUD /api/incidents, /api/incidents/{id}/articles|factchecks|refresh"
+      sources.py: "CRUD /api/sources, /api/sources/stats, /api/sources/refresh-counts"
+      notifications.py: "GET /api/notifications, GET /api/notifications/unread-count, PUT /api/notifications/mark-read"
+      feedback.py: "POST /api/feedback (Rate-Limited, HTML-E-Mail an feedback@aegis-sight.de)"
+    agents/:
+      claude_client.py: "Shared Claude CLI Client mit JSON-Output + Usage-Tracking (ClaudeUsage, UsageAccumulator)"
+      orchestrator.py: "AsyncQueue, koordiniert Agenten-Pipeline sequentiell, Token-Akkumulation + Snapshots + DB-Notifications"
+      researcher.py: "Claude WebSearch Agent (Ad-hoc + Deep Research Modus)"
+      analyzer.py: "Analyse-Agent (Zusammenfassung + Briefing-Format)"
+      factchecker.py: "Faktencheck-Agent (quellengebunden)"
+    feeds/:
+      rss_parser.py: "RSS-Feed Aggregation (dynamisch aus DB, Fallback auf config.py)"
+    static/:
+      index.html: "Login-Seite"
+      dashboard.html: "Hauptdashboard"
+      css/style.css: "AegisSight Design System"
+      js/: "api.js, app.js, components.js, ws.js"
+```
+
+## Architektur
+
+```yaml
+agenten_pipeline:
+  1_rss: "RSS-Feeds durchsuchen (nur Ad-hoc-Lagen)"
+  2_claude_recherche: "Claude CLI WebSearch (Ad-hoc oder Deep Research)"
+  3_analyse: "Zusammenfassung/Briefing mit Inline-Zitaten [1][2] + sources_json"
+  4_faktencheck: "Claims gegen unabhängige Quellen prüfen"
+  orchestrierung: "Sequentielle Queue (1 Auftrag gleichzeitig)"
+
+incident_typen:
+  adhoc: "Breaking News -> RSS + WebSearch -> Plaintext-Summary mit Quellenreferenzen"
+  research: "Hintergrundrecherche -> Nur Deep Research -> Markdown-Briefing mit Quellenverzeichnis"
+
+internationale_quellen:
+  toggle: "Pro Lage konfigurierbar (Checkbox beim Anlegen/Bearbeiten)"
+  international_true: "DE + internationale Feeds (Reuters, BBC, Al Jazeera) + mehrsprachige Claude-Recherche"
+  international_false: "Nur deutschsprachige Quellen (DE, AT, CH), internationale RSS-Kategorie übersprungen"
+  db_feld: "international_sources INTEGER DEFAULT 1"
+  betroffene_agenten: "RSSParser (Kategorien-Filter), ResearcherAgent (Sprach-Prompts), Orchestrator (Weiterleitung)"
+
+quellenanzeige:
+  inline_zitate: "Klickbare [1][2] Verweise im Lagebild → Quellenverzeichnis"
+  quellenverzeichnis: "Am Ende des Lagebilds, nummeriert mit Links"
+  quellenübersicht: "Aggregierte Ansicht aller Quellen pro Lage mit Sprach-Statistik"
+  timeline_expand: "Artikel klickbar → Inhaltsvorschau + Link zum Original"
+  sprach_badges: "EN/FR etc. Badge bei fremdsprachigen Artikeln"
+  evidence_text: "Faktencheck zeigt erklärenden Text + Quellen-Chips"
+  deduplizierung: "URL-Normalisierung + Headline-Ähnlichkeit (www, trailing slash, query params)"
+
+benachrichtigungen:
+  persistenz: "DB-Tabelle notifications (pro Nutzer, 7 Tage Aufbewahrung)"
+  erzeugung: "Orchestrator schreibt nach refresh_summary in DB (öffentlich=alle Nutzer, privat=nur Ersteller)"
+  frontend: "NotificationCenter lädt aus DB beim Init, optimistisches UI bei WebSocket-Events, Debounced DB-Sync"
+  gelesen: "Als gelesen markieren (is_read=1) → visuell abgeblendet, nicht gelöscht"
+  tab_badge: "document.title = '(N) IntelSight...' bei ungelesenen Notifications"
+  cleanup: "Stündlicher Job löscht Notifications älter als 7 Tage"
+
+quellenverwaltung:
+  db_tabelle: "sources (id, name, url, domain, source_type, category, status, notes, added_by, article_count, last_seen_at, created_at)"
+  source_types: "rss_feed | web_source | excluded"
+  kategorien: "nachrichtenagentur, oeffentlich-rechtlich, qualitaetszeitung, behoerde, fachmedien, think-tank, international, regional, sonstige"
+  seeding: "Beim Start aus config.py RSS_FEEDS + EXCLUDED_SOURCES (wenn Tabelle leer)"
+  dynamisch: "source_rules.py liest aktive Quellen aus DB, Fallback auf config.py"
+  frontend: "Modal mit Filter, Suche, Inline-Formular; Sidebar: 'Quellen verwalten' Button + Mini-Stats"
+
+deployment:
+  workflow: "scp Dateien -> ssh alt -> systemctl restart osint-monitor"
+```
diff --git a/data b/data
new file mode 120000
index 0000000..e4e4dbf
--- /dev/null
+++ b/data
@@ -0,0 +1 @@
+/mnt/gitea/osint-data
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..7b944e4
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,11 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+python-jose[cryptography]
+passlib[bcrypt]
+aiosqlite
+feedparser
+httpx
+apscheduler==3.10.4
+websockets
+python-multipart
+aiosmtplib
diff --git a/setup_users.py b/setup_users.py
new file mode 100644
index 0000000..0071fed
--- /dev/null
+++ b/setup_users.py
@@ -0,0 +1,63 @@
+"""Erstellt die initialen Nutzer für den OSINT Lagemonitor."""
+import asyncio
+import os
+import sys
+import secrets
+import string
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from database import init_db, get_db
+from auth import hash_password
+
+
+def generate_password(length=16):
+    """Generiert ein sicheres Passwort."""
+    alphabet = string.ascii_letters + string.digits + "!@#$%&*"
+    return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+
+async def main():
+    await init_db()
+    db = await get_db()
+
+    users = [
+        {"username": "rac00n", "password": generate_password()},
+        {"username": "ch33tah", "password": generate_password()},
+    ]
+
+    print("\n=== OSINT Lagemonitor - Nutzer-Setup ===\n")
+
+    for user in users:
+        cursor = await db.execute(
+            "SELECT id FROM users WHERE username = ?", (user["username"],)
+        )
+        existing = await cursor.fetchone()
+
+        if existing:
+            # Passwort aktualisieren
+            pw_hash = hash_password(user["password"])
+            await db.execute(
+                "UPDATE users SET password_hash = ? WHERE username = ?",
+                (pw_hash, user["username"]),
+            )
+            print(f"  Nutzer '{user['username']}' - Passwort aktualisiert")
+        else:
+            pw_hash = hash_password(user["password"])
+            await db.execute(
+                "INSERT INTO users (username, password_hash) VALUES (?, ?)",
+                (user["username"], pw_hash),
+            )
+            print(f"  Nutzer '{user['username']}' - Erstellt")
+
+        print(f"  Passwort: {user['password']}")
+        print()
+
+    await db.commit()
+    await db.close()
+
+    print("WICHTIG: Passwörter jetzt notieren! Sie werden nicht erneut angezeigt.\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/src/agents/analyzer.py b/src/agents/analyzer.py
new file mode 100644
index 0000000..0f406a5
--- /dev/null
+++ b/src/agents/analyzer.py
@@ -0,0 +1,169 @@
+"""Analyzer-Agent: Analysiert, übersetzt und fasst Meldungen zusammen."""
+import asyncio
+import json
+import logging
+import re
+from datetime import datetime
+from config import TIMEZONE
+from agents.claude_client import call_claude, ClaudeUsage
+
+logger = logging.getLogger("osint.analyzer")
+
+ANALYSIS_PROMPT_TEMPLATE = """Du bist ein OSINT-Analyse-Agent für ein Lagemonitoring-System.
+HEUTIGES DATUM: {today}
+AUSGABESPRACHE: {output_language}
+
+VORFALL: {title}
+KONTEXT: {description}
+
+VORHANDENE MELDUNGEN:
+{articles_text}
+
+AUFTRAG:
+1. Erstelle eine neutrale, faktenbasierte Zusammenfassung auf {output_language} (max. 500 Wörter)
+2. Verwende Inline-Quellenverweise [1], [2], [3] etc. im Zusammenfassungstext
+3. Liste die bestätigten Kernfakten auf
+4. Übersetze fremdsprachige Überschriften und Inhalte in die Ausgabesprache
+
+STRUKTUR:
+- Wenn die Meldungen thematisch klar einen einzelnen Strang behandeln: Fließtext ohne Überschriften
+- Wenn verschiedene Aspekte oder Themenfelder aufkommen (z.B. Ereignis + Reaktionen + Hintergrund): Gliedere mit kurzen Markdown-Zwischenüberschriften (##)
+- Die Entscheidung liegt bei dir — Überschriften nur wenn sie dem Leser helfen, verschiedene Themenstränge auseinanderzuhalten
+
+REGELN:
+- Neutral und sachlich - keine Wertungen oder Spekulationen
+- Nur gesicherte Informationen in die Zusammenfassung
+- Bei widersprüchlichen Angaben beide Seiten erwähnen
+- Quellen immer mit [Nr] referenzieren
+- Jede verwendete Quelle MUSS im sources-Array aufgelistet sein
+- Nummeriere die Quellen fortlaufend ab [1]
+- Ältere Quellen zeitlich einordnen (z.B. "laut einem Bericht vom Januar", "Anfang Februar berichtete...")
+
+Antworte AUSSCHLIESSLICH als JSON-Objekt mit diesen Feldern:
+- "summary": Zusammenfassung auf {output_language} mit Quellenverweisen [1], [2] etc. im Text (Markdown-Überschriften ## erlaubt wenn sinnvoll)
+- "sources": Array von Quellenobjekten, je: {{"nr": 1, "name": "Quellenname", "url": "https://..."}}
+- "key_facts": Array von bestätigten Kernfakten (Strings, in Ausgabesprache)
+- "translations": Array von Objekten mit "article_id", "headline_de", "content_de" (nur für fremdsprachige Artikel)
+
+Antworte NUR mit dem JSON-Objekt. Keine Einleitung, keine Erklärung."""
+
+BRIEFING_PROMPT_TEMPLATE = """Du bist ein OSINT-Analyse-Agent für ein Lagemonitoring-System.
+Du erstellst ein strukturiertes Briefing für eine Hintergrundrecherche.
+HEUTIGES DATUM: {today}
+AUSGABESPRACHE: {output_language}
+
+THEMA: {title}
+KONTEXT: {description}
+
+VORLIEGENDE QUELLEN:
+{articles_text}
+
+AUFTRAG:
+Erstelle ein strukturiertes Briefing (max. 800 Wörter) auf {output_language} mit folgenden Abschnitten.
+Verwende durchgehend Inline-Quellenverweise [1], [2], [3] etc. im Text.
+
+## ÜBERBLICK
+Kurze Einordnung des Themas (2-3 Sätze)
+
+## HINTERGRUND
+Historischer Kontext, relevante Vorgeschichte
+
+## AKTEURE
+Beteiligte Personen, Organisationen, Institutionen und ihre Rollen
+
+## AKTUELLE LAGE
+Was ist der aktuelle Stand? Welche Entwicklungen gibt es?
+
+## EINSCHÄTZUNG
+Sachliche Bewertung der Situation, mögliche Entwicklungen
+
+## QUELLENQUALITÄT
+Kurze Bewertung der Informationslage: Wie belastbar sind die vorliegenden Quellen?
+
+REGELN:
+- Neutral und sachlich - keine Wertungen oder Spekulationen
+- Nur gesicherte Informationen verwenden
+- Bei widersprüchlichen Angaben beide Seiten erwähnen
+- Quellen immer mit [Nr] referenzieren
+- Jede verwendete Quelle MUSS im sources-Array aufgelistet sein
+- Nummeriere die Quellen fortlaufend ab [1]
+- Ältere Quellen zeitlich einordnen (z.B. "laut einem Bericht vom Januar", "Anfang Februar berichtete...")
+- Markdown-Überschriften (##) für die Abschnitte verwenden
+- Fettdruck (**) für Schlüsselbegriffe erlaubt
+
+Antworte AUSSCHLIESSLICH als JSON-Objekt mit diesen Feldern:
+- "summary": Das strukturierte Briefing als Markdown-Text mit Quellenverweisen [1], [2] etc.
+- "sources": Array von Quellenobjekten, je: {{"nr": 1, "name": "Quellenname", "url": "https://..."}}
+- "key_facts": Array von gesicherten Kernfakten (Strings, in Ausgabesprache)
+- "translations": Array von Objekten mit "article_id", "headline_de", "content_de" (nur für fremdsprachige Artikel)
+
+Antworte NUR mit dem JSON-Objekt. Keine Einleitung, keine Erklärung."""
+
+
+class AnalyzerAgent:
+    """Analysiert und übersetzt Meldungen über Claude CLI."""
+
+    async def analyze(self, title: str, description: str, articles: list[dict], incident_type: str = "adhoc") -> tuple[dict | None, ClaudeUsage | None]:
+        """Analysiert alle Meldungen zu einem Vorfall."""
+        if not articles:
+            return None, None
+
+        # Artikel-Text für Prompt aufbereiten
+        articles_text = ""
+        for i, article in enumerate(articles[:30]):  # Max 30 Artikel um Prompt-Länge zu begrenzen
+            articles_text += f"\n--- Meldung {i+1} (ID: {article.get('id', 'neu')}) ---\n"
+            articles_text += f"Quelle: {article.get('source', 'Unbekannt')}\n"
+            url = article.get('source_url', '')
+            if url:
+                articles_text += f"URL: {url}\n"
+            articles_text += f"Sprache: {article.get('language', 'de')}\n"
+            published = article.get('published_at', '')
+            if published:
+                articles_text += f"Veröffentlicht: {published}\n"
+            headline = article.get('headline_de') or article.get('headline', '')
+            articles_text += f"Überschrift: {headline}\n"
+            content = article.get('content_de') or article.get('content_original', '')
+            if content:
+                articles_text += f"Inhalt: {content[:500]}\n"
+
+        from config import OUTPUT_LANGUAGE
+        today = datetime.now(TIMEZONE).strftime("%d.%m.%Y")
+        template = BRIEFING_PROMPT_TEMPLATE if incident_type == "research" else ANALYSIS_PROMPT_TEMPLATE
+        prompt = template.format(
+            title=title,
+            description=description or "Keine weiteren Details",
+            articles_text=articles_text,
+            today=today,
+            output_language=OUTPUT_LANGUAGE,
+        )
+
+        try:
+            result, usage = await call_claude(prompt)
+            analysis = self._parse_response(result)
+            if analysis:
+                logger.info(f"Analyse abgeschlossen: {len(analysis.get('sources', []))} Quellen referenziert")
+            return analysis, usage
+        except Exception as e:
+            logger.error(f"Analyse-Fehler: {e}")
+            return None, None
+
+    def _parse_response(self, response: str) -> dict | None:
+        """Parst die Claude-Antwort als JSON-Objekt."""
+        try:
+            data = json.loads(response)
+            if isinstance(data, dict):
+                return data
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r'\{.*\}', response, re.DOTALL)
+        if match:
+            try:
+                data = json.loads(match.group())
+                if isinstance(data, dict):
+                    return data
+            except json.JSONDecodeError:
+                pass
+
+        logger.warning("Konnte Analyse-Antwort nicht als JSON parsen")
+        return None
diff --git a/src/agents/claude_client.py b/src/agents/claude_client.py
new file mode 100644
index 0000000..d8eafa0
--- /dev/null
+++ b/src/agents/claude_client.py
@@ -0,0 +1,88 @@
+"""Shared Claude CLI Client mit Usage-Tracking."""
+import asyncio
+import json
+import logging
+from dataclasses import dataclass
+from config import CLAUDE_PATH, CLAUDE_TIMEOUT
+
+logger = logging.getLogger("osint.claude_client")
+
+
+@dataclass
+class ClaudeUsage:
+    """Token-Verbrauch eines einzelnen Claude CLI Aufrufs."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cache_read_tokens: int = 0
+    cost_usd: float = 0.0
+    duration_ms: int = 0
+
+
+@dataclass
+class UsageAccumulator:
+    """Akkumuliert Usage über mehrere Claude-Aufrufe eines Refreshs."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cache_read_tokens: int = 0
+    total_cost_usd: float = 0.0
+    call_count: int = 0
+
+    def add(self, usage: ClaudeUsage):
+        self.input_tokens += usage.input_tokens
+        self.output_tokens += usage.output_tokens
+        self.cache_creation_tokens += usage.cache_creation_tokens
+        self.cache_read_tokens += usage.cache_read_tokens
+        self.total_cost_usd += usage.cost_usd
+        self.call_count += 1
+
+
+async def call_claude(prompt: str, tools: str | None = "WebSearch,WebFetch") -> tuple[str, ClaudeUsage]:
+    """Ruft Claude CLI auf. Gibt (result_text, usage) zurück."""
+    cmd = [CLAUDE_PATH, "-p", prompt, "--output-format", "json"]
+    if tools:
+        cmd.extend(["--allowedTools", tools])
+    else:
+        cmd.extend(["--max-turns", "1"])
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+        env={"PATH": "/usr/local/bin:/usr/bin:/bin", "HOME": "/home/claude-dev"},
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=CLAUDE_TIMEOUT)
+    except asyncio.TimeoutError:
+        process.kill()
+        raise TimeoutError(f"Claude CLI Timeout nach {CLAUDE_TIMEOUT}s")
+
+    if process.returncode != 0:
+        error_msg = stderr.decode("utf-8", errors="replace").strip()
+        logger.error(f"Claude CLI Fehler (Exit {process.returncode}): {error_msg}")
+        raise RuntimeError(f"Claude CLI Fehler: {error_msg}")
+
+    raw = stdout.decode("utf-8", errors="replace").strip()
+    usage = ClaudeUsage()
+    result_text = raw
+
+    try:
+        data = json.loads(raw)
+        result_text = data.get("result", raw)
+        u = data.get("usage", {})
+        usage = ClaudeUsage(
+            input_tokens=u.get("input_tokens", 0),
+            output_tokens=u.get("output_tokens", 0),
+            cache_creation_tokens=u.get("cache_creation_input_tokens", 0),
+            cache_read_tokens=u.get("cache_read_input_tokens", 0),
+            cost_usd=data.get("total_cost_usd", 0.0),
+            duration_ms=data.get("duration_ms", 0),
+        )
+        logger.info(
+            f"Claude: {usage.input_tokens} in / {usage.output_tokens} out / "
+            f"cache {usage.cache_creation_tokens}+{usage.cache_read_tokens} / "
+            f"${usage.cost_usd:.4f} / {usage.duration_ms}ms"
+        )
+    except json.JSONDecodeError:
+        logger.warning("Claude CLI Antwort kein gültiges JSON, nutze raw output")
+
+    return result_text, usage
diff --git a/src/agents/factchecker.py b/src/agents/factchecker.py
new file mode 100644
index 0000000..8ae2073
--- /dev/null
+++ b/src/agents/factchecker.py
@@ -0,0 +1,143 @@
+"""Factchecker-Agent: Prüft Fakten gegen mehrere unabhängige Quellen."""
+import asyncio
+import json
+import logging
+import re
+from agents.claude_client import call_claude, ClaudeUsage
+
+logger = logging.getLogger("osint.factchecker")
+
+FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für ein OSINT-Lagemonitoring-System.
+AUSGABESPRACHE: {output_language}
+
+VORFALL: {title}
+
+VORLIEGENDE MELDUNGEN:
+{articles_text}
+
+STRENGE REGELN - KEINE HALLUZINATIONEN:
+- Du darfst NUR Fakten bewerten, die direkt aus den oben übergebenen Meldungen stammen
+- KEINE Fakten aus deinem Trainingskorpus - NUR aus den übergebenen Meldungen + WebSearch
+- Nutze WebSearch um jeden Claim gegen mindestens 1 weitere unabhängige Quelle zu prüfen
+- Rufe die gefundenen URLs per WebFetch ab um den Inhalt zu verifizieren
+- Nur wenn du den Claim in der tatsächlich abgerufenen Quelle findest, darfst du ihn als bestätigt markieren
+- Jeder Claim MUSS eine konkrete Quellen-URL als Beleg enthalten
+- "confirmed" erst bei 2+ unabhängigen Quellen mit überprüfbarer URL
+- Lieber "unconfirmed" als falsch bestätigt
+
+AUFTRAG:
+1. Identifiziere die 5-10 wichtigsten Faktenaussagen aus den Meldungen
+2. Prüfe jeden Claim aktiv per WebSearch gegen mindestens eine weitere unabhängige Quelle
+3. Kategorisiere jede Aussage:
+   - "confirmed": Durch 2+ unabhängige seriöse Quellen mit überprüfbarer URL bestätigt
+   - "unconfirmed": Nur 1 Quelle oder nicht unabhängig verifizierbar
+   - "contradicted": Widersprüchliche Informationen aus verschiedenen Quellen
+   - "developing": Situation noch unklar, entwickelt sich
+4. Markiere WICHTIGE NEUE Entwicklungen mit is_notification: true
+
+Antworte AUSSCHLIESSLICH als JSON-Array. Jedes Element hat:
+- "claim": Die Faktenaussage auf {output_language}
+- "status": "confirmed" | "unconfirmed" | "contradicted" | "developing"
+- "sources_count": Anzahl unabhängiger Quellen mit überprüfbarer URL
+- "evidence": Begründung MIT konkreten Quellen-URLs als Beleg (z.B. "Bestätigt durch: tagesschau.de (URL), Reuters (URL)")
+- "is_notification": true/false (nur bei wichtigen Entwicklungen true)
+
+Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""
+
+RESEARCH_FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für eine Hintergrundrecherche in einem OSINT-Lagemonitoring-System.
+AUSGABESPRACHE: {output_language}
+
+THEMA: {title}
+
+VORLIEGENDE QUELLEN:
+{articles_text}
+
+STRENGE REGELN - KEINE HALLUZINATIONEN:
+- Du darfst NUR Fakten bewerten, die direkt aus den oben übergebenen Quellen stammen
+- KEINE Fakten aus deinem Trainingskorpus - NUR aus den übergebenen Quellen + WebSearch
+- Nutze WebSearch um jeden Claim gegen mindestens 1 weitere unabhängige Quelle zu prüfen
+- Rufe die gefundenen URLs per WebFetch ab um den Inhalt zu verifizieren
+- Nur wenn du den Claim in der tatsächlich abgerufenen Quelle findest, darfst du ihn als gesichert markieren
+- Jeder Claim MUSS eine konkrete Quellen-URL als Beleg enthalten
+- Lieber "unverified" als falsch bestätigt
+
+AUFTRAG:
+Fokus: "Was sind die gesicherten Fakten zu diesem Thema?"
+
+1. Identifiziere die 5-10 wichtigsten Faktenaussagen aus den Quellen
+2. Prüfe jeden Claim aktiv per WebSearch gegen weitere unabhängige Quellen
+3. Kategorisiere jede Aussage:
+   - "established": Breit dokumentierter, gesicherter Fakt (3+ unabhängige Quellen mit URL)
+   - "disputed": Umstrittener Sachverhalt, verschiedene Positionen dokumentiert
+   - "unverified": Einzelbehauptung, nicht unabhängig verifizierbar
+   - "developing": Aktuelle Entwicklung, Faktenlage noch im Fluss
+4. Markiere WICHTIGE Erkenntnisse mit is_notification: true
+
+Antworte AUSSCHLIESSLICH als JSON-Array. Jedes Element hat:
+- "claim": Die Faktenaussage auf {output_language}
+- "status": "established" | "disputed" | "unverified" | "developing"
+- "sources_count": Anzahl unabhängiger Quellen mit überprüfbarer URL
+- "evidence": Begründung MIT konkreten Quellen-URLs als Beleg
+- "is_notification": true/false
+
+Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""
+
+
+class FactCheckerAgent:
+    """Prüft Fakten über Claude CLI gegen unabhängige Quellen."""
+
+    async def check(self, title: str, articles: list[dict], incident_type: str = "adhoc") -> tuple[list[dict], ClaudeUsage | None]:
+        """Führt Faktencheck für eine Lage durch."""
+        if not articles:
+            return [], None
+
+        articles_text = ""
+        for i, article in enumerate(articles[:20]):
+            articles_text += f"\n--- Meldung {i+1} ---\n"
+            articles_text += f"Quelle: {article.get('source', 'Unbekannt')}\n"
+            source_url = article.get('source_url', '')
+            if source_url:
+                articles_text += f"URL: {source_url}\n"
+            headline = article.get('headline_de') or article.get('headline', '')
+            articles_text += f"Überschrift: {headline}\n"
+            content = article.get('content_de') or article.get('content_original', '')
+            if content:
+                articles_text += f"Inhalt: {content[:300]}\n"
+
+        from config import OUTPUT_LANGUAGE
+        template = RESEARCH_FACTCHECK_PROMPT_TEMPLATE if incident_type == "research" else FACTCHECK_PROMPT_TEMPLATE
+        prompt = template.format(
+            title=title,
+            articles_text=articles_text,
+            output_language=OUTPUT_LANGUAGE,
+        )
+
+        try:
+            result, usage = await call_claude(prompt)
+            facts = self._parse_response(result)
+            logger.info(f"Faktencheck: {len(facts)} Fakten geprüft")
+            return facts, usage
+        except Exception as e:
+            logger.error(f"Faktencheck-Fehler: {e}")
+            return [], None
+
+    def _parse_response(self, response: str) -> list[dict]:
+        """Parst die Claude-Antwort als JSON-Array."""
+        try:
+            data = json.loads(response)
+            if isinstance(data, list):
+                return data
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r'\[.*\]', response, re.DOTALL)
+        if match:
+            try:
+                data = json.loads(match.group())
+                if isinstance(data, list):
+                    return data
+            except json.JSONDecodeError:
+                pass
+
+        logger.warning("Konnte Faktencheck-Antwort nicht als JSON parsen")
+        return []
diff --git a/src/agents/orchestrator.py b/src/agents/orchestrator.py
new file mode 100644
index 0000000..10c40b9
--- /dev/null
+++ b/src/agents/orchestrator.py
@@ -0,0 +1,893 @@
+"""Agenten-Orchestrierung: Queue und Steuerung der Claude-Agenten."""
+import asyncio
+import json
+import logging
+import re
+from datetime import datetime, timezone
+from config import TIMEZONE
+from typing import Optional
+from urllib.parse import urlparse, urlunparse
+
+from agents.claude_client import UsageAccumulator
+from source_rules import (
+    DOMAIN_CATEGORY_MAP,
+    _detect_category,
+    _extract_domain,
+    discover_source,
+    domain_to_display_name,
+)
+
+logger = logging.getLogger("osint.orchestrator")
+
+
+def _normalize_url(url: str) -> str:
+    """URL normalisieren für Duplikat-Erkennung."""
+    if not url:
+        return ""
+    url = url.strip()
+    try:
+        parsed = urlparse(url)
+        # Scheme normalisieren
+        scheme = parsed.scheme.lower() or "https"
+        # Host normalisieren (www entfernen, lowercase)
+        netloc = parsed.netloc.lower()
+        if netloc.startswith("www."):
+            netloc = netloc[4:]
+        # Pfad normalisieren (trailing slash entfernen)
+        path = parsed.path.rstrip("/")
+        # Query-Parameter und Fragment entfernen (Tracking-Params etc.)
+        return urlunparse((scheme, netloc, path, "", "", ""))
+    except Exception:
+        return url.lower().strip().rstrip("/")
+
+
+def _normalize_headline(headline: str) -> str:
+    """Überschrift normalisieren für Ähnlichkeitsvergleich."""
+    if not headline:
+        return ""
+    h = headline.lower().strip()
+    # Umlaute normalisieren
+    h = h.replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
+    # Sonderzeichen entfernen
+    h = re.sub(r"[^\w\s]", "", h)
+    h = re.sub(r"\s+", " ", h).strip()
+    return h
+
+
+def _is_duplicate(article: dict, seen_urls: set, seen_headlines: set) -> bool:
+    """Prüft ob ein Artikel ein Duplikat ist (URL oder Headline)."""
+    url = article.get("source_url", "")
+    headline = article.get("headline", "")
+
+    # URL-Duplikat
+    if url:
+        norm_url = _normalize_url(url)
+        if norm_url in seen_urls:
+            return True
+        seen_urls.add(norm_url)
+
+    # Headline-Duplikat (nur wenn Überschrift lang genug)
+    if headline and len(headline) > 20:
+        norm_headline = _normalize_headline(headline)
+        if norm_headline and norm_headline in seen_headlines:
+            return True
+        if norm_headline:
+            seen_headlines.add(norm_headline)
+
+    return False
+
+
+async def _background_discover_sources(articles: list[dict]):
+    """Background-Task: Registriert seriöse, unbekannte Quellen aus Recherche-Ergebnissen."""
+    from database import get_db
+
+    db = await get_db()
+    try:
+        # 1. Unique Domains extrahieren
+        seen_domains: set[str] = set()
+        domains_to_check: list[tuple[str, str, str]] = []
+        for article in articles:
+            url = article.get("source_url")
+            if not url:
+                continue
+            domain = _extract_domain(url)
+            if not domain or domain in seen_domains:
+                continue
+            seen_domains.add(domain)
+
+            # 2. Nur seriöse Domains (in DOMAIN_CATEGORY_MAP, nicht "sonstige")
+            category = _detect_category(domain)
+            if category == "sonstige":
+                continue
+            domains_to_check.append((domain, url, category))
+
+        if not domains_to_check:
+            return
+
+        # 3. Gegen DB prüfen — welche Domains existieren schon?
+        new_count = 0
+        for domain, url, category in domains_to_check:
+            cursor = await db.execute(
+                "SELECT id FROM sources WHERE LOWER(domain) = ?",
+                (domain.lower(),),
+            )
+            if await cursor.fetchone():
+                continue  # Domain schon bekannt
+
+            # 4. RSS-Feed-Erkennung
+            try:
+                result = await discover_source(url)
+                name = domain_to_display_name(domain)
+                source_type = result["source_type"]  # "rss_feed" oder "web_source"
+                feed_url = result.get("rss_url")
+
+                await db.execute(
+                    """INSERT INTO sources (name, url, domain, source_type, category, status, notes, added_by)
+                       VALUES (?, ?, ?, ?, ?, 'active', 'Auto-entdeckt via Recherche', 'system')""",
+                    (name, feed_url or f"https://{domain}", domain, source_type, category),
+                )
+                new_count += 1
+                logger.info(f"Neue Quelle registriert: {name} ({domain}) als {source_type}")
+            except Exception as e:
+                logger.debug(f"Discovery fehlgeschlagen für {domain}: {e}")
+
+        if new_count > 0:
+            await db.commit()
+            logger.info(f"Background-Discovery: {new_count} neue Quellen registriert")
+    except Exception as e:
+        logger.warning(f"Background-Discovery Fehler: {e}")
+    finally:
+        await db.close()
+
+
+async def _create_notifications_for_incident(
+    db, incident_id: int, visibility: str, created_by: int, tenant_id: int, notifications: list[dict]
+):
+    """Erzeugt DB-Notifications fuer alle betroffenen Nutzer der Organisation.
+
+    - Oeffentliche Lagen -> alle Nutzer der Org
+    - Private Lagen -> nur Ersteller
+    """
+    if not notifications:
+        return
+
+    now = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
+
+    if visibility == "public" and tenant_id:
+        cursor = await db.execute(
+            "SELECT id FROM users WHERE organization_id = ? AND is_active = 1 AND last_login_at IS NOT NULL",
+            (tenant_id,),
+        )
+        user_ids = [row["id"] for row in await cursor.fetchall()]
+    else:
+        user_ids = [created_by]
+
+    for user_id in user_ids:
+        for notif in notifications:
+            await db.execute(
+                """INSERT INTO notifications (user_id, incident_id, type, title, text, icon, tenant_id, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    user_id,
+                    incident_id,
+                    notif.get("type", "refresh_summary"),
+                    notif["title"],
+                    notif["text"],
+                    notif.get("icon", "info"),
+                    tenant_id,
+                    now,
+                ),
+            )
+
+    await db.commit()
+    logger.info(f"Notifications erstellt: {len(notifications)} x {len(user_ids)} Nutzer fuer Lage {incident_id}")
+
+
+async def _send_email_notifications_for_incident(
+    db, incident_id: int, incident_title: str, visibility: str,
+    created_by: int, tenant_id: int, notifications: list[dict]
+):
+    """Sendet E-Mail-Benachrichtigungen basierend auf individuellen Nutzer-Abos.
+
+    Jeder Nutzer hat eigene E-Mail-Praeferenzen pro Lage (incident_subscriptions).
+    Nur Nutzer die aktiv sind und sich mindestens einmal eingeloggt haben
+    (last_login_at IS NOT NULL) werden beruecksichtigt.
+    """
+    if not notifications:
+        return
+
+    from email_utils.sender import send_email
+    from email_utils.templates import incident_notification_email
+    from config import MAGIC_LINK_BASE_URL
+
+    # Alle Nutzer mit aktiven Abos fuer diese Lage laden
+    cursor = await db.execute(
+        """SELECT s.notify_email_summary, s.notify_email_new_articles,
+                  s.notify_email_status_change, u.id, u.email, u.username
+           FROM incident_subscriptions s
+           JOIN users u ON u.id = s.user_id
+           WHERE s.incident_id = ?
+             AND u.is_active = 1
+             AND u.last_login_at IS NOT NULL
+             AND (s.notify_email_summary = 1
+                  OR s.notify_email_new_articles = 1
+                  OR s.notify_email_status_change = 1)""",
+        (incident_id,),
+    )
+    subscribers = await cursor.fetchall()
+    if not subscribers:
+        return
+
+    dashboard_url = f"{MAGIC_LINK_BASE_URL}/dashboard"
+
+    for sub in subscribers:
+        prefs = dict(sub)
+
+        # Relevante Notifications basierend auf Nutzer-Praeferenzen filtern
+        filtered_notifications = []
+        for n in notifications:
+            ntype = n.get("type", "refresh_summary")
+
+            if ntype == "refresh_summary" and prefs.get("notify_email_summary"):
+                filtered_notifications.append(n)
+            elif ntype == "new_articles" and prefs.get("notify_email_new_articles"):
+                filtered_notifications.append(n)
+            elif ntype == "status_change" and prefs.get("notify_email_status_change"):
+                filtered_notifications.append(n)
+
+        if not filtered_notifications:
+            continue
+
+        subject, html = incident_notification_email(
+            username=prefs["username"],
+            incident_title=incident_title,
+            notifications=filtered_notifications,
+            dashboard_url=dashboard_url,
+        )
+        try:
+            await send_email(prefs["email"], subject, html)
+            logger.info(f"E-Mail-Benachrichtigung gesendet an {prefs['email']} fuer Lage {incident_id} ({len(filtered_notifications)} Items)")
+        except Exception as e:
+            logger.error(f"E-Mail-Benachrichtigung fehlgeschlagen fuer {prefs['email']}: {e}")
+
+
+class AgentOrchestrator:
+    """Verwaltet die Claude-Agenten-Queue und koordiniert Recherche-Zyklen."""
+
+    def __init__(self):
+        self._queue: asyncio.Queue = asyncio.Queue()
+        self._running = False
+        self._current_task: Optional[int] = None
+        self._ws_manager = None
+        self._queued_ids: set[int] = set()
+        self._cancel_requested: set[int] = set()
+
+    def set_ws_manager(self, ws_manager):
+        """WebSocket-Manager setzen für Echtzeit-Updates."""
+        self._ws_manager = ws_manager
+
+    async def start(self):
+        """Queue-Worker starten."""
+        self._running = True
+        asyncio.create_task(self._worker())
+        logger.info("Agenten-Orchestrator gestartet")
+
+    async def stop(self):
+        """Queue-Worker stoppen."""
+        self._running = False
+        logger.info("Agenten-Orchestrator gestoppt")
+
+    async def enqueue_refresh(self, incident_id: int, trigger_type: str = "manual") -> bool:
+        """Refresh-Auftrag in die Queue stellen. Gibt False zurueck wenn bereits in Queue/aktiv."""
+        if incident_id in self._queued_ids or self._current_task == incident_id:
+            logger.info(f"Refresh fuer Lage {incident_id} uebersprungen: bereits aktiv/in Queue")
+            return False
+
+        visibility, created_by, tenant_id = await self._get_incident_visibility(incident_id)
+
+        self._queued_ids.add(incident_id)
+        await self._queue.put((incident_id, trigger_type))
+        queue_size = self._queue.qsize()
+        logger.info(f"Refresh fuer Lage {incident_id} eingereiht (Queue: {queue_size}, Trigger: {trigger_type})")
+
+        if self._ws_manager:
+            await self._ws_manager.broadcast_for_incident({
+                "type": "status_update",
+                "incident_id": incident_id,
+                "data": {"status": "queued", "queue_position": queue_size},
+            }, visibility, created_by, tenant_id)
+
+        return True
+
+    async def cancel_refresh(self, incident_id: int) -> bool:
+        """Fordert Abbruch eines laufenden Refreshes an."""
+        if self._current_task != incident_id:
+            return False
+        self._cancel_requested.add(incident_id)
+        logger.info(f"Cancel angefordert fuer Lage {incident_id}")
+        if self._ws_manager:
+            try:
+                vis, cb, tid = await self._get_incident_visibility(incident_id)
+            except Exception:
+                vis, cb, tid = "public", None, None
+            await self._ws_manager.broadcast_for_incident({
+                "type": "status_update",
+                "incident_id": incident_id,
+                "data": {"status": "cancelling", "detail": "Wird abgebrochen..."},
+            }, vis, cb, tid)
+        return True
+
+    def _check_cancelled(self, incident_id: int):
+        """Prüft ob Abbruch angefordert wurde und wirft CancelledError."""
+        if incident_id in self._cancel_requested:
+            self._cancel_requested.discard(incident_id)
+            raise asyncio.CancelledError("Vom Nutzer abgebrochen")
+
+    async def _worker(self):
+        """Verarbeitet Refresh-Aufträge sequentiell."""
+        while self._running:
+            try:
+                item = await asyncio.wait_for(self._queue.get(), timeout=5.0)
+            except asyncio.TimeoutError:
+                continue
+
+            incident_id, trigger_type = item
+            self._queued_ids.discard(incident_id)
+            self._current_task = incident_id
+            logger.info(f"Starte Refresh für Lage {incident_id} (Trigger: {trigger_type})")
+
+            RETRY_DELAYS = [0, 120, 300]  # Sekunden: sofort, 2min, 5min
+            TRANSIENT_ERRORS = (asyncio.TimeoutError, ConnectionError, OSError)
+            last_error = None
+
+            try:
+                for attempt in range(3):
+                    try:
+                        await self._run_refresh(incident_id, trigger_type=trigger_type, retry_count=attempt)
+                        last_error = None
+                        break  # Erfolg
+                    except asyncio.CancelledError:
+                        logger.info(f"Refresh fuer Lage {incident_id} abgebrochen")
+                        await self._mark_refresh_cancelled(incident_id)
+                        try:
+                            _vis, _cb, _tid = await self._get_incident_visibility(incident_id)
+                        except Exception:
+                            _vis, _cb, _tid = "public", None, None
+                        if self._ws_manager:
+                            await self._ws_manager.broadcast_for_incident({
+                                "type": "refresh_cancelled",
+                                "incident_id": incident_id,
+                                "data": {"status": "cancelled"},
+                            }, _vis, _cb, _tid)
+                        last_error = None
+                        break
+                    except TRANSIENT_ERRORS as e:
+                        last_error = e
+                        logger.warning(f"Transienter Fehler bei Lage {incident_id} (Versuch {attempt + 1}/3): {e}")
+                        if attempt < 2:
+                            await self._mark_refresh_failed(incident_id, str(e))
+                            delay = RETRY_DELAYS[attempt + 1]
+                            logger.info(f"Retry in {delay}s für Lage {incident_id}")
+                            # Retry-Status per WebSocket senden
+                            if self._ws_manager:
+                                try:
+                                    _vis, _cb, _tid = await self._get_incident_visibility(incident_id)
+                                except Exception:
+                                    _vis, _cb, _tid = "public", None, None
+                                await self._ws_manager.broadcast_for_incident({
+                                    "type": "status_update",
+                                    "incident_id": incident_id,
+                                    "data": {"status": "retrying", "attempt": attempt + 1, "delay": delay},
+                                }, _vis, _cb, _tid)
+                            await asyncio.sleep(delay)
+                        else:
+                            await self._mark_refresh_failed(incident_id, f"Endgültig fehlgeschlagen nach 3 Versuchen: {e}")
+                    except Exception as e:
+                        last_error = e
+                        logger.error(f"Permanenter Fehler bei Refresh für Lage {incident_id}: {e}")
+                        await self._mark_refresh_failed(incident_id, str(e))
+                        break  # Permanenter Fehler, kein Retry
+
+                if last_error and self._ws_manager:
+                    try:
+                        _vis, _cb, _tid = await self._get_incident_visibility(incident_id)
+                    except Exception:
+                        _vis, _cb, _tid = "public", None, None
+                    await self._ws_manager.broadcast_for_incident({
+                        "type": "refresh_error",
+                        "incident_id": incident_id,
+                        "data": {"error": str(last_error)},
+                    }, _vis, _cb, _tid)
+            finally:
+                self._current_task = None
+                self._queue.task_done()
+
+    async def _mark_refresh_cancelled(self, incident_id: int):
+        """Markiert den laufenden Refresh-Log-Eintrag als cancelled."""
+        from database import get_db
+        db = await get_db()
+        try:
+            await db.execute(
+                """UPDATE refresh_log SET status = 'cancelled', error_message = 'Vom Nutzer abgebrochen',
+                   completed_at = ? WHERE incident_id = ? AND status = 'running'""",
+                (datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S'), incident_id),
+            )
+            await db.commit()
+        except Exception as e:
+            logger.warning(f"Konnte Refresh-Log nicht als abgebrochen markieren: {e}")
+        finally:
+            await db.close()
+
+    async def _mark_refresh_failed(self, incident_id: int, error: str):
+        """Markiert den laufenden Refresh-Log-Eintrag als error."""
+        from database import get_db
+        db = await get_db()
+        try:
+            await db.execute(
+                """UPDATE refresh_log SET status = 'error', error_message = ?,
+                   completed_at = ? WHERE incident_id = ? AND status = 'running'""",
+                (error[:500], datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S'), incident_id),
+            )
+            await db.commit()
+        except Exception as e:
+            logger.warning(f"Konnte Refresh-Log nicht als fehlgeschlagen markieren: {e}")
+        finally:
+            await db.close()
+
+    async def _get_incident_visibility(self, incident_id: int) -> tuple[str, Optional[int], Optional[int]]:
+        """Incident-Visibility, created_by und tenant_id laden."""
+        from database import get_db
+        visibility = "public"
+        created_by = None
+        tenant_id = None
+        db = await get_db()
+        try:
+            cursor = await db.execute(
+                "SELECT visibility, created_by, tenant_id FROM incidents WHERE id = ?", (incident_id,)
+            )
+            row = await cursor.fetchone()
+            if row:
+                visibility = row["visibility"] or "public"
+                created_by = row["created_by"]
+                tenant_id = row["tenant_id"]
+        finally:
+            await db.close()
+        return visibility, created_by, tenant_id
+
+    async def _run_refresh(self, incident_id: int, trigger_type: str = "manual", retry_count: int = 0):
+        """Führt einen kompletten Refresh-Zyklus durch."""
+        import aiosqlite
+        from database import get_db
+        from agents.researcher import ResearcherAgent
+        from agents.analyzer import AnalyzerAgent
+        from agents.factchecker import FactCheckerAgent
+        from feeds.rss_parser import RSSParser
+
+        db = await get_db()
+        try:
+            # Lage laden
+            cursor = await db.execute("SELECT * FROM incidents WHERE id = ?", (incident_id,))
+            incident = await cursor.fetchone()
+            if not incident:
+                logger.warning(f"Lage {incident_id} nicht gefunden")
+                return
+
+            title = incident["title"]
+            description = incident["description"] or ""
+            incident_type = incident["type"] or "adhoc"
+            international = bool(incident["international_sources"]) if "international_sources" in incident.keys() else True
+            visibility = incident["visibility"] if "visibility" in incident.keys() else "public"
+            created_by = incident["created_by"] if "created_by" in incident.keys() else None
+            tenant_id = incident["tenant_id"] if "tenant_id" in incident.keys() else None
+
+            # Bei Retry: vorherigen running-Eintrag als error markieren
+            if retry_count > 0:
+                await db.execute(
+                    """UPDATE refresh_log SET status = 'error', error_message = 'Retry gestartet',
+                       completed_at = ? WHERE incident_id = ? AND status = 'running'""",
+                    (datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S'), incident_id),
+                )
+                await db.commit()
+
+            # Refresh-Log starten
+            now = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
+            cursor = await db.execute(
+                "INSERT INTO refresh_log (incident_id, started_at, status, trigger_type, retry_count, tenant_id) VALUES (?, ?, 'running', ?, ?, ?)",
+                (incident_id, now, trigger_type, retry_count, tenant_id),
+            )
+            await db.commit()
+            log_id = cursor.lastrowid
+            usage_acc = UsageAccumulator()
+
+            research_status = "deep_researching" if incident_type == "research" else "researching"
+            research_detail = "Hintergrundrecherche im Web läuft..." if incident_type == "research" else "RSS-Feeds und Web werden durchsucht..."
+            if self._ws_manager:
+                await self._ws_manager.broadcast_for_incident({
+                    "type": "status_update",
+                    "incident_id": incident_id,
+                    "data": {"status": research_status, "detail": research_detail, "started_at": now},
+                }, visibility, created_by, tenant_id)
+
+            # Schritt 1+2: RSS-Feeds und Claude-Recherche parallel ausführen
+            async def _rss_pipeline():
+                """RSS-Feed-Suche (Feed-Selektion + Parsing)."""
+                if incident_type != "adhoc":
+                    logger.info("Recherche-Modus: RSS-Feeds übersprungen")
+                    return [], None
+
+                rss_researcher = ResearcherAgent()
+                rss_parser = RSSParser()
+
+                from source_rules import get_feeds_with_metadata
+                all_feeds = await get_feeds_with_metadata(tenant_id=tenant_id)
+
+                feed_usage = None
+                if len(all_feeds) > 20:
+                    selected_feeds, feed_usage = await rss_researcher.select_relevant_feeds(
+                        title, description, international, all_feeds
+                    )
+                    logger.info(f"Feed-Selektion: {len(selected_feeds)} von {len(all_feeds)} Feeds ausgewählt")
+                    articles = await rss_parser.search_feeds_selective(title, selected_feeds)
+                else:
+                    articles = await rss_parser.search_feeds(title, international=international, tenant_id=tenant_id)
+
+                logger.info(f"RSS: {len(articles)} relevante Artikel gefunden (international={international})")
+                return articles, feed_usage
+
+            async def _web_search_pipeline():
+                """Claude WebSearch-Recherche."""
+                researcher = ResearcherAgent()
+                results, usage = await researcher.search(title, description, incident_type, international=international)
+                logger.info(f"Claude-Recherche: {len(results)} Ergebnisse")
+                return results, usage
+
+            # Beide Pipelines parallel starten
+            (rss_articles, rss_feed_usage), (search_results, search_usage) = await asyncio.gather(
+                _rss_pipeline(),
+                _web_search_pipeline(),
+            )
+
+            if rss_feed_usage:
+                usage_acc.add(rss_feed_usage)
+            if search_usage:
+                usage_acc.add(search_usage)
+
+            # Checkpoint 1: Cancel prüfen nach RSS/WebSearch
+            self._check_cancelled(incident_id)
+
+            # Alle Ergebnisse zusammenführen
+            all_results = rss_articles + search_results
+
+            # Duplikate entfernen (normalisierte URL + Headline-Ähnlichkeit)
+            seen_urls = set()
+            seen_headlines = set()
+            unique_results = []
+            for article in all_results:
+                if not _is_duplicate(article, seen_urls, seen_headlines):
+                    unique_results.append(article)
+
+            dupes_removed = len(all_results) - len(unique_results)
+            if dupes_removed > 0:
+                logger.info(f"Deduplizierung: {dupes_removed} Duplikate entfernt, {len(unique_results)} verbleibend")
+
+            source_count = len(set(a.get("source", "") for a in unique_results))
+            if self._ws_manager:
+                await self._ws_manager.broadcast_for_incident({
+                    "type": "status_update",
+                    "incident_id": incident_id,
+                    "data": {
+                        "status": "analyzing",
+                        "detail": f"Analysiert {len(unique_results)} Meldungen aus {source_count} Quellen...",
+                        "started_at": now,
+                    },
+                }, visibility, created_by, tenant_id)
+
+            # In DB speichern (neue Artikel) — auch gegen bestehende DB-Einträge prüfen
+            new_count = 0
+            for article in unique_results:
+                # Prüfen ob URL (normalisiert) schon existiert
+                if article.get("source_url"):
+                    norm_url = _normalize_url(article["source_url"])
+                    cursor = await db.execute(
+                        "SELECT id, source_url FROM articles WHERE incident_id = ?",
+                        (incident_id,),
+                    )
+                    existing_articles = await cursor.fetchall()
+                    already_exists = False
+                    for existing in existing_articles:
+                        if existing["source_url"] and _normalize_url(existing["source_url"]) == norm_url:
+                            already_exists = True
+                            break
+                    if already_exists:
+                        continue
+
+                # Headline-Duplikat gegen DB prüfen
+                headline = article.get("headline", "")
+                if headline and len(headline) > 20:
+                    norm_h = _normalize_headline(headline)
+                    cursor = await db.execute(
+                        "SELECT id, headline FROM articles WHERE incident_id = ?",
+                        (incident_id,),
+                    )
+                    existing_articles = await cursor.fetchall()
+                    headline_exists = False
+                    for existing in existing_articles:
+                        if _normalize_headline(existing["headline"]) == norm_h:
+                            headline_exists = True
+                            break
+                    if headline_exists:
+                        continue
+
+                await db.execute(
+                    """INSERT INTO articles (incident_id, headline, headline_de, source,
+                       source_url, content_original, content_de, language, published_at, tenant_id)
+                       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                    (
+                        incident_id,
+                        article.get("headline", ""),
+                        article.get("headline_de"),
+                        article.get("source", "Unbekannt"),
+                        article.get("source_url"),
+                        article.get("content_original"),
+                        article.get("content_de"),
+                        article.get("language", "de"),
+                        article.get("published_at"),
+                        tenant_id,
+                    ),
+                )
+                new_count += 1
+
+            await db.commit()
+
+            # Quellen-Statistiken aktualisieren
+            if new_count > 0:
+                try:
+                    from database import refresh_source_counts
+                    await refresh_source_counts(db)
+                except Exception as e:
+                    logger.warning(f"Quellen-Statistiken konnten nicht aktualisiert werden: {e}")
+
+            # Schritt 3: Analyse und Zusammenfassung
+            if new_count > 0 or not incident["summary"]:
+                cursor = await db.execute(
+                    "SELECT * FROM articles WHERE incident_id = ? ORDER BY collected_at DESC",
+                    (incident_id,),
+                )
+                all_articles = [dict(row) for row in await cursor.fetchall()]
+
+                analyzer = AnalyzerAgent()
+                analysis, analysis_usage = await analyzer.analyze(title, description, all_articles, incident_type)
+                if analysis_usage:
+                    usage_acc.add(analysis_usage)
+
+                if analysis:
+                    is_first_summary = not incident["summary"]
+
+                    # Snapshot des alten Lagebilds sichern (nur wenn schon eins existiert)
+                    if incident["summary"]:
+                        cursor = await db.execute(
+                            "SELECT COUNT(*) as cnt FROM articles WHERE incident_id = ?",
+                            (incident_id,),
+                        )
+                        snap_articles = (await cursor.fetchone())["cnt"]
+                        cursor = await db.execute(
+                            "SELECT COUNT(*) as cnt FROM fact_checks WHERE incident_id = ?",
+                            (incident_id,),
+                        )
+                        snap_fcs = (await cursor.fetchone())["cnt"]
+                        await db.execute(
+                            """INSERT INTO incident_snapshots
+                               (incident_id, summary, sources_json,
+                                article_count, fact_check_count, refresh_log_id, created_at, tenant_id)
+                               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                            (incident_id, incident["summary"], incident["sources_json"],
+                             snap_articles, snap_fcs, log_id, now, tenant_id),
+                        )
+
+                    # sources_json aus der Analyse extrahieren und speichern
+                    sources = analysis.get("sources", [])
+                    sources_json = json.dumps(sources, ensure_ascii=False) if sources else None
+
+                    new_summary = analysis.get("summary", "")
+
+                    await db.execute(
+                        "UPDATE incidents SET summary = ?, sources_json = ?, updated_at = ? WHERE id = ?",
+                        (new_summary, sources_json, now, incident_id),
+                    )
+
+                    # Beim ersten Refresh: Snapshot des neuen Lagebilds erstellen
+                    if is_first_summary and new_summary:
+                        cursor = await db.execute(
+                            "SELECT COUNT(*) as cnt FROM articles WHERE incident_id = ?",
+                            (incident_id,),
+                        )
+                        snap_articles = (await cursor.fetchone())["cnt"]
+                        cursor = await db.execute(
+                            "SELECT COUNT(*) as cnt FROM fact_checks WHERE incident_id = ?",
+                            (incident_id,),
+                        )
+                        snap_fcs = (await cursor.fetchone())["cnt"]
+                        await db.execute(
+                            """INSERT INTO incident_snapshots
+                               (incident_id, summary, sources_json,
+                                article_count, fact_check_count, refresh_log_id, created_at, tenant_id)
+                               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                            (incident_id, new_summary, sources_json,
+                             snap_articles, snap_fcs, log_id, now, tenant_id),
+                        )
+
+                    # Übersetzungen aktualisieren
+                    for translation in analysis.get("translations", []):
+                        article_id = translation.get("article_id")
+                        if article_id:
+                            await db.execute(
+                                "UPDATE articles SET headline_de = ?, content_de = ? WHERE id = ?",
+                                (translation.get("headline_de"), translation.get("content_de"), article_id),
+                            )
+
+                    await db.commit()
+
+                # Checkpoint 2: Cancel prüfen nach Analyse
+                self._check_cancelled(incident_id)
+
+                if self._ws_manager:
+                    await self._ws_manager.broadcast_for_incident({
+                        "type": "status_update",
+                        "incident_id": incident_id,
+                        "data": {"status": "factchecking", "detail": "Prüft Fakten gegen unabhängige Quellen...", "started_at": now},
+                    }, visibility, created_by, tenant_id)
+
+                # Schritt 4: Faktencheck
+                factchecker = FactCheckerAgent()
+                fact_checks, fc_usage = await factchecker.check(title, all_articles, incident_type)
+                if fc_usage:
+                    usage_acc.add(fc_usage)
+
+                # Checkpoint 3: Cancel prüfen nach Faktencheck
+                self._check_cancelled(incident_id)
+
+                # Prüfen ob dies der erste Refresh ist (keine vorherigen Faktenchecks)
+                cursor = await db.execute(
+                    "SELECT COUNT(*) as cnt FROM fact_checks WHERE incident_id = ?",
+                    (incident_id,),
+                )
+                row = await cursor.fetchone()
+                is_first_refresh = row["cnt"] == 0
+
+                # Notification-Summary sammeln
+                confirmed_count = 0
+                contradicted_count = 0
+                status_changes = []
+
+                for fc in fact_checks:
+                    # Prüfen ob Claim schon existiert (mit altem Status)
+                    cursor = await db.execute(
+                        "SELECT id, status FROM fact_checks WHERE incident_id = ? AND claim = ?",
+                        (incident_id, fc.get("claim", "")),
+                    )
+                    existing = await cursor.fetchone()
+                    old_status = existing["status"] if existing else None
+                    new_status = fc.get("status", "developing")
+
+                    if existing:
+                        await db.execute(
+                            "UPDATE fact_checks SET status = ?, sources_count = ?, evidence = ?, is_notification = ?, checked_at = ? WHERE id = ?",
+                            (new_status, fc.get("sources_count", 0), fc.get("evidence"), fc.get("is_notification", 0), now, existing["id"]),
+                        )
+                    else:
+                        await db.execute(
+                            """INSERT INTO fact_checks (incident_id, claim, status, sources_count, evidence, is_notification, tenant_id)
+                               VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                            (incident_id, fc.get("claim", ""), new_status, fc.get("sources_count", 0), fc.get("evidence"), fc.get("is_notification", 0), tenant_id),
+                        )
+
+                    # Status-Statistik sammeln
+                    if new_status == "confirmed" or new_status == "established":
+                        confirmed_count += 1
+                    elif new_status == "contradicted" or new_status == "disputed":
+                        contradicted_count += 1
+
+                    # Echte Status-Änderungen tracken (nicht beim ersten Refresh)
+                    if not is_first_refresh and old_status and old_status != new_status:
+                        status_changes.append({
+                            "claim": fc.get("claim", ""),
+                            "old_status": old_status,
+                            "new_status": new_status,
+                        })
+
+                await db.commit()
+
+                # Gebündelte Notification senden (nicht beim ersten Refresh)
+                if not is_first_refresh:
+                    if self._ws_manager:
+                        await self._ws_manager.broadcast_for_incident({
+                            "type": "refresh_summary",
+                            "incident_id": incident_id,
+                            "data": {
+                                "new_articles": new_count,
+                                "confirmed_count": confirmed_count,
+                                "contradicted_count": contradicted_count,
+                                "status_changes": status_changes,
+                                "is_first_refresh": False,
+                                "incident_title": title,
+                            },
+                        }, visibility, created_by, tenant_id)
+
+                    # DB-Notifications erzeugen
+                    parts = []
+                    if new_count > 0:
+                        parts.append(f"{new_count} neue Meldung{'en' if new_count != 1 else ''}")
+                    if confirmed_count > 0:
+                        parts.append(f"{confirmed_count} bestätigt")
+                    if contradicted_count > 0:
+                        parts.append(f"{contradicted_count} widersprochen")
+                    summary_text = ", ".join(parts) if parts else "Keine neuen Entwicklungen"
+
+                    db_notifications = [{
+                        "type": "refresh_summary",
+                        "title": title,
+                        "text": f"Recherche: {summary_text}",
+                        "icon": "warning" if contradicted_count > 0 else "success",
+                    }]
+                    if new_count > 0:
+                        db_notifications.append({
+                            "type": "new_articles",
+                            "title": title,
+                            "text": f"{new_count} neue Meldung{'en' if new_count != 1 else ''} gefunden",
+                            "icon": "info",
+                        })
+                    for sc in status_changes:
+                        db_notifications.append({
+                            "type": "status_change",
+                            "title": title,
+                            "text": f"{sc['claim']}: {sc['old_status']} \u2192 {sc['new_status']}",
+                            "icon": "error" if sc["new_status"] in ("contradicted", "disputed") else "success",
+                        })
+
+                    if created_by:
+                        await _create_notifications_for_incident(
+                            db, incident_id, visibility, created_by, tenant_id, db_notifications
+                        )
+                        # E-Mail-Benachrichtigungen versenden
+                        await _send_email_notifications_for_incident(
+                            db, incident_id, title, visibility, created_by, tenant_id, db_notifications
+                        )
+
+            # Refresh-Log abschließen (mit Token-Statistiken)
+            await db.execute(
+                """UPDATE refresh_log SET
+                    completed_at = ?, articles_found = ?, status = 'completed',
+                    input_tokens = ?, output_tokens = ?,
+                    cache_creation_tokens = ?, cache_read_tokens = ?,
+                    total_cost_usd = ?, api_calls = ?
+                WHERE id = ?""",
+                (datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S'), new_count,
+                 usage_acc.input_tokens, usage_acc.output_tokens,
+                 usage_acc.cache_creation_tokens, usage_acc.cache_read_tokens,
+                 round(usage_acc.total_cost_usd, 7), usage_acc.call_count, log_id),
+            )
+            await db.commit()
+            logger.info(
+                f"Token: {usage_acc.input_tokens} in / {usage_acc.output_tokens} out / "
+                f"${usage_acc.total_cost_usd:.4f} ({usage_acc.call_count} Calls)"
+            )
+
+            # Quellen-Discovery im Background starten
+            if unique_results:
+                asyncio.create_task(_background_discover_sources(unique_results))
+
+            if self._ws_manager:
+                await self._ws_manager.broadcast_for_incident({
+                    "type": "refresh_complete",
+                    "incident_id": incident_id,
+                    "data": {"new_articles": new_count, "status": "idle"},
+                }, visibility, created_by, tenant_id)
+
+            logger.info(f"Refresh für Lage {incident_id} abgeschlossen: {new_count} neue Artikel")
+
+        finally:
+            await db.close()
+
+
+# Singleton-Instanz
+orchestrator = AgentOrchestrator()
diff --git a/src/agents/researcher.py b/src/agents/researcher.py
new file mode 100644
index 0000000..3decddc
--- /dev/null
+++ b/src/agents/researcher.py
@@ -0,0 +1,236 @@
+"""Researcher-Agent: Sucht nach Informationen via Claude WebSearch."""
+import asyncio
+import json
+import logging
+import re
+from agents.claude_client import call_claude, ClaudeUsage
+
+logger = logging.getLogger("osint.researcher")
+
+RESEARCH_PROMPT_TEMPLATE = """Du bist ein OSINT-Recherche-Agent für ein Lagemonitoring-System.
+AUSGABESPRACHE: {output_language}
+
+AUFTRAG: Suche nach aktuellen Informationen zu folgendem Vorfall:
+Titel: {title}
+Kontext: {description}
+
+REGELN:
+- Suche nur bei seriösen Nachrichtenquellen (Nachrichtenagenturen, Qualitätszeitungen, öffentlich-rechtliche Medien, Behörden)
+- KEIN Social Media (Twitter/X, Facebook, Instagram, TikTok, Reddit)
+- KEINE Boulevardmedien (Bild, Sun, Daily Mail etc.)
+{language_instruction}
+- Faktenbasiert und neutral - keine Spekulationen
+- Nutze removepaywalls.com für Paywall-geschützte Artikel (z.B. Spiegel+, Zeit+, SZ+): https://www.removepaywalls.com/search?url=ARTIKEL_URL
+
+Gib die Ergebnisse AUSSCHLIESSLICH als JSON-Array zurück, ohne Erklärungen davor oder danach.
+Jedes Element hat diese Felder:
+- "headline": Originale Überschrift
+- "headline_de": Übersetzung in Ausgabesprache (falls Originalsprache abweicht)
+- "source": Name der Quelle (z.B. "Reuters", "tagesschau")
+- "source_url": URL des Artikels
+- "content_summary": Zusammenfassung des Inhalts (2-3 Sätze, in Ausgabesprache)
+- "language": Sprache des Originals (z.B. "de", "en", "fr")
+- "published_at": Veröffentlichungsdatum falls bekannt (ISO-Format)
+
+Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""
+
+DEEP_RESEARCH_PROMPT_TEMPLATE = """Du bist ein OSINT-Tiefenrecherche-Agent für ein Lagemonitoring-System.
+AUSGABESPRACHE: {output_language}
+
+AUFTRAG: Führe eine umfassende Hintergrundrecherche durch zu:
+Titel: {title}
+Kontext: {description}
+
+RECHERCHE-STRATEGIE:
+- Breite Suche: Hintergrundberichte, Analysen, Expertenmeinungen, Think-Tank-Publikationen
+- Suche nach: Akteuren, Zusammenhängen, historischem Kontext, rechtlichen Rahmenbedingungen
+- Akademische und Fachquellen zusätzlich zu Nachrichtenquellen
+- Nutze removepaywalls.com für Paywall-geschützte Artikel (z.B. https://www.removepaywalls.com/search?url=ARTIKEL_URL)
+{language_instruction}
+- Ziel: 8-15 hochwertige Quellen
+
+QUELLENTYPEN (priorisiert):
+1. Fachzeitschriften und Branchenmedien
+2. Qualitätszeitungen (Hintergrundberichte, Dossiers)
+3. Think Tanks und Forschungsinstitute
+4. Offizielle Dokumente und Pressemitteilungen
+5. Nachrichtenagenturen (für Faktengrundlage)
+
+AUSSCHLUSS:
+- KEIN Social Media (Twitter/X, Facebook, Instagram, TikTok, Reddit)
+- KEINE Boulevardmedien
+- KEINE Meinungsblogs ohne Quellenbelege
+
+Gib die Ergebnisse AUSSCHLIESSLICH als JSON-Array zurück, ohne Erklärungen davor oder danach.
+Jedes Element hat diese Felder:
+- "headline": Originale Überschrift
+- "headline_de": Übersetzung in Ausgabesprache (falls Originalsprache abweicht)
+- "source": Name der Quelle (z.B. "netzpolitik.org", "Handelsblatt")
+- "source_url": URL des Artikels
+- "content_summary": Ausführliche Zusammenfassung des Inhalts (3-5 Sätze, in Ausgabesprache)
+- "language": Sprache des Originals (z.B. "de", "en", "fr")
+- "published_at": Veröffentlichungsdatum falls bekannt (ISO-Format)
+
+Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""
+
+# Sprach-Anweisungen
+LANG_INTERNATIONAL = "- Suche in Deutsch UND Englisch für internationale Abdeckung"
+LANG_GERMAN_ONLY = "- Suche NUR auf Deutsch bei deutschsprachigen Quellen (Deutschland, Österreich, Schweiz)\n- KEINE englischsprachigen oder anderssprachigen Quellen"
+
+LANG_DEEP_INTERNATIONAL = "- Suche in Deutsch, Englisch und weiteren relevanten Sprachen"
+LANG_DEEP_GERMAN_ONLY = "- Suche NUR auf Deutsch bei deutschsprachigen Quellen (Deutschland, Österreich, Schweiz)\n- KEINE englischsprachigen oder anderssprachigen Quellen"
+
+
+FEED_SELECTION_PROMPT_TEMPLATE = """Du bist ein OSINT-Analyst. Wähle aus dieser Feed-Liste die Feeds aus, die für die Lage relevant sein könnten.
+
+LAGE: {title}
+KONTEXT: {description}
+INTERNATIONALE QUELLEN: {international}
+
+FEEDS:
+{feed_list}
+
+REGELN:
+- Wähle alle Feeds die thematisch oder regional relevant sein könnten
+- Lieber einen Feed zu viel als zu wenig auswählen
+- Bei "Internationale Quellen: Nein": Keine internationalen Feeds auswählen
+- Allgemeine Nachrichtenfeeds (tagesschau, Spiegel etc.) sind fast immer relevant
+- Antworte NUR mit einem JSON-Array der Nummern, z.B. [1, 2, 5, 12]"""
+
+
+class ResearcherAgent:
+    """Führt OSINT-Recherchen über Claude CLI WebSearch durch."""
+
+    async def select_relevant_feeds(
+        self,
+        title: str,
+        description: str,
+        international: bool,
+        feeds_metadata: list[dict],
+    ) -> tuple[list[dict], ClaudeUsage | None]:
+        """Lässt Claude die relevanten Feeds für eine Lage vorauswählen.
+
+        Returns:
+            (ausgewählte Feeds, usage) — Bei Fehler: (alle Feeds, None)
+        """
+        # Feed-Liste als nummerierte Übersicht formatieren
+        feed_lines = []
+        for i, feed in enumerate(feeds_metadata, 1):
+            feed_lines.append(
+                f"{i}. {feed['name']} ({feed['domain']}) [{feed['category']}]"
+            )
+
+        prompt = FEED_SELECTION_PROMPT_TEMPLATE.format(
+            title=title,
+            description=description or "Keine weitere Beschreibung",
+            international="Ja" if international else "Nein",
+            feed_list="\n".join(feed_lines),
+        )
+
+        try:
+            result, usage = await call_claude(prompt, tools=None)
+
+            # JSON-Array aus Antwort extrahieren
+            match = re.search(r'\[[\d\s,]+\]', result)
+            if not match:
+                logger.warning("Feed-Selektion: Kein JSON-Array in Antwort, nutze alle Feeds")
+                return feeds_metadata, usage
+
+            indices = json.loads(match.group())
+            selected = []
+            for idx in indices:
+                if isinstance(idx, int) and 1 <= idx <= len(feeds_metadata):
+                    selected.append(feeds_metadata[idx - 1])
+
+            if not selected:
+                logger.warning("Feed-Selektion: Keine gültigen Indizes, nutze alle Feeds")
+                return feeds_metadata, usage
+
+            logger.info(
+                f"Feed-Selektion: {len(selected)} von {len(feeds_metadata)} Feeds ausgewählt"
+            )
+            return selected, usage
+
+        except Exception as e:
+            logger.warning(f"Feed-Selektion fehlgeschlagen ({e}), nutze alle Feeds")
+            return feeds_metadata, None
+
+    async def search(self, title: str, description: str = "", incident_type: str = "adhoc", international: bool = True) -> tuple[list[dict], ClaudeUsage | None]:
+        """Sucht nach Informationen zu einem Vorfall."""
+        from config import OUTPUT_LANGUAGE
+        if incident_type == "research":
+            lang_instruction = LANG_DEEP_INTERNATIONAL if international else LANG_DEEP_GERMAN_ONLY
+            prompt = DEEP_RESEARCH_PROMPT_TEMPLATE.format(
+                title=title, description=description, language_instruction=lang_instruction,
+                output_language=OUTPUT_LANGUAGE,
+            )
+        else:
+            lang_instruction = LANG_INTERNATIONAL if international else LANG_GERMAN_ONLY
+            prompt = RESEARCH_PROMPT_TEMPLATE.format(
+                title=title, description=description, language_instruction=lang_instruction,
+                output_language=OUTPUT_LANGUAGE,
+            )
+
+        try:
+            result, usage = await call_claude(prompt)
+            articles = self._parse_response(result)
+
+            # Ausgeschlossene Quellen dynamisch aus DB laden
+            excluded_sources = await self._get_excluded_sources()
+
+            # Ausgeschlossene Quellen filtern
+            filtered = []
+            for article in articles:
+                source = article.get("source", "").lower()
+                source_url = article.get("source_url", "").lower()
+                excluded = False
+                for excl in excluded_sources:
+                    if excl in source or excl in source_url:
+                        excluded = True
+                        break
+                if not excluded:
+                    # Bei nur-deutsch: nicht-deutsche Ergebnisse nachfiltern
+                    if not international and article.get("language", "de") != "de":
+                        continue
+                    filtered.append(article)
+
+            logger.info(f"Recherche ergab {len(filtered)} Artikel (von {len(articles)} gefundenen, international={international})")
+            return filtered, usage
+
+        except Exception as e:
+            logger.error(f"Recherche-Fehler: {e}")
+            return [], None
+
+    async def _get_excluded_sources(self) -> list[str]:
+        """Lädt ausgeschlossene Quellen aus der Datenbank."""
+        try:
+            from source_rules import get_source_rules
+            rules = await get_source_rules()
+            return rules.get("excluded_domains", [])
+        except Exception as e:
+            logger.warning(f"Fallback auf config.py für Excluded Sources: {e}")
+            from config import EXCLUDED_SOURCES
+            return list(EXCLUDED_SOURCES)
+
+    def _parse_response(self, response: str) -> list[dict]:
+        """Parst die Claude-Antwort als JSON-Array."""
+        # Versuche JSON direkt zu parsen
+        try:
+            data = json.loads(response)
+            if isinstance(data, list):
+                return data
+        except json.JSONDecodeError:
+            pass
+
+        # Versuche JSON aus der Antwort zu extrahieren (zwischen [ und ])
+        match = re.search(r'\[.*\]', response, re.DOTALL)
+        if match:
+            try:
+                data = json.loads(match.group())
+                if isinstance(data, list):
+                    return data
+            except json.JSONDecodeError:
+                pass
+
+        logger.warning("Konnte Claude-Antwort nicht als JSON parsen")
+        return []
diff --git a/src/auth.py b/src/auth.py
new file mode 100644
index 0000000..2a1d6d4
--- /dev/null
+++ b/src/auth.py
@@ -0,0 +1,106 @@
+"""JWT-Authentifizierung mit Magic-Link-Support und Multi-Tenancy."""
+import secrets
+import string
+from datetime import datetime, timedelta, timezone
+from jose import jwt, JWTError
+import bcrypt as _bcrypt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from config import JWT_SECRET, JWT_ALGORITHM, JWT_EXPIRE_HOURS, MAGIC_LINK_EXPIRE_MINUTES
+
+security = HTTPBearer()
+
+
+def hash_password(password: str) -> str:
+    """Passwort hashen mit bcrypt."""
+    return _bcrypt.hashpw(password.encode("utf-8"), _bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(password: str, password_hash: str) -> bool:
+    """Passwort gegen Hash pruefen."""
+    return _bcrypt.checkpw(password.encode("utf-8"), password_hash.encode("utf-8"))
+
+
+JWT_ISSUER = "intelsight-osint"
+JWT_AUDIENCE = "intelsight-osint"
+
+
+def create_token(
+    user_id: int,
+    username: str,
+    email: str,
+    role: str = "member",
+    tenant_id: int = None,
+    org_slug: str = None,
+) -> str:
+    """JWT-Token erstellen mit Tenant-Kontext."""
+    now = datetime.now(timezone.utc)
+    expire = now + timedelta(hours=JWT_EXPIRE_HOURS)
+    payload = {
+        "sub": str(user_id),
+        "username": username,
+        "email": email,
+        "role": role,
+        "tenant_id": tenant_id,
+        "org_slug": org_slug,
+        "iss": JWT_ISSUER,
+        "aud": JWT_AUDIENCE,
+        "iat": now,
+        "exp": expire,
+    }
+    return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
+
+
+def decode_token(token: str) -> dict:
+    """JWT-Token dekodieren und validieren."""
+    try:
+        payload = jwt.decode(
+            token,
+            JWT_SECRET,
+            algorithms=[JWT_ALGORITHM],
+            issuer=JWT_ISSUER,
+            audience=JWT_AUDIENCE,
+        )
+        return payload
+    except JWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token ungueltig oder abgelaufen",
+        )
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+) -> dict:
+    """FastAPI Dependency: Aktuellen Nutzer aus Token extrahieren."""
+    payload = decode_token(credentials.credentials)
+    return {
+        "id": int(payload["sub"]),
+        "username": payload["username"],
+        "email": payload.get("email", ""),
+        "role": payload.get("role", "member"),
+        "tenant_id": payload.get("tenant_id"),
+        "org_slug": payload.get("org_slug"),
+    }
+
+
+async def require_org_member(
+    current_user: dict = Depends(get_current_user),
+) -> dict:
+    """FastAPI Dependency: Erfordert Org-Mitgliedschaft."""
+    if not current_user.get("tenant_id"):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Keine Organisation zugeordnet",
+        )
+    return current_user
+
+
+def generate_magic_token() -> str:
+    """Generiert einen 64-Zeichen URL-safe Token."""
+    return secrets.token_urlsafe(48)
+
+
+def generate_magic_code() -> str:
+    """Generiert einen 6-stelligen numerischen Code."""
+    return ''.join(secrets.choice(string.digits) for _ in range(6))
diff --git a/src/config.py b/src/config.py
new file mode 100644
index 0000000..05c281c
--- /dev/null
+++ b/src/config.py
@@ -0,0 +1,74 @@
+"""Konfiguration für den OSINT Lagemonitor."""
+import os
+from zoneinfo import ZoneInfo
+
+# Zeitzone für alle Anwendungs-Timestamps (DB, Logs, UI)
+TIMEZONE = ZoneInfo("Europe/Berlin")
+
+# Pfade
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+LOG_DIR = os.path.join(BASE_DIR, "logs")
+STATIC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
+DB_PATH = os.path.join(DATA_DIR, "osint.db")
+
+# JWT
+JWT_SECRET = os.environ.get("JWT_SECRET")
+if not JWT_SECRET:
+    raise RuntimeError("JWT_SECRET Umgebungsvariable muss gesetzt sein")
+JWT_ALGORITHM = "HS256"
+JWT_EXPIRE_HOURS = 24
+
+# Claude CLI
+CLAUDE_PATH = os.environ.get("CLAUDE_PATH", "/home/claude-dev/.claude/local/claude")
+CLAUDE_MAX_CONCURRENT = 1
+CLAUDE_TIMEOUT = 300  # Sekunden (Claude mit WebSearch braucht oft 2-3 Min)
+
+# Ausgabesprache (Lagebilder, Faktenchecks, Zusammenfassungen)
+OUTPUT_LANGUAGE = "Deutsch"
+
+# Auto-Refresh
+REFRESH_MIN_INTERVAL = 10  # Minuten
+REFRESH_MAX_INTERVAL = 10080  # 1 Woche
+REFRESH_DEFAULT_INTERVAL = 15
+
+# RSS-Feeds (Fallback, primär aus DB geladen)
+RSS_FEEDS = {
+    "deutsch": [
+        {"name": "tagesschau", "url": "https://www.tagesschau.de/index~rss2.xml"},
+        {"name": "ZDF heute", "url": "https://www.zdf.de/rss/zdf/nachrichten"},
+        {"name": "Spiegel", "url": "https://www.spiegel.de/schlagzeilen/index.rss"},
+        {"name": "Zeit", "url": "https://newsfeed.zeit.de/index"},
+        {"name": "FAZ", "url": "https://www.faz.net/rss/aktuell/"},
+        {"name": "Süddeutsche", "url": "https://rss.sueddeutsche.de/rss/Topthemen"},
+        {"name": "NZZ", "url": "https://www.nzz.ch/recent.rss"},
+        {"name": "Deutsche Welle", "url": "https://rss.dw.com/rdf/rss-de-all"},
+    ],
+    "international": [
+        {"name": "Reuters", "url": "https://www.reutersagency.com/feed/"},
+        {"name": "AP News", "url": "https://rsshub.app/apnews/topics/apf-topnews"},
+        {"name": "BBC World", "url": "https://feeds.bbci.co.uk/news/world/rss.xml"},
+        {"name": "Al Jazeera", "url": "https://www.aljazeera.com/xml/rss/all.xml"},
+        {"name": "France24", "url": "https://www.france24.com/en/rss"},
+    ],
+    "behoerden": [
+        {"name": "BMI", "url": "https://www.bmi.bund.de/SiteGlobals/Functions/RSSFeed/BMI/RSSNewsfeed/RSSNewsfeed_Nachrichten.xml"},
+        {"name": "Europol", "url": "https://www.europol.europa.eu/rss.xml"},
+    ],
+}
+
+# Ausgeschlossene Quellen (Fallback, primär aus DB geladen)
+EXCLUDED_SOURCES = ["bild.de", "bild", "twitter", "x.com", "facebook", "instagram", "tiktok", "reddit"]
+
+# SMTP (E-Mail-Versand für Magic Links und Einladungen)
+SMTP_HOST = os.environ.get("SMTP_HOST", "")
+SMTP_PORT = int(os.environ.get("SMTP_PORT", "587"))
+SMTP_USER = os.environ.get("SMTP_USER", "")
+SMTP_PASSWORD = os.environ.get("SMTP_PASSWORD", "")
+SMTP_FROM_EMAIL = os.environ.get("SMTP_FROM_EMAIL", "noreply@intelsight.de")
+SMTP_FROM_NAME = os.environ.get("SMTP_FROM_NAME", "AegisSight Monitor")
+SMTP_USE_TLS = os.environ.get("SMTP_USE_TLS", "true").lower() == "true"
+
+# Magic Link
+MAGIC_LINK_EXPIRE_MINUTES = 10
+MAGIC_LINK_BASE_URL = os.environ.get("MAGIC_LINK_BASE_URL", "https://osint.intelsight.de")
diff --git a/src/database.py b/src/database.py
new file mode 100644
index 0000000..61eec40
--- /dev/null
+++ b/src/database.py
@@ -0,0 +1,504 @@
+"""SQLite Datenbank-Setup und Zugriff."""
+import aiosqlite
+import logging
+import os
+from config import DB_PATH, DATA_DIR
+
+logger = logging.getLogger("osint.database")
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS organizations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    slug TEXT UNIQUE NOT NULL,
+    is_active INTEGER DEFAULT 1,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS licenses (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+    license_type TEXT NOT NULL DEFAULT 'trial',
+    max_users INTEGER NOT NULL DEFAULT 5,
+    valid_from TIMESTAMP NOT NULL,
+    valid_until TIMESTAMP,
+    status TEXT NOT NULL DEFAULT 'active',
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    email TEXT UNIQUE NOT NULL,
+    username TEXT NOT NULL,
+    password_hash TEXT,
+    organization_id INTEGER NOT NULL REFERENCES organizations(id),
+    role TEXT NOT NULL DEFAULT 'member',
+    is_active INTEGER DEFAULT 1,
+    last_login_at TIMESTAMP,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE IF NOT EXISTS magic_links (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    email TEXT NOT NULL,
+    token TEXT UNIQUE NOT NULL,
+    code TEXT NOT NULL,
+    purpose TEXT NOT NULL DEFAULT 'login',
+    user_id INTEGER REFERENCES users(id),
+    is_used INTEGER DEFAULT 0,
+    expires_at TIMESTAMP NOT NULL,
+    ip_address TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS portal_admins (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    username TEXT UNIQUE NOT NULL,
+    password_hash TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS incidents (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT DEFAULT 'active',
+    type TEXT DEFAULT 'adhoc',
+    refresh_mode TEXT DEFAULT 'manual',
+    refresh_interval INTEGER DEFAULT 15,
+    retention_days INTEGER DEFAULT 0,
+    visibility TEXT DEFAULT 'public',
+    summary TEXT,
+    sources_json TEXT,
+    international_sources INTEGER DEFAULT 1,
+    tenant_id INTEGER REFERENCES organizations(id),
+    created_by INTEGER REFERENCES users(id),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE IF NOT EXISTS articles (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+    headline TEXT NOT NULL,
+    headline_de TEXT,
+    source TEXT NOT NULL,
+    source_url TEXT,
+    content_original TEXT,
+    content_de TEXT,
+    language TEXT DEFAULT 'de',
+    published_at TIMESTAMP,
+    collected_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    verification_status TEXT DEFAULT 'unverified',
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+CREATE TABLE IF NOT EXISTS fact_checks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+    claim TEXT NOT NULL,
+    status TEXT DEFAULT 'developing',
+    sources_count INTEGER DEFAULT 0,
+    evidence TEXT,
+    is_notification INTEGER DEFAULT 0,
+    checked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+
+CREATE TABLE IF NOT EXISTS refresh_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+    started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    articles_found INTEGER DEFAULT 0,
+    status TEXT DEFAULT 'running',
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+
+CREATE TABLE IF NOT EXISTS incident_snapshots (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+    summary TEXT,
+    sources_json TEXT,
+    article_count INTEGER DEFAULT 0,
+    fact_check_count INTEGER DEFAULT 0,
+    refresh_log_id INTEGER REFERENCES refresh_log(id),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+
+CREATE TABLE IF NOT EXISTS sources (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    url TEXT,
+    domain TEXT,
+    source_type TEXT NOT NULL DEFAULT 'rss_feed',
+    category TEXT NOT NULL DEFAULT 'sonstige',
+    status TEXT NOT NULL DEFAULT 'active',
+    notes TEXT,
+    added_by TEXT,
+    article_count INTEGER DEFAULT 0,
+    last_seen_at TIMESTAMP,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+
+CREATE TABLE IF NOT EXISTS notifications (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'refresh_summary',
+    title TEXT NOT NULL,
+    text TEXT NOT NULL,
+    icon TEXT DEFAULT 'info',
+    is_read INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    tenant_id INTEGER REFERENCES organizations(id)
+);
+CREATE INDEX IF NOT EXISTS idx_notifications_user_read ON notifications(user_id, is_read);
+
+CREATE TABLE IF NOT EXISTS incident_subscriptions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    incident_id INTEGER NOT NULL REFERENCES incidents(id) ON DELETE CASCADE,
+    notify_email_summary INTEGER DEFAULT 0,
+    notify_email_new_articles INTEGER DEFAULT 0,
+    notify_email_status_change INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(user_id, incident_id)
+);
+"""
+
+
+async def get_db() -> aiosqlite.Connection:
+    """Erstellt eine neue Datenbankverbindung."""
+    os.makedirs(DATA_DIR, exist_ok=True)
+    db = await aiosqlite.connect(DB_PATH)
+    db.row_factory = aiosqlite.Row
+    await db.execute("PRAGMA journal_mode=WAL")
+    await db.execute("PRAGMA foreign_keys=ON")
+    return db
+
+
+async def init_db():
+    """Initialisiert die Datenbank mit dem Schema."""
+    db = await get_db()
+    try:
+        await db.executescript(SCHEMA)
+        await db.commit()
+
+        # --- Migrationen fuer bestehende Datenbanken ---
+
+        # Incidents-Spalten pruefen
+        cursor = await db.execute("PRAGMA table_info(incidents)")
+        columns = [row[1] for row in await cursor.fetchall()]
+
+        if "type" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN type TEXT DEFAULT 'adhoc'")
+            await db.commit()
+
+        if "sources_json" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN sources_json TEXT")
+            await db.commit()
+
+        if "international_sources" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN international_sources INTEGER DEFAULT 1")
+            await db.commit()
+
+        if "visibility" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN visibility TEXT DEFAULT 'public'")
+            await db.commit()
+
+        if "tenant_id" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+            logger.info("Migration: tenant_id zu incidents hinzugefuegt")
+
+        # Migration: E-Mail-Benachrichtigungs-Praeferenzen pro Lage
+        if "notify_email_summary" not in columns:
+            await db.execute("ALTER TABLE incidents ADD COLUMN notify_email_summary INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE incidents ADD COLUMN notify_email_new_articles INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE incidents ADD COLUMN notify_email_status_change INTEGER DEFAULT 0")
+            await db.commit()
+            logger.info("Migration: E-Mail-Benachrichtigungs-Spalten zu incidents hinzugefuegt")
+
+        # Migration: Token-Spalten fuer refresh_log
+        cursor = await db.execute("PRAGMA table_info(refresh_log)")
+        rl_columns = [row[1] for row in await cursor.fetchall()]
+        if "input_tokens" not in rl_columns:
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN input_tokens INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN output_tokens INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN cache_creation_tokens INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN cache_read_tokens INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN total_cost_usd REAL DEFAULT 0.0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN api_calls INTEGER DEFAULT 0")
+            await db.commit()
+
+        if "trigger_type" not in rl_columns:
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN trigger_type TEXT DEFAULT 'manual'")
+            await db.commit()
+
+        if "retry_count" not in rl_columns:
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN retry_count INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN error_message TEXT")
+            await db.commit()
+
+        if "tenant_id" not in rl_columns:
+            await db.execute("ALTER TABLE refresh_log ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Migration: reliability_score entfernen (falls noch vorhanden)
+        cursor = await db.execute("PRAGMA table_info(incidents)")
+        inc_columns = [row[1] for row in await cursor.fetchall()]
+        if "reliability_score" in inc_columns:
+            await db.execute("ALTER TABLE incidents DROP COLUMN reliability_score")
+            await db.commit()
+
+        cursor = await db.execute("PRAGMA table_info(incident_snapshots)")
+        snap_columns = [row[1] for row in await cursor.fetchall()]
+        if "reliability_score" in snap_columns:
+            await db.execute("ALTER TABLE incident_snapshots DROP COLUMN reliability_score")
+            await db.commit()
+
+        # Migration: notifications-Tabelle (fuer bestehende DBs)
+        cursor = await db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='notifications'")
+        if not await cursor.fetchone():
+            await db.executescript("""
+                CREATE TABLE IF NOT EXISTS notifications (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    incident_id INTEGER REFERENCES incidents(id) ON DELETE CASCADE,
+                    type TEXT NOT NULL DEFAULT 'refresh_summary',
+                    title TEXT NOT NULL,
+                    text TEXT NOT NULL,
+                    icon TEXT DEFAULT 'info',
+                    is_read INTEGER DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    tenant_id INTEGER REFERENCES organizations(id)
+                );
+                CREATE INDEX IF NOT EXISTS idx_notifications_user_read ON notifications(user_id, is_read);
+            """)
+            await db.commit()
+
+        # Migration: incident_subscriptions-Tabelle (fuer bestehende DBs)
+        cursor = await db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='incident_subscriptions'")
+        if not await cursor.fetchone():
+            await db.executescript("""
+                CREATE TABLE IF NOT EXISTS incident_subscriptions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    incident_id INTEGER NOT NULL REFERENCES incidents(id) ON DELETE CASCADE,
+                    notify_email_summary INTEGER DEFAULT 0,
+                    notify_email_new_articles INTEGER DEFAULT 0,
+                    notify_email_status_change INTEGER DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    UNIQUE(user_id, incident_id)
+                );
+            """)
+            await db.commit()
+            logger.info("Migration: incident_subscriptions-Tabelle erstellt")
+        else:
+            # Migration: Spalte umbenennen contradiction -> new_articles
+            cursor = await db.execute("PRAGMA table_info(incident_subscriptions)")
+            sub_columns = [row[1] for row in await cursor.fetchall()]
+            if "notify_email_contradiction" in sub_columns:
+                await db.execute("ALTER TABLE incident_subscriptions RENAME COLUMN notify_email_contradiction TO notify_email_new_articles")
+                await db.commit()
+                logger.info("Migration: notify_email_contradiction -> notify_email_new_articles umbenannt")
+
+        # Migration: role-Spalte fuer users
+        cursor = await db.execute("PRAGMA table_info(users)")
+        user_columns = [row[1] for row in await cursor.fetchall()]
+        if "role" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN role TEXT DEFAULT 'member'")
+            await db.execute("UPDATE users SET role = 'org_admin'")
+            await db.commit()
+            logger.info("Migration: role-Spalte zu users hinzugefuegt")
+
+        # Migration: email, organization_id, is_active, last_login_at fuer users
+        if "email" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN email TEXT")
+            await db.commit()
+            logger.info("Migration: email zu users hinzugefuegt")
+
+        if "organization_id" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN organization_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+            logger.info("Migration: organization_id zu users hinzugefuegt")
+
+        # Index erst nach Spalten-Migration erstellen
+        try:
+            await db.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_users_org_username ON users(organization_id, username)")
+            await db.commit()
+        except Exception:
+            pass  # Index existiert bereits oder Spalte fehlt noch
+
+        if "is_active" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN is_active INTEGER DEFAULT 1")
+            await db.commit()
+
+        if "last_login_at" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN last_login_at TIMESTAMP")
+            await db.commit()
+
+        # Migration: E-Mail-Benachrichtigungs-Praeferenzen fuer users
+        if "notify_email_summary" not in user_columns:
+            await db.execute("ALTER TABLE users ADD COLUMN notify_email_summary INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE users ADD COLUMN notify_email_new_articles INTEGER DEFAULT 0")
+            await db.execute("ALTER TABLE users ADD COLUMN notify_email_status_change INTEGER DEFAULT 0")
+            await db.commit()
+            logger.info("Migration: E-Mail-Benachrichtigungs-Spalten zu users hinzugefuegt")
+
+        # Migration: tenant_id fuer articles
+        cursor = await db.execute("PRAGMA table_info(articles)")
+        art_columns = [row[1] for row in await cursor.fetchall()]
+        if "tenant_id" not in art_columns:
+            await db.execute("ALTER TABLE articles ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Migration: tenant_id fuer fact_checks
+        cursor = await db.execute("PRAGMA table_info(fact_checks)")
+        fc_columns = [row[1] for row in await cursor.fetchall()]
+        if "tenant_id" not in fc_columns:
+            await db.execute("ALTER TABLE fact_checks ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Migration: tenant_id fuer incident_snapshots
+        cursor = await db.execute("PRAGMA table_info(incident_snapshots)")
+        snap_columns2 = [row[1] for row in await cursor.fetchall()]
+        if "tenant_id" not in snap_columns2:
+            await db.execute("ALTER TABLE incident_snapshots ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Migration: tenant_id fuer sources
+        cursor = await db.execute("PRAGMA table_info(sources)")
+        src_columns = [row[1] for row in await cursor.fetchall()]
+        if "tenant_id" not in src_columns:
+            await db.execute("ALTER TABLE sources ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Migration: tenant_id fuer notifications
+        cursor = await db.execute("PRAGMA table_info(notifications)")
+        notif_columns = [row[1] for row in await cursor.fetchall()]
+        if "tenant_id" not in notif_columns:
+            await db.execute("ALTER TABLE notifications ADD COLUMN tenant_id INTEGER REFERENCES organizations(id)")
+            await db.commit()
+
+        # Indexes erstellen (nach Spalten-Migrationen)
+        for idx_sql in [
+            "CREATE INDEX IF NOT EXISTS idx_incidents_tenant_status ON incidents(tenant_id, status)",
+            "CREATE INDEX IF NOT EXISTS idx_articles_tenant_incident ON articles(tenant_id, incident_id)",
+        ]:
+            try:
+                await db.execute(idx_sql)
+                await db.commit()
+            except Exception:
+                pass
+
+        # Verwaiste running-Eintraege beim Start als error markieren (aelter als 15 Min)
+        await db.execute(
+            """UPDATE refresh_log SET status = 'error', error_message = 'Verwaist beim Neustart',
+               completed_at = CURRENT_TIMESTAMP
+               WHERE status = 'running'
+               AND started_at < datetime('now', '-15 minutes')"""
+        )
+        await db.commit()
+
+        # Sources-Tabelle seeden (nur wenn leer)
+        cursor = await db.execute("SELECT COUNT(*) as cnt FROM sources")
+        row = await cursor.fetchone()
+        if row["cnt"] == 0:
+            await _seed_sources(db)
+
+    finally:
+        await db.close()
+
+
+async def _seed_sources(db: aiosqlite.Connection):
+    """Befuellt die sources-Tabelle aus der config.py-Konfiguration."""
+    from config import RSS_FEEDS, EXCLUDED_SOURCES
+
+    category_map = {
+        "tagesschau": "oeffentlich-rechtlich",
+        "ZDF heute": "oeffentlich-rechtlich",
+        "Deutsche Welle": "oeffentlich-rechtlich",
+        "Spiegel": "qualitaetszeitung",
+        "Zeit": "qualitaetszeitung",
+        "FAZ": "qualitaetszeitung",
+        "Süddeutsche": "qualitaetszeitung",
+        "NZZ": "qualitaetszeitung",
+        "Reuters": "nachrichtenagentur",
+        "AP News": "nachrichtenagentur",
+        "BBC World": "international",
+        "Al Jazeera": "international",
+        "France24": "international",
+        "BMI": "behoerde",
+        "Europol": "behoerde",
+    }
+
+    for _rss_category, feeds in RSS_FEEDS.items():
+        for feed in feeds:
+            name = feed["name"]
+            url = feed["url"]
+            try:
+                from urllib.parse import urlparse
+                domain = urlparse(url).netloc.lower().replace("www.", "")
+            except Exception:
+                domain = ""
+
+            category = category_map.get(name, "sonstige")
+            await db.execute(
+                """INSERT INTO sources (name, url, domain, source_type, category, status, added_by, tenant_id)
+                   VALUES (?, ?, ?, 'rss_feed', ?, 'active', 'system', NULL)""",
+                (name, url, domain, category),
+            )
+
+    for excl in EXCLUDED_SOURCES:
+        await db.execute(
+            """INSERT INTO sources (name, domain, source_type, category, status, added_by, tenant_id)
+               VALUES (?, ?, 'excluded', 'sonstige', 'active', 'system', NULL)""",
+            (excl, excl),
+        )
+
+    await db.commit()
+    await refresh_source_counts(db)
+
+    logger.info(f"Sources-Tabelle geseeded: {len(RSS_FEEDS.get('deutsch', []))+len(RSS_FEEDS.get('international', []))+len(RSS_FEEDS.get('behoerden', []))} RSS-Feeds, {len(EXCLUDED_SOURCES)} ausgeschlossene Quellen")
+
+
+async def refresh_source_counts(db: aiosqlite.Connection):
+    """Berechnet Artikelzaehler und last_seen_at fuer alle Quellen neu."""
+    cursor = await db.execute("SELECT id, name, domain FROM sources WHERE source_type != 'excluded'")
+    sources = await cursor.fetchall()
+
+    for source in sources:
+        sid = source["id"]
+        name = source["name"]
+        domain = source["domain"] or ""
+
+        if domain:
+            cursor = await db.execute(
+                """SELECT COUNT(*) as cnt, MAX(collected_at) as last_seen
+                   FROM articles WHERE source = ? OR source_url LIKE ?""",
+                (name, f"%{domain}%"),
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT COUNT(*) as cnt, MAX(collected_at) as last_seen FROM articles WHERE source = ?",
+                (name,),
+            )
+        row = await cursor.fetchone()
+        await db.execute(
+            "UPDATE sources SET article_count = ?, last_seen_at = ? WHERE id = ?",
+            (row["cnt"], row["last_seen"], sid),
+        )
+
+    await db.commit()
+
+
+async def db_dependency():
+    """FastAPI Dependency fuer Datenbankverbindungen."""
+    db = await get_db()
+    try:
+        yield db
+    finally:
+        await db.close()
diff --git a/src/email_utils/__init__.py b/src/email_utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/email_utils/rate_limiter.py b/src/email_utils/rate_limiter.py
new file mode 100644
index 0000000..57c596c
--- /dev/null
+++ b/src/email_utils/rate_limiter.py
@@ -0,0 +1,102 @@
+"""In-Memory Rate-Limiting fuer Magic-Link-Anfragen und Code-Verifizierung."""
+import time
+from collections import defaultdict
+
+
+class RateLimiter:
+    """Rate-Limiter mit zwei Ebenen: pro E-Mail und pro IP."""
+
+    def __init__(
+        self,
+        max_per_email: int = 3,
+        email_window_seconds: int = 900,  # 15 Minuten
+        max_per_ip: int = 10,
+        ip_window_seconds: int = 3600,  # 1 Stunde
+    ):
+        self.max_per_email = max_per_email
+        self.email_window = email_window_seconds
+        self.max_per_ip = max_per_ip
+        self.ip_window = ip_window_seconds
+        self._email_requests: dict[str, list[float]] = defaultdict(list)
+        self._ip_requests: dict[str, list[float]] = defaultdict(list)
+
+    def _clean(self, entries: list[float], window: int) -> list[float]:
+        cutoff = time.time() - window
+        return [t for t in entries if t > cutoff]
+
+    def check(self, email: str, ip: str) -> tuple[bool, str]:
+        """Prueft ob die Anfrage erlaubt ist.
+
+        Returns:
+            (erlaubt, grund) - True wenn OK, False mit Grund wenn blockiert.
+        """
+        now = time.time()
+
+        # E-Mail-Limit
+        self._email_requests[email] = self._clean(self._email_requests[email], self.email_window)
+        if len(self._email_requests[email]) >= self.max_per_email:
+            return False, "Zu viele Anfragen fuer diese E-Mail-Adresse. Bitte warten."
+
+        # IP-Limit
+        self._ip_requests[ip] = self._clean(self._ip_requests[ip], self.ip_window)
+        if len(self._ip_requests[ip]) >= self.max_per_ip:
+            return False, "Zu viele Anfragen von dieser IP-Adresse. Bitte warten."
+
+        return True, ""
+
+    def record(self, email: str, ip: str):
+        """Zeichnet eine erfolgreiche Anfrage auf."""
+        now = time.time()
+        self._email_requests[email].append(now)
+        self._ip_requests[ip].append(now)
+
+
+class VerifyCodeLimiter:
+    """Rate-Limiter fuer Code-Verifizierung (Brute-Force-Schutz).
+
+    Zaehlt Fehlversuche pro E-Mail und pro IP.
+    Nach max_attempts wird gesperrt bis das Zeitfenster ablaeuft.
+    """
+
+    def __init__(
+        self,
+        max_attempts_per_email: int = 5,
+        max_attempts_per_ip: int = 15,
+        window_seconds: int = 600,  # 10 Minuten (= Magic-Link-Ablaufzeit)
+    ):
+        self.max_per_email = max_attempts_per_email
+        self.max_per_ip = max_attempts_per_ip
+        self.window = window_seconds
+        self._email_failures: dict[str, list[float]] = defaultdict(list)
+        self._ip_failures: dict[str, list[float]] = defaultdict(list)
+
+    def _clean(self, entries: list[float]) -> list[float]:
+        cutoff = time.time() - self.window
+        return [t for t in entries if t > cutoff]
+
+    def check(self, email: str, ip: str) -> tuple[bool, str]:
+        """Prueft ob ein Verifizierungsversuch erlaubt ist."""
+        self._email_failures[email] = self._clean(self._email_failures[email])
+        if len(self._email_failures[email]) >= self.max_per_email:
+            return False, "Zu viele Fehlversuche. Bitte neuen Code anfordern."
+
+        self._ip_failures[ip] = self._clean(self._ip_failures[ip])
+        if len(self._ip_failures[ip]) >= self.max_per_ip:
+            return False, "Zu viele Fehlversuche von dieser IP-Adresse."
+
+        return True, ""
+
+    def record_failure(self, email: str, ip: str):
+        """Zeichnet einen fehlgeschlagenen Versuch auf."""
+        now = time.time()
+        self._email_failures[email].append(now)
+        self._ip_failures[ip].append(now)
+
+    def clear(self, email: str):
+        """Loescht Zaehler nach erfolgreichem Login."""
+        self._email_failures.pop(email, None)
+
+
+# Singleton-Instanzen
+magic_link_limiter = RateLimiter()
+verify_code_limiter = VerifyCodeLimiter()
diff --git a/src/email_utils/sender.py b/src/email_utils/sender.py
new file mode 100644
index 0000000..c00abfc
--- /dev/null
+++ b/src/email_utils/sender.py
@@ -0,0 +1,54 @@
+"""Async E-Mail-Versand via SMTP."""
+import logging
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+import aiosmtplib
+
+from config import (
+    SMTP_HOST,
+    SMTP_PORT,
+    SMTP_USER,
+    SMTP_PASSWORD,
+    SMTP_FROM_EMAIL,
+    SMTP_FROM_NAME,
+    SMTP_USE_TLS,
+)
+
+logger = logging.getLogger("osint.email")
+
+
+async def send_email(to_email: str, subject: str, html_body: str) -> bool:
+    """Sendet eine HTML-E-Mail.
+
+    Returns:
+        True bei Erfolg, False bei Fehler.
+    """
+    if not SMTP_HOST:
+        logger.warning(f"SMTP nicht konfiguriert - E-Mail an {to_email} nicht gesendet: {subject}")
+        return False
+
+    msg = MIMEMultipart("alternative")
+    msg["From"] = f"{SMTP_FROM_NAME} <{SMTP_FROM_EMAIL}>"
+    msg["To"] = to_email
+    msg["Subject"] = subject
+
+    # Text-Fallback (simpel)
+    text_content = f"Betreff: {subject}\n\nBitte oeffnen Sie diese E-Mail in einem HTML-faehigen E-Mail-Client."
+    msg.attach(MIMEText(text_content, "plain", "utf-8"))
+    msg.attach(MIMEText(html_body, "html", "utf-8"))
+
+    try:
+        await aiosmtplib.send(
+            msg,
+            hostname=SMTP_HOST,
+            port=SMTP_PORT,
+            username=SMTP_USER if SMTP_USER else None,
+            password=SMTP_PASSWORD if SMTP_PASSWORD else None,
+            start_tls=SMTP_USE_TLS,
+        )
+        logger.info(f"E-Mail gesendet an {to_email}: {subject}")
+        return True
+    except Exception as e:
+        logger.error(f"E-Mail-Versand fehlgeschlagen an {to_email}: {e}")
+        return False
diff --git a/src/email_utils/templates.py b/src/email_utils/templates.py
new file mode 100644
index 0000000..93107fd
--- /dev/null
+++ b/src/email_utils/templates.py
@@ -0,0 +1,138 @@
+"""HTML-E-Mail-Vorlagen fuer Magic Links, Einladungen und Benachrichtigungen."""
+
+
+def magic_link_login_email(username: str, code: str, link: str) -> tuple[str, str]:
+    """Erzeugt Login-E-Mail mit Magic Link und Code.
+
+    Returns:
+        (subject, html_body)
+    """
+    subject = f"AegisSight Monitor - Anmeldung"
+    html = f"""<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; padding: 40px 20px;">
+  <div style="max-width: 480px; margin: 0 auto; background: #1e293b; border-radius: 12px; padding: 32px; border: 1px solid #334155;">
+    <h1 style="color: #f0b429; font-size: 20px; margin: 0 0 24px 0;">AegisSight Monitor</h1>
+
+    <p style="margin: 0 0 16px 0;">Hallo {username},</p>
+
+    <p style="margin: 0 0 24px 0;">Klicken Sie auf den Link oder geben Sie den Code ein, um sich anzumelden:</p>
+
+    <div style="background: #0f172a; border-radius: 8px; padding: 20px; text-align: center; margin: 0 0 24px 0;">
+      <div style="font-size: 32px; font-weight: 700; letter-spacing: 8px; color: #f0b429; font-family: monospace;">{code}</div>
+    </div>
+
+    <div style="text-align: center; margin: 0 0 24px 0;">
+      <a href="{link}" style="display: inline-block; background: #f0b429; color: #0f172a; padding: 12px 32px; border-radius: 6px; text-decoration: none; font-weight: 600;">Jetzt anmelden</a>
+    </div>
+
+    <p style="color: #94a3b8; font-size: 13px; margin: 0;">Dieser Link ist 10 Minuten gueltig. Falls Sie diese Anmeldung nicht angefordert haben, ignorieren Sie diese E-Mail.</p>
+  </div>
+</body>
+</html>"""
+    return subject, html
+
+
+def invite_email(username: str, org_name: str, code: str, link: str) -> tuple[str, str]:
+    """Erzeugt Einladungs-E-Mail fuer neue Nutzer.
+
+    Returns:
+        (subject, html_body)
+    """
+    subject = f"Einladung zum AegisSight Monitor - {org_name}"
+    html = f"""<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; padding: 40px 20px;">
+  <div style="max-width: 480px; margin: 0 auto; background: #1e293b; border-radius: 12px; padding: 32px; border: 1px solid #334155;">
+    <h1 style="color: #f0b429; font-size: 20px; margin: 0 0 24px 0;">AegisSight Monitor</h1>
+
+    <p style="margin: 0 0 16px 0;">Hallo {username},</p>
+
+    <p style="margin: 0 0 16px 0;">Sie wurden zur Organisation <strong>{org_name}</strong> im AegisSight Monitor eingeladen.</p>
+
+    <p style="margin: 0 0 24px 0;">Klicken Sie auf den Link, um Ihren Zugang zu aktivieren:</p>
+
+    <div style="background: #0f172a; border-radius: 8px; padding: 20px; text-align: center; margin: 0 0 24px 0;">
+      <div style="font-size: 32px; font-weight: 700; letter-spacing: 8px; color: #f0b429; font-family: monospace;">{code}</div>
+    </div>
+
+    <div style="text-align: center; margin: 0 0 24px 0;">
+      <a href="{link}" style="display: inline-block; background: #f0b429; color: #0f172a; padding: 12px 32px; border-radius: 6px; text-decoration: none; font-weight: 600;">Einladung annehmen</a>
+    </div>
+
+    <p style="color: #94a3b8; font-size: 13px; margin: 0;">Dieser Link ist 48 Stunden gueltig.</p>
+  </div>
+</body>
+</html>"""
+    return subject, html
+
+
+def incident_notification_email(
+    username: str,
+    incident_title: str,
+    notifications: list[dict],
+    dashboard_url: str,
+) -> tuple[str, str]:
+    """Erzeugt Benachrichtigungs-E-Mail fuer Lagen-Updates.
+
+    Args:
+        username: Empfaenger-Name
+        incident_title: Titel der Lage/Recherche
+        notifications: Liste von {"text": ..., "icon": ...} Dicts
+        dashboard_url: Link zum Dashboard
+
+    Returns:
+        (subject, html_body)
+    """
+    subject = f"AegisSight - {incident_title}"
+
+    icon_map = {
+        "success": "&#10003;",    # Haekchen
+        "warning": "&#9888;",     # Warndreieck
+        "error": "&#10007;",      # Kreuz
+        "info": "&#9432;",        # Info-Kreis
+    }
+    color_map = {
+        "success": "#22c55e",
+        "warning": "#f0b429",
+        "error": "#ef4444",
+        "info": "#94a3b8",
+    }
+
+    items_html = ""
+    for n in notifications:
+        icon = icon_map.get(n.get("icon", "info"), "&#9432;")
+        color = color_map.get(n.get("icon", "info"), "#94a3b8")
+        text = n.get("text", "")
+        items_html += f"""
+      <div style="display: flex; align-items: flex-start; gap: 10px; padding: 10px 0; border-bottom: 1px solid #334155;">
+        <span style="color: {color}; font-size: 18px; line-height: 1;">{icon}</span>
+        <span style="color: #e2e8f0; font-size: 14px; line-height: 1.4;">{text}</span>
+      </div>"""
+
+    html = f"""<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; padding: 40px 20px;">
+  <div style="max-width: 480px; margin: 0 auto; background: #1e293b; border-radius: 12px; padding: 32px; border: 1px solid #334155;">
+    <h1 style="color: #f0b429; font-size: 20px; margin: 0 0 8px 0;">AegisSight Monitor</h1>
+    <p style="color: #94a3b8; font-size: 12px; margin: 0 0 24px 0;">Lagebericht-Benachrichtigung</p>
+
+    <p style="margin: 0 0 8px 0;">Hallo {username},</p>
+    <p style="margin: 0 0 20px 0;">es gibt Neuigkeiten zur Lage <strong style="color: #f0b429;">{incident_title}</strong>:</p>
+
+    <div style="background: #0f172a; border-radius: 8px; padding: 4px 16px; margin: 0 0 24px 0;">
+      {items_html}
+    </div>
+
+    <div style="text-align: center; margin: 0 0 24px 0;">
+      <a href="{dashboard_url}" style="display: inline-block; background: #f0b429; color: #0f172a; padding: 12px 32px; border-radius: 6px; text-decoration: none; font-weight: 600;">Im Dashboard ansehen</a>
+    </div>
+
+    <p style="color: #64748b; font-size: 12px; margin: 0;">Diese Benachrichtigung kann in den Einstellungen im Dashboard deaktiviert werden.</p>
+  </div>
+</body>
+</html>"""
+    return subject, html
diff --git a/src/feeds/rss_parser.py b/src/feeds/rss_parser.py
new file mode 100644
index 0000000..d40a3a2
--- /dev/null
+++ b/src/feeds/rss_parser.py
@@ -0,0 +1,157 @@
+"""RSS-Feed Parser: Durchsucht vorkonfigurierte Feeds nach relevanten Meldungen."""
+import asyncio
+import logging
+import feedparser
+import httpx
+from datetime import datetime, timezone
+from config import TIMEZONE
+
+logger = logging.getLogger("osint.rss")
+
+
+class RSSParser:
+    """Durchsucht RSS-Feeds nach relevanten Artikeln."""
+
+    # Stoppwörter die bei der RSS-Suche ignoriert werden
+    STOP_WORDS = {
+        "und", "oder", "der", "die", "das", "ein", "eine", "in", "im", "am", "an",
+        "auf", "für", "mit", "von", "zu", "zum", "zur", "bei", "nach", "vor",
+        "über", "unter", "ist", "sind", "hat", "the", "and", "for", "with", "from",
+    }
+
+    async def search_feeds(self, search_term: str, international: bool = True, tenant_id: int = None) -> list[dict]:
+        """Durchsucht RSS-Feeds nach einem Suchbegriff.
+
+        Args:
+            search_term: Suchbegriff
+            international: Wenn False, nur deutsche Feeds + Behoerden (keine internationalen)
+            tenant_id: Optionale Org-ID fuer tenant-spezifische Quellen
+        """
+        all_articles = []
+        search_words = [
+            w for w in search_term.lower().split()
+            if w not in self.STOP_WORDS and len(w) >= 3
+        ]
+        if not search_words:
+            search_words = search_term.lower().split()[:2]
+
+        rss_feeds = await self._get_rss_feeds(tenant_id=tenant_id)
+
+        # Feed-Kategorien filtern
+        if international:
+            categories = rss_feeds.keys()
+        else:
+            categories = [c for c in rss_feeds.keys() if c != "international"]
+
+        tasks = []
+        for category in categories:
+            for feed_config in rss_feeds.get(category, []):
+                tasks.append(self._fetch_feed(feed_config, search_words))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for result in results:
+            if isinstance(result, Exception):
+                logger.warning(f"Feed-Fehler: {result}")
+                continue
+            all_articles.extend(result)
+
+        cat_info = "alle" if international else "nur deutsch + behörden"
+        logger.info(f"RSS-Suche nach '{search_term}' ({cat_info}): {len(all_articles)} Treffer")
+        return all_articles
+
+    async def search_feeds_selective(self, search_term: str, selected_feeds: list[dict]) -> list[dict]:
+        """Durchsucht nur die übergebenen Feeds (vorselektiert durch Claude).
+
+        Args:
+            search_term: Suchbegriff
+            selected_feeds: Liste von Feed-Dicts mit mindestens {"name", "url"}
+        """
+        all_articles = []
+        search_words = [
+            w for w in search_term.lower().split()
+            if w not in self.STOP_WORDS and len(w) >= 3
+        ]
+        if not search_words:
+            search_words = search_term.lower().split()[:2]
+
+        tasks = []
+        for feed_config in selected_feeds:
+            tasks.append(self._fetch_feed(feed_config, search_words))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for result in results:
+            if isinstance(result, Exception):
+                logger.warning(f"Feed-Fehler: {result}")
+                continue
+            all_articles.extend(result)
+
+        logger.info(f"RSS-Selektiv nach '{search_term}': {len(all_articles)} Treffer aus {len(selected_feeds)} Feeds")
+        return all_articles
+
+    async def _get_rss_feeds(self, tenant_id: int = None) -> dict:
+        """Laedt RSS-Feeds aus der Datenbank (global + org-spezifisch)."""
+        try:
+            from source_rules import get_source_rules
+            rules = await get_source_rules(tenant_id=tenant_id)
+            return rules.get("rss_feeds", {})
+        except Exception as e:
+            logger.warning(f"Fallback auf config.py fuer RSS-Feeds: {e}")
+            from config import RSS_FEEDS
+            return dict(RSS_FEEDS)
+
+    async def _fetch_feed(self, feed_config: dict, search_words: list[str]) -> list[dict]:
+        """Einzelnen RSS-Feed abrufen und durchsuchen."""
+        name = feed_config["name"]
+        url = feed_config["url"]
+        articles = []
+
+        try:
+            async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+                response = await client.get(url, headers={
+                    "User-Agent": "OSINT-Monitor/1.0 (News Aggregator)"
+                })
+                response.raise_for_status()
+
+            feed = await asyncio.to_thread(feedparser.parse, response.text)
+
+            for entry in feed.entries[:50]:
+                title = entry.get("title", "")
+                summary = entry.get("summary", "")
+                text = f"{title} {summary}".lower()
+
+                # Prüfe ob mindestens ein Suchwort vorkommt
+                if all(word in text for word in search_words):
+                    published = None
+                    if hasattr(entry, "published_parsed") and entry.published_parsed:
+                        try:
+                            published = datetime(*entry.published_parsed[:6], tzinfo=timezone.utc).astimezone(TIMEZONE).isoformat()
+                        except (TypeError, ValueError):
+                            pass
+
+                    articles.append({
+                        "headline": title,
+                        "headline_de": title if self._is_german(title) else None,
+                        "source": name,
+                        "source_url": entry.get("link", ""),
+                        "content_original": summary[:1000] if summary else None,
+                        "content_de": summary[:1000] if summary and self._is_german(summary) else None,
+                        "language": "de" if self._is_german(title) else "en",
+                        "published_at": published,
+                    })
+
+        except Exception as e:
+            logger.debug(f"Feed {name} ({url}): {e}")
+
+        return articles
+
+    def _is_german(self, text: str) -> bool:
+        """Einfache Heuristik ob ein Text deutsch ist."""
+        german_words = {"der", "die", "das", "und", "ist", "von", "mit", "für", "auf", "ein",
+                        "eine", "den", "dem", "des", "sich", "wird", "nach", "bei", "auch",
+                        "über", "wie", "aus", "hat", "zum", "zur", "als", "noch", "mehr",
+                        "nicht", "aber", "oder", "sind", "vor", "einem", "einer", "wurde"}
+        words = set(text.lower().split())
+        matches = words & german_words
+        return len(matches) >= 2
diff --git a/src/main.py b/src/main.py
new file mode 100644
index 0000000..d2aec19
--- /dev/null
+++ b/src/main.py
@@ -0,0 +1,331 @@
+"""OSINT Lagemonitor - Hauptanwendung."""
+import asyncio
+import json
+import logging
+import os
+import sys
+from contextlib import asynccontextmanager
+from datetime import datetime
+from typing import Dict
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, RedirectResponse
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from config import STATIC_DIR, LOG_DIR, DATA_DIR, TIMEZONE
+from database import init_db, get_db
+from auth import decode_token
+from agents.orchestrator import orchestrator
+
+# Logging
+os.makedirs(LOG_DIR, exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler(os.path.join(LOG_DIR, "osint-monitor.log")),
+    ],
+)
+logger = logging.getLogger("osint")
+
+
+class WebSocketManager:
+    """Verwaltet WebSocket-Verbindungen für Echtzeit-Updates."""
+
+    def __init__(self):
+        self._connections: Dict[WebSocket, int] = {}  # ws -> user_id
+
+    async def connect(self, websocket: WebSocket, user_id: int):
+        self._connections[websocket] = user_id
+        logger.info(f"WebSocket verbunden (User {user_id}, {len(self._connections)} aktiv)")
+
+    def disconnect(self, websocket: WebSocket):
+        self._connections.pop(websocket, None)
+        logger.info(f"WebSocket getrennt ({len(self._connections)} aktiv)")
+
+    async def broadcast(self, message: dict):
+        """Nachricht an alle verbundenen Clients senden."""
+        if not self._connections:
+            return
+        data = json.dumps(message, ensure_ascii=False)
+        disconnected = []
+        for ws in self._connections:
+            try:
+                await ws.send_text(data)
+            except Exception:
+                disconnected.append(ws)
+        for ws in disconnected:
+            self._connections.pop(ws, None)
+
+    async def broadcast_for_incident(self, message: dict, visibility: str, created_by: int):
+        """Nachricht nur an berechtigte Clients senden (private Lagen → nur Ersteller)."""
+        if not self._connections:
+            return
+        data = json.dumps(message, ensure_ascii=False)
+        disconnected = []
+        for ws, user_id in self._connections.items():
+            if visibility == "private" and user_id != created_by:
+                continue
+            try:
+                await ws.send_text(data)
+            except Exception:
+                disconnected.append(ws)
+        for ws in disconnected:
+            self._connections.pop(ws, None)
+
+
+ws_manager = WebSocketManager()
+
+# Scheduler für Auto-Refresh
+scheduler = AsyncIOScheduler()
+
+
+async def check_auto_refresh():
+    """Prüft welche Lagen einen Auto-Refresh brauchen."""
+    db = await get_db()
+    try:
+        cursor = await db.execute(
+            "SELECT id, refresh_interval FROM incidents WHERE status = 'active' AND refresh_mode = 'auto'"
+        )
+        incidents = await cursor.fetchall()
+
+        now = datetime.now(TIMEZONE)
+
+        for incident in incidents:
+            incident_id = incident["id"]
+            interval = incident["refresh_interval"]
+
+            # Nur letzten AUTO-Refresh prüfen (manuelle Refreshs ignorieren)
+            cursor = await db.execute(
+                "SELECT started_at FROM refresh_log WHERE incident_id = ? AND trigger_type = 'auto' ORDER BY started_at DESC LIMIT 1",
+                (incident_id,),
+            )
+            last_refresh = await cursor.fetchone()
+
+            should_refresh = False
+            if not last_refresh:
+                should_refresh = True
+            else:
+                last_time = datetime.fromisoformat(last_refresh["started_at"])
+                if last_time.tzinfo is None:
+                    last_time = last_time.replace(tzinfo=TIMEZONE)
+                elapsed = (now - last_time).total_seconds() / 60
+                if elapsed >= interval:
+                    should_refresh = True
+
+            if should_refresh:
+                # Prüfen ob bereits ein laufender Refresh existiert
+                cursor = await db.execute(
+                    "SELECT id FROM refresh_log WHERE incident_id = ? AND status = 'running' LIMIT 1",
+                    (incident_id,),
+                )
+                if await cursor.fetchone():
+                    continue  # Laufender Refresh — überspringen
+
+                await orchestrator.enqueue_refresh(incident_id, trigger_type="auto")
+
+    except Exception as e:
+        logger.error(f"Auto-Refresh Check Fehler: {e}")
+    finally:
+        await db.close()
+
+
+async def cleanup_expired():
+    """Bereinigt abgelaufene Lagen basierend auf retention_days."""
+    db = await get_db()
+    try:
+        cursor = await db.execute(
+            "SELECT id, retention_days, created_at FROM incidents WHERE retention_days > 0 AND status = 'active'"
+        )
+        incidents = await cursor.fetchall()
+
+        now = datetime.now(TIMEZONE)
+        for incident in incidents:
+            created = datetime.fromisoformat(incident["created_at"])
+            if created.tzinfo is None:
+                created = created.replace(tzinfo=TIMEZONE)
+            age_days = (now - created).days
+            if age_days >= incident["retention_days"]:
+                await db.execute(
+                    "UPDATE incidents SET status = 'archived' WHERE id = ?",
+                    (incident["id"],),
+                )
+                logger.info(f"Lage {incident['id']} archiviert (Aufbewahrung abgelaufen)")
+
+        # Verwaiste running-Einträge bereinigen (> 15 Minuten ohne Abschluss)
+        cursor = await db.execute(
+            "SELECT id, incident_id, started_at FROM refresh_log WHERE status = 'running'"
+        )
+        orphans = await cursor.fetchall()
+        for orphan in orphans:
+            started = datetime.fromisoformat(orphan["started_at"])
+            if started.tzinfo is None:
+                started = started.replace(tzinfo=TIMEZONE)
+            age_minutes = (now - started).total_seconds() / 60
+            if age_minutes >= 15:
+                await db.execute(
+                    "UPDATE refresh_log SET status = 'error', completed_at = ?, error_message = ? WHERE id = ?",
+                    (now.isoformat(), f"Verwaist (>{int(age_minutes)} Min ohne Abschluss, automatisch bereinigt)", orphan["id"]),
+                )
+                logger.warning(f"Verwaisten Refresh #{orphan['id']} für Lage {orphan['incident_id']} bereinigt ({int(age_minutes)} Min)")
+
+        # Alte Notifications bereinigen (> 7 Tage)
+        await db.execute("DELETE FROM notifications WHERE created_at < datetime('now', '-7 days')")
+
+        await db.commit()
+    except Exception as e:
+        logger.error(f"Cleanup Fehler: {e}")
+    finally:
+        await db.close()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """App Startup/Shutdown."""
+    # Startup
+    os.makedirs(DATA_DIR, exist_ok=True)
+    await init_db()
+
+    # Verwaiste running-Einträge beim Start bereinigen
+    db = await get_db()
+    try:
+        result = await db.execute(
+            "UPDATE refresh_log SET status = 'error', completed_at = ?, error_message = 'Verwaist (Neustart, automatisch bereinigt)' WHERE status = 'running'",
+            (datetime.now(TIMEZONE).isoformat(),),
+        )
+        if result.rowcount > 0:
+            await db.commit()
+            logger.warning(f"{result.rowcount} verwaiste running-Einträge beim Start bereinigt")
+    finally:
+        await db.close()
+
+    orchestrator.set_ws_manager(ws_manager)
+    await orchestrator.start()
+
+    scheduler.add_job(check_auto_refresh, "interval", minutes=1, id="auto_refresh")
+    scheduler.add_job(cleanup_expired, "interval", hours=1, id="cleanup")
+    scheduler.start()
+
+    logger.info("OSINT Lagemonitor gestartet")
+    yield
+
+    # Shutdown
+    scheduler.shutdown()
+    await orchestrator.stop()
+    logger.info("OSINT Lagemonitor gestoppt")
+
+
+app = FastAPI(
+    title="OSINT Lagemonitor",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+
+# Security-Headers Middleware
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response = await call_next(request)
+        response.headers["Content-Security-Policy"] = (
+            "default-src 'self'; "
+            "script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; "
+            "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net; "
+            "font-src 'self' https://fonts.gstatic.com; "
+            "img-src 'self' data:; "
+            "connect-src 'self' wss: ws:; "
+            "frame-ancestors 'none'"
+        )
+        response.headers["Permissions-Policy"] = (
+            "camera=(), microphone=(), geolocation=(), payment=()"
+        )
+        return response
+
+
+app.add_middleware(SecurityHeadersMiddleware)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://osint.intelsight.de"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+# Router einbinden
+from routers.auth import router as auth_router
+from routers.incidents import router as incidents_router
+from routers.sources import router as sources_router
+from routers.notifications import router as notifications_router
+from routers.feedback import router as feedback_router
+
+app.include_router(auth_router)
+app.include_router(incidents_router)
+app.include_router(sources_router)
+app.include_router(notifications_router)
+app.include_router(feedback_router)
+
+
+@app.websocket("/api/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket-Endpunkt für Echtzeit-Updates."""
+    await websocket.accept()
+
+    # Token als erste Nachricht empfangen (nicht in URL)
+    try:
+        token = await asyncio.wait_for(websocket.receive_text(), timeout=5.0)
+    except asyncio.TimeoutError:
+        try:
+            await websocket.close(code=4001, reason="Token fehlt")
+        except Exception:
+            pass
+        return
+    except WebSocketDisconnect:
+        return
+
+    try:
+        payload = decode_token(token)
+        user_id = int(payload["sub"])
+    except Exception:
+        try:
+            await websocket.close(code=4001, reason="Token ungültig")
+        except Exception:
+            pass
+        return
+
+    # Authentifizierung erfolgreich
+    await ws_manager.connect(websocket, user_id)
+    await websocket.send_text("authenticated")
+
+    try:
+        while True:
+            data = await websocket.receive_text()
+            if data == "ping":
+                await websocket.send_text("pong")
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket)
+
+
+# Statische Dateien und Frontend-Routing
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+@app.get("/")
+async def root():
+    """Login-Seite ausliefern."""
+    return FileResponse(os.path.join(STATIC_DIR, "index.html"))
+
+
+@app.get("/dashboard")
+async def dashboard():
+    """Dashboard ausliefern."""
+    return FileResponse(os.path.join(STATIC_DIR, "dashboard.html"))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8891)
diff --git a/src/middleware/__init__.py b/src/middleware/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/middleware/license_check.py b/src/middleware/license_check.py
new file mode 100644
index 0000000..f5ad914
--- /dev/null
+++ b/src/middleware/license_check.py
@@ -0,0 +1,51 @@
+"""FastAPI Dependency: Lizenzpruefung vor mutiernden Endpoints."""
+from fastapi import Depends, HTTPException, status
+from auth import get_current_user
+from database import db_dependency
+from services.license_service import check_license
+import aiosqlite
+
+
+async def require_active_license(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+) -> dict:
+    """Dependency die sicherstellt, dass die Lizenz der Org aktiv ist.
+
+    Blockiert mutierende Operationen bei abgelaufener/widerrufener Lizenz.
+    Gibt den current_user zurueck (angereichert mit Lizenz-Info).
+    """
+    tenant_id = current_user.get("tenant_id")
+    if not tenant_id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Keine Organisation zugeordnet",
+        )
+
+    lic = await check_license(db, tenant_id)
+
+    if not lic["valid"]:
+        if lic["status"] == "org_disabled":
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Organisation deaktiviert. Bitte kontaktieren Sie den Support.",
+            )
+
+    current_user["license"] = lic
+    return current_user
+
+
+async def require_writable_license(
+    current_user: dict = Depends(require_active_license),
+) -> dict:
+    """Dependency die sicherstellt, dass die Lizenz Schreibzugriff erlaubt.
+
+    Blockiert neue Lagen/Refreshes bei abgelaufener Lizenz (Nur-Lesen-Modus).
+    """
+    lic = current_user.get("license", {})
+    if lic.get("read_only"):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Lizenz abgelaufen oder widerrufen. Nur Lesezugriff moeglich.",
+        )
+    return current_user
diff --git a/src/migration/__init__.py b/src/migration/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/migration/migrate_to_multitenancy.py b/src/migration/migrate_to_multitenancy.py
new file mode 100644
index 0000000..81aff2e
--- /dev/null
+++ b/src/migration/migrate_to_multitenancy.py
@@ -0,0 +1,177 @@
+"""Einmalige Datenmigration zu Multi-Tenancy.
+
+Dieses Script:
+1. Erstellt die AegisSight-Organisation
+2. Erstellt eine permanente Lizenz fuer AegisSight
+3. Weist bestehende Nutzer (rac00n, ch33tah) der AegisSight-Org zu
+4. Setzt tenant_id auf alle bestehenden Daten
+5. Erstellt Portal-Admin-Zugaenge
+"""
+import asyncio
+import os
+import sys
+import shutil
+from datetime import datetime
+
+# Pfade fuer Imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from config import DB_PATH, TIMEZONE
+from database import init_db, get_db
+from auth import hash_password
+
+
+# E-Mail-Adressen fuer bestehende Nutzer
+USER_EMAILS = {
+    "rac00n": os.environ.get("RACOON_EMAIL", "momohomma@googlemail.com"),
+    "ch33tah": os.environ.get("CHEETAH_EMAIL", "hendrik_gebhardt@gmx.de"),
+}
+
+
+async def migrate():
+    """Fuehrt die Multi-Tenancy-Migration durch."""
+
+    # 1. Backup erstellen
+    if os.path.exists(DB_PATH):
+        backup_path = DB_PATH + f".backup-{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        shutil.copy2(DB_PATH, backup_path)
+        print(f"Backup erstellt: {backup_path}")
+    else:
+        print("Keine bestehende Datenbank gefunden. Frische Installation.")
+
+    # 2. Schema-Migration (init_db erstellt neue Tabellen und fuegt Spalten hinzu)
+    await init_db()
+    print("Schema-Migration abgeschlossen.")
+
+    db = await get_db()
+    try:
+        # 3. Pruefen ob Migration bereits gelaufen ist
+        cursor = await db.execute("SELECT COUNT(*) as cnt FROM organizations")
+        org_count = (await cursor.fetchone())["cnt"]
+        if org_count > 0:
+            print("Migration wurde bereits durchgefuehrt. Abbruch.")
+            return
+
+        # 4. AegisSight-Organisation anlegen
+        now = datetime.now(TIMEZONE).isoformat()
+        cursor = await db.execute(
+            """INSERT INTO organizations (name, slug, is_active, created_at, updated_at)
+               VALUES (?, ?, 1, ?, ?)""",
+            ("AegisSight", "aegissight", now, now),
+        )
+        aegis_org_id = cursor.lastrowid
+        print(f"Organisation AegisSight angelegt (ID: {aegis_org_id})")
+
+        # 5. Permanente Lizenz fuer AegisSight
+        await db.execute(
+            """INSERT INTO licenses (organization_id, license_type, max_users, valid_from, valid_until, status, notes)
+               VALUES (?, 'permanent', 50, ?, NULL, 'active', 'Interne AegisSight-Lizenz')""",
+            (aegis_org_id, now),
+        )
+        print("Permanente Lizenz fuer AegisSight erstellt")
+
+        # 6. Bestehende Nutzer der AegisSight-Org zuweisen
+        cursor = await db.execute("SELECT id, username FROM users")
+        users = await cursor.fetchall()
+
+        for user in users:
+            username = user["username"]
+            email = USER_EMAILS.get(username, f"{username}@aegis-sight.de")
+
+            await db.execute(
+                """UPDATE users SET
+                   organization_id = ?,
+                   role = 'org_admin',
+                   is_active = 1,
+                   email = ?
+                   WHERE id = ?""",
+                (aegis_org_id, email, user["id"]),
+            )
+            print(f"Nutzer '{username}' -> AegisSight (org_admin, email: {email})")
+
+        # 7. tenant_id auf alle bestehenden Incidents setzen
+        await db.execute(
+            "UPDATE incidents SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+        cursor = await db.execute("SELECT changes()")
+        changes = (await cursor.fetchone())[0]
+        print(f"{changes} Incidents mit tenant_id versehen")
+
+        # 8. tenant_id auf alle bestehenden Articles setzen
+        await db.execute(
+            "UPDATE articles SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+        cursor = await db.execute("SELECT changes()")
+        changes = (await cursor.fetchone())[0]
+        print(f"{changes} Articles mit tenant_id versehen")
+
+        # 9. tenant_id auf alle bestehenden fact_checks setzen
+        await db.execute(
+            "UPDATE fact_checks SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+
+        # 10. tenant_id auf alle bestehenden refresh_log setzen
+        await db.execute(
+            "UPDATE refresh_log SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+
+        # 11. tenant_id auf alle bestehenden incident_snapshots setzen
+        await db.execute(
+            "UPDATE incident_snapshots SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+
+        # 12. tenant_id auf alle bestehenden notifications setzen
+        await db.execute(
+            "UPDATE notifications SET tenant_id = ? WHERE tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+
+        # 13. System-Quellen bleiben global (tenant_id=NULL)
+        # Nur nutzer-erstellte Quellen bekommen tenant_id
+        await db.execute(
+            "UPDATE sources SET tenant_id = ? WHERE added_by != 'system' AND tenant_id IS NULL",
+            (aegis_org_id,),
+        )
+        print("Nutzer-Quellen mit tenant_id versehen (System-Quellen bleiben global)")
+
+        # 14. Portal-Admin-Zugaenge anlegen
+        print("\n--- Portal-Admin-Zugaenge ---")
+        portal_users = ["rac00n", "ch33tah"]
+        for pu in portal_users:
+            # Pruefen ob schon existiert
+            cursor = await db.execute(
+                "SELECT id FROM portal_admins WHERE username = ?", (pu,)
+            )
+            if await cursor.fetchone():
+                print(f"Portal-Admin '{pu}' existiert bereits")
+                continue
+
+            # Passwort generieren
+            import secrets
+            import string
+            password = ''.join(secrets.choice(string.ascii_letters + string.digits + "!@#$%&*") for _ in range(16))
+            pw_hash = hash_password(password)
+
+            await db.execute(
+                "INSERT INTO portal_admins (username, password_hash) VALUES (?, ?)",
+                (pu, pw_hash),
+            )
+            print(f"Portal-Admin '{pu}' erstellt - Passwort: {password}")
+
+        await db.commit()
+        print("\nMigration erfolgreich abgeschlossen!")
+
+    except Exception as e:
+        print(f"\nFEHLER bei Migration: {e}")
+        raise
+    finally:
+        await db.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(migrate())
diff --git a/src/models.py b/src/models.py
new file mode 100644
index 0000000..fed049e
--- /dev/null
+++ b/src/models.py
@@ -0,0 +1,245 @@
+"""Pydantic Models für Request/Response Schemas."""
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+
+# Auth (Legacy)
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+# Auth (Magic Link)
+class MagicLinkRequest(BaseModel):
+    email: str = Field(min_length=1, max_length=254)
+
+
+class MagicLinkResponse(BaseModel):
+    message: str
+
+
+class VerifyTokenRequest(BaseModel):
+    token: str
+
+
+class VerifyCodeRequest(BaseModel):
+    email: str = Field(min_length=1, max_length=254)
+    code: str = Field(min_length=6, max_length=6)
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    username: str
+
+
+class UserResponse(BaseModel):
+    id: int
+    username: str
+
+
+class UserMeResponse(BaseModel):
+    id: int
+    username: str
+    email: str = ""
+    role: str = "member"
+    org_name: str = ""
+    org_slug: str = ""
+    tenant_id: Optional[int] = None
+    license_status: str = "unknown"
+    license_type: str = ""
+    read_only: bool = False
+
+
+# Incidents (Lagen)
+class IncidentCreate(BaseModel):
+    title: str = Field(min_length=1, max_length=200)
+    description: Optional[str] = None
+    type: str = Field(default="adhoc", pattern="^(adhoc|research)$")
+    refresh_mode: str = Field(default="manual", pattern="^(manual|auto)$")
+    refresh_interval: int = Field(default=15, ge=10, le=10080)
+    retention_days: int = Field(default=0, ge=0, le=999)
+    international_sources: bool = True
+    visibility: str = Field(default="public", pattern="^(public|private)$")
+
+
+class IncidentUpdate(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    type: Optional[str] = Field(default=None, pattern="^(adhoc|research)$")
+    status: Optional[str] = Field(default=None, pattern="^(active|archived)$")
+    refresh_mode: Optional[str] = Field(default=None, pattern="^(manual|auto)$")
+    refresh_interval: Optional[int] = Field(default=None, ge=10, le=10080)
+    retention_days: Optional[int] = Field(default=None, ge=0, le=999)
+    international_sources: Optional[bool] = None
+    visibility: Optional[str] = Field(default=None, pattern="^(public|private)$")
+
+
+class IncidentResponse(BaseModel):
+    id: int
+    title: str
+    description: Optional[str]
+    type: str
+    status: str
+    refresh_mode: str
+    refresh_interval: int
+    retention_days: int
+    visibility: str = "public"
+    summary: Optional[str]
+    sources_json: Optional[str] = None
+    international_sources: bool = True
+    created_by: int
+    created_by_username: str = ""
+    created_at: str
+    updated_at: str
+    article_count: int = 0
+    source_count: int = 0
+
+
+# Articles
+class ArticleResponse(BaseModel):
+    id: int
+    incident_id: int
+    headline: str
+    headline_de: Optional[str]
+    source: str
+    source_url: Optional[str]
+    content_original: Optional[str]
+    content_de: Optional[str]
+    language: str
+    published_at: Optional[str]
+    collected_at: str
+    verification_status: str
+
+
+# Fact Checks
+class FactCheckResponse(BaseModel):
+    id: int
+    incident_id: int
+    claim: str
+    status: str
+    sources_count: int
+    evidence: Optional[str]
+    is_notification: bool
+    checked_at: str
+
+
+# Sources (Quellenverwaltung)
+class SourceCreate(BaseModel):
+    name: str = Field(min_length=1, max_length=200)
+    url: Optional[str] = None
+    domain: Optional[str] = None
+    source_type: str = Field(default="rss_feed", pattern="^(rss_feed|web_source|excluded)$")
+    category: str = Field(default="sonstige", pattern="^(nachrichtenagentur|oeffentlich-rechtlich|qualitaetszeitung|behoerde|fachmedien|think-tank|international|regional|sonstige)$")
+    status: str = Field(default="active", pattern="^(active|inactive)$")
+    notes: Optional[str] = None
+
+
+class SourceUpdate(BaseModel):
+    name: Optional[str] = Field(default=None, max_length=200)
+    url: Optional[str] = None
+    domain: Optional[str] = None
+    source_type: Optional[str] = Field(default=None, pattern="^(rss_feed|web_source|excluded)$")
+    category: Optional[str] = Field(default=None, pattern="^(nachrichtenagentur|oeffentlich-rechtlich|qualitaetszeitung|behoerde|fachmedien|think-tank|international|regional|sonstige)$")
+    status: Optional[str] = Field(default=None, pattern="^(active|inactive)$")
+    notes: Optional[str] = None
+
+
+class SourceResponse(BaseModel):
+    id: int
+    name: str
+    url: Optional[str]
+    domain: Optional[str]
+    source_type: str
+    category: str
+    status: str
+    notes: Optional[str]
+    added_by: Optional[str]
+    article_count: int = 0
+    last_seen_at: Optional[str] = None
+    created_at: str
+
+
+# Source Discovery
+class DiscoverRequest(BaseModel):
+    url: str = Field(min_length=1, max_length=500)
+
+
+class DiscoverResponse(BaseModel):
+    name: str
+    domain: str
+    rss_url: Optional[str] = None
+    category: str
+    source_type: str
+
+
+# Multi-Discovery
+class DiscoverMultiResponse(BaseModel):
+    domain: str
+    category: str
+    added_count: int
+    skipped_count: int
+    total_found: int
+    sources: list[SourceResponse]
+    fallback_single: bool = False
+
+
+# Domain-Aktionen (Sperren/Entsperren)
+class DomainActionRequest(BaseModel):
+    domain: str = Field(min_length=1, max_length=200)
+    notes: Optional[str] = None
+
+
+# Refresh-Log
+class RefreshLogResponse(BaseModel):
+    id: int
+    started_at: str
+    completed_at: Optional[str] = None
+    articles_found: int = 0
+    status: str
+    trigger_type: str = "manual"
+    retry_count: int = 0
+    error_message: Optional[str] = None
+    duration_seconds: Optional[float] = None
+
+
+# Notifications
+class NotificationResponse(BaseModel):
+    id: int
+    incident_id: Optional[int]
+    type: str
+    title: str
+    text: str
+    icon: str
+    is_read: bool
+    created_at: str
+
+
+class NotificationMarkReadRequest(BaseModel):
+    notification_ids: Optional[list[int]] = None  # None = alle
+
+
+
+class SubscriptionUpdate(BaseModel):
+    notify_email_summary: bool = False
+    notify_email_new_articles: bool = False
+    notify_email_status_change: bool = False
+
+
+class SubscriptionResponse(BaseModel):
+    notify_email_summary: bool = False
+    notify_email_new_articles: bool = False
+    notify_email_status_change: bool = False
+
+
+
+class FeedbackRequest(BaseModel):
+    category: str = Field(pattern="^(bug|feature|question|other)$")
+    message: str = Field(min_length=10, max_length=5000)
+
+
+class WSMessage(BaseModel):
+    type: str  # new_article, status_update, notification, refresh_complete
+    incident_id: int
+    data: dict
diff --git a/src/routers/auth.py b/src/routers/auth.py
new file mode 100644
index 0000000..76297e0
--- /dev/null
+++ b/src/routers/auth.py
@@ -0,0 +1,276 @@
+"""Auth-Router: Magic-Link-Login und Nutzerverwaltung."""
+import logging
+from datetime import datetime, timedelta, timezone
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from models import (
+    MagicLinkRequest,
+    MagicLinkResponse,
+    VerifyTokenRequest,
+    VerifyCodeRequest,
+    TokenResponse,
+    UserMeResponse,
+)
+from auth import (
+    create_token,
+    get_current_user,
+    generate_magic_token,
+    generate_magic_code,
+    verify_password,
+)
+from database import db_dependency
+from config import TIMEZONE, MAGIC_LINK_EXPIRE_MINUTES, MAGIC_LINK_BASE_URL
+from email_utils.sender import send_email
+from email_utils.templates import magic_link_login_email
+from email_utils.rate_limiter import magic_link_limiter, verify_code_limiter
+import aiosqlite
+
+logger = logging.getLogger("osint.auth")
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+@router.post("/magic-link", response_model=MagicLinkResponse)
+async def request_magic_link(
+    data: MagicLinkRequest,
+    request: Request,
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Magic Link anfordern. Sendet E-Mail mit Link + Code."""
+    email = data.email.lower().strip()
+    ip = request.client.host if request.client else "unknown"
+
+    # Rate-Limit pruefen
+    allowed, reason = magic_link_limiter.check(email, ip)
+    if not allowed:
+        logger.warning(f"Rate-Limit fuer {email} von {ip}: {reason}")
+        # Trotzdem 200 zurueckgeben (kein Information-Leak)
+        return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+    # Nutzer suchen
+    cursor = await db.execute(
+        """SELECT u.id, u.email, u.username, u.role, u.organization_id, u.is_active,
+                  o.is_active as org_active, o.slug as org_slug
+           FROM users u
+           JOIN organizations o ON o.id = u.organization_id
+           WHERE LOWER(u.email) = ?""",
+        (email,),
+    )
+    user = await cursor.fetchone()
+
+    if not user:
+        magic_link_limiter.record(email, ip)
+        return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+    if not user["is_active"]:
+        magic_link_limiter.record(email, ip)
+        return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+    if not user["org_active"]:
+        magic_link_limiter.record(email, ip)
+        return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+    # Lizenz pruefen
+    from services.license_service import check_license
+    lic = await check_license(db, user["organization_id"])
+    if lic.get("status") == "org_disabled":
+        magic_link_limiter.record(email, ip)
+        return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+    # Token + Code generieren
+    token = generate_magic_token()
+    code = generate_magic_code()
+    expires_at = (datetime.now(timezone.utc) + timedelta(minutes=MAGIC_LINK_EXPIRE_MINUTES)).strftime('%Y-%m-%d %H:%M:%S')
+
+    # Alte ungenutzte Magic Links fuer diese E-Mail invalidieren
+    await db.execute(
+        "UPDATE magic_links SET is_used = 1 WHERE email = ? AND is_used = 0",
+        (email,),
+    )
+
+    # Neuen Magic Link speichern
+    await db.execute(
+        """INSERT INTO magic_links (email, token, code, purpose, user_id, expires_at, ip_address)
+           VALUES (?, ?, ?, 'login', ?, ?, ?)""",
+        (email, token, code, user["id"], expires_at, ip),
+    )
+    await db.commit()
+
+    # E-Mail senden
+    link = f"{MAGIC_LINK_BASE_URL}/auth/verify?token={token}"
+    subject, html = magic_link_login_email(user["username"], code, link)
+    await send_email(email, subject, html)
+
+    magic_link_limiter.record(email, ip)
+    return MagicLinkResponse(message="Wenn ein Konto existiert, wurde eine E-Mail gesendet.")
+
+
+@router.post("/verify", response_model=TokenResponse)
+async def verify_magic_link(
+    data: VerifyTokenRequest,
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Magic Link verifizieren (Token aus URL)."""
+    cursor = await db.execute(
+        """SELECT ml.*, u.username, u.email, u.role, u.organization_id, u.is_active,
+                  o.slug as org_slug, o.is_active as org_active
+           FROM magic_links ml
+           JOIN users u ON u.id = ml.user_id
+           JOIN organizations o ON o.id = u.organization_id
+           WHERE ml.token = ? AND ml.is_used = 0""",
+        (data.token,),
+    )
+    ml = await cursor.fetchone()
+
+    if not ml:
+        raise HTTPException(status_code=400, detail="Ungueltiger oder bereits verwendeter Link")
+
+    # Ablauf pruefen
+    now = datetime.now(timezone.utc)
+    expires = datetime.fromisoformat(ml["expires_at"])
+    if expires.tzinfo is None:
+        expires = expires.replace(tzinfo=timezone.utc)
+    if now > expires:
+        raise HTTPException(status_code=400, detail="Link abgelaufen. Bitte neuen Link anfordern.")
+
+    if not ml["is_active"] or not ml["org_active"]:
+        raise HTTPException(status_code=403, detail="Konto oder Organisation deaktiviert")
+
+    # Magic Link als verwendet markieren
+    await db.execute("UPDATE magic_links SET is_used = 1 WHERE id = ?", (ml["id"],))
+
+    # Letzten Login aktualisieren
+    await db.execute(
+        "UPDATE users SET last_login_at = ? WHERE id = ?",
+        (now.isoformat(), ml["user_id"]),
+    )
+    await db.commit()
+
+    # JWT erstellen
+    token = create_token(
+        user_id=ml["user_id"],
+        username=ml["username"],
+        email=ml["email"],
+        role=ml["role"],
+        tenant_id=ml["organization_id"],
+        org_slug=ml["org_slug"],
+    )
+
+    return TokenResponse(
+        access_token=token,
+        username=ml["username"],
+    )
+
+
+@router.post("/verify-code", response_model=TokenResponse)
+async def verify_magic_code(
+    data: VerifyCodeRequest,
+    request: Request,
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Magic Code verifizieren (6-stelliger Code + E-Mail)."""
+    email = data.email.lower().strip()
+    ip = request.client.host if request.client else "unknown"
+
+    # Brute-Force-Schutz: Fehlversuche pruefen
+    allowed, reason = verify_code_limiter.check(email, ip)
+    if not allowed:
+        logger.warning(f"Verify-Code Rate-Limit fuer {email} von {ip}: {reason}")
+        # Bei Sperre alle offenen Magic Links fuer diese E-Mail invalidieren
+        await db.execute(
+            "UPDATE magic_links SET is_used = 1 WHERE email = ? AND is_used = 0",
+            (email,),
+        )
+        await db.commit()
+        raise HTTPException(status_code=429, detail=reason)
+
+    cursor = await db.execute(
+        """SELECT ml.*, u.username, u.email as user_email, u.role, u.organization_id, u.is_active,
+                  o.slug as org_slug, o.is_active as org_active
+           FROM magic_links ml
+           JOIN users u ON u.id = ml.user_id
+           JOIN organizations o ON o.id = u.organization_id
+           WHERE LOWER(ml.email) = ? AND ml.code = ? AND ml.is_used = 0
+           ORDER BY ml.created_at DESC LIMIT 1""",
+        (email, data.code),
+    )
+    ml = await cursor.fetchone()
+
+    if not ml:
+        verify_code_limiter.record_failure(email, ip)
+        logger.warning(f"Fehlgeschlagener Code-Versuch fuer {email} von {ip}")
+        raise HTTPException(status_code=400, detail="Ungueltiger Code")
+
+    # Ablauf pruefen
+    now = datetime.now(timezone.utc)
+    expires = datetime.fromisoformat(ml["expires_at"])
+    if expires.tzinfo is None:
+        expires = expires.replace(tzinfo=timezone.utc)
+    if now > expires:
+        raise HTTPException(status_code=400, detail="Code abgelaufen. Bitte neuen Code anfordern.")
+
+    if not ml["is_active"] or not ml["org_active"]:
+        raise HTTPException(status_code=403, detail="Konto oder Organisation deaktiviert")
+
+    # Magic Link als verwendet markieren
+    await db.execute("UPDATE magic_links SET is_used = 1 WHERE id = ?", (ml["id"],))
+
+    # Letzten Login aktualisieren
+    await db.execute(
+        "UPDATE users SET last_login_at = ? WHERE id = ?",
+        (now.isoformat(), ml["user_id"]),
+    )
+    await db.commit()
+
+    # Fehlversuche-Zaehler nach Erfolg zuruecksetzen
+    verify_code_limiter.clear(email)
+
+    token = create_token(
+        user_id=ml["user_id"],
+        username=ml["username"],
+        email=ml["user_email"],
+        role=ml["role"],
+        tenant_id=ml["organization_id"],
+        org_slug=ml["org_slug"],
+    )
+
+    return TokenResponse(
+        access_token=token,
+        username=ml["username"],
+    )
+
+
+@router.get("/me", response_model=UserMeResponse)
+async def get_me(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Aktuellen Nutzer mit Org-Info abfragen."""
+    # Org-Name laden
+    org_name = ""
+    if current_user.get("tenant_id"):
+        cursor = await db.execute(
+            "SELECT name FROM organizations WHERE id = ?",
+            (current_user["tenant_id"],),
+        )
+        org = await cursor.fetchone()
+        if org:
+            org_name = org["name"]
+
+    # Lizenzstatus laden
+    license_info = {}
+    if current_user.get("tenant_id"):
+        from services.license_service import check_license
+        license_info = await check_license(db, current_user["tenant_id"])
+
+    return UserMeResponse(
+        id=current_user["id"],
+        username=current_user["username"],
+        email=current_user.get("email", ""),
+        role=current_user["role"],
+        org_name=org_name,
+        org_slug=current_user.get("org_slug", ""),
+        tenant_id=current_user.get("tenant_id"),
+        license_status=license_info.get("status", "unknown"),
+        license_type=license_info.get("license_type", ""),
+        read_only=license_info.get("read_only", False),
+    )
diff --git a/src/routers/feedback.py b/src/routers/feedback.py
new file mode 100644
index 0000000..6b0cbf8
--- /dev/null
+++ b/src/routers/feedback.py
@@ -0,0 +1,115 @@
+"""Feedback-Router: Nutzer-Feedback per E-Mail an das Team."""
+import html
+import time
+import logging
+from collections import defaultdict
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+import aiosmtplib
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from auth import get_current_user
+from models import FeedbackRequest
+from config import (
+    SMTP_HOST,
+    SMTP_PORT,
+    SMTP_USER,
+    SMTP_PASSWORD,
+    SMTP_FROM_EMAIL,
+    SMTP_FROM_NAME,
+    SMTP_USE_TLS,
+)
+
+logger = logging.getLogger("osint.feedback")
+router = APIRouter(prefix="/api", tags=["feedback"])
+
+FEEDBACK_EMAIL = "feedback@aegis-sight.de"
+CATEGORY_LABELS = {
+    "bug": "Fehlerbericht",
+    "feature": "Feature-Wunsch",
+    "question": "Frage",
+    "other": "Sonstiges",
+}
+
+# In-Memory Rate-Limiting: max 3 pro Nutzer/Stunde
+_user_timestamps: dict[int, list[float]] = defaultdict(list)
+_MAX_PER_HOUR = 3
+_WINDOW = 3600
+
+
+@router.post("/feedback", status_code=204)
+async def send_feedback(
+    data: FeedbackRequest,
+    current_user: dict = Depends(get_current_user),
+):
+    """Feedback per E-Mail an das Team senden."""
+    user_id = current_user["id"]
+
+    # Rate-Limiting
+    now = time.time()
+    cutoff = now - _WINDOW
+    _user_timestamps[user_id] = [t for t in _user_timestamps[user_id] if t > cutoff]
+    if len(_user_timestamps[user_id]) >= _MAX_PER_HOUR:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail="Maximal 3 Feedback-Nachrichten pro Stunde. Bitte spaeter erneut versuchen.",
+        )
+
+    if not SMTP_HOST:
+        logger.warning("SMTP nicht konfiguriert - Feedback nicht gesendet")
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="E-Mail-Versand nicht verfuegbar.",
+        )
+
+    username = current_user["username"]
+    email = current_user.get("email", "")
+    category_label = CATEGORY_LABELS.get(data.category, data.category)
+    message_escaped = html.escape(data.message)
+
+    subject = f"[AegisSight Feedback] {category_label} von {username}"
+    html_body = f"""\
+<div style="font-family:Arial,sans-serif;max-width:600px;margin:0 auto;">
+  <div style="background:#151D2E;color:#E8ECF4;padding:20px;border-radius:8px 8px 0 0;">
+    <h2 style="margin:0;color:#C8A851;">Neues Feedback</h2>
+  </div>
+  <div style="background:#1A2440;color:#E8ECF4;padding:20px;border-radius:0 0 8px 8px;">
+    <table style="border-collapse:collapse;">
+      <tr><td style="color:#8896AB;padding:4px 16px 4px 0;">Kategorie:</td><td><strong>{category_label}</strong></td></tr>
+      <tr><td style="color:#8896AB;padding:4px 16px 4px 0;">Nutzer:</td><td>{html.escape(username)}</td></tr>
+      <tr><td style="color:#8896AB;padding:4px 16px 4px 0;">E-Mail:</td><td>{html.escape(email) if email else "nicht hinterlegt"}</td></tr>
+    </table>
+    <hr style="border:none;border-top:1px solid #1E2D45;margin:16px 0;">
+    <div style="white-space:pre-wrap;line-height:1.5;">{message_escaped}</div>
+  </div>
+</div>"""
+
+    msg = MIMEMultipart("alternative")
+    msg["From"] = f"{SMTP_FROM_NAME} <{SMTP_FROM_EMAIL}>"
+    msg["To"] = FEEDBACK_EMAIL
+    msg["Subject"] = subject
+    if email:
+        msg["Reply-To"] = email
+
+    text_fallback = f"Feedback von {username} ({category_label}):\n\n{data.message}"
+    msg.attach(MIMEText(text_fallback, "plain", "utf-8"))
+    msg.attach(MIMEText(html_body, "html", "utf-8"))
+
+    try:
+        await aiosmtplib.send(
+            msg,
+            hostname=SMTP_HOST,
+            port=SMTP_PORT,
+            username=SMTP_USER if SMTP_USER else None,
+            password=SMTP_PASSWORD if SMTP_PASSWORD else None,
+            start_tls=SMTP_USE_TLS,
+        )
+        _user_timestamps[user_id].append(now)
+        logger.info(f"Feedback von {username} ({category_label}) gesendet")
+    except Exception as e:
+        logger.error(f"Feedback-E-Mail fehlgeschlagen: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="E-Mail konnte nicht gesendet werden.",
+        )
diff --git a/src/routers/incidents.py b/src/routers/incidents.py
new file mode 100644
index 0000000..6257ffe
--- /dev/null
+++ b/src/routers/incidents.py
@@ -0,0 +1,636 @@
+"""Incidents-Router: Lagen verwalten (Multi-Tenant)."""
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi.responses import StreamingResponse
+from models import IncidentCreate, IncidentUpdate, IncidentResponse, SubscriptionUpdate, SubscriptionResponse
+from auth import get_current_user
+from middleware.license_check import require_writable_license
+from database import db_dependency
+from datetime import datetime, timezone
+import aiosqlite
+import json
+import re
+import unicodedata
+
+router = APIRouter(prefix="/api/incidents", tags=["incidents"])
+
+INCIDENT_UPDATE_COLUMNS = {
+    "title", "description", "type", "status", "refresh_mode",
+    "refresh_interval", "retention_days", "international_sources", "visibility",
+}
+
+
+async def _check_incident_access(
+    db: aiosqlite.Connection, incident_id: int, user_id: int, tenant_id: int
+) -> aiosqlite.Row:
+    """Lage laden und Zugriff pruefen (Tenant + Sichtbarkeit)."""
+    cursor = await db.execute(
+        "SELECT * FROM incidents WHERE id = ? AND tenant_id = ?",
+        (incident_id, tenant_id),
+    )
+    row = await cursor.fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Lage nicht gefunden")
+    if row["visibility"] == "private" and row["created_by"] != user_id:
+        raise HTTPException(status_code=403, detail="Kein Zugriff auf private Lage")
+    return row
+
+
+async def _enrich_incident(db: aiosqlite.Connection, row: aiosqlite.Row) -> dict:
+    """Incident-Row mit Statistiken und Ersteller-Name anreichern."""
+    incident = dict(row)
+    cursor = await db.execute(
+        "SELECT COUNT(*) as cnt FROM articles WHERE incident_id = ?",
+        (incident["id"],),
+    )
+    article_count = (await cursor.fetchone())["cnt"]
+
+    cursor = await db.execute(
+        "SELECT COUNT(DISTINCT source) as cnt FROM articles WHERE incident_id = ?",
+        (incident["id"],),
+    )
+    source_count = (await cursor.fetchone())["cnt"]
+
+    cursor = await db.execute(
+        "SELECT username FROM users WHERE id = ?",
+        (incident["created_by"],),
+    )
+    user_row = await cursor.fetchone()
+
+    incident["article_count"] = article_count
+    incident["source_count"] = source_count
+    incident["created_by_username"] = user_row["username"] if user_row else "Unbekannt"
+    return incident
+
+
+@router.get("", response_model=list[IncidentResponse])
+async def list_incidents(
+    status_filter: str = None,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Alle Lagen des Tenants auflisten (oeffentliche + eigene private)."""
+    tenant_id = current_user.get("tenant_id")
+    user_id = current_user["id"]
+
+    query = "SELECT * FROM incidents WHERE tenant_id = ? AND (visibility = 'public' OR created_by = ?)"
+    params = [tenant_id, user_id]
+
+    if status_filter:
+        query += " AND status = ?"
+        params.append(status_filter)
+
+    query += " ORDER BY updated_at DESC"
+    cursor = await db.execute(query, params)
+    rows = await cursor.fetchall()
+
+    results = []
+    for row in rows:
+        results.append(await _enrich_incident(db, row))
+    return results
+
+
+@router.post("", response_model=IncidentResponse, status_code=status.HTTP_201_CREATED)
+async def create_incident(
+    data: IncidentCreate,
+    current_user: dict = Depends(require_writable_license),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Neue Lage anlegen."""
+    tenant_id = current_user.get("tenant_id")
+    now = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
+    cursor = await db.execute(
+        """INSERT INTO incidents (title, description, type, refresh_mode, refresh_interval,
+           retention_days, international_sources, visibility,
+           tenant_id, created_by, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            data.title,
+            data.description,
+            data.type,
+            data.refresh_mode,
+            data.refresh_interval,
+            data.retention_days,
+            1 if data.international_sources else 0,
+            data.visibility,
+            tenant_id,
+            current_user["id"],
+            now,
+            now,
+        ),
+    )
+    await db.commit()
+
+    cursor = await db.execute("SELECT * FROM incidents WHERE id = ?", (cursor.lastrowid,))
+    row = await cursor.fetchone()
+    return await _enrich_incident(db, row)
+
+
+@router.get("/refreshing")
+async def get_refreshing_incidents(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Gibt IDs aller Lagen mit laufendem Refresh zurueck (nur eigener Tenant)."""
+    tenant_id = current_user.get("tenant_id")
+    cursor = await db.execute(
+        """SELECT rl.incident_id, rl.started_at FROM refresh_log rl
+           JOIN incidents i ON i.id = rl.incident_id
+           WHERE rl.status = 'running'
+           AND i.tenant_id = ?
+           AND (i.visibility = 'public' OR i.created_by = ?)""",
+        (tenant_id, current_user["id"]),
+    )
+    rows = await cursor.fetchall()
+    return {
+        "refreshing": [row["incident_id"] for row in rows],
+        "details": {str(row["incident_id"]): {"started_at": row["started_at"]} for row in rows},
+    }
+
+
+@router.get("/{incident_id}", response_model=IncidentResponse)
+async def get_incident(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Einzelne Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    row = await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    return await _enrich_incident(db, row)
+
+
+@router.put("/{incident_id}", response_model=IncidentResponse)
+async def update_incident(
+    incident_id: int,
+    data: IncidentUpdate,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Lage aktualisieren."""
+    tenant_id = current_user.get("tenant_id")
+    row = await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+
+    updates = {}
+    for field, value in data.model_dump(exclude_none=True).items():
+        if field not in INCIDENT_UPDATE_COLUMNS:
+            continue
+        updates[field] = value
+
+    if not updates:
+        return await _enrich_incident(db, row)
+
+    updates["updated_at"] = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    values = list(updates.values()) + [incident_id]
+
+    await db.execute(f"UPDATE incidents SET {set_clause} WHERE id = ?", values)
+    await db.commit()
+
+    cursor = await db.execute("SELECT * FROM incidents WHERE id = ?", (incident_id,))
+    row = await cursor.fetchone()
+    return await _enrich_incident(db, row)
+
+
+@router.delete("/{incident_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_incident(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Lage loeschen (nur Ersteller)."""
+    tenant_id = current_user.get("tenant_id")
+    cursor = await db.execute(
+        "SELECT id, created_by FROM incidents WHERE id = ? AND tenant_id = ?",
+        (incident_id, tenant_id),
+    )
+    incident = await cursor.fetchone()
+    if not incident:
+        raise HTTPException(status_code=404, detail="Lage nicht gefunden")
+
+    if incident["created_by"] != current_user["id"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Nur der Ersteller kann diese Lage loeschen",
+        )
+
+    await db.execute("DELETE FROM incidents WHERE id = ?", (incident_id,))
+    await db.commit()
+
+
+@router.get("/{incident_id}/articles")
+async def get_articles(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Alle Artikel einer Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    cursor = await db.execute(
+        "SELECT * FROM articles WHERE incident_id = ? ORDER BY collected_at DESC",
+        (incident_id,),
+    )
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+@router.get("/{incident_id}/snapshots")
+async def get_snapshots(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Lageberichte (Snapshots) einer Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    cursor = await db.execute(
+        """SELECT id, incident_id, summary, sources_json,
+                  article_count, fact_check_count, created_at
+           FROM incident_snapshots WHERE incident_id = ?
+           ORDER BY created_at DESC""",
+        (incident_id,),
+    )
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+@router.get("/{incident_id}/factchecks")
+async def get_factchecks(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Faktenchecks einer Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    cursor = await db.execute(
+        "SELECT * FROM fact_checks WHERE incident_id = ? ORDER BY checked_at DESC",
+        (incident_id,),
+    )
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+@router.get("/{incident_id}/refresh-log")
+async def get_refresh_log(
+    incident_id: int,
+    limit: int = 20,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Refresh-Verlauf einer Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    cursor = await db.execute(
+        """SELECT id, started_at, completed_at, articles_found, status,
+                  trigger_type, retry_count, error_message
+           FROM refresh_log WHERE incident_id = ?
+           ORDER BY started_at DESC LIMIT ?""",
+        (incident_id, min(limit, 100)),
+    )
+    rows = await cursor.fetchall()
+    results = []
+    for row in rows:
+        entry = dict(row)
+        if entry["started_at"] and entry["completed_at"]:
+            try:
+                start = datetime.fromisoformat(entry["started_at"])
+                end = datetime.fromisoformat(entry["completed_at"])
+                entry["duration_seconds"] = round((end - start).total_seconds(), 1)
+            except Exception:
+                entry["duration_seconds"] = None
+        else:
+            entry["duration_seconds"] = None
+        results.append(entry)
+    return results
+
+
+@router.get("/{incident_id}/subscription", response_model=SubscriptionResponse)
+async def get_subscription(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """E-Mail-Abo-Einstellungen des aktuellen Nutzers fuer eine Lage abrufen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    cursor = await db.execute(
+        """SELECT notify_email_summary, notify_email_new_articles, notify_email_status_change
+           FROM incident_subscriptions WHERE user_id = ? AND incident_id = ?""",
+        (current_user["id"], incident_id),
+    )
+    row = await cursor.fetchone()
+    if row:
+        return dict(row)
+    return {"notify_email_summary": False, "notify_email_new_articles": False, "notify_email_status_change": False}
+
+
+@router.put("/{incident_id}/subscription", response_model=SubscriptionResponse)
+async def update_subscription(
+    incident_id: int,
+    data: SubscriptionUpdate,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """E-Mail-Abo-Einstellungen des aktuellen Nutzers fuer eine Lage setzen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    await db.execute(
+        """INSERT INTO incident_subscriptions (user_id, incident_id, notify_email_summary, notify_email_new_articles, notify_email_status_change)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(user_id, incident_id) DO UPDATE SET
+               notify_email_summary = excluded.notify_email_summary,
+               notify_email_new_articles = excluded.notify_email_new_articles,
+               notify_email_status_change = excluded.notify_email_status_change""",
+        (
+            current_user["id"],
+            incident_id,
+            1 if data.notify_email_summary else 0,
+            1 if data.notify_email_new_articles else 0,
+            1 if data.notify_email_status_change else 0,
+        ),
+    )
+    await db.commit()
+    return {
+        "notify_email_summary": data.notify_email_summary,
+        "notify_email_new_articles": data.notify_email_new_articles,
+        "notify_email_status_change": data.notify_email_status_change,
+    }
+
+
+@router.post("/{incident_id}/refresh")
+async def trigger_refresh(
+    incident_id: int,
+    current_user: dict = Depends(require_writable_license),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Manuellen Refresh fuer eine Lage ausloesen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+
+    from agents.orchestrator import orchestrator
+    enqueued = await orchestrator.enqueue_refresh(incident_id)
+
+    if not enqueued:
+        return {"status": "skipped", "incident_id": incident_id}
+    return {"status": "queued", "incident_id": incident_id}
+
+
+@router.post("/{incident_id}/cancel-refresh")
+async def cancel_refresh(
+    incident_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Laufenden Refresh fuer eine Lage abbrechen."""
+    tenant_id = current_user.get("tenant_id")
+    await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+
+    from agents.orchestrator import orchestrator
+    cancelled = await orchestrator.cancel_refresh(incident_id)
+
+    return {"status": "cancelling" if cancelled else "not_running"}
+
+
+
+def _slugify(text: str) -> str:
+    """Dateinamen-sicherer Slug aus Titel."""
+    replacements = {
+        "\u00e4": "ae", "\u00f6": "oe", "\u00fc": "ue", "\u00df": "ss",
+        "\u00c4": "Ae", "\u00d6": "Oe", "\u00dc": "Ue",
+    }
+    for src, dst in replacements.items():
+        text = text.replace(src, dst)
+    text = unicodedata.normalize("NFKD", text)
+    text = re.sub(r"[^\w\s-]", "", text)
+    text = re.sub(r"[\s_]+", "-", text).strip("-")
+    return text[:80].lower()
+
+
+def _build_markdown_export(
+    incident: dict, articles: list, fact_checks: list,
+    snapshots: list, scope: str, creator: str
+) -> str:
+    """Markdown-Dokument zusammenbauen."""
+    typ = "Hintergrundrecherche" if incident.get("type") == "research" else "Breaking News"
+    updated = (incident.get("updated_at") or "")[:16].replace("T", " ")
+
+    lines = []
+    lines.append(f"# {incident['title']}")
+    lines.append(f"> {typ} | Erstellt von {creator} | Stand: {updated}")
+    lines.append("")
+
+    # Lagebild
+    summary = incident.get("summary") or "*Noch kein Lagebild verf\u00fcgbar.*"
+    lines.append("## Lagebild")
+    lines.append("")
+    lines.append(summary)
+    lines.append("")
+
+    # Quellenverzeichnis aus sources_json
+    sources_json = incident.get("sources_json")
+    if sources_json:
+        try:
+            sources = json.loads(sources_json) if isinstance(sources_json, str) else sources_json
+            if sources:
+                lines.append("## Quellenverzeichnis")
+                lines.append("")
+                for i, src in enumerate(sources, 1):
+                    name = src.get("name") or src.get("title") or src.get("url", "")
+                    url = src.get("url", "")
+                    if url:
+                        lines.append(f"{i}. [{name}]({url})")
+                    else:
+                        lines.append(f"{i}. {name}")
+                lines.append("")
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    # Faktencheck
+    if fact_checks:
+        lines.append("## Faktencheck")
+        lines.append("")
+        for fc in fact_checks:
+            claim = fc.get("claim", "")
+            fc_status = fc.get("status", "")
+            sources_count = fc.get("sources_count", 0)
+            evidence = fc.get("evidence", "")
+            status_label = {
+                "confirmed": "Best\u00e4tigt", "unconfirmed": "Unbest\u00e4tigt",
+                "disputed": "Umstritten", "false": "Falsch",
+            }.get(fc_status, fc_status)
+            line = f"- **{claim}** \u2014 {status_label} ({sources_count} Quellen)"
+            if evidence:
+                line += f"\n  {evidence}"
+            lines.append(line)
+        lines.append("")
+
+    # Scope=full: Artikel\u00fcbersicht
+    if scope == "full" and articles:
+        lines.append("## Artikel\u00fcbersicht")
+        lines.append("")
+        lines.append("| Headline | Quelle | Sprache | Datum |")
+        lines.append("|----------|--------|---------|-------|")
+        for art in articles:
+            headline = (art.get("headline_de") or art.get("headline") or "").replace("|", "/")
+            source = (art.get("source") or "").replace("|", "/")
+            lang = art.get("language", "")
+            pub = (art.get("published_at") or art.get("collected_at") or "")[:16]
+            lines.append(f"| {headline} | {source} | {lang} | {pub} |")
+        lines.append("")
+
+    # Scope=full: Snapshot-Verlauf
+    if scope == "full" and snapshots:
+        lines.append("## Snapshot-Verlauf")
+        lines.append("")
+        for snap in snapshots:
+            snap_date = (snap.get("created_at") or "")[:16].replace("T", " ")
+            art_count = snap.get("article_count", 0)
+            fc_count = snap.get("fact_check_count", 0)
+            lines.append(f"### Snapshot vom {snap_date}")
+            lines.append(f"Artikel: {art_count} | Faktenchecks: {fc_count}")
+            lines.append("")
+            snap_summary = snap.get("summary", "")
+            if snap_summary:
+                lines.append(snap_summary)
+                lines.append("")
+
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    lines.append("---")
+    lines.append(f"*Exportiert am {now} aus AegisSight Monitor*")
+    return "\n".join(lines)
+
+
+def _build_json_export(
+    incident: dict, articles: list, fact_checks: list,
+    snapshots: list, scope: str, creator: str
+) -> dict:
+    """Strukturiertes JSON fuer Export."""
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    sources = []
+    sources_json = incident.get("sources_json")
+    if sources_json:
+        try:
+            sources = json.loads(sources_json) if isinstance(sources_json, str) else sources_json
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    export = {
+        "export_version": "1.0",
+        "exported_at": now,
+        "scope": scope,
+        "incident": {
+            "id": incident["id"],
+            "title": incident["title"],
+            "description": incident.get("description"),
+            "type": incident.get("type"),
+            "status": incident.get("status"),
+            "visibility": incident.get("visibility"),
+            "created_by": creator,
+            "created_at": incident.get("created_at"),
+            "updated_at": incident.get("updated_at"),
+            "summary": incident.get("summary"),
+            "international_sources": bool(incident.get("international_sources")),
+        },
+        "sources": sources,
+        "fact_checks": [
+            {
+                "claim": fc.get("claim"),
+                "status": fc.get("status"),
+                "sources_count": fc.get("sources_count"),
+                "evidence": fc.get("evidence"),
+                "checked_at": fc.get("checked_at"),
+            }
+            for fc in fact_checks
+        ],
+    }
+
+    if scope == "full":
+        export["articles"] = [
+            {
+                "headline": art.get("headline"),
+                "headline_de": art.get("headline_de"),
+                "source": art.get("source"),
+                "source_url": art.get("source_url"),
+                "language": art.get("language"),
+                "published_at": art.get("published_at"),
+                "collected_at": art.get("collected_at"),
+                "verification_status": art.get("verification_status"),
+            }
+            for art in articles
+        ]
+        export["snapshots"] = [
+            {
+                "created_at": snap.get("created_at"),
+                "article_count": snap.get("article_count"),
+                "fact_check_count": snap.get("fact_check_count"),
+                "summary": snap.get("summary"),
+            }
+            for snap in snapshots
+        ]
+
+    return export
+
+
+@router.get("/{incident_id}/export")
+async def export_incident(
+    incident_id: int,
+    format: str = Query(..., pattern="^(md|json)$"),
+    scope: str = Query("report", pattern="^(report|full)$"),
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Lage als Markdown oder JSON exportieren."""
+    tenant_id = current_user.get("tenant_id")
+    row = await _check_incident_access(db, incident_id, current_user["id"], tenant_id)
+    incident = dict(row)
+
+    # Ersteller-Name
+    cursor = await db.execute("SELECT username FROM users WHERE id = ?", (incident["created_by"],))
+    user_row = await cursor.fetchone()
+    creator = user_row["username"] if user_row else "Unbekannt"
+
+    # Artikel
+    cursor = await db.execute(
+        "SELECT * FROM articles WHERE incident_id = ? ORDER BY collected_at DESC",
+        (incident_id,),
+    )
+    articles = [dict(r) for r in await cursor.fetchall()]
+
+    # Faktenchecks
+    cursor = await db.execute(
+        "SELECT * FROM fact_checks WHERE incident_id = ? ORDER BY checked_at DESC",
+        (incident_id,),
+    )
+    fact_checks = [dict(r) for r in await cursor.fetchall()]
+
+    # Snapshots (nur bei full)
+    snapshots = []
+    if scope == "full":
+        cursor = await db.execute(
+            "SELECT * FROM incident_snapshots WHERE incident_id = ? ORDER BY created_at DESC",
+            (incident_id,),
+        )
+        snapshots = [dict(r) for r in await cursor.fetchall()]
+
+    # Dateiname
+    date_str = datetime.now(timezone.utc).strftime("%Y%m%d")
+    slug = _slugify(incident["title"])
+    scope_suffix = "_vollexport" if scope == "full" else ""
+
+    if format == "md":
+        body = _build_markdown_export(incident, articles, fact_checks, snapshots, scope, creator)
+        filename = f"{slug}{scope_suffix}_{date_str}.md"
+        media_type = "text/markdown; charset=utf-8"
+    else:
+        export_data = _build_json_export(incident, articles, fact_checks, snapshots, scope, creator)
+        body = json.dumps(export_data, ensure_ascii=False, indent=2)
+        filename = f"{slug}{scope_suffix}_{date_str}.json"
+        media_type = "application/json; charset=utf-8"
+
+    return StreamingResponse(
+        iter([body]),
+        media_type=media_type,
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
diff --git a/src/routers/notifications.py b/src/routers/notifications.py
new file mode 100644
index 0000000..af727ec
--- /dev/null
+++ b/src/routers/notifications.py
@@ -0,0 +1,62 @@
+"""Notifications-Router: Persistente Benachrichtigungen (Multi-Tenant)."""
+import logging
+from fastapi import APIRouter, Depends, Query
+from models import NotificationResponse, NotificationMarkReadRequest
+from auth import get_current_user
+from database import db_dependency
+import aiosqlite
+
+logger = logging.getLogger("osint.notifications")
+
+router = APIRouter(prefix="/api/notifications", tags=["notifications"])
+
+
+@router.get("", response_model=list[NotificationResponse])
+async def list_notifications(
+    limit: int = Query(default=50, ge=1, le=200),
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Eigene Notifications abrufen (neueste zuerst)."""
+    cursor = await db.execute(
+        "SELECT * FROM notifications WHERE user_id = ? ORDER BY created_at DESC LIMIT ?",
+        (current_user["id"], limit),
+    )
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+@router.get("/unread-count")
+async def get_unread_count(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Anzahl ungelesener Notifications."""
+    cursor = await db.execute(
+        "SELECT COUNT(*) as cnt FROM notifications WHERE user_id = ? AND is_read = 0",
+        (current_user["id"],),
+    )
+    row = await cursor.fetchone()
+    return {"unread_count": row["cnt"]}
+
+
+@router.put("/mark-read")
+async def mark_notifications_read(
+    body: NotificationMarkReadRequest,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Notifications als gelesen markieren (bestimmte IDs oder alle)."""
+    if body.notification_ids:
+        placeholders = ",".join("?" for _ in body.notification_ids)
+        await db.execute(
+            f"UPDATE notifications SET is_read = 1 WHERE user_id = ? AND id IN ({placeholders})",
+            [current_user["id"]] + body.notification_ids,
+        )
+    else:
+        await db.execute(
+            "UPDATE notifications SET is_read = 1 WHERE user_id = ? AND is_read = 0",
+            (current_user["id"],),
+        )
+    await db.commit()
+    return {"ok": True}
diff --git a/src/routers/sources.py b/src/routers/sources.py
new file mode 100644
index 0000000..fb1b2f3
--- /dev/null
+++ b/src/routers/sources.py
@@ -0,0 +1,527 @@
+"""Sources-Router: Quellenverwaltung (Multi-Tenant)."""
+import logging
+from collections import defaultdict
+from fastapi import APIRouter, Depends, HTTPException, status
+from models import SourceCreate, SourceUpdate, SourceResponse, DiscoverRequest, DiscoverResponse, DiscoverMultiResponse, DomainActionRequest
+from auth import get_current_user
+from database import db_dependency, refresh_source_counts
+from source_rules import discover_source, discover_all_feeds, evaluate_feeds_with_claude, _extract_domain, _detect_category, domain_to_display_name
+import aiosqlite
+
+logger = logging.getLogger("osint.sources")
+
+router = APIRouter(prefix="/api/sources", tags=["sources"])
+
+SOURCE_UPDATE_COLUMNS = {"name", "url", "domain", "source_type", "category", "status", "notes"}
+
+
+def _check_source_ownership(source: dict, username: str):
+    """Prueft ob der Nutzer die Quelle bearbeiten/loeschen darf."""
+    added_by = source.get("added_by", "")
+    if added_by == "system":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="System-Quellen koennen nicht veraendert werden",
+        )
+    if added_by and added_by != username:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Nur der Ersteller kann diese Quelle bearbeiten",
+        )
+
+
+@router.get("", response_model=list[SourceResponse])
+async def list_sources(
+    source_type: str = None,
+    category: str = None,
+    source_status: str = None,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Alle Quellen auflisten (global + org-spezifisch)."""
+    tenant_id = current_user.get("tenant_id")
+
+    # Global (tenant_id=NULL) + eigene Org
+    query = "SELECT * FROM sources WHERE (tenant_id IS NULL OR tenant_id = ?)"
+    params = [tenant_id]
+
+    if source_type:
+        query += " AND source_type = ?"
+        params.append(source_type)
+    if category:
+        query += " AND category = ?"
+        params.append(category)
+    if source_status:
+        query += " AND status = ?"
+        params.append(source_status)
+
+    query += " ORDER BY source_type, category, name"
+    cursor = await db.execute(query, params)
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+
+@router.get("/stats")
+async def get_source_stats(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Aggregierte Quellen-Statistiken (global + eigene Org)."""
+    tenant_id = current_user.get("tenant_id")
+
+    cursor = await db.execute("""
+        SELECT
+            source_type,
+            COUNT(*) as count,
+            SUM(article_count) as total_articles
+        FROM sources
+        WHERE status = 'active' AND (tenant_id IS NULL OR tenant_id = ?)
+        GROUP BY source_type
+    """, (tenant_id,))
+    rows = await cursor.fetchall()
+
+    stats = {
+        "rss_feed": {"count": 0, "articles": 0},
+        "web_source": {"count": 0, "articles": 0},
+        "excluded": {"count": 0, "articles": 0},
+    }
+    for row in rows:
+        st = row["source_type"]
+        if st in stats:
+            stats[st]["count"] = row["count"]
+            stats[st]["articles"] = row["total_articles"] or 0
+
+    cursor = await db.execute(
+        "SELECT COUNT(*) as cnt FROM articles WHERE tenant_id = ?",
+        (tenant_id,),
+    )
+    total_row = await cursor.fetchone()
+
+    return {
+        "by_type": stats,
+        "total_sources": sum(s["count"] for s in stats.values()),
+        "total_articles": total_row["cnt"],
+    }
+
+
+@router.post("/discover", response_model=DiscoverResponse)
+async def discover_source_endpoint(
+    data: DiscoverRequest,
+    current_user: dict = Depends(get_current_user),
+):
+    """RSS-Feed, Name, Kategorie und Domain einer URL automatisch erkennen."""
+    try:
+        result = await discover_source(data.url)
+        return result
+    except Exception as e:
+        logger.error(f"Discovery fehlgeschlagen: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Discovery fehlgeschlagen")
+
+
+@router.post("/discover-multi", response_model=DiscoverMultiResponse)
+async def discover_multi_endpoint(
+    data: DiscoverRequest,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Findet ALLE RSS-Feeds einer Domain, bewertet sie mit Claude und legt relevante als Quellen an."""
+    tenant_id = current_user.get("tenant_id")
+    try:
+        multi = await discover_all_feeds(data.url)
+        domain = multi["domain"]
+        category = multi["category"]
+
+        if not multi["feeds"]:
+            single = await discover_source(data.url)
+            sources = []
+            if single.get("rss_url"):
+                cursor = await db.execute(
+                    "SELECT id FROM sources WHERE url = ?", (single["rss_url"],)
+                )
+                existing = await cursor.fetchone()
+                if not existing:
+                    cursor = await db.execute(
+                        """INSERT INTO sources (name, url, domain, source_type, category, status, added_by, tenant_id)
+                           VALUES (?, ?, ?, ?, ?, 'active', ?, ?)""",
+                        (single["name"], single["rss_url"], single["domain"],
+                         single["source_type"], single["category"], current_user["username"], tenant_id),
+                    )
+                    await db.commit()
+                    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (cursor.lastrowid,))
+                    row = await cursor.fetchone()
+                    sources.append(dict(row))
+
+            return DiscoverMultiResponse(
+                domain=single.get("domain", domain),
+                category=single.get("category", category),
+                added_count=len(sources),
+                skipped_count=1 if not sources and single.get("rss_url") else 0,
+                total_found=1 if single.get("rss_url") else 0,
+                sources=sources,
+                fallback_single=True,
+            )
+
+        relevant_feeds = await evaluate_feeds_with_claude(domain, multi["feeds"])
+
+        cursor = await db.execute("SELECT url FROM sources WHERE url IS NOT NULL")
+        existing_urls = {row["url"] for row in await cursor.fetchall()}
+
+        new_ids = []
+        skipped = 0
+        for feed in relevant_feeds:
+            if feed["url"] in existing_urls:
+                skipped += 1
+                continue
+
+            cursor = await db.execute(
+                """INSERT INTO sources (name, url, domain, source_type, category, status, added_by, tenant_id)
+                   VALUES (?, ?, ?, 'rss_feed', ?, 'active', ?, ?)""",
+                (feed["name"], feed["url"], domain, category, current_user["username"], tenant_id),
+            )
+            new_ids.append(cursor.lastrowid)
+            existing_urls.add(feed["url"])
+
+        cursor = await db.execute(
+            "SELECT id FROM sources WHERE LOWER(domain) = ? AND source_type = 'web_source'",
+            (domain.lower(),),
+        )
+        if not await cursor.fetchone():
+            cursor = await db.execute(
+                """INSERT INTO sources (name, url, domain, source_type, category, status, added_by, tenant_id)
+                   VALUES (?, ?, ?, 'web_source', ?, 'active', ?, ?)""",
+                (domain_to_display_name(domain), f"https://{domain}", domain, category, current_user["username"], tenant_id),
+            )
+            new_ids.append(cursor.lastrowid)
+
+        await db.commit()
+
+        added_sources = []
+        if new_ids:
+            placeholders = ",".join("?" for _ in new_ids)
+            cursor = await db.execute(
+                f"SELECT * FROM sources WHERE id IN ({placeholders}) ORDER BY id",
+                new_ids,
+            )
+            added_sources = [dict(row) for row in await cursor.fetchall()]
+
+        return DiscoverMultiResponse(
+            domain=domain,
+            category=category,
+            added_count=len(added_sources),
+            skipped_count=skipped,
+            total_found=len(multi["feeds"]),
+            sources=added_sources,
+            fallback_single=False,
+        )
+
+    except Exception as e:
+        logger.error(f"Multi-Discovery fehlgeschlagen: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Multi-Discovery fehlgeschlagen")
+
+
+@router.post("/rediscover-existing")
+async def rediscover_existing_endpoint(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Einmalige Migration: Bestehende RSS-Quellen nach zusaetzlichen Feeds durchsuchen."""
+    tenant_id = current_user.get("tenant_id")
+    try:
+        cursor = await db.execute(
+            "SELECT * FROM sources WHERE source_type = 'rss_feed' AND status = 'active' AND (tenant_id IS NULL OR tenant_id = ?)",
+            (tenant_id,),
+        )
+        existing_sources = [dict(row) for row in await cursor.fetchall()]
+
+        domains = defaultdict(list)
+        for src in existing_sources:
+            if src["domain"]:
+                domains[src["domain"]].append(src)
+
+        cursor = await db.execute("SELECT url FROM sources WHERE url IS NOT NULL")
+        existing_urls = {row["url"] for row in await cursor.fetchall()}
+
+        domains_processed = 0
+        feeds_added = 0
+        feeds_skipped = 0
+
+        for domain, sources in domains.items():
+            domains_processed += 1
+            base_url = f"https://{domain}"
+
+            try:
+                multi = await discover_all_feeds(base_url)
+                if not multi["feeds"]:
+                    continue
+
+                relevant_feeds = await evaluate_feeds_with_claude(domain, multi["feeds"])
+                category = _detect_category(domain)
+
+                for feed in relevant_feeds:
+                    if feed["url"] in existing_urls:
+                        feeds_skipped += 1
+                        continue
+
+                    await db.execute(
+                        """INSERT INTO sources (name, url, domain, source_type, category, status, added_by, tenant_id)
+                           VALUES (?, ?, ?, 'rss_feed', ?, 'active', ?, ?)""",
+                        (feed["name"], feed["url"], domain, category, current_user["username"], tenant_id),
+                    )
+                    existing_urls.add(feed["url"])
+                    feeds_added += 1
+
+                await db.commit()
+            except Exception as e:
+                logger.warning(f"Rediscovery fuer {domain} fehlgeschlagen: {e}")
+                continue
+
+        return {
+            "domains_processed": domains_processed,
+            "feeds_added": feeds_added,
+            "feeds_skipped": feeds_skipped,
+        }
+
+    except Exception as e:
+        logger.error(f"Rediscovery fehlgeschlagen: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Rediscovery fehlgeschlagen")
+
+
+@router.post("/block-domain")
+async def block_domain(
+    data: DomainActionRequest,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Domain sperren: Alle Feeds deaktivieren + excluded-Eintrag anlegen."""
+    tenant_id = current_user.get("tenant_id")
+    domain = data.domain.lower().strip()
+    username = current_user["username"]
+
+    cursor = await db.execute(
+        "SELECT added_by FROM sources WHERE LOWER(domain) = ? AND source_type != 'excluded' AND status = 'active' AND (tenant_id IS NULL OR tenant_id = ?)",
+        (domain, tenant_id),
+    )
+    affected = await cursor.fetchall()
+    for row in affected:
+        ab = row["added_by"] or ""
+        if ab != "system" and ab != username and ab != "":
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Domain enthaelt Quellen anderer Nutzer",
+            )
+
+    cursor = await db.execute(
+        "UPDATE sources SET status = 'inactive' WHERE LOWER(domain) = ? AND source_type != 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)",
+        (domain, tenant_id),
+    )
+    feeds_deactivated = cursor.rowcount
+
+    cursor = await db.execute(
+        "SELECT id FROM sources WHERE LOWER(domain) = ? AND source_type = 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)",
+        (domain, tenant_id),
+    )
+    existing = await cursor.fetchone()
+
+    if existing:
+        excluded_id = existing["id"]
+        if data.notes:
+            await db.execute(
+                "UPDATE sources SET notes = ? WHERE id = ?",
+                (data.notes, excluded_id),
+            )
+    else:
+        cursor = await db.execute(
+            """INSERT INTO sources (name, url, domain, source_type, category, status, notes, added_by, tenant_id)
+               VALUES (?, NULL, ?, 'excluded', 'sonstige', 'active', ?, ?, ?)""",
+            (domain, domain, data.notes, current_user["username"], tenant_id),
+        )
+        excluded_id = cursor.lastrowid
+
+    await db.commit()
+
+    return {
+        "domain": domain,
+        "feeds_deactivated": feeds_deactivated,
+        "excluded_id": excluded_id,
+    }
+
+
+@router.post("/unblock-domain")
+async def unblock_domain(
+    data: DomainActionRequest,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Domain entsperren: excluded-Eintrag loeschen + Feeds reaktivieren."""
+    tenant_id = current_user.get("tenant_id")
+    domain = data.domain.lower().strip()
+
+    cursor = await db.execute(
+        "SELECT COUNT(*) as cnt FROM sources WHERE LOWER(domain) = ? AND source_type != 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)",
+        (domain, tenant_id),
+    )
+    row = await cursor.fetchone()
+    has_feeds = row["cnt"] > 0
+
+    if has_feeds:
+        await db.execute(
+            "DELETE FROM sources WHERE LOWER(domain) = ? AND source_type = 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)",
+            (domain, tenant_id),
+        )
+        cursor = await db.execute(
+            "UPDATE sources SET status = 'active' WHERE LOWER(domain) = ? AND source_type != 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)",
+            (domain, tenant_id),
+        )
+        feeds_reactivated = cursor.rowcount
+    else:
+        await db.execute(
+            """UPDATE sources SET source_type = 'web_source', status = 'active', notes = 'Entsperrt'
+               WHERE LOWER(domain) = ? AND source_type = 'excluded' AND (tenant_id IS NULL OR tenant_id = ?)""",
+            (domain, tenant_id),
+        )
+        feeds_reactivated = 0
+
+    await db.commit()
+
+    return {
+        "domain": domain,
+        "feeds_reactivated": feeds_reactivated,
+    }
+
+
+@router.delete("/domain/{domain}")
+async def delete_domain(
+    domain: str,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Alle Quellen einer Domain loeschen (nur org-eigene, nicht globale)."""
+    tenant_id = current_user.get("tenant_id")
+    domain_lower = domain.lower().strip()
+
+    cursor = await db.execute(
+        "SELECT * FROM sources WHERE LOWER(domain) = ? AND tenant_id = ?",
+        (domain_lower, tenant_id),
+    )
+    rows = await cursor.fetchall()
+
+    if not rows:
+        raise HTTPException(status_code=404, detail="Keine Quellen fuer diese Domain gefunden")
+
+    username = current_user["username"]
+    for row in rows:
+        source = dict(row)
+        if source["added_by"] == "system":
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Domain enthaelt System-Quellen, die nicht geloescht werden koennen",
+            )
+        if source["added_by"] and source["added_by"] != username:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Domain enthaelt Quellen anderer Nutzer",
+            )
+
+    await db.execute(
+        "DELETE FROM sources WHERE LOWER(domain) = ? AND tenant_id = ?",
+        (domain_lower, tenant_id),
+    )
+    await db.commit()
+
+    return {
+        "domain": domain_lower,
+        "deleted_count": len(rows),
+    }
+
+
+@router.post("", response_model=SourceResponse, status_code=status.HTTP_201_CREATED)
+async def create_source(
+    data: SourceCreate,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Neue Quelle hinzufuegen (org-spezifisch)."""
+    tenant_id = current_user.get("tenant_id")
+    cursor = await db.execute(
+        """INSERT INTO sources (name, url, domain, source_type, category, status, notes, added_by, tenant_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            data.name,
+            data.url,
+            data.domain,
+            data.source_type,
+            data.category,
+            data.status,
+            data.notes,
+            current_user["username"],
+            tenant_id,
+        ),
+    )
+    await db.commit()
+
+    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (cursor.lastrowid,))
+    row = await cursor.fetchone()
+    return dict(row)
+
+
+@router.put("/{source_id}", response_model=SourceResponse)
+async def update_source(
+    source_id: int,
+    data: SourceUpdate,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Quelle bearbeiten."""
+    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
+    row = await cursor.fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Quelle nicht gefunden")
+
+    _check_source_ownership(dict(row), current_user["username"])
+
+    updates = {}
+    for field, value in data.model_dump(exclude_none=True).items():
+        if field not in SOURCE_UPDATE_COLUMNS:
+            continue
+        updates[field] = value
+
+    if not updates:
+        return dict(row)
+
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    values = list(updates.values()) + [source_id]
+
+    await db.execute(f"UPDATE sources SET {set_clause} WHERE id = ?", values)
+    await db.commit()
+
+    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
+    row = await cursor.fetchone()
+    return dict(row)
+
+
+@router.delete("/{source_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_source(
+    source_id: int,
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Quelle loeschen."""
+    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
+    row = await cursor.fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Quelle nicht gefunden")
+
+    _check_source_ownership(dict(row), current_user["username"])
+
+    await db.execute("DELETE FROM sources WHERE id = ?", (source_id,))
+    await db.commit()
+
+
+@router.post("/refresh-counts")
+async def trigger_refresh_counts(
+    current_user: dict = Depends(get_current_user),
+    db: aiosqlite.Connection = Depends(db_dependency),
+):
+    """Artikelzaehler fuer alle Quellen neu berechnen."""
+    await refresh_source_counts(db)
+    return {"status": "ok"}
diff --git a/src/rss_parser.py b/src/rss_parser.py
new file mode 100644
index 0000000..d5be675
--- /dev/null
+++ b/src/rss_parser.py
@@ -0,0 +1,102 @@
+"""RSS-Feed Parser: Durchsucht vorkonfigurierte Feeds nach relevanten Meldungen."""
+import asyncio
+import logging
+import feedparser
+import httpx
+from datetime import datetime, timezone
+from config import RSS_FEEDS
+
+logger = logging.getLogger("osint.rss")
+
+
+class RSSParser:
+    """Durchsucht RSS-Feeds nach relevanten Artikeln."""
+
+    # Stoppwörter die bei der RSS-Suche ignoriert werden
+    STOP_WORDS = {
+        "und", "oder", "der", "die", "das", "ein", "eine", "in", "im", "am", "an",
+        "auf", "für", "mit", "von", "zu", "zum", "zur", "bei", "nach", "vor",
+        "über", "unter", "ist", "sind", "hat", "the", "and", "for", "with", "from",
+    }
+
+    async def search_feeds(self, search_term: str) -> list[dict]:
+        """Durchsucht alle konfigurierten RSS-Feeds nach einem Suchbegriff."""
+        all_articles = []
+        # Stoppwörter und kurze Wörter (< 3 Zeichen) filtern
+        search_words = [
+            w for w in search_term.lower().split()
+            if w not in self.STOP_WORDS and len(w) >= 3
+        ]
+        if not search_words:
+            search_words = search_term.lower().split()[:2]
+
+        tasks = []
+        for category, feeds in RSS_FEEDS.items():
+            for feed_config in feeds:
+                tasks.append(self._fetch_feed(feed_config, search_words))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for result in results:
+            if isinstance(result, Exception):
+                logger.warning(f"Feed-Fehler: {result}")
+                continue
+            all_articles.extend(result)
+
+        logger.info(f"RSS-Suche nach '{search_term}': {len(all_articles)} Treffer")
+        return all_articles
+
+    async def _fetch_feed(self, feed_config: dict, search_words: list[str]) -> list[dict]:
+        """Einzelnen RSS-Feed abrufen und durchsuchen."""
+        name = feed_config["name"]
+        url = feed_config["url"]
+        articles = []
+
+        try:
+            async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+                response = await client.get(url, headers={
+                    "User-Agent": "OSINT-Monitor/1.0 (News Aggregator)"
+                })
+                response.raise_for_status()
+
+            feed = await asyncio.to_thread(feedparser.parse, response.text)
+
+            for entry in feed.entries[:50]:
+                title = entry.get("title", "")
+                summary = entry.get("summary", "")
+                text = f"{title} {summary}".lower()
+
+                # Prüfe ob mindestens ein Suchwort vorkommt
+                if any(word in text for word in search_words):
+                    published = None
+                    if hasattr(entry, "published_parsed") and entry.published_parsed:
+                        try:
+                            published = datetime(*entry.published_parsed[:6], tzinfo=timezone.utc).isoformat()
+                        except (TypeError, ValueError):
+                            pass
+
+                    articles.append({
+                        "headline": title,
+                        "headline_de": title if self._is_german(title) else None,
+                        "source": name,
+                        "source_url": entry.get("link", ""),
+                        "content_original": summary[:1000] if summary else None,
+                        "content_de": summary[:1000] if summary and self._is_german(summary) else None,
+                        "language": "de" if self._is_german(title) else "en",
+                        "published_at": published,
+                    })
+
+        except Exception as e:
+            logger.debug(f"Feed {name} ({url}): {e}")
+
+        return articles
+
+    def _is_german(self, text: str) -> bool:
+        """Einfache Heuristik ob ein Text deutsch ist."""
+        german_words = {"der", "die", "das", "und", "ist", "von", "mit", "für", "auf", "ein",
+                        "eine", "den", "dem", "des", "sich", "wird", "nach", "bei", "auch",
+                        "über", "wie", "aus", "hat", "zum", "zur", "als", "noch", "mehr",
+                        "nicht", "aber", "oder", "sind", "vor", "einem", "einer", "wurde"}
+        words = set(text.lower().split())
+        matches = words & german_words
+        return len(matches) >= 2
diff --git a/src/services/__init__.py b/src/services/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/services/license_service.py b/src/services/license_service.py
new file mode 100644
index 0000000..ce851bf
--- /dev/null
+++ b/src/services/license_service.py
@@ -0,0 +1,117 @@
+"""Lizenz-Verwaltung und -Pruefung."""
+import logging
+from datetime import datetime, timezone
+from config import TIMEZONE
+import aiosqlite
+
+logger = logging.getLogger("osint.license")
+
+
+async def check_license(db: aiosqlite.Connection, organization_id: int) -> dict:
+    """Prueft den Lizenzstatus einer Organisation.
+
+    Returns:
+        dict mit: valid, status, license_type, max_users, current_users, read_only, message
+    """
+    # Organisation pruefen
+    cursor = await db.execute(
+        "SELECT id, name, is_active FROM organizations WHERE id = ?",
+        (organization_id,),
+    )
+    org = await cursor.fetchone()
+    if not org:
+        return {"valid": False, "status": "not_found", "read_only": True, "message": "Organisation nicht gefunden"}
+
+    if not org["is_active"]:
+        return {"valid": False, "status": "org_disabled", "read_only": True, "message": "Organisation deaktiviert"}
+
+    # Aktive Lizenz suchen
+    cursor = await db.execute(
+        """SELECT * FROM licenses
+           WHERE organization_id = ? AND status = 'active'
+           ORDER BY created_at DESC LIMIT 1""",
+        (organization_id,),
+    )
+    license_row = await cursor.fetchone()
+
+    if not license_row:
+        return {"valid": False, "status": "no_license", "read_only": True, "message": "Keine aktive Lizenz"}
+
+    # Ablauf pruefen
+    now = datetime.now(timezone.utc)
+    valid_until = license_row["valid_until"]
+
+    if valid_until is not None:
+        try:
+            expiry = datetime.fromisoformat(valid_until)
+            if expiry.tzinfo is None:
+                expiry = expiry.replace(tzinfo=timezone.utc)
+            if now > expiry:
+                return {
+                    "valid": False,
+                    "status": "expired",
+                    "license_type": license_row["license_type"],
+                    "read_only": True,
+                    "message": "Lizenz abgelaufen",
+                }
+        except (ValueError, TypeError):
+            pass
+
+    # Nutzerzahl pruefen
+    cursor = await db.execute(
+        "SELECT COUNT(*) as cnt FROM users WHERE organization_id = ? AND is_active = 1",
+        (organization_id,),
+    )
+    current_users = (await cursor.fetchone())["cnt"]
+
+    return {
+        "valid": True,
+        "status": license_row["status"],
+        "license_type": license_row["license_type"],
+        "max_users": license_row["max_users"],
+        "current_users": current_users,
+        "read_only": False,
+        "message": "Lizenz aktiv",
+    }
+
+
+async def can_add_user(db: aiosqlite.Connection, organization_id: int) -> tuple[bool, str]:
+    """Prueft ob ein neuer Nutzer hinzugefuegt werden kann (Nutzer-Limit).
+
+    Returns:
+        (erlaubt, grund)
+    """
+    lic = await check_license(db, organization_id)
+    if not lic["valid"]:
+        return False, lic["message"]
+
+    if lic["current_users"] >= lic["max_users"]:
+        return False, f"Nutzer-Limit erreicht ({lic['current_users']}/{lic['max_users']})"
+
+    return True, ""
+
+
+async def expire_licenses(db: aiosqlite.Connection):
+    """Setzt abgelaufene Lizenzen auf 'expired'. Taeglich aufrufen."""
+    cursor = await db.execute(
+        """SELECT id, organization_id FROM licenses
+           WHERE status = 'active'
+           AND valid_until IS NOT NULL
+           AND valid_until < datetime('now')"""
+    )
+    expired = await cursor.fetchall()
+
+    count = 0
+    for lic in expired:
+        await db.execute(
+            "UPDATE licenses SET status = 'expired' WHERE id = ?",
+            (lic["id"],),
+        )
+        count += 1
+        logger.info(f"Lizenz {lic['id']} fuer Org {lic['organization_id']} als abgelaufen markiert")
+
+    if count > 0:
+        await db.commit()
+        logger.info(f"{count} Lizenz(en) als abgelaufen markiert")
+
+    return count
diff --git a/src/source_rules.py b/src/source_rules.py
new file mode 100644
index 0000000..758fbb0
--- /dev/null
+++ b/src/source_rules.py
@@ -0,0 +1,680 @@
+"""Dynamische Quellen-Regeln aus der Datenbank."""
+import logging
+import re
+import json
+import asyncio
+from urllib.parse import urlparse
+
+import httpx
+import feedparser
+
+from config import CLAUDE_PATH, CLAUDE_TIMEOUT
+
+logger = logging.getLogger("osint.source_rules")
+
+# Domain -> Kategorie Mapping für Auto-Erkennung
+DOMAIN_CATEGORY_MAP = {
+    # Nachrichtenagenturen
+    "reuters.com": "nachrichtenagentur",
+    "apnews.com": "nachrichtenagentur",
+    "dpa.com": "nachrichtenagentur",
+    "afp.com": "nachrichtenagentur",
+    # Öffentlich-Rechtlich
+    "tagesschau.de": "oeffentlich-rechtlich",
+    "zdf.de": "oeffentlich-rechtlich",
+    "dw.com": "oeffentlich-rechtlich",
+    "br.de": "oeffentlich-rechtlich",
+    "ndr.de": "oeffentlich-rechtlich",
+    "wdr.de": "oeffentlich-rechtlich",
+    "mdr.de": "oeffentlich-rechtlich",
+    "swr.de": "oeffentlich-rechtlich",
+    "hr.de": "oeffentlich-rechtlich",
+    "rbb24.de": "oeffentlich-rechtlich",
+    "ard.de": "oeffentlich-rechtlich",
+    "orf.at": "oeffentlich-rechtlich",
+    "srf.ch": "oeffentlich-rechtlich",
+    # Qualitätszeitungen
+    "spiegel.de": "qualitaetszeitung",
+    "zeit.de": "qualitaetszeitung",
+    "faz.net": "qualitaetszeitung",
+    "sueddeutsche.de": "qualitaetszeitung",
+    "nzz.ch": "qualitaetszeitung",
+    "welt.de": "qualitaetszeitung",
+    "tagesspiegel.de": "qualitaetszeitung",
+    "fr.de": "qualitaetszeitung",
+    "stern.de": "qualitaetszeitung",
+    "focus.de": "qualitaetszeitung",
+    # Behörden
+    "bmi.bund.de": "behoerde",
+    "europol.europa.eu": "behoerde",
+    "bka.de": "behoerde",
+    "bsi.bund.de": "behoerde",
+    "verfassungsschutz.de": "behoerde",
+    "bpb.de": "behoerde",
+    # Fachmedien
+    "netzpolitik.org": "fachmedien",
+    "handelsblatt.com": "fachmedien",
+    "heise.de": "fachmedien",
+    "golem.de": "fachmedien",
+    "t3n.de": "fachmedien",
+    "wiwo.de": "fachmedien",
+    # Think Tanks
+    "swp-berlin.org": "think-tank",
+    "iiss.org": "think-tank",
+    "brookings.edu": "think-tank",
+    "rand.org": "think-tank",
+    "dgap.org": "think-tank",
+    "chathamhouse.org": "think-tank",
+    # International
+    "bbc.co.uk": "international",
+    "bbc.com": "international",
+    "aljazeera.com": "international",
+    "france24.com": "international",
+    "cnn.com": "international",
+    "theguardian.com": "international",
+    "nytimes.com": "international",
+    "washingtonpost.com": "international",
+    "lemonde.fr": "international",
+    "elpais.com": "international",
+    # Regional
+    "berliner-zeitung.de": "regional",
+    "hamburger-abendblatt.de": "regional",
+    "stuttgarter-zeitung.de": "regional",
+    "ksta.de": "regional",
+    "rp-online.de": "regional",
+    "merkur.de": "regional",
+}
+
+# Bekannte Feed-Pfade zum Durchprobieren
+_FEED_PATHS = ["/feed", "/rss", "/rss.xml", "/atom.xml", "/feed.xml", "/index.xml", "/feed/rss", "/feeds/posts/default"]
+
+# Erweiterte nachrichtenspezifische Feed-Pfade für Multi-Discovery
+_NEWS_FEED_PATHS = [
+    "/world/rss", "/world/rss.xml", "/world/feed",
+    "/politics/rss", "/politics/rss.xml", "/politics/feed",
+    "/business/rss", "/business/rss.xml", "/business/feed",
+    "/technology/rss", "/technology/rss.xml", "/technology/feed",
+    "/environment/rss", "/environment/rss.xml", "/environment/feed",
+    "/science/rss", "/science/rss.xml", "/science/feed",
+    "/europe/rss", "/europe/rss.xml", "/europe/feed",
+    "/security/rss", "/security/rss.xml", "/security/feed",
+    "/international/rss", "/international/rss.xml", "/international/feed",
+    "/economy/rss", "/economy/rss.xml", "/economy/feed",
+    "/defence/rss", "/defence/rss.xml", "/defence/feed",
+    "/middle-east/rss", "/middle-east/rss.xml",
+    "/asia/rss", "/asia/rss.xml",
+    "/africa/rss", "/africa/rss.xml",
+    "/americas/rss", "/americas/rss.xml",
+    "/uk-news/rss", "/us-news/rss",
+    "/commentisfree/rss", "/opinion/rss",
+    "/law/rss", "/media/rss",
+    "/global-development/rss",
+    "/news/feed", "/news/rss", "/news/rss.xml",
+    "/politik/rss", "/politik/rss.xml",
+    "/wirtschaft/rss", "/wirtschaft/rss.xml",
+    "/panorama/rss", "/panorama/rss.xml",
+    "/wissen/rss", "/wissen/rss.xml",
+    "/ausland/rss", "/ausland/rss.xml",
+    "/inland/rss", "/inland/rss.xml",
+    "/netzwelt/rss", "/netzwelt/rss.xml",
+    "/kultur/rss", "/kultur/rss.xml",
+]
+
+# Bekannte Feed-Subdomains für Portale die Feeds auf separater Domain hosten
+_DOMAIN_FEED_URLS = {
+    "bbc.com": [
+        "https://feeds.bbci.co.uk/news/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/rss.xml",
+        "https://feeds.bbci.co.uk/news/business/rss.xml",
+        "https://feeds.bbci.co.uk/news/politics/rss.xml",
+        "https://feeds.bbci.co.uk/news/technology/rss.xml",
+        "https://feeds.bbci.co.uk/news/science_and_environment/rss.xml",
+        "https://feeds.bbci.co.uk/news/health/rss.xml",
+        "https://feeds.bbci.co.uk/news/education/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/middle_east/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/europe/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/africa/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/asia/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/us_and_canada/rss.xml",
+        "https://feeds.bbci.co.uk/news/world/latin_america/rss.xml",
+        "https://feeds.bbci.co.uk/news/entertainment_and_arts/rss.xml",
+    ],
+    "bbc.co.uk": "bbc.com",  # Alias
+    "reuters.com": [
+        "https://www.reutersagency.com/feed/",
+    ],
+    "aljazeera.com": [
+        "https://www.aljazeera.com/xml/rss/all.xml",
+    ],
+}
+
+
+def _get_extra_feed_urls(domain: str) -> list[str]:
+    """Gibt bekannte Feed-URLs für Domains mit separater Feed-Subdomain zurück."""
+    entry = _DOMAIN_FEED_URLS.get(domain)
+    if isinstance(entry, str):
+        # Alias — auf andere Domain verweisen
+        entry = _DOMAIN_FEED_URLS.get(entry)
+    if isinstance(entry, list):
+        return entry
+    return []
+
+
+def _normalize_url(url: str) -> str:
+    """URL normalisieren (https:// ergänzen falls fehlend)."""
+    url = url.strip()
+    if not url.startswith(("http://", "https://")):
+        url = "https://" + url
+    return url
+
+
+def _extract_domain(url: str) -> str:
+    """Domain aus URL extrahieren (ohne www.)."""
+    parsed = urlparse(url)
+    domain = parsed.hostname or ""
+    if domain.startswith("www."):
+        domain = domain[4:]
+    return domain
+
+
+def _detect_category(domain: str) -> str:
+    """Kategorie anhand der Domain erkennen."""
+    if domain in DOMAIN_CATEGORY_MAP:
+        return DOMAIN_CATEGORY_MAP[domain]
+    # Subdomain-Match: z.B. feeds.reuters.com -> reuters.com
+    parts = domain.split(".")
+    if len(parts) > 2:
+        parent = ".".join(parts[-2:])
+        if parent in DOMAIN_CATEGORY_MAP:
+            return DOMAIN_CATEGORY_MAP[parent]
+    return "sonstige"
+
+
+# Bekannte Domain → Anzeigename Zuordnungen
+DOMAIN_DISPLAY_NAMES = {
+    "tagesschau.de": "tagesschau",
+    "zdf.de": "ZDF heute",
+    "spiegel.de": "Spiegel",
+    "zeit.de": "Zeit",
+    "newsfeed.zeit.de": "Zeit",
+    "faz.net": "FAZ",
+    "sueddeutsche.de": "Süddeutsche Zeitung",
+    "rss.sueddeutsche.de": "Süddeutsche Zeitung",
+    "nzz.ch": "NZZ",
+    "dw.com": "Deutsche Welle",
+    "rss.dw.com": "Deutsche Welle",
+    "reuters.com": "Reuters",
+    "reutersagency.com": "Reuters",
+    "rsshub.app": "RSSHub",
+    "apnews.com": "AP News",
+    "bbc.com": "BBC",
+    "bbc.co.uk": "BBC",
+    "feeds.bbci.co.uk": "BBC",
+    "aljazeera.com": "Al Jazeera",
+    "france24.com": "France24",
+    "theguardian.com": "The Guardian",
+    "nytimes.com": "New York Times",
+    "washingtonpost.com": "Washington Post",
+    "cnn.com": "CNN",
+    "bmi.bund.de": "BMI",
+    "europol.europa.eu": "Europol",
+    "handelsblatt.com": "Handelsblatt",
+    "wiwo.de": "WirtschaftsWoche",
+    "heise.de": "Heise Online",
+    "golem.de": "Golem",
+    "netzpolitik.org": "netzpolitik.org",
+    "t3n.de": "t3n",
+    "welt.de": "Welt",
+    "tagesspiegel.de": "Tagesspiegel",
+    "stern.de": "Stern",
+    "focus.de": "Focus",
+    "n-tv.de": "n-tv",
+    "bild.de": "BILD",
+    "tarnkappe.info": "Tarnkappe",
+    "bleepingcomputer.com": "BleepingComputer",
+    "techcrunch.com": "TechCrunch",
+    "theverge.com": "The Verge",
+    "wired.com": "WIRED",
+    "tomshardware.com": "Tom's Hardware",
+    "finanzen.net": "Finanzen.net",
+    "404media.co": "404 Media",
+    "medium.com": "Medium",
+    "swp-berlin.org": "SWP Berlin",
+    "dgap.org": "DGAP",
+    "brookings.edu": "Brookings",
+    "rand.org": "RAND",
+    "lemonde.fr": "Le Monde",
+    "elpais.com": "El País",
+    "orf.at": "ORF",
+    "srf.ch": "SRF",
+    "br.de": "BR",
+    "ndr.de": "NDR",
+    "wdr.de": "WDR",
+    "mdr.de": "MDR",
+    "swr.de": "SWR",
+    "hr.de": "hr",
+    "rbb24.de": "rbb24",
+    "fr.de": "Frankfurter Rundschau",
+    "rp-online.de": "Rheinische Post",
+    "ksta.de": "Kölner Stadt-Anzeiger",
+    "berliner-zeitung.de": "Berliner Zeitung",
+    "stuttgarter-zeitung.de": "Stuttgarter Zeitung",
+    "hamburger-abendblatt.de": "Hamburger Abendblatt",
+    "merkur.de": "Münchner Merkur",
+    "bsi.bund.de": "BSI",
+    "bpb.de": "bpb",
+    "bka.de": "BKA",
+    "verfassungsschutz.de": "Verfassungsschutz",
+    "bashinho.de": "Bashinho",
+}
+
+
+def domain_to_display_name(domain: str) -> str:
+    """Wandelt eine Domain in einen lesbaren Anzeigenamen um.
+
+    Prüft erst die bekannte Zuordnung, dann leitet einen sinnvollen
+    Namen aus der Domain ab (erster Teil, kapitalisiert).
+    """
+    if domain in DOMAIN_DISPLAY_NAMES:
+        return DOMAIN_DISPLAY_NAMES[domain]
+    # Subdomain-Match: feeds.reuters.com -> reuters.com
+    parts = domain.split(".")
+    if len(parts) > 2:
+        parent = ".".join(parts[-2:])
+        if parent in DOMAIN_DISPLAY_NAMES:
+            return DOMAIN_DISPLAY_NAMES[parent]
+    # Fallback: Domain-Kern extrahieren und kapitalisieren
+    # z.B. "example-news.de" → "Example News"
+    core = parts[-2] if len(parts) >= 2 else parts[0]
+    return core.replace("-", " ").title()
+
+
+async def _validate_feed(client: httpx.AsyncClient, url: str) -> dict | None:
+    """Prüft ob eine URL ein gültiger RSS/Atom-Feed ist. Gibt Feed-Info zurück oder None."""
+    try:
+        resp = await client.get(url)
+        if resp.status_code != 200:
+            return None
+        content_type = resp.headers.get("content-type", "")
+        text = resp.text[:10000]  # Nur Anfang prüfen
+        # Muss XML-artig sein
+        if "<rss" not in text and "<feed" not in text and "<channel" not in text:
+            return None
+        feed = await asyncio.to_thread(feedparser.parse, text)
+        if feed.get("bozo") and not feed.entries:
+            return None
+        if feed.feed.get("title") or feed.entries:
+            return {
+                "url": str(resp.url),  # Finale URL nach Redirects
+                "title": feed.feed.get("title", ""),
+            }
+    except Exception:
+        pass
+    return None
+
+
+async def discover_source(url: str) -> dict:
+    """Erkennt RSS-Feed, Name, Domain und Kategorie einer URL automatisch.
+
+    Returns:
+        dict mit: name, domain, rss_url, category, source_type
+    """
+    url = _normalize_url(url)
+    domain = _extract_domain(url)
+    category = _detect_category(domain)
+
+    result = {
+        "name": domain_to_display_name(domain),
+        "domain": domain,
+        "rss_url": None,
+        "category": category,
+        "source_type": "web_source",
+    }
+
+    async with httpx.AsyncClient(
+        timeout=12.0,
+        follow_redirects=True,
+        headers={"User-Agent": "Mozilla/5.0 (compatible; OSINT-Monitor/1.0)"},
+    ) as client:
+        # 1. Seite abrufen und nach RSS-Links suchen
+        page_title = None
+        try:
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                html = resp.text[:50000]
+                # <title> extrahieren
+                title_match = re.search(r"<title[^>]*>([^<]+)</title>", html, re.IGNORECASE)
+                if title_match:
+                    page_title = title_match.group(1).strip()
+
+                # RSS/Atom Link-Tags suchen
+                feed_links = re.findall(
+                    r'<link[^>]+type=["\']application/(rss|atom)\+xml["\'][^>]*>',
+                    html,
+                    re.IGNORECASE,
+                )
+                # Auch umgekehrte Attribut-Reihenfolge
+                feed_links += re.findall(
+                    r'<link[^>]+href=["\']([^"\']+)["\'][^>]+type=["\']application/(rss|atom)\+xml["\'][^>]*>',
+                    html,
+                    re.IGNORECASE,
+                )
+                # href aus den gefundenen Tags extrahieren
+                feed_urls = []
+                for tag in re.finditer(
+                    r'<link[^>]+type=["\']application/(?:rss|atom)\+xml["\'][^>]*>',
+                    html,
+                    re.IGNORECASE,
+                ):
+                    href_match = re.search(r'href=["\']([^"\']+)["\']', tag.group(0))
+                    if href_match:
+                        href = href_match.group(1)
+                        # Relative URLs auflösen
+                        if href.startswith("/"):
+                            parsed = urlparse(url)
+                            href = f"{parsed.scheme}://{parsed.netloc}{href}"
+                        elif not href.startswith("http"):
+                            href = url.rstrip("/") + "/" + href
+                        feed_urls.append(href)
+
+                # Gefundene Feed-URLs validieren
+                for feed_url in feed_urls:
+                    feed_info = await _validate_feed(client, feed_url)
+                    if feed_info:
+                        result["rss_url"] = feed_info["url"]
+                        result["source_type"] = "rss_feed"
+                        if feed_info["title"]:
+                            result["name"] = feed_info["title"]
+                        elif page_title:
+                            result["name"] = page_title
+                        return result
+        except Exception as e:
+            logger.debug(f"Fehler beim Abrufen von {url}: {e}")
+
+        # 2. Bekannte Feed-Pfade durchprobieren
+        parsed = urlparse(url)
+        base_url = f"{parsed.scheme}://{parsed.netloc}"
+        for path in _FEED_PATHS:
+            feed_url = base_url + path
+            feed_info = await _validate_feed(client, feed_url)
+            if feed_info:
+                result["rss_url"] = feed_info["url"]
+                result["source_type"] = "rss_feed"
+                if feed_info["title"]:
+                    result["name"] = feed_info["title"]
+                elif page_title:
+                    result["name"] = page_title
+                return result
+
+        # Kein Feed gefunden — Name aus Seitentitel
+        if page_title:
+            result["name"] = page_title
+
+    return result
+
+
+async def discover_all_feeds(url: str) -> dict:
+    """Findet ALLE RSS/Atom-Feeds einer Domain.
+
+    Returns:
+        dict mit: domain, category, page_title, feeds: [{"url", "title"}, ...]
+    """
+    url = _normalize_url(url)
+    domain = _extract_domain(url)
+    category = _detect_category(domain)
+
+    result = {
+        "domain": domain,
+        "category": category,
+        "page_title": None,
+        "feeds": [],
+    }
+
+    seen_urls = set()
+
+    async with httpx.AsyncClient(
+        timeout=15.0,
+        follow_redirects=True,
+        headers={"User-Agent": "Mozilla/5.0 (compatible; OSINT-Monitor/1.0)"},
+    ) as client:
+        # 1. HTML-Seite abrufen und ALLE RSS-Link-Tags sammeln
+        candidate_urls = []
+        try:
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                html = resp.text[:100000]
+                title_match = re.search(r"<title[^>]*>([^<]+)</title>", html, re.IGNORECASE)
+                if title_match:
+                    result["page_title"] = title_match.group(1).strip()
+
+                parsed = urlparse(url)
+                base = f"{parsed.scheme}://{parsed.netloc}"
+
+                for tag in re.finditer(
+                    r'<link[^>]+type=["\']application/(?:rss|atom)\+xml["\'][^>]*>',
+                    html,
+                    re.IGNORECASE,
+                ):
+                    href_match = re.search(r'href=["\']([^"\']+)["\']', tag.group(0))
+                    if href_match:
+                        href = href_match.group(1)
+                        if href.startswith("/"):
+                            href = base + href
+                        elif not href.startswith("http"):
+                            href = url.rstrip("/") + "/" + href
+                        candidate_urls.append(href)
+        except Exception as e:
+            logger.debug(f"Fehler beim Abrufen von {url}: {e}")
+
+        # 2. Bekannte Feed-Pfade hinzufügen (Standard + Nachrichten-spezifisch)
+        parsed = urlparse(url)
+        base_url = f"{parsed.scheme}://{parsed.netloc}"
+        for path in _FEED_PATHS + _NEWS_FEED_PATHS:
+            candidate_urls.append(base_url + path)
+
+        # 2b. Bekannte Feed-URLs für Domains mit separater Feed-Subdomain (z.B. BBC)
+        extra_urls = _get_extra_feed_urls(domain)
+        candidate_urls.extend(extra_urls)
+
+        # 3. Alle Kandidaten parallel validieren (in Batches von 10)
+        async def _validate_and_collect(feed_url: str):
+            try:
+                return await _validate_feed(client, feed_url)
+            except Exception:
+                return None
+
+        for i in range(0, len(candidate_urls), 10):
+            batch = candidate_urls[i:i + 10]
+            results = await asyncio.gather(*[_validate_and_collect(u) for u in batch])
+            for feed_info in results:
+                if feed_info and feed_info["url"] not in seen_urls:
+                    seen_urls.add(feed_info["url"])
+                    result["feeds"].append(feed_info)
+
+    logger.info(f"discover_all_feeds({domain}): {len(result['feeds'])} Feeds gefunden")
+    return result
+
+
+async def evaluate_feeds_with_claude(domain: str, feeds: list[dict]) -> list[dict]:
+    """Lässt Claude die OSINT-Relevanz der Feeds bewerten.
+
+    Args:
+        domain: Domain-Name
+        feeds: Liste von {"url", "title"} Dicts
+
+    Returns:
+        Liste von {"url", "title", "name"} Dicts (nur relevante Feeds)
+    """
+    if not feeds:
+        return []
+
+    feed_list = "\n".join(
+        f"  {i+1}. {f['title'] or f['url']} — {f['url']}"
+        for i, f in enumerate(feeds)
+    )
+
+    prompt = f"""Du bist ein OSINT-Analyst. Bewerte diese RSS-Feeds der Domain "{domain}" nach OSINT-Relevanz.
+
+OSINT-relevante Themen: Politik, Sicherheit, Wirtschaft, Internationale Beziehungen, Verteidigung, Konflikte, Terrorismus, Cybersecurity, Umweltkatastrophen, Technologie, Wissenschaft, Nachrichten allgemein.
+
+NICHT relevant: Sport, Lifestyle, Rezepte, Unterhaltung, Reisen, Mode, Kultur/Kunst, Wetter, Kreuzworträtsel, Podcasts (allgemein), Leserbriefe, Kommentare/Meinung.
+
+Feeds:
+{feed_list}
+
+Antworte AUSSCHLIESSLICH mit einem JSON-Array. Jedes Element:
+{{"index": <1-basiert>, "relevant": true/false, "name": "<Anzeigename für OSINT-Monitor, z.B. 'Guardian World' oder 'Spiegel Politik'>"}}
+
+Nur das JSON-Array, kein anderer Text."""
+
+    try:
+        cmd = [
+            CLAUDE_PATH,
+            "-p", prompt,
+            "--output-format", "text",
+        ]
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env={"PATH": "/usr/local/bin:/usr/bin:/bin", "HOME": "/home/claude-dev"},
+        )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=min(CLAUDE_TIMEOUT, 120)
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            logger.warning(f"Claude-Bewertung Timeout für {domain}, nutze Fallback")
+            return _fallback_all_feeds(domain, feeds)
+
+        if process.returncode != 0:
+            logger.warning(f"Claude-Bewertung fehlgeschlagen für {domain}, nutze Fallback")
+            return _fallback_all_feeds(domain, feeds)
+
+        response = stdout.decode("utf-8", errors="replace").strip()
+
+        # JSON aus Antwort extrahieren (Claude gibt manchmal Markdown-Blöcke zurück)
+        json_match = re.search(r'\[.*\]', response, re.DOTALL)
+        if not json_match:
+            logger.warning(f"Kein JSON in Claude-Antwort für {domain}, nutze Fallback")
+            return _fallback_all_feeds(domain, feeds)
+
+        evaluations = json.loads(json_match.group(0))
+
+        relevant = []
+        for ev in evaluations:
+            idx = ev.get("index", 0) - 1
+            if ev.get("relevant") and 0 <= idx < len(feeds):
+                feed = feeds[idx]
+                relevant.append({
+                    "url": feed["url"],
+                    "title": feed["title"],
+                    "name": ev.get("name", feed["title"] or domain),
+                })
+
+        logger.info(f"Claude-Bewertung für {domain}: {len(relevant)}/{len(feeds)} relevant")
+        return relevant
+
+    except json.JSONDecodeError:
+        logger.warning(f"JSON-Parse-Fehler bei Claude-Antwort für {domain}, nutze Fallback")
+        return _fallback_all_feeds(domain, feeds)
+    except Exception as e:
+        logger.warning(f"Claude-Bewertung Fehler für {domain}: {e}, nutze Fallback")
+        return _fallback_all_feeds(domain, feeds)
+
+
+def _fallback_all_feeds(domain: str, feeds: list[dict]) -> list[dict]:
+    """Fallback: Alle Feeds übernehmen mit Feed-Titel als Name."""
+    return [
+        {
+            "url": f["url"],
+            "title": f["title"],
+            "name": f["title"] or domain,
+        }
+        for f in feeds
+    ]
+
+
+async def get_feeds_with_metadata(tenant_id: int = None) -> list[dict]:
+    """Alle aktiven RSS-Feeds mit Metadaten fuer Claude-Selektion (global + org-spezifisch)."""
+    from database import get_db
+
+    db = await get_db()
+    try:
+        if tenant_id:
+            cursor = await db.execute(
+                "SELECT name, url, domain, category FROM sources "
+                "WHERE source_type = 'rss_feed' AND status = 'active' "
+                "AND (tenant_id IS NULL OR tenant_id = ?)",
+                (tenant_id,),
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT name, url, domain, category FROM sources "
+                "WHERE source_type = 'rss_feed' AND status = 'active'"
+            )
+        return [dict(row) for row in await cursor.fetchall()]
+    except Exception as e:
+        logger.error(f"Fehler beim Laden der Feed-Metadaten: {e}")
+        return []
+    finally:
+        await db.close()
+
+
+async def get_source_rules(tenant_id: int = None) -> dict:
+    """Liest Quellen-Konfiguration aus DB (global + org-spezifisch).
+
+    Returns:
+        dict mit:
+        - excluded_domains: Liste ausgeschlossener Domains
+        - rss_feeds: Dict mit Kategorien deutsch/international/behoerden
+    """
+    from database import get_db
+
+    db = await get_db()
+    try:
+        if tenant_id:
+            cursor = await db.execute(
+                "SELECT * FROM sources WHERE status = 'active' AND (tenant_id IS NULL OR tenant_id = ?)",
+                (tenant_id,),
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT * FROM sources WHERE status = 'active'"
+            )
+        sources = [dict(row) for row in await cursor.fetchall()]
+
+        excluded_domains = []
+        rss_feeds = {"deutsch": [], "international": [], "behoerden": []}
+
+        for source in sources:
+            if source["source_type"] == "excluded":
+                excluded_domains.append(source["domain"] or source["name"])
+            elif source["source_type"] == "rss_feed" and source["url"]:
+                feed_entry = {"name": source["name"], "url": source["url"]}
+                cat = source["category"]
+                if cat == "behoerde":
+                    rss_feeds["behoerden"].append(feed_entry)
+                elif cat == "international":
+                    rss_feeds["international"].append(feed_entry)
+                else:
+                    # Alle anderen Kategorien → deutsch
+                    rss_feeds["deutsch"].append(feed_entry)
+
+        return {
+            "excluded_domains": excluded_domains,
+            "rss_feeds": rss_feeds,
+        }
+    except Exception as e:
+        logger.error(f"Fehler beim Laden der Quellen-Regeln: {e}")
+        # Fallback auf config.py
+        from config import RSS_FEEDS, EXCLUDED_SOURCES
+        return {
+            "excluded_domains": list(EXCLUDED_SOURCES),
+            "rss_feeds": dict(RSS_FEEDS),
+        }
+    finally:
+        await db.close()
diff --git a/src/static/apple-touch-icon.png b/src/static/apple-touch-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..4688b584c0c6ca7c636ccdaa7e783b6d7e6a11c4
GIT binary patch
literal 8787
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
JPDHLkV1kLs%uxUU

literal 0
HcmV?d00001

diff --git a/src/static/components.js b/src/static/components.js
new file mode 100644
index 0000000..f1a2831
--- /dev/null
+++ b/src/static/components.js
@@ -0,0 +1,444 @@
+/**
+ * UI-Komponenten für das Dashboard.
+ */
+const UI = {
+    /**
+     * Sidebar-Eintrag für eine Lage rendern.
+     */
+    renderIncidentItem(incident, isActive) {
+        const isRefreshing = App._refreshingIncidents && App._refreshingIncidents.has(incident.id);
+        const dotClass = isRefreshing ? 'refreshing' : (incident.status === 'active' ? 'active' : 'archived');
+        const activeClass = isActive ? 'active' : '';
+        const creator = incident.created_by_username || '';
+
+        return `
+            <div class="incident-item ${activeClass}" data-id="${incident.id}" onclick="App.selectIncident(${incident.id})" role="button" tabindex="0">
+                <span class="incident-dot ${dotClass}" id="dot-${incident.id}"></span>
+                <div style="flex:1;min-width:0;">
+                    <div class="incident-name">${this.escape(incident.title)}</div>
+                    <div class="incident-meta">${incident.article_count} Artikel &middot; ${this.escape(creator)}</div>
+                </div>
+                ${incident.visibility === 'private' ? '<span class="badge badge-private" style="font-size:9px;">PRIVAT</span>' : ''}
+                ${incident.type === 'research' ? '<span class="badge badge-research" style="font-size:9px;">RECH</span>' : ''}
+                ${incident.refresh_mode === 'auto' ? '<span class="badge badge-auto" style="font-size:9px;">AUTO</span>' : ''}
+            </div>
+        `;
+    },
+
+    /**
+     * Faktencheck-Eintrag rendern.
+     */
+    factCheckLabels: {
+        confirmed: 'Bestätigt durch mehrere Quellen',
+        unconfirmed: 'Nicht unabhängig bestätigt',
+        contradicted: 'Widerlegt',
+        developing: 'Faktenlage noch im Fluss',
+        established: 'Gesicherter Fakt (3+ Quellen)',
+        disputed: 'Umstrittener Sachverhalt',
+        unverified: 'Nicht unabhängig verifizierbar',
+    },
+
+    factCheckChipLabels: {
+        confirmed: 'Bestätigt',
+        unconfirmed: 'Unbestätigt',
+        contradicted: 'Widerlegt',
+        developing: 'Unklar',
+        established: 'Gesichert',
+        disputed: 'Umstritten',
+        unverified: 'Ungeprüft',
+    },
+
+    factCheckIcons: {
+        confirmed: '&#10003;',
+        unconfirmed: '?',
+        contradicted: '&#10007;',
+        developing: '&#8635;',
+        established: '&#10003;',
+        disputed: '&#9888;',
+        unverified: '?',
+    },
+
+    /**
+     * Faktencheck-Filterleiste rendern.
+     */
+    renderFactCheckFilters(factchecks) {
+        // Welche Stati kommen tatsächlich vor + Zähler
+        const statusCounts = {};
+        factchecks.forEach(fc => {
+            statusCounts[fc.status] = (statusCounts[fc.status] || 0) + 1;
+        });
+        const statusOrder = ['confirmed', 'established', 'developing', 'unconfirmed', 'unverified', 'disputed', 'contradicted'];
+        const usedStatuses = statusOrder.filter(s => statusCounts[s]);
+        if (usedStatuses.length <= 1) return '';
+
+        const items = usedStatuses.map(status => {
+            const icon = this.factCheckIcons[status] || '?';
+            const chipLabel = this.factCheckChipLabels[status] || status;
+            const count = statusCounts[status];
+            return `<label class="fc-dropdown-item" data-status="${status}">
+                <input type="checkbox" checked onchange="App.toggleFactCheckFilter('${status}')">
+                <span class="factcheck-icon ${status}">${icon}</span>
+                <span class="fc-dropdown-label">${chipLabel}</span>
+                <span class="fc-dropdown-count">${count}</span>
+            </label>`;
+        }).join('');
+
+        return `<button class="fc-dropdown-toggle" onclick="App.toggleFcDropdown(event)">Filter</button>
+            <div class="fc-dropdown-menu" id="fc-dropdown-menu">${items}</div>`;
+    },
+
+    renderFactCheck(fc) {
+        const urls = (fc.evidence || '').match(/https?:\/\/[^\s,)]+/g) || [];
+        const count = urls.length;
+        return `
+            <div class="factcheck-item" data-fc-status="${fc.status}">
+                <div class="factcheck-icon ${fc.status}" title="${this.factCheckLabels[fc.status] || fc.status}" aria-hidden="true">${this.factCheckIcons[fc.status] || '?'}</div>
+                <span class="sr-only">${this.factCheckLabels[fc.status] || fc.status}</span>
+                <div style="flex:1;">
+                    <div class="factcheck-claim">${this.escape(fc.claim)}</div>
+                    <div style="display:flex;align-items:center;gap:6px;margin-top:2px;">
+                        <span class="factcheck-sources">${count} Quelle${count !== 1 ? 'n' : ''}</span>
+                    </div>
+                    <div class="evidence-block">${this.renderEvidence(fc.evidence || '')}</div>
+                </div>
+            </div>
+        `;
+    },
+
+    /**
+     * Evidence mit erklärenden Text UND Quellen-Chips rendern.
+     */
+    renderEvidence(text) {
+        if (!text) return '<span class="evidence-empty">Keine Belege</span>';
+
+        const urls = text.match(/https?:\/\/[^\s,)]+/g) || [];
+        if (urls.length === 0) {
+            return `<span class="evidence-text">${this.escape(text)}</span>`;
+        }
+
+        // Erklärenden Text extrahieren (URLs entfernen)
+        let explanation = text;
+        urls.forEach(url => { explanation = explanation.replace(url, '').trim(); });
+        // Aufräumen: Klammern, mehrfache Kommas/Leerzeichen
+        explanation = explanation.replace(/\(\s*\)/g, '');
+        explanation = explanation.replace(/,\s*,/g, ',');
+        explanation = explanation.replace(/\s+/g, ' ').trim();
+        explanation = explanation.replace(/[,.:;]+$/, '').trim();
+
+        // Chips für jede URL
+        const chips = urls.map(url => {
+            let label;
+            try { label = new URL(url).hostname.replace('www.', ''); } catch { label = url; }
+            return `<a href="${this.escape(url)}" target="_blank" rel="noopener" class="evidence-chip" title="${this.escape(url)}">${this.escape(label)}</a>`;
+        }).join('');
+
+        const explanationHtml = explanation
+            ? `<span class="evidence-text">${this.escape(explanation)}</span>`
+            : '';
+
+        return `${explanationHtml}<div class="evidence-chips">${chips}</div>`;
+    },
+
+    /**
+     * Verifizierungs-Badge.
+     */
+    verificationBadge(status) {
+        const map = {
+            verified: { class: 'badge-verified', text: 'Verifiziert' },
+            unverified: { class: 'badge-unverified', text: 'Offen' },
+            contradicted: { class: 'badge-contradicted', text: 'Widerlegt' },
+        };
+        const badge = map[status] || map.unverified;
+        return `<span class="badge ${badge.class}">${badge.text}</span>`;
+    },
+
+    /**
+     * Toast-Benachrichtigung anzeigen.
+     */
+    showToast(message, type = 'info', duration = 5000) {
+        const container = document.getElementById('toast-container');
+        const toast = document.createElement('div');
+        toast.className = `toast toast-${type}`;
+        toast.setAttribute('role', 'status');
+        toast.innerHTML = `<span class="toast-text">${this.escape(message)}</span>`;
+        container.appendChild(toast);
+
+        setTimeout(() => {
+            toast.style.opacity = '0';
+            toast.style.transform = 'translateX(100%)';
+            toast.style.transition = 'all 0.3s ease';
+            setTimeout(() => toast.remove(), 300);
+        }, duration);
+    },
+
+    /**
+     * Fortschrittsanzeige einblenden und Status setzen.
+     */
+    showProgress(status) {
+        const bar = document.getElementById('progress-bar');
+        if (!bar) return;
+        bar.style.display = 'block';
+
+        const steps = {
+            queued: { active: 0, label: 'In Warteschlange...' },
+            researching: { active: 1, label: 'Recherchiert Quellen...' },
+            deep_researching: { active: 1, label: 'Tiefenrecherche läuft...' },
+            analyzing: { active: 2, label: 'Analysiert Meldungen...' },
+            factchecking: { active: 3, label: 'Faktencheck läuft...' },
+        };
+
+        const step = steps[status] || steps.queued;
+        const stepIds = ['step-researching', 'step-analyzing', 'step-factchecking'];
+
+        stepIds.forEach((id, i) => {
+            const el = document.getElementById(id);
+            if (!el) return;
+            el.className = 'progress-step';
+            if (i + 1 < step.active) el.classList.add('done');
+            else if (i + 1 === step.active) el.classList.add('active');
+        });
+
+        const fill = document.getElementById('progress-fill');
+        const percent = step.active === 0 ? 5 : Math.round((step.active / 3) * 100);
+        if (fill) {
+            fill.style.width = percent + '%';
+        }
+
+        // ARIA-Werte auf der Progressbar aktualisieren
+        bar.setAttribute('aria-valuenow', String(percent));
+        bar.setAttribute('aria-valuetext', step.label);
+
+        const label = document.getElementById('progress-label');
+        if (label) label.textContent = step.label;
+    },
+
+    /**
+     * Fortschrittsanzeige ausblenden.
+     */
+    hideProgress() {
+        const bar = document.getElementById('progress-bar');
+        if (bar) bar.style.display = 'none';
+    },
+
+    /**
+     * Zusammenfassung mit Inline-Zitaten und Quellenverzeichnis rendern.
+     */
+    renderSummary(summary, sourcesJson, incidentType) {
+        if (!summary) return '<span style="color:var(--text-tertiary);">Noch keine Zusammenfassung.</span>';
+
+        let sources = [];
+        try { sources = JSON.parse(sourcesJson || '[]'); } catch(e) {}
+
+        // Markdown-Rendering
+        let html = this.escape(summary);
+
+        // ## Überschriften
+        html = html.replace(/^## (.+)$/gm, '<h3 class="briefing-heading">$1</h3>');
+        // **Fettdruck**
+        html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+        // Listen (- Item)
+        html = html.replace(/^- (.+)$/gm, '<li>$1</li>');
+        html = html.replace(/(<li>.*<\/li>\n?)+/gs, '<ul>$&</ul>');
+        // Zeilenumbrüche (aber nicht nach Headings/Listen)
+        html = html.replace(/\n(?!<)/g, '<br>');
+        // Überflüssige <br> nach Block-Elementen entfernen + doppelte <br> zusammenfassen
+        html = html.replace(/<\/h3>(<br>)+/g, '</h3>');
+        html = html.replace(/<\/ul>(<br>)+/g, '</ul>');
+        html = html.replace(/(<br>){2,}/g, '<br>');
+
+        // Inline-Zitate [1], [2] etc. als klickbare Links rendern
+        if (sources.length > 0) {
+            html = html.replace(/\[(\d+)\]/g, (match, num) => {
+                const src = sources.find(s => s.nr === parseInt(num));
+                if (src && src.url) {
+                    return `<a href="${this.escape(src.url)}" target="_blank" rel="noopener" class="citation" title="${this.escape(src.name)}">[${num}]</a>`;
+                }
+                return match;
+            });
+        }
+
+        return `<div class="briefing-content">${html}</div>`;
+    },
+
+    /**
+     * Quellenübersicht für eine Lage rendern.
+     */
+    renderSourceOverview(articles) {
+        if (!articles || articles.length === 0) return '';
+
+        // Nach Quelle aggregieren
+        const sourceMap = {};
+        articles.forEach(a => {
+            const name = a.source || 'Unbekannt';
+            if (!sourceMap[name]) {
+                sourceMap[name] = { count: 0, languages: new Set(), urls: [] };
+            }
+            sourceMap[name].count++;
+            sourceMap[name].languages.add(a.language || 'de');
+            if (a.source_url) sourceMap[name].urls.push(a.source_url);
+        });
+
+        const sources = Object.entries(sourceMap)
+            .sort((a, b) => b[1].count - a[1].count);
+
+        // Sprach-Statistik
+        const langCount = {};
+        articles.forEach(a => {
+            const lang = (a.language || 'de').toUpperCase();
+            langCount[lang] = (langCount[lang] || 0) + 1;
+        });
+
+        const langChips = Object.entries(langCount)
+            .sort((a, b) => b[1] - a[1])
+            .map(([lang, count]) => `<span class="source-lang-chip">${lang} <strong>${count}</strong></span>`)
+            .join('');
+
+        let html = `<div class="source-overview-header">`;
+        html += `<span class="source-overview-stat">${articles.length} Artikel aus ${sources.length} Quellen</span>`;
+        html += `<div class="source-lang-chips">${langChips}</div>`;
+        html += `</div>`;
+
+        html += '<div class="source-overview-grid">';
+        sources.forEach(([name, data]) => {
+            const langs = [...data.languages].map(l => l.toUpperCase()).join('/');
+            html += `<div class="source-overview-item">
+                <span class="source-overview-name">${this.escape(name)}</span>
+                <span class="source-overview-lang">${langs}</span>
+                <span class="source-overview-count">${data.count}</span>
+            </div>`;
+        });
+        html += '</div>';
+
+        return html;
+    },
+
+    /**
+     * Kategorie-Labels.
+     */
+    _categoryLabels: {
+        'nachrichtenagentur': 'Agentur',
+        'oeffentlich-rechtlich': 'ÖR',
+        'qualitaetszeitung': 'Qualität',
+        'behoerde': 'Behörde',
+        'fachmedien': 'Fach',
+        'think-tank': 'Think Tank',
+        'international': 'Intl.',
+        'regional': 'Regional',
+        'sonstige': 'Sonstige',
+    },
+
+    /**
+     * Domain-Gruppe rendern (aufklappbar mit Feeds).
+     */
+    renderSourceGroup(domain, feeds, isExcluded, excludedNotes) {
+        const catLabel = this._categoryLabels[feeds[0]?.category] || feeds[0]?.category || '';
+        const feedCount = feeds.filter(f => f.source_type !== 'excluded').length;
+        const hasMultiple = feedCount > 1;
+        const displayName = domain || feeds[0]?.name || 'Unbekannt';
+        const escapedDomain = this.escape(domain);
+
+        if (isExcluded) {
+            // Gesperrte Domain
+            const notesHtml = excludedNotes ? ` <span class="source-group-notes">${this.escape(excludedNotes)}</span>` : '';
+            return `<div class="source-group">
+                <div class="source-group-header excluded">
+                    <div class="source-group-info">
+                        <span class="source-group-name">${this.escape(displayName)}</span>${notesHtml}
+                    </div>
+                    <span class="source-excluded-badge">Gesperrt</span>
+                    <div class="source-group-actions">
+                        <button class="btn btn-small btn-secondary" onclick="App.unblockDomain('${escapedDomain}')">Entsperren</button>
+                        <button class="source-delete-btn" onclick="App.deleteDomain('${escapedDomain}')" title="Löschen" aria-label="Löschen">&times;</button>
+                    </div>
+                </div>
+            </div>`;
+        }
+
+        // Aktive Domain-Gruppe
+        const toggleAttr = hasMultiple ? `onclick="App.toggleGroup('${escapedDomain}')" role="button" tabindex="0" aria-expanded="false"` : '';
+        const toggleIcon = hasMultiple ? '<span class="source-group-toggle" aria-hidden="true">&#9654;</span>' : '<span class="source-group-toggle-placeholder"></span>';
+
+        let feedRows = '';
+        if (hasMultiple) {
+            const realFeeds = feeds.filter(f => f.source_type !== 'excluded');
+            feedRows = `<div class="source-group-feeds" data-domain="${escapedDomain}">`;
+            realFeeds.forEach((feed, i) => {
+                const isLast = i === realFeeds.length - 1;
+                const connector = isLast ? '\u2514\u2500' : '\u251C\u2500';
+                const typeLabel = feed.source_type === 'rss_feed' ? 'RSS' : 'Web';
+                const urlDisplay = feed.url ? this._shortenUrl(feed.url) : '';
+                feedRows += `<div class="source-feed-row">
+                    <span class="source-feed-connector">${connector}</span>
+                    <span class="source-feed-name">${this.escape(feed.name)}</span>
+                    <span class="source-type-badge type-${feed.source_type}">${typeLabel}</span>
+                    <span class="source-feed-url" title="${this.escape(feed.url || '')}">${this.escape(urlDisplay)}</span>
+                    <button class="source-delete-btn" onclick="App.deleteSingleFeed(${feed.id})" title="Löschen" aria-label="Löschen">&times;</button>
+                </div>`;
+            });
+            feedRows += '</div>';
+        }
+
+        const feedCountBadge = feedCount > 0
+            ? `<span class="source-feed-count">${feedCount} Feed${feedCount !== 1 ? 's' : ''}</span>`
+            : '';
+
+        return `<div class="source-group">
+            <div class="source-group-header" ${toggleAttr}>
+                ${toggleIcon}
+                <div class="source-group-info">
+                    <span class="source-group-name">${this.escape(displayName)}</span>
+                </div>
+                <span class="source-category-badge cat-${feeds[0]?.category || 'sonstige'}">${catLabel}</span>
+                ${feedCountBadge}
+                <div class="source-group-actions" onclick="event.stopPropagation()">
+                    <button class="btn btn-small btn-secondary" onclick="App.blockDomainDirect('${escapedDomain}')">Sperren</button>
+                    <button class="source-delete-btn" onclick="App.deleteDomain('${escapedDomain}')" title="Löschen" aria-label="Löschen">&times;</button>
+                </div>
+            </div>
+            ${feedRows}
+        </div>`;
+    },
+
+    /**
+     * URL kürzen für die Anzeige in Feed-Zeilen.
+     */
+    _shortenUrl(url) {
+        try {
+            const u = new URL(url);
+            let path = u.pathname;
+            if (path.length > 40) path = path.substring(0, 37) + '...';
+            return u.hostname + path;
+        } catch {
+            return url.length > 50 ? url.substring(0, 47) + '...' : url;
+        }
+    },
+
+    /**
+     * URLs in Evidence-Text als kompakte Hostname-Chips rendern (Legacy-Fallback).
+     */
+    renderEvidenceChips(text) {
+        return this.renderEvidence(text);
+    },
+
+    /**
+     * URLs in Evidence-Text als klickbare Links rendern (Legacy).
+     */
+    linkifyEvidence(text) {
+        if (!text) return '';
+        const escaped = this.escape(text);
+        return escaped.replace(
+            /(https?:\/\/[^\s,)]+)/g,
+            '<a href="$1" target="_blank" rel="noopener">$1</a>'
+        );
+    },
+
+    /**
+     * HTML escapen.
+     */
+    escape(str) {
+        if (!str) return '';
+        const div = document.createElement('div');
+        div.textContent = str;
+        return div.innerHTML;
+    },
+};
diff --git a/src/static/css/style.css b/src/static/css/style.css
new file mode 100644
index 0000000..185388c
--- /dev/null
+++ b/src/static/css/style.css
@@ -0,0 +1,4027 @@
+/* AegisSight Design System - OSINT Lagemonitor (Dark Theme: Navy/Gold) */
+
+/* === CSS Variables === */
+:root {
+    /* Backgrounds */
+    --bg-primary: #0B1121;
+    --bg-secondary: #1A2440;
+    --bg-card: #151D2E;
+    --bg-sidebar: #0A1832;
+    --bg-topbar: #151D2E;
+    --bg-hover: #1A2440;
+    --bg-elevated: #1E2D45;
+
+    /* Accent (Gold) */
+    --accent: #C8A851;
+    --accent-hover: #B5923E;
+    --accent-pressed: #A07E2B;
+
+    /* Text */
+    --text-primary: #E8ECF4;
+    --text-secondary: #8896AB;
+    --text-disabled: #95A3B8;
+    --text-tertiary: #95A3B8;
+
+    /* Inputs / Borders */
+    --input-bg: #1A2440;
+    --input-border: #1E2D45;
+    --border: #1E2D45;
+
+    /* Status */
+    --success: #10B981;
+    --warning: #F59E0B;
+    --error: #EF4444;
+    --info: #7C8DB5;
+
+    /* Sidebar */
+    --sidebar-text: #E8ECF4;
+    --sidebar-text-sec: #8896AB;
+    --sidebar-active: #C8A851;
+    --sidebar-hover-bg: #1A2440;
+
+    /* Typography */
+    --font-title: 'Poppins', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    --font-body: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif;
+    --font-mono: 'SF Mono', Consolas, Menlo, monospace;
+
+    /* Spacing (8pt scale) */
+    --sp-xxs: 2px;
+    --sp-xs: 4px;
+    --sp-sm: 6px;
+    --sp-md: 8px;
+    --sp-lg: 12px;
+    --sp-xl: 16px;
+    --sp-2xl: 20px;
+    --sp-3xl: 24px;
+    --sp-4xl: 32px;
+    --sp-5xl: 48px;
+
+    /* Radii */
+    --radius: 4px;
+    --radius-lg: 8px;
+
+    /* Tints (halbtransparente Hintergründe) */
+    --tint-accent: rgba(200, 168, 81, 0.15);
+    --tint-accent-subtle: rgba(200, 168, 81, 0.08);
+    --tint-accent-faint: rgba(200, 168, 81, 0.04);
+    --tint-accent-strong: rgba(200, 168, 81, 0.18);
+    --tint-error: rgba(239, 68, 68, 0.12);
+    --tint-error-strong: rgba(239, 68, 68, 0.3);
+    --tint-error-border: rgba(239, 68, 68, 0.4);
+    --tint-success: rgba(16, 185, 129, 0.15);
+    --tint-warning: rgba(245, 158, 11, 0.15);
+    --tint-info: rgba(124, 141, 181, 0.15);
+    --tint-indigo: rgba(99, 102, 241, 0.15);
+    --tint-hover: rgba(26, 36, 64, 0.5);
+    --tint-hover-subtle: rgba(255, 255, 255, 0.03);
+
+    /* Shadows */
+    --shadow-sm: 0 4px 12px rgba(0, 0, 0, 0.3);
+    --shadow-md: 0 8px 24px rgba(0, 0, 0, 0.4);
+    --shadow-lg: 0 12px 40px rgba(0, 0, 0, 0.5);
+
+    /* Glows */
+    --glow-accent: 0 0 8px rgba(200, 168, 81, 0.4);
+    --glow-accent-strong: 0 0 16px rgba(200, 168, 81, 0.6);
+
+    /* Overlay */
+    --backdrop: rgba(11, 17, 33, 0.85);
+
+    /* Category Badge Colors */
+    --cat-nachrichtenagentur: #F87171;
+    --cat-oeffentlich-rechtlich: #60A5FA;
+    --cat-qualitaetszeitung: #C084FC;
+    --cat-behoerde: #FBBF24;
+    --cat-fachmedien: #2DD4BF;
+    --cat-think-tank: #818CF8;
+    --cat-international: #34D399;
+    --cat-regional: #FB923C;
+
+    /* Category Badge Backgrounds */
+    --cat-nachrichtenagentur-bg: rgba(239, 68, 68, 0.12);
+    --cat-oeffentlich-rechtlich-bg: rgba(59, 130, 246, 0.12);
+    --cat-qualitaetszeitung-bg: rgba(168, 85, 247, 0.12);
+    --cat-behoerde-bg: rgba(245, 158, 11, 0.12);
+    --cat-fachmedien-bg: rgba(20, 184, 166, 0.12);
+    --cat-think-tank-bg: rgba(99, 102, 241, 0.12);
+    --cat-international-bg: rgba(16, 185, 129, 0.12);
+    --cat-regional-bg: rgba(251, 146, 60, 0.12);
+    --cat-sonstige-bg: rgba(124, 141, 181, 0.12);
+}
+
+/* === Light Theme === */
+[data-theme="light"] {
+    --bg-primary: #F4F5F7;
+    --bg-secondary: #E8EBF0;
+    --bg-card: #FFFFFF;
+    --bg-sidebar: #FFFFFF;
+    --bg-topbar: #FFFFFF;
+    --bg-hover: #E8EBF0;
+    --bg-elevated: #F0F1F3;
+
+    --accent: #96791A;
+    --accent-hover: #7D6516;
+    --accent-pressed: #645112;
+
+    --text-primary: #1A202C;
+    --text-secondary: #4A5568;
+    --text-disabled: #A0AEC0;
+    --text-tertiary: #A0AEC0;
+
+    --input-bg: #FFFFFF;
+    --input-border: #CBD5E0;
+    --border: #E2E8F0;
+
+    --success: #059669;
+    --warning: #D97706;
+    --error: #DC2626;
+    --info: #4A5568;
+
+    --sidebar-text: #1A202C;
+    --sidebar-text-sec: #4A5568;
+    --sidebar-active: #96791A;
+    --sidebar-hover-bg: #F0EDE6;
+
+    --tint-accent: rgba(150, 121, 26, 0.10);
+    --tint-accent-subtle: rgba(150, 121, 26, 0.05);
+    --tint-accent-faint: rgba(150, 121, 26, 0.03);
+    --tint-accent-strong: rgba(150, 121, 26, 0.14);
+    --tint-error: rgba(220, 38, 38, 0.08);
+    --tint-error-strong: rgba(220, 38, 38, 0.2);
+    --tint-error-border: rgba(220, 38, 38, 0.3);
+    --tint-success: rgba(5, 150, 105, 0.10);
+    --tint-warning: rgba(217, 119, 6, 0.10);
+    --tint-info: rgba(74, 85, 104, 0.10);
+    --tint-indigo: rgba(99, 102, 241, 0.10);
+    --tint-hover: rgba(0, 0, 0, 0.04);
+    --tint-hover-subtle: rgba(0, 0, 0, 0.02);
+
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.08);
+    --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.10);
+    --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.12);
+
+    --glow-accent: 0 0 6px rgba(150, 121, 26, 0.2);
+    --glow-accent-strong: 0 0 12px rgba(150, 121, 26, 0.3);
+
+    --backdrop: rgba(0, 0, 0, 0.4);
+
+    --cat-nachrichtenagentur: #DC2626;
+    --cat-oeffentlich-rechtlich: #2563EB;
+    --cat-qualitaetszeitung: #7C3AED;
+    --cat-behoerde: #D97706;
+    --cat-fachmedien: #0D9488;
+    --cat-think-tank: #4F46E5;
+    --cat-international: #059669;
+    --cat-regional: #EA580C;
+
+    --cat-nachrichtenagentur-bg: rgba(220, 38, 38, 0.08);
+    --cat-oeffentlich-rechtlich-bg: rgba(37, 99, 235, 0.08);
+    --cat-qualitaetszeitung-bg: rgba(124, 58, 237, 0.08);
+    --cat-behoerde-bg: rgba(217, 119, 6, 0.08);
+    --cat-fachmedien-bg: rgba(13, 148, 136, 0.08);
+    --cat-think-tank-bg: rgba(79, 70, 229, 0.08);
+    --cat-international-bg: rgba(5, 150, 105, 0.08);
+    --cat-regional-bg: rgba(234, 88, 12, 0.08);
+    --cat-sonstige-bg: rgba(74, 85, 104, 0.08);
+}
+
+/* === Reset === */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* === Base === */
+html, body {
+    height: 100%;
+    font-family: var(--font-body);
+    font-size: 14px;
+    line-height: 1.6;
+    color: var(--text-primary);
+    background: var(--bg-primary);
+    -webkit-font-smoothing: antialiased;
+}
+
+a {
+    color: var(--accent);
+    text-decoration: none;
+    transition: color 0.2s ease;
+}
+
+a:hover {
+    color: var(--accent-hover);
+}
+
+/* === Scrollbar === */
+::-webkit-scrollbar {
+    width: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-primary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--text-disabled);
+    border-radius: var(--radius);
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--text-secondary);
+}
+
+/* === Login Page === */
+.login-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    padding: var(--sp-3xl);
+    background: var(--bg-primary);
+}
+
+.login-box {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-5xl) var(--sp-4xl);
+    width: 100%;
+    max-width: 420px;
+}
+
+.login-logo {
+    text-align: center;
+    margin-bottom: var(--sp-4xl);
+}
+
+.login-logo h1 {
+    font-family: var(--font-title);
+    font-size: 28px;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.login-logo h1 span {
+    color: var(--accent);
+}
+
+.login-logo .subtitle {
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-top: var(--sp-xs);
+    letter-spacing: 0.5px;
+    text-transform: uppercase;
+    font-weight: 500;
+}
+
+.form-group {
+    margin-bottom: var(--sp-xl);
+}
+
+.form-group label {
+    display: block;
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-sm);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.form-group input,
+.form-group select,
+.form-group textarea {
+    width: 100%;
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    font-size: 14px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    transition: border-color 0.2s ease;
+}
+
+.form-group input:focus,
+.form-group select:focus,
+.form-group textarea:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+    border-color: var(--accent);
+}
+
+.form-group input::placeholder,
+.form-group textarea::placeholder {
+    color: var(--text-disabled);
+}
+
+.form-group select {
+    cursor: pointer;
+    appearance: none;
+    background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238896AB' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3e%3cpolyline points='6 9 12 15 18 9'%3e%3c/polyline%3e%3c/svg%3e");
+    background-repeat: no-repeat;
+    background-position: right 12px center;
+    background-size: 16px;
+}
+
+.form-group textarea {
+    resize: vertical;
+    min-height: 80px;
+}
+
+.login-error {
+    display: none;
+    background: var(--tint-error);
+    border: 1px solid var(--tint-error-strong);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    margin-bottom: var(--sp-xl);
+    font-size: 13px;
+    color: var(--error);
+}
+
+/* === Buttons === */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--sp-md);
+    border: none;
+    border-radius: var(--radius);
+    cursor: pointer;
+    font-family: var(--font-body);
+    font-weight: 600;
+    font-size: 14px;
+    transition: all 0.2s ease;
+    min-height: 40px;
+    padding: 0 var(--sp-xl);
+}
+
+.btn:active {
+    transform: scale(0.98);
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+}
+
+.btn-primary {
+    background: var(--accent);
+    color: #FFFFFF;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: var(--accent-hover);
+}
+
+.btn-primary:active:not(:disabled) {
+    background: var(--accent-pressed);
+}
+
+.btn-secondary {
+    background: transparent;
+    color: var(--text-primary);
+    border: 1px solid var(--border);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--bg-secondary);
+    border-color: var(--accent);
+}
+
+.btn-danger {
+    background: transparent;
+    color: var(--error);
+    border: 1px solid var(--tint-error-border);
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: var(--tint-error);
+    border-color: var(--error);
+}
+
+.btn-small {
+    min-height: 32px;
+    padding: 0 var(--sp-lg);
+    font-size: 12px;
+}
+
+.btn-full {
+    width: 100%;
+}
+
+/* === Dashboard Layout === */
+.dashboard {
+    display: grid;
+    grid-template-columns: 240px 1fr;
+    grid-template-rows: 56px 1fr;
+    height: 100vh;
+    overflow: hidden;
+}
+
+/* === Header/Topbar === */
+.header {
+    grid-column: 1 / -1;
+    background: var(--bg-topbar);
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0 var(--sp-3xl);
+    z-index: 10;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+}
+
+.header-logo {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.header-logo span {
+    color: var(--accent);
+}
+
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+}
+
+.header-user {
+    font-size: 13px;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* === Sidebar === */
+.sidebar {
+    background: var(--bg-sidebar);
+    padding: var(--sp-xl);
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    border-right: 1px solid var(--border);
+    scrollbar-width: thin;
+    scrollbar-color: var(--text-disabled) transparent;
+}
+
+.sidebar::-webkit-scrollbar { width: 6px; }
+.sidebar::-webkit-scrollbar-track { background: transparent; }
+.sidebar::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.sidebar::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* Sidebar Filter Tabs */
+.sidebar-filter {
+    display: flex;
+    gap: var(--sp-xs);
+    padding: 0 var(--sp-xs);
+    margin-bottom: var(--sp-lg);
+}
+
+.sidebar-filter-btn {
+    flex: 1;
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-secondary);
+    font-family: var(--font-body);
+    font-size: 12px;
+    font-weight: 600;
+    padding: var(--sp-sm) 0;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.sidebar-filter-btn:hover {
+    background: var(--bg-hover);
+    border-color: var(--accent);
+    color: var(--text-primary);
+}
+
+.sidebar-filter-btn.active {
+    background: var(--tint-accent);
+    border-color: var(--accent);
+    color: var(--accent);
+}
+
+.sidebar-section {
+    margin-bottom: var(--sp-xl);
+}
+
+.sidebar-section-title {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--sidebar-text-sec);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    margin-bottom: var(--sp-md);
+    padding: 0 var(--sp-lg);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: var(--sp-sm);
+    user-select: none;
+}
+
+.sidebar-section-title:hover {
+    color: var(--sidebar-text);
+}
+
+.sidebar-chevron {
+    display: inline-block;
+    font-size: 14px;
+    transition: transform 0.2s ease;
+    transform: rotate(-90deg);
+}
+
+.sidebar-chevron.open {
+    transform: rotate(0deg);
+}
+
+.sidebar-section-count {
+    margin-left: auto;
+    font-size: 10px;
+    color: var(--text-disabled);
+    font-weight: 400;
+}
+
+.incident-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg);
+    border-radius: var(--radius);
+    cursor: pointer;
+    transition: background 0.2s ease;
+    position: relative;
+}
+
+.incident-item:hover {
+    background: var(--sidebar-hover-bg);
+}
+
+.incident-item:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+}
+
+.incident-item.active {
+    background: var(--bg-secondary);
+}
+
+.incident-item.active::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    width: 3px;
+    height: 24px;
+    background: var(--sidebar-active);
+    border-radius: 0 2px 2px 0;
+}
+
+.incident-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.incident-dot.active {
+    background: var(--success);
+}
+
+.incident-dot.archived {
+    background: var(--text-disabled);
+}
+
+.incident-dot.has-notification {
+    background: var(--warning);
+    animation: pulse 2s ease-in-out infinite;
+}
+
+.incident-dot.refreshing {
+    background: var(--accent);
+    animation: dotPulse 1.5s ease-in-out infinite;
+    box-shadow: var(--glow-accent-strong);
+}
+
+.incident-dot.refresh-error {
+    background: var(--error);
+    animation: dotFlash 0.6s ease-out;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+@keyframes dotPulse {
+    0%, 100% {
+        opacity: 1;
+        box-shadow: var(--glow-accent);
+        transform: scale(1);
+    }
+    50% {
+        opacity: 0.6;
+        box-shadow: var(--glow-accent-strong);
+        transform: scale(1.4);
+    }
+}
+
+@keyframes dotFlash {
+    0% { opacity: 1; transform: scale(1.6); }
+    100% { opacity: 1; transform: scale(1); }
+}
+
+.incident-name {
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--sidebar-text);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    flex: 1;
+}
+
+.incident-meta {
+    font-size: 11px;
+    color: var(--sidebar-text-sec);
+}
+
+.sidebar-stats {
+    margin-top: auto;
+    padding: var(--sp-xl) var(--sp-lg);
+    border-top: 1px solid var(--border);
+}
+
+.stat-row {
+    display: flex;
+    justify-content: space-between;
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-xs);
+}
+
+.stat-value {
+    color: var(--text-primary);
+    font-weight: 600;
+}
+
+/* === Main Content === */
+.main-content {
+    overflow-y: auto;
+    padding: var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-2xl);
+    background: var(--bg-primary);
+    scrollbar-width: thin;
+    scrollbar-color: var(--text-disabled) transparent;
+}
+
+.main-content::-webkit-scrollbar { width: 6px; }
+.main-content::-webkit-scrollbar-track { background: transparent; }
+.main-content::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.main-content::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+#incident-view {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-2xl);
+}
+
+/* === Cards === */
+.card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-3xl);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: var(--sp-xl);
+}
+
+.card-title {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+/* === Incident Header Strip === */
+.incident-header-strip {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-xl) var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    flex-shrink: 0;
+}
+
+/* Zeile 0: Typ-Badge + Auto-Refresh-Indicator */
+.incident-header-row0 {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+}
+
+.auto-refresh-indicator {
+    font-size: 11px;
+    color: var(--accent);
+    font-weight: 500;
+}
+
+/* Zeile 1: Badge + Titel + Buttons */
+.incident-header-row1 {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-xl);
+}
+
+.incident-header-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    min-width: 0;
+    flex: 1;
+}
+
+.incident-header-title {
+    font-family: var(--font-title);
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    margin: 0;
+}
+
+.incident-header-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-shrink: 0;
+}
+
+/* Zeile 2: Creator + Beschreibung + Reliability + Meta */
+.incident-header-row2 {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-xl);
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+}
+
+.incident-header-row2-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    flex: 1;
+    min-width: 0;
+}
+
+.incident-creator-badge {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    flex-shrink: 0;
+}
+
+.incident-creator-badge strong {
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.incident-header-row2-right {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+    flex-shrink: 0;
+}
+
+.header-divider {
+    width: 1px;
+    height: 16px;
+    background: var(--border);
+    flex-shrink: 0;
+}
+
+/* Typ-Badge */
+.incident-type-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: var(--sp-xxs) var(--sp-md);
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    flex-shrink: 0;
+}
+.incident-type-badge.type-adhoc {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+.incident-type-badge.type-research {
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+}
+
+/* === Analyse-Bereich: Cards in gridstack === */
+.incident-analysis-summary {
+    display: flex;
+    flex-direction: column;
+}
+
+.incident-analysis-summary > .card-header {
+    flex-shrink: 0;
+}
+
+.incident-analysis-summary > #summary-content {
+    overflow-y: auto;
+    flex: 1;
+    min-height: 0;
+    background: var(--bg-primary);
+    border-radius: 0 0 var(--radius) var(--radius);
+    padding: var(--sp-lg);
+}
+
+.incident-analysis-factcheck {
+    display: flex;
+    flex-direction: column;
+}
+
+.incident-analysis-factcheck > .card-header {
+    flex-shrink: 0;
+}
+
+.incident-analysis-factcheck > .factcheck-list {
+    overflow-y: auto;
+    flex: 1;
+    min-height: 0;
+}
+
+/* Timeline-Card volle Breite */
+.timeline-card {
+    flex-shrink: 0;
+}
+
+.incident-description-text {
+    font-size: 12px;
+    color: var(--text-disabled);
+    line-height: 1.4;
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.summary-text {
+    font-size: 14px;
+    line-height: 1.7;
+    color: var(--text-secondary);
+    white-space: pre-wrap;
+}
+
+.summary-meta {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+}
+
+/* === Faktencheck Card === */
+.factcheck-list {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-sm);
+}
+
+.factcheck-item {
+    display: flex;
+    align-items: flex-start;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg);
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    background: var(--bg-primary);
+}
+
+.factcheck-icon {
+    flex-shrink: 0;
+    width: 24px;
+    height: 24px;
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 12px;
+    font-weight: 700;
+    margin-top: 1px;
+}
+
+.factcheck-icon.confirmed {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.factcheck-icon.unconfirmed {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.factcheck-icon.contradicted {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.factcheck-icon.developing {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.factcheck-icon.established {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.factcheck-icon.disputed {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.factcheck-icon.unverified {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.factcheck-claim {
+    font-size: 13px;
+    color: var(--text-primary);
+    flex: 1;
+}
+
+.factcheck-sources {
+    font-size: 11px;
+    color: var(--text-disabled);
+    margin-top: var(--sp-xxs);
+}
+
+/* === Faktencheck Filter-Dropdown === */
+.fc-filter-bar {
+    position: relative;
+    margin-left: auto;
+}
+
+.fc-dropdown-toggle {
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 3px 10px;
+    font-size: 11px;
+    font-family: var(--font-body);
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: border-color 0.15s, color 0.15s;
+}
+
+.fc-dropdown-toggle:hover {
+    border-color: var(--accent);
+    color: var(--text-primary);
+}
+
+.fc-dropdown-menu {
+    display: none;
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: 4px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 4px 0;
+    min-width: 180px;
+    box-shadow: var(--shadow-sm);
+    z-index: 20;
+}
+
+.fc-dropdown-menu.open {
+    display: block;
+}
+
+.fc-dropdown-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-sm) var(--sp-lg);
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--text-primary);
+    transition: background 0.1s;
+}
+
+.fc-dropdown-item:hover {
+    background: var(--bg-hover);
+}
+
+.fc-dropdown-item input[type="checkbox"] {
+    accent-color: var(--accent);
+    width: 14px;
+    height: 14px;
+    cursor: pointer;
+}
+
+.fc-dropdown-item .factcheck-icon {
+    width: 20px;
+    height: 20px;
+    font-size: 10px;
+}
+
+.fc-dropdown-label {
+    flex: 1;
+}
+
+.fc-dropdown-count {
+    font-size: 11px;
+    color: var(--text-disabled);
+    font-weight: 600;
+}
+
+/* === Evidence Block (Faktencheck) === */
+.evidence-block {
+    margin-top: var(--sp-sm);
+}
+
+.evidence-text {
+    font-size: 11px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+    display: block;
+    margin-bottom: var(--sp-xs);
+}
+
+.evidence-empty {
+    font-size: 11px;
+    color: var(--text-disabled);
+}
+
+.evidence-chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--sp-xs);
+}
+
+.evidence-chip {
+    display: inline-flex;
+    align-items: center;
+    padding: 1px 6px;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    font-size: 10px;
+    color: var(--text-secondary);
+    text-decoration: none;
+    max-width: 180px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.evidence-chip:hover {
+    background: var(--bg-hover);
+    color: var(--accent);
+}
+
+/* === Visueller Zeitstrahl (.vt-*) === */
+.vt-timeline {
+    position: relative;
+    padding-left: 48px;
+    overflow-y: auto;
+    max-height: 400px;
+    scroll-behavior: smooth;
+}
+
+/* Vertikale Achse */
+.vt-timeline::before {
+    content: '';
+    position: absolute;
+    left: 23px;
+    top: 0;
+    bottom: 0;
+    width: 2px;
+    background: var(--border);
+}
+
+/* Scrollbar */
+.vt-timeline::-webkit-scrollbar { width: 6px; }
+.vt-timeline::-webkit-scrollbar-track { background: var(--bg-primary); border-radius: 3px; }
+.vt-timeline::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.vt-timeline::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* Zeitgruppe */
+.vt-time-group {
+    position: relative;
+}
+
+/* Zeitgruppen-Label (Raute auf der Achse) */
+.vt-time-label {
+    position: sticky;
+    top: 0;
+    z-index: 2;
+    padding: var(--sp-md) 0;
+    margin-left: -48px;
+    padding-left: 48px;
+    background: var(--bg-card);
+}
+
+.vt-time-label::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    top: 50%;
+    width: 10px;
+    height: 10px;
+    background: var(--accent);
+    transform: translateY(-50%) rotate(45deg);
+    z-index: 3;
+}
+
+.vt-time-label-text {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    font-weight: 700;
+    color: var(--accent);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+/* Basis-Eintrag (Artikel) */
+.vt-entry {
+    position: relative;
+    padding: var(--sp-md) 0;
+    padding-right: var(--sp-xl);
+    transition: background 0.15s ease;
+    cursor: default;
+}
+
+/* Achsen-Punkt (Artikel = kleiner grauer Kreis) */
+.vt-entry::before {
+    content: '';
+    position: absolute;
+    left: -30px;
+    top: 14px;
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    border: 2px solid var(--bg-card);
+    z-index: 1;
+    transition: background 0.2s ease, box-shadow 0.2s ease;
+}
+
+.vt-entry:hover {
+    background: var(--tint-hover);
+}
+
+/* Expandierbarer Eintrag */
+.vt-entry.expandable {
+    cursor: pointer;
+}
+
+/* Aufklapp-Dreieck */
+.vt-entry.expandable::after {
+    content: '\25B8';
+    position: absolute;
+    right: 12px;
+    top: 14px;
+    font-size: 10px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease, color 0.2s ease;
+}
+
+/* Expanded: Punkt Gold, Dreieck rotiert */
+.vt-entry.expanded::before {
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+}
+
+.vt-entry.expanded::after {
+    transform: rotate(90deg);
+    color: var(--accent);
+}
+
+/* Lagebericht-Eintrag (großer goldener Punkt + Glow) */
+.vt-entry.vt-snapshot::before {
+    width: 14px;
+    height: 14px;
+    left: -32px;
+    top: 12px;
+    background: var(--accent);
+    border: 2px solid var(--bg-card);
+    box-shadow: var(--glow-accent);
+}
+
+.vt-entry.vt-snapshot {
+    background: var(--tint-accent-faint);
+    border-radius: var(--radius);
+    margin: var(--sp-xs) 0;
+}
+
+.vt-entry.vt-snapshot:hover {
+    background: var(--tint-accent-subtle);
+}
+
+/* Artikel-Header (Zeit + Quelle + Lang-Badge) */
+.vt-article-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+}
+
+.vt-article-time {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    color: var(--accent);
+    font-weight: 600;
+    white-space: nowrap;
+}
+
+.vt-article-source {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.vt-article-source a {
+    color: var(--text-disabled);
+    text-decoration: none;
+}
+
+.vt-article-source a:hover {
+    color: var(--accent);
+}
+
+/* Headline */
+.vt-article-headline {
+    font-size: 13px;
+    color: var(--text-primary);
+    line-height: 1.4;
+    margin-top: var(--sp-xxs);
+}
+
+/* Aufklapp-Bereich */
+.vt-article-detail {
+    display: none;
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+    margin-top: var(--sp-sm);
+}
+
+.vt-entry.expanded .vt-article-detail {
+    display: block;
+}
+
+.vt-article-detail-content {
+    font-size: 12px;
+    color: var(--text-secondary);
+    line-height: 1.6;
+    max-height: 150px;
+    overflow-y: auto;
+}
+
+.vt-article-detail-link {
+    display: inline-block;
+    margin-top: var(--sp-sm);
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--accent);
+    text-decoration: none;
+}
+
+.vt-article-detail-link:hover {
+    color: var(--accent-hover);
+}
+
+/* Snapshot-Header (Badge + Zeit + Stats) */
+.vt-snapshot-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-wrap: wrap;
+}
+
+.vt-snapshot-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+}
+
+.vt-snapshot-time {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.vt-snapshot-stats {
+    font-size: 11px;
+    color: var(--text-secondary);
+}
+
+/* Snapshot-Vorschau (2 Zeilen, collapsed) */
+.vt-snapshot-preview {
+    font-size: 12px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+    margin-top: var(--sp-xs);
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+/* Snapshot-Detail (expanded → volle Zusammenfassung) */
+.vt-snapshot-detail {
+    display: none;
+    margin-top: var(--sp-md);
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+}
+
+.vt-entry.vt-snapshot.expanded .vt-snapshot-preview {
+    display: none;
+}
+
+.vt-entry.vt-snapshot.expanded .vt-snapshot-detail {
+    display: block;
+}
+
+/* Cluster-Badge */
+.vt-cluster-count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 18px;
+    height: 18px;
+    padding: 0 5px;
+    border-radius: 9px;
+    font-size: 10px;
+    font-weight: 700;
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+    margin-left: var(--sp-sm);
+}
+
+/* Modal-Version */
+.modal-content-viewer .vt-timeline {
+    max-height: none;
+    padding-left: 52px;
+}
+
+.modal-content-viewer .vt-timeline::before {
+    left: 27px;
+}
+
+/* === Sprach-Badge === */
+.lang-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 0 4px;
+    border-radius: 2px;
+    font-size: 9px;
+    font-weight: 700;
+    letter-spacing: 0.5px;
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+    flex-shrink: 0;
+}
+
+/* === Quellenübersicht === */
+.source-overview-card {
+    flex-shrink: 0;
+}
+
+.source-overview-card .card-header {
+    margin-bottom: var(--sp-lg);
+}
+
+.source-overview-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: var(--sp-lg);
+    flex-wrap: wrap;
+    gap: var(--sp-md);
+}
+
+.source-overview-stat {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+.source-lang-chips {
+    display: flex;
+    gap: var(--sp-sm);
+}
+
+.source-lang-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 11px;
+    color: var(--text-secondary);
+    background: var(--bg-secondary);
+}
+
+.source-lang-chip strong {
+    color: var(--text-primary);
+}
+
+.source-overview-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+    gap: var(--sp-sm);
+}
+
+.source-overview-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-lg);
+    border-radius: var(--radius);
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+}
+
+.source-overview-name {
+    font-size: 12px;
+    font-weight: 500;
+    color: var(--text-primary);
+    flex: 1;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-overview-lang {
+    font-size: 10px;
+    color: var(--text-disabled);
+    flex-shrink: 0;
+}
+
+.source-overview-count {
+    font-size: 12px;
+    font-weight: 700;
+    color: var(--accent);
+    background: var(--tint-accent);
+    padding: 1px 6px;
+    border-radius: var(--radius);
+    flex-shrink: 0;
+}
+
+/* === Badges === */
+.badge {
+    display: inline-flex;
+    align-items: center;
+    padding: var(--sp-xxs) var(--sp-md);
+    border-radius: var(--radius);
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.badge-verified {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.badge-unverified {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.badge-contradicted {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.badge-auto {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+
+.badge-research {
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+}
+
+.badge-private {
+    background: var(--tint-error);
+    color: var(--cat-nachrichtenagentur);
+}
+
+/* === Modal === */
+.modal-overlay {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: var(--backdrop);
+    backdrop-filter: blur(4px);
+    z-index: 100;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-overlay.active {
+    display: flex;
+}
+
+.modal {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    width: 100%;
+    max-width: 520px;
+    max-height: 90vh;
+    overflow-y: auto;
+}
+
+.modal-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-xl) var(--sp-3xl);
+    border-bottom: 1px solid var(--border);
+}
+
+.modal-title {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    font-size: 20px;
+    cursor: pointer;
+    padding: var(--sp-xs) var(--sp-md);
+    border-radius: var(--radius);
+    transition: all 0.2s ease;
+    line-height: 1;
+}
+
+.modal-close:hover {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.modal-body {
+    padding: var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-xl);
+}
+
+.modal-footer {
+    padding: var(--sp-xl) var(--sp-3xl);
+    border-top: 1px solid var(--border);
+    display: flex;
+    justify-content: flex-end;
+    gap: var(--sp-lg);
+}
+
+/* === Conditional Field === */
+.conditional-field {
+    display: none;
+}
+
+.conditional-field.visible {
+    display: block;
+}
+
+/* === Toast Notifications === */
+.toast-container {
+    position: fixed;
+    top: 72px;
+    right: var(--sp-3xl);
+    z-index: 200;
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    pointer-events: none;
+}
+
+.toast {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    box-shadow: var(--shadow-md);
+    pointer-events: auto;
+    animation: slideIn 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    max-width: 380px;
+    border-left: 3px solid var(--accent);
+}
+
+.toast.toast-warning {
+    border-left-color: var(--warning);
+}
+
+.toast.toast-error {
+    border-left-color: var(--error);
+}
+
+.toast.toast-success {
+    border-left-color: var(--success);
+}
+
+.toast.toast-info {
+    border-left-color: var(--info);
+}
+
+.toast-text {
+    font-size: 13px;
+    color: var(--text-primary);
+    line-height: 1.4;
+}
+
+@keyframes slideIn {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
+/* === Empty State === */
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: var(--sp-5xl) var(--sp-4xl);
+    text-align: center;
+}
+
+.empty-state-icon {
+    font-size: 48px;
+    margin-bottom: var(--sp-xl);
+    opacity: 0.2;
+    color: var(--text-secondary);
+}
+
+.empty-state-title {
+    font-family: var(--font-title);
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-md);
+}
+
+.empty-state-text {
+    font-size: 13px;
+    color: var(--text-disabled);
+    max-width: 320px;
+}
+
+/* === Loading Spinner === */
+.spinner {
+    width: 24px;
+    height: 24px;
+    border: 3px solid var(--border);
+    border-top-color: var(--accent);
+    border-radius: 50%;
+    animation: rotate 1s linear infinite;
+}
+
+@keyframes rotate {
+    to { transform: rotate(360deg); }
+}
+
+.loading-overlay {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--sp-lg);
+    padding: var(--sp-3xl);
+    color: var(--text-secondary);
+    font-size: 13px;
+}
+
+/* === Fortschrittsanzeige === */
+.progress-bar {
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-xl);
+    margin-bottom: var(--sp-xl);
+    position: relative;
+}
+
+.progress-steps {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: var(--sp-lg);
+}
+
+.progress-step {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    font-size: 12px;
+    color: var(--text-disabled);
+    transition: color 0.3s ease;
+}
+
+.progress-step.active {
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.progress-step.done {
+    color: var(--success);
+}
+
+.progress-step-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    transition: all 0.3s ease;
+    flex-shrink: 0;
+}
+
+.progress-step.active .progress-step-dot {
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
+.progress-step.done .progress-step-dot {
+    background: var(--success);
+}
+
+.progress-track {
+    height: 4px;
+    background: var(--bg-secondary);
+    border-radius: 2px;
+    overflow: hidden;
+    margin-bottom: var(--sp-md);
+}
+
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent), var(--success));
+    border-radius: 2px;
+    transition: width 0.5s ease-out;
+    width: 0%;
+}
+
+.progress-label-container {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: var(--sp-md);
+    position: relative;
+}
+
+.progress-label {
+    font-size: 12px;
+    color: var(--text-secondary);
+}
+
+.progress-timer {
+    font-family: var(--font-mono, 'Courier New', monospace);
+    color: var(--text-disabled);
+    font-size: 12px;
+}
+
+.progress-cancel-btn {
+    position: absolute;
+    right: var(--sp-xl);
+    bottom: var(--sp-lg);
+    background: none;
+    border: none;
+    color: var(--text-disabled);
+    font-size: 11px;
+    cursor: pointer;
+    text-decoration: underline;
+    padding: 2px 4px;
+    transition: color 0.2s ease;
+}
+
+.progress-cancel-btn:hover {
+    color: var(--error);
+}
+
+.progress-bar--complete .progress-cancel-btn,
+.progress-bar--error .progress-cancel-btn {
+    display: none;
+}
+
+.progress-bar--complete .progress-fill {
+    background: linear-gradient(90deg, var(--success), #34D399);
+    width: 100% !important;
+}
+
+.progress-bar--complete .progress-label {
+    color: var(--success);
+    font-weight: 600;
+}
+
+.progress-bar--error .progress-fill {
+    background: linear-gradient(90deg, var(--error), #F87171);
+}
+
+.progress-bar--error .progress-label {
+    color: var(--error);
+}
+
+/* === Briefing === */
+.briefing-content {
+    font-size: 14px;
+    line-height: 1.8;
+    color: var(--text-secondary);
+}
+
+.briefing-content strong {
+    color: var(--text-primary);
+}
+
+.briefing-heading {
+    font-size: 15px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-top: var(--sp-xl);
+    margin-bottom: var(--sp-xs);
+    padding-bottom: 0;
+    border-bottom: none;
+}
+
+.briefing-content .briefing-heading:first-child {
+    margin-top: 0;
+}
+
+/* === Form Hint === */
+.form-hint {
+    font-size: 11px;
+    color: var(--text-disabled);
+    margin-top: var(--sp-xs);
+}
+
+/* === Inline-Zitate === */
+.citation {
+    color: var(--accent);
+    text-decoration: none;
+    font-size: 11px;
+    vertical-align: super;
+    font-weight: 600;
+}
+.citation:hover {
+    text-decoration: underline;
+}
+
+/* === Quellenverzeichnis (im Lagebild) === */
+.source-list {
+    margin-top: 16px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border);
+}
+.source-list-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-disabled);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+}
+.source-list-item {
+    font-size: 12px;
+    color: var(--text-secondary);
+    padding: 2px 0;
+}
+.source-list-item a {
+    color: var(--text-primary);
+}
+.source-list-item a:hover {
+    color: var(--accent);
+}
+.source-nr {
+    color: var(--accent);
+    font-weight: 600;
+    margin-right: 4px;
+}
+
+/* === Timeline Filter === */
+.timeline-filter-input {
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: 4px 8px;
+    font-size: 12px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    width: 140px;
+}
+.timeline-filter-input:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+    border-color: var(--accent);
+}
+.timeline-filter-input::placeholder {
+    color: var(--text-disabled);
+}
+.timeline-filter-select {
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: 4px 8px;
+    font-size: 12px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    cursor: pointer;
+    appearance: none;
+    padding-right: 20px;
+    background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238896AB' stroke-width='2'%3e%3cpolyline points='6 9 12 15 18 9'/%3e%3c/svg%3e");
+    background-repeat: no-repeat;
+    background-position: right 4px center;
+    background-size: 12px;
+}
+
+/* === Horizontale Timeline (ht-*) === */
+
+/* Controls-Leiste */
+.ht-controls {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    flex-wrap: wrap;
+}
+
+/* Filter-/Range-Gruppen (Pill-Toggle) */
+.ht-filter-group,
+.ht-range-group {
+    display: flex;
+    border-radius: var(--radius);
+    overflow: hidden;
+    border: 1px solid var(--border);
+}
+
+.ht-filter-btn,
+.ht-range-btn,
+.ht-modal-filter-btn {
+    padding: 3px 10px;
+    font-size: 11px;
+    font-weight: 600;
+    font-family: var(--font-body);
+    border: none;
+    background: transparent;
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+}
+
+.ht-filter-btn:hover,
+.ht-range-btn:hover,
+.ht-modal-filter-btn:hover {
+    color: var(--text-primary);
+    background: var(--tint-accent-subtle);
+}
+
+.ht-filter-btn.active,
+.ht-range-btn.active,
+.ht-modal-filter-btn.active {
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+}
+
+/* Zähler + integrierte Legende */
+.ht-count {
+    font-size: 12px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+}
+
+.ht-legend-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    vertical-align: middle;
+    margin-right: 2px;
+}
+
+.ht-legend-dot.ht-legend-gold {
+    background: var(--accent);
+}
+
+/* Timeline-Container */
+.ht-timeline-container {
+    padding: 12px 20px 8px;
+}
+
+/* Achsen-Container */
+.ht-axis {
+    position: relative;
+    height: 110px;
+}
+
+/* Stündliches Layout: höher wegen Datums-Markern oben */
+.ht-axis--hourly {
+    height: 130px;
+}
+
+/* Punkte-Bereich (über der Linie) */
+.ht-points {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 0;
+    height: 56px;
+}
+
+.ht-axis--hourly .ht-points {
+    top: 20px;
+}
+
+/* Achsenlinie */
+.ht-axis-line {
+    position: absolute;
+    left: 2%;
+    right: 2%;
+    top: 60px;
+    height: 2px;
+    background: var(--border);
+}
+
+.ht-axis--hourly .ht-axis-line {
+    top: 80px;
+}
+
+/* Datums-Marker (vertikale Linie + Datum oben, nur bei Stunden-Granularität) */
+.ht-day-markers {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 0;
+    bottom: 0;
+    pointer-events: none;
+}
+
+.ht-day-marker {
+    position: absolute;
+    top: 0;
+}
+
+.ht-day-marker-label {
+    position: absolute;
+    top: 0;
+    left: 0;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    font-weight: 600;
+    color: var(--accent);
+    white-space: nowrap;
+}
+
+.ht-day-marker-line {
+    position: absolute;
+    top: 14px;
+    height: 66px;
+    width: 1px;
+    left: 0;
+    background: var(--accent);
+    opacity: 0.2;
+}
+
+/* Punkt (Basis) */
+.ht-point {
+    position: absolute;
+    bottom: 0;
+    transform: translateX(-50%);
+    border-radius: 50%;
+    background: var(--text-disabled);
+    border: 2px solid var(--bg-card);
+    cursor: pointer;
+    transition: all 0.2s ease;
+    z-index: 2;
+}
+
+.ht-point:hover {
+    box-shadow: var(--glow-accent);
+    z-index: 4;
+}
+
+.ht-point.active {
+    box-shadow: var(--glow-accent-strong);
+    z-index: 4;
+}
+
+/* Dimmen: nicht-aktive Punkte verblassen wenn ein Punkt aktiv ist */
+.ht-points:has(.ht-point.active) .ht-point:not(.active) {
+    opacity: 0.3;
+    transition: opacity 0.3s ease;
+}
+
+/* Pfeil über dem aktiven Punkt */
+.ht-point.active::after {
+    content: '▼';
+    position: absolute;
+    bottom: calc(100% + 2px);
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 10px;
+    color: var(--accent);
+    pointer-events: none;
+    line-height: 1;
+}
+
+/* Snapshot-Punkt (Raute) */
+.ht-point.ht-snapshot-point {
+    border-radius: 2px;
+    transform: translateX(-50%) rotate(45deg);
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+}
+
+.ht-point.ht-snapshot-point .ht-tooltip,
+.ht-point.ht-snapshot-point .ht-point-count {
+    transform: rotate(-45deg);
+}
+
+.ht-point.ht-snapshot-point .ht-tooltip {
+    transform: rotate(-45deg) translateX(-50%);
+    transform-origin: bottom left;
+}
+
+/* Gemischter Punkt (Gold-Kreis) */
+.ht-point.ht-mixed-point {
+    background: var(--accent);
+    border: 2px solid var(--bg-card);
+}
+
+/* Tooltip (über dem Punkt) */
+.ht-tooltip {
+    position: absolute;
+    bottom: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    font-size: 11px;
+    padding: 3px 8px;
+    border-radius: var(--radius);
+    white-space: nowrap;
+    pointer-events: none;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.15s ease, visibility 0.15s ease;
+    border: 1px solid var(--border);
+    z-index: 10;
+}
+
+.ht-point:hover .ht-tooltip {
+    opacity: 1;
+    visibility: visible;
+}
+
+/* Zahl unter dem Punkt */
+.ht-point-count {
+    position: absolute;
+    top: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    white-space: nowrap;
+    pointer-events: none;
+}
+
+.ht-point.active .ht-point-count,
+.ht-point:hover .ht-point-count {
+    color: var(--accent);
+}
+
+/* Achsen-Labels (unter der Linie) */
+.ht-axis-labels {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 72px;
+    height: 20px;
+}
+
+.ht-axis--hourly .ht-axis-labels {
+    top: 90px;
+}
+
+.ht-axis-label {
+    position: absolute;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-tertiary);
+    white-space: nowrap;
+}
+
+/* Leerer Zustand */
+.ht-empty {
+    padding: 20px;
+    text-align: center;
+    font-size: 13px;
+    color: var(--text-tertiary);
+}
+
+/* Detail-Panel */
+.ht-detail-panel {
+    margin-top: 8px;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg-secondary);
+    animation: ht-slide-down 0.2s ease;
+}
+
+@keyframes ht-slide-down {
+    from { opacity: 0; transform: translateY(-8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.ht-detail-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border);
+}
+
+.ht-detail-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--accent);
+    font-family: var(--font-mono);
+}
+
+.ht-detail-close {
+    background: none;
+    border: none;
+    color: var(--text-disabled);
+    font-size: 18px;
+    cursor: pointer;
+    padding: 0 4px;
+    line-height: 1;
+}
+
+.ht-detail-close:hover {
+    color: var(--text-primary);
+}
+
+.ht-detail-content {
+    max-height: 350px;
+    overflow-y: auto;
+    padding: 4px 12px;
+}
+
+.ht-detail-content::-webkit-scrollbar { width: 6px; }
+.ht-detail-content::-webkit-scrollbar-track { background: var(--bg-primary); border-radius: 3px; }
+.ht-detail-content::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.ht-detail-content::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* === Briefing Listen === */
+.briefing-content ul {
+    margin: 8px 0;
+    padding-left: 20px;
+}
+.briefing-content li {
+    margin: 4px 0;
+    font-size: 13px;
+    color: var(--text-secondary);
+}
+
+/* === Responsive === */
+
+@media (max-width: 768px) {
+    .dashboard {
+        grid-template-columns: 1fr;
+    }
+
+    .sidebar {
+        display: none;
+    }
+
+    .incident-header-row1 {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .incident-header-row2 {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .incident-header-row2-right {
+        flex-wrap: wrap;
+    }
+
+    .incident-header-actions {
+        width: 100%;
+        justify-content: flex-end;
+    }
+
+    .source-overview-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* === Toggle Switch === */
+.toggle-group {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-xs);
+}
+
+.toggle-label,
+.form-group .toggle-label {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    cursor: pointer;
+    user-select: none;
+    text-transform: none;
+    letter-spacing: normal;
+    font-weight: 400;
+    font-size: 13px;
+    color: var(--text-primary);
+    margin-bottom: 0;
+}
+
+.toggle-label input[type="checkbox"] {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+}
+
+.toggle-switch {
+    position: relative;
+    width: 36px;
+    min-width: 36px;
+    height: 20px;
+    background: var(--input-border);
+    border-radius: 10px;
+    transition: background 0.2s;
+    flex-shrink: 0;
+}
+
+.toggle-switch::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 16px;
+    height: 16px;
+    background: var(--text-secondary);
+    border-radius: 50%;
+    transition: transform 0.2s, background 0.2s;
+}
+
+.toggle-label input:checked + .toggle-switch {
+    background: var(--accent);
+}
+
+.toggle-label input:checked + .toggle-switch::after {
+    transform: translateX(16px);
+    background: var(--bg-primary);
+}
+
+.toggle-text {
+    font-size: 13px;
+    color: var(--text-primary);
+}
+
+/* International-Badge im Header */
+.intl-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+    font-size: 11px;
+    padding: 2px 8px;
+    border-radius: 3px;
+    font-weight: 500;
+}
+
+.intl-badge.intl-yes {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.intl-badge.intl-no {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+
+/* === Notification Center === */
+.notification-center {
+    position: relative;
+}
+
+.notification-bell {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: var(--sp-sm) var(--sp-md);
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.2s ease, background 0.2s ease;
+    position: relative;
+}
+
+.notification-bell:hover {
+    color: var(--accent);
+    background: var(--bg-hover);
+}
+
+.notification-badge {
+    position: absolute;
+    top: 0;
+    right: 0;
+    min-width: 16px;
+    height: 16px;
+    padding: 0 4px;
+    background: var(--error);
+    color: #fff;
+    font-size: 10px;
+    font-weight: 700;
+    font-family: var(--font-body);
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    line-height: 1;
+    pointer-events: none;
+    animation: badgePop 0.3s ease;
+}
+
+@keyframes badgePop {
+    0% { transform: scale(0); }
+    60% { transform: scale(1.3); }
+    100% { transform: scale(1); }
+}
+
+.notification-panel {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    width: 360px;
+    max-height: 480px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    z-index: 50;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.notification-panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-lg) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+.notification-panel-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.notification-mark-read {
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 11px;
+    font-weight: 600;
+    font-family: var(--font-body);
+    cursor: pointer;
+    padding: var(--sp-xxs) var(--sp-sm);
+    border-radius: var(--radius);
+    transition: background 0.2s ease;
+}
+
+.notification-mark-read:hover {
+    background: var(--tint-accent);
+}
+
+.notification-panel-list {
+    overflow-y: auto;
+    flex: 1;
+    max-height: 420px;
+}
+
+.notification-empty {
+    padding: var(--sp-3xl);
+    text-align: center;
+    font-size: 12px;
+    color: var(--text-disabled);
+}
+
+.notification-item {
+    display: flex;
+    align-items: flex-start;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    cursor: pointer;
+    transition: background 0.15s ease;
+}
+
+.notification-item:last-child {
+    border-bottom: none;
+}
+
+.notification-item:hover {
+    background: var(--bg-hover);
+}
+
+.notification-item.unread {
+    border-left: 3px solid var(--accent);
+    padding-left: calc(var(--sp-xl) - 3px);
+}
+
+.notification-item-icon {
+    width: 24px;
+    height: 24px;
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 11px;
+    font-weight: 700;
+    flex-shrink: 0;
+    margin-top: 1px;
+}
+
+.notification-item-icon.success {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.notification-item-icon.warning {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.notification-item-icon.error {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.notification-item-icon.info {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.notification-item-body {
+    flex: 1;
+    min-width: 0;
+}
+
+.notification-item-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.notification-item-text {
+    font-size: 11px;
+    color: var(--text-secondary);
+    line-height: 1.4;
+    margin-top: 1px;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+.notification-item-time {
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    white-space: nowrap;
+    flex-shrink: 0;
+    margin-top: 2px;
+}
+
+/* Notification Center Responsive */
+@media (max-width: 768px) {
+    .notification-panel {
+        width: calc(100vw - 32px);
+        right: -8px;
+    }
+}
+
+/* === Quellenverwaltung === */
+
+/* Wide Modal */
+.modal-wide {
+    max-width: 800px;
+}
+
+/* Content-Viewer Modal */
+.modal-content-viewer {
+    max-width: 900px;
+    height: 85vh;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.modal-content-viewer .modal-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+}
+
+.modal-header-extra {
+    margin-left: auto;
+    margin-right: 8px;
+}
+
+.modal-content-viewer .modal-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: var(--sp-2xl) var(--sp-3xl);
+    background: var(--bg-primary);
+    border-radius: 0 0 var(--radius-lg) var(--radius-lg);
+}
+
+/* Klickbare Sektionstitel */
+.card-title.clickable {
+    cursor: pointer;
+    transition: color 0.2s ease;
+}
+
+.card-title.clickable:hover {
+    color: var(--accent);
+}
+
+/* Detaillierte Quellenübersicht im Modal */
+.source-detail-group {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    margin-bottom: 6px;
+    overflow: hidden;
+}
+
+.source-detail-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: 10px 14px;
+    cursor: pointer;
+    background: var(--bg-secondary);
+    transition: background 0.15s ease;
+}
+
+.source-detail-header:hover {
+    background: var(--bg-hover);
+}
+
+.source-detail-toggle {
+    color: var(--text-disabled);
+    font-size: 12px;
+    transition: transform 0.2s ease;
+    flex-shrink: 0;
+}
+
+.source-detail-group.open .source-detail-toggle {
+    transform: rotate(90deg);
+}
+
+.source-detail-name {
+    flex: 1;
+    font-weight: 500;
+    color: var(--text-primary);
+    font-size: 13px;
+}
+
+.source-detail-articles {
+    display: none;
+    border-top: 1px solid var(--border);
+}
+
+.source-detail-group.open .source-detail-articles {
+    display: block;
+}
+
+.source-detail-article {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    padding: 8px 14px 8px 36px;
+    font-size: 12px;
+    border-bottom: 1px solid var(--border);
+}
+
+.source-detail-article:last-child {
+    border-bottom: none;
+}
+
+.source-detail-time {
+    color: var(--text-disabled);
+    flex-shrink: 0;
+    min-width: 90px;
+    font-family: var(--font-mono);
+    font-size: 11px;
+}
+
+.source-detail-headline {
+    flex: 1;
+    color: var(--text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.source-detail-link {
+    color: var(--accent);
+    text-decoration: none;
+    font-size: 14px;
+    flex-shrink: 0;
+    opacity: 0.6;
+    transition: opacity 0.15s ease;
+}
+
+.source-detail-link:hover {
+    opacity: 1;
+}
+
+/* Sidebar Sources Link */
+.sidebar-sources-link {
+    padding: var(--sp-lg) var(--sp-xl);
+    border-top: 1px solid var(--border);
+    margin-top: auto;
+}
+
+.sidebar-sources-link .btn {
+    margin-bottom: var(--sp-md);
+}
+
+.sidebar-feedback-btn {
+    margin-top: var(--sp-md);
+    opacity: 0.7;
+    font-size: 12px;
+}
+
+.sidebar-feedback-btn:hover {
+    opacity: 1;
+}
+
+.sidebar-stats-mini {
+    font-size: 11px;
+    color: var(--text-disabled);
+    text-align: center;
+}
+
+/* Stats-Leiste */
+.sources-stats-bar {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+    padding: var(--sp-lg);
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    margin-bottom: var(--sp-lg);
+    font-size: 12px;
+    color: var(--text-secondary);
+    flex-wrap: wrap;
+}
+
+.sources-stats-bar .sources-stat-item {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+}
+
+.sources-stats-bar .sources-stat-value {
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.sources-search-input {
+    width: 160px;
+}
+
+/* Toolbar */
+.sources-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-lg);
+    margin-bottom: var(--sp-lg);
+}
+
+.sources-filters {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-wrap: wrap;
+}
+
+/* Sources-Modal Body */
+.sources-modal-body {
+    padding: var(--sp-xl) var(--sp-3xl);
+}
+
+/* Inline-Formular Zeile */
+.sources-form-row {
+    display: flex;
+    gap: var(--sp-md);
+    align-items: flex-end;
+}
+
+.sources-form-row .form-group {
+    margin: 0;
+}
+
+.sources-form-row .form-group.flex-1 {
+    flex: 1;
+}
+
+.sources-form-row .btn {
+    height: 36px;
+    white-space: nowrap;
+}
+
+/* Discovery-Ergebnis */
+.sources-discovery-result {
+    margin-top: var(--sp-lg);
+}
+
+.sources-discovery-actions {
+    display: flex;
+    gap: var(--sp-md);
+    margin-top: var(--sp-lg);
+}
+
+/* Toolbar Button-Gruppe */
+.sources-toolbar-actions {
+    display: flex;
+    gap: var(--sp-md);
+}
+
+/* Readonly-Input */
+.input-readonly {
+    background: var(--bg-elevated);
+    color: var(--text-secondary);
+}
+
+.source-notes-input {
+    width: 200px;
+}
+
+/* Inline-Formular */
+.sources-add-form {
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-xl);
+    margin-bottom: var(--sp-lg);
+}
+
+.sources-add-form-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr 1fr;
+    gap: var(--sp-lg);
+}
+
+.sources-add-form-grid .form-group {
+    margin: 0;
+}
+
+.sources-add-form label:not(.toggle-label) {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-xs);
+    display: block;
+}
+
+.sources-add-form input,
+.sources-add-form select {
+    width: 100%;
+}
+
+/* Quellen-Liste */
+.sources-list {
+    max-height: 50vh;
+    overflow-y: auto;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+}
+
+.sources-list::-webkit-scrollbar {
+    width: 6px;
+}
+.sources-list::-webkit-scrollbar-track {
+    background: var(--bg-primary);
+}
+.sources-list::-webkit-scrollbar-thumb {
+    background: var(--text-disabled);
+    border-radius: 3px;
+}
+
+/* Source Row */
+.source-row {
+    display: grid;
+    grid-template-columns: 1fr 120px 90px 60px 40px 32px;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    transition: background 0.15s ease;
+    font-size: 13px;
+}
+
+.source-row:last-child {
+    border-bottom: none;
+}
+
+.source-row:hover {
+    background: var(--bg-hover);
+}
+
+.source-row-name {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+.source-row-name-text {
+    font-weight: 500;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-row-domain {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-row-count {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--accent);
+    text-align: center;
+}
+
+/* Kategorie-Badges */
+.source-category-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 600;
+    white-space: nowrap;
+    text-transform: uppercase;
+    letter-spacing: 0.3px;
+}
+
+.source-category-badge.cat-nachrichtenagentur {
+    background: var(--cat-nachrichtenagentur-bg);
+    color: var(--cat-nachrichtenagentur);
+}
+
+.source-category-badge.cat-oeffentlich-rechtlich {
+    background: var(--cat-oeffentlich-rechtlich-bg);
+    color: var(--cat-oeffentlich-rechtlich);
+}
+
+.source-category-badge.cat-qualitaetszeitung {
+    background: var(--cat-qualitaetszeitung-bg);
+    color: var(--cat-qualitaetszeitung);
+}
+
+.source-category-badge.cat-behoerde {
+    background: var(--cat-behoerde-bg);
+    color: var(--cat-behoerde);
+}
+
+.source-category-badge.cat-fachmedien {
+    background: var(--cat-fachmedien-bg);
+    color: var(--cat-fachmedien);
+}
+
+.source-category-badge.cat-think-tank {
+    background: var(--cat-think-tank-bg);
+    color: var(--cat-think-tank);
+}
+
+.source-category-badge.cat-international {
+    background: var(--cat-international-bg);
+    color: var(--cat-international);
+}
+
+.source-category-badge.cat-regional {
+    background: var(--cat-regional-bg);
+    color: var(--cat-regional);
+}
+
+.source-category-badge.cat-sonstige {
+    background: var(--cat-sonstige-bg);
+    color: var(--info);
+}
+
+/* Typ-Badges */
+.source-type-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 6px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 600;
+    white-space: nowrap;
+}
+
+.source-type-badge.type-rss_feed {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.source-type-badge.type-web_source {
+    background: var(--cat-oeffentlich-rechtlich-bg);
+    color: var(--cat-oeffentlich-rechtlich);
+}
+
+.source-type-badge.type-excluded {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+/* Active Toggle */
+.source-toggle {
+    position: relative;
+    width: 28px;
+    height: 16px;
+    background: var(--input-border);
+    border-radius: 8px;
+    cursor: pointer;
+    transition: background 0.2s;
+    border: none;
+    padding: 0;
+    flex-shrink: 0;
+}
+
+.source-toggle::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 12px;
+    height: 12px;
+    background: var(--text-secondary);
+    border-radius: 50%;
+    transition: transform 0.2s, background 0.2s;
+}
+
+.source-toggle.active {
+    background: var(--accent);
+}
+
+.source-toggle.active::after {
+    transform: translateX(12px);
+    background: var(--bg-primary);
+}
+
+/* Delete Button */
+.source-delete-btn {
+    background: none;
+    border: none;
+    color: var(--text-disabled);
+    cursor: pointer;
+    font-size: 14px;
+    padding: 2px 6px;
+    border-radius: var(--radius);
+    transition: color 0.2s, background 0.2s;
+    line-height: 1;
+}
+
+.source-delete-btn:hover {
+    color: var(--error);
+    background: var(--tint-error);
+}
+
+/* Domain-Gruppen */
+.source-group {
+    border-bottom: 1px solid var(--border);
+}
+
+.source-group:last-child {
+    border-bottom: none;
+}
+
+.source-group-header {
+    display: grid;
+    grid-template-columns: 20px 1fr auto auto auto;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-xl);
+    cursor: pointer;
+    transition: background 0.15s ease;
+    font-size: 13px;
+}
+
+.source-group-header:hover {
+    background: var(--bg-hover);
+}
+
+.source-group-header.expanded .source-group-toggle {
+    transform: rotate(90deg);
+}
+
+.source-group-toggle {
+    font-size: 10px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease;
+    display: inline-block;
+    width: 20px;
+    text-align: center;
+    user-select: none;
+}
+
+.source-group-toggle-placeholder {
+    width: 20px;
+    display: inline-block;
+}
+
+.source-group-info {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    min-width: 0;
+}
+
+.source-group-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    font-size: 14px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-group-notes {
+    font-size: 12px;
+    color: var(--text-disabled);
+    font-weight: 400;
+}
+
+.source-feed-count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 1px 8px;
+    border-radius: 9px;
+    font-size: 11px;
+    font-weight: 600;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    white-space: nowrap;
+}
+
+.source-group-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xs);
+}
+
+/* Gesperrte Domain */
+.source-group-header.excluded {
+    grid-template-columns: 1fr auto auto;
+    border-left: 3px solid var(--error);
+    opacity: 0.65;
+    cursor: default;
+}
+
+.source-group-header.excluded:hover {
+    opacity: 0.8;
+}
+
+.source-group-header.excluded .source-group-name {
+    color: var(--text-secondary);
+}
+
+.source-excluded-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 1px 6px;
+    border-radius: 9px;
+    font-size: 10px;
+    font-weight: 600;
+    background: var(--tint-error);
+    color: var(--error);
+    white-space: nowrap;
+    flex-shrink: 0;
+}
+
+/* Feed-Zeilen (aufklappbar) */
+.source-group-feeds {
+    display: none;
+    padding-left: 36px;
+    padding-bottom: var(--sp-sm);
+}
+
+.source-group-feeds.expanded {
+    display: block;
+}
+
+.source-feed-row {
+    display: grid;
+    grid-template-columns: 22px 1fr auto auto auto;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: 3px var(--sp-xl) 3px 0;
+    font-size: 12px;
+    color: var(--text-secondary);
+    transition: background 0.15s ease;
+}
+
+.source-feed-row:hover {
+    background: var(--bg-hover);
+    border-radius: var(--radius);
+}
+
+.source-feed-connector {
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    font-size: 12px;
+    white-space: pre;
+    user-select: none;
+}
+
+.source-feed-name {
+    font-weight: 500;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-feed-url {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 250px;
+}
+
+/* Block-Button */
+.btn.source-block-btn {
+    color: var(--error);
+    border-color: var(--tint-error-strong);
+}
+
+.btn.source-block-btn:hover {
+    background: var(--tint-error);
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .modal-wide {
+        max-width: 95vw;
+    }
+
+    .modal-content-viewer {
+        max-width: 95vw;
+        height: 90vh;
+    }
+
+    .source-group-header {
+        grid-template-columns: 20px 1fr auto auto;
+    }
+
+    .source-feed-row {
+        grid-template-columns: 22px 1fr auto auto;
+    }
+
+    .source-feed-url {
+        display: none;
+    }
+
+    .sources-add-form-grid {
+        grid-template-columns: 1fr 1fr;
+    }
+}
+
+/* === Lagebild Zeitstempel === */
+.lagebild-timestamp {
+    font-size: 12px;
+    font-weight: 400;
+    color: var(--text-primary);
+    margin-left: auto;
+}
+
+/* === Quellenübersicht Toggle === */
+.source-overview-header-toggle {
+    cursor: pointer;
+    user-select: none;
+}
+
+.source-overview-header-toggle:hover {
+    background: var(--tint-hover-subtle);
+}
+
+.source-overview-toggle-icon {
+    font-size: 11px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease;
+    margin-left: auto;
+}
+
+.source-overview-card .card-header.source-overview-header-toggle {
+    margin-bottom: 0;
+}
+
+.source-overview-card #source-overview-content:not([style*="none"]) {
+    margin-top: var(--sp-lg);
+}
+
+/* === Quellenübersicht Detailansicht-Button === */
+.btn.btn-secondary.source-detail-btn {
+    font-size: 11px;
+    padding: 3px 10px;
+    margin-left: auto;
+    opacity: 0.7;
+    transition: opacity 0.2s ease;
+}
+
+.source-detail-btn:hover {
+    opacity: 1;
+}
+
+/* === Quellenübersicht Chevron === */
+.source-overview-chevron {
+    font-size: 32px;
+    color: var(--accent);
+    transition: transform 0.2s ease, color 0.2s ease;
+    display: inline-block;
+    flex-shrink: 0;
+}
+
+.source-overview-chevron.open {
+    transform: rotate(90deg);
+}
+
+.source-overview-header-toggle:hover .source-overview-chevron {
+    color: var(--accent);
+}
+
+/* === Theme Toggle Button === */
+.theme-toggle-btn {
+    font-size: 18px;
+    width: 36px;
+    height: 36px;
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    cursor: pointer;
+    transition: background 0.2s, border-color 0.2s;
+}
+
+/* === Light Theme Sonderregeln === */
+[data-theme="light"] .sidebar {
+    border-right: 1px solid var(--border);
+    box-shadow: 1px 0 4px rgba(0, 0, 0, 0.04);
+}
+
+[data-theme="light"] .card {
+    box-shadow: var(--shadow-sm);
+}
+
+[data-theme="light"] .header {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06);
+}
+
+[data-theme="light"] ::-webkit-scrollbar-track {
+    background: #F0F1F3;
+}
+
+[data-theme="light"] ::-webkit-scrollbar-thumb {
+    background: #C4C9D4;
+}
+
+[data-theme="light"] ::-webkit-scrollbar-thumb:hover {
+    background: #A0A8B8;
+}
+
+[data-theme="light"] .login-container {
+    background: linear-gradient(135deg, #F4F5F7 0%, #E8EBF0 50%, #F0EDE6 100%);
+}
+
+[data-theme="light"] .modal {
+    box-shadow: var(--shadow-lg);
+}
+
+[data-theme="light"] .notification-panel {
+    box-shadow: var(--shadow-lg);
+}
+
+[data-theme="light"] .toast {
+    box-shadow: var(--shadow-md);
+}
+
+[data-theme="light"] .ht-detail-panel {
+    box-shadow: var(--shadow-sm);
+}
+
+/* === gridstack Dashboard-Layout === */
+.grid-stack {
+    min-height: 200px;
+}
+
+.grid-stack > .grid-stack-item > .grid-stack-item-content {
+    overflow: hidden;
+}
+
+.grid-stack-item-content > .card {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list,
+.grid-stack-item-content #timeline {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    min-height: 0;
+    scrollbar-width: thin;
+    scrollbar-color: var(--text-disabled) transparent;
+}
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content::-webkit-scrollbar,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list::-webkit-scrollbar,
+.grid-stack-item-content #timeline::-webkit-scrollbar { width: 6px; }
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content::-webkit-scrollbar-track,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list::-webkit-scrollbar-track,
+.grid-stack-item-content #timeline::-webkit-scrollbar-track { background: transparent; border-radius: 3px; }
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content::-webkit-scrollbar-thumb,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list::-webkit-scrollbar-thumb,
+.grid-stack-item-content #timeline::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content::-webkit-scrollbar-thumb:hover,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list::-webkit-scrollbar-thumb:hover,
+.grid-stack-item-content #timeline::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* Quellenübersicht: Kachel wächst beim Aufklappen via resizeTileToContent */
+.grid-stack-item-content #source-overview-content {
+    overflow-y: auto;
+    scrollbar-width: thin;
+    scrollbar-color: var(--text-disabled) transparent;
+}
+
+.grid-stack-item-content #source-overview-content::-webkit-scrollbar { width: 6px; }
+.grid-stack-item-content #source-overview-content::-webkit-scrollbar-track { background: transparent; border-radius: 3px; }
+.grid-stack-item-content #source-overview-content::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.grid-stack-item-content #source-overview-content::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+.grid-stack-item-content .incident-analysis-summary,
+.grid-stack-item-content .incident-analysis-factcheck {
+    max-height: none;
+    overflow: hidden;
+}
+
+.grid-stack .card-header {
+    cursor: grab;
+}
+
+.grid-stack .card-header:active {
+    cursor: grabbing;
+}
+
+.grid-stack-item > .ui-resizable-se {
+    width: 16px;
+    height: 16px;
+    opacity: 0;
+    transition: opacity 0.2s;
+}
+
+.grid-stack-item:hover > .ui-resizable-se {
+    opacity: 0.5;
+}
+
+/* Layout-Toolbar */
+.layout-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-md) 0;
+}
+
+.layout-toggles {
+    display: flex;
+    gap: var(--sp-sm);
+}
+
+.layout-toggle-btn {
+    padding: var(--sp-xs) var(--sp-lg);
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    background: transparent;
+    color: var(--text-disabled);
+    font-size: 12px;
+    font-family: var(--font-body);
+    cursor: pointer;
+    transition: all 0.2s;
+    text-decoration: line-through;
+}
+
+.layout-toggle-btn.active {
+    background: var(--tint-accent);
+    color: var(--accent);
+    border-color: var(--accent);
+    text-decoration: none;
+}
+
+.layout-toggle-btn:hover {
+    border-color: var(--accent);
+}
+
+/* Temporäre Messklasse: hebt alle Höhenbeschränkungen auf */
+.grid-stack-item.gs-measuring {
+    height: auto !important;
+}
+
+.gs-measuring > .grid-stack-item-content {
+    height: auto !important;
+    position: relative !important;
+}
+
+.gs-measuring .grid-stack-item-content > .card {
+    height: auto !important;
+}
+
+/* === Barrierefreiheit (A11y) === */
+
+/* Screen-Reader-only: visuell versteckt, für Screenreader sichtbar */
+.sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+/* Skip-Link: bei Tab-Focus sichtbar */
+.skip-link {
+    position: absolute;
+    top: -100%;
+    left: 0;
+    z-index: 10000;
+    padding: 8px 16px;
+    background: var(--accent);
+    color: var(--bg-primary);
+    font-weight: 600;
+    text-decoration: none;
+}
+.skip-link:focus {
+    top: 0;
+}
+
+/* prefers-reduced-motion: alle Animationen deaktivieren */
+@media (prefers-reduced-motion: reduce) {
+    *, *::before, *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+
+/* === Barrierefreiheits-Panel === */
+.a11y-center { position: relative; }
+
+.a11y-btn {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: var(--sp-sm) var(--sp-md);
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.2s ease, background 0.2s ease;
+    width: 36px;
+    height: 36px;
+}
+.a11y-btn:hover { color: var(--accent); background: var(--bg-hover); }
+
+.a11y-panel {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    width: 240px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    z-index: 200;
+    padding: var(--sp-xl);
+}
+
+.a11y-panel-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: var(--sp-lg);
+}
+
+.a11y-option {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-sm) 0;
+    cursor: pointer;
+    font-size: 13px;
+    color: var(--text-primary);
+    user-select: none;
+}
+.a11y-option input[type="checkbox"] { display: none; }
+.a11y-option .toggle-switch {
+    flex-shrink: 0;
+}
+.a11y-option input:checked + .toggle-switch {
+    background: var(--accent);
+}
+.a11y-option input:checked + .toggle-switch::after {
+    transform: translateX(16px);
+    background: var(--bg-primary);
+}
+
+/* === A11y: Hoher Kontrast (Dark Theme) === */
+/* === Refresh History Popover === */
+.meta-updated-link {
+    cursor: pointer;
+    text-decoration: underline;
+    text-decoration-style: dashed;
+    text-underline-offset: 3px;
+    transition: color 0.2s ease;
+}
+.meta-updated-link:hover,
+.meta-updated-link:focus {
+    color: var(--accent);
+}
+.incident-header-row2-right {
+    position: relative;
+}
+.refresh-history-popover {
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: var(--sp-md);
+    width: 380px;
+    max-height: 420px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-md);
+    z-index: 30;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+.refresh-history-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-lg) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+}
+.refresh-history-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+.refresh-history-close {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    font-size: 18px;
+    cursor: pointer;
+    padding: 0 var(--sp-xs);
+    line-height: 1;
+}
+.refresh-history-close:hover {
+    color: var(--text-primary);
+}
+.refresh-history-list {
+    overflow-y: auto;
+    max-height: 360px;
+    scrollbar-width: thin;
+    scrollbar-color: var(--text-disabled) transparent;
+}
+.refresh-history-list::-webkit-scrollbar { width: 5px; }
+.refresh-history-list::-webkit-scrollbar-track { background: transparent; }
+.refresh-history-list::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.refresh-history-entry {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    font-size: 12px;
+}
+.refresh-history-entry:last-child {
+    border-bottom: none;
+}
+.rh-status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+.rh-status-dot.completed { background: var(--success); }
+.rh-status-dot.error { background: var(--error); }
+.rh-status-dot.running {
+    background: var(--warning);
+    animation: rh-pulse 1.5s ease-in-out infinite;
+}
+@keyframes rh-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+.rh-info {
+    flex: 1;
+    min-width: 0;
+}
+.rh-info-time {
+    color: var(--text-primary);
+    font-weight: 500;
+}
+.rh-info-detail {
+    color: var(--text-secondary);
+    font-size: 11px;
+    margin-top: 1px;
+}
+.rh-info-error {
+    color: var(--error);
+    font-size: 11px;
+    margin-top: 1px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.rh-trigger-badge {
+    font-size: 10px;
+    font-weight: 600;
+    text-transform: uppercase;
+    padding: 1px 6px;
+    border-radius: var(--radius);
+    flex-shrink: 0;
+}
+.rh-trigger-badge.auto {
+    background: var(--tint-success);
+    color: var(--success);
+}
+.rh-trigger-badge.manual {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+
+/* === Interval Input Group === */
+.interval-input-group {
+    display: flex;
+    gap: var(--sp-md);
+}
+.interval-input-group input[type="number"] {
+    width: 80px;
+    flex-shrink: 0;
+}
+.interval-input-group select {
+    flex: 1;
+    min-width: 0;
+}
+
+[data-a11y-contrast="true"] {
+    --text-disabled: #B0BDD0;
+    --border: #3A4A66;
+    --input-border: #3A4A66;
+}
+[data-a11y-contrast="true"] .btn-primary {
+    color: #1A1A1A;
+}
+
+/* === A11y: Hoher Kontrast (Light Theme) === */
+[data-a11y-contrast="true"][data-theme="light"] {
+    --accent: #6B5714;
+    --accent-hover: #5A4A11;
+    --text-disabled: #718096;
+    --border: #94A3B8;
+    --input-border: #94A3B8;
+}
+
+/* === A11y: Focus-Hervorhebung === */
+[data-a11y-focus="true"] a:focus,
+[data-a11y-focus="true"] button:focus,
+[data-a11y-focus="true"] input:focus,
+[data-a11y-focus="true"] select:focus,
+[data-a11y-focus="true"] textarea:focus,
+[data-a11y-focus="true"] [tabindex]:focus,
+[data-a11y-focus="true"] [role="button"]:focus {
+    outline: 3px solid var(--accent) !important;
+    outline-offset: 2px !important;
+}
+
+/* === A11y: Größere Schrift === */
+[data-a11y-fontsize="true"] {
+    font-size: 115%;
+}
+
+/* === A11y: Animationen aus === */
+[data-a11y-motion="true"] *,
+[data-a11y-motion="true"] *::before,
+[data-a11y-motion="true"] *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+}
+
+/* === Export Dropdown === */
+.export-dropdown {
+    position: relative;
+    display: inline-block;
+}
+.export-dropdown-menu {
+    display: none;
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: var(--sp-xs);
+    min-width: 220px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-md);
+    z-index: 50;
+    padding: var(--sp-xs) 0;
+}
+.export-dropdown-menu.show {
+    display: block;
+}
+.export-dropdown-item {
+    display: block;
+    width: 100%;
+    padding: var(--sp-md) var(--sp-xl);
+    background: none;
+    border: none;
+    color: var(--text-primary);
+    font-size: 13px;
+    text-align: left;
+    cursor: pointer;
+    transition: background 0.15s ease;
+}
+.export-dropdown-item:hover {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+.export-dropdown-divider {
+    border: none;
+    border-top: 1px solid var(--border);
+    margin: var(--sp-xs) 0;
+}
+
+/* === Print Styles === */
+@media print {
+    .sidebar,
+    .header,
+    .incident-header-actions,
+    .layout-toolbar,
+    .skip-link,
+    .a11y-center,
+    .notification-center,
+    .refresh-history-popover,
+    .export-dropdown {
+        display: none !important;
+    }
+    .main-content {
+        margin-left: 0 !important;
+        padding: 0 !important;
+    }
+    .dashboard {
+        display: block !important;
+    }
+    .grid-stack {
+        display: block !important;
+        height: auto !important;
+    }
+    .grid-stack-item {
+        position: static !important;
+        width: 100% !important;
+        height: auto !important;
+        margin-bottom: 1rem;
+    }
+    .grid-stack-item-content {
+        position: static !important;
+        overflow: visible !important;
+    }
+    .card {
+        border: 1px solid #ccc !important;
+        box-shadow: none !important;
+        break-inside: avoid;
+        background: white !important;
+        color: black !important;
+    }
+    .card-header {
+        background: #f5f5f5 !important;
+        color: black !important;
+    }
+    body {
+        background: white !important;
+        color: black !important;
+    }
+}
diff --git a/src/static/dashboard.html b/src/static/dashboard.html
new file mode 100644
index 0000000..0b624ce
--- /dev/null
+++ b/src/static/dashboard.html
@@ -0,0 +1,541 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <script>(function(){var t=localStorage.getItem('osint_theme');if(t)document.documentElement.setAttribute('data-theme',t);try{var a=JSON.parse(localStorage.getItem('osint_a11y')||'{}');Object.keys(a).forEach(function(k){if(a[k])document.documentElement.setAttribute('data-a11y-'+k,'true');});}catch(e){}})()</script>
+    <link rel="icon" type="image/png" sizes="32x32" href="/static/favicon-32x32.png">
+    <link rel="icon" type="image/png" sizes="16x16" href="/static/favicon-16x16.png">
+    <link rel="apple-touch-icon" sizes="180x180" href="/static/apple-touch-icon.png">
+    <link rel="shortcut icon" href="/static/favicon.ico">
+    <title>AegisSight Monitor</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link href="https://cdn.jsdelivr.net/npm/gridstack@12/dist/gridstack.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="/static/css/style.css?v=20260304b">
+</head>
+<body>
+    <a href="#main-content" class="skip-link">Zum Hauptinhalt springen</a>
+    <div class="dashboard">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-left">
+                <div class="header-logo">Aegis<span>Sight</span> Monitor</div>
+                <h1 class="sr-only">AegisSight Monitor Dashboard</h1>
+            </div>
+            <div class="header-right">
+                <button class="btn btn-secondary btn-small theme-toggle-btn" id="theme-toggle" onclick="ThemeManager.toggle()" title="Theme wechseln" aria-label="Theme wechseln">&#9788;</button>
+                <span class="header-user" id="header-user"></span>
+                <button class="btn btn-secondary btn-small" id="logout-btn">Abmelden</button>
+            </div>
+        </header>
+
+        <!-- Sidebar -->
+        <nav class="sidebar" aria-label="Seitenleiste">
+            <div class="sidebar-section">
+                <button class="btn btn-primary btn-full btn-small" id="new-incident-btn">+ Neue Lage / Recherche</button>
+            </div>
+
+            <div class="sidebar-filter">
+                <button class="sidebar-filter-btn active" data-filter="all" onclick="App.setSidebarFilter('all')" aria-pressed="true">Alle</button>
+                <button class="sidebar-filter-btn" data-filter="mine" onclick="App.setSidebarFilter('mine')" aria-pressed="false">Eigene</button>
+            </div>
+
+            <div class="sidebar-section">
+                <h2 class="sidebar-section-title collapsible" onclick="App.toggleSidebarSection('active-incidents')" role="button" tabindex="0">
+                    <span class="sidebar-chevron" id="chevron-active-incidents">&#9662;</span>
+                    Aktive Lagen
+                    <span class="sidebar-section-count" id="count-active-incidents"></span>
+                </h2>
+                <div id="active-incidents" aria-live="polite"></div>
+            </div>
+
+            <div class="sidebar-section">
+                <h2 class="sidebar-section-title collapsible" onclick="App.toggleSidebarSection('active-research')" role="button" tabindex="0">
+                    <span class="sidebar-chevron" id="chevron-active-research">&#9662;</span>
+                    Aktive Recherchen
+                    <span class="sidebar-section-count" id="count-active-research"></span>
+                </h2>
+                <div id="active-research" aria-live="polite"></div>
+            </div>
+
+            <div class="sidebar-section">
+                <h2 class="sidebar-section-title collapsible" onclick="App.toggleSidebarSection('archived-incidents')" role="button" tabindex="0">
+                    <span class="sidebar-chevron" id="chevron-archived-incidents">&#9662;</span>
+                    Archiv
+                    <span class="sidebar-section-count" id="count-archived-incidents"></span>
+                </h2>
+                <div id="archived-incidents" aria-live="polite"></div>
+            </div>
+            <div class="sidebar-sources-link">
+                <button class="btn btn-secondary btn-full btn-small" onclick="App.openSourceManagement()">Quellen verwalten</button>
+                <button class="btn btn-secondary btn-full btn-small sidebar-feedback-btn" onclick="App.openFeedback()">Feedback senden</button>
+                <div class="sidebar-stats-mini">
+                    <span id="stat-sources-count">0 Quellen</span> &middot; <span id="stat-articles-count">0 Artikel</span>
+                </div>
+            </div>
+        </nav>
+
+        <!-- Main Content -->
+        <main class="main-content" id="main-content">
+            <div class="empty-state" id="empty-state">
+                <div class="empty-state-icon">&#9737;</div>
+                <div class="empty-state-title">Kein Vorfall ausgewählt</div>
+                <div class="empty-state-text">Erstelle eine neue Lage oder wähle einen bestehenden Vorfall aus der Seitenleiste.</div>
+            </div>
+
+            <!-- Lagebild (hidden by default) -->
+            <div id="incident-view" style="display:none;">
+                <!-- Header Strip -->
+                <div class="incident-header-strip" id="incident-header-strip">
+                    <div class="incident-header-row0">
+                        <span class="incident-type-label" id="incident-type-badge"></span>
+                        <span class="auto-refresh-indicator" id="meta-refresh-mode"></span>
+                    </div>
+                    <div class="incident-header-row1">
+                        <div class="incident-header-left">
+                            <h2 class="incident-header-title" id="incident-title"></h2>
+                        </div>
+                        <div class="incident-header-actions">
+                            <button class="btn btn-primary btn-small" id="refresh-btn">Aktualisieren</button>
+                            <button class="btn btn-secondary btn-small" id="edit-incident-btn">Bearbeiten</button>
+                            <div class="export-dropdown" id="export-dropdown">
+                                <button class="btn btn-secondary btn-small" onclick="App.toggleExportDropdown(event)">Exportieren &#9662;</button>
+                                <div class="export-dropdown-menu" id="export-dropdown-menu">
+                                    <button class="export-dropdown-item" onclick="App.exportIncident('md','report')">Lagebericht (Markdown)</button>
+                                    <button class="export-dropdown-item" onclick="App.exportIncident('json','report')">Lagebericht (JSON)</button>
+                                    <hr class="export-dropdown-divider">
+                                    <button class="export-dropdown-item" onclick="App.exportIncident('md','full')">Vollexport (Markdown)</button>
+                                    <button class="export-dropdown-item" onclick="App.exportIncident('json','full')">Vollexport (JSON)</button>
+                                    <hr class="export-dropdown-divider">
+                                    <button class="export-dropdown-item" onclick="App.printIncident()">Drucken / PDF</button>
+                                </div>
+                            </div>
+                            <button class="btn btn-secondary btn-small" id="archive-incident-btn">Archivieren</button>
+                            <button class="btn btn-danger btn-small" id="delete-incident-btn">Löschen</button>
+                        </div>
+                    </div>
+                    <div class="incident-header-row2">
+                        <div class="incident-header-row2-left">
+                            <span class="incident-creator-badge">von <strong id="incident-creator"></strong></span>
+                            <span class="intl-badge" id="intl-badge"></span>
+                            <span id="incident-description" class="incident-description-text"></span>
+                        </div>
+                        <div class="incident-header-row2-right">
+                            <div class="summary-meta" id="summary-meta">
+                                <span id="meta-updated" class="meta-updated-link" role="button" tabindex="0" onclick="App.toggleRefreshHistory()" onkeydown="if(event.key==='Enter')App.toggleRefreshHistory()"></span>
+                            </div>
+                            <div class="refresh-history-popover" id="refresh-history-popover" style="display:none;">
+                                <div class="refresh-history-header">
+                                    <span class="refresh-history-title">Refresh-Verlauf</span>
+                                    <button class="refresh-history-close" onclick="App.closeRefreshHistory()">&times;</button>
+                                </div>
+                                <div class="refresh-history-list" id="refresh-history-list">
+                                    <div style="padding:12px;color:var(--text-disabled);font-size:12px;">Lade...</div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Fortschrittsanzeige -->
+                <div class="progress-bar" id="progress-bar" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100" aria-label="Verarbeitungsfortschritt" style="display:none;">
+                    <div class="progress-steps">
+                        <div class="progress-step" id="step-researching">
+                            <div class="progress-step-dot"></div>
+                            <span>Recherche</span>
+                        </div>
+                        <div class="progress-step" id="step-analyzing">
+                            <div class="progress-step-dot"></div>
+                            <span>Analyse</span>
+                        </div>
+                        <div class="progress-step" id="step-factchecking">
+                            <div class="progress-step-dot"></div>
+                            <span>Faktencheck</span>
+                        </div>
+                    </div>
+                    <div class="progress-track">
+                        <div class="progress-fill" id="progress-fill"></div>
+                    </div>
+                    <div class="progress-label-container">
+                        <span id="progress-label" class="progress-label">Warte auf Start...</span>
+                        <span id="progress-timer" class="progress-timer"></span>
+                    </div>
+                    <button id="progress-cancel-btn" class="progress-cancel-btn" onclick="App.cancelRefresh()">Abbrechen</button>
+                </div>
+
+                <!-- Layout-Toolbar -->
+                <div class="layout-toolbar" id="layout-toolbar" style="display:none;">
+                    <div class="layout-toggles">
+                        <button class="layout-toggle-btn active" data-tile="lagebild" onclick="LayoutManager.toggleTile('lagebild')" aria-pressed="true">Lagebild</button>
+                        <button class="layout-toggle-btn active" data-tile="faktencheck" onclick="LayoutManager.toggleTile('faktencheck')" aria-pressed="true">Faktencheck</button>
+                        <button class="layout-toggle-btn active" data-tile="quellen" onclick="LayoutManager.toggleTile('quellen')" aria-pressed="true">Quellen</button>
+                        <button class="layout-toggle-btn active" data-tile="timeline" onclick="LayoutManager.toggleTile('timeline')" aria-pressed="true">Timeline</button>
+                    </div>
+                    <button class="btn btn-secondary btn-small" onclick="LayoutManager.reset()">Layout zurücksetzen</button>
+                </div>
+
+                <!-- gridstack Dashboard-Grid -->
+                <div class="grid-stack">
+                    <div class="grid-stack-item" gs-id="lagebild" gs-x="0" gs-y="0" gs-w="6" gs-h="4" gs-min-w="4" gs-min-h="4">
+                        <div class="grid-stack-item-content">
+                            <div class="card incident-analysis-summary">
+                                <div class="card-header">
+                                    <div class="card-title clickable" onclick="openContentModal('Lagebild', 'summary-content')">Lagebild</div>
+                                    <span class="lagebild-timestamp" id="lagebild-timestamp"></span>
+                                </div>
+                                <div id="summary-content">
+                                    <div id="summary-text" class="summary-text"></div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="grid-stack-item" gs-id="faktencheck" gs-x="6" gs-y="0" gs-w="6" gs-h="4" gs-min-w="4" gs-min-h="4">
+                        <div class="grid-stack-item-content">
+                            <div class="card incident-analysis-factcheck" id="factcheck-card">
+                                <div class="card-header">
+                                    <div class="card-title clickable" onclick="openContentModal('Faktencheck', 'factcheck-list')">Faktencheck</div>
+                                    <div class="fc-filter-bar" id="fc-filters"></div>
+                                </div>
+                                <div class="factcheck-list" id="factcheck-list">
+                                    <div class="empty-state" style="padding:20px;">
+                                        <div class="empty-state-text">Noch keine Fakten geprüft</div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="grid-stack-item" gs-id="quellen" gs-x="0" gs-y="4" gs-w="12" gs-h="2" gs-min-w="6" gs-min-h="2">
+                        <div class="grid-stack-item-content">
+                            <div class="card source-overview-card">
+                                <div class="card-header source-overview-header-toggle" onclick="App.toggleSourceOverview()" role="button" tabindex="0" aria-expanded="false">
+                                    <span class="source-overview-chevron" id="source-overview-chevron" title="Aufklappen" aria-hidden="true">&#9656;</span>
+                                    <div class="card-title clickable">Quellenübersicht</div>
+                                    <button class="btn btn-secondary btn-small source-detail-btn" onclick="event.stopPropagation(); openContentModal('Quellenübersicht', 'source-overview-content')">Detailansicht</button>
+                                </div>
+                                <div id="source-overview-content" style="display:none;"></div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="grid-stack-item" gs-id="timeline" gs-x="0" gs-y="5" gs-w="12" gs-h="4" gs-min-w="6" gs-min-h="4">
+                        <div class="grid-stack-item-content">
+                            <div class="card timeline-card">
+                                <div class="card-header">
+                                    <div class="card-title clickable" onclick="openContentModal('Ereignis-Timeline', 'timeline')">Ereignis-Timeline</div>
+                                    <div class="ht-controls">
+                                        <div class="ht-filter-group">
+                                            <button class="ht-filter-btn active" data-filter="all" onclick="App.setTimelineFilter('all')" aria-pressed="true">Alle</button>
+                                            <button class="ht-filter-btn" data-filter="articles" onclick="App.setTimelineFilter('articles')" aria-pressed="false">Meldungen</button>
+                                            <button class="ht-filter-btn" data-filter="snapshots" onclick="App.setTimelineFilter('snapshots')" aria-pressed="false">Lageberichte</button>
+                                        </div>
+                                        <span class="ht-count" id="article-count"></span>
+                                        <div class="ht-range-group">
+                                            <button class="ht-range-btn" data-range="24h" onclick="App.setTimelineRange('24h')" aria-pressed="false">24h</button>
+                                            <button class="ht-range-btn" data-range="7d" onclick="App.setTimelineRange('7d')" aria-pressed="false">7T</button>
+                                            <button class="ht-range-btn active" data-range="all" onclick="App.setTimelineRange('all')" aria-pressed="true">Alles</button>
+                                        </div>
+                                        <label for="timeline-search" class="sr-only">Timeline durchsuchen</label>
+                                        <input type="text" id="timeline-search" class="timeline-filter-input" placeholder="Suche..." oninput="App.debouncedRerenderTimeline()">
+                                    </div>
+                                </div>
+                                <div id="timeline" class="ht-timeline-container">
+                                    <div class="ht-empty">Noch keine Meldungen</div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Parkplatz für ausgeblendete Kacheln -->
+                <div id="tile-parking" style="display:none;"></div>
+            </div>
+        </main>
+    </div>
+
+    <!-- Modal: Neue Lage -->
+    <div class="modal-overlay" id="modal-new" role="dialog" aria-modal="true" aria-labelledby="modal-new-title">
+        <div class="modal">
+            <div class="modal-header">
+                <div class="modal-title" id="modal-new-title">Neue Lage anlegen</div>
+                <button class="modal-close" onclick="closeModal('modal-new')" aria-label="Schließen">&times;</button>
+            </div>
+            <form id="new-incident-form">
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label for="inc-title">Titel des Vorfalls</label>
+                        <input type="text" id="inc-title" required placeholder="z.B. Explosion in Madrid">
+                    </div>
+                    <div class="form-group">
+                        <label for="inc-description">Beschreibung / Kontext</label>
+                        <textarea id="inc-description" placeholder="Weitere Details zum Vorfall (optional)"></textarea>
+                    </div>
+                    <div class="form-group">
+                        <label for="inc-type">Art der Lage</label>
+                        <select id="inc-type" onchange="toggleTypeDefaults()">
+                            <option value="adhoc">Ad-hoc Lage (Breaking News)</option>
+                            <option value="research">Recherche (Hintergrund)</option>
+                        </select>
+                        <div class="form-hint" id="type-hint">
+                            RSS-Feeds + WebSearch, automatische Aktualisierung empfohlen
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>Quellen</label>
+                        <div class="toggle-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="inc-international" checked>
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Internationale Quellen einbeziehen</span>
+                            </label>
+                            <div class="form-hint" id="sources-hint">DE + internationale Feeds (Reuters, BBC, Al Jazeera etc.)</div>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>Sichtbarkeit</label>
+                        <div class="toggle-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="inc-visibility" checked>
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text" id="visibility-text">Öffentlich — für alle Nutzer sichtbar</span>
+                            </label>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label for="inc-refresh-mode">Aktualisierung</label>
+                        <select id="inc-refresh-mode" onchange="toggleRefreshInterval()">
+                            <option value="manual">Manuell</option>
+                            <option value="auto">Automatisch</option>
+                        </select>
+                    </div>
+                    <div class="form-group conditional-field" id="refresh-interval-field">
+                        <label for="inc-refresh-value">Intervall</label>
+                        <div class="interval-input-group">
+                            <input type="number" id="inc-refresh-value" min="10" value="15">
+                            <select id="inc-refresh-unit" onchange="updateIntervalMin()">
+                                <option value="1" selected>Minuten</option>
+                                <option value="60">Stunden</option>
+                                <option value="1440">Tage</option>
+                                <option value="10080">Wochen</option>
+                            </select>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label for="inc-retention">Aufbewahrung (Tage)</label>
+                        <input type="number" id="inc-retention" min="0" max="999" value="30" placeholder="0 = Unbegrenzt">
+                        <div class="form-hint">0 = Unbegrenzt, max. 999 Tage</div>
+                    </div>
+                    <div class="form-group" style="margin-top: 8px;">
+                        <label>E-Mail-Benachrichtigungen</label>
+                        <div class="form-hint" style="margin-bottom: 8px;">Per E-Mail benachrichtigen bei:</div>
+                        <div class="toggle-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="inc-notify-summary">
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Neues Lagebild</span>
+                            </label>
+                        </div>
+                        <div class="toggle-group" style="margin-top: 8px;">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="inc-notify-new-articles">
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Neue Artikel</span>
+                            </label>
+                        </div>
+                        <div class="toggle-group" style="margin-top: 8px;">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="inc-notify-status-change">
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Statusänderung Faktencheck</span>
+                            </label>
+                        </div>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" onclick="closeModal('modal-new')">Abbrechen</button>
+                    <button type="submit" class="btn btn-primary" id="modal-new-submit">Lage anlegen</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <!-- Modal: Quellenverwaltung -->
+    <div class="modal-overlay" id="modal-sources" role="dialog" aria-modal="true" aria-labelledby="modal-sources-title">
+        <div class="modal modal-wide">
+            <div class="modal-header">
+                <div class="modal-title" id="modal-sources-title">Quellenverwaltung</div>
+                <button class="modal-close" onclick="closeModal('modal-sources')" aria-label="Schließen">&times;</button>
+            </div>
+            <div class="modal-body sources-modal-body">
+                <!-- Stats-Leiste -->
+                <div class="sources-stats-bar" id="sources-stats-bar"></div>
+
+                <!-- Toolbar -->
+                <div class="sources-toolbar">
+                    <div class="sources-filters">
+                        <label for="sources-filter-type" class="sr-only">Quellentyp filtern</label>
+                        <select id="sources-filter-type" class="timeline-filter-select" onchange="App.filterSources()">
+                            <option value="">Alle Typen</option>
+                            <option value="rss_feed">RSS-Feed</option>
+                            <option value="web_source">Web-Quelle</option>
+                            <option value="excluded">Gesperrt</option>
+                        </select>
+                        <label for="sources-filter-category" class="sr-only">Kategorie filtern</label>
+                        <select id="sources-filter-category" class="timeline-filter-select" onchange="App.filterSources()">
+                            <option value="">Alle Kategorien</option>
+                            <option value="nachrichtenagentur">Nachrichtenagentur</option>
+                            <option value="oeffentlich-rechtlich">Öffentlich-Rechtlich</option>
+                            <option value="qualitaetszeitung">Qualitätszeitung</option>
+                            <option value="behoerde">Behörde</option>
+                            <option value="fachmedien">Fachmedien</option>
+                            <option value="think-tank">Think Tank</option>
+                            <option value="international">International</option>
+                            <option value="regional">Regional</option>
+                            <option value="sonstige">Sonstige</option>
+                        </select>
+                        <label for="sources-search" class="sr-only">Quellen durchsuchen</label>
+                        <input type="text" id="sources-search" class="timeline-filter-input sources-search-input" placeholder="Suche..." oninput="App.filterSources()">
+                    </div>
+                    <div class="sources-toolbar-actions">
+                        <button class="btn btn-secondary btn-small source-block-btn" onclick="App.showBlockDomainDialog()">Domain sperren</button>
+                        <button class="btn btn-primary btn-small" onclick="App.toggleSourceForm()">+ Quelle</button>
+                    </div>
+                </div>
+
+                <!-- Inline-Formular: Domain sperren (ein-/ausklappbar) -->
+                <div class="sources-add-form" id="sources-block-form" style="display:none;">
+                    <div class="sources-form-row">
+                        <div class="form-group flex-1">
+                            <label for="block-domain-input">Domain</label>
+                            <input type="text" id="block-domain-input" placeholder="z.B. bild.de">
+                        </div>
+                        <div class="form-group">
+                            <label for="block-domain-notes">Notizen</label>
+                            <input type="text" id="block-domain-notes" class="source-notes-input" placeholder="Optional">
+                        </div>
+                        <button class="btn btn-danger btn-small" onclick="App.blockDomain()">Sperren</button>
+                        <button class="btn btn-secondary btn-small" onclick="App.showBlockDomainDialog(false)">Abbrechen</button>
+                    </div>
+                </div>
+
+                <!-- Inline-Formular: Quelle hinzufügen (ein-/ausklappbar) -->
+                <div class="sources-add-form" id="sources-add-form" style="display:none;">
+                    <div class="sources-form-row">
+                        <div class="form-group flex-1">
+                            <label for="src-discover-url">URL oder Domain</label>
+                            <input type="text" id="src-discover-url" placeholder="z.B. netzpolitik.org">
+                        </div>
+                        <button class="btn btn-secondary btn-small" id="src-discover-btn" onclick="App.discoverSource()">Erkennen</button>
+                    </div>
+
+                    <!-- Ergebnis-Anzeige (nach Discovery) -->
+                    <div id="src-discovery-result" class="sources-discovery-result" style="display:none;">
+                        <div class="sources-add-form-grid">
+                            <div class="form-group">
+                                <label for="src-name">Name</label>
+                                <input type="text" id="src-name" placeholder="Wird erkannt...">
+                            </div>
+                            <div class="form-group">
+                                <label for="src-category">Kategorie</label>
+                                <select id="src-category">
+                                    <option value="nachrichtenagentur">Nachrichtenagentur</option>
+                                    <option value="oeffentlich-rechtlich">Öffentlich-Rechtlich</option>
+                                    <option value="qualitaetszeitung">Qualitätszeitung</option>
+                                    <option value="behoerde">Behörde</option>
+                                    <option value="fachmedien">Fachmedien</option>
+                                    <option value="think-tank">Think Tank</option>
+                                    <option value="international">International</option>
+                                    <option value="regional">Regional</option>
+                                    <option value="sonstige" selected>Sonstige</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label>Typ</label>
+                                <input type="text" id="src-type-display" class="input-readonly" readonly>
+                            </div>
+                            <div class="form-group" id="src-rss-url-group">
+                                <label>RSS-Feed URL</label>
+                                <input type="text" id="src-rss-url" class="input-readonly" readonly>
+                            </div>
+                            <div class="form-group">
+                                <label>Domain</label>
+                                <input type="text" id="src-domain" class="input-readonly" readonly>
+                            </div>
+                            <div class="form-group">
+                                <label for="src-notes">Notizen</label>
+                                <input type="text" id="src-notes" placeholder="Optional">
+                            </div>
+                        </div>
+                        <div class="sources-discovery-actions">
+                            <button class="btn btn-primary btn-small" onclick="App.saveSource()">Speichern</button>
+                            <button class="btn btn-secondary btn-small" onclick="App.toggleSourceForm(false)">Abbrechen</button>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Quellen-Liste (gruppiert) -->
+                <div class="sources-list" id="sources-list">
+                    <div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;">Lade Quellen...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Modal: Content-Viewer (wiederverwendbar für Lagebild, Faktencheck, Quellenübersicht, Timeline) -->
+    <div class="modal-overlay" id="modal-content-viewer" role="dialog" aria-modal="true" aria-labelledby="content-viewer-title">
+        <div class="modal modal-content-viewer">
+            <div class="modal-header">
+                <div class="modal-title" id="content-viewer-title"></div>
+                <div class="modal-header-extra" id="content-viewer-header-extra"></div>
+                <button class="modal-close" onclick="closeModal('modal-content-viewer')" aria-label="Schließen">&times;</button>
+            </div>
+            <div class="modal-body" id="content-viewer-body"></div>
+        </div>
+    </div>
+
+    <!-- Modal: Feedback -->
+    <div class="modal-overlay" id="modal-feedback" role="dialog" aria-modal="true" aria-labelledby="modal-feedback-title">
+        <div class="modal">
+            <div class="modal-header">
+                <div class="modal-title" id="modal-feedback-title">Feedback senden</div>
+                <button class="modal-close" onclick="closeModal('modal-feedback')" aria-label="Schliessen">&times;</button>
+            </div>
+            <form id="feedback-form">
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label for="fb-category">Kategorie</label>
+                        <select id="fb-category">
+                            <option value="bug">Fehlerbericht</option>
+                            <option value="feature">Feature-Wunsch</option>
+                            <option value="question">Frage</option>
+                            <option value="other">Sonstiges</option>
+                        </select>
+                    </div>
+                    <div class="form-group">
+                        <label for="fb-message">Nachricht</label>
+                        <textarea id="fb-message" required minlength="10" maxlength="5000" rows="6" placeholder="Beschreibe dein Anliegen (mind. 10 Zeichen)..."></textarea>
+                        <div class="form-hint"><span id="fb-char-count">0</span> / 5.000 Zeichen</div>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" onclick="closeModal('modal-feedback')">Abbrechen</button>
+                    <button type="submit" class="btn btn-primary" id="fb-submit-btn">Absenden</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <!-- Toast Container -->
+    <div class="toast-container" id="toast-container" aria-live="polite" aria-atomic="true"></div>
+
+    <script src="https://cdn.jsdelivr.net/npm/gridstack@12/dist/gridstack-all.js"></script>
+    <script src="/static/js/api.js?v=20260304a"></script>
+    <script src="/static/js/ws.js?v=20260304a"></script>
+    <script src="/static/js/components.js?v=20260304a"></script>
+    <script src="/static/js/layout.js?v=20260304a"></script>
+    <script src="/static/js/app.js?v=20260304a"></script>
+</body>
+</html>
diff --git a/src/static/favicon-16x16.png b/src/static/favicon-16x16.png
new file mode 100644
index 0000000000000000000000000000000000000000..639db6414c177728c8f0832dc3d52cad21a42874
GIT binary patch
literal 568
zcmV-80>}M{P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV00061Nkl<Zc$|$>
zO=uHQ5Pmb;{A}B#+cd4%MuH-3Em)g_P@&qRH?1f2B2*OdAl`x}Pf`R=9ty>?2fY+T
zQF~Gmq~f8d0YO6QPYzp5Htr^yCY!t&53=cIlUC<A^L^iYGv5q|F2T&)Ee`<T&*A@)
zcdMbd$jmGy$=wA=x;Qu2<9|U>P$?8k#mB2JGeyJVYi9=qU_fYzljFhO_$V{8w-s=S
zL_~;)ckZpce)8f~Vk8!;I8CAl=>yE5uv0TtRU0oPQ;Vl|CIZm<x+^k$Vqr6z`|-^*
zt>0%Z+<c#VcXxfeQq-G`YGvc;)jY{Y-OFifK?or<En*ubQ+&;CZb?Z%aywubGTHv2
z!(+*r%Q~R4--~YvxGkt^xN#%Bq#_6{8r8~?;UlK;eJx(dJ-0D9BnA_+$jk%)*yaKe
zlMq5oO&qe$pF6FuKD<A`BvA=ycyRXCXyVuv=m`%vF1o`;#J`G{E-s8bTYD2TN~RSI
zhMUIEw_4TG^?c@0HJ+T)+yQnGKxAf~IXXFcJAJ)buGlq1;85RiIlr+S3P;B5NPKFV
znIr%zEnb_a03fB5^K-{j{e8V5r{*X%dn+1H_Zi95;yg1+5P)8M+Y;?;qm*^Wsjq+d
z_}TjP<&)QD|0aT0z;EeZ;lAE+UH=mDUu4HMc01X<YJULhJTVJud7#w*0000<MNUMn
GLSTa7=m7ly

literal 0
HcmV?d00001

diff --git a/src/static/favicon-192x192.png b/src/static/favicon-192x192.png
new file mode 100644
index 0000000000000000000000000000000000000000..b364215d9e9d6a083bc16821dbee9bc78f48fcff
GIT binary patch
literal 9506
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
AXaE2J

literal 0
HcmV?d00001

diff --git a/src/static/favicon-32x32.png b/src/static/favicon-32x32.png
new file mode 100644
index 0000000000000000000000000000000000000000..8621cc79cfc8ac48c9076b02da0e7a5ae624f608
GIT binary patch
literal 1314
zcmV+-1>O3IP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F8000E(Nkl<Zc$~FY
zU2IfE6#mZ4-T!6VZYh7QZLte&DYS*E6blqIzGx(xKzT44Lm*;Ei1?uKNqzE#2O~ru
z)Wm26{}R!}zYs%7#h*a2fL6dFrLApcq0n|)y1RGg_;9(f(7pRZ^}NlUbI$k8H*?RN
zA>?Vy%$eqii1NvolXEuEnUE3x7kI9*jtpl4oEFGIjkF)Lfip8JrIipQth`zi2?=DD
zJRON?A2NY!t+m#y4MQ5~nQ6rUEHb%~xMh$I++MAeLfXOcL?ZshSKl8C`9hutnhWIk
zmBI1CvX%zv3KZOoQ>K$DsU)%zNVV?M=XyRl@ZG?tpMP8R_wePrp5OXp`-|JE#HBMI
zti5<ej1*U_`n|Y(T~VO8dTFLSsRV9Fc{{j09vh2|efiCyQ~N&qI@s~k@kWr0_&st$
zkXAmQmq3OXn^X$IoxC>GzGgUj7;&-S%<Rhb!$oB+wJvW#i4B{Y+a_T+tz0Rs3_}{b
z_rBNl`dj;3StoJ-eT^rd+0r&KcTTbYk+vNT%nXo#-y>w{ik*YP<sTX8J$UJAZ%5Nq
z-~Q^J{-eih*S|7{S?k;P-X@X$Fr~=Udtty$q}74_d%7NMZEga9Q{89J-r@^@!5j=n
zYJ=ej=GC+fbsv1rbOqw>n;z-Sk$`REv1=}+l&r6-u24!VrIkt~Ommu})|$1M1PF#F
z6xQaH$4pH6GQ$H#)_)#s=hspSDW#ABzt;l*siDGfyGR%=3s7Qq<k7<}Zy^9wft>42
zRt5ZCw;}+i|2#i97K=@S!Do7UqX4Qb@&v`C;uF!B%lA(|u~Hx*N^2jhBjNE`S)2=$
zBLQ2P(gpM4Ac2QBZEqwJ_T)k-CBOiyxc0e84tBlSA_Rd5(3;_KOUR;CN2;24wy;(v
ziS)%Qs{(a35h5a9-Mr#NxUgVKO2MP!F?V}MXH!BaAp_-wiNL)_{4!1e6F>|Sn2P?g
zGF(uWv;=U@??^xhYq=}$sh`ixw7kA{^tG3FwF1Cj=ld_zuik{XijxtjsG3{7>9Qv<
zx7?0Z=G4UT14k$rUUa=OI&XpFbu5Gs%*=};m6ego((`-Y{%B42>2p0wX?10Ed_qdX
zEO(IO(H}ZTI$tOs9sczgYh?n!g|7EINxHAiDydmw!ILwN(*$s{7;SxeV;@6`z3=QB
zvhIXbQHheKhE_>MLK?A=bAOo8Lu*SaA38?D<zZIl9Vq|+QVPk;{M6<R%L6`RVrVGp
zo$f^tf?$L6b?$K`l!(u-*|69;$RZ<#$ka9w5oygj6bgo3eQ8H$BAJ|aW{3!a0AYBH
zf!{uEFY#ZE6y3e?XSc6-KEOJY{25EJZMF*Aw`^X!bjhL<0ALtW09GMl)`(4-xP0<M
zkH_p=HyK=Zbn%kMTbZ>2oWXA>kj=qn3IMB{S2O?sYi22h5|;KbHIz^H*RglusjB8(
zwbw77jOyBE*Z{fofTn4hhG7_Px69BPGMO})h!76B<fOat$AwMLHb}!8VAeX<_AIZ4
z1hDP|X7KJe-tF)k0kN&ER9w0^V3sX=V%_x|8TUOE{Ei5uno?Q`(%QO&?AYwGI}*r;
zgxx1vF<ND6M4iCX63B-{zLxG#rroQ2-*<Nk4&?AQoT(bw7L&CO%tVb`V)IV^Uq8?P
Y1sq~gM5QvH-2eap07*qoM6N<$f_^`PHvj+t

literal 0
HcmV?d00001

diff --git a/src/static/favicon-48x48.png b/src/static/favicon-48x48.png
new file mode 100644
index 0000000000000000000000000000000000000000..5363756933283d0eb93c33313715fea9bd8c3842
GIT binary patch
literal 2163
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

literal 0
HcmV?d00001

diff --git a/src/static/favicon-512x512.png b/src/static/favicon-512x512.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc2c0094cda112341658e5e6f2a1bf54ef4e44e0
GIT binary patch
literal 27209
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

literal 0
HcmV?d00001

diff --git a/src/static/favicon.ico b/src/static/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..b3ed8d378b605fef1a423babb0535677b5327456
GIT binary patch
literal 590
zcmV-U0<rx70096201yxW0000W05}2w02TlM0EtjeM-2)Z3IG5A4M|8uQUCw|5C8xG
z5C{eU001BJ|6u?C0sl!vK~#90jZ;l%6HyR;Gu!-Z+oanxt=L9_B5f^Ln}blH+M_qE
zC-ov!6!9S5f+tT>1Wz6c#j^*!6hu*bQW2!$p{M~tLh4TrTTC|YCYvUkycrL&>1LBw
z=Q#6y-+MFP42Ukl%-k&x0N~Hz|B`pBp|{A)EG5a^1xUI$H`n8TK~YdC6ida&t1mM}
z!{Tda2L)h2Xo-{K!QS{NGqbl9aEU}jh=_OYt-OBn;#FcK7OOZ-q6g^%%%HGSGgVa^
zFC<for*<X+(E7S7GJRrUGn@PI%`~mwXD-})pL=(AeY;ZBn~iE^<LT8r$wuAFX=_0U
zAv7&w8zobG&2DZ<NkDQtU>7pk{-MKT$(hSKpt9eKZwa_9sA{-zBfX>|2rU}b%8}tC
zrty6(UdTPSF*qa!6SK(71OV9P0uhrCLQG8@vd*77t*<`3KfokW321n5_SR_P*cIpr
z4>&Hm!$!ovikB`fj67R=6EjMt6%2-(#?QA})zbBR=211CoYUL^b`d~iW}Z1ZIe9yM
zy;-i<HALW0-*7p<u^b9V#_ULZYMPlO04gnBo2LLErIhn?$5Z`%y&<ROC^dU48c_Ec
z$<*RJGf5DDUVPgU?QElzb;qf%fB5*>`t{|L*Jl4Ff>*$A>0aT!-f><367pYU$2E34
c*}ZCi0P8$43u<|w)c^nh07*qoM6N<$f-8stj{pDw

literal 0
HcmV?d00001

diff --git a/src/static/index.html b/src/static/index.html
new file mode 100644
index 0000000..4b8dcb7
--- /dev/null
+++ b/src/static/index.html
@@ -0,0 +1,212 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <script>(function(){var t=localStorage.getItem('osint_theme');if(t)document.documentElement.setAttribute('data-theme',t);try{var a=JSON.parse(localStorage.getItem('osint_a11y')||'{}');Object.keys(a).forEach(function(k){if(a[k])document.documentElement.setAttribute('data-a11y-'+k,'true');});}catch(e){}})()</script>
+    <link rel="icon" type="image/png" sizes="32x32" href="/static/favicon-32x32.png">
+    <link rel="icon" type="image/png" sizes="16x16" href="/static/favicon-16x16.png">
+    <link rel="apple-touch-icon" sizes="180x180" href="/static/apple-touch-icon.png">
+    <link rel="shortcut icon" href="/static/favicon.ico">
+    <title>AegisSight Monitor - Login</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/css/style.css?v=20260304a">
+</head>
+<body>
+    <a href="#login-form" class="skip-link">Zum Anmeldeformular springen</a>
+    <main class="login-container">
+        <div class="login-box">
+            <div class="login-logo">
+                <h1>Aegis<span style="color: var(--accent)">Sight</span></h1>
+                <div class="subtitle">Lagemonitor</div>
+            </div>
+
+            <div id="login-error" class="login-error" role="alert" aria-live="assertive"></div>
+            <div id="login-success" class="login-success" role="status" aria-live="polite" style="display:none;"></div>
+
+            <!-- Schritt 1: E-Mail eingeben -->
+            <form id="email-form">
+                <div class="form-group">
+                    <label for="email">E-Mail-Adresse</label>
+                    <input type="email" id="email" name="email" autocomplete="email" required placeholder="name@organisation.de">
+                </div>
+                <button type="submit" class="btn btn-primary btn-full" id="email-btn">Anmelden</button>
+            </form>
+
+            <!-- Schritt 2: Code eingeben -->
+            <form id="code-form" style="display:none;">
+                <p style="color: var(--text-secondary); margin: 0 0 16px 0; font-size: 14px;">
+                    Ein 6-stelliger Code wurde an <strong id="sent-email"></strong> gesendet.
+                </p>
+                <div class="form-group">
+                    <label for="code">Code eingeben</label>
+                    <input type="text" id="code" name="code" autocomplete="one-time-code" required
+                           placeholder="000000" maxlength="6" pattern="[0-9]{6}"
+                           style="text-align:center; font-size:24px; letter-spacing:8px; font-family:monospace;">
+                </div>
+                <button type="submit" class="btn btn-primary btn-full" id="code-btn">Verifizieren</button>
+                <button type="button" class="btn btn-secondary btn-full" id="back-btn" style="margin-top:8px;">Zurueck</button>
+            </form>
+
+            <div style="text-align:center;margin-top:16px;">
+                <button class="btn btn-secondary btn-small theme-toggle-btn" id="theme-toggle" onclick="ThemeManager.toggle()" title="Theme wechseln" aria-label="Theme wechseln">&#9788;</button>
+            </div>
+        </div>
+    </main>
+
+    <script>
+    const ThemeManager = {
+        _key: 'osint_theme',
+        init() {
+            const saved = localStorage.getItem(this._key);
+            const theme = saved || 'dark';
+            document.documentElement.setAttribute('data-theme', theme);
+            this._updateIcon(theme);
+        },
+        toggle() {
+            const current = document.documentElement.getAttribute('data-theme') || 'dark';
+            const next = current === 'dark' ? 'light' : 'dark';
+            document.documentElement.setAttribute('data-theme', next);
+            localStorage.setItem(this._key, next);
+            this._updateIcon(next);
+        },
+        _updateIcon(theme) {
+            const btn = document.getElementById('theme-toggle');
+            if (btn) btn.textContent = theme === 'dark' ? '\u2600' : '\u263D';
+        }
+    };
+    ThemeManager.init();
+    </script>
+    <script>
+        // Pruefen ob bereits eingeloggt
+        const token = localStorage.getItem('osint_token');
+        if (token) {
+            fetch('/api/auth/me', {
+                headers: { 'Authorization': 'Bearer ' + token }
+            }).then(r => {
+                if (r.ok) window.location.href = '/dashboard';
+            });
+        }
+
+        // URL-Parameter pruefen (Magic Link Token)
+        const urlParams = new URLSearchParams(window.location.search);
+        const verifyToken = urlParams.get('token');
+
+        if (verifyToken) {
+            // Direkte Token-Verifikation
+            (async () => {
+                try {
+                    const response = await fetch('/api/auth/verify', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ token: verifyToken }),
+                    });
+                    if (!response.ok) {
+                        const data = await response.json();
+                        throw new Error(data.detail || 'Verifikation fehlgeschlagen');
+                    }
+                    const data = await response.json();
+                    localStorage.setItem('osint_token', data.access_token);
+                    localStorage.setItem('osint_username', data.username);
+                    window.location.href = '/dashboard';
+                } catch (err) {
+                    const errorEl = document.getElementById('login-error');
+                    errorEl.textContent = err.message;
+                    errorEl.style.display = 'block';
+                    // URL bereinigen
+                    window.history.replaceState({}, '', '/');
+                }
+            })();
+        }
+
+        let currentEmail = '';
+
+        // Schritt 1: E-Mail senden
+        document.getElementById('email-form').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const errorEl = document.getElementById('login-error');
+            const successEl = document.getElementById('login-success');
+            const btn = document.getElementById('email-btn');
+            errorEl.style.display = 'none';
+            successEl.style.display = 'none';
+            btn.disabled = true;
+            btn.textContent = 'Wird gesendet...';
+
+            currentEmail = document.getElementById('email').value.trim();
+
+            try {
+                const response = await fetch('/api/auth/magic-link', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ email: currentEmail }),
+                });
+
+                if (!response.ok) {
+                    const data = await response.json();
+                    throw new Error(data.detail || 'Anfrage fehlgeschlagen');
+                }
+
+                // Zu Code-Eingabe wechseln
+                document.getElementById('email-form').style.display = 'none';
+                document.getElementById('code-form').style.display = 'block';
+                document.getElementById('sent-email').textContent = currentEmail;
+                document.getElementById('code').focus();
+
+            } catch (err) {
+                errorEl.textContent = err.message;
+                errorEl.style.display = 'block';
+            } finally {
+                btn.disabled = false;
+                btn.textContent = 'Anmelden';
+            }
+        });
+
+        // Schritt 2: Code verifizieren
+        document.getElementById('code-form').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const errorEl = document.getElementById('login-error');
+            const btn = document.getElementById('code-btn');
+            errorEl.style.display = 'none';
+            btn.disabled = true;
+            btn.textContent = 'Wird geprueft...';
+
+            try {
+                const response = await fetch('/api/auth/verify-code', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        email: currentEmail,
+                        code: document.getElementById('code').value.trim(),
+                    }),
+                });
+
+                if (!response.ok) {
+                    const data = await response.json();
+                    throw new Error(data.detail || 'Verifizierung fehlgeschlagen');
+                }
+
+                const data = await response.json();
+                localStorage.setItem('osint_token', data.access_token);
+                localStorage.setItem('osint_username', data.username);
+                window.location.href = '/dashboard';
+            } catch (err) {
+                errorEl.textContent = err.message;
+                errorEl.style.display = 'block';
+            } finally {
+                btn.disabled = false;
+                btn.textContent = 'Verifizieren';
+            }
+        });
+
+        // Zurueck-Button
+        document.getElementById('back-btn').addEventListener('click', () => {
+            document.getElementById('code-form').style.display = 'none';
+            document.getElementById('email-form').style.display = 'block';
+            document.getElementById('login-error').style.display = 'none';
+            document.getElementById('code').value = '';
+        });
+    </script>
+</body>
+</html>
diff --git a/src/static/js/api.js b/src/static/js/api.js
new file mode 100644
index 0000000..13650fe
--- /dev/null
+++ b/src/static/js/api.js
@@ -0,0 +1,196 @@
+/**
+ * API-Client für den OSINT Lagemonitor.
+ */
+const API = {
+    baseUrl: '/api',
+
+    _getHeaders() {
+        const token = localStorage.getItem('osint_token');
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': token ? `Bearer ${token}` : '',
+        };
+    },
+
+    async _request(method, path, body = null) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 30000);
+
+        const options = {
+            method,
+            headers: this._getHeaders(),
+            signal: controller.signal,
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+
+        let response;
+        try {
+            response = await fetch(`${this.baseUrl}${path}`, options);
+        } catch (err) {
+            clearTimeout(timeout);
+            if (err.name === 'AbortError') {
+                throw new Error('Zeitüberschreitung bei der Anfrage');
+            }
+            throw err;
+        }
+        clearTimeout(timeout);
+
+        if (response.status === 401) {
+            localStorage.removeItem('osint_token');
+            localStorage.removeItem('osint_username');
+            window.location.href = '/';
+            return;
+        }
+
+        if (!response.ok) {
+            const data = await response.json().catch(() => ({}));
+            let detail = data.detail;
+            if (Array.isArray(detail)) {
+                detail = detail.map(e => e.msg || JSON.stringify(e)).join('; ');
+            } else if (typeof detail === 'object' && detail !== null) {
+                detail = JSON.stringify(detail);
+            }
+            throw new Error(detail || `Fehler ${response.status}`);
+        }
+
+        if (response.status === 204) return null;
+        return response.json();
+    },
+
+    // Auth
+    getMe() {
+        return this._request('GET', '/auth/me');
+    },
+
+    // Incidents
+    listIncidents(statusFilter = null) {
+        const query = statusFilter ? `?status_filter=${statusFilter}` : '';
+        return this._request('GET', `/incidents${query}`);
+    },
+
+    createIncident(data) {
+        return this._request('POST', '/incidents', data);
+    },
+
+    getRefreshingIncidents() {
+        return this._request('GET', '/incidents/refreshing');
+    },
+
+    getIncident(id) {
+        return this._request('GET', `/incidents/${id}`);
+    },
+
+    updateIncident(id, data) {
+        return this._request('PUT', `/incidents/${id}`, data);
+    },
+
+    deleteIncident(id) {
+        return this._request('DELETE', `/incidents/${id}`);
+    },
+
+    getArticles(incidentId) {
+        return this._request('GET', `/incidents/${incidentId}/articles`);
+    },
+
+    getFactChecks(incidentId) {
+        return this._request('GET', `/incidents/${incidentId}/factchecks`);
+    },
+
+    getSnapshots(incidentId) {
+        return this._request('GET', `/incidents/${incidentId}/snapshots`);
+    },
+
+    refreshIncident(id) {
+        return this._request('POST', `/incidents/${id}/refresh`);
+    },
+
+    getRefreshLog(incidentId, limit = 20) {
+        return this._request('GET', `/incidents/${incidentId}/refresh-log?limit=${limit}`);
+    },
+
+    // Sources (Quellenverwaltung)
+    listSources(params = {}) {
+        const query = new URLSearchParams();
+        if (params.source_type) query.set('source_type', params.source_type);
+        if (params.category) query.set('category', params.category);
+        if (params.source_status) query.set('source_status', params.source_status);
+        const qs = query.toString();
+        return this._request('GET', `/sources${qs ? '?' + qs : ''}`);
+    },
+
+    createSource(data) {
+        return this._request('POST', '/sources', data);
+    },
+
+    updateSource(id, data) {
+        return this._request('PUT', `/sources/${id}`, data);
+    },
+
+    deleteSource(id) {
+        return this._request('DELETE', `/sources/${id}`);
+    },
+
+    getSourceStats() {
+        return this._request('GET', '/sources/stats');
+    },
+
+    refreshSourceCounts() {
+        return this._request('POST', '/sources/refresh-counts');
+    },
+
+    discoverSource(url) {
+        return this._request('POST', '/sources/discover', { url });
+    },
+
+    discoverMulti(url) {
+        return this._request('POST', '/sources/discover-multi', { url });
+    },
+
+    rediscoverExisting() {
+        return this._request('POST', '/sources/rediscover-existing');
+    },
+
+    blockDomain(domain, notes) {
+        return this._request('POST', '/sources/block-domain', { domain, notes });
+    },
+
+    unblockDomain(domain) {
+        return this._request('POST', '/sources/unblock-domain', { domain });
+    },
+
+    deleteDomain(domain) {
+        return this._request('DELETE', `/sources/domain/${encodeURIComponent(domain)}`);
+    },
+
+    cancelRefresh(id) {
+        return this._request('POST', `/incidents/${id}/cancel-refresh`);
+    },
+
+    // Notifications
+    listNotifications(limit = 50) {
+        return this._request('GET', `/notifications?limit=${limit}`);
+    },
+
+    getUnreadCount() {
+        return this._request('GET', '/notifications/unread-count');
+    },
+
+    markNotificationsRead(ids = null) {
+        return this._request('PUT', '/notifications/mark-read', { notification_ids: ids });
+    },
+
+    // Feedback
+    sendFeedback(data) {
+        return this._request('POST', '/feedback', data);
+    },
+
+    // Export
+    exportIncident(id, format, scope) {
+        const token = localStorage.getItem('osint_token');
+        return fetch(`${this.baseUrl}/incidents/${id}/export?format=${format}&scope=${scope}`, {
+            headers: { 'Authorization': `Bearer ${token}` },
+        });
+    },
+};
diff --git a/src/static/js/app.js b/src/static/js/app.js
new file mode 100644
index 0000000..ef319ac
--- /dev/null
+++ b/src/static/js/app.js
@@ -0,0 +1,2813 @@
+/**
+ * OSINT Lagemonitor - Hauptanwendungslogik.
+ */
+
+/**
+ * Theme Manager: Dark/Light Theme Toggle mit localStorage-Persistenz.
+ */
+const ThemeManager = {
+    _key: 'osint_theme',
+    init() {
+        const saved = localStorage.getItem(this._key);
+        const theme = saved || 'dark';
+        document.documentElement.setAttribute('data-theme', theme);
+        this._updateIcon(theme);
+    },
+    toggle() {
+        const current = document.documentElement.getAttribute('data-theme') || 'dark';
+        const next = current === 'dark' ? 'light' : 'dark';
+        document.documentElement.setAttribute('data-theme', next);
+        localStorage.setItem(this._key, next);
+        this._updateIcon(next);
+    },
+    _updateIcon(theme) {
+        const btn = document.getElementById('theme-toggle');
+        if (btn) btn.textContent = theme === 'dark' ? '\u2600' : '\u263D';
+    }
+};
+
+/**
+ * Barrierefreiheits-Manager: Panel mit 4 Schaltern (Kontrast, Focus, Schrift, Animationen).
+ */
+const A11yManager = {
+    _key: 'osint_a11y',
+    _isOpen: false,
+    _settings: { contrast: false, focus: false, fontsize: false, motion: false },
+
+    init() {
+        // Einstellungen aus localStorage laden
+        try {
+            const saved = JSON.parse(localStorage.getItem(this._key) || '{}');
+            Object.keys(this._settings).forEach(k => {
+                if (typeof saved[k] === 'boolean') this._settings[k] = saved[k];
+            });
+        } catch (e) { /* Ungültige Daten ignorieren */ }
+
+        // Button + Panel dynamisch in .header-right einfügen (vor Theme-Toggle)
+        const headerRight = document.querySelector('.header-right');
+        const themeToggle = document.getElementById('theme-toggle');
+        if (!headerRight) return;
+
+        const container = document.createElement('div');
+        container.className = 'a11y-center';
+        container.innerHTML = `
+            <button class="a11y-btn" id="a11y-btn" title="Barrierefreiheit"
+                    aria-label="Barrierefreiheit" aria-expanded="false" aria-haspopup="true">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+                    <circle cx="12" cy="4" r="2"/>
+                    <path d="M12 8c-3.3 0-6 .5-6 .5v2s2.7-.5 5-.5v3l-3 7h2.5l2.5-5.5 2.5 5.5h2.5l-3-7v-3c2.3 0 5 .5 5 .5v-2S15.3 8 12 8z"/>
+                </svg>
+            </button>
+            <div class="a11y-panel" id="a11y-panel" style="display:none;">
+                <div class="a11y-panel-title">Barrierefreiheit</div>
+                <label class="a11y-option">
+                    <input type="checkbox" id="a11y-contrast">
+                    <span class="toggle-switch"></span>
+                    <span>Hoher Kontrast</span>
+                </label>
+                <label class="a11y-option">
+                    <input type="checkbox" id="a11y-focus">
+                    <span class="toggle-switch"></span>
+                    <span>Focus-Hervorhebung</span>
+                </label>
+                <label class="a11y-option">
+                    <input type="checkbox" id="a11y-fontsize">
+                    <span class="toggle-switch"></span>
+                    <span>Größere Schrift</span>
+                </label>
+                <label class="a11y-option">
+                    <input type="checkbox" id="a11y-motion">
+                    <span class="toggle-switch"></span>
+                    <span>Animationen aus</span>
+                </label>
+            </div>
+        `;
+
+        if (themeToggle) {
+            headerRight.insertBefore(container, themeToggle);
+        } else {
+            headerRight.prepend(container);
+        }
+
+        // Toggle-Event-Listener
+        ['contrast', 'focus', 'fontsize', 'motion'].forEach(key => {
+            document.getElementById('a11y-' + key).addEventListener('change', () => this.toggle(key));
+        });
+
+        // Button öffnet/schließt Panel
+        document.getElementById('a11y-btn').addEventListener('click', (e) => {
+            e.stopPropagation();
+            this._isOpen ? this._closePanel() : this._openPanel();
+        });
+
+        // Klick außerhalb schließt Panel
+        document.addEventListener('click', (e) => {
+            if (this._isOpen && !container.contains(e.target)) {
+                this._closePanel();
+            }
+        });
+
+        // Einstellungen anwenden + Checkboxen synchronisieren
+        this._apply();
+        this._syncUI();
+    },
+
+    toggle(key) {
+        this._settings[key] = !this._settings[key];
+        this._apply();
+        this._syncUI();
+        this._save();
+    },
+
+    _apply() {
+        const root = document.documentElement;
+        Object.keys(this._settings).forEach(k => {
+            if (this._settings[k]) {
+                root.setAttribute('data-a11y-' + k, 'true');
+            } else {
+                root.removeAttribute('data-a11y-' + k);
+            }
+        });
+    },
+
+    _syncUI() {
+        Object.keys(this._settings).forEach(k => {
+            const cb = document.getElementById('a11y-' + k);
+            if (cb) cb.checked = this._settings[k];
+        });
+    },
+
+    _save() {
+        localStorage.setItem(this._key, JSON.stringify(this._settings));
+    },
+
+    _openPanel() {
+        this._isOpen = true;
+        document.getElementById('a11y-panel').style.display = '';
+        document.getElementById('a11y-btn').setAttribute('aria-expanded', 'true');
+    },
+
+    _closePanel() {
+        this._isOpen = false;
+        document.getElementById('a11y-panel').style.display = 'none';
+        document.getElementById('a11y-btn').setAttribute('aria-expanded', 'false');
+    }
+};
+
+/**
+ * Notification-Center: Glocke mit Badge + History-Panel.
+ */
+const NotificationCenter = {
+    _notifications: [],
+    _unreadCount: 0,
+    _isOpen: false,
+    _maxItems: 50,
+    _syncTimer: null,
+
+    async init() {
+        // Glocken-Container dynamisch in .header-right vor #header-user einfügen
+        const headerRight = document.querySelector('.header-right');
+        const headerUser = document.getElementById('header-user');
+        if (!headerRight || !headerUser) return;
+
+        const container = document.createElement('div');
+        container.className = 'notification-center';
+        container.innerHTML = `
+            <button class="notification-bell" id="notification-bell" title="Benachrichtigungen" aria-label="Benachrichtigungen" aria-expanded="false" aria-haspopup="true">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+                    <path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"/>
+                    <path d="M13.73 21a2 2 0 0 1-3.46 0"/>
+                </svg>
+                <span class="notification-badge" id="notification-badge" style="display:none;">0</span>
+            </button>
+            <div class="notification-panel" id="notification-panel" style="display:none;">
+                <div class="notification-panel-header">
+                    <span class="notification-panel-title">Benachrichtigungen</span>
+                    <button class="notification-mark-read" id="notification-mark-read">Alle gelesen</button>
+                </div>
+                <div class="notification-panel-list" id="notification-panel-list">
+                    <div class="notification-empty">Keine Benachrichtigungen</div>
+                </div>
+            </div>
+        `;
+        headerRight.insertBefore(container, headerUser);
+
+        // Event-Listener
+        document.getElementById('notification-bell').addEventListener('click', (e) => {
+            e.stopPropagation();
+            this.toggle();
+        });
+        document.getElementById('notification-mark-read').addEventListener('click', (e) => {
+            e.stopPropagation();
+            this.markAllRead();
+        });
+        // Klick außerhalb schließt Panel
+        document.addEventListener('click', (e) => {
+            if (this._isOpen && !container.contains(e.target)) {
+                this.close();
+            }
+        });
+
+        // Notifications aus DB laden
+        await this._loadFromDB();
+    },
+
+    add(notification) {
+        // Optimistisches UI: sofort anzeigen
+        notification.read = false;
+        notification.timestamp = notification.timestamp || new Date().toISOString();
+        this._notifications.unshift(notification);
+        if (this._notifications.length > this._maxItems) {
+            this._notifications.pop();
+        }
+        this._unreadCount++;
+        this._updateBadge();
+        this._renderList();
+
+        // DB-Sync mit Debounce (Orchestrator schreibt parallel in DB)
+        clearTimeout(this._syncTimer);
+        this._syncTimer = setTimeout(() => this._syncFromDB(), 500);
+    },
+
+    toggle() {
+        this._isOpen ? this.close() : this.open();
+    },
+
+    open() {
+        this._isOpen = true;
+        const panel = document.getElementById('notification-panel');
+        if (panel) panel.style.display = 'flex';
+        const bell = document.getElementById('notification-bell');
+        if (bell) bell.setAttribute('aria-expanded', 'true');
+    },
+
+    close() {
+        this._isOpen = false;
+        const panel = document.getElementById('notification-panel');
+        if (panel) panel.style.display = 'none';
+        const bell = document.getElementById('notification-bell');
+        if (bell) bell.setAttribute('aria-expanded', 'false');
+    },
+
+    async markAllRead() {
+        this._notifications.forEach(n => n.read = true);
+        this._unreadCount = 0;
+        this._updateBadge();
+        this._renderList();
+
+        // In DB als gelesen markieren (fire-and-forget)
+        try {
+            await API.markNotificationsRead(null);
+        } catch (e) {
+            console.warn('Notifications als gelesen markieren fehlgeschlagen:', e);
+        }
+    },
+
+    _updateBadge() {
+        const badge = document.getElementById('notification-badge');
+        if (!badge) return;
+        if (this._unreadCount > 0) {
+            badge.style.display = 'flex';
+            badge.textContent = this._unreadCount > 99 ? '99+' : this._unreadCount;
+            document.title = `(${this._unreadCount}) ${App._originalTitle}`;
+        } else {
+            badge.style.display = 'none';
+            document.title = App._originalTitle;
+        }
+    },
+
+    _renderList() {
+        const list = document.getElementById('notification-panel-list');
+        if (!list) return;
+
+        if (this._notifications.length === 0) {
+            list.innerHTML = '<div class="notification-empty">Keine Benachrichtigungen</div>';
+            return;
+        }
+
+        list.innerHTML = this._notifications.map(n => {
+            const time = new Date(n.timestamp);
+            const timeStr = time.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
+            const unreadClass = n.read ? '' : ' unread';
+            const icon = n.icon || 'info';
+            return `<div class="notification-item${unreadClass}" onclick="NotificationCenter._handleClick(${n.incident_id})" data-id="${n.incident_id}">
+                <div class="notification-item-icon ${icon}">${this._iconSymbol(icon)}</div>
+                <div class="notification-item-body">
+                    <div class="notification-item-title">${this._escapeHtml(n.title)}</div>
+                    <div class="notification-item-text">${this._escapeHtml(n.text)}</div>
+                </div>
+                <div class="notification-item-time">${timeStr}</div>
+            </div>`;
+        }).join('');
+    },
+
+    _handleClick(incidentId) {
+        this.close();
+        if (incidentId) {
+            App.selectIncident(incidentId);
+        }
+    },
+
+    _iconSymbol(type) {
+        switch (type) {
+            case 'success': return '\u2713';
+            case 'warning': return '!';
+            case 'error': return '\u2717';
+            default: return 'i';
+        }
+    },
+
+    _escapeHtml(text) {
+        const d = document.createElement('div');
+        d.textContent = text || '';
+        return d.innerHTML;
+    },
+
+    async _loadFromDB() {
+        try {
+            const items = await API.listNotifications(50);
+            this._notifications = items.map(n => ({
+                id: n.id,
+                incident_id: n.incident_id,
+                title: n.title,
+                text: n.text,
+                icon: n.icon || 'info',
+                type: n.type,
+                read: !!n.is_read,
+                timestamp: n.created_at,
+            }));
+            this._unreadCount = this._notifications.filter(n => !n.read).length;
+            this._updateBadge();
+            this._renderList();
+        } catch (e) {
+            console.warn('Notifications laden fehlgeschlagen:', e);
+        }
+    },
+
+    async _syncFromDB() {
+        try {
+            const items = await API.listNotifications(50);
+            this._notifications = items.map(n => ({
+                id: n.id,
+                incident_id: n.incident_id,
+                title: n.title,
+                text: n.text,
+                icon: n.icon || 'info',
+                type: n.type,
+                read: !!n.is_read,
+                timestamp: n.created_at,
+            }));
+            this._unreadCount = this._notifications.filter(n => !n.read).length;
+            this._updateBadge();
+            this._renderList();
+        } catch (e) {
+            console.warn('Notifications sync fehlgeschlagen:', e);
+        }
+    },
+};
+
+const App = {
+    currentIncidentId: null,
+    incidents: [],
+    _originalTitle: document.title,
+    _notificationCount: 0,
+    _refreshingIncidents: new Set(),
+    _editingIncidentId: null,
+    _currentArticles: [],
+    _currentIncidentType: 'adhoc',
+    _sidebarFilter: 'all',
+    _currentUsername: '',
+    _allSources: [],
+    _sourcesOnly: [],
+    _blacklistOnly: [],
+    _expandedGroups: new Set(),
+    _editingSourceId: null,
+    _timelineFilter: 'all',
+    _timelineRange: 'all',
+    _activePointIndex: null,
+    _timelineSearchTimer: null,
+    _pendingComplete: null,
+    _pendingCompleteTimer: null,
+
+    async init() {
+        ThemeManager.init();
+        A11yManager.init();
+        // Auth prüfen
+        const token = localStorage.getItem('osint_token');
+        if (!token) {
+            window.location.href = '/';
+            return;
+        }
+
+        try {
+            const user = await API.getMe();
+            this._currentUsername = user.username;
+            document.getElementById('header-user').textContent = user.username;
+        } catch {
+            window.location.href = '/';
+            return;
+        }
+
+        // Event-Listener
+        document.getElementById('logout-btn').addEventListener('click', () => this.logout());
+        document.getElementById('new-incident-btn').addEventListener('click', () => openModal('modal-new'));
+        document.getElementById('new-incident-form').addEventListener('submit', (e) => this.handleFormSubmit(e));
+        document.getElementById('refresh-btn').addEventListener('click', () => this.handleRefresh());
+        document.getElementById('delete-incident-btn').addEventListener('click', () => this.handleDelete());
+        document.getElementById('edit-incident-btn').addEventListener('click', () => this.handleEdit());
+        document.getElementById('archive-incident-btn').addEventListener('click', () => this.handleArchive());
+        document.getElementById('inc-international').addEventListener('change', () => updateSourcesHint());
+        document.getElementById('inc-visibility').addEventListener('change', () => updateVisibilityHint());
+
+        // Feedback
+        document.getElementById('feedback-form').addEventListener('submit', (e) => this.submitFeedback(e));
+        document.getElementById('fb-message').addEventListener('input', (e) => {
+            document.getElementById('fb-char-count').textContent = e.target.value.length.toLocaleString('de-DE');
+        });
+
+        // Notification-Center initialisieren
+        await NotificationCenter.init();
+
+        // WebSocket
+        WS.connect();
+        WS.on('status_update', (msg) => this.handleStatusUpdate(msg));
+        WS.on('refresh_complete', (msg) => this.handleRefreshComplete(msg));
+        WS.on('notification', (msg) => this.handleNotification(msg));
+        WS.on('refresh_summary', (msg) => this.handleRefreshSummary(msg));
+        WS.on('refresh_error', (msg) => this.handleRefreshError(msg));
+        WS.on('refresh_cancelled', (msg) => this.handleRefreshCancelled(msg));
+
+        // Sidebar-Chevrons initial auf offen setzen (Archiv geschlossen)
+        document.querySelectorAll('.sidebar-chevron').forEach(c => c.classList.add('open'));
+        document.getElementById('archived-incidents').style.display = 'none';
+        document.getElementById('chevron-archived-incidents').classList.remove('open');
+
+        // Lagen laden
+        await this.loadIncidents();
+
+        // Laufende Refreshes wiederherstellen
+        try {
+            const data = await API.getRefreshingIncidents();
+            if (data.refreshing && data.refreshing.length > 0) {
+                data.refreshing.forEach(id => this._refreshingIncidents.add(id));
+                // Sidebar-Dots aktualisieren
+                data.refreshing.forEach(id => this._updateSidebarDot(id));
+            }
+        } catch (e) { /* Kein kritischer Fehler */ }
+
+        // Zuletzt ausgewählte Lage wiederherstellen
+        const savedId = localStorage.getItem('selectedIncidentId');
+        if (savedId) {
+            const id = parseInt(savedId, 10);
+            if (this.incidents.some(inc => inc.id === id)) {
+                await this.selectIncident(id);
+            }
+        }
+    },
+
+    async loadIncidents() {
+        try {
+            this.incidents = await API.listIncidents();
+            this.renderSidebar();
+        } catch (err) {
+            UI.showToast('Fehler beim Laden der Lagen: ' + err.message, 'error');
+        }
+    },
+
+    renderSidebar() {
+        const activeContainer = document.getElementById('active-incidents');
+        const archivedContainer = document.getElementById('archived-incidents');
+
+        // Filter-Buttons aktualisieren
+        document.querySelectorAll('.sidebar-filter-btn').forEach(btn => {
+            const isActive = btn.dataset.filter === this._sidebarFilter;
+            btn.classList.toggle('active', isActive);
+            btn.setAttribute('aria-pressed', String(isActive));
+        });
+
+        // Lagen nach Filter einschränken
+        let filtered = this.incidents;
+        if (this._sidebarFilter === 'mine') {
+            filtered = filtered.filter(i => i.created_by_username === this._currentUsername);
+        }
+
+        const active = filtered.filter(i => i.status === 'active');
+        const archived = filtered.filter(i => i.status === 'archived');
+
+        const emptyLabel = this._sidebarFilter === 'mine' ? 'Keine eigenen Lagen' : 'Keine aktiven Lagen';
+
+        activeContainer.innerHTML = active.length
+            ? active.map(i => UI.renderIncidentItem(i, i.id === this.currentIncidentId)).join('')
+            : `<div style="padding:8px 12px;font-size:12px;color:var(--text-tertiary);">${emptyLabel}</div>`;
+
+        archivedContainer.innerHTML = archived.length
+            ? archived.map(i => UI.renderIncidentItem(i, i.id === this.currentIncidentId)).join('')
+            : '<div style="padding:8px 12px;font-size:12px;color:var(--text-tertiary);">Kein Archiv</div>';
+
+        // Sidebar-Stats aktualisieren
+        this.updateSidebarStats();
+    },
+
+    setSidebarFilter(filter) {
+        this._sidebarFilter = filter;
+        this.renderSidebar();
+    },
+
+    async selectIncident(id) {
+        this.closeRefreshHistory();
+        this.currentIncidentId = id;
+        localStorage.setItem('selectedIncidentId', id);
+        this.renderSidebar();
+
+        document.getElementById('empty-state').style.display = 'none';
+        document.getElementById('incident-view').style.display = 'flex';
+
+        // gridstack-Layout initialisieren (einmalig)
+        if (typeof LayoutManager !== 'undefined') LayoutManager.init();
+
+        // Refresh-Status für diese Lage wiederherstellen
+        const isRefreshing = this._refreshingIncidents.has(id);
+        this._updateRefreshButton(isRefreshing);
+        if (isRefreshing) {
+            UI.showProgress('researching');
+        } else {
+            UI.hideProgress();
+        }
+
+        await this.loadIncidentDetail(id);
+    },
+
+    async loadIncidentDetail(id) {
+        try {
+            const [incident, articles, factchecks, snapshots] = await Promise.all([
+                API.getIncident(id),
+                API.getArticles(id),
+                API.getFactChecks(id),
+                API.getSnapshots(id),
+            ]);
+
+            this.renderIncidentDetail(incident, articles, factchecks, snapshots);
+        } catch (err) {
+            UI.showToast('Fehler beim Laden: ' + err.message, 'error');
+        }
+    },
+
+    renderIncidentDetail(incident, articles, factchecks, snapshots) {
+        // Header Strip
+        document.getElementById('incident-title').textContent = incident.title;
+        document.getElementById('incident-description').textContent = incident.description || '';
+
+        // Typ-Badge
+        const typeBadge = document.getElementById('incident-type-badge');
+        typeBadge.className = 'incident-type-badge ' + (incident.type === 'research' ? 'type-research' : 'type-adhoc');
+        typeBadge.textContent = incident.type === 'research' ? 'Recherche' : 'Breaking';
+
+        // Archiv-Button Text
+        this._updateArchiveButton(incident.status);
+
+        // Ersteller anzeigen
+        const creatorEl = document.getElementById('incident-creator');
+        if (creatorEl) {
+            creatorEl.textContent = incident.created_by_username || '';
+        }
+
+        // Delete-Button: nur Ersteller darf löschen
+        const deleteBtn = document.getElementById('delete-incident-btn');
+        const isCreator = incident.created_by_username === this._currentUsername;
+        deleteBtn.disabled = !isCreator;
+        deleteBtn.title = isCreator ? '' : `Nur ${incident.created_by_username} kann diese Lage löschen`;
+
+        // Zusammenfassung mit Quellenverzeichnis
+        const summaryText = document.getElementById('summary-text');
+        if (incident.summary) {
+            summaryText.innerHTML = UI.renderSummary(
+                incident.summary,
+                incident.sources_json,
+                incident.type
+            );
+        } else {
+            summaryText.innerHTML = '<span style="color:var(--text-disabled);">Noch keine Zusammenfassung. Klicke auf "Aktualisieren" um die Recherche zu starten.</span>';
+        }
+
+        // Meta (im Header-Strip) — relative Zeitangabe mit vollem Datum als Tooltip
+        const updated = incident.updated_at ? new Date(incident.updated_at) : null;
+        const metaUpdated = document.getElementById('meta-updated');
+        if (updated) {
+            const fullDate = `${updated.toLocaleDateString('de-DE')} ${updated.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })}`;
+            metaUpdated.textContent = `Stand: ${App._timeAgo(updated)}`;
+            metaUpdated.title = fullDate;
+        } else {
+            metaUpdated.textContent = '';
+            metaUpdated.title = '';
+        }
+
+        // Zeitstempel direkt im Lagebild-Card-Header
+        const lagebildTs = document.getElementById('lagebild-timestamp');
+        if (lagebildTs) {
+            lagebildTs.textContent = updated
+                ? `Stand: ${updated.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric' })} ${updated.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })} Uhr`
+                : '';
+        }
+
+        document.getElementById('meta-refresh-mode').textContent = incident.refresh_mode === 'auto'
+            ? `Auto alle ${App._formatInterval(incident.refresh_interval)}`
+            : 'Manuell';
+
+        // International-Badge
+        const intlBadge = document.getElementById('intl-badge');
+        if (intlBadge) {
+            const isIntl = incident.international_sources !== false && incident.international_sources !== 0;
+            intlBadge.className = 'intl-badge ' + (isIntl ? 'intl-yes' : 'intl-no');
+            intlBadge.textContent = isIntl ? 'International' : 'Nur DE';
+        }
+
+        // Faktencheck
+        const fcFilters = document.getElementById('fc-filters');
+        const factcheckList = document.getElementById('factcheck-list');
+        if (factchecks.length > 0) {
+            fcFilters.innerHTML = UI.renderFactCheckFilters(factchecks);
+            factcheckList.innerHTML = factchecks.map(fc => UI.renderFactCheck(fc)).join('');
+        } else {
+            fcFilters.innerHTML = '';
+            factcheckList.innerHTML = '<div style="padding:12px;font-size:13px;color:var(--text-tertiary);">Noch keine Fakten geprüft</div>';
+        }
+
+        // Quellenübersicht
+        const sourceOverview = document.getElementById('source-overview-content');
+        if (sourceOverview) {
+            sourceOverview.innerHTML = UI.renderSourceOverview(articles);
+            // Kachel an Inhalt anpassen
+            if (typeof LayoutManager !== 'undefined' && LayoutManager._grid) {
+                if (sourceOverview.style.display !== 'none') {
+                    // Offen → an Inhalt anpassen
+                    requestAnimationFrame(() => requestAnimationFrame(() => {
+                        LayoutManager.resizeTileToContent('quellen');
+                    }));
+                } else {
+                    // Geschlossen → einheitliche Default-Höhe
+                    const defaults = LayoutManager.DEFAULT_LAYOUT.find(d => d.id === 'quellen');
+                    if (defaults) {
+                        const node = LayoutManager._grid.engine.nodes.find(
+                            n => n.el && n.el.getAttribute('gs-id') === 'quellen'
+                        );
+                        if (node) LayoutManager._grid.update(node.el, { h: defaults.h });
+                    }
+                }
+            }
+        }
+
+        // Timeline - Artikel + Snapshots zwischenspeichern und rendern
+        this._currentArticles = articles;
+        this._currentSnapshots = snapshots || [];
+        this._currentIncidentType = incident.type;
+        this._timelineFilter = 'all';
+        this._timelineRange = 'all';
+        this._activePointIndex = null;
+        document.getElementById('timeline-search').value = '';
+        document.querySelectorAll('.ht-filter-btn').forEach(btn => {
+            const isActive = btn.dataset.filter === 'all';
+            btn.classList.toggle('active', isActive);
+            btn.setAttribute('aria-pressed', String(isActive));
+        });
+        document.querySelectorAll('.ht-range-btn').forEach(btn => {
+            const isActive = btn.dataset.range === 'all';
+            btn.classList.toggle('active', isActive);
+            btn.setAttribute('aria-pressed', String(isActive));
+        });
+        this.rerenderTimeline();
+        this._resizeTimelineTile();
+    },
+
+    _collectEntries(filterType, searchTerm, range) {
+        const type = this._currentIncidentType;
+        const getArticleDate = (a) => (type === 'research' && a.published_at) ? a.published_at : a.collected_at;
+
+        let entries = [];
+
+        if (filterType === 'all' || filterType === 'articles') {
+            let articles = this._currentArticles || [];
+            if (searchTerm) {
+                articles = articles.filter(a => {
+                    const text = `${a.headline || ''} ${a.headline_de || ''} ${a.source || ''} ${a.content_de || ''} ${a.content_original || ''}`.toLowerCase();
+                    return text.includes(searchTerm);
+                });
+            }
+            articles.forEach(a => entries.push({ kind: 'article', data: a, timestamp: getArticleDate(a) || '' }));
+        }
+
+        if (filterType === 'all' || filterType === 'snapshots') {
+            let snapshots = this._currentSnapshots || [];
+            if (searchTerm) {
+                snapshots = snapshots.filter(s => (s.summary || '').toLowerCase().includes(searchTerm));
+            }
+            snapshots.forEach(s => entries.push({ kind: 'snapshot', data: s, timestamp: s.created_at || '' }));
+        }
+
+        if (range && range !== 'all') {
+            const now = Date.now();
+            const cutoff = range === '24h' ? now - 24 * 60 * 60 * 1000 : now - 7 * 24 * 60 * 60 * 1000;
+            entries = entries.filter(e => new Date(e.timestamp || 0).getTime() >= cutoff);
+        }
+
+        return entries;
+    },
+
+    _updateTimelineCount(entries) {
+        const articleCount = entries.filter(e => e.kind === 'article').length;
+        const snapshotCount = entries.filter(e => e.kind === 'snapshot').length;
+        const countEl = document.getElementById('article-count');
+        if (articleCount > 0 && snapshotCount > 0) {
+            countEl.innerHTML = `<span class="ht-legend-dot"></span> ${articleCount} Meldung${articleCount !== 1 ? 'en' : ''} + <span class="ht-legend-dot ht-legend-gold"></span> ${snapshotCount} Lagebericht${snapshotCount !== 1 ? 'e' : ''}`;
+        } else if (articleCount > 0) {
+            countEl.innerHTML = `<span class="ht-legend-dot"></span> ${articleCount} Meldung${articleCount !== 1 ? 'en' : ''}`;
+        } else if (snapshotCount > 0) {
+            countEl.innerHTML = `<span class="ht-legend-dot ht-legend-gold"></span> ${snapshotCount} Lagebericht${snapshotCount !== 1 ? 'e' : ''}`;
+        } else {
+            countEl.textContent = '0 Meldungen';
+        }
+    },
+
+    debouncedRerenderTimeline() {
+        clearTimeout(this._timelineSearchTimer);
+        this._timelineSearchTimer = setTimeout(() => this.rerenderTimeline(), 250);
+    },
+
+    rerenderTimeline() {
+        const container = document.getElementById('timeline');
+        const searchTerm = (document.getElementById('timeline-search').value || '').toLowerCase();
+        const filterType = this._timelineFilter;
+        const range = this._timelineRange;
+
+        let entries = this._collectEntries(filterType, searchTerm, range);
+        this._updateTimelineCount(entries);
+
+        if (entries.length === 0) {
+            this._activePointIndex = null;
+            container.innerHTML = (searchTerm || range !== 'all')
+                ? '<div class="ht-empty">Keine Einträge im gewählten Zeitraum.</div>'
+                : '<div class="ht-empty">Noch keine Meldungen. Starte eine Recherche mit "Aktualisieren".</div>';
+            return;
+        }
+
+        entries.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+
+        const granularity = this._calcGranularity(entries, range);
+        let buckets = this._buildBuckets(entries, granularity);
+        buckets = this._mergeCloseBuckets(buckets);
+
+        // Aktiven Index validieren
+        if (this._activePointIndex !== null && this._activePointIndex >= buckets.length) {
+            this._activePointIndex = null;
+        }
+
+        // Achsen-Bereich
+        const rangeStart = buckets[0].timestamp;
+        const rangeEnd = buckets[buckets.length - 1].timestamp;
+        const maxCount = Math.max(...buckets.map(b => b.entries.length));
+
+        // Stunden- vs. Tages-Granularität
+        const isHourly = granularity === 'hour';
+        const axisLabels = this._buildAxisLabels(buckets, granularity, true);
+
+        // HTML aufbauen
+        let html = `<div class="ht-axis${isHourly ? ' ht-axis--hourly' : ''}">`;
+
+        // Datums-Marker (immer anzeigen, ausgedünnt)
+        const dayMarkers = this._thinLabels(this._buildDayMarkers(buckets, rangeStart, rangeEnd), 10);
+        html += '<div class="ht-day-markers">';
+        dayMarkers.forEach(m => {
+            html += `<div class="ht-day-marker" style="left:${m.pos}%;">`;
+            html += `<div class="ht-day-marker-label">${UI.escape(m.text)}</div>`;
+            html += `<div class="ht-day-marker-line"></div>`;
+            html += `</div>`;
+        });
+        html += '</div>';
+
+        // Punkte
+        html += '<div class="ht-points">';
+        buckets.forEach((bucket, idx) => {
+            const pos = this._bucketPositionPercent(bucket, rangeStart, rangeEnd, buckets.length);
+            const size = this._calcPointSize(bucket.entries.length, maxCount);
+            const hasSnapshots = bucket.entries.some(e => e.kind === 'snapshot');
+            const hasArticles = bucket.entries.some(e => e.kind === 'article');
+
+            let pointClass = 'ht-point';
+            if (filterType === 'snapshots') {
+                pointClass += ' ht-snapshot-point';
+            } else if (hasSnapshots) {
+                pointClass += ' ht-mixed-point';
+            }
+            if (this._activePointIndex === idx) pointClass += ' active';
+
+            const tooltip = `${bucket.label}: ${bucket.entries.length} Eintr${bucket.entries.length === 1 ? 'ag' : 'äge'}`;
+
+            html += `<div class="${pointClass}" style="left:${pos}%;width:${size}px;height:${size}px;" onclick="App.openTimelineDetail(${idx})" data-idx="${idx}">`;
+            html += `<div class="ht-tooltip">${UI.escape(tooltip)}</div>`;
+            html += `</div>`;
+        });
+        html += '</div>';
+
+        // Achsenlinie
+        html += '<div class="ht-axis-line"></div>';
+
+        // Achsen-Labels (ausgedünnt um Überlappung zu vermeiden)
+        const thinned = this._thinLabels(axisLabels);
+        html += '<div class="ht-axis-labels">';
+        thinned.forEach(lbl => {
+            html += `<div class="ht-axis-label" style="left:${lbl.pos}%;">${UI.escape(lbl.text)}</div>`;
+        });
+        html += '</div>';
+        html += '</div>';
+
+        // Detail-Panel (wenn ein Punkt aktiv ist)
+        if (this._activePointIndex !== null && this._activePointIndex < buckets.length) {
+            html += this._renderDetailPanel(buckets[this._activePointIndex]);
+        }
+
+        container.innerHTML = html;
+    },
+
+    _calcGranularity(entries, range) {
+        if (entries.length < 2) return 'day';
+        const timestamps = entries.map(e => new Date(e.timestamp || 0).getTime()).filter(t => t > 0);
+        if (timestamps.length < 2) return 'day';
+        const span = Math.max(...timestamps) - Math.min(...timestamps);
+        if (range === '24h' || span <= 48 * 60 * 60 * 1000) return 'hour';
+        return 'day';
+    },
+
+    _buildBuckets(entries, granularity) {
+        const bucketMap = {};
+        entries.forEach(e => {
+            const d = new Date(e.timestamp || 0);
+            let key, label, ts;
+            if (granularity === 'hour') {
+                key = `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}-${d.getHours()}`;
+                label = d.toLocaleDateString('de-DE', { day: '2-digit', month: 'short' }) + ', ' + d.getHours().toString().padStart(2, '0') + ':00';
+                ts = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours()).getTime();
+            } else {
+                key = `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+                label = d.toLocaleDateString('de-DE', { weekday: 'short', day: '2-digit', month: 'short' });
+                ts = new Date(d.getFullYear(), d.getMonth(), d.getDate(), 12).getTime();
+            }
+            if (!bucketMap[key]) {
+                bucketMap[key] = { key, label, timestamp: ts, entries: [] };
+            }
+            bucketMap[key].entries.push(e);
+        });
+        return Object.values(bucketMap).sort((a, b) => a.timestamp - b.timestamp);
+    },
+
+    _mergeCloseBuckets(buckets) {
+        if (buckets.length < 2) return buckets;
+        const rangeStart = buckets[0].timestamp;
+        const rangeEnd = buckets[buckets.length - 1].timestamp;
+        if (rangeEnd <= rangeStart) return buckets;
+
+        const container = document.getElementById('timeline');
+        const axisWidth = (container ? container.offsetWidth : 800) * 0.92;
+        const maxCount = Math.max(...buckets.map(b => b.entries.length));
+        const result = [buckets[0]];
+
+        for (let i = 1; i < buckets.length; i++) {
+            const prev = result[result.length - 1];
+            const curr = buckets[i];
+
+            const distPx = ((curr.timestamp - prev.timestamp) / (rangeEnd - rangeStart)) * axisWidth;
+            const prevSize = Math.min(32, this._calcPointSize(prev.entries.length, maxCount));
+            const currSize = Math.min(32, this._calcPointSize(curr.entries.length, maxCount));
+            const minDistPx = (prevSize + currSize) / 2 + 6;
+
+            if (distPx < minDistPx) {
+                prev.entries = prev.entries.concat(curr.entries);
+            } else {
+                result.push(curr);
+            }
+        }
+        return result;
+    },
+
+    _bucketPositionPercent(bucket, rangeStart, rangeEnd, totalBuckets) {
+        if (totalBuckets === 1) return 50;
+        if (rangeEnd === rangeStart) return 50;
+        return ((bucket.timestamp - rangeStart) / (rangeEnd - rangeStart)) * 100;
+    },
+
+    _calcPointSize(count, maxCount) {
+        if (maxCount <= 1) return 16;
+        const minSize = 12;
+        const maxSize = 32;
+        const logScale = Math.log(count + 1) / Math.log(maxCount + 1);
+        return Math.round(minSize + logScale * (maxSize - minSize));
+    },
+
+    _buildAxisLabels(buckets, granularity, timeOnly) {
+        if (buckets.length === 0) return [];
+        const maxLabels = 8;
+        const labels = [];
+        const rangeStart = buckets[0].timestamp;
+        const rangeEnd = buckets[buckets.length - 1].timestamp;
+
+        const getLabelText = (b) => {
+            if (timeOnly) {
+                // Bei Tages-Granularität: Uhrzeit des ersten Eintrags nehmen
+                const ts = (granularity === 'day' && b.entries && b.entries.length > 0)
+                    ? new Date(b.entries[0].timestamp || b.timestamp)
+                    : new Date(b.timestamp);
+                return ts.getHours().toString().padStart(2, '0') + ':' + ts.getMinutes().toString().padStart(2, '0');
+            }
+            return b.label;
+        };
+
+        if (buckets.length <= maxLabels) {
+            buckets.forEach(b => {
+                labels.push({ text: getLabelText(b), pos: this._bucketPositionPercent(b, rangeStart, rangeEnd, buckets.length) });
+            });
+        } else {
+            const step = (buckets.length - 1) / (maxLabels - 1);
+            for (let i = 0; i < maxLabels; i++) {
+                const idx = Math.round(i * step);
+                const b = buckets[idx];
+                labels.push({ text: getLabelText(b), pos: this._bucketPositionPercent(b, rangeStart, rangeEnd, buckets.length) });
+            }
+        }
+        return labels;
+    },
+
+    _thinLabels(labels, minGapPercent) {
+        if (!labels || labels.length <= 1) return labels;
+        const gap = minGapPercent || 8;
+        const result = [labels[0]];
+        for (let i = 1; i < labels.length; i++) {
+            if (labels[i].pos - result[result.length - 1].pos >= gap) {
+                result.push(labels[i]);
+            }
+        }
+        return result;
+    },
+
+    _buildDayMarkers(buckets, rangeStart, rangeEnd) {
+        const seen = {};
+        const markers = [];
+        buckets.forEach(b => {
+            const d = new Date(b.timestamp);
+            const dayKey = `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+            if (!seen[dayKey]) {
+                seen[dayKey] = true;
+                const now = new Date();
+                const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                const yesterday = new Date(today.getTime() - 86400000);
+                const bucketDay = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+                let label;
+                const dateStr = d.toLocaleDateString('de-DE', { day: '2-digit', month: 'short' });
+                if (bucketDay.getTime() === today.getTime()) {
+                    label = 'Heute, ' + dateStr;
+                } else if (bucketDay.getTime() === yesterday.getTime()) {
+                    label = 'Gestern, ' + dateStr;
+                } else {
+                    label = d.toLocaleDateString('de-DE', { weekday: 'short', day: '2-digit', month: 'short' });
+                }
+                const pos = this._bucketPositionPercent(b, rangeStart, rangeEnd, buckets.length);
+                markers.push({ text: label, pos });
+            }
+        });
+        return markers;
+    },
+
+    _renderDetailPanel(bucket) {
+        const type = this._currentIncidentType;
+        const sorted = [...bucket.entries].sort((a, b) => {
+            if (a.kind === 'snapshot' && b.kind !== 'snapshot') return -1;
+            if (a.kind !== 'snapshot' && b.kind === 'snapshot') return 1;
+            return new Date(b.timestamp || 0) - new Date(a.timestamp || 0);
+        });
+
+        let entriesHtml = '';
+        sorted.forEach(e => {
+            if (e.kind === 'snapshot') {
+                entriesHtml += this._renderSnapshotEntry(e.data);
+            } else {
+                entriesHtml += this._renderArticleEntry(e.data, type, 0);
+            }
+        });
+
+        return `<div class="ht-detail-panel">
+            <div class="ht-detail-header">
+                <span class="ht-detail-title">${UI.escape(bucket.label)} (${bucket.entries.length} Eintr${bucket.entries.length === 1 ? 'ag' : 'äge'})</span>
+                <button class="ht-detail-close" onclick="App.closeTimelineDetail()">&times;</button>
+            </div>
+            <div class="ht-detail-content">${entriesHtml}</div>
+        </div>`;
+    },
+
+    setTimelineFilter(filter) {
+        this._timelineFilter = filter;
+        this._activePointIndex = null;
+        document.querySelectorAll('.ht-filter-btn').forEach(btn => {
+            const isActive = btn.dataset.filter === filter;
+            btn.classList.toggle('active', isActive);
+            btn.setAttribute('aria-pressed', String(isActive));
+        });
+        this.rerenderTimeline();
+    },
+
+    setTimelineRange(range) {
+        this._timelineRange = range;
+        this._activePointIndex = null;
+        document.querySelectorAll('.ht-range-btn').forEach(btn => {
+            const isActive = btn.dataset.range === range;
+            btn.classList.toggle('active', isActive);
+            btn.setAttribute('aria-pressed', String(isActive));
+        });
+        this.rerenderTimeline();
+    },
+
+    openTimelineDetail(bucketIndex) {
+        if (this._activePointIndex === bucketIndex) {
+            this._activePointIndex = null;
+        } else {
+            this._activePointIndex = bucketIndex;
+        }
+        this.rerenderTimeline();
+        this._resizeTimelineTile();
+    },
+
+    closeTimelineDetail() {
+        this._activePointIndex = null;
+        this.rerenderTimeline();
+        this._resizeTimelineTile();
+    },
+
+    _resizeTimelineTile() {
+        if (typeof LayoutManager === 'undefined' || !LayoutManager._grid) return;
+        requestAnimationFrame(() => { requestAnimationFrame(() => {
+            // Prüfen ob Detail-Panel oder expandierter Eintrag offen ist
+            const hasDetail = document.querySelector('.ht-detail-panel') !== null;
+            const hasExpanded = document.querySelector('.timeline-card .vt-entry.expanded') !== null;
+
+            if (hasDetail || hasExpanded) {
+                LayoutManager.resizeTileToContent('timeline');
+            } else {
+                // Zurück auf Default-Höhe
+                const defaults = LayoutManager.DEFAULT_LAYOUT.find(d => d.id === 'timeline');
+                if (defaults) {
+                    const node = LayoutManager._grid.engine.nodes.find(
+                        n => n.el && n.el.getAttribute('gs-id') === 'timeline'
+                    );
+                    if (node) {
+                        LayoutManager._grid.update(node.el, { h: defaults.h });
+                        LayoutManager._debouncedSave();
+                    }
+                }
+            }
+            // Scroll in Sicht
+            const card = document.querySelector('.timeline-card');
+            const main = document.querySelector('.main-content');
+            if (!card || !main) return;
+            const cardBottom = card.getBoundingClientRect().bottom;
+            const mainBottom = main.getBoundingClientRect().bottom;
+            if (cardBottom > mainBottom) {
+                main.scrollBy({ top: cardBottom - mainBottom + 16, behavior: document.documentElement.dataset.a11yMotion ? 'instant' : 'smooth' });
+            }
+        }); });
+    },
+
+    _buildFullVerticalTimeline(filterType, searchTerm) {
+        let entries = this._collectEntries(filterType, searchTerm);
+        if (entries.length === 0) {
+            return '<div class="ht-empty">Keine Einträge.</div>';
+        }
+
+        entries.sort((a, b) => new Date(b.timestamp || 0) - new Date(a.timestamp || 0));
+        const granularity = this._calcGranularity(entries);
+        const groups = this._groupByTimePeriod(entries, granularity);
+
+        let html = '<div class="vt-timeline">';
+        groups.forEach(g => {
+            html += `<div class="vt-time-group">`;
+            html += `<div class="vt-time-label"><span class="vt-time-label-text">${UI.escape(g.label)}</span></div>`;
+            html += this._renderTimeGroupEntries(g.entries, this._currentIncidentType);
+            html += `</div>`;
+        });
+        html += '</div>';
+        return html;
+    },
+
+    /**
+     * Einträge nach Zeitperiode gruppieren.
+     */
+    _groupByTimePeriod(entries, granularity) {
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const yesterday = new Date(today.getTime() - 86400000);
+
+        const groups = [];
+        let currentGroup = null;
+
+        entries.forEach(entry => {
+            const d = entry.timestamp ? new Date(entry.timestamp) : null;
+            let key, label;
+
+            if (!d || isNaN(d.getTime())) {
+                key = 'unknown';
+                label = 'Unbekannt';
+            } else if (granularity === 'hour') {
+                const h = d.getHours();
+                key = `${d.toDateString()}-${h}`;
+                label = `${h.toString().padStart(2, '0')}:00 Uhr`;
+            } else {
+                const entryDate = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+                key = entryDate.toDateString();
+                if (entryDate.getTime() === today.getTime()) {
+                    label = 'Heute';
+                } else if (entryDate.getTime() === yesterday.getTime()) {
+                    label = 'Gestern';
+                } else {
+                    label = d.toLocaleDateString('de-DE', { weekday: 'short', day: 'numeric', month: 'short' });
+                }
+            }
+
+            if (!currentGroup || currentGroup.key !== key) {
+                currentGroup = { key, label, entries: [] };
+                groups.push(currentGroup);
+            }
+            currentGroup.entries.push(entry);
+        });
+
+        return groups;
+    },
+
+    /**
+     * Entries einer Zeitgruppe rendern, mit Cluster-Erkennung.
+     */
+    _renderTimeGroupEntries(entries, type) {
+        // Cluster-Erkennung: ≥4 Artikel pro Minute
+        const minuteCounts = {};
+        entries.forEach(e => {
+            if (e.kind === 'article') {
+                const mk = this._getMinuteKey(e.timestamp);
+                minuteCounts[mk] = (minuteCounts[mk] || 0) + 1;
+            }
+        });
+
+        const minuteRendered = {};
+        let html = '';
+
+        entries.forEach(e => {
+            if (e.kind === 'snapshot') {
+                html += this._renderSnapshotEntry(e.data);
+            } else {
+                const mk = this._getMinuteKey(e.timestamp);
+                const isCluster = minuteCounts[mk] >= 4;
+                const isFirstInCluster = isCluster && !minuteRendered[mk];
+                if (isFirstInCluster) minuteRendered[mk] = true;
+                html += this._renderArticleEntry(e.data, type, isFirstInCluster ? minuteCounts[mk] : 0);
+            }
+        });
+
+        return html;
+    },
+
+    /**
+     * Artikel-Eintrag für den Zeitstrahl rendern.
+     */
+    _renderArticleEntry(article, type, clusterCount) {
+        const dateField = (type === 'research' && article.published_at)
+            ? article.published_at : article.collected_at;
+        const time = dateField
+            ? new Date(dateField).toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })
+            : '--:--';
+
+        const headline = article.headline_de || article.headline;
+        const sourceUrl = article.source_url
+            ? `<a href="${UI.escape(article.source_url)}" target="_blank" rel="noopener" onclick="event.stopPropagation()">${UI.escape(article.source)}</a>`
+            : UI.escape(article.source);
+
+        const langBadge = article.language && article.language !== 'de'
+            ? `<span class="lang-badge">${article.language.toUpperCase()}</span>` : '';
+
+        const clusterBadge = clusterCount > 0
+            ? `<span class="vt-cluster-count">${clusterCount}</span>` : '';
+
+        const content = article.content_de || article.content_original || '';
+        const hasContent = content.length > 0;
+
+        let detailHtml = '';
+        if (hasContent) {
+            const truncated = content.length > 400 ? content.substring(0, 400) + '...' : content;
+            detailHtml = `<div class="vt-article-detail">
+                <div class="vt-article-detail-content">${UI.escape(truncated)}</div>
+                ${article.source_url ? `<a href="${UI.escape(article.source_url)}" target="_blank" rel="noopener" class="vt-article-detail-link" onclick="event.stopPropagation()">Artikel öffnen &rarr;</a>` : ''}
+            </div>`;
+        }
+
+        return `<div class="vt-entry ${hasContent ? 'expandable' : ''}" ${hasContent ? 'onclick="App.toggleTimelineEntry(this)"' : ''}>
+            <div class="vt-article-header">
+                <span class="vt-article-time">${time}</span>
+                <span class="vt-article-source">${sourceUrl}</span>
+                ${langBadge}${clusterBadge}
+            </div>
+            <div class="vt-article-headline">${UI.escape(headline)}</div>
+            ${detailHtml}
+        </div>`;
+    },
+
+    /**
+     * Snapshot/Lagebericht-Eintrag für den Zeitstrahl rendern.
+     */
+    _renderSnapshotEntry(snapshot) {
+        const time = snapshot.created_at
+            ? new Date(snapshot.created_at).toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })
+            : '--:--';
+
+        const stats = [];
+        if (snapshot.article_count) stats.push(`${snapshot.article_count} Artikel`);
+        if (snapshot.fact_check_count) stats.push(`${snapshot.fact_check_count} Fakten`);
+        const statsText = stats.join(', ');
+
+        // Vorschau: erste 200 Zeichen der Zusammenfassung
+        const summaryText = snapshot.summary || '';
+        const preview = summaryText.length > 200 ? summaryText.substring(0, 200) + '...' : summaryText;
+
+        // Vollständige Zusammenfassung via UI.renderSummary
+        const fullSummary = UI.renderSummary(snapshot.summary, snapshot.sources_json, this._currentIncidentType);
+
+        return `<div class="vt-entry vt-snapshot expandable" onclick="App.toggleTimelineEntry(this)">
+            <div class="vt-snapshot-header">
+                <span class="vt-snapshot-badge">Lagebericht</span>
+                <span class="vt-snapshot-time">${time}</span>
+                <span class="vt-snapshot-stats">${UI.escape(statsText)}</span>
+            </div>
+            <div class="vt-snapshot-preview">${UI.escape(preview)}</div>
+            <div class="vt-snapshot-detail">${fullSummary}</div>
+        </div>`;
+    },
+
+    /**
+     * Timeline-Eintrag auf-/zuklappen (mutual-exclusive pro Zeitgruppe).
+     */
+    toggleTimelineEntry(el) {
+        const container = el.closest('.ht-detail-content') || el.closest('.vt-time-group');
+        if (container) {
+            container.querySelectorAll('.vt-entry.expanded').forEach(item => {
+                if (item !== el) item.classList.remove('expanded');
+            });
+        }
+        el.classList.toggle('expanded');
+        if (el.classList.contains('expanded')) {
+            requestAnimationFrame(() => {
+                var scrollParent = el.closest('.ht-detail-content');
+                if (scrollParent && el.classList.contains('vt-snapshot')) {
+                    scrollParent.scrollTo({ top: 0, behavior: document.documentElement.dataset.a11yMotion ? 'instant' : 'smooth' });
+                } else {
+                    el.scrollIntoView({ behavior: document.documentElement.dataset.a11yMotion ? 'instant' : 'smooth', block: 'nearest' });
+                }
+            });
+        }
+        // Timeline-Kachel an Inhalt anpassen
+        this._resizeTimelineTile();
+    },
+
+    /**
+     * Minutenschlüssel für Cluster-Erkennung.
+     */
+    _getMinuteKey(timestamp) {
+        if (!timestamp) return 'none';
+        const d = new Date(timestamp);
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}-${d.getHours()}-${d.getMinutes()}`;
+    },
+
+    // === Event Handlers ===
+
+    _getFormData() {
+        const value = parseInt(document.getElementById('inc-refresh-value').value) || 15;
+        const unit = parseInt(document.getElementById('inc-refresh-unit').value) || 1;
+        const interval = Math.max(10, Math.min(10080, value * unit));
+        return {
+            title: document.getElementById('inc-title').value.trim(),
+            description: document.getElementById('inc-description').value.trim() || null,
+            type: document.getElementById('inc-type').value,
+            refresh_mode: document.getElementById('inc-refresh-mode').value,
+            refresh_interval: interval,
+            retention_days: parseInt(document.getElementById('inc-retention').value) || 0,
+            international_sources: document.getElementById('inc-international').checked,
+            visibility: document.getElementById('inc-visibility').checked ? 'public' : 'private',
+        };
+    },
+
+    async handleFormSubmit(e) {
+        e.preventDefault();
+        const submitBtn = document.getElementById('modal-new-submit');
+        submitBtn.disabled = true;
+
+        try {
+            const data = this._getFormData();
+
+            if (this._editingIncidentId) {
+                // Edit-Modus: ID sichern bevor closeModal sie löscht
+                const editId = this._editingIncidentId;
+                await API.updateIncident(editId, data);
+                closeModal('modal-new');
+                await this.loadIncidents();
+                await this.loadIncidentDetail(editId);
+                UI.showToast('Lage aktualisiert.', 'success');
+            } else {
+                // Create-Modus
+                const incident = await API.createIncident(data);
+                closeModal('modal-new');
+
+                await this.loadIncidents();
+                await this.selectIncident(incident.id);
+
+                // Sofort ersten Refresh starten
+                this._refreshingIncidents.add(incident.id);
+                this._updateRefreshButton(true);
+                UI.showProgress('queued');
+                await API.refreshIncident(incident.id);
+                UI.showToast(`Lage "${incident.title}" angelegt. Recherche gestartet.`, 'success');
+            }
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        } finally {
+            submitBtn.disabled = false;
+            this._editingIncidentId = null;
+        }
+    },
+
+    async handleRefresh() {
+        if (!this.currentIncidentId) return;
+        if (this._refreshingIncidents.has(this.currentIncidentId)) {
+            UI.showToast('Recherche läuft bereits...', 'warning');
+            return;
+        }
+        try {
+            this._refreshingIncidents.add(this.currentIncidentId);
+            this._updateRefreshButton(true);
+            UI.showProgress('queued');
+            const result = await API.refreshIncident(this.currentIncidentId);
+            if (result && result.status === 'skipped') {
+                this._refreshingIncidents.delete(this.currentIncidentId);
+                this._updateRefreshButton(false);
+                UI.hideProgress();
+                UI.showToast('Recherche läuft bereits oder ist in der Warteschlange.', 'warning');
+            }
+        } catch (err) {
+            this._refreshingIncidents.delete(this.currentIncidentId);
+            this._updateRefreshButton(false);
+            UI.hideProgress();
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    _formatInterval(minutes) {
+        if (minutes >= 10080 && minutes % 10080 === 0) {
+            const w = minutes / 10080;
+            return w === 1 ? '1 Woche' : `${w} Wochen`;
+        }
+        if (minutes >= 1440 && minutes % 1440 === 0) {
+            const d = minutes / 1440;
+            return d === 1 ? '1 Tag' : `${d} Tage`;
+        }
+        if (minutes >= 60 && minutes % 60 === 0) {
+            const h = minutes / 60;
+            return h === 1 ? '1 Stunde' : `${h} Stunden`;
+        }
+        return `${minutes} Min.`;
+    },
+
+    _setIntervalFields(minutes) {
+        let value, unit;
+        if (minutes >= 10080 && minutes % 10080 === 0) {
+            value = minutes / 10080; unit = '10080';
+        } else if (minutes >= 1440 && minutes % 1440 === 0) {
+            value = minutes / 1440; unit = '1440';
+        } else if (minutes >= 60 && minutes % 60 === 0) {
+            value = minutes / 60; unit = '60';
+        } else {
+            value = minutes; unit = '1';
+        }
+        const input = document.getElementById('inc-refresh-value');
+        input.value = value;
+        input.min = unit === '1' ? 10 : 1;
+        document.getElementById('inc-refresh-unit').value = unit;
+    },
+
+    _refreshHistoryOpen: false,
+
+    toggleRefreshHistory() {
+        if (this._refreshHistoryOpen) {
+            this.closeRefreshHistory();
+        } else {
+            this._openRefreshHistory();
+        }
+    },
+
+    async _openRefreshHistory() {
+        if (!this.currentIncidentId) return;
+        const popover = document.getElementById('refresh-history-popover');
+        if (!popover) return;
+
+        this._refreshHistoryOpen = true;
+        popover.style.display = 'flex';
+
+        // Lade Refresh-Log
+        const list = document.getElementById('refresh-history-list');
+        list.innerHTML = '<div style="padding:12px;color:var(--text-disabled);font-size:12px;">Lade...</div>';
+
+        try {
+            const logs = await API.getRefreshLog(this.currentIncidentId, 20);
+            this._renderRefreshHistory(logs);
+        } catch (e) {
+            list.innerHTML = '<div style="padding:12px;color:var(--error);font-size:12px;">Fehler beim Laden</div>';
+        }
+
+        // Outside-Click Listener
+        setTimeout(() => {
+            const handler = (e) => {
+                if (!popover.contains(e.target) && !e.target.closest('.meta-updated-link')) {
+                    this.closeRefreshHistory();
+                    document.removeEventListener('click', handler);
+                }
+            };
+            document.addEventListener('click', handler);
+            popover._outsideHandler = handler;
+        }, 0);
+    },
+
+    closeRefreshHistory() {
+        this._refreshHistoryOpen = false;
+        const popover = document.getElementById('refresh-history-popover');
+        if (popover) {
+            popover.style.display = 'none';
+            if (popover._outsideHandler) {
+                document.removeEventListener('click', popover._outsideHandler);
+                delete popover._outsideHandler;
+            }
+        }
+    },
+
+    _renderRefreshHistory(logs) {
+        const list = document.getElementById('refresh-history-list');
+        if (!list) return;
+
+        if (!logs || logs.length === 0) {
+            list.innerHTML = '<div style="padding:12px;color:var(--text-disabled);font-size:12px;">Noch keine Refreshes durchgeführt</div>';
+            return;
+        }
+
+        list.innerHTML = logs.map(log => {
+            const started = new Date(log.started_at);
+            const timeStr = started.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit' }) + ' ' +
+                started.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
+
+            let detail = '';
+            if (log.status === 'completed') {
+                detail = `${log.articles_found} Artikel`;
+                if (log.duration_seconds != null) {
+                    detail += ` in ${this._formatDuration(log.duration_seconds)}`;
+                }
+            } else if (log.status === 'running') {
+                detail = 'Läuft...';
+            } else if (log.status === 'error') {
+                detail = '';
+            }
+
+            const retryInfo = log.retry_count > 0 ? ` (Versuch ${log.retry_count + 1})` : '';
+            const errorHtml = log.error_message
+                ? `<div class="rh-info-error" title="${log.error_message.replace(/"/g, '&quot;')}">${log.error_message}</div>`
+                : '';
+
+            return `<div class="refresh-history-entry">
+                <div class="rh-status-dot ${log.status}"></div>
+                <div class="rh-info">
+                    <div class="rh-info-time">${timeStr}${retryInfo}</div>
+                    ${detail ? `<div class="rh-info-detail">${detail}</div>` : ''}
+                    ${errorHtml}
+                </div>
+                <span class="rh-trigger-badge ${log.trigger_type}">${log.trigger_type === 'auto' ? 'Auto' : 'Manuell'}</span>
+            </div>`;
+        }).join('');
+    },
+
+    _formatDuration(seconds) {
+        if (seconds == null) return '';
+        if (seconds < 60) return `${Math.round(seconds)}s`;
+        const m = Math.floor(seconds / 60);
+        const s = Math.round(seconds % 60);
+        return s > 0 ? `${m}m ${s}s` : `${m}m`;
+    },
+
+    _timeAgo(date) {
+        if (!date) return '';
+        const now = new Date();
+        const diff = Math.floor((now - date) / 1000);
+        if (diff < 60) return 'gerade eben';
+        if (diff < 3600) return `vor ${Math.floor(diff / 60)}m`;
+        if (diff < 86400) return `vor ${Math.floor(diff / 3600)}h`;
+        return `vor ${Math.floor(diff / 86400)}d`;
+    },
+
+    _updateRefreshButton(disabled) {
+        const btn = document.getElementById('refresh-btn');
+        if (!btn) return;
+        btn.disabled = disabled;
+        btn.textContent = disabled ? 'Läuft...' : 'Aktualisieren';
+    },
+
+    async handleDelete() {
+        if (!this.currentIncidentId) return;
+        if (!await confirmDialog('Lage wirklich löschen? Alle gesammelten Daten gehen verloren.')) return;
+
+        try {
+            await API.deleteIncident(this.currentIncidentId);
+            this.currentIncidentId = null;
+            if (typeof LayoutManager !== 'undefined') LayoutManager.destroy();
+            document.getElementById('incident-view').style.display = 'none';
+            document.getElementById('empty-state').style.display = 'flex';
+            await this.loadIncidents();
+            UI.showToast('Lage gelöscht.', 'success');
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    handleEdit() {
+        if (!this.currentIncidentId) return;
+        const incident = this.incidents.find(i => i.id === this.currentIncidentId);
+        if (!incident) return;
+
+        this._editingIncidentId = this.currentIncidentId;
+
+        // Formular mit aktuellen Werten füllen
+        document.getElementById('inc-title').value = incident.title;
+        document.getElementById('inc-description').value = incident.description || '';
+        document.getElementById('inc-type').value = incident.type || 'adhoc';
+        document.getElementById('inc-refresh-mode').value = incident.refresh_mode;
+        App._setIntervalFields(incident.refresh_interval);
+        document.getElementById('inc-retention').value = incident.retention_days;
+        document.getElementById('inc-international').checked = incident.international_sources !== false && incident.international_sources !== 0;
+        document.getElementById('inc-visibility').checked = incident.visibility !== 'private';
+        updateVisibilityHint();
+        updateSourcesHint();
+        toggleTypeDefaults();
+        toggleRefreshInterval();
+
+        // Modal-Titel und Submit ändern
+        document.getElementById('modal-new-title').textContent = 'Lage bearbeiten';
+        document.getElementById('modal-new-submit').textContent = 'Speichern';
+
+        openModal('modal-new');
+    },
+
+    async handleArchive() {
+        if (!this.currentIncidentId) return;
+        const incident = this.incidents.find(i => i.id === this.currentIncidentId);
+        if (!incident) return;
+
+        const isArchived = incident.status === 'archived';
+        const action = isArchived ? 'wiederherstellen' : 'archivieren';
+
+        if (!await confirmDialog(`Lage wirklich ${action}?`)) return;
+
+        try {
+            const newStatus = isArchived ? 'active' : 'archived';
+            await API.updateIncident(this.currentIncidentId, { status: newStatus });
+            await this.loadIncidents();
+            await this.loadIncidentDetail(this.currentIncidentId);
+            this._updateArchiveButton(newStatus);
+            UI.showToast(isArchived ? 'Lage wiederhergestellt.' : 'Lage archiviert.', 'success');
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    _updateSidebarDot(incidentId, mode) {
+        const dot = document.getElementById(`dot-${incidentId}`);
+        if (!dot) return;
+        const incident = this.incidents.find(i => i.id === incidentId);
+        const baseClass = incident ? (incident.status === 'active' ? 'active' : 'archived') : 'active';
+
+        if (mode === 'error') {
+            dot.className = `incident-dot refresh-error`;
+            setTimeout(() => {
+                dot.className = `incident-dot ${baseClass}`;
+            }, 3000);
+        } else if (this._refreshingIncidents.has(incidentId)) {
+            dot.className = `incident-dot refreshing`;
+        } else {
+            dot.className = `incident-dot ${baseClass}`;
+        }
+    },
+
+    _updateArchiveButton(status) {
+        const btn = document.getElementById('archive-incident-btn');
+        if (!btn) return;
+        btn.textContent = status === 'archived' ? 'Wiederherstellen' : 'Archivieren';
+    },
+
+    // === WebSocket Handlers ===
+
+    handleStatusUpdate(msg) {
+        const status = msg.data.status;
+        if (status === 'retrying') {
+            // Retry-Status → Fehleranzeige mit Retry-Info
+            if (msg.incident_id === this.currentIncidentId) {
+                UI.showProgressError('', true, msg.data.delay || 120);
+            }
+            return;
+        }
+        if (status !== 'idle') {
+            this._refreshingIncidents.add(msg.incident_id);
+        }
+        this._updateSidebarDot(msg.incident_id);
+        if (msg.incident_id === this.currentIncidentId) {
+            UI.showProgress(status, msg.data);
+            this._updateRefreshButton(status !== 'idle');
+        }
+    },
+
+    async handleRefreshComplete(msg) {
+        this._refreshingIncidents.delete(msg.incident_id);
+        this._updateSidebarDot(msg.incident_id);
+
+        if (msg.incident_id === this.currentIncidentId) {
+            this._updateRefreshButton(false);
+            await this.loadIncidentDetail(msg.incident_id);
+
+            // Progress-Bar nicht sofort ausblenden — auf refresh_summary warten
+            this._pendingComplete = msg.incident_id;
+            // Fallback: Wenn nach 5s kein refresh_summary kommt → direkt ausblenden
+            if (this._pendingCompleteTimer) clearTimeout(this._pendingCompleteTimer);
+            this._pendingCompleteTimer = setTimeout(() => {
+                if (this._pendingComplete === msg.incident_id) {
+                    this._pendingComplete = null;
+                    UI.hideProgress();
+                }
+            }, 5000);
+        }
+
+        await this.loadIncidents();
+    },
+
+    handleNotification(msg) {
+        // Legacy-Fallback: Einzelne Notifications ans NotificationCenter weiterleiten
+        const incident = this.incidents.find(i => i.id === msg.incident_id);
+        NotificationCenter.add({
+            incident_id: msg.incident_id,
+            title: incident ? incident.title : 'Lage #' + msg.incident_id,
+            text: msg.data.message || 'Neue Entwicklung',
+            icon: 'warning',
+        });
+    },
+
+    handleRefreshSummary(msg) {
+        const d = msg.data;
+        const title = d.incident_title || 'Lage';
+
+        // Abschluss-Animation auslösen wenn pending
+        if (this._pendingComplete === msg.incident_id) {
+            if (this._pendingCompleteTimer) {
+                clearTimeout(this._pendingCompleteTimer);
+                this._pendingCompleteTimer = null;
+            }
+            this._pendingComplete = null;
+            UI.showProgressComplete(d);
+            setTimeout(() => UI.hideProgress(), 4000);
+        }
+
+        // Toast-Text zusammenbauen
+        const parts = [];
+        if (d.new_articles > 0) {
+            parts.push(`${d.new_articles} neue Meldung${d.new_articles !== 1 ? 'en' : ''}`);
+        }
+        if (d.confirmed_count > 0) {
+            parts.push(`${d.confirmed_count} bestätigt`);
+        }
+        if (d.contradicted_count > 0) {
+            parts.push(`${d.contradicted_count} widersprochen`);
+        }
+        if (d.status_changes && d.status_changes.length > 0) {
+            parts.push(`${d.status_changes.length} Statusänderung${d.status_changes.length !== 1 ? 'en' : ''}`);
+        }
+
+        const summaryText = parts.length > 0
+            ? parts.join(', ')
+            : 'Keine neuen Entwicklungen';
+
+        // 1 Toast statt 5-10
+        UI.showToast(`Recherche abgeschlossen: ${summaryText}`, 'success', 6000);
+
+        // Ins NotificationCenter eintragen
+        NotificationCenter.add({
+            incident_id: msg.incident_id,
+            title: title,
+            text: `Recherche: ${summaryText}`,
+            icon: d.contradicted_count > 0 ? 'warning' : 'success',
+        });
+
+        // Status-Änderungen als separate Einträge
+        if (d.status_changes) {
+            d.status_changes.forEach(sc => {
+                const oldLabel = this._translateStatus(sc.old_status);
+                const newLabel = this._translateStatus(sc.new_status);
+                NotificationCenter.add({
+                    incident_id: msg.incident_id,
+                    title: title,
+                    text: `${sc.claim}: ${oldLabel} \u2192 ${newLabel}`,
+                    icon: sc.new_status === 'contradicted' || sc.new_status === 'disputed' ? 'error' : 'success',
+                });
+            });
+        }
+
+        // Sidebar-Dot blinken
+        const dot = document.getElementById(`dot-${msg.incident_id}`);
+        if (dot) {
+            dot.classList.add('has-notification');
+            setTimeout(() => dot.classList.remove('has-notification'), 10000);
+        }
+    },
+
+    _translateStatus(status) {
+        const map = {
+            confirmed: 'Bestätigt',
+            established: 'Gesichert',
+            unconfirmed: 'Unbestätigt',
+            contradicted: 'Widersprochen',
+            disputed: 'Umstritten',
+            developing: 'In Entwicklung',
+            unverified: 'Ungeprüft',
+        };
+        return map[status] || status;
+    },
+
+    handleRefreshError(msg) {
+        this._refreshingIncidents.delete(msg.incident_id);
+        this._updateSidebarDot(msg.incident_id, 'error');
+        if (msg.incident_id === this.currentIncidentId) {
+            this._updateRefreshButton(false);
+            // Pending-Complete aufräumen
+            if (this._pendingCompleteTimer) {
+                clearTimeout(this._pendingCompleteTimer);
+                this._pendingCompleteTimer = null;
+            }
+            this._pendingComplete = null;
+            UI.showProgressError(msg.data.error, false);
+        }
+        UI.showToast(`Recherche-Fehler: ${msg.data.error}`, 'error');
+    },
+
+    handleRefreshCancelled(msg) {
+        this._refreshingIncidents.delete(msg.incident_id);
+        this._updateSidebarDot(msg.incident_id);
+        if (msg.incident_id === this.currentIncidentId) {
+            this._updateRefreshButton(false);
+            if (this._pendingCompleteTimer) {
+                clearTimeout(this._pendingCompleteTimer);
+                this._pendingCompleteTimer = null;
+            }
+            this._pendingComplete = null;
+            UI.hideProgress();
+        }
+        UI.showToast('Recherche abgebrochen.', 'info');
+    },
+
+    async cancelRefresh() {
+        if (!this.currentIncidentId) return;
+        const ok = await confirmDialog('Laufende Recherche abbrechen?');
+        if (!ok) return;
+
+        const btn = document.getElementById('progress-cancel-btn');
+        if (btn) {
+            btn.textContent = 'Wird abgebrochen...';
+            btn.disabled = true;
+        }
+
+        try {
+            await API.cancelRefresh(this.currentIncidentId);
+        } catch (err) {
+            UI.showToast('Abbrechen fehlgeschlagen: ' + err.message, 'error');
+            if (btn) {
+                btn.textContent = 'Abbrechen';
+                btn.disabled = false;
+            }
+        }
+    },
+
+    // === Export ===
+
+    toggleExportDropdown(event) {
+        event.stopPropagation();
+        const menu = document.getElementById('export-dropdown-menu');
+        if (!menu) return;
+        menu.classList.toggle('show');
+    },
+
+    _closeExportDropdown() {
+        const menu = document.getElementById('export-dropdown-menu');
+        if (menu) menu.classList.remove('show');
+    },
+
+    async exportIncident(format, scope) {
+        this._closeExportDropdown();
+        if (!this.currentIncidentId) return;
+        try {
+            const response = await API.exportIncident(this.currentIncidentId, format, scope);
+            if (!response.ok) {
+                const err = await response.json().catch(() => ({}));
+                throw new Error(err.detail || 'Fehler ' + response.status);
+            }
+            const blob = await response.blob();
+            const disposition = response.headers.get('Content-Disposition') || '';
+            let filename = 'export.' + format;
+            const match = disposition.match(/filename="?([^"]+)"?/);
+            if (match) filename = match[1];
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+            UI.showToast('Export heruntergeladen', 'success');
+        } catch (err) {
+            UI.showToast('Export fehlgeschlagen: ' + err.message, 'error');
+        }
+    },
+
+    printIncident() {
+        this._closeExportDropdown();
+        window.print();
+    },
+
+    // === Sidebar-Stats ===
+
+    async updateSidebarStats() {
+        try {
+            const stats = await API.getSourceStats();
+            const srcCount = document.getElementById('stat-sources-count');
+            const artCount = document.getElementById('stat-articles-count');
+            if (srcCount) srcCount.textContent = `${stats.total_sources} Quellen`;
+            if (artCount) artCount.textContent = `${stats.total_articles} Artikel`;
+        } catch {
+            // Fallback: aus Lagen berechnen
+            const totalArticles = this.incidents.reduce((sum, i) => sum + i.article_count, 0);
+            const totalSources = this.incidents.reduce((sum, i) => sum + i.source_count, 0);
+            const srcCount = document.getElementById('stat-sources-count');
+            const artCount = document.getElementById('stat-articles-count');
+            if (srcCount) srcCount.textContent = `${totalSources} Quellen`;
+            if (artCount) artCount.textContent = `${totalArticles} Artikel`;
+        }
+    },
+
+    // === Soft-Refresh (F5) ===
+
+    async softRefresh() {
+        try {
+            await this.loadIncidents();
+            if (this.currentIncidentId) {
+                await this.selectIncident(this.currentIncidentId);
+            }
+            UI.showToast('Daten aktualisiert.', 'success', 2000);
+        } catch (err) {
+            UI.showToast('Aktualisierung fehlgeschlagen: ' + err.message, 'error');
+        }
+    },
+
+    // === Feedback ===
+
+    openFeedback() {
+        const form = document.getElementById('feedback-form');
+        if (form) form.reset();
+        const counter = document.getElementById('fb-char-count');
+        if (counter) counter.textContent = '0';
+        openModal('modal-feedback');
+    },
+
+    async submitFeedback(e) {
+        e.preventDefault();
+        const btn = document.getElementById('fb-submit-btn');
+        const category = document.getElementById('fb-category').value;
+        const message = document.getElementById('fb-message').value.trim();
+
+        if (message.length < 10) {
+            UI.showToast('Bitte mindestens 10 Zeichen eingeben.', 'warning');
+            return;
+        }
+
+        btn.disabled = true;
+        btn.textContent = 'Wird gesendet...';
+        try {
+            await API.sendFeedback({ category, message });
+            closeModal('modal-feedback');
+            UI.showToast('Feedback gesendet. Vielen Dank!', 'success');
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        } finally {
+            btn.disabled = false;
+            btn.textContent = 'Absenden';
+        }
+    },
+
+    // === Sidebar Sektionen ein-/ausklappen ===
+
+    toggleSidebarSection(sectionId) {
+        const list = document.getElementById(sectionId);
+        if (!list) return;
+        const chevron = document.getElementById('chevron-' + sectionId);
+        const isHidden = list.style.display === 'none';
+        list.style.display = isHidden ? '' : 'none';
+        if (chevron) {
+            chevron.classList.toggle('open', isHidden);
+        }
+    },
+
+    // === Quellenverwaltung ===
+
+    async openSourceManagement() {
+        openModal('modal-sources');
+        await this.loadSources();
+    },
+
+    async loadSources() {
+        try {
+            const [sources, stats] = await Promise.all([
+                API.listSources(),
+                API.getSourceStats(),
+            ]);
+            this._allSources = sources;
+            this._sourcesOnly = sources.filter(s => s.source_type !== 'excluded');
+            this._blacklistOnly = sources.filter(s => s.source_type === 'excluded');
+
+            this.renderSourceStats(stats);
+            this.renderSourceList();
+        } catch (err) {
+            UI.showToast('Fehler beim Laden der Quellen: ' + err.message, 'error');
+        }
+    },
+
+    renderSourceStats(stats) {
+        const bar = document.getElementById('sources-stats-bar');
+        if (!bar) return;
+
+        const rss = stats.by_type.rss_feed || { count: 0, articles: 0 };
+        const web = stats.by_type.web_source || { count: 0, articles: 0 };
+        const excluded = this._blacklistOnly.length;
+
+        bar.innerHTML = `
+            <span class="sources-stat-item"><span class="sources-stat-value">${rss.count}</span> RSS-Feeds</span>
+            <span class="sources-stat-item"><span class="sources-stat-value">${web.count}</span> Web-Quellen</span>
+            <span class="sources-stat-item"><span class="sources-stat-value">${excluded}</span> Gesperrt</span>
+            <span class="sources-stat-item"><span class="sources-stat-value">${stats.total_articles}</span> Artikel gesamt</span>
+        `;
+    },
+
+    /**
+     * Quellen nach Domain gruppiert rendern.
+     */
+    renderSourceList() {
+        const list = document.getElementById('sources-list');
+        if (!list) return;
+
+        // Filter anwenden
+        const typeFilter = document.getElementById('sources-filter-type')?.value || '';
+        const catFilter = document.getElementById('sources-filter-category')?.value || '';
+        const search = (document.getElementById('sources-search')?.value || '').toLowerCase();
+
+        // Alle Quellen nach Domain gruppieren
+        const groups = new Map();
+        const excludedDomains = new Set();
+        const excludedNotes = {};
+
+        // Blacklist-Domains sammeln
+        this._blacklistOnly.forEach(s => {
+            const domain = (s.domain || s.name || '').toLowerCase();
+            if (domain) {
+                excludedDomains.add(domain);
+                excludedNotes[domain] = s.notes || '';
+            }
+        });
+
+        // Feeds nach Domain gruppieren
+        this._sourcesOnly.forEach(s => {
+            const domain = (s.domain || '').toLowerCase() || `_single_${s.id}`;
+            if (!groups.has(domain)) groups.set(domain, []);
+            groups.get(domain).push(s);
+        });
+
+        // Gesperrte Domains die keine Feeds haben auch als Gruppe
+        this._blacklistOnly.forEach(s => {
+            const domain = (s.domain || s.name || '').toLowerCase();
+            if (domain && !groups.has(domain)) {
+                groups.set(domain, [s]);
+            }
+        });
+
+        // Filter auf Gruppen anwenden
+        let filteredGroups = [];
+        for (const [domain, feeds] of groups) {
+            const isExcluded = excludedDomains.has(domain);
+
+            // Typ-Filter
+            if (typeFilter === 'excluded' && !isExcluded) continue;
+            if (typeFilter && typeFilter !== 'excluded') {
+                const hasMatchingType = feeds.some(f => f.source_type === typeFilter);
+                if (!hasMatchingType) continue;
+            }
+
+            // Kategorie-Filter
+            if (catFilter) {
+                const hasMatchingCat = feeds.some(f => f.category === catFilter);
+                if (!hasMatchingCat) continue;
+            }
+
+            // Suche
+            if (search) {
+                const groupText = feeds.map(f =>
+                    `${f.name} ${f.domain || ''} ${f.url || ''} ${f.notes || ''}`
+                ).join(' ').toLowerCase() + ' ' + domain;
+                if (!groupText.includes(search)) continue;
+            }
+
+            filteredGroups.push({ domain, feeds, isExcluded });
+        }
+
+        if (filteredGroups.length === 0) {
+            list.innerHTML = '<div style="padding:24px;text-align:center;font-size:13px;color:var(--text-disabled);">Keine Quellen gefunden</div>';
+            return;
+        }
+
+        // Sortierung: Aktive zuerst (alphabetisch), dann gesperrte
+        filteredGroups.sort((a, b) => {
+            if (a.isExcluded !== b.isExcluded) return a.isExcluded ? 1 : -1;
+            return a.domain.localeCompare(b.domain);
+        });
+
+        list.innerHTML = filteredGroups.map(g =>
+            UI.renderSourceGroup(g.domain, g.feeds, g.isExcluded, excludedNotes[g.domain] || '')
+        ).join('');
+
+        // Erweiterte Gruppen wiederherstellen
+        this._expandedGroups.forEach(domain => {
+            const feedsEl = list.querySelector(`.source-group-feeds[data-domain="${CSS.escape(domain)}"]`);
+            if (feedsEl) {
+                feedsEl.classList.add('expanded');
+                const header = feedsEl.previousElementSibling;
+                if (header) header.classList.add('expanded');
+            }
+        });
+    },
+
+    filterSources() {
+        this.renderSourceList();
+    },
+
+    /**
+     * Domain-Gruppe auf-/zuklappen.
+     */
+    toggleSourceOverview() {
+        const content = document.getElementById('source-overview-content');
+        const chevron = document.getElementById('source-overview-chevron');
+        if (!content) return;
+        const isHidden = content.style.display === 'none';
+        content.style.display = isHidden ? '' : 'none';
+        if (chevron) {
+            chevron.classList.toggle('open', isHidden);
+            chevron.title = isHidden ? 'Einklappen' : 'Aufklappen';
+        }
+        // aria-expanded auf dem Header-Toggle synchronisieren
+        const header = chevron ? chevron.closest('[role="button"]') : null;
+        if (header) header.setAttribute('aria-expanded', String(isHidden));
+        // gridstack-Kachel an Inhalt anpassen (doppelter rAF für vollständiges Layout)
+        if (typeof LayoutManager !== 'undefined' && LayoutManager._grid) {
+            if (isHidden) {
+                // Aufgeklappt → Inhalt muss erst layouten
+                requestAnimationFrame(() => requestAnimationFrame(() => {
+                    LayoutManager.resizeTileToContent('quellen');
+                }));
+            } else {
+                // Zugeklappt → auf Default-Höhe zurück
+                const defaults = LayoutManager.DEFAULT_LAYOUT.find(d => d.id === 'quellen');
+                if (defaults) {
+                    const node = LayoutManager._grid.engine.nodes.find(
+                        n => n.el && n.el.getAttribute('gs-id') === 'quellen'
+                    );
+                    if (node) {
+                        LayoutManager._grid.update(node.el, { h: defaults.h });
+                        LayoutManager._debouncedSave();
+                    }
+                }
+            }
+        }
+    },
+
+    toggleGroup(domain) {
+        const list = document.getElementById('sources-list');
+        if (!list) return;
+        const feedsEl = list.querySelector(`.source-group-feeds[data-domain="${CSS.escape(domain)}"]`);
+        if (!feedsEl) return;
+
+        const isExpanded = feedsEl.classList.toggle('expanded');
+        const header = feedsEl.previousElementSibling;
+        if (header) {
+            header.classList.toggle('expanded', isExpanded);
+            header.setAttribute('aria-expanded', String(isExpanded));
+        }
+
+        if (isExpanded) {
+            this._expandedGroups.add(domain);
+        } else {
+            this._expandedGroups.delete(domain);
+        }
+    },
+
+    /**
+     * Domain sperren (aus dem Inline-Formular).
+     */
+    async blockDomain() {
+        const input = document.getElementById('block-domain-input');
+        const domain = (input?.value || '').trim();
+        if (!domain) {
+            UI.showToast('Domain ist erforderlich.', 'warning');
+            return;
+        }
+
+        const notes = (document.getElementById('block-domain-notes')?.value || '').trim() || null;
+
+        try {
+            await API.blockDomain(domain, notes);
+            UI.showToast(`${domain} gesperrt.`, 'success');
+            this.showBlockDomainDialog(false);
+            await this.loadSources();
+            this.updateSidebarStats();
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    /**
+     * Faktencheck-Filter umschalten.
+     */
+    toggleFactCheckFilter(status) {
+        const checkbox = document.querySelector(`.fc-dropdown-item[data-status="${status}"] input`);
+        if (!checkbox) return;
+        const isActive = checkbox.checked;
+
+        document.querySelectorAll(`.factcheck-item[data-fc-status="${status}"]`).forEach(el => {
+            el.style.display = isActive ? '' : 'none';
+        });
+    },
+
+    toggleFcDropdown(e) {
+        e.stopPropagation();
+        const btn = e.target.closest('.fc-dropdown-toggle');
+        const menu = btn ? btn.nextElementSibling : document.getElementById('fc-dropdown-menu');
+        if (!menu) return;
+        const isOpen = menu.classList.toggle('open');
+        if (btn) btn.setAttribute('aria-expanded', String(isOpen));
+        if (isOpen) {
+            const close = (ev) => {
+                if (!menu.contains(ev.target)) {
+                    menu.classList.remove('open');
+                    document.removeEventListener('click', close);
+                }
+            };
+            setTimeout(() => document.addEventListener('click', close), 0);
+        }
+    },
+
+    filterModalTimeline(searchTerm) {
+        const filterBtn = document.querySelector('.ht-modal-filter-btn.active');
+        const filterType = filterBtn ? filterBtn.dataset.filter : 'all';
+        const body = document.getElementById('content-viewer-body');
+        if (!body) return;
+        body.innerHTML = this._buildFullVerticalTimeline(filterType, (searchTerm || '').toLowerCase());
+    },
+
+    filterModalTimelineType(filterType, btn) {
+        document.querySelectorAll('.ht-modal-filter-btn').forEach(b => b.classList.remove('active'));
+        if (btn) btn.classList.add('active');
+        const searchInput = document.querySelector('#content-viewer-header-extra .timeline-filter-input');
+        const searchTerm = searchInput ? searchInput.value.toLowerCase() : '';
+        const body = document.getElementById('content-viewer-body');
+        if (!body) return;
+        body.innerHTML = this._buildFullVerticalTimeline(filterType, searchTerm);
+    },
+
+    /**
+     * Domain direkt sperren (aus der Gruppenliste).
+     */
+    async blockDomainDirect(domain) {
+        if (!await confirmDialog(`"${domain}" wirklich sperren? Alle Feeds dieser Domain werden deaktiviert.`)) return;
+
+        try {
+            await API.blockDomain(domain);
+            UI.showToast(`${domain} gesperrt.`, 'success');
+            await this.loadSources();
+            this.updateSidebarStats();
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    /**
+     * Domain entsperren.
+     */
+    async unblockDomain(domain) {
+        try {
+            await API.unblockDomain(domain);
+            UI.showToast(`${domain} entsperrt.`, 'success');
+            await this.loadSources();
+            this.updateSidebarStats();
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    /**
+     * Alle Quellen einer Domain löschen.
+     */
+    async deleteDomain(domain) {
+        if (!await confirmDialog(`Alle Quellen von "${domain}" wirklich löschen?`)) return;
+
+        try {
+            await API.deleteDomain(domain);
+            UI.showToast(`${domain} gelöscht.`, 'success');
+            await this.loadSources();
+            this.updateSidebarStats();
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    /**
+     * Einzelnen Feed löschen.
+     */
+    async deleteSingleFeed(sourceId) {
+        try {
+            await API.deleteSource(sourceId);
+            this._allSources = this._allSources.filter(s => s.id !== sourceId);
+            this._sourcesOnly = this._sourcesOnly.filter(s => s.id !== sourceId);
+            this.renderSourceList();
+            this.updateSidebarStats();
+            UI.showToast('Feed gelöscht.', 'success');
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    /**
+     * "Domain sperren" Dialog ein-/ausblenden.
+     */
+    showBlockDomainDialog(show) {
+        const form = document.getElementById('sources-block-form');
+        if (!form) return;
+
+        if (show === undefined || show === true) {
+            form.style.display = 'block';
+            document.getElementById('block-domain-input').value = '';
+            document.getElementById('block-domain-notes').value = '';
+            // Add-Form ausblenden
+            const addForm = document.getElementById('sources-add-form');
+            if (addForm) addForm.style.display = 'none';
+        } else {
+            form.style.display = 'none';
+        }
+    },
+
+    _discoveredData: null,
+
+    toggleSourceForm(show) {
+        const form = document.getElementById('sources-add-form');
+        if (!form) return;
+
+        if (show === undefined) {
+            show = form.style.display === 'none';
+        }
+
+        form.style.display = show ? 'block' : 'none';
+
+        if (show) {
+            this._editingSourceId = null;
+            this._discoveredData = null;
+            document.getElementById('src-discover-url').value = '';
+            document.getElementById('src-discovery-result').style.display = 'none';
+            document.getElementById('src-discover-btn').disabled = false;
+            document.getElementById('src-discover-btn').textContent = 'Erkennen';
+            // Block-Form ausblenden
+            const blockForm = document.getElementById('sources-block-form');
+            if (blockForm) blockForm.style.display = 'none';
+        }
+    },
+
+    async discoverSource() {
+        const urlInput = document.getElementById('src-discover-url');
+        const url = urlInput.value.trim();
+        if (!url) {
+            UI.showToast('Bitte URL oder Domain eingeben.', 'warning');
+            return;
+        }
+
+        // Prüfen ob Domain gesperrt ist
+        const inputDomain = url.replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0].toLowerCase();
+        const isBlocked = inputDomain && this._blacklistOnly.some(s => (s.domain || '').toLowerCase() === inputDomain);
+
+        if (isBlocked) {
+            if (!await confirmDialog(`"${inputDomain}" ist gesperrt. Trotzdem hinzufügen? Die Domain wird dabei entsperrt.`)) return;
+            await API.unblockDomain(inputDomain);
+        }
+
+        const btn = document.getElementById('src-discover-btn');
+        btn.disabled = true;
+        btn.textContent = 'Suche Feeds...';
+
+        try {
+            const result = await API.discoverMulti(url);
+
+            if (result.fallback_single) {
+                this._discoveredData = {
+                    name: result.domain,
+                    domain: result.domain,
+                    category: result.category,
+                    source_type: result.total_found > 0 ? 'rss_feed' : 'web_source',
+                    rss_url: result.sources.length > 0 ? result.sources[0].url : null,
+                };
+                if (result.sources.length > 0) {
+                    this._discoveredData.name = result.sources[0].name;
+                }
+
+                document.getElementById('src-name').value = this._discoveredData.name || '';
+                document.getElementById('src-category').value = this._discoveredData.category || 'sonstige';
+                document.getElementById('src-domain').value = this._discoveredData.domain || '';
+                document.getElementById('src-notes').value = '';
+
+                const typeLabel = this._discoveredData.source_type === 'rss_feed' ? 'RSS-Feed' : 'Web-Quelle';
+                document.getElementById('src-type-display').value = typeLabel;
+
+                const rssGroup = document.getElementById('src-rss-url-group');
+                const rssInput = document.getElementById('src-rss-url');
+                if (this._discoveredData.rss_url) {
+                    rssInput.value = this._discoveredData.rss_url;
+                    rssGroup.style.display = 'block';
+                } else {
+                    rssInput.value = '';
+                    rssGroup.style.display = 'none';
+                }
+
+                document.getElementById('src-discovery-result').style.display = 'block';
+
+                if (result.added_count > 0) {
+                    UI.showToast(`${result.domain}: Feed wurde automatisch hinzugefügt.`, 'success');
+                    this.toggleSourceForm(false);
+                    await this.loadSources();
+                } else if (result.total_found === 0) {
+                    UI.showToast('Kein RSS-Feed gefunden. Als Web-Quelle speichern?', 'info');
+                } else {
+                    UI.showToast('Feed bereits vorhanden.', 'info');
+                }
+            } else {
+                document.getElementById('src-discovery-result').style.display = 'none';
+
+                if (result.added_count > 0) {
+                    UI.showToast(`${result.domain}: ${result.added_count} Feeds hinzugefügt` +
+                        (result.skipped_count > 0 ? ` (${result.skipped_count} bereits vorhanden)` : ''),
+                        'success');
+                } else if (result.skipped_count > 0) {
+                    UI.showToast(`${result.domain}: Alle ${result.skipped_count} Feeds bereits vorhanden.`, 'info');
+                } else {
+                    UI.showToast(`${result.domain}: Keine relevanten Feeds gefunden.`, 'info');
+                }
+
+                this.toggleSourceForm(false);
+                await this.loadSources();
+            }
+        } catch (err) {
+            UI.showToast('Erkennung fehlgeschlagen: ' + err.message, 'error');
+        } finally {
+            btn.disabled = false;
+            btn.textContent = 'Erkennen';
+        }
+    },
+
+    async saveSource() {
+        const name = document.getElementById('src-name').value.trim();
+        if (!name) {
+            UI.showToast('Name ist erforderlich. Bitte erst "Erkennen" klicken.', 'warning');
+            return;
+        }
+
+        const discovered = this._discoveredData || {};
+        const data = {
+            name,
+            source_type: discovered.source_type || 'web_source',
+            category: document.getElementById('src-category').value,
+            url: discovered.rss_url || null,
+            domain: document.getElementById('src-domain').value.trim() || discovered.domain || null,
+            notes: document.getElementById('src-notes').value.trim() || null,
+        };
+
+        if (!data.domain && discovered.domain) {
+            data.domain = discovered.domain;
+        }
+
+        try {
+            if (this._editingSourceId) {
+                await API.updateSource(this._editingSourceId, data);
+                UI.showToast('Quelle aktualisiert.', 'success');
+            } else {
+                await API.createSource(data);
+                UI.showToast('Quelle hinzugefügt.', 'success');
+            }
+
+            this.toggleSourceForm(false);
+            await this.loadSources();
+            this.updateSidebarStats();
+        } catch (err) {
+            UI.showToast('Fehler: ' + err.message, 'error');
+        }
+    },
+
+    logout() {
+        localStorage.removeItem('osint_token');
+        localStorage.removeItem('osint_username');
+        this._sessionWarningShown = false;
+        WS.disconnect();
+        window.location.href = '/';
+    },
+};
+
+// === Barrierefreier Bestätigungsdialog ===
+
+function confirmDialog(message) {
+    return new Promise((resolve) => {
+        // Overlay erstellen
+        const overlay = document.createElement('div');
+        overlay.className = 'modal-overlay active';
+        overlay.setAttribute('role', 'alertdialog');
+        overlay.setAttribute('aria-modal', 'true');
+        overlay.setAttribute('aria-labelledby', 'confirm-dialog-msg');
+
+        const modal = document.createElement('div');
+        modal.className = 'modal';
+        modal.style.maxWidth = '420px';
+        modal.innerHTML = `
+            <div class="modal-header">
+                <div class="modal-title">Bestätigung</div>
+            </div>
+            <div class="modal-body" style="padding:16px 24px;">
+                <p id="confirm-dialog-msg" style="margin:0;font-size:14px;color:var(--text-primary);line-height:1.5;">${message.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-secondary" id="confirm-cancel">Abbrechen</button>
+                <button class="btn btn-primary" id="confirm-ok">Bestätigen</button>
+            </div>
+        `;
+        overlay.appendChild(modal);
+        document.body.appendChild(overlay);
+
+        const previousFocus = document.activeElement;
+
+        const cleanup = (result) => {
+            releaseFocus(overlay);
+            overlay.remove();
+            if (previousFocus) previousFocus.focus();
+            resolve(result);
+        };
+
+        modal.querySelector('#confirm-cancel').addEventListener('click', () => cleanup(false));
+        modal.querySelector('#confirm-ok').addEventListener('click', () => cleanup(true));
+        overlay.addEventListener('click', (e) => {
+            if (e.target === overlay) cleanup(false);
+        });
+        overlay.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') cleanup(false);
+        });
+
+        trapFocus(overlay);
+    });
+}
+
+// === Globale Hilfsfunktionen ===
+
+// --- Focus-Trap für Modals (WCAG 2.4.3) ---
+const FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
+function trapFocus(modalEl) {
+    const handler = (e) => {
+        if (e.key !== 'Tab') return;
+        const focusable = Array.from(modalEl.querySelectorAll(FOCUSABLE_SELECTOR)).filter(el => el.offsetParent !== null);
+        if (focusable.length === 0) return;
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        if (e.shiftKey && document.activeElement === first) {
+            e.preventDefault();
+            last.focus();
+        } else if (!e.shiftKey && document.activeElement === last) {
+            e.preventDefault();
+            first.focus();
+        }
+    };
+    modalEl._focusTrapHandler = handler;
+    modalEl.addEventListener('keydown', handler);
+    // Fokus auf erstes Element setzen
+    requestAnimationFrame(() => {
+        const focusable = Array.from(modalEl.querySelectorAll(FOCUSABLE_SELECTOR)).filter(el => el.offsetParent !== null);
+        if (focusable.length > 0) focusable[0].focus();
+    });
+}
+
+function releaseFocus(modalEl) {
+    if (modalEl._focusTrapHandler) {
+        modalEl.removeEventListener('keydown', modalEl._focusTrapHandler);
+        delete modalEl._focusTrapHandler;
+    }
+}
+
+function openModal(id) {
+    if (id === 'modal-new' && !App._editingIncidentId) {
+        // Create-Modus: Formular zurücksetzen
+        document.getElementById('new-incident-form').reset();
+        document.getElementById('modal-new-title').textContent = 'Neue Lage anlegen';
+        document.getElementById('modal-new-submit').textContent = 'Lage anlegen';
+        toggleTypeDefaults();
+        toggleRefreshInterval();
+    }
+    const modal = document.getElementById(id);
+    modal._previousFocus = document.activeElement;
+    modal.classList.add('active');
+    trapFocus(modal);
+}
+
+function closeModal(id) {
+    const modal = document.getElementById(id);
+    releaseFocus(modal);
+    modal.classList.remove('active');
+    if (modal._previousFocus) {
+        modal._previousFocus.focus();
+        delete modal._previousFocus;
+    }
+    if (id === 'modal-new') {
+        App._editingIncidentId = null;
+        document.getElementById('modal-new-title').textContent = 'Neue Lage anlegen';
+        document.getElementById('modal-new-submit').textContent = 'Lage anlegen';
+    }
+}
+
+function openContentModal(title, sourceElementId) {
+    const source = document.getElementById(sourceElementId);
+    if (!source) return;
+
+    document.getElementById('content-viewer-title').textContent = title;
+    const body = document.getElementById('content-viewer-body');
+    const headerExtra = document.getElementById('content-viewer-header-extra');
+    headerExtra.innerHTML = '';
+
+    if (sourceElementId === 'factcheck-list') {
+        // Faktencheck: Filter in den Modal-Header, Liste in den Body
+        const filters = document.getElementById('fc-filters');
+        if (filters && filters.innerHTML.trim()) {
+            headerExtra.innerHTML = `<div class="fc-filter-bar">${filters.innerHTML}</div>`;
+        }
+        body.innerHTML = source.innerHTML;
+        // Filter im Modal auf Modal-Items umleiten
+        headerExtra.querySelectorAll('.fc-dropdown-item input[type="checkbox"]').forEach(cb => {
+            cb.onchange = function() {
+                const status = this.closest('.fc-dropdown-item').dataset.status;
+                body.querySelectorAll(`.factcheck-item[data-fc-status="${status}"]`).forEach(el => {
+                    el.style.display = cb.checked ? '' : 'none';
+                });
+            };
+        });
+    } else if (sourceElementId === 'source-overview-content') {
+        // Quellenübersicht: Detailansicht mit Suchleiste
+        headerExtra.innerHTML = '<input type="text" class="timeline-filter-input" placeholder="Quellen durchsuchen..." oninput="App.filterModalSources(this.value)" style="width:200px;">';
+        body.innerHTML = buildDetailedSourceOverview();
+    } else if (sourceElementId === 'timeline') {
+        // Timeline: Vollständige vertikale Timeline im Modal mit Filter + Suche
+        headerExtra.innerHTML = `<div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap;">
+            <div class="ht-filter-group">
+                <button class="ht-modal-filter-btn active" data-filter="all" onclick="App.filterModalTimelineType('all', this)">Alle</button>
+                <button class="ht-modal-filter-btn" data-filter="articles" onclick="App.filterModalTimelineType('articles', this)">Meldungen</button>
+                <button class="ht-modal-filter-btn" data-filter="snapshots" onclick="App.filterModalTimelineType('snapshots', this)">Lageberichte</button>
+            </div>
+            <input type="text" class="timeline-filter-input" placeholder="Suche..." oninput="App.filterModalTimeline(this.value)" style="width:180px;">
+        </div>`;
+        body.innerHTML = App._buildFullVerticalTimeline('all', '');
+    } else {
+        body.innerHTML = source.innerHTML;
+    }
+
+    openModal('modal-content-viewer');
+}
+
+App.filterModalSources = function(query) {
+    const q = query.toLowerCase().trim();
+    const details = document.querySelectorAll('#content-viewer-body details');
+    details.forEach(d => {
+        if (!q) {
+            d.style.display = '';
+            d.removeAttribute('open');
+            return;
+        }
+        const name = d.querySelector('summary').textContent.toLowerCase();
+        // Quellenname oder Artikel-Headlines durchsuchen
+        const articles = d.querySelectorAll('div > div');
+        let articleMatch = false;
+        articles.forEach(a => {
+            const text = a.textContent.toLowerCase();
+            const hit = text.includes(q);
+            a.style.display = hit ? '' : 'none';
+            if (hit) articleMatch = true;
+        });
+        const match = name.includes(q) || articleMatch;
+        d.style.display = match ? '' : 'none';
+        // Bei Artikeltreffer aufklappen, bei Namens-Match alle Artikel zeigen
+        if (match && articleMatch && !name.includes(q)) {
+            d.setAttribute('open', '');
+        } else if (name.includes(q)) {
+            articles.forEach(a => a.style.display = '');
+        }
+    });
+};
+
+function buildDetailedSourceOverview() {
+    const articles = App._currentArticles || [];
+    if (!articles.length) return '<div style="padding:24px;color:var(--text-disabled);">Keine Artikel vorhanden</div>';
+
+    // Nach Quelle gruppieren
+    const sourceMap = {};
+    articles.forEach(a => {
+        const name = a.source || 'Unbekannt';
+        if (!sourceMap[name]) sourceMap[name] = { articles: [], languages: new Set() };
+        sourceMap[name].articles.push(a);
+        sourceMap[name].languages.add((a.language || 'de').toUpperCase());
+    });
+
+    const sources = Object.entries(sourceMap).sort((a, b) => b[1].articles.length - a[1].articles.length);
+
+    // Sprach-Statistik Header
+    const langCount = {};
+    articles.forEach(a => {
+        const lang = (a.language || 'de').toUpperCase();
+        langCount[lang] = (langCount[lang] || 0) + 1;
+    });
+    const langChips = Object.entries(langCount)
+        .sort((a, b) => b[1] - a[1])
+        .map(([lang, count]) => `<span class="source-lang-chip">${lang} <strong>${count}</strong></span>`)
+        .join('');
+
+    let html = `<div class="source-overview-header">
+        <span class="source-overview-stat">${articles.length} Artikel aus ${sources.length} Quellen</span>
+        <div class="source-lang-chips">${langChips}</div>
+    </div>`;
+
+    sources.forEach(([name, data]) => {
+        const langs = [...data.languages].join('/');
+        const escapedName = UI.escape(name);
+        html += `<details style="border:1px solid var(--border);border-radius:4px;margin-bottom:6px;">
+            <summary style="display:flex;align-items:center;gap:8px;padding:10px 14px;cursor:pointer;background:var(--bg-secondary);color:var(--text-primary);font-size:13px;list-style:none;">
+                <span style="color:var(--text-secondary);font-size:12px;flex-shrink:0;">&#9656;</span>
+                <span style="flex:1;font-weight:500;">${escapedName}</span>
+                <span style="font-size:10px;color:var(--text-secondary);flex-shrink:0;">${langs}</span>
+                <span style="font-size:12px;font-weight:700;color:var(--accent);background:var(--tint-accent);padding:1px 6px;border-radius:4px;flex-shrink:0;">${data.articles.length}</span>
+            </summary>
+            <div style="border-top:1px solid var(--border);">`;
+        data.articles.forEach(a => {
+            const headline = UI.escape(a.headline_de || a.headline || 'Ohne Titel');
+            const time = a.collected_at
+                ? new Date(a.collected_at).toLocaleString('de-DE', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' })
+                : '';
+            const langBadge = a.language && a.language !== 'de'
+                ? `<span class="lang-badge">${a.language.toUpperCase()}</span>` : '';
+            const link = a.source_url
+                ? `<a href="${UI.escape(a.source_url)}" target="_blank" rel="noopener" style="color:var(--accent);text-decoration:none;font-size:14px;flex-shrink:0;opacity:0.6;" title="Artikel öffnen">&#8599;</a>` : '';
+            html += `<div style="display:flex;align-items:center;gap:10px;padding:8px 14px 8px 36px;font-size:12px;border-bottom:1px solid var(--border);">
+                <span style="color:var(--text-secondary);flex-shrink:0;min-width:90px;font-size:11px;">${time}</span>
+                <span style="flex:1;color:var(--text-secondary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">${headline}</span>
+                ${langBadge}
+                ${link}
+            </div>`;
+        });
+        html += `</div></details>`;
+    });
+
+    return html;
+}
+
+function toggleRefreshInterval() {
+    const mode = document.getElementById('inc-refresh-mode').value;
+    const field = document.getElementById('refresh-interval-field');
+    field.classList.toggle('visible', mode === 'auto');
+}
+
+function updateIntervalMin() {
+    const unit = parseInt(document.getElementById('inc-refresh-unit').value);
+    const input = document.getElementById('inc-refresh-value');
+    if (unit === 1) {
+        // Minuten: Minimum 10
+        input.min = 10;
+        if (parseInt(input.value) < 10) input.value = 10;
+    } else {
+        // Stunden/Tage/Wochen: Minimum 1
+        input.min = 1;
+        if (parseInt(input.value) < 1) input.value = 1;
+    }
+}
+
+function updateVisibilityHint() {
+    const isPublic = document.getElementById('inc-visibility').checked;
+    const text = document.getElementById('visibility-text');
+    if (text) {
+        text.textContent = isPublic
+            ? 'Öffentlich — für alle Nutzer sichtbar'
+            : 'Privat — nur für dich sichtbar';
+    }
+}
+
+function updateSourcesHint() {
+    const intl = document.getElementById('inc-international').checked;
+    const hint = document.getElementById('sources-hint');
+    if (hint) {
+        hint.textContent = intl
+            ? 'DE + internationale Feeds (Reuters, BBC, Al Jazeera etc.)'
+            : 'Nur deutschsprachige Quellen (DE, AT, CH)';
+    }
+}
+
+function toggleTypeDefaults() {
+    const type = document.getElementById('inc-type').value;
+    const hint = document.getElementById('type-hint');
+    const refreshMode = document.getElementById('inc-refresh-mode');
+
+    if (type === 'research') {
+        hint.textContent = 'Nur WebSearch (Deep Research), manuelle Aktualisierung empfohlen';
+        refreshMode.value = 'manual';
+        toggleRefreshInterval();
+    } else {
+        hint.textContent = 'RSS-Feeds + WebSearch, automatische Aktualisierung empfohlen';
+    }
+}
+
+// Tab-Fokus: Nur Tab-Badge (Titel-Counter) zurücksetzen, nicht alle Notifications
+window.addEventListener('focus', () => {
+    document.title = App._originalTitle;
+});
+
+// ESC schließt Modals
+// F5: Daten aktualisieren statt Seite neu laden
+document.addEventListener('keydown', (e) => {
+    if (e.key === 'F5') {
+        e.preventDefault();
+        App.softRefresh();
+    }
+});
+
+document.addEventListener('keydown', (e) => {
+    if (e.key === 'Escape') {
+        document.querySelectorAll('.modal-overlay.active').forEach(m => {
+            closeModal(m.id);
+        });
+    }
+});
+
+// Keyboard-Handler: Enter/Space auf [role="button"] löst click aus (WCAG 2.1.1)
+document.addEventListener('keydown', (e) => {
+    if ((e.key === 'Enter' || e.key === ' ') && e.target.matches('[role="button"]')) {
+        e.preventDefault();
+        e.target.click();
+    }
+});
+
+// Session-Ablauf prüfen (alle 60 Sekunden)
+setInterval(() => {
+    const token = localStorage.getItem('osint_token');
+    if (!token) return;
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        const expiresAt = payload.exp * 1000;
+        const remaining = expiresAt - Date.now();
+        const fiveMinutes = 5 * 60 * 1000;
+        if (remaining <= 0) {
+            App.logout();
+        } else if (remaining <= fiveMinutes && !App._sessionWarningShown) {
+            App._sessionWarningShown = true;
+            const mins = Math.ceil(remaining / 60000);
+            UI.showToast(`Session läuft in ${mins} Minute${mins !== 1 ? 'n' : ''} ab. Bitte erneut anmelden.`, 'warning', 15000);
+        }
+    } catch (e) { /* Token nicht parsbar */ }
+}, 60000);
+
+// Modal-Overlays: Klick außerhalb der Box schließt das Modal
+document.addEventListener('click', (e) => {
+    if (e.target.classList.contains('modal-overlay') && e.target.classList.contains('active')) {
+        closeModal(e.target.id);
+    }
+});
+
+// App starten
+document.addEventListener('click', (e) => {
+    if (!e.target.closest('.export-dropdown')) {
+        App._closeExportDropdown();
+    }
+});
+document.addEventListener('DOMContentLoaded', () => App.init());
diff --git a/src/static/js/components.js b/src/static/js/components.js
new file mode 100644
index 0000000..2f532c0
--- /dev/null
+++ b/src/static/js/components.js
@@ -0,0 +1,625 @@
+/**
+ * UI-Komponenten für das Dashboard.
+ */
+const UI = {
+    /**
+     * Sidebar-Eintrag für eine Lage rendern.
+     */
+    renderIncidentItem(incident, isActive) {
+        const isRefreshing = App._refreshingIncidents && App._refreshingIncidents.has(incident.id);
+        const dotClass = isRefreshing ? 'refreshing' : (incident.status === 'active' ? 'active' : 'archived');
+        const activeClass = isActive ? 'active' : '';
+        const creator = incident.created_by_username || '';
+
+        return `
+            <div class="incident-item ${activeClass}" data-id="${incident.id}" onclick="App.selectIncident(${incident.id})" role="button" tabindex="0">
+                <span class="incident-dot ${dotClass}" id="dot-${incident.id}"></span>
+                <div style="flex:1;min-width:0;">
+                    <div class="incident-name">${this.escape(incident.title)}</div>
+                    <div class="incident-meta">${incident.article_count} Artikel &middot; ${this.escape(creator)}</div>
+                </div>
+                ${incident.visibility === 'private' ? '<span class="badge badge-private" style="font-size:9px;">PRIVAT</span>' : ''}
+                ${incident.refresh_mode === 'auto' ? '<span class="badge badge-auto" title="Auto-Refresh aktiv">&#x21bb;</span>' : ''}
+            </div>
+        `;
+    },
+
+    /**
+     * Faktencheck-Eintrag rendern.
+     */
+    factCheckLabels: {
+        confirmed: 'Bestätigt durch mehrere Quellen',
+        unconfirmed: 'Nicht unabhängig bestätigt',
+        contradicted: 'Widerlegt',
+        developing: 'Faktenlage noch im Fluss',
+        established: 'Gesicherter Fakt (3+ Quellen)',
+        disputed: 'Umstrittener Sachverhalt',
+        unverified: 'Nicht unabhängig verifizierbar',
+    },
+
+    factCheckTooltips: {
+        confirmed: 'Bestätigt: Mindestens zwei unabhängige, seriöse Quellen stützen diese Aussage übereinstimmend.',
+        established: 'Gesichert: Drei oder mehr unabhängige Quellen bestätigen den Sachverhalt. Hohe Verlässlichkeit.',
+        developing: 'Unklar: Die Faktenlage ist noch im Fluss. Neue Informationen können das Bild verändern.',
+        unconfirmed: 'Unbestätigt: Bisher nur aus einer Quelle bekannt. Eine unabhängige Bestätigung steht aus.',
+        unverified: 'Ungeprüft: Die Aussage konnte bisher nicht anhand verfügbarer Quellen überprüft werden.',
+        disputed: 'Umstritten: Quellen widersprechen sich. Es gibt sowohl stützende als auch widersprechende Belege.',
+        contradicted: 'Widerlegt: Zuverlässige Quellen widersprechen dieser Aussage. Wahrscheinlich falsch.',
+    },
+
+    factCheckChipLabels: {
+        confirmed: 'Bestätigt',
+        unconfirmed: 'Unbestätigt',
+        contradicted: 'Widerlegt',
+        developing: 'Unklar',
+        established: 'Gesichert',
+        disputed: 'Umstritten',
+        unverified: 'Ungeprüft',
+    },
+
+    factCheckIcons: {
+        confirmed: '&#10003;',
+        unconfirmed: '?',
+        contradicted: '&#10007;',
+        developing: '&#8635;',
+        established: '&#10003;',
+        disputed: '&#9888;',
+        unverified: '?',
+    },
+
+    /**
+     * Faktencheck-Filterleiste rendern.
+     */
+    renderFactCheckFilters(factchecks) {
+        // Welche Stati kommen tatsächlich vor + Zähler
+        const statusCounts = {};
+        factchecks.forEach(fc => {
+            statusCounts[fc.status] = (statusCounts[fc.status] || 0) + 1;
+        });
+        const statusOrder = ['confirmed', 'established', 'developing', 'unconfirmed', 'unverified', 'disputed', 'contradicted'];
+        const usedStatuses = statusOrder.filter(s => statusCounts[s]);
+        if (usedStatuses.length <= 1) return '';
+
+        const items = usedStatuses.map(status => {
+            const icon = this.factCheckIcons[status] || '?';
+            const chipLabel = this.factCheckChipLabels[status] || status;
+            const tooltip = this.factCheckTooltips[status] || '';
+            const count = statusCounts[status];
+            return `<label class="fc-dropdown-item" data-status="${status}" title="${tooltip}">
+                <input type="checkbox" checked onchange="App.toggleFactCheckFilter('${status}')">
+                <span class="factcheck-icon ${status}">${icon}</span>
+                <span class="fc-dropdown-label">${chipLabel}</span>
+                <span class="fc-dropdown-count">${count}</span>
+            </label>`;
+        }).join('');
+
+        return `<button class="fc-dropdown-toggle" onclick="App.toggleFcDropdown(event)">Filter</button>
+            <div class="fc-dropdown-menu" id="fc-dropdown-menu">${items}</div>`;
+    },
+
+    renderFactCheck(fc) {
+        const urls = (fc.evidence || '').match(/https?:\/\/[^\s,)]+/g) || [];
+        const count = urls.length;
+        return `
+            <div class="factcheck-item" data-fc-status="${fc.status}">
+                <div class="factcheck-icon ${fc.status}" title="${this.factCheckTooltips[fc.status] || this.factCheckLabels[fc.status] || fc.status}" aria-hidden="true">${this.factCheckIcons[fc.status] || '?'}</div>
+                <span class="sr-only">${this.factCheckLabels[fc.status] || fc.status}</span>
+                <div style="flex:1;">
+                    <div class="factcheck-claim">${this.escape(fc.claim)}</div>
+                    <div style="display:flex;align-items:center;gap:6px;margin-top:2px;">
+                        <span class="factcheck-sources">${count} Quelle${count !== 1 ? 'n' : ''}</span>
+                    </div>
+                    <div class="evidence-block">${this.renderEvidence(fc.evidence || '')}</div>
+                </div>
+            </div>
+        `;
+    },
+
+    /**
+     * Evidence mit erklärenden Text UND Quellen-Chips rendern.
+     */
+    renderEvidence(text) {
+        if (!text) return '<span class="evidence-empty">Keine Belege</span>';
+
+        const urls = text.match(/https?:\/\/[^\s,)]+/g) || [];
+        if (urls.length === 0) {
+            return `<span class="evidence-text">${this.escape(text)}</span>`;
+        }
+
+        // Erklärenden Text extrahieren (URLs entfernen)
+        let explanation = text;
+        urls.forEach(url => { explanation = explanation.replace(url, '').trim(); });
+        // Aufräumen: Klammern, mehrfache Kommas/Leerzeichen
+        explanation = explanation.replace(/\(\s*\)/g, '');
+        explanation = explanation.replace(/,\s*,/g, ',');
+        explanation = explanation.replace(/\s+/g, ' ').trim();
+        explanation = explanation.replace(/[,.:;]+$/, '').trim();
+
+        // Chips für jede URL
+        const chips = urls.map(url => {
+            let label;
+            try { label = new URL(url).hostname.replace('www.', ''); } catch { label = url; }
+            return `<a href="${this.escape(url)}" target="_blank" rel="noopener" class="evidence-chip" title="${this.escape(url)}">${this.escape(label)}</a>`;
+        }).join('');
+
+        const explanationHtml = explanation
+            ? `<span class="evidence-text">${this.escape(explanation)}</span>`
+            : '';
+
+        return `${explanationHtml}<div class="evidence-chips">${chips}</div>`;
+    },
+
+    /**
+     * Verifizierungs-Badge.
+     */
+    verificationBadge(status) {
+        const map = {
+            verified: { class: 'badge-verified', text: 'Verifiziert' },
+            unverified: { class: 'badge-unverified', text: 'Offen' },
+            contradicted: { class: 'badge-contradicted', text: 'Widerlegt' },
+        };
+        const badge = map[status] || map.unverified;
+        return `<span class="badge ${badge.class}">${badge.text}</span>`;
+    },
+
+    /**
+     * Toast-Benachrichtigung anzeigen.
+     */
+    _toastTimers: new Map(),
+
+    showToast(message, type = 'info', duration = 5000) {
+        const container = document.getElementById('toast-container');
+
+        // Duplikat? Bestehenden Toast neu animieren
+        const existing = Array.from(container.children).find(
+            t => t.dataset.msg === message && t.dataset.type === type
+        );
+        if (existing) {
+            clearTimeout(this._toastTimers.get(existing));
+            // Kurz rausschieben, dann neu reingleiten
+            existing.style.transition = 'none';
+            existing.style.opacity = '0';
+            existing.style.transform = 'translateX(100%)';
+            void existing.offsetWidth; // Reflow erzwingen
+            existing.style.transition = 'all 0.3s ease';
+            existing.style.opacity = '1';
+            existing.style.transform = 'translateX(0)';
+            const timer = setTimeout(() => {
+                existing.style.opacity = '0';
+                existing.style.transform = 'translateX(100%)';
+                setTimeout(() => { existing.remove(); this._toastTimers.delete(existing); }, 300);
+            }, duration);
+            this._toastTimers.set(existing, timer);
+            return;
+        }
+
+        const toast = document.createElement('div');
+        toast.className = `toast toast-${type}`;
+        toast.setAttribute('role', 'status');
+        toast.dataset.msg = message;
+        toast.dataset.type = type;
+        toast.innerHTML = `<span class="toast-text">${this.escape(message)}</span>`;
+        container.appendChild(toast);
+
+        const timer = setTimeout(() => {
+            toast.style.opacity = '0';
+            toast.style.transform = 'translateX(100%)';
+            toast.style.transition = 'all 0.3s ease';
+            setTimeout(() => { toast.remove(); this._toastTimers.delete(toast); }, 300);
+        }, duration);
+        this._toastTimers.set(toast, timer);
+    },
+
+    _progressStartTime: null,
+    _progressTimer: null,
+
+    /**
+     * Fortschrittsanzeige einblenden und Status setzen.
+     */
+    showProgress(status, extra = {}) {
+        const bar = document.getElementById('progress-bar');
+        if (!bar) return;
+        bar.style.display = 'block';
+        bar.classList.remove('progress-bar--complete', 'progress-bar--error');
+
+        const steps = {
+            queued: { active: 0, label: 'In Warteschlange...' },
+            researching: { active: 1, label: 'Recherchiert Quellen...' },
+            deep_researching: { active: 1, label: 'Tiefenrecherche läuft...' },
+            analyzing: { active: 2, label: 'Analysiert Meldungen...' },
+            factchecking: { active: 3, label: 'Faktencheck läuft...' },
+        };
+
+        const step = steps[status] || steps.queued;
+
+        // Queue-Position anzeigen
+        let labelText = step.label;
+        if (status === 'queued' && extra.queue_position > 1) {
+            labelText = `In Warteschlange (Position ${extra.queue_position})...`;
+        } else if (extra.detail) {
+            labelText = extra.detail;
+        }
+
+        // Timer starten beim Übergang von queued zu aktivem Status
+        if (step.active > 0 && !this._progressStartTime) {
+            if (extra.started_at) {
+                // Echte Startzeit vom Server verwenden
+                const serverStart = parseUTC(extra.started_at);
+                this._progressStartTime = serverStart ? serverStart.getTime() : Date.now();
+            } else {
+                this._progressStartTime = Date.now();
+            }
+            this._startProgressTimer();
+        }
+
+        const stepIds = ['step-researching', 'step-analyzing', 'step-factchecking'];
+
+        stepIds.forEach((id, i) => {
+            const el = document.getElementById(id);
+            if (!el) return;
+            el.className = 'progress-step';
+            if (i + 1 < step.active) el.classList.add('done');
+            else if (i + 1 === step.active) el.classList.add('active');
+        });
+
+        const fill = document.getElementById('progress-fill');
+        const percent = step.active === 0 ? 5 : Math.round((step.active / 3) * 100);
+        if (fill) {
+            fill.style.width = percent + '%';
+        }
+
+        // ARIA-Werte auf der Progressbar aktualisieren
+        bar.setAttribute('aria-valuenow', String(percent));
+        bar.setAttribute('aria-valuetext', labelText);
+
+        const label = document.getElementById('progress-label');
+        if (label) label.textContent = labelText;
+
+        // Cancel-Button sichtbar machen
+        const cancelBtn = document.getElementById('progress-cancel-btn');
+        if (cancelBtn) cancelBtn.style.display = '';
+    },
+
+    /**
+     * Timer-Intervall starten (1x pro Sekunde).
+     */
+    _startProgressTimer() {
+        if (this._progressTimer) return;
+        const timerEl = document.getElementById('progress-timer');
+        if (!timerEl) return;
+
+        this._progressTimer = setInterval(() => {
+            if (!this._progressStartTime) return;
+            const elapsed = Math.floor((Date.now() - this._progressStartTime) / 1000);
+            const mins = Math.floor(elapsed / 60);
+            const secs = elapsed % 60;
+            timerEl.textContent = `${mins}:${String(secs).padStart(2, '0')}`;
+        }, 1000);
+    },
+
+    /**
+     * Abschluss-Animation: Grüner Balken mit Summary-Text.
+     */
+    showProgressComplete(data) {
+        const bar = document.getElementById('progress-bar');
+        if (!bar) return;
+
+        // Timer stoppen
+        this._stopProgressTimer();
+
+        // Alle Steps auf done
+        ['step-researching', 'step-analyzing', 'step-factchecking'].forEach(id => {
+            const el = document.getElementById(id);
+            if (el) { el.className = 'progress-step done'; }
+        });
+
+        // Fill auf 100%
+        const fill = document.getElementById('progress-fill');
+        if (fill) fill.style.width = '100%';
+
+        // Complete-Klasse
+        bar.classList.remove('progress-bar--error');
+        bar.classList.add('progress-bar--complete');
+
+        // Label mit Summary
+        const parts = [];
+        if (data.new_articles > 0) {
+            parts.push(`${data.new_articles} neue Artikel`);
+        }
+        if (data.confirmed_count > 0) {
+            parts.push(`${data.confirmed_count} Fakten bestätigt`);
+        }
+        if (data.contradicted_count > 0) {
+            parts.push(`${data.contradicted_count} widerlegt`);
+        }
+        const summaryText = parts.length > 0 ? parts.join(', ') : 'Keine neuen Entwicklungen';
+        const label = document.getElementById('progress-label');
+        if (label) label.textContent = `Abgeschlossen: ${summaryText}`;
+
+        // Cancel-Button ausblenden
+        const cancelBtn = document.getElementById('progress-cancel-btn');
+        if (cancelBtn) cancelBtn.style.display = 'none';
+
+        bar.setAttribute('aria-valuenow', '100');
+        bar.setAttribute('aria-valuetext', 'Abgeschlossen');
+    },
+
+    /**
+     * Fehler-Zustand: Roter Balken mit Fehlermeldung.
+     */
+    showProgressError(errorMsg, willRetry = false, delay = 0) {
+        const bar = document.getElementById('progress-bar');
+        if (!bar) return;
+        bar.style.display = 'block';
+
+        // Timer stoppen
+        this._stopProgressTimer();
+
+        // Error-Klasse
+        bar.classList.remove('progress-bar--complete');
+        bar.classList.add('progress-bar--error');
+
+        const label = document.getElementById('progress-label');
+        if (label) {
+            label.textContent = willRetry
+                ? `Fehlgeschlagen \u2014 erneuter Versuch in ${delay}s...`
+                : `Fehlgeschlagen: ${errorMsg}`;
+        }
+
+        // Cancel-Button ausblenden
+        const cancelBtn = document.getElementById('progress-cancel-btn');
+        if (cancelBtn) cancelBtn.style.display = 'none';
+
+        // Bei finalem Fehler nach 6s ausblenden
+        if (!willRetry) {
+            setTimeout(() => this.hideProgress(), 6000);
+        }
+    },
+
+    /**
+     * Timer-Intervall stoppen und zurücksetzen.
+     */
+    _stopProgressTimer() {
+        if (this._progressTimer) {
+            clearInterval(this._progressTimer);
+            this._progressTimer = null;
+        }
+        this._progressStartTime = null;
+        const timerEl = document.getElementById('progress-timer');
+        if (timerEl) timerEl.textContent = '';
+    },
+
+    /**
+     * Fortschrittsanzeige ausblenden.
+     */
+    hideProgress() {
+        const bar = document.getElementById('progress-bar');
+        if (bar) {
+            bar.style.display = 'none';
+            bar.classList.remove('progress-bar--complete', 'progress-bar--error');
+        }
+        this._stopProgressTimer();
+    },
+
+    /**
+     * Zusammenfassung mit Inline-Zitaten und Quellenverzeichnis rendern.
+     */
+    renderSummary(summary, sourcesJson, incidentType) {
+        if (!summary) return '<span style="color:var(--text-tertiary);">Noch keine Zusammenfassung.</span>';
+
+        let sources = [];
+        try { sources = JSON.parse(sourcesJson || '[]'); } catch(e) {}
+
+        // Markdown-Rendering
+        let html = this.escape(summary);
+
+        // ## Überschriften
+        html = html.replace(/^## (.+)$/gm, '<h3 class="briefing-heading">$1</h3>');
+        // **Fettdruck**
+        html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+        // Listen (- Item)
+        html = html.replace(/^- (.+)$/gm, '<li>$1</li>');
+        html = html.replace(/(<li>.*<\/li>\n?)+/gs, '<ul>$&</ul>');
+        // Zeilenumbrüche (aber nicht nach Headings/Listen)
+        html = html.replace(/\n(?!<)/g, '<br>');
+        // Überflüssige <br> nach Block-Elementen entfernen + doppelte <br> zusammenfassen
+        html = html.replace(/<\/h3>(<br>)+/g, '</h3>');
+        html = html.replace(/<\/ul>(<br>)+/g, '</ul>');
+        html = html.replace(/(<br>){2,}/g, '<br>');
+
+        // Inline-Zitate [1], [2] etc. als klickbare Links rendern
+        if (sources.length > 0) {
+            html = html.replace(/\[(\d+)\]/g, (match, num) => {
+                const src = sources.find(s => s.nr === parseInt(num));
+                if (src && src.url) {
+                    return `<a href="${this.escape(src.url)}" target="_blank" rel="noopener" class="citation" title="${this.escape(src.name)}">[${num}]</a>`;
+                }
+                return match;
+            });
+        }
+
+        return `<div class="briefing-content">${html}</div>`;
+    },
+
+    /**
+     * Quellenübersicht für eine Lage rendern.
+     */
+    renderSourceOverview(articles) {
+        if (!articles || articles.length === 0) return '';
+
+        // Nach Quelle aggregieren
+        const sourceMap = {};
+        articles.forEach(a => {
+            const name = a.source || 'Unbekannt';
+            if (!sourceMap[name]) {
+                sourceMap[name] = { count: 0, languages: new Set(), urls: [] };
+            }
+            sourceMap[name].count++;
+            sourceMap[name].languages.add(a.language || 'de');
+            if (a.source_url) sourceMap[name].urls.push(a.source_url);
+        });
+
+        const sources = Object.entries(sourceMap)
+            .sort((a, b) => b[1].count - a[1].count);
+
+        // Sprach-Statistik
+        const langCount = {};
+        articles.forEach(a => {
+            const lang = (a.language || 'de').toUpperCase();
+            langCount[lang] = (langCount[lang] || 0) + 1;
+        });
+
+        const langChips = Object.entries(langCount)
+            .sort((a, b) => b[1] - a[1])
+            .map(([lang, count]) => `<span class="source-lang-chip">${lang} <strong>${count}</strong></span>`)
+            .join('');
+
+        let html = `<div class="source-overview-header">`;
+        html += `<span class="source-overview-stat">${articles.length} Artikel aus ${sources.length} Quellen</span>`;
+        html += `<div class="source-lang-chips">${langChips}</div>`;
+        html += `</div>`;
+
+        html += '<div class="source-overview-grid">';
+        sources.forEach(([name, data]) => {
+            const langs = [...data.languages].map(l => l.toUpperCase()).join('/');
+            html += `<div class="source-overview-item">
+                <span class="source-overview-name">${this.escape(name)}</span>
+                <span class="source-overview-lang">${langs}</span>
+                <span class="source-overview-count">${data.count}</span>
+            </div>`;
+        });
+        html += '</div>';
+
+        return html;
+    },
+
+    /**
+     * Kategorie-Labels.
+     */
+    _categoryLabels: {
+        'nachrichtenagentur': 'Agentur',
+        'oeffentlich-rechtlich': 'ÖR',
+        'qualitaetszeitung': 'Qualität',
+        'behoerde': 'Behörde',
+        'fachmedien': 'Fach',
+        'think-tank': 'Think Tank',
+        'international': 'Intl.',
+        'regional': 'Regional',
+        'sonstige': 'Sonstige',
+    },
+
+    /**
+     * Domain-Gruppe rendern (aufklappbar mit Feeds).
+     */
+    renderSourceGroup(domain, feeds, isExcluded, excludedNotes) {
+        const catLabel = this._categoryLabels[feeds[0]?.category] || feeds[0]?.category || '';
+        const feedCount = feeds.filter(f => f.source_type !== 'excluded').length;
+        const hasMultiple = feedCount > 1;
+        const displayName = domain || feeds[0]?.name || 'Unbekannt';
+        const escapedDomain = this.escape(domain);
+
+        if (isExcluded) {
+            // Gesperrte Domain
+            const notesHtml = excludedNotes ? ` <span class="source-group-notes">${this.escape(excludedNotes)}</span>` : '';
+            return `<div class="source-group">
+                <div class="source-group-header excluded">
+                    <div class="source-group-info">
+                        <span class="source-group-name">${this.escape(displayName)}</span>${notesHtml}
+                    </div>
+                    <span class="source-excluded-badge">Gesperrt</span>
+                    <div class="source-group-actions">
+                        <button class="btn btn-small btn-secondary" onclick="App.unblockDomain('${escapedDomain}')">Entsperren</button>
+                        <button class="source-delete-btn" onclick="App.deleteDomain('${escapedDomain}')" title="Löschen" aria-label="Löschen">&times;</button>
+                    </div>
+                </div>
+            </div>`;
+        }
+
+        // Aktive Domain-Gruppe
+        const toggleAttr = hasMultiple ? `onclick="App.toggleGroup('${escapedDomain}')" role="button" tabindex="0" aria-expanded="false"` : '';
+        const toggleIcon = hasMultiple ? '<span class="source-group-toggle" aria-hidden="true">&#9654;</span>' : '<span class="source-group-toggle-placeholder"></span>';
+
+        let feedRows = '';
+        if (hasMultiple) {
+            const realFeeds = feeds.filter(f => f.source_type !== 'excluded');
+            feedRows = `<div class="source-group-feeds" data-domain="${escapedDomain}">`;
+            realFeeds.forEach((feed, i) => {
+                const isLast = i === realFeeds.length - 1;
+                const connector = isLast ? '\u2514\u2500' : '\u251C\u2500';
+                const typeLabel = feed.source_type === 'rss_feed' ? 'RSS' : 'Web';
+                const urlDisplay = feed.url ? this._shortenUrl(feed.url) : '';
+                feedRows += `<div class="source-feed-row">
+                    <span class="source-feed-connector">${connector}</span>
+                    <span class="source-feed-name">${this.escape(feed.name)}</span>
+                    <span class="source-type-badge type-${feed.source_type}">${typeLabel}</span>
+                    <span class="source-feed-url" title="${this.escape(feed.url || '')}">${this.escape(urlDisplay)}</span>
+                    <button class="source-delete-btn" onclick="App.deleteSingleFeed(${feed.id})" title="Löschen" aria-label="Löschen">&times;</button>
+                </div>`;
+            });
+            feedRows += '</div>';
+        }
+
+        const feedCountBadge = feedCount > 0
+            ? `<span class="source-feed-count">${feedCount} Feed${feedCount !== 1 ? 's' : ''}</span>`
+            : '';
+
+        return `<div class="source-group">
+            <div class="source-group-header" ${toggleAttr}>
+                ${toggleIcon}
+                <div class="source-group-info">
+                    <span class="source-group-name">${this.escape(displayName)}</span>
+                </div>
+                <span class="source-category-badge cat-${feeds[0]?.category || 'sonstige'}">${catLabel}</span>
+                ${feedCountBadge}
+                <div class="source-group-actions" onclick="event.stopPropagation()">
+                    <button class="btn btn-small btn-secondary" onclick="App.blockDomainDirect('${escapedDomain}')">Sperren</button>
+                    <button class="source-delete-btn" onclick="App.deleteDomain('${escapedDomain}')" title="Löschen" aria-label="Löschen">&times;</button>
+                </div>
+            </div>
+            ${feedRows}
+        </div>`;
+    },
+
+    /**
+     * URL kürzen für die Anzeige in Feed-Zeilen.
+     */
+    _shortenUrl(url) {
+        try {
+            const u = new URL(url);
+            let path = u.pathname;
+            if (path.length > 40) path = path.substring(0, 37) + '...';
+            return u.hostname + path;
+        } catch {
+            return url.length > 50 ? url.substring(0, 47) + '...' : url;
+        }
+    },
+
+    /**
+     * URLs in Evidence-Text als kompakte Hostname-Chips rendern (Legacy-Fallback).
+     */
+    renderEvidenceChips(text) {
+        return this.renderEvidence(text);
+    },
+
+    /**
+     * URLs in Evidence-Text als klickbare Links rendern (Legacy).
+     */
+    linkifyEvidence(text) {
+        if (!text) return '';
+        const escaped = this.escape(text);
+        return escaped.replace(
+            /(https?:\/\/[^\s,)]+)/g,
+            '<a href="$1" target="_blank" rel="noopener">$1</a>'
+        );
+    },
+
+    /**
+     * HTML escapen.
+     */
+    escape(str) {
+        if (!str) return '';
+        const div = document.createElement('div');
+        div.textContent = str;
+        return div.innerHTML;
+    },
+};
diff --git a/src/static/js/layout.js b/src/static/js/layout.js
new file mode 100644
index 0000000..9dd8c88
--- /dev/null
+++ b/src/static/js/layout.js
@@ -0,0 +1,282 @@
+/**
+ * LayoutManager: Drag & Resize Dashboard-Layout mit gridstack.js
+ * Persistenz über localStorage, Reset auf Standard-Layout möglich.
+ */
+const LayoutManager = {
+    _grid: null,
+    _storageKey: 'osint_layout',
+    _initialized: false,
+    _saveTimeout: null,
+    _hiddenTiles: {},
+
+    DEFAULT_LAYOUT: [
+        { id: 'lagebild',    x: 0, y: 0, w: 6,  h: 4, minW: 4, minH: 4 },
+        { id: 'faktencheck', x: 6, y: 0, w: 6,  h: 4, minW: 4, minH: 4 },
+        { id: 'quellen',     x: 0, y: 4, w: 12, h: 2, minW: 6, minH: 2 },
+        { id: 'timeline',    x: 0, y: 5, w: 12, h: 4, minW: 6, minH: 4 },
+    ],
+
+    TILE_MAP: {
+        lagebild:    '.incident-analysis-summary',
+        faktencheck: '.incident-analysis-factcheck',
+        quellen:     '.source-overview-card',
+        timeline:    '.timeline-card',
+    },
+
+    init() {
+        if (this._initialized) return;
+
+        const container = document.querySelector('.grid-stack');
+        if (!container) return;
+
+        this._grid = GridStack.init({
+            column: 12,
+            cellHeight: 80,
+            margin: 12,
+            animate: true,
+            handle: '.card-header',
+            float: false,
+            disableOneColumnMode: true,
+        }, container);
+
+        const saved = this._load();
+        if (saved) {
+            this._applyLayout(saved);
+        }
+
+        this._grid.on('change', () => this._debouncedSave());
+
+        const toolbar = document.getElementById('layout-toolbar');
+        if (toolbar) toolbar.style.display = 'flex';
+
+        this._syncToggles();
+        this._initialized = true;
+    },
+
+    _applyLayout(layout) {
+        if (!this._grid) return;
+
+        this._hiddenTiles = {};
+
+        layout.forEach(item => {
+            const el = this._grid.engine.nodes.find(n => n.el && n.el.getAttribute('gs-id') === item.id);
+            if (!el) return;
+
+            if (item.visible === false) {
+                this._hiddenTiles[item.id] = item;
+                this._grid.removeWidget(el.el, true, false);
+            } else {
+                this._grid.update(el.el, { x: item.x, y: item.y, w: item.w, h: item.h });
+            }
+        });
+
+        this._syncToggles();
+    },
+
+    save() {
+        if (!this._grid) return;
+
+        const items = [];
+        this._grid.engine.nodes.forEach(node => {
+            const id = node.el ? node.el.getAttribute('gs-id') : null;
+            if (!id) return;
+            items.push({
+                id, x: node.x, y: node.y, w: node.w, h: node.h, visible: true,
+            });
+        });
+
+        Object.keys(this._hiddenTiles).forEach(id => {
+            items.push({ ...this._hiddenTiles[id], visible: false });
+        });
+
+        try {
+            localStorage.setItem(this._storageKey, JSON.stringify(items));
+        } catch (e) { /* quota */ }
+    },
+
+    _debouncedSave() {
+        clearTimeout(this._saveTimeout);
+        this._saveTimeout = setTimeout(() => this.save(), 300);
+    },
+
+    _load() {
+        try {
+            const raw = localStorage.getItem(this._storageKey);
+            if (!raw) return null;
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed) || parsed.length === 0) return null;
+            return parsed;
+        } catch (e) {
+            return null;
+        }
+    },
+
+    toggleTile(tileId) {
+        if (!this._grid) return;
+
+        const selector = this.TILE_MAP[tileId];
+        if (!selector) return;
+
+        if (this._hiddenTiles[tileId]) {
+            // Kachel einblenden
+            const cfg = this._hiddenTiles[tileId];
+            delete this._hiddenTiles[tileId];
+
+            const cardEl = document.querySelector(selector);
+            if (!cardEl) return;
+
+            // Wrapper erstellen
+            const wrapper = document.createElement('div');
+            wrapper.className = 'grid-stack-item';
+            wrapper.setAttribute('gs-id', tileId);
+            wrapper.setAttribute('gs-x', cfg.x);
+            wrapper.setAttribute('gs-y', cfg.y);
+            wrapper.setAttribute('gs-w', cfg.w);
+            wrapper.setAttribute('gs-h', cfg.h);
+            wrapper.setAttribute('gs-min-w', cfg.minW || '');
+            wrapper.setAttribute('gs-min-h', cfg.minH || '');
+            const content = document.createElement('div');
+            content.className = 'grid-stack-item-content';
+            content.appendChild(cardEl);
+            wrapper.appendChild(content);
+
+            this._grid.addWidget(wrapper);
+        } else {
+            // Kachel ausblenden
+            const node = this._grid.engine.nodes.find(
+                n => n.el && n.el.getAttribute('gs-id') === tileId
+            );
+            if (!node) return;
+
+            const defaults = this.DEFAULT_LAYOUT.find(d => d.id === tileId);
+            this._hiddenTiles[tileId] = {
+                id: tileId,
+                x: node.x, y: node.y, w: node.w, h: node.h,
+                minW: defaults ? defaults.minW : 4,
+                minH: defaults ? defaults.minH : 2,
+                visible: false,
+            };
+
+            // Card aus dem Widget retten bevor es entfernt wird
+            const cardEl = node.el.querySelector(selector);
+            if (cardEl) {
+                // Temporär im incident-view parken (unsichtbar)
+                const parking = document.getElementById('tile-parking');
+                if (parking) parking.appendChild(cardEl);
+            }
+
+            this._grid.removeWidget(node.el, true, false);
+        }
+
+        this._syncToggles();
+        this.save();
+    },
+
+    _syncToggles() {
+        document.querySelectorAll('.layout-toggle-btn').forEach(btn => {
+            const tileId = btn.getAttribute('data-tile');
+            const isHidden = !!this._hiddenTiles[tileId];
+            btn.classList.toggle('active', !isHidden);
+            btn.setAttribute('aria-pressed', String(!isHidden));
+        });
+    },
+
+    reset() {
+        localStorage.removeItem(this._storageKey);
+
+        // Cards einsammeln BEVOR der Grid zerstört wird (aus Grid + Parking)
+        const cards = {};
+        Object.entries(this.TILE_MAP).forEach(([id, selector]) => {
+            const card = document.querySelector(selector);
+            if (card) cards[id] = card;
+        });
+
+        this._hiddenTiles = {};
+
+        if (this._grid) {
+            this._grid.destroy(false);
+            this._grid = null;
+        }
+        this._initialized = false;
+
+        const gridEl = document.querySelector('.grid-stack');
+        if (!gridEl) return;
+
+        // Grid leeren (Cards sind bereits in cards-Map gesichert)
+        gridEl.innerHTML = '';
+
+        // Cards in Default-Layout neu aufbauen
+        this.DEFAULT_LAYOUT.forEach(cfg => {
+            const cardEl = cards[cfg.id];
+            if (!cardEl) return;
+
+            const wrapper = document.createElement('div');
+            wrapper.className = 'grid-stack-item';
+            wrapper.setAttribute('gs-id', cfg.id);
+            wrapper.setAttribute('gs-x', cfg.x);
+            wrapper.setAttribute('gs-y', cfg.y);
+            wrapper.setAttribute('gs-w', cfg.w);
+            wrapper.setAttribute('gs-h', cfg.h);
+            wrapper.setAttribute('gs-min-w', cfg.minW);
+            wrapper.setAttribute('gs-min-h', cfg.minH);
+
+            const content = document.createElement('div');
+            content.className = 'grid-stack-item-content';
+            content.appendChild(cardEl);
+            wrapper.appendChild(content);
+            gridEl.appendChild(wrapper);
+        });
+
+        this.init();
+    },
+
+    resizeTileToContent(tileId) {
+        if (!this._grid) return;
+
+        const node = this._grid.engine.nodes.find(
+            n => n.el && n.el.getAttribute('gs-id') === tileId
+        );
+        if (!node || !node.el) return;
+
+        const wrapper = node.el.querySelector('.grid-stack-item-content');
+        if (!wrapper) return;
+
+        const card = wrapper.firstElementChild;
+        if (!card) return;
+
+        const cellH = this._grid.opts.cellHeight || 80;
+        const margin = this._grid.opts.margin || 12;
+
+        // Temporär alle height-Constraints aufheben
+        node.el.classList.add('gs-measuring');
+        const naturalHeight = card.scrollHeight;
+        node.el.classList.remove('gs-measuring');
+
+        // In Grid-Units umrechnen (aufrunden + 1 Puffer)
+        const neededH = Math.ceil(naturalHeight / (cellH + margin)) + 1;
+        const minH = node.minH || 2;
+        const finalH = Math.max(neededH, minH);
+
+        this._grid.update(node.el, { h: finalH });
+        this._debouncedSave();
+    },
+
+    resetAllTilesToDefault() {
+        if (!this._grid) return;
+        this.DEFAULT_LAYOUT.forEach(cfg => {
+            const node = this._grid.engine.nodes.find(
+                n => n.el && n.el.getAttribute('gs-id') === cfg.id
+            );
+            if (node) this._grid.update(node.el, { h: cfg.h });
+        });
+    },
+
+    destroy() {
+        if (this._grid) {
+            this._grid.destroy(false);
+            this._grid = null;
+        }
+        this._initialized = false;
+        this._hiddenTiles = {};
+    },
+};
diff --git a/src/static/js/ws.js b/src/static/js/ws.js
new file mode 100644
index 0000000..667c336
--- /dev/null
+++ b/src/static/js/ws.js
@@ -0,0 +1,105 @@
+/**
+ * WebSocket-Client für Echtzeit-Updates.
+ */
+const WS = {
+    socket: null,
+    reconnectDelay: 2000,
+    maxReconnectDelay: 30000,
+    _handlers: {},
+    _pingInterval: null,
+
+    connect() {
+        const token = localStorage.getItem('osint_token');
+        if (!token) return;
+
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const url = `${protocol}//${window.location.host}/api/ws`;
+
+        try {
+            this.socket = new WebSocket(url);
+        } catch (e) {
+            console.error('WebSocket-Verbindungsfehler:', e);
+            this._scheduleReconnect();
+            return;
+        }
+
+        this.socket.onopen = () => {
+            // Token als erste Nachricht senden (nicht in URL)
+            this.socket.send(token);
+        };
+
+        this.socket.onmessage = (event) => {
+            if (event.data === 'pong') return;
+            if (event.data === 'authenticated') {
+                console.log('WebSocket verbunden');
+                this.reconnectDelay = 2000;
+                this._startPing();
+                return;
+            }
+            try {
+                const msg = JSON.parse(event.data);
+                this._dispatch(msg);
+            } catch (e) {
+                console.error('WebSocket Parse-Fehler:', e);
+            }
+        };
+
+        this.socket.onclose = () => {
+            console.log('WebSocket getrennt');
+            this._stopPing();
+            this._scheduleReconnect();
+        };
+
+        this.socket.onerror = () => {};
+    },
+
+    disconnect() {
+        this._stopPing();
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+    },
+
+    on(type, handler) {
+        if (!this._handlers[type]) {
+            this._handlers[type] = [];
+        }
+        this._handlers[type].push(handler);
+    },
+
+    _dispatch(msg) {
+        const handlers = this._handlers[msg.type] || [];
+        handlers.forEach(h => h(msg));
+
+        // Globale Handler
+        const allHandlers = this._handlers['*'] || [];
+        allHandlers.forEach(h => h(msg));
+    },
+
+    _startPing() {
+        this._pingInterval = setInterval(() => {
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send('ping');
+            }
+        }, 30000);
+    },
+
+    _stopPing() {
+        if (this._pingInterval) {
+            clearInterval(this._pingInterval);
+            this._pingInterval = null;
+        }
+    },
+
+    _scheduleReconnect() {
+        setTimeout(() => {
+            if (!this.socket || this.socket.readyState === WebSocket.CLOSED) {
+                this.connect();
+            }
+        }, this.reconnectDelay);
+
+        this.reconnectDelay = Math.min(this.reconnectDelay * 1.5, this.maxReconnectDelay);
+    },
+
+};
diff --git a/src/static/layout.js b/src/static/layout.js
new file mode 100644
index 0000000..09ce34c
--- /dev/null
+++ b/src/static/layout.js
@@ -0,0 +1,272 @@
+/**
+ * LayoutManager: Drag & Resize Dashboard-Layout mit gridstack.js
+ * Persistenz über localStorage, Reset auf Standard-Layout möglich.
+ */
+const LayoutManager = {
+    _grid: null,
+    _storageKey: 'osint_layout',
+    _initialized: false,
+    _saveTimeout: null,
+    _hiddenTiles: {},
+
+    DEFAULT_LAYOUT: [
+        { id: 'lagebild',    x: 0, y: 0, w: 6,  h: 4, minW: 4, minH: 4 },
+        { id: 'faktencheck', x: 6, y: 0, w: 6,  h: 4, minW: 4, minH: 4 },
+        { id: 'quellen',     x: 0, y: 4, w: 12, h: 2, minW: 6, minH: 2 },
+        { id: 'timeline',    x: 0, y: 5, w: 12, h: 4, minW: 6, minH: 4 },
+    ],
+
+    TILE_MAP: {
+        lagebild:    '.incident-analysis-summary',
+        faktencheck: '.incident-analysis-factcheck',
+        quellen:     '.source-overview-card',
+        timeline:    '.timeline-card',
+    },
+
+    init() {
+        if (this._initialized) return;
+
+        const container = document.querySelector('.grid-stack');
+        if (!container) return;
+
+        this._grid = GridStack.init({
+            column: 12,
+            cellHeight: 80,
+            margin: 12,
+            animate: true,
+            handle: '.card-header',
+            float: false,
+            disableOneColumnMode: true,
+        }, container);
+
+        const saved = this._load();
+        if (saved) {
+            this._applyLayout(saved);
+        }
+
+        this._grid.on('change', () => this._debouncedSave());
+
+        const toolbar = document.getElementById('layout-toolbar');
+        if (toolbar) toolbar.style.display = 'flex';
+
+        this._syncToggles();
+        this._initialized = true;
+    },
+
+    _applyLayout(layout) {
+        if (!this._grid) return;
+
+        this._hiddenTiles = {};
+
+        layout.forEach(item => {
+            const el = this._grid.engine.nodes.find(n => n.el && n.el.getAttribute('gs-id') === item.id);
+            if (!el) return;
+
+            if (item.visible === false) {
+                this._hiddenTiles[item.id] = item;
+                this._grid.removeWidget(el.el, true, false);
+            } else {
+                this._grid.update(el.el, { x: item.x, y: item.y, w: item.w, h: item.h });
+            }
+        });
+
+        this._syncToggles();
+    },
+
+    save() {
+        if (!this._grid) return;
+
+        const items = [];
+        this._grid.engine.nodes.forEach(node => {
+            const id = node.el ? node.el.getAttribute('gs-id') : null;
+            if (!id) return;
+            items.push({
+                id, x: node.x, y: node.y, w: node.w, h: node.h, visible: true,
+            });
+        });
+
+        Object.keys(this._hiddenTiles).forEach(id => {
+            items.push({ ...this._hiddenTiles[id], visible: false });
+        });
+
+        try {
+            localStorage.setItem(this._storageKey, JSON.stringify(items));
+        } catch (e) { /* quota */ }
+    },
+
+    _debouncedSave() {
+        clearTimeout(this._saveTimeout);
+        this._saveTimeout = setTimeout(() => this.save(), 300);
+    },
+
+    _load() {
+        try {
+            const raw = localStorage.getItem(this._storageKey);
+            if (!raw) return null;
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed) || parsed.length === 0) return null;
+            return parsed;
+        } catch (e) {
+            return null;
+        }
+    },
+
+    toggleTile(tileId) {
+        if (!this._grid) return;
+
+        const selector = this.TILE_MAP[tileId];
+        if (!selector) return;
+
+        if (this._hiddenTiles[tileId]) {
+            // Kachel einblenden
+            const cfg = this._hiddenTiles[tileId];
+            delete this._hiddenTiles[tileId];
+
+            const cardEl = document.querySelector(selector);
+            if (!cardEl) return;
+
+            // Wrapper erstellen
+            const wrapper = document.createElement('div');
+            wrapper.className = 'grid-stack-item';
+            wrapper.setAttribute('gs-id', tileId);
+            wrapper.setAttribute('gs-x', cfg.x);
+            wrapper.setAttribute('gs-y', cfg.y);
+            wrapper.setAttribute('gs-w', cfg.w);
+            wrapper.setAttribute('gs-h', cfg.h);
+            wrapper.setAttribute('gs-min-w', cfg.minW || '');
+            wrapper.setAttribute('gs-min-h', cfg.minH || '');
+            const content = document.createElement('div');
+            content.className = 'grid-stack-item-content';
+            content.appendChild(cardEl);
+            wrapper.appendChild(content);
+
+            this._grid.addWidget(wrapper);
+        } else {
+            // Kachel ausblenden
+            const node = this._grid.engine.nodes.find(
+                n => n.el && n.el.getAttribute('gs-id') === tileId
+            );
+            if (!node) return;
+
+            const defaults = this.DEFAULT_LAYOUT.find(d => d.id === tileId);
+            this._hiddenTiles[tileId] = {
+                id: tileId,
+                x: node.x, y: node.y, w: node.w, h: node.h,
+                minW: defaults ? defaults.minW : 4,
+                minH: defaults ? defaults.minH : 2,
+                visible: false,
+            };
+
+            // Card aus dem Widget retten bevor es entfernt wird
+            const cardEl = node.el.querySelector(selector);
+            if (cardEl) {
+                // Temporär im incident-view parken (unsichtbar)
+                const parking = document.getElementById('tile-parking');
+                if (parking) parking.appendChild(cardEl);
+            }
+
+            this._grid.removeWidget(node.el, true, false);
+        }
+
+        this._syncToggles();
+        this.save();
+    },
+
+    _syncToggles() {
+        document.querySelectorAll('.layout-toggle-btn').forEach(btn => {
+            const tileId = btn.getAttribute('data-tile');
+            const isHidden = !!this._hiddenTiles[tileId];
+            btn.classList.toggle('active', !isHidden);
+            btn.setAttribute('aria-pressed', String(!isHidden));
+        });
+    },
+
+    reset() {
+        localStorage.removeItem(this._storageKey);
+
+        // Cards einsammeln BEVOR der Grid zerstört wird (aus Grid + Parking)
+        const cards = {};
+        Object.entries(this.TILE_MAP).forEach(([id, selector]) => {
+            const card = document.querySelector(selector);
+            if (card) cards[id] = card;
+        });
+
+        this._hiddenTiles = {};
+
+        if (this._grid) {
+            this._grid.destroy(false);
+            this._grid = null;
+        }
+        this._initialized = false;
+
+        const gridEl = document.querySelector('.grid-stack');
+        if (!gridEl) return;
+
+        // Grid leeren (Cards sind bereits in cards-Map gesichert)
+        gridEl.innerHTML = '';
+
+        // Cards in Default-Layout neu aufbauen
+        this.DEFAULT_LAYOUT.forEach(cfg => {
+            const cardEl = cards[cfg.id];
+            if (!cardEl) return;
+
+            const wrapper = document.createElement('div');
+            wrapper.className = 'grid-stack-item';
+            wrapper.setAttribute('gs-id', cfg.id);
+            wrapper.setAttribute('gs-x', cfg.x);
+            wrapper.setAttribute('gs-y', cfg.y);
+            wrapper.setAttribute('gs-w', cfg.w);
+            wrapper.setAttribute('gs-h', cfg.h);
+            wrapper.setAttribute('gs-min-w', cfg.minW);
+            wrapper.setAttribute('gs-min-h', cfg.minH);
+
+            const content = document.createElement('div');
+            content.className = 'grid-stack-item-content';
+            content.appendChild(cardEl);
+            wrapper.appendChild(content);
+            gridEl.appendChild(wrapper);
+        });
+
+        this.init();
+    },
+
+    resizeTileToContent(tileId) {
+        if (!this._grid) return;
+
+        const node = this._grid.engine.nodes.find(
+            n => n.el && n.el.getAttribute('gs-id') === tileId
+        );
+        if (!node || !node.el) return;
+
+        const wrapper = node.el.querySelector('.grid-stack-item-content');
+        if (!wrapper) return;
+
+        const card = wrapper.firstElementChild;
+        if (!card) return;
+
+        const cellH = this._grid.opts.cellHeight || 80;
+        const margin = this._grid.opts.margin || 12;
+
+        // Temporär alle height-Constraints aufheben
+        node.el.classList.add('gs-measuring');
+        const naturalHeight = card.scrollHeight;
+        node.el.classList.remove('gs-measuring');
+
+        // In Grid-Units umrechnen (aufrunden + 1 Puffer)
+        const neededH = Math.ceil(naturalHeight / (cellH + margin)) + 1;
+        const minH = node.minH || 2;
+        const finalH = Math.max(neededH, minH);
+
+        this._grid.update(node.el, { h: finalH });
+        this._debouncedSave();
+    },
+
+    destroy() {
+        if (this._grid) {
+            this._grid.destroy(false);
+            this._grid = null;
+        }
+        this._initialized = false;
+        this._hiddenTiles = {};
+    },
+};
diff --git a/src/static/style.css b/src/static/style.css
new file mode 100644
index 0000000..fdc16ba
--- /dev/null
+++ b/src/static/style.css
@@ -0,0 +1,3653 @@
+/* AegisSight Design System - OSINT Lagemonitor (Dark Theme: Navy/Gold) */
+
+/* === CSS Variables === */
+:root {
+    /* Backgrounds */
+    --bg-primary: #0B1121;
+    --bg-secondary: #1A2440;
+    --bg-card: #151D2E;
+    --bg-sidebar: #0A1832;
+    --bg-topbar: #151D2E;
+    --bg-hover: #1A2440;
+    --bg-elevated: #1E2D45;
+
+    /* Accent (Gold) */
+    --accent: #C8A851;
+    --accent-hover: #B5923E;
+    --accent-pressed: #A07E2B;
+
+    /* Text */
+    --text-primary: #E8ECF4;
+    --text-secondary: #8896AB;
+    --text-disabled: #95A3B8;
+    --text-tertiary: #95A3B8;
+
+    /* Circuit-Pattern */
+    --circuit-pattern: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='300' height='300'><g stroke='%23C8A851' stroke-width='0.8' fill='none' opacity='0.2'><path d='M0 50 H80 V20 H150'/><path d='M150 20 V70 H220 V50 H300'/><path d='M0 150 H50 V110 H120'/><path d='M120 110 H180 V170 H250'/><path d='M250 170 V150 H300'/><path d='M0 250 H60 V220 H130'/><path d='M130 220 V270 H200'/><path d='M200 270 H260 V250 H300'/><path d='M70 0 V50'/><path d='M70 260 V300'/><path d='M200 0 V20 H240'/><path d='M200 280 V300'/><path d='M140 130 H200 V90'/><path d='M30 180 H80 V210 H110'/><path d='M240 100 H300'/><path d='M0 100 H30'/><path d='M260 200 V240'/></g><g fill='%23C8A851' opacity='0.2'><circle cx='80' cy='50' r='2'/><circle cx='150' cy='20' r='2'/><circle cx='150' cy='70' r='2'/><circle cx='220' cy='50' r='2'/><circle cx='50' cy='150' r='2'/><circle cx='120' cy='110' r='2'/><circle cx='180' cy='170' r='2'/><circle cx='250' cy='170' r='2'/><circle cx='60' cy='250' r='2'/><circle cx='130' cy='220' r='2'/><circle cx='200' cy='270' r='2'/><circle cx='260' cy='250' r='2'/><circle cx='140' cy='130' r='2'/><circle cx='200' cy='90' r='2'/><circle cx='80' cy='210' r='2'/></g></svg>");
+
+    /* Inputs / Borders */
+    --input-bg: #1A2440;
+    --input-border: #1E2D45;
+    --border: #1E2D45;
+
+    /* Status */
+    --success: #10B981;
+    --warning: #F59E0B;
+    --error: #EF4444;
+    --info: #7C8DB5;
+
+    /* Sidebar */
+    --sidebar-text: #E8ECF4;
+    --sidebar-text-sec: #8896AB;
+    --sidebar-active: #C8A851;
+    --sidebar-hover-bg: #1A2440;
+
+    /* Typography */
+    --font-title: 'Poppins', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    --font-body: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif;
+    --font-mono: 'SF Mono', Consolas, Menlo, monospace;
+
+    /* Spacing (8pt scale) */
+    --sp-xxs: 2px;
+    --sp-xs: 4px;
+    --sp-sm: 6px;
+    --sp-md: 8px;
+    --sp-lg: 12px;
+    --sp-xl: 16px;
+    --sp-2xl: 20px;
+    --sp-3xl: 24px;
+    --sp-4xl: 32px;
+    --sp-5xl: 48px;
+
+    /* Radii */
+    --radius: 4px;
+    --radius-lg: 8px;
+
+    /* Tints (halbtransparente Hintergründe) */
+    --tint-accent: rgba(200, 168, 81, 0.15);
+    --tint-accent-subtle: rgba(200, 168, 81, 0.08);
+    --tint-accent-faint: rgba(200, 168, 81, 0.04);
+    --tint-accent-strong: rgba(200, 168, 81, 0.18);
+    --tint-error: rgba(239, 68, 68, 0.12);
+    --tint-error-strong: rgba(239, 68, 68, 0.3);
+    --tint-error-border: rgba(239, 68, 68, 0.4);
+    --tint-success: rgba(16, 185, 129, 0.15);
+    --tint-warning: rgba(245, 158, 11, 0.15);
+    --tint-info: rgba(124, 141, 181, 0.15);
+    --tint-indigo: rgba(99, 102, 241, 0.15);
+    --tint-hover: rgba(26, 36, 64, 0.5);
+    --tint-hover-subtle: rgba(255, 255, 255, 0.03);
+
+    /* Shadows */
+    --shadow-sm: 0 4px 12px rgba(0, 0, 0, 0.3);
+    --shadow-md: 0 8px 24px rgba(0, 0, 0, 0.4);
+    --shadow-lg: 0 12px 40px rgba(0, 0, 0, 0.5);
+
+    /* Glows */
+    --glow-accent: 0 0 8px rgba(200, 168, 81, 0.4);
+    --glow-accent-strong: 0 0 16px rgba(200, 168, 81, 0.6);
+
+    /* Overlay */
+    --backdrop: rgba(11, 17, 33, 0.85);
+
+    /* Category Badge Colors */
+    --cat-nachrichtenagentur: #F87171;
+    --cat-oeffentlich-rechtlich: #60A5FA;
+    --cat-qualitaetszeitung: #C084FC;
+    --cat-behoerde: #FBBF24;
+    --cat-fachmedien: #2DD4BF;
+    --cat-think-tank: #818CF8;
+    --cat-international: #34D399;
+    --cat-regional: #FB923C;
+
+    /* Category Badge Backgrounds */
+    --cat-nachrichtenagentur-bg: rgba(239, 68, 68, 0.12);
+    --cat-oeffentlich-rechtlich-bg: rgba(59, 130, 246, 0.12);
+    --cat-qualitaetszeitung-bg: rgba(168, 85, 247, 0.12);
+    --cat-behoerde-bg: rgba(245, 158, 11, 0.12);
+    --cat-fachmedien-bg: rgba(20, 184, 166, 0.12);
+    --cat-think-tank-bg: rgba(99, 102, 241, 0.12);
+    --cat-international-bg: rgba(16, 185, 129, 0.12);
+    --cat-regional-bg: rgba(251, 146, 60, 0.12);
+    --cat-sonstige-bg: rgba(124, 141, 181, 0.12);
+}
+
+/* === Light Theme === */
+[data-theme="light"] {
+    --bg-primary: #F4F5F7;
+    --bg-secondary: #E8EBF0;
+    --bg-card: #FFFFFF;
+    --bg-sidebar: #FFFFFF;
+    --bg-topbar: #FFFFFF;
+    --bg-hover: #E8EBF0;
+    --bg-elevated: #F0F1F3;
+
+    --accent: #96791A;
+    --accent-hover: #7D6516;
+    --accent-pressed: #645112;
+
+    --text-primary: #1A202C;
+    --text-secondary: #4A5568;
+    --text-disabled: #A0AEC0;
+    --text-tertiary: #A0AEC0;
+
+    --circuit-pattern: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='300' height='300'><g stroke='%234A5568' stroke-width='0.8' fill='none' opacity='0.2'><path d='M0 50 H80 V20 H150'/><path d='M150 20 V70 H220 V50 H300'/><path d='M0 150 H50 V110 H120'/><path d='M120 110 H180 V170 H250'/><path d='M250 170 V150 H300'/><path d='M0 250 H60 V220 H130'/><path d='M130 220 V270 H200'/><path d='M200 270 H260 V250 H300'/><path d='M70 0 V50'/><path d='M70 260 V300'/><path d='M200 0 V20 H240'/><path d='M200 280 V300'/><path d='M140 130 H200 V90'/><path d='M30 180 H80 V210 H110'/><path d='M240 100 H300'/><path d='M0 100 H30'/><path d='M260 200 V240'/></g><g fill='%234A5568' opacity='0.2'><circle cx='80' cy='50' r='2'/><circle cx='150' cy='20' r='2'/><circle cx='150' cy='70' r='2'/><circle cx='220' cy='50' r='2'/><circle cx='50' cy='150' r='2'/><circle cx='120' cy='110' r='2'/><circle cx='180' cy='170' r='2'/><circle cx='250' cy='170' r='2'/><circle cx='60' cy='250' r='2'/><circle cx='130' cy='220' r='2'/><circle cx='200' cy='270' r='2'/><circle cx='260' cy='250' r='2'/><circle cx='140' cy='130' r='2'/><circle cx='200' cy='90' r='2'/><circle cx='80' cy='210' r='2'/></g></svg>");
+
+    --input-bg: #FFFFFF;
+    --input-border: #CBD5E0;
+    --border: #E2E8F0;
+
+    --success: #059669;
+    --warning: #D97706;
+    --error: #DC2626;
+    --info: #4A5568;
+
+    --sidebar-text: #1A202C;
+    --sidebar-text-sec: #4A5568;
+    --sidebar-active: #96791A;
+    --sidebar-hover-bg: #F0EDE6;
+
+    --tint-accent: rgba(150, 121, 26, 0.10);
+    --tint-accent-subtle: rgba(150, 121, 26, 0.05);
+    --tint-accent-faint: rgba(150, 121, 26, 0.03);
+    --tint-accent-strong: rgba(150, 121, 26, 0.14);
+    --tint-error: rgba(220, 38, 38, 0.08);
+    --tint-error-strong: rgba(220, 38, 38, 0.2);
+    --tint-error-border: rgba(220, 38, 38, 0.3);
+    --tint-success: rgba(5, 150, 105, 0.10);
+    --tint-warning: rgba(217, 119, 6, 0.10);
+    --tint-info: rgba(74, 85, 104, 0.10);
+    --tint-indigo: rgba(99, 102, 241, 0.10);
+    --tint-hover: rgba(0, 0, 0, 0.04);
+    --tint-hover-subtle: rgba(0, 0, 0, 0.02);
+
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.08);
+    --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.10);
+    --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.12);
+
+    --glow-accent: 0 0 6px rgba(150, 121, 26, 0.2);
+    --glow-accent-strong: 0 0 12px rgba(150, 121, 26, 0.3);
+
+    --backdrop: rgba(0, 0, 0, 0.4);
+
+    --cat-nachrichtenagentur: #DC2626;
+    --cat-oeffentlich-rechtlich: #2563EB;
+    --cat-qualitaetszeitung: #7C3AED;
+    --cat-behoerde: #D97706;
+    --cat-fachmedien: #0D9488;
+    --cat-think-tank: #4F46E5;
+    --cat-international: #059669;
+    --cat-regional: #EA580C;
+
+    --cat-nachrichtenagentur-bg: rgba(220, 38, 38, 0.08);
+    --cat-oeffentlich-rechtlich-bg: rgba(37, 99, 235, 0.08);
+    --cat-qualitaetszeitung-bg: rgba(124, 58, 237, 0.08);
+    --cat-behoerde-bg: rgba(217, 119, 6, 0.08);
+    --cat-fachmedien-bg: rgba(13, 148, 136, 0.08);
+    --cat-think-tank-bg: rgba(79, 70, 229, 0.08);
+    --cat-international-bg: rgba(5, 150, 105, 0.08);
+    --cat-regional-bg: rgba(234, 88, 12, 0.08);
+    --cat-sonstige-bg: rgba(74, 85, 104, 0.08);
+}
+
+/* === Reset === */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* === Base === */
+html, body {
+    height: 100%;
+    font-family: var(--font-body);
+    font-size: 14px;
+    line-height: 1.6;
+    color: var(--text-primary);
+    background: var(--bg-primary);
+    -webkit-font-smoothing: antialiased;
+}
+
+a {
+    color: var(--accent);
+    text-decoration: none;
+    transition: color 0.2s ease;
+}
+
+a:hover {
+    color: var(--accent-hover);
+}
+
+/* === Scrollbar === */
+::-webkit-scrollbar {
+    width: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-primary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--text-disabled);
+    border-radius: var(--radius);
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--text-secondary);
+}
+
+/* === Login Page === */
+.login-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    padding: var(--sp-3xl);
+    background: var(--circuit-pattern) repeat, var(--bg-primary);
+    background-size: 300px 300px, auto;
+}
+
+.login-box {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-5xl) var(--sp-4xl);
+    width: 100%;
+    max-width: 420px;
+}
+
+.login-logo {
+    text-align: center;
+    margin-bottom: var(--sp-4xl);
+}
+
+.login-logo h1 {
+    font-family: var(--font-title);
+    font-size: 28px;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.login-logo h1 span {
+    color: var(--accent);
+}
+
+.login-logo .subtitle {
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-top: var(--sp-xs);
+    letter-spacing: 0.5px;
+    text-transform: uppercase;
+    font-weight: 500;
+}
+
+.form-group {
+    margin-bottom: var(--sp-xl);
+}
+
+.form-group label {
+    display: block;
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-sm);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.form-group input,
+.form-group select,
+.form-group textarea {
+    width: 100%;
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    font-size: 14px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    transition: border-color 0.2s ease;
+}
+
+.form-group input:focus,
+.form-group select:focus,
+.form-group textarea:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+    border-color: var(--accent);
+}
+
+.form-group input::placeholder,
+.form-group textarea::placeholder {
+    color: var(--text-disabled);
+}
+
+.form-group select {
+    cursor: pointer;
+    appearance: none;
+    background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238896AB' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3e%3cpolyline points='6 9 12 15 18 9'%3e%3c/polyline%3e%3c/svg%3e");
+    background-repeat: no-repeat;
+    background-position: right 12px center;
+    background-size: 16px;
+}
+
+.form-group textarea {
+    resize: vertical;
+    min-height: 80px;
+}
+
+.login-error {
+    display: none;
+    background: var(--tint-error);
+    border: 1px solid var(--tint-error-strong);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    margin-bottom: var(--sp-xl);
+    font-size: 13px;
+    color: var(--error);
+}
+
+/* === Buttons === */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--sp-md);
+    border: none;
+    border-radius: var(--radius);
+    cursor: pointer;
+    font-family: var(--font-body);
+    font-weight: 600;
+    font-size: 14px;
+    transition: all 0.2s ease;
+    min-height: 40px;
+    padding: 0 var(--sp-xl);
+}
+
+.btn:active {
+    transform: scale(0.98);
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+}
+
+.btn-primary {
+    background: var(--accent);
+    color: #FFFFFF;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: var(--accent-hover);
+}
+
+.btn-primary:active:not(:disabled) {
+    background: var(--accent-pressed);
+}
+
+.btn-secondary {
+    background: transparent;
+    color: var(--text-primary);
+    border: 1px solid var(--border);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--bg-secondary);
+    border-color: var(--accent);
+}
+
+.btn-danger {
+    background: transparent;
+    color: var(--error);
+    border: 1px solid var(--tint-error-border);
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: var(--tint-error);
+    border-color: var(--error);
+}
+
+.btn-small {
+    min-height: 32px;
+    padding: 0 var(--sp-lg);
+    font-size: 12px;
+}
+
+.btn-full {
+    width: 100%;
+}
+
+/* === Dashboard Layout === */
+.dashboard {
+    display: grid;
+    grid-template-columns: 240px 1fr;
+    grid-template-rows: 56px 1fr;
+    height: 100vh;
+    overflow: hidden;
+}
+
+/* === Header/Topbar === */
+.header {
+    grid-column: 1 / -1;
+    background: var(--bg-topbar);
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0 var(--sp-3xl);
+    z-index: 10;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+}
+
+.header-logo {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.header-logo span {
+    color: var(--accent);
+}
+
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+}
+
+.header-user {
+    font-size: 13px;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* === Sidebar === */
+.sidebar {
+    background: var(--bg-sidebar);
+    padding: var(--sp-xl);
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    border-right: 1px solid var(--border);
+}
+
+/* Sidebar Filter Tabs */
+.sidebar-filter {
+    display: flex;
+    gap: var(--sp-xs);
+    padding: 0 var(--sp-xs);
+    margin-bottom: var(--sp-lg);
+}
+
+.sidebar-filter-btn {
+    flex: 1;
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-secondary);
+    font-family: var(--font-body);
+    font-size: 12px;
+    font-weight: 600;
+    padding: var(--sp-sm) 0;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.sidebar-filter-btn:hover {
+    background: var(--bg-hover);
+    border-color: var(--accent);
+    color: var(--text-primary);
+}
+
+.sidebar-filter-btn.active {
+    background: var(--tint-accent);
+    border-color: var(--accent);
+    color: var(--accent);
+}
+
+.sidebar-section {
+    margin-bottom: var(--sp-xl);
+}
+
+.sidebar-section-title {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--sidebar-text-sec);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    margin-bottom: var(--sp-md);
+    padding: 0 var(--sp-lg);
+}
+
+.incident-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg);
+    border-radius: var(--radius);
+    cursor: pointer;
+    transition: background 0.2s ease;
+    position: relative;
+}
+
+.incident-item:hover {
+    background: var(--sidebar-hover-bg);
+}
+
+.incident-item:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+}
+
+.incident-item.active {
+    background: var(--bg-secondary);
+}
+
+.incident-item.active::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    width: 3px;
+    height: 24px;
+    background: var(--sidebar-active);
+    border-radius: 0 2px 2px 0;
+}
+
+.incident-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.incident-dot.active {
+    background: var(--success);
+}
+
+.incident-dot.archived {
+    background: var(--text-disabled);
+}
+
+.incident-dot.has-notification {
+    background: var(--warning);
+    animation: pulse 2s ease-in-out infinite;
+}
+
+.incident-dot.refreshing {
+    background: var(--accent);
+    animation: dotPulse 1.5s ease-in-out infinite;
+    box-shadow: var(--glow-accent-strong);
+}
+
+.incident-dot.refresh-error {
+    background: var(--error);
+    animation: dotFlash 0.6s ease-out;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+@keyframes dotPulse {
+    0%, 100% {
+        opacity: 1;
+        box-shadow: var(--glow-accent);
+        transform: scale(1);
+    }
+    50% {
+        opacity: 0.6;
+        box-shadow: var(--glow-accent-strong);
+        transform: scale(1.4);
+    }
+}
+
+@keyframes dotFlash {
+    0% { opacity: 1; transform: scale(1.6); }
+    100% { opacity: 1; transform: scale(1); }
+}
+
+.incident-name {
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--sidebar-text);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    flex: 1;
+}
+
+.incident-meta {
+    font-size: 11px;
+    color: var(--sidebar-text-sec);
+}
+
+.sidebar-stats {
+    margin-top: auto;
+    padding: var(--sp-xl) var(--sp-lg);
+    border-top: 1px solid var(--border);
+}
+
+.stat-row {
+    display: flex;
+    justify-content: space-between;
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-xs);
+}
+
+.stat-value {
+    color: var(--text-primary);
+    font-weight: 600;
+}
+
+/* === Main Content === */
+.main-content {
+    overflow-y: auto;
+    padding: var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-2xl);
+    background: var(--circuit-pattern) repeat, var(--bg-primary);
+    background-size: 300px 300px, auto;
+}
+
+#incident-view {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-2xl);
+}
+
+/* === Cards === */
+.card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-3xl);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: var(--sp-xl);
+}
+
+.card-title {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+/* === Incident Header Strip === */
+.incident-header-strip {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: var(--sp-xl) var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    flex-shrink: 0;
+}
+
+/* Zeile 1: Badge + Titel + Buttons */
+.incident-header-row1 {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-xl);
+}
+
+.incident-header-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    min-width: 0;
+    flex: 1;
+}
+
+.incident-header-title {
+    font-family: var(--font-title);
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    margin: 0;
+}
+
+.incident-header-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-shrink: 0;
+}
+
+/* Zeile 2: Creator + Beschreibung + Reliability + Meta */
+.incident-header-row2 {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-xl);
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+}
+
+.incident-header-row2-left {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    flex: 1;
+    min-width: 0;
+}
+
+.incident-creator-badge {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    flex-shrink: 0;
+}
+
+.incident-creator-badge strong {
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.incident-header-row2-right {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+    flex-shrink: 0;
+}
+
+.header-divider {
+    width: 1px;
+    height: 16px;
+    background: var(--border);
+    flex-shrink: 0;
+}
+
+/* Typ-Badge */
+.incident-type-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: var(--sp-xxs) var(--sp-md);
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    flex-shrink: 0;
+}
+.incident-type-badge.type-adhoc {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+.incident-type-badge.type-research {
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+}
+
+/* === Analyse-Bereich: Cards in gridstack === */
+.incident-analysis-summary {
+    display: flex;
+    flex-direction: column;
+}
+
+.incident-analysis-summary > .card-header {
+    flex-shrink: 0;
+}
+
+.incident-analysis-summary > #summary-content {
+    overflow-y: auto;
+    flex: 1;
+    min-height: 0;
+    background: var(--bg-primary);
+    border-radius: 0 0 var(--radius) var(--radius);
+    padding: var(--sp-lg);
+}
+
+.incident-analysis-factcheck {
+    display: flex;
+    flex-direction: column;
+}
+
+.incident-analysis-factcheck > .card-header {
+    flex-shrink: 0;
+}
+
+.incident-analysis-factcheck > .factcheck-list {
+    overflow-y: auto;
+    flex: 1;
+    min-height: 0;
+}
+
+/* Timeline-Card volle Breite */
+.timeline-card {
+    flex-shrink: 0;
+}
+
+.incident-description-text {
+    font-size: 12px;
+    color: var(--text-disabled);
+    line-height: 1.4;
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.summary-text {
+    font-size: 14px;
+    line-height: 1.7;
+    color: var(--text-secondary);
+    white-space: pre-wrap;
+}
+
+.summary-meta {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+}
+
+/* === Faktencheck Card === */
+.factcheck-list {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-sm);
+}
+
+.factcheck-item {
+    display: flex;
+    align-items: flex-start;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg);
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    background: var(--bg-primary);
+}
+
+.factcheck-icon {
+    flex-shrink: 0;
+    width: 24px;
+    height: 24px;
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 12px;
+    font-weight: 700;
+    margin-top: 1px;
+}
+
+.factcheck-icon.confirmed {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.factcheck-icon.unconfirmed {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.factcheck-icon.contradicted {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.factcheck-icon.developing {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.factcheck-icon.established {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.factcheck-icon.disputed {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.factcheck-icon.unverified {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.factcheck-claim {
+    font-size: 13px;
+    color: var(--text-primary);
+    flex: 1;
+}
+
+.factcheck-sources {
+    font-size: 11px;
+    color: var(--text-disabled);
+    margin-top: var(--sp-xxs);
+}
+
+/* === Faktencheck Filter-Dropdown === */
+.fc-filter-bar {
+    position: relative;
+    margin-left: auto;
+}
+
+.fc-dropdown-toggle {
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 3px 10px;
+    font-size: 11px;
+    font-family: var(--font-body);
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: border-color 0.15s, color 0.15s;
+}
+
+.fc-dropdown-toggle:hover {
+    border-color: var(--accent);
+    color: var(--text-primary);
+}
+
+.fc-dropdown-menu {
+    display: none;
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: 4px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 4px 0;
+    min-width: 180px;
+    box-shadow: var(--shadow-sm);
+    z-index: 20;
+}
+
+.fc-dropdown-menu.open {
+    display: block;
+}
+
+.fc-dropdown-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-sm) var(--sp-lg);
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--text-primary);
+    transition: background 0.1s;
+}
+
+.fc-dropdown-item:hover {
+    background: var(--bg-hover);
+}
+
+.fc-dropdown-item input[type="checkbox"] {
+    accent-color: var(--accent);
+    width: 14px;
+    height: 14px;
+    cursor: pointer;
+}
+
+.fc-dropdown-item .factcheck-icon {
+    width: 20px;
+    height: 20px;
+    font-size: 10px;
+}
+
+.fc-dropdown-label {
+    flex: 1;
+}
+
+.fc-dropdown-count {
+    font-size: 11px;
+    color: var(--text-disabled);
+    font-weight: 600;
+}
+
+/* === Evidence Block (Faktencheck) === */
+.evidence-block {
+    margin-top: var(--sp-sm);
+}
+
+.evidence-text {
+    font-size: 11px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+    display: block;
+    margin-bottom: var(--sp-xs);
+}
+
+.evidence-empty {
+    font-size: 11px;
+    color: var(--text-disabled);
+}
+
+.evidence-chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--sp-xs);
+}
+
+.evidence-chip {
+    display: inline-flex;
+    align-items: center;
+    padding: 1px 6px;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    font-size: 10px;
+    color: var(--text-secondary);
+    text-decoration: none;
+    max-width: 180px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.evidence-chip:hover {
+    background: var(--bg-hover);
+    color: var(--accent);
+}
+
+/* === Visueller Zeitstrahl (.vt-*) === */
+.vt-timeline {
+    position: relative;
+    padding-left: 48px;
+    overflow-y: auto;
+    max-height: 400px;
+    scroll-behavior: smooth;
+}
+
+/* Vertikale Achse */
+.vt-timeline::before {
+    content: '';
+    position: absolute;
+    left: 23px;
+    top: 0;
+    bottom: 0;
+    width: 2px;
+    background: var(--border);
+}
+
+/* Scrollbar */
+.vt-timeline::-webkit-scrollbar { width: 6px; }
+.vt-timeline::-webkit-scrollbar-track { background: var(--bg-primary); border-radius: 3px; }
+.vt-timeline::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.vt-timeline::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* Zeitgruppe */
+.vt-time-group {
+    position: relative;
+}
+
+/* Zeitgruppen-Label (Raute auf der Achse) */
+.vt-time-label {
+    position: sticky;
+    top: 0;
+    z-index: 2;
+    padding: var(--sp-md) 0;
+    margin-left: -48px;
+    padding-left: 48px;
+    background: var(--bg-card);
+}
+
+.vt-time-label::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    top: 50%;
+    width: 10px;
+    height: 10px;
+    background: var(--accent);
+    transform: translateY(-50%) rotate(45deg);
+    z-index: 3;
+}
+
+.vt-time-label-text {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    font-weight: 700;
+    color: var(--accent);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+/* Basis-Eintrag (Artikel) */
+.vt-entry {
+    position: relative;
+    padding: var(--sp-md) 0;
+    padding-right: var(--sp-xl);
+    transition: background 0.15s ease;
+    cursor: default;
+}
+
+/* Achsen-Punkt (Artikel = kleiner grauer Kreis) */
+.vt-entry::before {
+    content: '';
+    position: absolute;
+    left: -30px;
+    top: 14px;
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    border: 2px solid var(--bg-card);
+    z-index: 1;
+    transition: background 0.2s ease, box-shadow 0.2s ease;
+}
+
+.vt-entry:hover {
+    background: var(--tint-hover);
+}
+
+/* Expandierbarer Eintrag */
+.vt-entry.expandable {
+    cursor: pointer;
+}
+
+/* Aufklapp-Dreieck */
+.vt-entry.expandable::after {
+    content: '\25B8';
+    position: absolute;
+    right: 12px;
+    top: 14px;
+    font-size: 10px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease, color 0.2s ease;
+}
+
+/* Expanded: Punkt Gold, Dreieck rotiert */
+.vt-entry.expanded::before {
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+}
+
+.vt-entry.expanded::after {
+    transform: rotate(90deg);
+    color: var(--accent);
+}
+
+/* Lagebericht-Eintrag (großer goldener Punkt + Glow) */
+.vt-entry.vt-snapshot::before {
+    width: 14px;
+    height: 14px;
+    left: -32px;
+    top: 12px;
+    background: var(--accent);
+    border: 2px solid var(--bg-card);
+    box-shadow: var(--glow-accent);
+}
+
+.vt-entry.vt-snapshot {
+    background: var(--tint-accent-faint);
+    border-radius: var(--radius);
+    margin: var(--sp-xs) 0;
+}
+
+.vt-entry.vt-snapshot:hover {
+    background: var(--tint-accent-subtle);
+}
+
+/* Artikel-Header (Zeit + Quelle + Lang-Badge) */
+.vt-article-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+}
+
+.vt-article-time {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    color: var(--accent);
+    font-weight: 600;
+    white-space: nowrap;
+}
+
+.vt-article-source {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.vt-article-source a {
+    color: var(--text-disabled);
+    text-decoration: none;
+}
+
+.vt-article-source a:hover {
+    color: var(--accent);
+}
+
+/* Headline */
+.vt-article-headline {
+    font-size: 13px;
+    color: var(--text-primary);
+    line-height: 1.4;
+    margin-top: var(--sp-xxs);
+}
+
+/* Aufklapp-Bereich */
+.vt-article-detail {
+    display: none;
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+    margin-top: var(--sp-sm);
+}
+
+.vt-entry.expanded .vt-article-detail {
+    display: block;
+}
+
+.vt-article-detail-content {
+    font-size: 12px;
+    color: var(--text-secondary);
+    line-height: 1.6;
+    max-height: 150px;
+    overflow-y: auto;
+}
+
+.vt-article-detail-link {
+    display: inline-block;
+    margin-top: var(--sp-sm);
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--accent);
+    text-decoration: none;
+}
+
+.vt-article-detail-link:hover {
+    color: var(--accent-hover);
+}
+
+/* Snapshot-Header (Badge + Zeit + Stats) */
+.vt-snapshot-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-wrap: wrap;
+}
+
+.vt-snapshot-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+}
+
+.vt-snapshot-time {
+    font-size: 11px;
+    font-family: var(--font-mono);
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.vt-snapshot-stats {
+    font-size: 11px;
+    color: var(--text-secondary);
+}
+
+/* Snapshot-Vorschau (2 Zeilen, collapsed) */
+.vt-snapshot-preview {
+    font-size: 12px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+    margin-top: var(--sp-xs);
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+/* Snapshot-Detail (expanded → volle Zusammenfassung) */
+.vt-snapshot-detail {
+    display: none;
+    margin-top: var(--sp-md);
+    padding-top: var(--sp-md);
+    border-top: 1px solid var(--border);
+}
+
+.vt-entry.vt-snapshot.expanded .vt-snapshot-preview {
+    display: none;
+}
+
+.vt-entry.vt-snapshot.expanded .vt-snapshot-detail {
+    display: block;
+}
+
+/* Cluster-Badge */
+.vt-cluster-count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 18px;
+    height: 18px;
+    padding: 0 5px;
+    border-radius: 9px;
+    font-size: 10px;
+    font-weight: 700;
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+    margin-left: var(--sp-sm);
+}
+
+/* Modal-Version */
+.modal-content-viewer .vt-timeline {
+    max-height: none;
+    padding-left: 52px;
+}
+
+.modal-content-viewer .vt-timeline::before {
+    left: 27px;
+}
+
+/* === Sprach-Badge === */
+.lang-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 0 4px;
+    border-radius: 2px;
+    font-size: 9px;
+    font-weight: 700;
+    letter-spacing: 0.5px;
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+    flex-shrink: 0;
+}
+
+/* === Quellenübersicht === */
+.source-overview-card {
+    flex-shrink: 0;
+}
+
+.source-overview-card .card-header {
+    margin-bottom: var(--sp-lg);
+}
+
+.source-overview-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: var(--sp-lg);
+    flex-wrap: wrap;
+    gap: var(--sp-md);
+}
+
+.source-overview-stat {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+.source-lang-chips {
+    display: flex;
+    gap: var(--sp-sm);
+}
+
+.source-lang-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 11px;
+    color: var(--text-secondary);
+    background: var(--bg-secondary);
+}
+
+.source-lang-chip strong {
+    color: var(--text-primary);
+}
+
+.source-overview-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+    gap: var(--sp-sm);
+}
+
+.source-overview-item {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-lg);
+    border-radius: var(--radius);
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+}
+
+.source-overview-name {
+    font-size: 12px;
+    font-weight: 500;
+    color: var(--text-primary);
+    flex: 1;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-overview-lang {
+    font-size: 10px;
+    color: var(--text-disabled);
+    flex-shrink: 0;
+}
+
+.source-overview-count {
+    font-size: 12px;
+    font-weight: 700;
+    color: var(--accent);
+    background: var(--tint-accent);
+    padding: 1px 6px;
+    border-radius: var(--radius);
+    flex-shrink: 0;
+}
+
+/* === Badges === */
+.badge {
+    display: inline-flex;
+    align-items: center;
+    padding: var(--sp-xxs) var(--sp-md);
+    border-radius: var(--radius);
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.badge-verified {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.badge-unverified {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.badge-contradicted {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.badge-auto {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+
+.badge-research {
+    background: var(--tint-indigo);
+    color: var(--cat-think-tank);
+}
+
+.badge-private {
+    background: var(--tint-error);
+    color: var(--cat-nachrichtenagentur);
+}
+
+/* === Modal === */
+.modal-overlay {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: var(--backdrop);
+    backdrop-filter: blur(4px);
+    z-index: 100;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-overlay.active {
+    display: flex;
+}
+
+.modal {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    width: 100%;
+    max-width: 520px;
+    max-height: 90vh;
+    overflow-y: auto;
+}
+
+.modal-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-xl) var(--sp-3xl);
+    border-bottom: 1px solid var(--border);
+}
+
+.modal-title {
+    font-family: var(--font-title);
+    font-size: 16px;
+    font-weight: 600;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    font-size: 20px;
+    cursor: pointer;
+    padding: var(--sp-xs) var(--sp-md);
+    border-radius: var(--radius);
+    transition: all 0.2s ease;
+    line-height: 1;
+}
+
+.modal-close:hover {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.modal-body {
+    padding: var(--sp-3xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-xl);
+}
+
+.modal-footer {
+    padding: var(--sp-xl) var(--sp-3xl);
+    border-top: 1px solid var(--border);
+    display: flex;
+    justify-content: flex-end;
+    gap: var(--sp-lg);
+}
+
+/* === Conditional Field === */
+.conditional-field {
+    display: none;
+}
+
+.conditional-field.visible {
+    display: block;
+}
+
+/* === Toast Notifications === */
+.toast-container {
+    position: fixed;
+    top: 72px;
+    right: var(--sp-3xl);
+    z-index: 200;
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-md);
+    pointer-events: none;
+}
+
+.toast {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-lg) var(--sp-xl);
+    box-shadow: var(--shadow-md);
+    pointer-events: auto;
+    animation: slideIn 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    max-width: 380px;
+    border-left: 3px solid var(--accent);
+}
+
+.toast.toast-warning {
+    border-left-color: var(--warning);
+}
+
+.toast.toast-error {
+    border-left-color: var(--error);
+}
+
+.toast.toast-success {
+    border-left-color: var(--success);
+}
+
+.toast-text {
+    font-size: 13px;
+    color: var(--text-primary);
+    line-height: 1.4;
+}
+
+@keyframes slideIn {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
+/* === Empty State === */
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: var(--sp-5xl) var(--sp-4xl);
+    text-align: center;
+}
+
+.empty-state-icon {
+    font-size: 48px;
+    margin-bottom: var(--sp-xl);
+    opacity: 0.2;
+    color: var(--text-secondary);
+}
+
+.empty-state-title {
+    font-family: var(--font-title);
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-md);
+}
+
+.empty-state-text {
+    font-size: 13px;
+    color: var(--text-disabled);
+    max-width: 320px;
+}
+
+/* === Loading Spinner === */
+.spinner {
+    width: 24px;
+    height: 24px;
+    border: 3px solid var(--border);
+    border-top-color: var(--accent);
+    border-radius: 50%;
+    animation: rotate 1s linear infinite;
+}
+
+@keyframes rotate {
+    to { transform: rotate(360deg); }
+}
+
+.loading-overlay {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--sp-lg);
+    padding: var(--sp-3xl);
+    color: var(--text-secondary);
+    font-size: 13px;
+}
+
+/* === Fortschrittsanzeige === */
+.progress-bar {
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-xl);
+    margin-bottom: var(--sp-xl);
+}
+
+.progress-steps {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: var(--sp-lg);
+}
+
+.progress-step {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    font-size: 12px;
+    color: var(--text-disabled);
+    transition: color 0.3s ease;
+}
+
+.progress-step.active {
+    color: var(--accent);
+    font-weight: 600;
+}
+
+.progress-step.done {
+    color: var(--success);
+}
+
+.progress-step-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    transition: all 0.3s ease;
+    flex-shrink: 0;
+}
+
+.progress-step.active .progress-step-dot {
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
+.progress-step.done .progress-step-dot {
+    background: var(--success);
+}
+
+.progress-track {
+    height: 4px;
+    background: var(--bg-secondary);
+    border-radius: 2px;
+    overflow: hidden;
+    margin-bottom: var(--sp-md);
+}
+
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent), var(--success));
+    border-radius: 2px;
+    transition: width 0.5s ease-out;
+    width: 0%;
+}
+
+.progress-label {
+    font-size: 12px;
+    color: var(--text-secondary);
+    text-align: center;
+}
+
+/* === Briefing === */
+.briefing-content {
+    font-size: 14px;
+    line-height: 1.8;
+    color: var(--text-secondary);
+}
+
+.briefing-content strong {
+    color: var(--text-primary);
+}
+
+.briefing-heading {
+    font-size: 15px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-top: var(--sp-xl);
+    margin-bottom: var(--sp-xs);
+    padding-bottom: 0;
+    border-bottom: none;
+}
+
+.briefing-content .briefing-heading:first-child {
+    margin-top: 0;
+}
+
+/* === Form Hint === */
+.form-hint {
+    font-size: 11px;
+    color: var(--text-disabled);
+    margin-top: var(--sp-xs);
+}
+
+/* === Inline-Zitate === */
+.citation {
+    color: var(--accent);
+    text-decoration: none;
+    font-size: 11px;
+    vertical-align: super;
+    font-weight: 600;
+}
+.citation:hover {
+    text-decoration: underline;
+}
+
+/* === Quellenverzeichnis (im Lagebild) === */
+.source-list {
+    margin-top: 16px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border);
+}
+.source-list-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-disabled);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+}
+.source-list-item {
+    font-size: 12px;
+    color: var(--text-secondary);
+    padding: 2px 0;
+}
+.source-list-item a {
+    color: var(--text-primary);
+}
+.source-list-item a:hover {
+    color: var(--accent);
+}
+.source-nr {
+    color: var(--accent);
+    font-weight: 600;
+    margin-right: 4px;
+}
+
+/* === Timeline Filter === */
+.timeline-filter-input {
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: 4px 8px;
+    font-size: 12px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    width: 140px;
+}
+.timeline-filter-input:focus {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+    border-color: var(--accent);
+}
+.timeline-filter-input::placeholder {
+    color: var(--text-disabled);
+}
+.timeline-filter-select {
+    background: var(--input-bg);
+    border: 1px solid var(--input-border);
+    border-radius: var(--radius);
+    padding: 4px 8px;
+    font-size: 12px;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    cursor: pointer;
+    appearance: none;
+    padding-right: 20px;
+    background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238896AB' stroke-width='2'%3e%3cpolyline points='6 9 12 15 18 9'/%3e%3c/svg%3e");
+    background-repeat: no-repeat;
+    background-position: right 4px center;
+    background-size: 12px;
+}
+
+/* === Horizontale Timeline (ht-*) === */
+
+/* Controls-Leiste */
+.ht-controls {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    flex-wrap: wrap;
+}
+
+/* Filter-/Range-Gruppen (Pill-Toggle) */
+.ht-filter-group,
+.ht-range-group {
+    display: flex;
+    border-radius: var(--radius);
+    overflow: hidden;
+    border: 1px solid var(--border);
+}
+
+.ht-filter-btn,
+.ht-range-btn,
+.ht-modal-filter-btn {
+    padding: 3px 10px;
+    font-size: 11px;
+    font-weight: 600;
+    font-family: var(--font-body);
+    border: none;
+    background: transparent;
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+}
+
+.ht-filter-btn:hover,
+.ht-range-btn:hover,
+.ht-modal-filter-btn:hover {
+    color: var(--text-primary);
+    background: var(--tint-accent-subtle);
+}
+
+.ht-filter-btn.active,
+.ht-range-btn.active,
+.ht-modal-filter-btn.active {
+    background: var(--tint-accent-strong);
+    color: var(--accent);
+}
+
+/* Zähler + integrierte Legende */
+.ht-count {
+    font-size: 12px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+}
+
+.ht-legend-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-disabled);
+    vertical-align: middle;
+    margin-right: 2px;
+}
+
+.ht-legend-dot.ht-legend-gold {
+    background: var(--accent);
+}
+
+/* Timeline-Container */
+.ht-timeline-container {
+    padding: 12px 20px 8px;
+}
+
+/* Achsen-Container */
+.ht-axis {
+    position: relative;
+    height: 110px;
+}
+
+/* Stündliches Layout: höher wegen Datums-Markern oben */
+.ht-axis--hourly {
+    height: 130px;
+}
+
+/* Punkte-Bereich (über der Linie) */
+.ht-points {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 0;
+    height: 56px;
+}
+
+.ht-axis--hourly .ht-points {
+    top: 20px;
+}
+
+/* Achsenlinie */
+.ht-axis-line {
+    position: absolute;
+    left: 2%;
+    right: 2%;
+    top: 60px;
+    height: 2px;
+    background: var(--border);
+}
+
+.ht-axis--hourly .ht-axis-line {
+    top: 80px;
+}
+
+/* Datums-Marker (vertikale Linie + Datum oben, nur bei Stunden-Granularität) */
+.ht-day-markers {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 0;
+    bottom: 0;
+    pointer-events: none;
+}
+
+.ht-day-marker {
+    position: absolute;
+    top: 0;
+}
+
+.ht-day-marker-label {
+    position: absolute;
+    top: 0;
+    left: 0;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    font-weight: 600;
+    color: var(--accent);
+    white-space: nowrap;
+}
+
+.ht-day-marker-line {
+    position: absolute;
+    top: 14px;
+    height: 66px;
+    width: 1px;
+    left: 0;
+    background: var(--accent);
+    opacity: 0.2;
+}
+
+/* Punkt (Basis) */
+.ht-point {
+    position: absolute;
+    bottom: 0;
+    transform: translateX(-50%);
+    border-radius: 50%;
+    background: var(--text-disabled);
+    border: 2px solid var(--bg-card);
+    cursor: pointer;
+    transition: all 0.2s ease;
+    z-index: 2;
+}
+
+.ht-point:hover {
+    box-shadow: var(--glow-accent);
+    z-index: 4;
+}
+
+.ht-point.active {
+    box-shadow: var(--glow-accent-strong);
+    z-index: 4;
+}
+
+/* Dimmen: nicht-aktive Punkte verblassen wenn ein Punkt aktiv ist */
+.ht-points:has(.ht-point.active) .ht-point:not(.active) {
+    opacity: 0.3;
+    transition: opacity 0.3s ease;
+}
+
+/* Pfeil über dem aktiven Punkt */
+.ht-point.active::after {
+    content: '▼';
+    position: absolute;
+    bottom: calc(100% + 2px);
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 10px;
+    color: var(--accent);
+    pointer-events: none;
+    line-height: 1;
+}
+
+/* Snapshot-Punkt (Raute) */
+.ht-point.ht-snapshot-point {
+    border-radius: 2px;
+    transform: translateX(-50%) rotate(45deg);
+    background: var(--accent);
+    box-shadow: var(--glow-accent);
+}
+
+.ht-point.ht-snapshot-point .ht-tooltip,
+.ht-point.ht-snapshot-point .ht-point-count {
+    transform: rotate(-45deg);
+}
+
+.ht-point.ht-snapshot-point .ht-tooltip {
+    transform: rotate(-45deg) translateX(-50%);
+    transform-origin: bottom left;
+}
+
+/* Gemischter Punkt (Gold-Kreis) */
+.ht-point.ht-mixed-point {
+    background: var(--accent);
+    border: 2px solid var(--bg-card);
+}
+
+/* Tooltip (über dem Punkt) */
+.ht-tooltip {
+    position: absolute;
+    bottom: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    font-size: 11px;
+    padding: 3px 8px;
+    border-radius: var(--radius);
+    white-space: nowrap;
+    pointer-events: none;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.15s ease, visibility 0.15s ease;
+    border: 1px solid var(--border);
+    z-index: 10;
+}
+
+.ht-point:hover .ht-tooltip {
+    opacity: 1;
+    visibility: visible;
+}
+
+/* Zahl unter dem Punkt */
+.ht-point-count {
+    position: absolute;
+    top: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    white-space: nowrap;
+    pointer-events: none;
+}
+
+.ht-point.active .ht-point-count,
+.ht-point:hover .ht-point-count {
+    color: var(--accent);
+}
+
+/* Achsen-Labels (unter der Linie) */
+.ht-axis-labels {
+    position: absolute;
+    left: 4%;
+    right: 4%;
+    top: 72px;
+    height: 20px;
+}
+
+.ht-axis--hourly .ht-axis-labels {
+    top: 90px;
+}
+
+.ht-axis-label {
+    position: absolute;
+    transform: translateX(-50%);
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-tertiary);
+    white-space: nowrap;
+}
+
+/* Leerer Zustand */
+.ht-empty {
+    padding: 20px;
+    text-align: center;
+    font-size: 13px;
+    color: var(--text-tertiary);
+}
+
+/* Detail-Panel */
+.ht-detail-panel {
+    margin-top: 8px;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg-secondary);
+    animation: ht-slide-down 0.2s ease;
+}
+
+@keyframes ht-slide-down {
+    from { opacity: 0; transform: translateY(-8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.ht-detail-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border);
+}
+
+.ht-detail-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--accent);
+    font-family: var(--font-mono);
+}
+
+.ht-detail-close {
+    background: none;
+    border: none;
+    color: var(--text-disabled);
+    font-size: 18px;
+    cursor: pointer;
+    padding: 0 4px;
+    line-height: 1;
+}
+
+.ht-detail-close:hover {
+    color: var(--text-primary);
+}
+
+.ht-detail-content {
+    max-height: 350px;
+    overflow-y: auto;
+    padding: 4px 12px;
+}
+
+.ht-detail-content::-webkit-scrollbar { width: 6px; }
+.ht-detail-content::-webkit-scrollbar-track { background: var(--bg-primary); border-radius: 3px; }
+.ht-detail-content::-webkit-scrollbar-thumb { background: var(--text-disabled); border-radius: 3px; }
+.ht-detail-content::-webkit-scrollbar-thumb:hover { background: var(--text-secondary); }
+
+/* === Briefing Listen === */
+.briefing-content ul {
+    margin: 8px 0;
+    padding-left: 20px;
+}
+.briefing-content li {
+    margin: 4px 0;
+    font-size: 13px;
+    color: var(--text-secondary);
+}
+
+/* === Responsive === */
+
+@media (max-width: 768px) {
+    .dashboard {
+        grid-template-columns: 1fr;
+    }
+
+    .sidebar {
+        display: none;
+    }
+
+    .incident-header-row1 {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .incident-header-row2 {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .incident-header-row2-right {
+        flex-wrap: wrap;
+    }
+
+    .incident-header-actions {
+        width: 100%;
+        justify-content: flex-end;
+    }
+
+    .source-overview-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* === Toggle Switch === */
+.toggle-group {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-xs);
+}
+
+.toggle-label,
+.form-group .toggle-label {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    cursor: pointer;
+    user-select: none;
+    text-transform: none;
+    letter-spacing: normal;
+    font-weight: 400;
+    font-size: 13px;
+    color: var(--text-primary);
+    margin-bottom: 0;
+}
+
+.toggle-label input[type="checkbox"] {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+}
+
+.toggle-switch {
+    position: relative;
+    width: 36px;
+    min-width: 36px;
+    height: 20px;
+    background: var(--input-border);
+    border-radius: 10px;
+    transition: background 0.2s;
+    flex-shrink: 0;
+}
+
+.toggle-switch::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 16px;
+    height: 16px;
+    background: var(--text-secondary);
+    border-radius: 50%;
+    transition: transform 0.2s, background 0.2s;
+}
+
+.toggle-label input:checked + .toggle-switch {
+    background: var(--accent);
+}
+
+.toggle-label input:checked + .toggle-switch::after {
+    transform: translateX(16px);
+    background: var(--bg-primary);
+}
+
+.toggle-text {
+    font-size: 13px;
+    color: var(--text-primary);
+}
+
+/* International-Badge im Header */
+.intl-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+    font-size: 11px;
+    padding: 2px 8px;
+    border-radius: 3px;
+    font-weight: 500;
+}
+
+.intl-badge.intl-yes {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.intl-badge.intl-no {
+    background: var(--tint-accent);
+    color: var(--accent);
+}
+
+/* === Notification Center === */
+.notification-center {
+    position: relative;
+}
+
+.notification-bell {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: var(--sp-sm) var(--sp-md);
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.2s ease, background 0.2s ease;
+    position: relative;
+}
+
+.notification-bell:hover {
+    color: var(--accent);
+    background: var(--bg-hover);
+}
+
+.notification-badge {
+    position: absolute;
+    top: 0;
+    right: 0;
+    min-width: 16px;
+    height: 16px;
+    padding: 0 4px;
+    background: var(--error);
+    color: #fff;
+    font-size: 10px;
+    font-weight: 700;
+    font-family: var(--font-body);
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    line-height: 1;
+    pointer-events: none;
+    animation: badgePop 0.3s ease;
+}
+
+@keyframes badgePop {
+    0% { transform: scale(0); }
+    60% { transform: scale(1.3); }
+    100% { transform: scale(1); }
+}
+
+.notification-panel {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    width: 360px;
+    max-height: 480px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    z-index: 50;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.notification-panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-lg) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+.notification-panel-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.notification-mark-read {
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 11px;
+    font-weight: 600;
+    font-family: var(--font-body);
+    cursor: pointer;
+    padding: var(--sp-xxs) var(--sp-sm);
+    border-radius: var(--radius);
+    transition: background 0.2s ease;
+}
+
+.notification-mark-read:hover {
+    background: var(--tint-accent);
+}
+
+.notification-panel-list {
+    overflow-y: auto;
+    flex: 1;
+    max-height: 420px;
+}
+
+.notification-empty {
+    padding: var(--sp-3xl);
+    text-align: center;
+    font-size: 12px;
+    color: var(--text-disabled);
+}
+
+.notification-item {
+    display: flex;
+    align-items: flex-start;
+    gap: var(--sp-lg);
+    padding: var(--sp-lg) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    cursor: pointer;
+    transition: background 0.15s ease;
+}
+
+.notification-item:last-child {
+    border-bottom: none;
+}
+
+.notification-item:hover {
+    background: var(--bg-hover);
+}
+
+.notification-item.unread {
+    border-left: 3px solid var(--accent);
+    padding-left: calc(var(--sp-xl) - 3px);
+}
+
+.notification-item-icon {
+    width: 24px;
+    height: 24px;
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 11px;
+    font-weight: 700;
+    flex-shrink: 0;
+    margin-top: 1px;
+}
+
+.notification-item-icon.success {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.notification-item-icon.warning {
+    background: var(--tint-warning);
+    color: var(--warning);
+}
+
+.notification-item-icon.error {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+.notification-item-icon.info {
+    background: var(--tint-info);
+    color: var(--info);
+}
+
+.notification-item-body {
+    flex: 1;
+    min-width: 0;
+}
+
+.notification-item-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.notification-item-text {
+    font-size: 11px;
+    color: var(--text-secondary);
+    line-height: 1.4;
+    margin-top: 1px;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+.notification-item-time {
+    font-size: 10px;
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    white-space: nowrap;
+    flex-shrink: 0;
+    margin-top: 2px;
+}
+
+/* Notification Center Responsive */
+@media (max-width: 768px) {
+    .notification-panel {
+        width: calc(100vw - 32px);
+        right: -8px;
+    }
+}
+
+/* === Quellenverwaltung === */
+
+/* Wide Modal */
+.modal-wide {
+    max-width: 800px;
+}
+
+/* Content-Viewer Modal */
+.modal-content-viewer {
+    max-width: 900px;
+    height: 85vh;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.modal-content-viewer .modal-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+}
+
+.modal-header-extra {
+    margin-left: auto;
+    margin-right: 8px;
+}
+
+.modal-content-viewer .modal-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: var(--sp-2xl) var(--sp-3xl);
+    background: var(--bg-primary);
+    border-radius: 0 0 var(--radius-lg) var(--radius-lg);
+}
+
+/* Klickbare Sektionstitel */
+.card-title.clickable {
+    cursor: pointer;
+    transition: color 0.2s ease;
+}
+
+.card-title.clickable:hover {
+    color: var(--accent);
+}
+
+/* Detaillierte Quellenübersicht im Modal */
+.source-detail-group {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    margin-bottom: 6px;
+    overflow: hidden;
+}
+
+.source-detail-header {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: 10px 14px;
+    cursor: pointer;
+    background: var(--bg-secondary);
+    transition: background 0.15s ease;
+}
+
+.source-detail-header:hover {
+    background: var(--bg-hover);
+}
+
+.source-detail-toggle {
+    color: var(--text-disabled);
+    font-size: 12px;
+    transition: transform 0.2s ease;
+    flex-shrink: 0;
+}
+
+.source-detail-group.open .source-detail-toggle {
+    transform: rotate(90deg);
+}
+
+.source-detail-name {
+    flex: 1;
+    font-weight: 500;
+    color: var(--text-primary);
+    font-size: 13px;
+}
+
+.source-detail-articles {
+    display: none;
+    border-top: 1px solid var(--border);
+}
+
+.source-detail-group.open .source-detail-articles {
+    display: block;
+}
+
+.source-detail-article {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-lg);
+    padding: 8px 14px 8px 36px;
+    font-size: 12px;
+    border-bottom: 1px solid var(--border);
+}
+
+.source-detail-article:last-child {
+    border-bottom: none;
+}
+
+.source-detail-time {
+    color: var(--text-disabled);
+    flex-shrink: 0;
+    min-width: 90px;
+    font-family: var(--font-mono);
+    font-size: 11px;
+}
+
+.source-detail-headline {
+    flex: 1;
+    color: var(--text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.source-detail-link {
+    color: var(--accent);
+    text-decoration: none;
+    font-size: 14px;
+    flex-shrink: 0;
+    opacity: 0.6;
+    transition: opacity 0.15s ease;
+}
+
+.source-detail-link:hover {
+    opacity: 1;
+}
+
+/* Sidebar Sources Link */
+.sidebar-sources-link {
+    padding: var(--sp-lg) var(--sp-xl);
+    border-top: 1px solid var(--border);
+    margin-top: auto;
+}
+
+.sidebar-sources-link .btn {
+    margin-bottom: var(--sp-md);
+}
+
+.sidebar-stats-mini {
+    font-size: 11px;
+    color: var(--text-disabled);
+    text-align: center;
+}
+
+/* Stats-Leiste */
+.sources-stats-bar {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xl);
+    padding: var(--sp-lg);
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    margin-bottom: var(--sp-lg);
+    font-size: 12px;
+    color: var(--text-secondary);
+    flex-wrap: wrap;
+}
+
+.sources-stats-bar .sources-stat-item {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--sp-xs);
+}
+
+.sources-stats-bar .sources-stat-value {
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.sources-search-input {
+    width: 160px;
+}
+
+/* Toolbar */
+.sources-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--sp-lg);
+    margin-bottom: var(--sp-lg);
+}
+
+.sources-filters {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    flex-wrap: wrap;
+}
+
+/* Sources-Modal Body */
+.sources-modal-body {
+    padding: var(--sp-xl) var(--sp-3xl);
+}
+
+/* Inline-Formular Zeile */
+.sources-form-row {
+    display: flex;
+    gap: var(--sp-md);
+    align-items: flex-end;
+}
+
+.sources-form-row .form-group {
+    margin: 0;
+}
+
+.sources-form-row .form-group.flex-1 {
+    flex: 1;
+}
+
+.sources-form-row .btn {
+    height: 36px;
+    white-space: nowrap;
+}
+
+/* Discovery-Ergebnis */
+.sources-discovery-result {
+    margin-top: var(--sp-lg);
+}
+
+.sources-discovery-actions {
+    display: flex;
+    gap: var(--sp-md);
+    margin-top: var(--sp-lg);
+}
+
+/* Toolbar Button-Gruppe */
+.sources-toolbar-actions {
+    display: flex;
+    gap: var(--sp-md);
+}
+
+/* Readonly-Input */
+.input-readonly {
+    background: var(--bg-elevated);
+    color: var(--text-secondary);
+}
+
+.source-notes-input {
+    width: 200px;
+}
+
+/* Inline-Formular */
+.sources-add-form {
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: var(--sp-xl);
+    margin-bottom: var(--sp-lg);
+}
+
+.sources-add-form-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr 1fr;
+    gap: var(--sp-lg);
+}
+
+.sources-add-form-grid .form-group {
+    margin: 0;
+}
+
+.sources-add-form label:not(.toggle-label) {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: var(--sp-xs);
+    display: block;
+}
+
+.sources-add-form input,
+.sources-add-form select {
+    width: 100%;
+}
+
+/* Quellen-Liste */
+.sources-list {
+    max-height: 50vh;
+    overflow-y: auto;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+}
+
+.sources-list::-webkit-scrollbar {
+    width: 6px;
+}
+.sources-list::-webkit-scrollbar-track {
+    background: var(--bg-primary);
+}
+.sources-list::-webkit-scrollbar-thumb {
+    background: var(--text-disabled);
+    border-radius: 3px;
+}
+
+/* Source Row */
+.source-row {
+    display: grid;
+    grid-template-columns: 1fr 120px 90px 60px 40px 32px;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-xl);
+    border-bottom: 1px solid var(--border);
+    transition: background 0.15s ease;
+    font-size: 13px;
+}
+
+.source-row:last-child {
+    border-bottom: none;
+}
+
+.source-row:hover {
+    background: var(--bg-hover);
+}
+
+.source-row-name {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+.source-row-name-text {
+    font-weight: 500;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-row-domain {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-row-count {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--accent);
+    text-align: center;
+}
+
+/* Kategorie-Badges */
+.source-category-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 600;
+    white-space: nowrap;
+    text-transform: uppercase;
+    letter-spacing: 0.3px;
+}
+
+.source-category-badge.cat-nachrichtenagentur {
+    background: var(--cat-nachrichtenagentur-bg);
+    color: var(--cat-nachrichtenagentur);
+}
+
+.source-category-badge.cat-oeffentlich-rechtlich {
+    background: var(--cat-oeffentlich-rechtlich-bg);
+    color: var(--cat-oeffentlich-rechtlich);
+}
+
+.source-category-badge.cat-qualitaetszeitung {
+    background: var(--cat-qualitaetszeitung-bg);
+    color: var(--cat-qualitaetszeitung);
+}
+
+.source-category-badge.cat-behoerde {
+    background: var(--cat-behoerde-bg);
+    color: var(--cat-behoerde);
+}
+
+.source-category-badge.cat-fachmedien {
+    background: var(--cat-fachmedien-bg);
+    color: var(--cat-fachmedien);
+}
+
+.source-category-badge.cat-think-tank {
+    background: var(--cat-think-tank-bg);
+    color: var(--cat-think-tank);
+}
+
+.source-category-badge.cat-international {
+    background: var(--cat-international-bg);
+    color: var(--cat-international);
+}
+
+.source-category-badge.cat-regional {
+    background: var(--cat-regional-bg);
+    color: var(--cat-regional);
+}
+
+.source-category-badge.cat-sonstige {
+    background: var(--cat-sonstige-bg);
+    color: var(--info);
+}
+
+/* Typ-Badges */
+.source-type-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 6px;
+    border-radius: var(--radius);
+    font-size: 10px;
+    font-weight: 600;
+    white-space: nowrap;
+}
+
+.source-type-badge.type-rss_feed {
+    background: var(--tint-success);
+    color: var(--success);
+}
+
+.source-type-badge.type-web_source {
+    background: var(--cat-oeffentlich-rechtlich-bg);
+    color: var(--cat-oeffentlich-rechtlich);
+}
+
+.source-type-badge.type-excluded {
+    background: var(--tint-error);
+    color: var(--error);
+}
+
+/* Active Toggle */
+.source-toggle {
+    position: relative;
+    width: 28px;
+    height: 16px;
+    background: var(--input-border);
+    border-radius: 8px;
+    cursor: pointer;
+    transition: background 0.2s;
+    border: none;
+    padding: 0;
+    flex-shrink: 0;
+}
+
+.source-toggle::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 12px;
+    height: 12px;
+    background: var(--text-secondary);
+    border-radius: 50%;
+    transition: transform 0.2s, background 0.2s;
+}
+
+.source-toggle.active {
+    background: var(--accent);
+}
+
+.source-toggle.active::after {
+    transform: translateX(12px);
+    background: var(--bg-primary);
+}
+
+/* Delete Button */
+.source-delete-btn {
+    background: none;
+    border: none;
+    color: var(--text-disabled);
+    cursor: pointer;
+    font-size: 14px;
+    padding: 2px 6px;
+    border-radius: var(--radius);
+    transition: color 0.2s, background 0.2s;
+    line-height: 1;
+}
+
+.source-delete-btn:hover {
+    color: var(--error);
+    background: var(--tint-error);
+}
+
+/* Domain-Gruppen */
+.source-group {
+    border-bottom: 1px solid var(--border);
+}
+
+.source-group:last-child {
+    border-bottom: none;
+}
+
+.source-group-header {
+    display: grid;
+    grid-template-columns: 20px 1fr auto auto auto;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-md) var(--sp-xl);
+    cursor: pointer;
+    transition: background 0.15s ease;
+    font-size: 13px;
+}
+
+.source-group-header:hover {
+    background: var(--bg-hover);
+}
+
+.source-group-header.expanded .source-group-toggle {
+    transform: rotate(90deg);
+}
+
+.source-group-toggle {
+    font-size: 10px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease;
+    display: inline-block;
+    width: 20px;
+    text-align: center;
+    user-select: none;
+}
+
+.source-group-toggle-placeholder {
+    width: 20px;
+    display: inline-block;
+}
+
+.source-group-info {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    min-width: 0;
+}
+
+.source-group-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    font-size: 14px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-group-notes {
+    font-size: 12px;
+    color: var(--text-disabled);
+    font-weight: 400;
+}
+
+.source-feed-count {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 1px 8px;
+    border-radius: 9px;
+    font-size: 11px;
+    font-weight: 600;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    white-space: nowrap;
+}
+
+.source-group-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-xs);
+}
+
+/* Gesperrte Domain */
+.source-group-header.excluded {
+    grid-template-columns: 1fr auto auto;
+    border-left: 3px solid var(--error);
+    opacity: 0.65;
+    cursor: default;
+}
+
+.source-group-header.excluded:hover {
+    opacity: 0.8;
+}
+
+.source-group-header.excluded .source-group-name {
+    color: var(--text-secondary);
+}
+
+.source-excluded-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 1px 6px;
+    border-radius: 9px;
+    font-size: 10px;
+    font-weight: 600;
+    background: var(--tint-error);
+    color: var(--error);
+    white-space: nowrap;
+    flex-shrink: 0;
+}
+
+/* Feed-Zeilen (aufklappbar) */
+.source-group-feeds {
+    display: none;
+    padding-left: 36px;
+    padding-bottom: var(--sp-sm);
+}
+
+.source-group-feeds.expanded {
+    display: block;
+}
+
+.source-feed-row {
+    display: grid;
+    grid-template-columns: 22px 1fr auto auto auto;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: 3px var(--sp-xl) 3px 0;
+    font-size: 12px;
+    color: var(--text-secondary);
+    transition: background 0.15s ease;
+}
+
+.source-feed-row:hover {
+    background: var(--bg-hover);
+    border-radius: var(--radius);
+}
+
+.source-feed-connector {
+    font-family: var(--font-mono);
+    color: var(--text-disabled);
+    font-size: 12px;
+    white-space: pre;
+    user-select: none;
+}
+
+.source-feed-name {
+    font-weight: 500;
+    color: var(--text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.source-feed-url {
+    font-size: 11px;
+    color: var(--text-disabled);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 250px;
+}
+
+/* Block-Button */
+.btn.source-block-btn {
+    color: var(--error);
+    border-color: var(--tint-error-strong);
+}
+
+.btn.source-block-btn:hover {
+    background: var(--tint-error);
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .modal-wide {
+        max-width: 95vw;
+    }
+
+    .modal-content-viewer {
+        max-width: 95vw;
+        height: 90vh;
+    }
+
+    .source-group-header {
+        grid-template-columns: 20px 1fr auto auto;
+    }
+
+    .source-feed-row {
+        grid-template-columns: 22px 1fr auto auto;
+    }
+
+    .source-feed-url {
+        display: none;
+    }
+
+    .sources-add-form-grid {
+        grid-template-columns: 1fr 1fr;
+    }
+}
+
+/* === Lagebild Zeitstempel === */
+.lagebild-timestamp {
+    font-size: 12px;
+    font-weight: 400;
+    color: var(--text-primary);
+    margin-left: auto;
+}
+
+/* === Quellenübersicht Toggle === */
+.source-overview-header-toggle {
+    cursor: pointer;
+    user-select: none;
+}
+
+.source-overview-header-toggle:hover {
+    background: var(--tint-hover-subtle);
+}
+
+.source-overview-toggle-icon {
+    font-size: 11px;
+    color: var(--text-disabled);
+    transition: transform 0.2s ease;
+    margin-left: auto;
+}
+
+.source-overview-card .card-header.source-overview-header-toggle {
+    margin-bottom: 0;
+}
+
+.source-overview-card #source-overview-content:not([style*="none"]) {
+    margin-top: var(--sp-lg);
+}
+
+/* === Quellenübersicht Detailansicht-Button === */
+.btn.btn-secondary.source-detail-btn {
+    font-size: 11px;
+    padding: 3px 10px;
+    margin-left: auto;
+    opacity: 0.7;
+    transition: opacity 0.2s ease;
+}
+
+.source-detail-btn:hover {
+    opacity: 1;
+}
+
+/* === Quellenübersicht Chevron === */
+.source-overview-chevron {
+    font-size: 32px;
+    color: var(--accent);
+    transition: transform 0.2s ease, color 0.2s ease;
+    display: inline-block;
+    flex-shrink: 0;
+}
+
+.source-overview-chevron.open {
+    transform: rotate(90deg);
+}
+
+.source-overview-header-toggle:hover .source-overview-chevron {
+    color: var(--accent);
+}
+
+/* === Theme Toggle Button === */
+.theme-toggle-btn {
+    font-size: 18px;
+    width: 36px;
+    height: 36px;
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    cursor: pointer;
+    transition: background 0.2s, border-color 0.2s;
+}
+
+/* === Light Theme Sonderregeln === */
+[data-theme="light"] .sidebar {
+    border-right: 1px solid var(--border);
+    box-shadow: 1px 0 4px rgba(0, 0, 0, 0.04);
+}
+
+[data-theme="light"] .card {
+    box-shadow: var(--shadow-sm);
+}
+
+[data-theme="light"] .header {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.06);
+}
+
+[data-theme="light"] ::-webkit-scrollbar-track {
+    background: #F0F1F3;
+}
+
+[data-theme="light"] ::-webkit-scrollbar-thumb {
+    background: #C4C9D4;
+}
+
+[data-theme="light"] ::-webkit-scrollbar-thumb:hover {
+    background: #A0A8B8;
+}
+
+[data-theme="light"] .main-content {
+    background: var(--circuit-pattern) repeat, var(--bg-primary);
+    background-size: 300px 300px, auto;
+}
+
+[data-theme="light"] .login-container {
+    background: var(--circuit-pattern) repeat, linear-gradient(135deg, #F4F5F7 0%, #E8EBF0 50%, #F0EDE6 100%);
+    background-size: 300px 300px, auto;
+}
+
+[data-theme="light"] .modal {
+    box-shadow: var(--shadow-lg);
+}
+
+[data-theme="light"] .notification-panel {
+    box-shadow: var(--shadow-lg);
+}
+
+[data-theme="light"] .toast {
+    box-shadow: var(--shadow-md);
+}
+
+[data-theme="light"] .ht-detail-panel {
+    box-shadow: var(--shadow-sm);
+}
+
+/* === gridstack Dashboard-Layout === */
+.grid-stack {
+    min-height: 200px;
+}
+
+.grid-stack > .grid-stack-item > .grid-stack-item-content {
+    overflow: hidden;
+}
+
+.grid-stack-item-content > .card {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.grid-stack-item-content .incident-analysis-summary > #summary-content,
+.grid-stack-item-content .incident-analysis-factcheck > .factcheck-list,
+.grid-stack-item-content #timeline {
+    flex: 1;
+    overflow-y: auto;
+    min-height: 0;
+}
+
+/* Quellenübersicht: Kachel wächst beim Aufklappen via resizeTileToContent */
+.grid-stack-item-content #source-overview-content {
+    overflow-y: auto;
+}
+
+.grid-stack-item-content .incident-analysis-summary,
+.grid-stack-item-content .incident-analysis-factcheck {
+    max-height: none;
+    overflow: hidden;
+}
+
+.grid-stack .card-header {
+    cursor: grab;
+}
+
+.grid-stack .card-header:active {
+    cursor: grabbing;
+}
+
+.grid-stack-item > .ui-resizable-se {
+    width: 16px;
+    height: 16px;
+    opacity: 0;
+    transition: opacity 0.2s;
+}
+
+.grid-stack-item:hover > .ui-resizable-se {
+    opacity: 0.5;
+}
+
+/* Layout-Toolbar */
+.layout-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: var(--sp-md) 0;
+}
+
+.layout-toggles {
+    display: flex;
+    gap: var(--sp-sm);
+}
+
+.layout-toggle-btn {
+    padding: var(--sp-xs) var(--sp-lg);
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    background: transparent;
+    color: var(--text-disabled);
+    font-size: 12px;
+    font-family: var(--font-body);
+    cursor: pointer;
+    transition: all 0.2s;
+    text-decoration: line-through;
+}
+
+.layout-toggle-btn.active {
+    background: var(--tint-accent);
+    color: var(--accent);
+    border-color: var(--accent);
+    text-decoration: none;
+}
+
+.layout-toggle-btn:hover {
+    border-color: var(--accent);
+}
+
+/* Temporäre Messklasse: hebt alle Höhenbeschränkungen auf */
+.grid-stack-item.gs-measuring {
+    height: auto !important;
+}
+
+.gs-measuring > .grid-stack-item-content {
+    height: auto !important;
+    position: relative !important;
+}
+
+.gs-measuring .grid-stack-item-content > .card {
+    height: auto !important;
+}
+
+/* === Barrierefreiheit (A11y) === */
+
+/* Screen-Reader-only: visuell versteckt, für Screenreader sichtbar */
+.sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+/* Skip-Link: bei Tab-Focus sichtbar */
+.skip-link {
+    position: absolute;
+    top: -100%;
+    left: 0;
+    z-index: 10000;
+    padding: 8px 16px;
+    background: var(--accent);
+    color: var(--bg-primary);
+    font-weight: 600;
+    text-decoration: none;
+}
+.skip-link:focus {
+    top: 0;
+}
+
+/* prefers-reduced-motion: alle Animationen deaktivieren */
+@media (prefers-reduced-motion: reduce) {
+    *, *::before, *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+
+/* === Barrierefreiheits-Panel === */
+.a11y-center { position: relative; }
+
+.a11y-btn {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: var(--sp-sm) var(--sp-md);
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.2s ease, background 0.2s ease;
+    width: 36px;
+    height: 36px;
+}
+.a11y-btn:hover { color: var(--accent); background: var(--bg-hover); }
+
+.a11y-panel {
+    position: absolute;
+    top: calc(100% + 8px);
+    right: 0;
+    width: 240px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    z-index: 200;
+    padding: var(--sp-xl);
+}
+
+.a11y-panel-title {
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: var(--sp-lg);
+}
+
+.a11y-option {
+    display: flex;
+    align-items: center;
+    gap: var(--sp-md);
+    padding: var(--sp-sm) 0;
+    cursor: pointer;
+    font-size: 13px;
+    color: var(--text-primary);
+    user-select: none;
+}
+.a11y-option input[type="checkbox"] { display: none; }
+.a11y-option .toggle-switch {
+    flex-shrink: 0;
+}
+.a11y-option input:checked + .toggle-switch {
+    background: var(--accent);
+}
+.a11y-option input:checked + .toggle-switch::after {
+    transform: translateX(16px);
+    background: var(--bg-primary);
+}
+
+/* === A11y: Hoher Kontrast (Dark Theme) === */
+[data-a11y-contrast="true"] {
+    --text-disabled: #B0BDD0;
+    --border: #3A4A66;
+    --input-border: #3A4A66;
+}
+[data-a11y-contrast="true"] .btn-primary {
+    color: #1A1A1A;
+}
+
+/* === A11y: Hoher Kontrast (Light Theme) === */
+[data-a11y-contrast="true"][data-theme="light"] {
+    --accent: #6B5714;
+    --accent-hover: #5A4A11;
+    --text-disabled: #718096;
+    --border: #94A3B8;
+    --input-border: #94A3B8;
+}
+
+/* === A11y: Focus-Hervorhebung === */
+[data-a11y-focus="true"] a:focus,
+[data-a11y-focus="true"] button:focus,
+[data-a11y-focus="true"] input:focus,
+[data-a11y-focus="true"] select:focus,
+[data-a11y-focus="true"] textarea:focus,
+[data-a11y-focus="true"] [tabindex]:focus,
+[data-a11y-focus="true"] [role="button"]:focus {
+    outline: 3px solid var(--accent) !important;
+    outline-offset: 2px !important;
+}
+
+/* === A11y: Größere Schrift === */
+[data-a11y-fontsize="true"] {
+    font-size: 115%;
+}
+
+/* === A11y: Animationen aus === */
+[data-a11y-motion="true"] *,
+[data-a11y-motion="true"] *::before,
+[data-a11y-motion="true"] *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+}