feat(1b): Automatische Notfallerkennung raus → manueller Notruf-Knopf

Die unzuverlässige/intransparente Auto-Erkennung (Stichwörter + LLM) ist
ersatzlos entfernt: emergency.py neu (nur manueller, vom Nutzer bestätigter
Notruf), llm_classifier.py gelöscht, Aufrufe in chat.py/ws.py raus,
emergency_llm_* aus der Config.

Neu: prominenter "🆘 Hilfe rufen"-Knopf (Bestätigung) → POST /api/emergency
→ protokolliert + liefert Hinweis in Nutzersprache. Eskalation (Benachrichtigung
an Angehörige) folgt später; vorerst Platzhalter "ACHTUNG: Es ist noch keine
Benachrichtigung eingebaut." (10 Sprachen). Admin-Tab "Notfälle" → "Notrufe".

Tests: test_emergency_llm.py entfernt, test_quota_safety.py auf Notruf-Endpunkt
umgeschrieben. 208 passed. Live verifiziert.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/safety/emergency.py

@@ -1,140 +1,41 @@
-"""Notfall-Erkennung und Eskalation (Senioren-Kontext).
+"""Manuell ausgelöster Notruf — vom Nutzer bewusst bestätigt.
 
-Zweistufig:
-1. Schnelle Stichwort-Heuristik (`detect` / `handle_emergency`) im Hot-Path -> 0 Latenz.
-2. LLM-Klassifikation (`schedule_llm_emergency_check`) als Hintergrund-Task, der NUR
-   laeuft, wenn die Heuristik nichts fand -> faengt verpasste Formulierungen, ohne die
-   Antwortlatenz zu erhoehen.
+Es gibt KEINE automatische Notfallerkennung (keine Stichwörter, kein LLM): die
+wäre unzuverlässig (Fehlalarme wie verpasste Notfälle) und intransparent. Ein
+Notruf entsteht nur durch eine ausdrückliche Nutzeraktion (Knopf + Bestätigung).
 
-Die erkannten Textauszuege sind hochsensibel und werden bewusst protokolliert
-(DSGVO beachten: Einwilligung, Aufbewahrung, Zugriff).
+Die tatsächliche Benachrichtigung von Angehörigen (SMS/Anruf/Webhook) ist noch
+NICHT implementiert. Bis dahin wird der Notruf protokolliert und der Nutzer
+erhält einen klaren Hinweis in seiner Sprache.
 """
 
-import asyncio
-import logging
-
-import httpx
-
-from app.config import settings, Settings
 from app.metrics import metrics
 
-logger = logging.getLogger(__name__)
-
-# Referenzen auf laufende Hintergrund-Tasks halten (sonst GC-gefaehrdet).
-_pending: set[asyncio.Task] = set()
-
-# Phrasen je Kategorie (de/en), bewusst eher spezifisch gegen Fehlalarme.
-_PATTERNS: dict[str, list[str]] = {
-    "medical": [
-        "brustschmerz", "schmerzen in der brust", "kann nicht atmen", "keine luft",
-        "atemnot", "herzinfarkt", "schlaganfall", "bewusstlos", "gestuerzt", "gestürzt",
-        "gefallen und komme nicht hoch", "starke blutung",
-        "chest pain", "can't breathe", "cannot breathe", "heart attack", "stroke",
-        "i fell and can't", "bleeding badly",
-    ],
-    "self_harm": [
-        "nicht mehr leben", "mich umbringen", "selbstmord", "suizid", "will sterben",
-        "kill myself", "end my life", "suicide", "want to die",
-    ],
-    "help": [
-        "notruf", "notarzt", "krankenwagen", "ruf einen arzt", "es brennt",
-        "call an ambulance", "call 911", "call 112",
-    ],
+# Platzhalter-Hinweis je Sprache, solange die Eskalation noch nicht gebaut ist.
+_NO_NOTIFY_NOTICE: dict[str, str] = {
+    "de": "ACHTUNG: Es ist noch keine Benachrichtigung eingebaut.",
+    "en": "ATTENTION: No notification has been set up yet.",
+    "fr": "ATTENTION : aucune notification n'est encore configurée.",
+    "es": "ATENCIÓN: todavía no se ha configurado ninguna notificación.",
+    "it": "ATTENZIONE: non è ancora stata configurata alcuna notifica.",
+    "pt": "ATENÇÃO: ainda não há nenhuma notificação configurada.",
+    "pl": "UWAGA: Nie skonfigurowano jeszcze żadnego powiadomienia.",
+    "ar": "تنبيه: لم يتم إعداد أي إشعار بعد.",
+    "ru": "ВНИМАНИЕ: Уведомление пока не настроено.",
+    "zh": "注意：尚未设置任何通知。",
 }
 
 
-def detect(text: str):
-    """Liefert (category, matched_phrase) oder None."""
-    if not text:
-        return None
-    low = text.lower()
-    for category, phrases in _PATTERNS.items():
-        for phrase in phrases:
-            if phrase in low:
-                return category, phrase
-    return None
+def notify_notice(language: str | None) -> str:
+    """Liefert den Platzhalter-Hinweis in der Nutzersprache (Fallback Deutsch)."""
+    return _NO_NOTIFY_NOTICE.get((language or "de").lower(), _NO_NOTIFY_NOTICE["de"])
 
 
-async def _fire_webhook(url: str, user, category: str, snippet: str) -> None:
-    try:
-        async with httpx.AsyncClient(timeout=5) as client:
-            await client.post(
-                url,
-                json={
-                    "user_id": user.id,
-                    "display_name": user.display_name,
-                    "category": category,
-                    "text": snippet,
-                },
-            )
-    except Exception:  # noqa: BLE001 - best effort, darf den Chat nicht brechen
-        metrics.inc("emergency_webhook_error_total")
+def record_manual_emergency(user, store, language: str | None = None) -> dict:
+    """Protokolliert einen vom Nutzer bestätigten Notruf und liefert den Hinweis.
 
-
-def _escalate(user, category: str, snippet: str, store, cfg: Settings, source: str) -> None:
-    """Protokolliert + eskaliert einen erkannten Notfall (Log, Metrik, Webhook)."""
-    store.log_emergency(user.id, category, snippet)
-    metrics.inc("emergency_total", {"category": category, "source": source})
-    if cfg.emergency_webhook_url:
-        try:
-            asyncio.get_running_loop().create_task(
-                _fire_webhook(cfg.emergency_webhook_url, user, category, snippet)
-            )
-        except RuntimeError:
-            pass  # kein laufender Event-Loop (z. B. im Test) -> Webhook ueberspringen
-
-
-def handle_emergency(user, text: str, store, cfg: Settings = settings):
-    """Stufe 1: Stichwort-Heuristik. Erkennt, protokolliert und eskaliert sofort.
-
-    Gibt {"category", "matched"} zurueck, wenn etwas erkannt wurde, sonst None.
-    Der Webhook (falls konfiguriert) wird nicht-blockierend ausgeloest.
+    Eskalation (Benachrichtigung) folgt später; hier wird nur protokolliert.
     """
-    match = detect(text)
-    if not match:
-        return None
-    category, phrase = match
-    _escalate(user, category, text[:500], store, cfg, source="keyword")
-    return {"category": category, "matched": phrase}
-
-
-async def _llm_check(user, text: str, store, cfg: Settings, on_emergency) -> None:
-    """Hintergrund: LLM-Klassifikation + Eskalation (best-effort)."""
-    try:
-        from app.safety.llm_classifier import classify_emergency
-
-        result = await classify_emergency(text, cfg)
-        if not result:
-            return
-        category = result["category"]
-        _escalate(user, category, text[:500], store, cfg, source="llm")
-        logger.info(
-            "llm-emergency: %s (conf=%.2f) fuer %s", category, result["confidence"], user.id
-        )
-        if on_emergency is not None:
-            await on_emergency(category)
-    except Exception:  # best-effort: darf den Turn nie brechen
-        logger.exception("llm-emergency-check fehlgeschlagen (ignoriert)")
-
-
-def schedule_llm_emergency_check(user, text: str, store, keyword_hit,
-                                 cfg: Settings = settings, on_emergency=None):
-    """Stufe 2: plant die LLM-Klassifikation als Hintergrund-Task.
-
-    Laeuft NUR, wenn die Stichwort-Heuristik nichts fand (`keyword_hit` ist None) und
-    die LLM-Stufe aktiviert ist. `on_emergency(category)` (async) wird bei Treffer
-    aufgerufen (z. B. WS-Event). Gibt den Task zurueck oder None - blockiert nie.
-    """
-    if keyword_hit is not None or not cfg.emergency_llm_enabled:
-        return None
-    if not text or not text.strip():
-        return None
-    try:
-        task = asyncio.get_running_loop().create_task(
-            _llm_check(user, text, store, cfg, on_emergency)
-        )
-    except RuntimeError:
-        return None  # kein laufender Event-Loop (z. B. Test) -> ueberspringen
-    _pending.add(task)
-    task.add_done_callback(_pending.discard)
-    return task
+    store.log_emergency(user.id, "manual", "Vom Nutzer ausgelöster Notruf")
+    metrics.inc("emergency_total", {"category": "manual", "source": "user"})
+    return {"category": "manual", "notice": notify_notice(language)}

app/safety/llm_classifier.py

@@ -1,96 +0,0 @@
-"""LLM-Notfall-Klassifikation (zweite Stufe der Notfall-Erkennung).
-
-Ergaenzt die schnelle Stichwort-Heuristik (`app.safety.emergency.detect`) um einen
-LLM-Klassifikator, der Formulierungen erkennt, die keine Stichwoerter treffen.
-
-Bewusst **best-effort** und mit Konfidenz-Schwelle (sensibler Senioren-Kontext):
-Ein LLM-Fehler oder kaputtes JSON fuehrt nie zu einem Alarm und nie zu einem Fehler
-im Antwort-Turn.
-"""
-
-import json
-import logging
-import re
-
-from app.config import Settings, settings
-
-logger = logging.getLogger(__name__)
-
-# Gueltige Notfall-Kategorien (deckungsgleich mit der Stichwort-Heuristik).
-VALID_CATEGORIES = {"medical", "self_harm", "help"}
-
-_SYSTEM_PROMPT = (
-    "Du bist ein Sicherheits-Klassifikator fuer einen Senioren-Sprachassistenten. "
-    "Beurteile, ob die Nutzeraeusserung einen akuten Notfall beschreibt. Kategorien: "
-    "'medical' (akute medizinische Notlage, z. B. Brustschmerz, Atemnot, Sturz, "
-    "Schlaganfall), 'self_harm' (Suizidalitaet/Selbstgefaehrdung), 'help' (akuter "
-    "Hilferuf, z. B. Feuer, Notruf), 'none' (kein Notfall). Antworte AUSSCHLIESSLICH "
-    "mit JSON: {\"category\": \"medical|self_harm|help|none\", \"confidence\": 0.0-1.0, "
-    "\"reason\": \"kurze Begruendung\"}. Sei zurueckhaltend: nur echte, akute Notlagen "
-    "sind ein Notfall, keine beilaeufigen Erwaehnungen oder Vergangenes."
-)
-
-
-def _build_classifier_llm(cfg: Settings):
-    """Baut eine eigene LLM-Instanz fuer die Klassifikation (eigener JSON-Prompt)."""
-    provider = cfg.emergency_llm_provider or cfg.default_llm_provider
-    if provider == "local-openai-compatible":
-        from app.providers.llm.local_openai_compatible import LocalOpenAICompatibleLLM
-
-        return LocalOpenAICompatibleLLM(
-            cfg.local_llm_base_url,
-            cfg.local_llm_api_key,
-            cfg.local_llm_model,
-            system_prompt=_SYSTEM_PROMPT,
-            disable_reasoning=True,
-            max_tokens=128,
-            temperature=0.0,
-        )
-
-    from app.dependencies import get_llm_provider
-
-    return get_llm_provider(provider, cfg)
-
-
-def parse_classification(raw: str) -> dict | None:
-    """Liest {category, confidence, reason} aus der (evtl. verrauschten) LLM-Antwort."""
-    if not raw:
-        return None
-    match = re.search(r"\{.*\}", raw, re.DOTALL)
-    if not match:
-        return None
-    try:
-        data = json.loads(match.group(0))
-    except ValueError:
-        return None
-    if not isinstance(data, dict):
-        return None
-    category = data.get("category")
-    if category not in VALID_CATEGORIES:
-        return None
-    try:
-        confidence = float(data.get("confidence", 0.0))
-    except (TypeError, ValueError):
-        confidence = 0.0
-    return {
-        "category": category,
-        "confidence": confidence,
-        "reason": str(data.get("reason", "")),
-    }
-
-
-async def classify_emergency(text: str, cfg: Settings = settings) -> dict | None:
-    """Klassifiziert eine Aeusserung. Liefert {category, confidence, reason} oder None.
-
-    None bedeutet: kein Notfall (bzw. unter der Konfidenz-Schwelle / nicht parsebar).
-    """
-    if not text or not text.strip():
-        return None
-    llm = _build_classifier_llm(cfg)
-    raw = await llm.complete(text)
-    result = parse_classification(raw)
-    if result is None:
-        return None
-    if result["confidence"] < cfg.emergency_llm_min_confidence:
-        return None
-    return result