Add adaptive learning and model rollback

Merge pull request v0.5.0 behavior learning and safe activation (#32)

.gitea/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,33 @@
+---
+name: Fehler
+about: Reproduzierbaren SillyHome-Fehler melden
+title: "BUG: "
+---
+
+## Beobachtet
+
+Was ist tatsächlich passiert?
+
+## Erwartet
+
+Was sollte passieren?
+
+## Aktor und Kontext
+
+- Aktor:
+- Trigger/Kontext:
+- SillyHome-Modus:
+- Passende HA-Automation und Zustand:
+
+## Nachweise
+
+- Version:
+- Relevante Logs:
+- `activation_reason`:
+- `prediction.execution_reason`:
+
+## Reproduktion
+
+1.
+2.
+3.

.gitea/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,25 @@
+## Ziel
+
+Welches konkrete Verhalten ändert sich?
+
+## Umsetzung
+
+- 
+
+## Sicherheit
+
+- Backup/Rollback:
+- Auswirkung auf bestehende HA-Automationen:
+- Shadow/Active-Verhalten:
+
+## Verifikation
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+```
+
+- Live-Health:
+- Live-Aktor:

AGENTS.md

@@ -0,0 +1,50 @@
+# AGENTS.md
+
+Diese Datei ist die kurze Arbeitsanweisung für Menschen und kleine Coding-Modelle.
+
+## Reihenfolge
+
+1. `README.md` lesen.
+2. Für Verhaltenslogik `docs/BEHAVIOR_ENGINE.md` lesen.
+3. Für Fehler `docs/DEBUGGING.md` abarbeiten.
+4. Für HA-Automationen `docs/CONTROL_HANDOFF.md` lesen.
+5. Vor Release oder Live-Update `docs/OPERATIONS.md` vollständig abarbeiten.
+
+## Verbindliche Regeln
+
+- Erst Zustand und Logs prüfen, dann Ursache formulieren, dann ändern.
+- Keine Annahme als Fakt darstellen.
+- Vor Live-Änderungen Backup oder klaren Rollback-Punkt erstellen.
+- Bestehende Nutzeränderungen nicht zurücksetzen.
+- Kleine, fokussierte Änderungen mit passenden Tests.
+- Eigene SillyHome-Schaltungen niemals als neues Nutzerverhalten lernen.
+- Ein Aktor darf nicht unbeabsichtigt ohne Steuerung bleiben:
+  - SillyHome aktiv: passende HA-Automation darf pausiert sein.
+  - SillyHome Shadow: HA-Automation muss auf Wunsch fortgesetzt werden können.
+- Keine Secrets in Code, Dokumentation, Commits oder Logs.
+
+## Pflichtprüfung
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+```
+
+## Versionsstellen
+
+Bei jedem Release dieselbe Version setzen:
+
+- `pyproject.toml`
+- `addon/config.yaml`
+- `app/main.py`
+- `CHANGELOG.md`
+
+Danach prüfen:
+
+```bash
+grep -R 'version.*0\\.7\\.0' -n pyproject.toml addon/config.yaml app/main.py
+```
+
+Die konkrete Zielversion im Befehl anpassen.

ARCHITECTURE.md

@@ -11,10 +11,13 @@ Autonomes Schalten wird separat pro Aktor freigegeben.
 - Lokal-first und datensparsam; keine Cloudpflicht.
 - Trennung von Datenintegration, Kontextzuordnung, Verhaltenslernen,
   Vorhersage und Aktorausführung.
-- Logbook-basierte Herkunftserkennung; bekannte Automationen und eigene
+- Logbook-basierte Herkunftserkennung; eindeutig erkannte HA-Automationen
-  Schaltungen werden nicht als Nutzerhandlungen trainiert.
+  zählen wie manuelle Bedienungen. Eigene SillyHome-Schaltungen werden nicht
+  zurückgelernt.
 - Ausführung nur für freigegebene, reversible Domains und Zustände sowie mit
-  Konfidenzschwelle und Cooldown.
+  Konfidenzschwelle und zustandsbezogenem Cooldown.
+- Eindeutig passende HA-Automationen können bei einer SillyHome-Übernahme
+  pausiert und beim Rückfall in den Shadow-Modus wieder fortgesetzt werden.
 - Standardintegration über die lokale Home-Assistant-REST-API.
 - Persistenz als atomische lokale Modell- und Aktorartefakte.
 - Deployment als Home-Assistant-Add-on oder über Docker Compose.

CHANGELOG.md

@@ -1,5 +1,306 @@
 # Changelog
 
+## 1.2.0 - 2026-06-17
+- Automatische Sensor-Gewichtungsanpassung aus Nutzerfeedback:
+  korrektes Feedback staerkt aktuelle Kontextsignale leicht, falsches Feedback
+  wertet sie vorsichtig ab.
+- Modell-Snapshots mit aktivem Modellstand und Rollback-API ergaenzt.
+- Dashboard zeigt Modell-Snapshots, Rollback, Zeitprofile,
+  adaptive Gewichtungsupdates und Automation-Konflikte.
+- Automation-Refresh markiert Konflikte, wenn SillyHome aktiv ist und passende
+  HA-Automationen parallel aktiv bleiben.
+- Zeitprofile fuer Nacht, Morgen, Tag, Abend und Wochenende werden aus
+  gelernten Handlungen gebildet.
+
+## 1.1.0 - 2026-06-17
+- Dashboard als Einrichtungs- und Visualisierungszentrale erweitert:
+  Job-Queue, Sicherheitsprofil, Entscheidungsakte, Wissen/Annahmen/
+  Unsicherheiten und Beitragsfaktoren pro Aktor.
+- Lokales Safety-Profil pro Aktor eingefuehrt: manuelle Sperre,
+  Freigabestufe, Mindest-Confidence und optionaler Cooldown werden vor
+  autonomem Schalten ausgewertet.
+- Sofort-Schaltpfad bleibt schnell: Safety prueft nur lokale Daten; der
+  Home-Assistant-Serviceaufruf wird nicht durch Discovery, Training oder
+  Statistik blockiert.
+- Sichtbare Job-Queue fuer Discovery, Reconciliation, Training, Evaluation
+  und Automation-Refresh mit Status, Dauer, Fehler und Zusammenfassung.
+- Entscheidungsstatistik erweitert: Sensor-/Kontextfaktoren, aktive
+  Gewichtungen, Sample-/Confidence-Trends und Feedbackzaehler werden
+  persistiert.
+
+## 1.0.5 - 2026-06-17
+- Lange Friendly Names, Entity-IDs, Chips, Tabellenwerte und Metriken brechen
+  im Dashboard responsiv um und laufen nicht mehr aus Karten oder Boxen.
+- Automatisierter Performance-Budget-Test fuer Root-HTML und
+  `/v1/actuators/dashboard` gegen das 5-Sekunden-Limit ergaenzt.
+- HA-/Ingress-Verifikation mit Supervisor-Status, Backup, Watchdog,
+  Hard-Reload und Rollback im Operating Guide dokumentiert.
+
+## 1.0.4 - 2026-06-17
+- Sensor-Relevanz ist in der Aktor-Detailansicht sichtbar: automatische
+  Relevanz, aktive Gewichtung und Score werden pro verwendetem Sensor/Zustand
+  angezeigt.
+- Gewichtungen koennen im Dashboard korrigiert und per API unter
+  `/v1/actuators/{actuator_entity_id}/weights` gespeichert werden.
+- Gruppen-Gewichtungen buendeln mehrere Sensoren/Zustaende fuer einen Aktor,
+  damit verbundene Kontextsignale gemeinsam bewertet werden koennen.
+
+## 1.0.3 - 2026-06-17
+- Header-Menue als Pulldown umgesetzt; die separate Navigationsleiste entfaellt.
+- Geraetegruppen und manuelle Kontextbereiche sind standardmaessig geschlossen.
+- Dashboard startet in Phasen: leere Bedienoberflaeche, dann Status, danach
+  Geraetedaten.
+- Detailansicht oeffnet streamartiger: zuerst Basis-Shell, dann Aktorwerte,
+  danach Kontextvorschlaege.
+
+## 1.0.2 - 2026-06-17
+- v1.0-Abnahme als `docs/V1_0_ACCEPTANCE.md` dokumentiert: erledigte,
+  teilweise erledigte und offene v1.0.x-Punkte sind getrennt sichtbar.
+- Dashboard-Startstatistik erweitert: Freigabebereitschaft, Aktiv/Shadow,
+  Gelernt/Wartet und gelernte Handlungen werden direkt im Startbereich
+  zusammengefasst.
+
+## 1.0.1 - 2026-06-17
+- Dashboard-UI nach v1-Korrektur neu strukturiert: feste Steuerungsleiste,
+  separate Geräteübersicht, klare Freigabe-/Detailfläche und Statusbereich.
+- Orange bleibt Primärfarbe; Cyan ist die sichtbare Komplementärfarbe. Rote
+  Aktions- und Fehlerflächen wurden aus der Oberfläche entfernt.
+- Startpfad weiter beschleunigt: Dashboard lädt nur noch lokale Startdaten.
+  HA-Discovery, Vorschläge und Automation-Refresh laufen erst nach Nutzeraktion.
+- Detailansicht öffnet ohne automatische Automation-Discovery. Passende
+  Automationen können gezielt per Button neu gesucht werden.
+
+## 1.0.0 - 2026-06-17
+- Neuer blockweiser Dashboard-Start über `/v1/actuators/dashboard`: lokale
+  Store-/Cache-Daten laden sofort, HA-Discovery und Vorschläge laufen
+  nachgelagert.
+- Discovery liest Entities pro Anfrage nur noch einmal und klassifiziert aus
+  diesem Snapshot weiter. Dadurch entfallen doppelte HA-Vollabfragen.
+- Persistenter JSON-Entity-Cache wird für Friendly Name, Raum, Gerät,
+  Discovery-Gruppen und schnelle Summaries genutzt.
+- Dashboard mit Orange als Primärfarbe, kompakter Navigation, aufklappbarer
+  Anleitung, aufklappbaren Gerätegruppen und Cache-/Systemstatistik.
+- Aktor-/Sensor-Kategorien erweitert: Feuchte, Wetter, Helligkeit, Bewegung,
+  Tür/Fenster, Präsenz, Lichtzustände, Schalter, Steckdosen, Lüftung, Heizung,
+  Cover, Helper, PV/Akku/Einspeisung.
+- Kontextvorschläge vermeiden weitere doppelte HA-Discovery und sortieren
+  aktortypbezogen nach relevanten Bereichen.
+
+## 0.7.21 - 2026-06-17
+- Dashboard-Ladepfad getrennt: beobachtete Geräte laden sofort über
+  `/v1/actuators/summary`; Status, Discovery und Vorschläge laufen unabhängig
+  nachgelagert und blockieren die Übersicht nicht mehr.
+- Systemstatus nutzt Timeouts und bleibt auch bei langsamem ML-/HA-Status
+  bedienbar.
+- HA-Entity-Metadaten werden als JSON-Cache gespeichert und für Friendly Name,
+  Raum und Gerät in schlanken Summaries wiederverwendet.
+- Anleitung, Gerätegruppen und manuelle Kontextauswahl sind aufklappbar und
+  kompakter für Smartphone- und Desktopansichten.
+
+## 0.7.20 - 2026-06-17
+- Dashboard-Übersicht ist kompatibel mit dem leichten Summary-Format und greift
+  nicht mehr auf `record.behavior.status` aus dem Vollformat zu.
+
+## 0.7.19 - 2026-06-17
+- Dashboard-Übersicht nutzt einen leichten `/v1/actuators/summary`-Endpunkt
+  statt voller Lernmuster und kompletter HA-Entityliste.
+- Nach Aktionen werden Dashboard-Caches gezielt invalidiert, damit keine
+  stale oder doppelt geladenen Einträge entstehen.
+
+## 0.7.18 - 2026-06-16
+- Dashboard lädt Aktoren, Entities und Discovery nur noch einmal pro Refresh und
+  rendert daraus Auswahl und Übersicht ohne doppelte API-Ladewege.
+- Manuelle Kontext-Evidenz wird dedupliziert, damit Hinweise wie
+  "Manuell vom Nutzer als relevant festgelegt" nicht mehrfach erscheinen.
+- Kontextauswahl ist vollständiger: Feuchte, Wetter, Licht-/Schalterzustände,
+  Bewegungs-/Tür-/Präsenzmelder, PV/Akku/Einspeisung und Helper werden sauberer
+  kategorisiert und per Suche/Kategorie erreichbar.
+- Domainspezifische Zuordnung geschärft: Lüftungen bevorzugen Feuchte/Temperatur,
+  Lichter Helligkeit/Bewegung/Tür/Präsenz, Heizungen Temperatur/Anwesenheit/Wetter.
+
+## 0.7.17 - 2026-06-16
+- WebSocket-Eventpfad ist schneller: irrelevante HA-State-Changes werden vor
+  dem teuren State-Cache-Listenbau verworfen.
+- WebSocket nutzt Keepalive und reconnectet nach Abbrüchen nach 1s statt 5s.
+
+## 0.7.16 - 2026-06-16
+- Beobachtete Aktoren werden in der Übersicht nach Raum oder Typ gruppiert und
+  mit Friendly Name angezeigt.
+
+## 0.7.15 - 2026-06-16
+- Add-on-Start ist robust gegen Home-Assistant-Core-502 beim Systemboot:
+  API und WebSocket-Listener starten trotzdem, Reconciliation/Training werden
+  im Hintergrund mit Retry nachgeholt.
+- Periodische Reconciliation und Fallback-Auswertung beenden den Dienst nicht
+  mehr bei temporären HA-Fehlern.
+- Add-on-Watchdog prüft `/health`, damit Supervisor den Dienst nach Absturz
+  wieder starten kann.
+
+## 0.7.14 - 2026-06-16
+- Onboarding-Vorschläge laden im Dashboard nachgelagert, damit Status,
+  Aktor-Auswahl und bestehende Geräte nicht auf Automation-Discovery warten.
+
+## 0.7.13 - 2026-06-16
+- Diagnose-/Schutzsensoren wie Überhitzung und Überlast werden nicht mehr nur
+  wegen gleicher Strom-/Monitoring-Bereiche automatisch als Lichtkontext
+  übernommen.
+- Verwendete Kontext-Entities können pro Aktor direkt entfernt und damit als
+  manuelle Zuordnung überschrieben werden.
+- Onboarding-Vorschläge zeigen passende, noch nicht eingerichtete Aktoren aus
+  bestehenden Automationen und naheliegenden Kontexten.
+- TV-/Medien-Aktoren über `media_player` und Fernbedienungen über `remote`
+  werden in Discovery und Auswahl berücksichtigt.
+
+## 0.7.12 - 2026-06-16
+- Aktor-Auswahlliste zeigt maximal 50 Treffer gleichzeitig und fordert bei
+  größeren Mengen zum Eingrenzen per Suche oder Typfilter auf.
+
+## 0.7.11 - 2026-06-16
+- Aktor-Discovery erkennt weitere steuerbare HA-Domains wie Buttons, Helper,
+  Heizungen, Schlösser, Ventile und numerische Helper.
+- Aktor-Auswahl dedupliziert Licht-/Schalter-Doppelungen pro Gerät und gruppiert
+  zusätzliche Typen im Dashboard.
+- Discovery liefert Kategorien für Mess-, Binär-, Kontext- und Aktor-Entities.
+- Nutzerfeedback kann Vorhersagen als korrekt oder falsch markieren und direkt
+  als Lernsignal speichern.
+
+## 0.7.10 - 2026-06-16
+- WebSocket-State-Changes aktualisieren einen internen Home-Assistant-State-
+  Cache und werten Aktoren direkt gegen diesen frischen Event-Zustand aus.
+- Event-Auswertungen lösen keine REST-Statusabfrage mehr aus, bevor sie
+  aktive Aktoren schalten.
+
+## 0.7.9 - 2026-06-15
+- Event-basierte Vorhersagen verwenden den frischen Sensorzustand direkt aus
+  dem Home-Assistant-WebSocket-Event, damit Kontextwechsel ohne REST-Race sofort
+  bewertet und geschaltet werden können
+- Regressionstest stellt sicher, dass ein Türsensor-Event trotz veraltetem
+  HA-Snapshot direkt `light.turn_on` auslöst
+
+## 0.7.8 - 2026-06-15
+- Home-Assistant-WebSocket-Listener deaktiviert den clientseitigen Keepalive-
+  Ping, damit stabile HA-Verbindungen nicht durch Ping-Timeouts ständig neu
+  aufgebaut werden
+- Fallback-Auswertung läuft bei getrenntem WebSocket kurzfristig alle 5 Sekunden,
+  damit übernommene Aktoren nicht ohne Steuerung bleiben
+
+## 0.7.7 - 2026-06-15
+- WebSocket-State-Changes lesen jetzt das echte Home-Assistant-Eventformat
+  (`event.data.entity_id`), damit Kontextwechsel wie Türsensoren sofort
+  Vorhersagen und Schaltungen auslösen statt erst beim nächsten Statusabruf
+
+## 0.7.6 - 2026-06-14
+- Kontextvorschläge blenden zusätzlich Batterie-, Status-, Node-, Last-Seen-
+  und Basic-Entities aus, sofern sie nicht bewusst manuell ausgewählt wurden
+
+## 0.7.5 - 2026-06-14
+- Kontextvorschläge weiter geschärft: Standardliste zeigt nur gleiche Räume,
+  gemeinsame Geräte/Tokens oder echte globale Außenwerte
+- Diagnosewerte wie MQTT-, WiFi-, Restart- und Connect-Zähler werden nicht mehr
+  als fachliche Kontextvorschläge angeboten
+
+## 0.7.4 - 2026-06-14
+- Kontext-Auswahl liefert jetzt aktorbezogene Vorschläge statt einer pauschalen
+  Roh-Liste aller Sensoren und Zustände
+- Dashboard-Auswahl für Aktoren und Kontext nach Typ/Kategorie gruppiert und
+  durchsuchbar; lange Listen werden begrenzt statt mobil unbedienbar zu werden
+- Manuelle Entity-ID-Eingabe ergänzt, damit relevante Sensoren auch ohne
+  Dropdown-Treffer gespeichert werden können
+- Irrelevante System-/VPN-/pfSense-Sensoren tauchen bei Lichtaktoren ohne
+  fachlichen Bezug nicht mehr als Standardvorschläge auf
+
+## 0.7.3 - 2026-06-14
+- Automatische Kontextzuordnung ignoriert generische Bereiche wie `Monitoring`,
+  damit System-/Disk-/Überhitzungssensoren nicht fälschlich Lichtaktoren erklären
+- Aktor-Auswahl auf tatsächlich sicher steuerbare Domains begrenzt:
+  `light`, `switch`, `cover`, `fan`, `humidifier`
+- Neue manuelle Kontext-Zuordnung pro Aktor: Haupt-Messsensor optional setzen und
+  mehrere relevante Kontext-Entities wie PIR, Außenhelligkeit, Luftfeuchtigkeit
+  oder andere Lichtzustände auswählen
+- Dashboard-Dropdown durch echtes Select plus Suche ersetzt; mobile Bedienung und
+  Aktor-Details enthalten Speichern/Neu-laden-Aktionen für manuelle Kontextwahl
+
+## 0.7.2 - 2026-06-14
+- Home-Assistant-Entity-Metadaten werden in Batches gelesen, damit große HA-
+  Installationen nicht mehr am Template-Ausgabe-Limit scheitern
+- Nicht über die HA-Config-API exponierte Automationen werden leise übersprungen,
+  statt wiederholt Warnungen in die Logs zu schreiben
+- Dashboard für mobile Nutzung optimiert: Sticky-Schnellnavigation, Karten statt
+  breiter Tabelle, größere Touch-Ziele und bessere Detail-/Menüführung
+- WebSocket-Status ist direkt im Dashboard-Systemstatus sichtbar
+
+## 0.7.1 - 2026-06-14
+- Event-basierter Home-Assistant-WebSocket-Listener authentifiziert sich jetzt
+  mit dem echten HA-WebSocket-Protokoll (`auth_required` -> `auth` -> `auth_ok`)
+- Kompatibilität mit aktuellen `websockets`-Versionen wiederhergestellt
+- WebSocket-Healthcheck und Event-Listener-Tests laufen ohne zusätzliches
+  Async-Pytest-Plugin
+- Add-on-Version angehoben, damit Home Assistant das aktualisierte Image baut
+
+## 0.7.0 - 2026-06-14
+- Freie Eingabe von Home-Assistant-Entitätsnamen mit Vorschlagsliste
+- Freigabestatus und Blockadegrund sind in Übersicht und Details immer sichtbar
+- Vorhersagen erklären konkret, warum sie ausgeführt oder nicht ausgeführt wurden
+- Cooldown blockiert nur Wiederholungen desselben Zielzustands; Gegenaktionen
+  wie `Licht an` gefolgt von `Licht aus` bleiben sofort möglich
+- Passende HA-Automationen werden aus ihren echten Konfigurationen erkannt und
+  können pausiert oder fortgesetzt werden
+- Sichere Steuerungsübergabe: SillyHome kann übernehmen und passende
+  HA-Automationen pausieren; beim Stoppen können sie gezielt fortgesetzt werden
+- Dashboard wird ohne Browser-Cache ausgeliefert
+- Reproduzierbare Runbooks für Debugging, Berechnung, Entwicklung, Tests,
+  Release, Add-on-Update, Live-Verifikation und Rollback
+
+## 0.6.2 - 2026-06-14
+- Eindeutig im Home-Assistant-Logbuch erkannte Automationen und Scripts zählen für
+  Lernen und Freigabe gleichwertig wie manuelle Bedienungen
+- Automationsmuster erhalten dieselbe Modellgewichtung wie manuelle Handlungen
+- Oberfläche zeigt die gemeinsame Zahl als `eindeutig geregelt`; eine
+  ausdrückliche Aktivierung pro Aktor bleibt weiterhin erforderlich
+
+## 0.6.1 - 2026-06-14
+- Manuelle Prüfung als `Aktuelle Situation auswerten` eindeutig von Simulation
+  oder Aktorschaltung abgegrenzt
+- Sichtbare Rückmeldung mit Prüfzeitpunkt, vorhergesagtem Zustand und Sicherheit
+  oder klarem Hinweis auf einen fehlenden frischen Sensorwechsel
+
+## 0.6.0 - 2026-06-14
+- Kausales Shadow-Lernen erkennt frische Kontextwechsel unmittelbar vor einer
+  Aktorhandlung, etwa `Tür geschlossen → offen` vor `Licht aus → an`
+- Historische Home-Assistant-Automationen dürfen Vorhersagen begründen, zählen
+  aber weiterhin niemals als eindeutige Benutzerhandlung oder Ausführungsfreigabe
+- Aktuelle `last_changed`-Zeitpunkte verhindern Vorhersagen aus längst
+  unveränderten Sensorzuständen
+- Oberfläche trennt gelernte Benutzerhandlungen und erkannte HA-Automationen
+
+## 0.5.4 - 2026-06-14
+- Tür-, Bewegungs- und andere belastbare Kontextsensoren werden auch ohne
+  numerischen Sensor als vollständige automatische Kontextzuordnung angezeigt
+- Status und Zuordnungssicherheit bilden das aktive Verhaltenslernen ab statt
+  eines optionalen numerischen Modells
+- Ausführungsfreigabe erscheint erst, wenn genügend eindeutig manuelle
+  Bedienungen vorliegen; bis dahin nennt die Oberfläche die noch fehlende Anzahl
+
+## 0.5.3 - 2026-06-14
+- Verhindert fachlich falsche Sensorzuordnungen nur aufgrund generischer Namen wie
+  `Licht` oder `Lichtschalter`
+- Übernimmt numerische Sensoren nur noch bei einem belastbaren absoluten Score und
+  einer eindeutigen Abgrenzung zum zweitbesten Kandidaten
+- Begrenzt Zusatzkontext auf relevante Sensoren und bevorzugt bei Lichtaktoren
+  echte Beleuchtungsstärke gegenüber fremden Leistungs- oder Energiezählern
+
+## 0.5.2 - 2026-06-14
+- Add-on-Build invalidiert den Docker-Cache bei jeder Versionsänderung, damit
+  Versionsmetadaten und tatsächlich ausgelieferter Anwendungscode übereinstimmen
+- Korrigierte Ingress-Oberfläche aus 0.5.1 dadurch erstmals zuverlässig ausgeliefert
+
+## 0.5.1 - 2026-06-14
+- Technische Modell-, Intervall- und Sicherheitsparameter aus der normalen
+  Home-Assistant-Add-on-Konfiguration entfernt; sichere Standardwerte bleiben aktiv
+- Ingress um einen klaren Ablauf mit Aktorauswahl, Beobachtungsphase und späterer
+  Ausführungsfreigabe ergänzt
+- Bedienelemente und Diagnosen in verständlicher Alltagssprache erklärt
+
 ## 0.5.0 - 2026-06-14
 - Ingress auf reine Aktorauswahl, automatischen Lernstatus und Vorhersagen reduziert
 - Automatische Kontextzuordnung ohne Sensor-Overrides oder Review-Blockade

README.md

@@ -1,6 +1,25 @@
 # SillyHome Next
 
-Lokaler, datenschutzfreundlicher API-Prototyp für Home Assistant.
+SillyHome lernt aus Home Assistant, sagt Aktorhandlungen voraus und darf sie
+nach einer ausdrücklichen Freigabe ausführen.
+
+## Schnell orientieren
+
+- Fehler finden: [`docs/DEBUGGING.md`](docs/DEBUGGING.md)
+- Berechnung verstehen: [`docs/BEHAVIOR_ENGINE.md`](docs/BEHAVIOR_ENGINE.md)
+- Steuerung übernehmen/zurückgeben:
+  [`docs/CONTROL_HANDOFF.md`](docs/CONTROL_HANDOFF.md)
+- Entwickeln, testen, veröffentlichen und installieren:
+  [`docs/OPERATIONS.md`](docs/OPERATIONS.md)
+- Version 1.0.0 bedienen und prüfen:
+  [`docs/V1_0_0_OPERATING_GUIDE.md`](docs/V1_0_0_OPERATING_GUIDE.md)
+- Version 1.0.x Abnahme und offene Punkte:
+  [`docs/V1_0_ACCEPTANCE.md`](docs/V1_0_ACCEPTANCE.md)
+- Version 1.1.0 Safety, Transparenz und Job-Queue:
+  [`docs/V1_1_0_OPERATING_GUIDE.md`](docs/V1_1_0_OPERATING_GUIDE.md)
+- Version 1.2.0 adaptive Gewichtung, Rollback und Profile:
+  [`docs/V1_2_0_OPERATING_GUIDE.md`](docs/V1_2_0_OPERATING_GUIDE.md)
+- Arbeitsregeln für Coding-Agenten: [`AGENTS.md`](AGENTS.md)
 
 ## Reifegrad
 
@@ -47,6 +66,8 @@ uvicorn app.main:app --reload
 - `http://127.0.0.1:8000/v1/discovery` - klassifizierte, filterbare Entities
 - `http://127.0.0.1:8000/v1/history` - normalisierte numerische Zeitreihen
 - `http://127.0.0.1:8000/v1/actuators/discovery` - unterstützte Aktuatoren für den aktor-zentrierten Workflow
+- `http://127.0.0.1:8000/v1/actuators/dashboard` - schnelle Dashboard-Startdaten aus Store und JSON-Cache
+- `http://127.0.0.1:8000/v1/actuators/summary` - schlanke Liste beobachteter Aktoren
 - `POST http://127.0.0.1:8000/v1/actuators` - Aktor freigeben; Kontextzuordnung und Modell-Lebenszyklus starten automatisch
 - `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/evaluate` - Shadow-Vorhersage aktualisieren
 - `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/activation` - autonomes Schalten pro Aktor freigeben oder stoppen
@@ -109,8 +130,12 @@ Lernentscheidungen erfolgen automatisch.
    System das lokale Modell automatisch.
 5. Vorhersagen laufen zunächst ausschließlich im Shadow-Modus.
 6. Erst nach ausdrücklicher Freigabe pro Aktor werden hochkonfidente,
-   erlaubte Zustände geschaltet. Eigene Schaltungen und erkannte
+   erlaubte Zustände geschaltet. Eindeutig im HA-Logbuch erkannte Automationen
-   HA-Automationen werden nicht als Nutzerhandlungen zurückgelernt.
+   und Scripts zählen dabei gleichwertig wie manuelle Bedienungen. Eigene
+   Schaltungen von SillyHome werden nicht zurückgelernt.
+7. Bei der Freigabe kann SillyHome passende HA-Automationen pausieren und die
+   Steuerung übernehmen. Beim Stoppen können diese Automationen gezielt wieder
+   fortgesetzt werden.
 
 Vor einem Update sollte in Home Assistant unter **Einstellungen → System → Backups**
 eine Teil-Sicherung des Add-ons erstellt werden. Zur Wiederherstellung das gewünschte
@@ -121,5 +146,5 @@ Teststand `v0.3.0` wurde als HA-Backup `7df0fca0` gesichert.
 ```bash
 pytest
 ruff check .
-mypy
+mypy app backend tests
 ```

addon/Dockerfile

@@ -4,13 +4,17 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
     PIP_NO_CACHE_DIR=1
 
+# The add-on version changes for every release. Copying its config before the
+# clone makes Docker invalidate the application layer instead of reusing old code.
+COPY config.yaml /tmp/addon-config.yaml
+
 RUN apt-get update \
     && apt-get install -y --no-install-recommends git \
     && git clone --depth 1 --branch main \
        http://192.168.6.31:3000/pino/sillyhome-next.git /app \
     && python -m pip install --upgrade pip \
     && python -m pip install /app \
-    && rm -rf /var/lib/apt/lists/* /app/.git
+    && rm -rf /var/lib/apt/lists/* /app/.git /tmp/addon-config.yaml
 
 COPY run.sh /run.sh
 RUN chmod 0755 /run.sh

addon/config.yaml

@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "0.5.0"
+version: "1.2.0"
 slug: sillyhome_next
 description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
 url: http://192.168.6.31:3000/pino/sillyhome-next
@@ -7,6 +7,7 @@ arch:
   - amd64
 startup: application
 boot: auto
+watchdog: http://[HOST]:[PORT:8000]/health
 init: false
 ingress: true
 ingress_port: 8000
@@ -16,28 +17,6 @@ panel_admin: true
 homeassistant_api: true
 hassio_api: false
 auth_api: false
-options:
-  history_days: 14
-  min_training_points: 24
-  retrain_stale_hours: 24
-  reconcile_interval_seconds: 900
-  min_behavior_actions: 3
-  prediction_confidence: 0.82
-  prediction_window_minutes: 30
-  prediction_interval_seconds: 60
-  execution_cooldown_seconds: 900
-  timezone: Europe/Berlin
-schema:
-  history_days: "int(1,31)"
-  min_training_points: "int(2,10000)"
-  retrain_stale_hours: "int(1,720)"
-  reconcile_interval_seconds: "int(60,86400)"
-  min_behavior_actions: "int(2,100)"
-  prediction_confidence: "float(0.5,0.99)"
-  prediction_window_minutes: "int(5,120)"
-  prediction_interval_seconds: "int(30,3600)"
-  execution_cooldown_seconds: "int(60,86400)"
-  timezone: "str"
 map:
   - type: addon_config
     read_only: false

app/actuators/lifecycle.py

@@ -13,13 +13,15 @@ from app.actuators.models import (
     AssignmentSource,
     LifecycleAuditEntry,
     LifecycleStatus,
+    ManualOverride,
     ModelLifecycleState,
     ReconciliationState,
+    SensorWeightGroup,
     model_id_for_actuator,
 )
 from app.actuators.store import ActuatorStore
 from app.config import Settings
-from app.ha.discovery import DiscoveredEntity, EntityRole
+from app.ha.discovery import DiscoveredEntity, EntityRole, discover_entities
 from app.ha.history import EntityHistorySeries, NumericHistoryPoint
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
@@ -45,6 +47,9 @@ _STOPWORDS = frozenset(
         "humidity",
         "illuminance",
         "light",
+        "licht",
+        "lichtschalter",
+        "monitoring",
         "power",
         "sensor",
         "state",
@@ -53,11 +58,86 @@ _STOPWORDS = frozenset(
         "value",
     }
 )
+_GENERIC_AREA_NAMES = frozenset({"energie", "monitoring", "power", "strom", "system", "technik"})
 _NUMERIC_AUTO_ACCEPT_SCORE = 0.82
+_NUMERIC_AUTO_ACCEPT_MIN_SCORE = 0.5
 _NUMERIC_MIN_MARGIN = 0.18
 _CONTEXT_AUTO_ACCEPT_SCORE = 0.78
+_CONTEXT_AUTO_ACCEPT_MIN_SCORE = 0.3
 _MAX_CONTEXT_SELECTIONS = 5
 _AUDIT_LIMIT = 20
+_MANUAL_CONTEXT_DOMAINS = frozenset({
+    "binary_sensor",
+    "climate",
+    "cover",
+    "device_tracker",
+    "fan",
+    "humidifier",
+    "input_boolean",
+    "input_number",
+    "input_select",
+    "light",
+    "media_player",
+    "person",
+    "remote",
+    "scene",
+    "sensor",
+    "sun",
+    "switch",
+    "weather",
+})
+_CONTEXT_SUGGESTION_LIMIT = 500
+_OUTDOOR_TOKENS = frozenset({"aussen", "außen", "outdoor", "garten", "terrasse", "balkon"})
+_DIAGNOSTIC_TOKENS = frozenset({
+    "basic",
+    "battery",
+    "bytes",
+    "connect",
+    "count",
+    "data",
+    "diagnostic",
+    "firmware",
+    "gesehen",
+    "heat",
+    "inbytes",
+    "interface",
+    "last",
+    "linkquality",
+    "knoten",
+    "knotens",
+    "mqtt",
+    "node",
+    "outbytes",
+    "pfsense",
+    "reason",
+    "restart",
+    "rssi",
+    "signal",
+    "ssid",
+    "status",
+    "overheat",
+    "overheating",
+    "overload",
+    "uptime",
+    "vpn",
+    "uberhitzung",
+    "ueberhitzung",
+    "ueberlast",
+    "überhitzung",
+    "überlast",
+    "wifi",
+    "zuletzt",
+})
+_AUTO_CONTEXT_CLASSES = frozenset({
+    "door",
+    "garage_door",
+    "illuminance",
+    "motion",
+    "occupancy",
+    "opening",
+    "presence",
+    "window",
+})
 
 
 class ActuatorReconciliationService:
@@ -84,11 +164,183 @@ class ActuatorReconciliationService:
     def get_actuator(self, actuator_entity_id: str) -> ActuatorRecord:
         return self._store.get(actuator_entity_id)
 
+    def suggest_context_options(
+        self,
+        actuator_entity_id: str,
+        *,
+        limit: int = _CONTEXT_SUGGESTION_LIMIT,
+    ) -> list[HaEntitySummary]:
+        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        discovered = {entity.entity_id: entity for entity in discover_entities(list(entities.values()))}
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            raise KeyError("Aktuator-Konfiguration nicht gefunden.")
+        selected_ids = _selected_context_ids(self._store.get(actuator_entity_id))
+        ranked: list[tuple[float, str, HaEntitySummary]] = []
+        for entity in entities.values():
+            if entity.entity_id == actuator_entity_id or entity.domain not in _MANUAL_CONTEXT_DOMAINS:
+                continue
+            role = _manual_context_role(entity, discovered.get(entity.entity_id))
+            score, _ = _score_candidate(
+                actuator,
+                entity,
+                role,
+                context=role is not EntityRole.MEASUREMENT,
+            )
+            selected = entity.entity_id in selected_ids
+            if selected:
+                score = max(score, 1.0)
+            if not selected and _is_diagnostic_context(entity):
+                continue
+            if not selected and not _has_context_relationship(actuator, entity):
+                score = max(score, 0.01)
+            ranked.append((score, _context_sort_group(entity), entity))
+        ranked.sort(
+            key=lambda item: (
+                -item[0],
+                item[1],
+                item[2].area_name or "",
+                item[2].friendly_name or item[2].entity_id,
+                item[2].entity_id,
+            )
+        )
+        return [entity for _, _, entity in ranked[:limit]]
+
     def delete_actuator(self, actuator_entity_id: str) -> None:
         model_id = model_id_for_actuator(actuator_entity_id)
         self._registry.archive(model_id)
         self._store.delete(actuator_entity_id)
 
+    def set_manual_assignment(
+        self,
+        actuator_entity_id: str,
+        *,
+        numeric_entity_id: str | None,
+        context_entity_ids: list[str],
+        note: str | None = None,
+    ) -> ActuatorRecord:
+        now = datetime.now(timezone.utc)
+        record = self._store.get(actuator_entity_id)
+        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            raise KeyError("Aktuator-Konfiguration nicht gefunden.")
+        selected_context_ids = list(dict.fromkeys(context_entity_ids))
+        selected_ids = [
+            entity_id
+            for entity_id in [numeric_entity_id, *selected_context_ids]
+            if entity_id
+        ]
+        missing = [entity_id for entity_id in selected_ids if entity_id not in entities]
+        if missing:
+            raise ValueError(f"Unbekannte Home-Assistant-Entity: {', '.join(missing)}")
+        if actuator_entity_id in selected_ids:
+            raise ValueError("Der Aktor selbst kann nicht als Kontextsensor verwendet werden.")
+
+        override = ManualOverride(
+            numeric_entity_id=numeric_entity_id,
+            context_entity_ids=selected_context_ids,
+            sensor_weights=record.manual_override.sensor_weights if record.manual_override else {},
+            sensor_weight_groups=(
+                record.manual_override.sensor_weight_groups if record.manual_override else []
+            ),
+            updated_at=now,
+            note=note,
+        )
+        assignment = self._manual_assignment(override)
+        lifecycle = self._reconcile_lifecycle(
+            actuator=actuator,
+            assignment=assignment,
+            lifecycle=record.lifecycle.model_copy(update={"last_reconciled_at": now}),
+            now=now,
+        )
+        updated = record.model_copy(
+            update={
+                "assignment": assignment,
+                "manual_override": override,
+                "numeric_candidates": _apply_weight_overrides(
+                    _merge_manual_candidates(
+                        record.numeric_candidates,
+                        entities,
+                        [numeric_entity_id] if numeric_entity_id else [],
+                        role=EntityRole.MEASUREMENT,
+                    ),
+                    override,
+                ),
+                "context_candidates": _apply_weight_overrides(
+                    _merge_manual_candidates(
+                        record.context_candidates,
+                        entities,
+                        selected_context_ids,
+                        role=EntityRole.CONTEXT,
+                    ),
+                    override,
+                ),
+                "lifecycle": lifecycle,
+                "updated_at": now,
+            }
+        )
+        return self._store.upsert(updated)
+
+    def set_weight_overrides(
+        self,
+        actuator_entity_id: str,
+        *,
+        sensor_weights: dict[str, float],
+        sensor_weight_groups: list[SensorWeightGroup],
+        note: str | None = None,
+    ) -> ActuatorRecord:
+        now = datetime.now(timezone.utc)
+        record = self._store.get(actuator_entity_id)
+        selected_ids = {
+            entity_id
+            for entity_id in [
+                record.assignment.selected_numeric_entity_id,
+                *record.assignment.selected_context_entity_ids,
+            ]
+            if entity_id
+        }
+        selected_ids.update(sensor_weights)
+        for group in sensor_weight_groups:
+            selected_ids.update(group.entity_ids)
+        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        missing = [entity_id for entity_id in selected_ids if entity_id not in entities]
+        if missing:
+            raise ValueError(f"Unbekannte Home-Assistant-Entity: {', '.join(sorted(missing))}")
+
+        previous = record.manual_override
+        override = ManualOverride(
+            numeric_entity_id=(
+                previous.numeric_entity_id
+                if previous is not None
+                else record.assignment.selected_numeric_entity_id
+            ),
+            context_entity_ids=(
+                previous.context_entity_ids
+                if previous is not None
+                else record.assignment.selected_context_entity_ids
+            ),
+            sensor_weights={entity_id: round(weight, 4) for entity_id, weight in sensor_weights.items()},
+            sensor_weight_groups=sensor_weight_groups,
+            updated_at=now,
+            note=note,
+        )
+        updated = record.model_copy(
+            update={
+                "manual_override": override,
+                "numeric_candidates": _apply_weight_overrides(
+                    record.numeric_candidates,
+                    override,
+                ),
+                "context_candidates": _apply_weight_overrides(
+                    record.context_candidates,
+                    override,
+                ),
+                "updated_at": now,
+            }
+        )
+        return self._store.upsert(updated)
+
     def reconcile_all(self, trigger: str = "manual") -> ReconciliationState:
         state = self._store.load_reconciliation_state().model_copy(
             update={
@@ -194,11 +446,18 @@ class ActuatorReconciliationService:
             ),
             context=True,
         )
-        assignment = self._select_assignment(
+        if record.manual_override is not None:
+            numeric_candidates = _apply_weight_overrides(numeric_candidates, record.manual_override)
+            context_candidates = _apply_weight_overrides(context_candidates, record.manual_override)
+        assignment = (
+            self._manual_assignment(record.manual_override)
+            if record.manual_override is not None
+            else self._select_assignment(
                 actuator=actuator,
                 numeric_candidates=numeric_candidates,
                 context_candidates=context_candidates,
             )
+        )
         lifecycle = self._reconcile_lifecycle(
             actuator=actuator,
             assignment=assignment,
@@ -208,7 +467,7 @@ class ActuatorReconciliationService:
         updated = record.model_copy(
             update={
                 "assignment": assignment,
-                "manual_override": None,
+                "manual_override": record.manual_override,
                 "numeric_candidates": numeric_candidates,
                 "context_candidates": context_candidates,
                 "lifecycle": lifecycle,
@@ -224,6 +483,23 @@ class ActuatorReconciliationService:
         )
         return updated
 
+    @staticmethod
+    def _manual_assignment(override: ManualOverride) -> AssignmentSelection:
+        selected_context_ids = list(dict.fromkeys(override.context_entity_ids))
+        selected_count = len(selected_context_ids) + (1 if override.numeric_entity_id else 0)
+        return AssignmentSelection(
+            selected_numeric_entity_id=override.numeric_entity_id,
+            selected_context_entity_ids=selected_context_ids,
+            source=AssignmentSource.MANUAL,
+            confidence=1.0 if selected_count else 0.0,
+            review_required=selected_count == 0,
+            reason=(
+                f"Manuell festgelegt: {selected_count} Kontext-Entity(s) werden verwendet."
+                if selected_count
+                else "Manuelle Zuordnung enthält noch keine Kontext-Entities."
+            ),
+        )
+
     def _select_assignment(
         self,
         *,
@@ -231,12 +507,29 @@ class ActuatorReconciliationService:
         numeric_candidates: list[AssignmentCandidate],
         context_candidates: list[AssignmentCandidate],
     ) -> AssignmentSelection:
-        top_numeric = numeric_candidates[0] if numeric_candidates else None
+        top_numeric = next(
-        top_contexts = [
+            (candidate for candidate in numeric_candidates if candidate.auto_accepted),
-            candidate.entity_id
+            None,
+        )
+        accepted_contexts = [
+            candidate
             for candidate in context_candidates
+            if candidate.auto_accepted
         ][: _MAX_CONTEXT_SELECTIONS]
+        top_contexts = [candidate.entity_id for candidate in accepted_contexts]
         if top_numeric is None:
+            if accepted_contexts:
+                return AssignmentSelection(
+                    selected_numeric_entity_id=None,
+                    selected_context_entity_ids=top_contexts,
+                    source=AssignmentSource.AUTOMATIC,
+                    confidence=max(candidate.confidence for candidate in accepted_contexts),
+                    review_required=False,
+                    reason=(
+                        "Passender Schaltkontext automatisch erkannt. Für diese "
+                        "Verhaltensvorhersage ist kein numerischer Sensor erforderlich."
+                    ),
+                )
             return AssignmentSelection(
                 selected_numeric_entity_id=None,
                 selected_context_entity_ids=top_contexts,
@@ -433,8 +726,19 @@ class ActuatorReconciliationService:
             confidence = candidate.score / highest if highest else 0.0
             margin = candidate.score - second_score if index == 0 else 0.0
             auto_score = _CONTEXT_AUTO_ACCEPT_SCORE if context else _NUMERIC_AUTO_ACCEPT_SCORE
-            auto_accepted = confidence >= auto_score and (
+            minimum_score = (
-                context or margin >= _NUMERIC_MIN_MARGIN
+                _CONTEXT_AUTO_ACCEPT_MIN_SCORE
+                if context
+                else _NUMERIC_AUTO_ACCEPT_MIN_SCORE
+            )
+            can_auto_accept_context = (
+                not context or _eligible_for_auto_context(actuator, candidate)
+            )
+            auto_accepted = (
+                can_auto_accept_context
+                and candidate.score >= minimum_score
+                and confidence >= auto_score
+                and (context or margin >= _NUMERIC_MIN_MARGIN)
             )
             sorted_candidates[index] = candidate.model_copy(
                 update={
@@ -479,6 +783,111 @@ def _filter_candidates(
     return result
 
 
+def _selected_context_ids(record: ActuatorRecord) -> set[str]:
+    result = set(record.assignment.selected_context_entity_ids)
+    if record.assignment.selected_numeric_entity_id:
+        result.add(record.assignment.selected_numeric_entity_id)
+    if record.manual_override is not None:
+        result.update(record.manual_override.context_entity_ids)
+        if record.manual_override.numeric_entity_id:
+            result.add(record.manual_override.numeric_entity_id)
+    return result
+
+
+def _manual_context_role(
+    entity: HaEntitySummary,
+    discovered: DiscoveredEntity | None,
+) -> EntityRole:
+    if discovered is not None and discovered.role is not EntityRole.UNSUPPORTED:
+        return discovered.role
+    if entity.domain == "sensor":
+        return EntityRole.MEASUREMENT
+    if entity.domain == "binary_sensor":
+        return EntityRole.BINARY_CONTEXT
+    return EntityRole.CONTEXT
+
+
+def _context_sort_group(entity: HaEntitySummary) -> str:
+    device_class = entity.device_class or ""
+    text = " ".join(
+        value.lower().replace("_", " ")
+        for value in [entity.entity_id, entity.friendly_name, entity.area_name, entity.device_name]
+        if value
+    )
+    if device_class in {"motion", "occupancy", "presence"}:
+        return "01_presence"
+    if device_class in {"illuminance"}:
+        return "02_brightness"
+    if device_class in {"door", "garage_door", "opening", "window"}:
+        return "03_opening"
+    if device_class in {"humidity", "moisture"}:
+        return "04_humidity"
+    if device_class in {"temperature"}:
+        return "05_temperature"
+    if any(token in text for token in {"pv", "solar", "akku", "batterie", "battery", "einspeisung"}):
+        return "06_pv_battery"
+    if device_class in {"power", "energy", "current", "voltage"}:
+        return "07_power"
+    if entity.domain in {"weather"}:
+        return "08_weather"
+    if entity.domain in {"fan", "humidifier"}:
+        return "09_ventilation"
+    if entity.domain in {"climate"}:
+        return "10_heating"
+    if entity.domain in {"cover"}:
+        return "11_cover"
+    if entity.domain in {"light", "switch"}:
+        return "12_states"
+    if entity.domain.startswith("input_"):
+        return "13_helper"
+    if entity.domain in {"person", "device_tracker"}:
+        return "14_people"
+    return f"20_{entity.domain}_{device_class}"
+
+
+def _is_diagnostic_context(entity: HaEntitySummary) -> bool:
+    tokens = _metadata_tokens(entity, include_stopwords=True)
+    return bool(tokens.intersection(_DIAGNOSTIC_TOKENS))
+
+
+def _has_context_relationship(actuator: HaEntitySummary, entity: HaEntitySummary) -> bool:
+    if (
+        actuator.area_name
+        and entity.area_name
+        and actuator.area_name == entity.area_name
+        and actuator.area_name.lower() not in _GENERIC_AREA_NAMES
+    ):
+        return True
+    if actuator.device_id and entity.device_id and actuator.device_id == entity.device_id:
+        return True
+    if actuator.device_name and entity.device_name and actuator.device_name == entity.device_name:
+        return True
+    if _metadata_tokens(actuator).intersection(_metadata_tokens(entity)):
+        return True
+    entity_tokens = _metadata_tokens(entity, include_stopwords=True)
+    return bool(
+        entity_tokens.intersection(_OUTDOOR_TOKENS)
+        and entity.device_class in {"illuminance", "humidity", "temperature"}
+    )
+
+
+def _eligible_for_auto_context(
+    actuator: HaEntitySummary,
+    candidate: AssignmentCandidate,
+) -> bool:
+    device_class = candidate.device_class or ""
+    if device_class in _AUTO_CONTEXT_CLASSES:
+        return True
+    if (
+        actuator.device_name
+        and candidate.device_name
+        and actuator.device_name == candidate.device_name
+        and candidate.domain in {"light", "switch"}
+    ):
+        return True
+    return False
+
+
 def _score_candidate(
     actuator: HaEntitySummary,
     entity: HaEntitySummary,
@@ -494,7 +903,12 @@ def _score_candidate(
     if overlap:
         score += min(0.4, 0.1 * len(overlap))
         evidence.append(f"Gemeinsame Tokens: {', '.join(overlap[:4])}")
-    if actuator.area_name and entity.area_name and actuator.area_name == entity.area_name:
+    if (
+        actuator.area_name
+        and entity.area_name
+        and actuator.area_name == entity.area_name
+        and actuator.area_name.lower() not in _GENERIC_AREA_NAMES
+    ):
         score += 0.35
         evidence.append(f"Gleicher Bereich: {actuator.area_name}")
     if actuator.device_id and entity.device_id and actuator.device_id == entity.device_id:
@@ -510,31 +924,140 @@ def _score_candidate(
     if entity.device_class in preferred_device_classes:
         score += 0.2
         evidence.append(f"Passende device_class: {entity.device_class}")
+    if not context and actuator.domain == "light" and entity.device_class == "illuminance":
+        score += 0.2
+        evidence.append("Beleuchtungsstärke wird für Lichtaktoren bevorzugt.")
     if not context and entity.unit_of_measurement is not None:
         score += 0.05
         evidence.append(f"Numerische Einheit vorhanden: {entity.unit_of_measurement}")
     if context and role is EntityRole.BINARY_CONTEXT:
         score += 0.05
         evidence.append("Binärer Kontextsensor bevorzugt für Zusatzkontext.")
+    if entity_tokens.intersection(_OUTDOOR_TOKENS) and entity.device_class in {
+        "illuminance",
+        "humidity",
+        "temperature",
+    }:
+        score += 0.1
+        evidence.append("Außenmesswert ist oft als übergreifender Kontext relevant.")
     return round(min(score, 1.0), 4), evidence
 
 
+def _merge_manual_candidates(
+    candidates: list[AssignmentCandidate],
+    entities: dict[str, HaEntitySummary],
+    selected_entity_ids: list[str],
+    *,
+    role: EntityRole,
+) -> list[AssignmentCandidate]:
+    by_id = {candidate.entity_id: candidate for candidate in candidates}
+    for entity_id in selected_entity_ids:
+        existing = by_id.get(entity_id)
+        if existing is not None:
+            evidence = [
+                item
+                for item in existing.evidence
+                if item != "Manuell vom Nutzer als relevant festgelegt."
+            ]
+            by_id[entity_id] = existing.model_copy(
+                update={
+                    "auto_accepted": True,
+                    "confidence": 1.0,
+                    "evidence": [
+                        *evidence,
+                        "Manuell vom Nutzer als relevant festgelegt.",
+                    ],
+                }
+            )
+            continue
+        entity = entities.get(entity_id)
+        if entity is None:
+            continue
+        by_id[entity_id] = AssignmentCandidate(
+            entity_id=entity.entity_id,
+            domain=entity.domain,
+            role=role,
+            device_class=entity.device_class,
+            state_class=entity.state_class,
+            unit_of_measurement=entity.unit_of_measurement,
+            friendly_name=entity.friendly_name,
+            area_name=entity.area_name,
+            device_name=entity.device_name,
+            score=1.0,
+            confidence=1.0,
+            auto_accepted=True,
+            evidence=["Manuell vom Nutzer als relevant festgelegt."],
+        )
+    return sorted(by_id.values(), key=lambda item: (-item.confidence, item.entity_id))
+
+
+def _apply_weight_overrides(
+    candidates: list[AssignmentCandidate],
+    override: ManualOverride,
+) -> list[AssignmentCandidate]:
+    if not override.sensor_weights and not override.sensor_weight_groups:
+        return candidates
+    group_weights: dict[str, float] = {}
+    for group in override.sensor_weight_groups:
+        for entity_id in group.entity_ids:
+            group_weights[entity_id] = max(group_weights.get(entity_id, 0.0), group.weight)
+    weighted: list[AssignmentCandidate] = []
+    for candidate in candidates:
+        explicit = override.sensor_weights.get(candidate.entity_id)
+        group_weight = group_weights.get(candidate.entity_id)
+        manual_weight = explicit if explicit is not None else group_weight
+        effective_weight = manual_weight if manual_weight is not None else 1.0
+        evidence = [
+            item
+            for item in candidate.evidence
+            if not item.startswith("Manuelle Gewichtung:")
+        ]
+        if manual_weight is not None:
+            evidence.append(f"Manuelle Gewichtung: {round(manual_weight * 100)} %.")
+        weighted.append(
+            candidate.model_copy(
+                update={
+                    "manual_weight": manual_weight,
+                    "effective_weight": round(effective_weight, 4),
+                    "evidence": evidence,
+                }
+            )
+        )
+    return sorted(weighted, key=lambda item: (-item.confidence * item.effective_weight, item.entity_id))
+
+
 def _preferred_device_classes(domain: str, *, context: bool) -> frozenset[str]:
     if context:
-        return frozenset({"door", "garage_door", "motion", "occupancy", "opening", "presence"})
         mapping = {
-        "climate": {"temperature", "humidity", "power"},
+            "climate": {"humidity", "illuminance", "occupancy", "presence", "temperature", "window"},
+            "cover": {"illuminance", "motion", "occupancy", "presence", "wind_speed"},
+            "fan": {"humidity", "moisture", "occupancy", "presence", "temperature"},
+            "humidifier": {"humidity", "moisture", "temperature"},
+            "light": {"door", "garage_door", "illuminance", "motion", "occupancy", "opening", "presence", "window"},
+            "media_player": {"occupancy", "presence"},
+            "switch": {"door", "garage_door", "motion", "occupancy", "opening", "presence", "window"},
+        }
+        return frozenset(
+            mapping.get(
+                domain,
+                {"door", "garage_door", "motion", "occupancy", "opening", "presence"},
+            )
+        )
+    mapping = {
+        "climate": {"temperature", "humidity"},
         "cover": {"illuminance", "temperature", "wind_speed"},
-        "fan": {"temperature", "humidity", "power"},
+        "fan": {"temperature", "humidity", "moisture"},
-        "humidifier": {"humidity", "temperature", "power"},
+        "humidifier": {"humidity", "moisture", "temperature"},
-        "light": {"illuminance", "power", "energy"},
+        "light": {"illuminance"},
+        "media_player": {"power", "energy"},
+        "remote": {"battery"},
         "switch": {"power", "energy", "current"},
         "valve": {"temperature", "pressure", "humidity"},
     }
     return frozenset(mapping.get(domain, {"power", "energy", "temperature"}))
 
 
-def _metadata_tokens(entity: HaEntitySummary) -> set[str]:
+def _metadata_tokens(entity: HaEntitySummary, *, include_stopwords: bool = False) -> set[str]:
     raw_values = [
         entity.entity_id,
         entity.friendly_name,
@@ -546,7 +1069,7 @@ def _metadata_tokens(entity: HaEntitySummary) -> set[str]:
         if value is None:
             continue
         for token in _TOKEN_PATTERN.findall(value.lower().replace("_", " ")):
-            if len(token) < 3 or token in _STOPWORDS:
+            if len(token) < 3 or (not include_stopwords and token in _STOPWORDS):
                 continue
             tokens.add(token)
     return tokens

app/actuators/models.py

@@ -37,6 +37,21 @@ class BehaviorStatus(StrEnum):
     BLOCKED = "blocked"
 
 
+class SafetyStage(StrEnum):
+    OBSERVE = "observe"
+    SUGGEST = "suggest"
+    SHADOW = "shadow"
+    PARTIAL = "partial"
+    ACTIVE = "active"
+
+
+class JobStatus(StrEnum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
 class AssignmentCandidate(BaseModel):
     entity_id: str
     domain: str
@@ -49,6 +64,8 @@ class AssignmentCandidate(BaseModel):
     device_name: str | None = None
     score: float = Field(ge=0.0)
     confidence: float = Field(ge=0.0, le=1.0)
+    manual_weight: float | None = Field(default=None, ge=0.0, le=1.0)
+    effective_weight: float = Field(default=1.0, ge=0.0, le=1.0)
     auto_accepted: bool = False
     evidence: list[str] = Field(default_factory=list)
 
@@ -62,9 +79,18 @@ class AssignmentSelection(BaseModel):
     reason: str = "Noch keine Zuordnung vorhanden."
 
 
+class SensorWeightGroup(BaseModel):
+    group_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    name: str = Field(min_length=1, max_length=120)
+    entity_ids: list[str] = Field(default_factory=list)
+    weight: float = Field(default=1.0, ge=0.0, le=1.0)
+
+
 class ManualOverride(BaseModel):
     numeric_entity_id: str | None = None
     context_entity_ids: list[str] = Field(default_factory=list)
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    sensor_weight_groups: list[SensorWeightGroup] = Field(default_factory=list)
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     note: str | None = None
 
@@ -92,6 +118,9 @@ class BehaviorPattern(BaseModel):
     minute_of_day: int = Field(ge=0, le=1439)
     weekday: int = Field(ge=0, le=6)
     context_states: dict[str, str] = Field(default_factory=dict)
+    trigger_entity_id: str | None = None
+    trigger_from_state: str | None = None
+    trigger_to_state: str | None = None
     source: str = Field(default="observed", max_length=40)
     weight: float = Field(default=1.0, ge=0.1, le=1.0)
     observed_at: datetime
@@ -104,6 +133,70 @@ class BehaviorPrediction(BaseModel):
     reason: str
     matching_patterns: int = Field(default=0, ge=0)
     executed: bool = False
+    execution_reason: str = "Vorhersage wurde noch nicht ausgeführt."
+
+
+class DecisionFactor(BaseModel):
+    entity_id: str | None = None
+    label: str
+    factor_type: str = Field(max_length=40)
+    state: str | None = None
+    weight: float = Field(default=1.0, ge=0.0, le=1.0)
+    contribution: float = Field(default=0.0, ge=0.0, le=1.0)
+    evidence: list[str] = Field(default_factory=list)
+
+
+class AdaptiveWeightUpdate(BaseModel):
+    entity_id: str
+    previous_weight: float = Field(ge=0.0, le=1.0)
+    new_weight: float = Field(ge=0.0, le=1.0)
+    reason: str = Field(max_length=300)
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class SafetyRule(BaseModel):
+    rule_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=160)
+    enabled: bool = True
+    blocking: bool = True
+    reason: str = Field(default="", max_length=300)
+
+
+def default_safety_rules() -> list[SafetyRule]:
+    return [
+        SafetyRule(
+            rule_id="activation_ready",
+            label="Nur nach Lernfreigabe aktiv schalten",
+            reason="Der Aktor muss genug eindeutiges Verhalten gelernt haben.",
+        ),
+        SafetyRule(
+            rule_id="confidence_threshold",
+            label="Mindest-Sicherheit einhalten",
+            reason="Vorhersagen unter der Schaltschwelle bleiben im Shadow-Modus.",
+        ),
+        SafetyRule(
+            rule_id="cooldown",
+            label="Sicherheits-Cooldown gegen Hin-und-her-Schalten",
+            reason="Gleiche Zielzustände werden nicht zu schnell wiederholt.",
+        ),
+        SafetyRule(
+            rule_id="manual_block",
+            label="Manuelle Sperre respektieren",
+            reason="Nutzer können jeden Aktor sofort blockieren.",
+        ),
+    ]
+
+
+class SafetyProfile(BaseModel):
+    stage: SafetyStage = SafetyStage.SHADOW
+    manual_block: bool = False
+    min_confidence: float = Field(default=0.82, ge=0.0, le=1.0)
+    min_confidence_on: float | None = Field(default=None, ge=0.0, le=1.0)
+    min_confidence_off: float | None = Field(default=None, ge=0.0, le=1.0)
+    cooldown_seconds: int | None = Field(default=None, ge=0)
+    rules: list[SafetyRule] = Field(default_factory=default_safety_rules)
+    updated_at: datetime | None = None
+    note: str | None = Field(default=None, max_length=500)
 
 
 class ExecutionEvent(BaseModel):
@@ -111,6 +204,40 @@ class ExecutionEvent(BaseModel):
     executed_at: datetime
 
 
+class ModelSnapshot(BaseModel):
+    version_id: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    sample_count: int = Field(default=0, ge=0)
+    high_confidence_sample_count: int = Field(default=0, ge=0)
+    average_confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+    incorrect_feedback_count: int = Field(default=0, ge=0)
+    patterns: list[BehaviorPattern] = Field(default_factory=list)
+    reason: str = Field(default="", max_length=500)
+
+
+class AutomationConflict(BaseModel):
+    automation_entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    severity: str = Field(default="info", max_length=20)
+    status: str = Field(default="open", max_length=40)
+    reason: str = Field(max_length=500)
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class TimeProfile(BaseModel):
+    profile_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=80)
+    sample_count: int = Field(default=0, ge=0)
+    dominant_state: str | None = None
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+
+
+class RelatedAutomation(BaseModel):
+    entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    config_id: str = Field(min_length=1, max_length=120)
+    friendly_name: str = Field(min_length=1, max_length=200)
+    enabled: bool
+
+
 class BehaviorState(BaseModel):
     mode: BehaviorMode = BehaviorMode.SHADOW
     status: BehaviorStatus = BehaviorStatus.COLLECTING
@@ -123,7 +250,26 @@ class BehaviorState(BaseModel):
     last_evaluated_at: datetime | None = None
     last_executed_at: datetime | None = None
     execution_events: list[ExecutionEvent] = Field(default_factory=list)
+    activation_ready: bool = False
+    activation_reason: str = "Noch nicht genügend Verhalten für eine Freigabe gelernt."
+    related_automations: list[RelatedAutomation] = Field(default_factory=list)
+    paused_automation_entity_ids: list[str] = Field(default_factory=list)
     reason: str = "Historische Aktorhandlungen werden analysiert."
+    safety: SafetyProfile = Field(default_factory=SafetyProfile)
+    decision_factors: list[DecisionFactor] = Field(default_factory=list)
+    knowledge: list[str] = Field(default_factory=list)
+    assumptions: list[str] = Field(default_factory=list)
+    uncertainties: list[str] = Field(default_factory=list)
+    safety_blockers: list[str] = Field(default_factory=list)
+    sample_trend: list[int] = Field(default_factory=list)
+    confidence_trend: list[float] = Field(default_factory=list)
+    correct_feedback_count: int = Field(default=0, ge=0)
+    incorrect_feedback_count: int = Field(default=0, ge=0)
+    model_snapshots: list[ModelSnapshot] = Field(default_factory=list)
+    active_model_version: str | None = None
+    adaptive_weight_updates: list[AdaptiveWeightUpdate] = Field(default_factory=list)
+    automation_conflicts: list[AutomationConflict] = Field(default_factory=list)
+    time_profiles: list[TimeProfile] = Field(default_factory=list)
 
 
 class ActuatorRecord(BaseModel):
@@ -150,5 +296,22 @@ class ReconciliationState(BaseModel):
     last_summary: str = "Noch keine Reconciliation ausgeführt."
 
 
+class JobQueueItem(BaseModel):
+    job_id: str = Field(min_length=1, max_length=120)
+    kind: str = Field(min_length=1, max_length=40)
+    target: str | None = Field(default=None, max_length=160)
+    trigger: str = Field(default="manual", max_length=40)
+    status: JobStatus = JobStatus.PENDING
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    duration_ms: int | None = Field(default=None, ge=0)
+    error: str | None = Field(default=None, max_length=500)
+    summary: str = Field(default="", max_length=500)
+
+
+class JobQueueState(BaseModel):
+    jobs: list[JobQueueItem] = Field(default_factory=list)
+
+
 def model_id_for_actuator(actuator_entity_id: str) -> str:
     return f"actuator.{actuator_entity_id}"

app/actuators/store.py

@@ -8,6 +8,9 @@ from threading import RLock
 
 from app.actuators.models import (
     ActuatorRecord,
+    JobQueueItem,
+    JobQueueState,
+    JobStatus,
     LifecycleStatus,
     ModelLifecycleState,
     ReconciliationState,
@@ -22,6 +25,7 @@ class ActuatorStore:
         self._actuators_root.mkdir(parents=True, exist_ok=True)
         self._lock = RLock()
         self._reconciliation_state_path = self._root / "reconciliation_state.json"
+        self._job_queue_path = self._root / "job_queue.json"
 
     def list(self) -> list[ActuatorRecord]:
         with self._lock:
@@ -85,6 +89,75 @@ class ActuatorStore:
             self._persist_reconciliation_state(state)
             return state
 
+    def load_job_queue(self) -> JobQueueState:
+        with self._lock:
+            if not self._job_queue_path.exists():
+                return JobQueueState()
+            try:
+                return JobQueueState.model_validate_json(
+                    self._job_queue_path.read_text(encoding="utf-8")
+                )
+            except ValueError as exc:
+                raise ValueError("Ungültiger Job-Queue-Status.") from exc
+
+    def start_job(
+        self,
+        *,
+        kind: str,
+        trigger: str,
+        target: str | None = None,
+        summary: str = "",
+    ) -> JobQueueItem:
+        now = datetime.now(timezone.utc)
+        job = JobQueueItem(
+            job_id=f"{now.strftime('%Y%m%d%H%M%S%f')}-{kind}-{target or 'all'}",
+            kind=kind,
+            target=target,
+            trigger=trigger,
+            status=JobStatus.RUNNING,
+            started_at=now,
+            summary=summary,
+        )
+        with self._lock:
+            queue = self.load_job_queue()
+            queue.jobs = [*queue.jobs, job][-50:]
+            self._persist_job_queue(queue)
+        return job
+
+    def finish_job(
+        self,
+        job_id: str,
+        *,
+        status: JobStatus,
+        summary: str = "",
+        error: str | None = None,
+    ) -> JobQueueItem | None:
+        now = datetime.now(timezone.utc)
+        with self._lock:
+            queue = self.load_job_queue()
+            updated_job: JobQueueItem | None = None
+            jobs: list[JobQueueItem] = []
+            for job in queue.jobs:
+                if job.job_id != job_id:
+                    jobs.append(job)
+                    continue
+                duration_ms = None
+                if job.started_at is not None:
+                    duration_ms = max(0, int((now - job.started_at).total_seconds() * 1000))
+                updated_job = job.model_copy(
+                    update={
+                        "status": status,
+                        "completed_at": now,
+                        "duration_ms": duration_ms,
+                        "summary": summary or job.summary,
+                        "error": error,
+                    }
+                )
+                jobs.append(updated_job)
+            queue.jobs = jobs[-50:]
+            self._persist_job_queue(queue)
+            return updated_job
+
     def _target(self, actuator_entity_id: str) -> Path:
         if "." not in actuator_entity_id:
             raise ValueError("Ungültige actuator_entity_id.")
@@ -108,6 +181,14 @@ class ActuatorStore:
         )
         os.replace(temporary, self._reconciliation_state_path)
 
+    def _persist_job_queue(self, state: JobQueueState) -> None:
+        temporary = self._job_queue_path.with_suffix(".json.tmp")
+        temporary.write_text(
+            json.dumps(state.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, self._job_queue_path)
+
     @staticmethod
     def _load(path: Path) -> ActuatorRecord:
         try:

app/api/v1/actuators.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
 from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
 from pydantic import BaseModel, Field
 
 from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import ActuatorRecord, ReconciliationState
+from app.actuators.models import ActuatorRecord, ReconciliationState, SensorWeightGroup
+from app.actuators.models import JobQueueItem, JobQueueState, JobStatus, SafetyProfile
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
+from app.config import Settings
 from app.dependencies import get_ha_reader
-from app.ha.discovery import EntityRole
+from app.ha.discovery import DiscoveredEntity, EntityRole, discover_entities
+from app.ha.exceptions import HaClientError
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 
@@ -22,18 +30,305 @@ class ConfigureActuatorRequest(BaseModel):
 
 class ActivationRequest(BaseModel):
     active: bool
+    pause_matching_automations: bool = False
+    restore_paused_automations: bool = False
+
+
+class AutomationControlRequest(BaseModel):
+    automation_entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    enabled: bool
+
+
+class ManualAssignmentRequest(BaseModel):
+    numeric_entity_id: str | None = Field(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
+    context_entity_ids: list[str] = Field(default_factory=list)
+    note: str | None = Field(default=None, max_length=500)
+
+
+class WeightOverrideRequest(BaseModel):
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    sensor_weight_groups: list[SensorWeightGroup] = Field(default_factory=list)
+    note: str | None = Field(default=None, max_length=500)
+
+
+class FeedbackRequest(BaseModel):
+    correct: bool
+    expected_state: str | None = Field(default=None, max_length=100)
+
+
+class SafetyProfileRequest(BaseModel):
+    safety: SafetyProfile
+
+
+class ModelRollbackRequest(BaseModel):
+    version_id: str = Field(min_length=1, max_length=120)
+
+
+class ActuatorSuggestion(BaseModel):
+    entity_id: str
+    domain: str
+    friendly_name: str | None = None
+    area_name: str | None = None
+    device_name: str | None = None
+    confidence: float
+    reason: str
+    related_automation_count: int = 0
+    likely_context_count: int = 0
+
+
+class ActuatorSummary(BaseModel):
+    actuator_entity_id: str
+    domain: str
+    friendly_name: str | None = None
+    area_name: str | None = None
+    device_name: str | None = None
+    enabled: bool
+    behavior_mode: str
+    behavior_status: str
+    lifecycle_status: str
+    activation_ready: bool
+    activation_reason: str
+    sample_count: int
+    prediction_target_state: str | None = None
+    prediction_confidence: float | None = None
+    updated_at: str
+
+
+class EntityCacheStatus(BaseModel):
+    available: bool
+    updated_at: str | None = None
+    entity_count: int = 0
+
+
+class DashboardSystemStatus(BaseModel):
+    api_status: str = "ok"
+    websocket_status: str = "unavailable"
+    websocket_error: str | None = None
+    reconciliation_last_completed_at: str | None = None
+    configured_actuators: int = 0
+    trained_models: int = 0
+    review_required: int = 0
+
+
+class DashboardDiscoveryGroup(BaseModel):
+    category: str
+    role: str
+    count: int
+
+
+class DashboardOverview(BaseModel):
+    system: DashboardSystemStatus
+    cache: EntityCacheStatus
+    actuators: list[ActuatorSummary]
+    discovery_groups: list[DashboardDiscoveryGroup]
+    jobs: JobQueueState = Field(default_factory=JobQueueState)
 
 
 @router.get("/discovery", response_model=list[HaEntitySummary])
-def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaEntitySummary]:
+def discover_actuators(
-    entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
+    request: Request,
-    discovered = ha_reader.discover()
+    refresh: bool = Query(default=False),
-    actuator_ids = sorted(
+    ha_reader: HaReader = Depends(get_ha_reader),
-        entity.entity_id for entity in discovered if entity.role is EntityRole.ACTUATOR
+) -> list[HaEntitySummary]:
+    cached_entities = [] if refresh else _load_cached_entities(request)
+    if cached_entities:
+        entities = {entity.entity_id: entity for entity in cached_entities}
+    else:
+        job = _start_job(
+            request,
+            kind="discovery",
+            trigger="manual" if refresh else "cache-miss",
+            summary="Home-Assistant-Entities werden gelesen und klassifiziert.",
+        )
+        try:
+            fresh_entities = list(ha_reader.read_entities())
+            _save_cached_entities(request, fresh_entities)
+        except Exception as exc:
+            _finish_job(job, request, status=JobStatus.FAILED, summary="Discovery fehlgeschlagen.", error=str(exc))
+            raise
+        _finish_job(job, request, status=JobStatus.COMPLETED, summary=f"{len(fresh_entities)} Entities klassifiziert.")
+        entities = {entity.entity_id: entity for entity in fresh_entities}
+    discovered = discover_entities(list(entities.values()))
+    actuator_ids = _deduplicate_actuator_ids(
+        [
+            (entity.entity_id, entity.category)
+            for entity in discovered
+            if entity.role is EntityRole.ACTUATOR
+        ],
+        entities,
     )
     return [entities[entity_id] for entity_id in actuator_ids if entity_id in entities]
 
 
+@router.get("/suggestions", response_model=list[ActuatorSuggestion])
+def suggest_actuators(
+    request: Request,
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> list[ActuatorSuggestion]:
+    entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
+    discovered = {entity.entity_id: entity for entity in discover_entities(list(entities.values()))}
+    configured_ids = {record.actuator_entity_id for record in _service(request).list_configured()}
+    actuator_ids = _deduplicate_actuator_ids(
+        [
+            (entity.entity_id, entity.category)
+            for entity in discovered.values()
+            if entity.role is EntityRole.ACTUATOR
+        ],
+        entities,
+    )
+    suggestions: list[ActuatorSuggestion] = []
+    for entity_id in actuator_ids:
+        if entity_id in configured_ids:
+            continue
+        entity = entities.get(entity_id)
+        if entity is None:
+            continue
+        try:
+            automations = ha_reader.find_automations_for_entity(entity_id)
+        except Exception:
+            automations = []
+        context_count = _likely_context_count(entity, entities, discovered)
+        if not automations and context_count == 0:
+            continue
+        confidence = 1.0 if automations else min(0.85, 0.35 + context_count * 0.1)
+        reason_parts = []
+        if automations:
+            reason_parts.append(f"{len(automations)} passende HA-Automation(en)")
+        if context_count:
+            reason_parts.append(f"{context_count} naheliegende Kontext-Entity(s)")
+        suggestions.append(
+            ActuatorSuggestion(
+                entity_id=entity.entity_id,
+                domain=entity.domain,
+                friendly_name=entity.friendly_name,
+                area_name=entity.area_name,
+                device_name=entity.device_name,
+                confidence=round(confidence, 4),
+                reason=", ".join(reason_parts),
+                related_automation_count=len(automations),
+                likely_context_count=context_count,
+            )
+        )
+    return sorted(
+        suggestions,
+        key=lambda item: (
+            -item.related_automation_count,
+            -item.confidence,
+            item.area_name or "",
+            item.friendly_name or item.entity_id,
+        ),
+    )[:30]
+
+
+@router.get("/context-options", response_model=list[HaEntitySummary])
+def context_options(
+    request: Request,
+    actuator_entity_id: str | None = Query(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$"),
+) -> list[HaEntitySummary]:
+    if actuator_entity_id is None:
+        return []
+    try:
+        return _service(request).suggest_context_options(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.get("/summary", response_model=list[ActuatorSummary])
+def list_configured_summary(request: Request) -> list[ActuatorSummary]:
+    records = _service(request).list_configured()
+    entity_map = _load_cached_entity_map(
+        request,
+        {record.actuator_entity_id for record in records},
+    )
+    return [
+        ActuatorSummary(
+            actuator_entity_id=record.actuator_entity_id,
+            domain=record.actuator_entity_id.split(".", 1)[0],
+            friendly_name=(
+                entity_map[record.actuator_entity_id].friendly_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            area_name=(
+                entity_map[record.actuator_entity_id].area_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            device_name=(
+                entity_map[record.actuator_entity_id].device_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            enabled=record.enabled,
+            behavior_mode=record.behavior.mode.value,
+            behavior_status=record.behavior.status.value,
+            lifecycle_status=record.lifecycle.status.value,
+            activation_ready=record.behavior.activation_ready,
+            activation_reason=record.behavior.activation_reason,
+            sample_count=record.behavior.sample_count,
+            prediction_target_state=(
+                record.behavior.prediction.target_state
+                if record.behavior.prediction is not None
+                else None
+            ),
+            prediction_confidence=(
+                record.behavior.prediction.confidence
+                if record.behavior.prediction is not None
+                else None
+            ),
+            updated_at=record.updated_at.isoformat(),
+        )
+        for record in records
+    ]
+
+
+@router.get("/dashboard", response_model=DashboardOverview)
+def dashboard_overview(request: Request) -> DashboardOverview:
+    cache_payload = _load_entity_cache_payload(request)
+    raw_entities = cache_payload.get("entities", [])
+    if not isinstance(raw_entities, list):
+        raw_entities = []
+    raw_updated_at = cache_payload.get("updated_at")
+    updated_at = raw_updated_at if isinstance(raw_updated_at, str) else None
+    raw_groups = cache_payload.get("discovery_groups", [])
+    cached_groups = [
+        DashboardDiscoveryGroup.model_validate(group)
+        for group in raw_groups
+        if isinstance(group, dict)
+    ] if isinstance(raw_groups, list) else []
+    reconciliation = _reconciliation_state_or_default(request)
+    ws_status = getattr(request.app.state, "ws_status", None)
+    actuators = list_configured_summary(request)
+    store = getattr(request.app.state, "actuator_store", None)
+    jobs = (
+        store.load_job_queue()
+        if isinstance(store, ActuatorStore)
+        else JobQueueState()
+    )
+    return DashboardOverview(
+        system=DashboardSystemStatus(
+            websocket_status=getattr(ws_status, "status", "unavailable"),
+            websocket_error=getattr(ws_status, "error", None),
+            reconciliation_last_completed_at=(
+                reconciliation.last_completed_at.isoformat()
+                if reconciliation.last_completed_at is not None
+                else None
+            ),
+            configured_actuators=len(actuators),
+            trained_models=reconciliation.trained_models,
+            review_required=reconciliation.review_required,
+        ),
+        cache=EntityCacheStatus(
+            available=bool(raw_entities),
+            updated_at=updated_at,
+            entity_count=len(raw_entities),
+        ),
+        actuators=actuators,
+        discovery_groups=cached_groups,
+        jobs=jobs,
+    )
+
+
 @router.get("", response_model=list[ActuatorRecord])
 def list_configured(request: Request) -> list[ActuatorRecord]:
     return _service(request).list_configured()
@@ -89,6 +384,48 @@ def evaluate_actuator(
         raise HTTPException(status_code=404, detail=str(exc)) from exc
 
 
+@router.post("/{actuator_entity_id}/feedback", response_model=ActuatorRecord)
+def record_feedback(
+    actuator_entity_id: str,
+    payload: FeedbackRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).record_feedback(
+            actuator_entity_id,
+            correct=payload.correct,
+            expected_state=payload.expected_state,
+        )
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/{actuator_entity_id}/safety", response_model=ActuatorRecord)
+def set_safety_profile(
+    actuator_entity_id: str,
+    payload: SafetyProfileRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).set_safety_profile(actuator_entity_id, profile=payload.safety)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/{actuator_entity_id}/model/rollback", response_model=ActuatorRecord)
+def rollback_model(
+    actuator_entity_id: str,
+    payload: ModelRollbackRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).rollback_model(actuator_entity_id, version_id=payload.version_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
 @router.post("/{actuator_entity_id}/activation", response_model=ActuatorRecord)
 def set_activation(
     actuator_entity_id: str,
@@ -96,13 +433,113 @@ def set_activation(
     request: Request,
 ) -> ActuatorRecord:
     try:
-        return _behavior(request).set_active(actuator_entity_id, active=payload.active)
+        return _behavior(request).set_active(
+            actuator_entity_id,
+            active=payload.active,
+            pause_matching_automations=payload.pause_matching_automations,
+            restore_paused_automations=payload.restore_paused_automations,
+        )
     except KeyError as exc:
         raise HTTPException(status_code=404, detail=str(exc)) from exc
     except ValueError as exc:
         raise HTTPException(status_code=409, detail=str(exc)) from exc
 
 
+@router.post("/{actuator_entity_id}/assignment", response_model=ActuatorRecord)
+def set_manual_assignment(
+    actuator_entity_id: str,
+    payload: ManualAssignmentRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        record = _service(request).set_manual_assignment(
+            actuator_entity_id,
+            numeric_entity_id=payload.numeric_entity_id,
+            context_entity_ids=payload.context_entity_ids,
+            note=payload.note,
+        )
+        _behavior(request).train(record.actuator_entity_id)
+        return _behavior(request).evaluate(record.actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/{actuator_entity_id}/weights", response_model=ActuatorRecord)
+def set_weight_overrides(
+    actuator_entity_id: str,
+    payload: WeightOverrideRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        _validate_weight_payload(payload)
+        record = _service(request).set_weight_overrides(
+            actuator_entity_id,
+            sensor_weights=payload.sensor_weights,
+            sensor_weight_groups=payload.sensor_weight_groups,
+            note=payload.note,
+        )
+        return record
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post(
+    "/{actuator_entity_id}/related-automations/refresh",
+    response_model=ActuatorRecord,
+)
+def refresh_related_automations(
+    actuator_entity_id: str,
+    request: Request,
+) -> ActuatorRecord:
+    job = _start_job(
+        request,
+        kind="automation_refresh",
+        trigger="manual",
+        target=actuator_entity_id,
+        summary="Passende HA-Automationen werden gesucht.",
+    )
+    try:
+        record = _behavior(request).refresh_related_automations(actuator_entity_id)
+        _finish_job(
+            job,
+            request,
+            status=JobStatus.COMPLETED,
+            summary=f"{len(record.behavior.related_automations)} Automationen gefunden.",
+        )
+        return record
+    except KeyError as exc:
+        _finish_job(job, request, status=JobStatus.FAILED, summary="Automation-Refresh fehlgeschlagen.", error=str(exc))
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (ValueError, HaClientError) as exc:
+        _finish_job(job, request, status=JobStatus.FAILED, summary="Automation-Refresh fehlgeschlagen.", error=str(exc))
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
+@router.post(
+    "/{actuator_entity_id}/related-automations/control",
+    response_model=ActuatorRecord,
+)
+def control_related_automation(
+    actuator_entity_id: str,
+    payload: AutomationControlRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).set_automation_enabled(
+            actuator_entity_id,
+            payload.automation_entity_id,
+            enabled=payload.enabled,
+        )
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (ValueError, HaClientError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
 @router.get("/reconciliation/state", response_model=ReconciliationState)
 def get_reconciliation_state(request: Request) -> ReconciliationState:
     store = getattr(request.app.state, "actuator_store", None)
@@ -119,12 +556,85 @@ def run_reconciliation(
     request: Request,
     trigger: str = Query(default="manual", pattern=r"^[a-z0-9_-]{1,32}$"),
 ) -> ReconciliationState:
+    reconciliation_job = _start_job(
+        request,
+        kind="reconciliation",
+        trigger=trigger,
+        summary="Kontext, Zuordnung und Modelle werden abgeglichen.",
+    )
+    training_job: JobQueueItem | None = None
+    evaluation_job: JobQueueItem | None = None
+    try:
         state = _service(request).reconcile_all(trigger=trigger)
+        _finish_job(reconciliation_job, request, status=JobStatus.COMPLETED, summary=state.last_summary)
+        reconciliation_job = None
+        training_job = _start_job(
+            request,
+            kind="training",
+            trigger=trigger,
+            summary="Gelernte Aktorhandlungen werden aktualisiert.",
+        )
         _behavior(request).train_all()
+        _finish_job(training_job, request, status=JobStatus.COMPLETED, summary="Training abgeschlossen.")
+        training_job = None
+        evaluation_job = _start_job(
+            request,
+            kind="evaluation",
+            trigger=trigger,
+            summary="Aktuelle Vorhersagen werden neu berechnet.",
+        )
         _behavior(request).evaluate_all()
+        _finish_job(evaluation_job, request, status=JobStatus.COMPLETED, summary="Evaluation abgeschlossen.")
+        evaluation_job = None
+    except Exception as exc:
+        for job in [reconciliation_job, training_job, evaluation_job]:
+            if isinstance(job, JobQueueItem) and job.status is JobStatus.RUNNING:
+                _finish_job(job, request, status=JobStatus.FAILED, summary="Job fehlgeschlagen.", error=str(exc))
+        raise
     return state
 
 
+@router.get("/job-queue/state", response_model=JobQueueState)
+def get_job_queue(request: Request) -> JobQueueState:
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Actuator Store nicht initialisiert.",
+        )
+    return store.load_job_queue()
+
+
+def _start_job(
+    request: Request,
+    *,
+    kind: str,
+    trigger: str,
+    target: str | None = None,
+    summary: str = "",
+) -> JobQueueItem | None:
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        return None
+    return store.start_job(kind=kind, trigger=trigger, target=target, summary=summary)
+
+
+def _finish_job(
+    job: JobQueueItem | None,
+    request: Request,
+    *,
+    status: JobStatus,
+    summary: str,
+    error: str | None = None,
+) -> None:
+    if job is None:
+        return
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        return
+    store.finish_job(job.job_id, status=status, summary=summary, error=error)
+
+
 def _service(request: Request) -> ActuatorReconciliationService:
     service = getattr(request.app.state, "actuator_service", None)
     if not isinstance(service, ActuatorReconciliationService):
@@ -143,3 +653,207 @@ def _behavior(request: Request) -> BehaviorEngine:
             detail="Verhaltenslernen ist nicht initialisiert.",
         )
     return engine
+
+
+def _validate_weight_payload(payload: WeightOverrideRequest) -> None:
+    for entity_id, weight in payload.sensor_weights.items():
+        if "." not in entity_id:
+            raise ValueError(f"Ungültige Entity-ID: {entity_id}")
+        if not 0.0 <= weight <= 1.0:
+            raise ValueError(f"Ungültige Gewichtung für {entity_id}: {weight}")
+    for group in payload.sensor_weight_groups:
+        if not group.entity_ids:
+            raise ValueError(f"Gruppe {group.name} enthält keine Entities.")
+        for entity_id in group.entity_ids:
+            if "." not in entity_id:
+                raise ValueError(f"Ungültige Entity-ID in Gruppe {group.name}: {entity_id}")
+
+
+def _reconciliation_state_or_default(request: Request) -> ReconciliationState:
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        return ReconciliationState()
+    try:
+        return store.load_reconciliation_state()
+    except ValueError:
+        return ReconciliationState(last_summary="Reconciliation-Status ist unlesbar.")
+
+
+def _entity_cache_path(request: Request) -> Path:
+    store = getattr(request.app.state, "actuator_store", None)
+    settings = getattr(request.app.state, "settings", None)
+    if isinstance(store, ActuatorStore):
+        base_dir = store._root
+    elif isinstance(settings, Settings):
+        base_dir = Path(settings.actuator_store).resolve().parent
+    else:
+        base_dir = Path(".").resolve()
+    return Path(os.getenv("SILLYHOME_ENTITY_CACHE", base_dir / "ha_entity_cache.json"))
+
+
+def _load_cached_entities(request: Request) -> list[HaEntitySummary]:
+    payload = _load_entity_cache_payload(request)
+    raw_entities = payload.get("entities", [])
+    if not isinstance(raw_entities, list):
+        return []
+    try:
+        return [HaEntitySummary.model_validate(entity) for entity in raw_entities]
+    except ValueError:
+        return []
+
+
+def _load_cached_entity_map(
+    request: Request,
+    entity_ids: set[str],
+) -> dict[str, HaEntitySummary]:
+    if not entity_ids:
+        return {}
+    payload = _load_entity_cache_payload(request)
+    raw_entities = payload.get("entities", [])
+    if not isinstance(raw_entities, list):
+        return {}
+    result: dict[str, HaEntitySummary] = {}
+    for raw_entity in raw_entities:
+        if not isinstance(raw_entity, dict):
+            continue
+        entity_id = raw_entity.get("entity_id")
+        if not isinstance(entity_id, str) or entity_id not in entity_ids:
+            continue
+        try:
+            result[entity_id] = HaEntitySummary.model_validate(raw_entity)
+        except ValueError:
+            continue
+    return result
+
+
+def _load_entity_cache_payload(request: Request) -> dict[str, object]:
+    path = _entity_cache_path(request)
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        return payload if isinstance(payload, dict) else {}
+    except (OSError, TypeError, ValueError):
+        return {}
+
+
+def _save_cached_entities(request: Request, entities: list[HaEntitySummary]) -> None:
+    path = _entity_cache_path(request)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    group_counts: dict[tuple[str, str], int] = {}
+    for entity in discover_entities(entities):
+        key = (entity.category, entity.role.value)
+        group_counts[key] = group_counts.get(key, 0) + 1
+    payload = {
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "discovery_groups": [
+            {"category": category, "role": role, "count": count}
+            for (category, role), count in sorted(group_counts.items())
+        ],
+        "entities": [entity.model_dump(mode="json") for entity in entities],
+    }
+    temporary = path.with_suffix(".json.tmp")
+    temporary.write_text(
+        json.dumps(payload, ensure_ascii=True, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def _deduplicate_actuator_ids(
+    discovered: list[tuple[str, str]],
+    entities: dict[str, HaEntitySummary],
+) -> list[str]:
+    priority = {
+        "light": 0,
+        "cover_shutter": 1,
+        "heating": 2,
+        "lock": 3,
+        "fan": 4,
+        "switch_socket": 5,
+        "button": 6,
+        "helper": 7,
+    }
+    selected: dict[str, tuple[int, str]] = {}
+    for entity_id, category in discovered:
+        entity = entities.get(entity_id)
+        if entity is None:
+            continue
+        key = _actuator_duplicate_key(entity, category)
+        rank = priority.get(category, 50)
+        current = selected.get(key)
+        if current is None or (rank, entity_id) < current:
+            selected[key] = (rank, entity_id)
+    return sorted(entity_id for _, entity_id in selected.values())
+
+
+def _actuator_duplicate_key(entity: HaEntitySummary, category: str) -> str:
+    if entity.device_id and category in {"light", "switch_socket", "button"}:
+        return f"device:{entity.device_id}:control"
+    if entity.device_name and category in {"light", "switch_socket", "button"}:
+        return f"device-name:{entity.device_name.lower()}:control"
+    return f"entity:{entity.entity_id}"
+
+
+def _likely_context_count(
+    actuator: HaEntitySummary,
+    entities: dict[str, HaEntitySummary],
+    discovered: dict[str, DiscoveredEntity],
+) -> int:
+    actuator_tokens = _tokens(actuator)
+    count = 0
+    for entity in entities.values():
+        if entity.entity_id == actuator.entity_id:
+            continue
+        descriptor = discovered.get(entity.entity_id)
+        role = descriptor.role if descriptor is not None else None
+        if role not in {
+            EntityRole.MEASUREMENT,
+            EntityRole.BINARY_CONTEXT,
+            EntityRole.CONTEXT,
+        }:
+            continue
+        if entity.device_class not in {
+            "door",
+            "energy",
+            "garage_door",
+            "humidity",
+            "illuminance",
+            "motion",
+            "occupancy",
+            "opening",
+            "power",
+            "presence",
+            "temperature",
+            "window",
+        }:
+            continue
+        same_area = bool(
+            actuator.area_name
+            and entity.area_name
+            and actuator.area_name == entity.area_name
+        )
+        same_device = bool(
+            actuator.device_id
+            and entity.device_id
+            and actuator.device_id == entity.device_id
+        )
+        token_match = bool(actuator_tokens.intersection(_tokens(entity)))
+        if same_area or same_device or token_match:
+            count += 1
+    return count
+
+
+def _tokens(entity: HaEntitySummary) -> set[str]:
+    values = [
+        entity.entity_id,
+        entity.friendly_name,
+        entity.area_name,
+        entity.device_name,
+    ]
+    tokens: set[str] = set()
+    for value in values:
+        if not value:
+            continue
+        tokens.update(token for token in value.lower().replace("_", " ").split() if len(token) > 2)
+    return tokens

app/ha/client.py

@@ -22,6 +22,7 @@ logger = logging.getLogger(__name__)
 _ENTITY_ID_PATTERN = re.compile(r"^[a-z0-9_]+\.[a-z0-9_]+$")
 _SERVICE_PART_PATTERN = re.compile(r"^[a-z0-9_]+$")
 _MAX_HISTORY_SECONDS = 31 * 24 * 60 * 60
+_METADATA_BATCH_SIZE = 200
 
 
 @dataclass(frozen=True)
@@ -107,6 +108,18 @@ class HaClient:
             )
         return payload
 
+    def get_automation_config(self, automation_id: str) -> dict[str, object]:
+        if not automation_id or len(automation_id) > 120:
+            raise ValueError("Ungültige Automation-ID.")
+        payload = self._get_json(
+            f"/api/config/automation/config/{quote(automation_id, safe='')}"
+        )
+        if not isinstance(payload, dict):
+            raise HaUnexpectedPayloadError(
+                "Automation-Konfiguration hat ein unerwartetes Format."
+            )
+        return payload
+
     def call_service(
         self,
         domain: str,
@@ -129,6 +142,17 @@ class HaClient:
             return {}
         if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
             raise ValueError("entity_id enthält ein ungültiges Format.")
+        result: dict[str, dict[str, str | None]] = {}
+        for start in range(0, len(entity_ids), _METADATA_BATCH_SIZE):
+            result.update(
+                self._list_entity_metadata_batch(entity_ids[start:start + _METADATA_BATCH_SIZE])
+            )
+        return result
+
+    def _list_entity_metadata_batch(
+        self,
+        entity_ids: list[str],
+    ) -> dict[str, dict[str, str | None]]:
         template = _metadata_template(entity_ids)
         rendered = self._post_text("/api/template", {"template": template})
         try:

app/ha/discovery.py

@@ -21,6 +21,7 @@ class DiscoveredEntity(BaseModel):
     device_class: str | None = None
     state_class: str | None = None
     unit_of_measurement: str | None = None
+    category: str
     role: EntityRole
     learnable: bool
     reason: str
@@ -87,16 +88,37 @@ _ACTUATOR_DOMAINS = frozenset({
     "cover",
     "fan",
     "humidifier",
-    "light",
+    "input_boolean",
+    "input_button",
     "lock",
+    "light",
+    "media_player",
+    "number",
+    "remote",
     "scene",
-    "select",
     "siren",
     "switch",
     "valve",
 })
-_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "sun", "weather", "zone"})
+_CONTEXT_DOMAINS = frozenset({
-_LEARNABLE_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "weather"})
+    "device_tracker",
+    "input_boolean",
+    "input_datetime",
+    "input_number",
+    "input_select",
+    "person",
+    "sun",
+    "weather",
+    "zone",
+})
+_LEARNABLE_CONTEXT_DOMAINS = frozenset({
+    "device_tracker",
+    "input_boolean",
+    "input_number",
+    "input_select",
+    "person",
+    "weather",
+})
 _NUMERIC_STATE_CLASSES = frozenset({"measurement", "total", "total_increasing"})
 
 
@@ -109,6 +131,7 @@ def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
         return _result(
             entity,
             EntityRole.MEASUREMENT,
+            category=_measurement_category(entity),
             learnable=True,
             reason="Numerischer Messsensor für Zeitreihen und Training.",
         )
@@ -117,6 +140,7 @@ def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
         return _result(
             entity,
             EntityRole.BINARY_CONTEXT,
+            category=_binary_category(entity),
             learnable=True,
             reason="Binärer Kontextsensor für Zustands- und Anwesenheitsmuster.",
         )
@@ -126,6 +150,7 @@ def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
         return _result(
             entity,
             EntityRole.CONTEXT,
+            category=_context_category(entity),
             learnable=learnable,
             reason=(
                 "Kontextquelle für Training und Erklärungen."
@@ -138,6 +163,7 @@ def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
         return _result(
             entity,
             EntityRole.ACTUATOR,
+            category=_actuator_category(entity),
             learnable=False,
             reason="Aktor ist ein mögliches Automationsziel, aber kein Trainingssensor.",
         )
@@ -145,6 +171,7 @@ def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
     return _result(
         entity,
         EntityRole.UNSUPPORTED,
+        category="unsupported",
         learnable=False,
         reason="Entity-Typ ist noch nicht für Lernen oder Automationen klassifiziert.",
     )
@@ -169,6 +196,7 @@ def _result(
     entity: HaEntitySummary,
     role: EntityRole,
     *,
+    category: str,
     learnable: bool,
     reason: str,
 ) -> DiscoveredEntity:
@@ -178,7 +206,117 @@ def _result(
         device_class=entity.device_class,
         state_class=entity.state_class,
         unit_of_measurement=entity.unit_of_measurement,
+        category=category,
         role=role,
         learnable=learnable,
         reason=reason,
     )
+
+
+def _actuator_category(entity: HaEntitySummary) -> str:
+    text = _entity_text(entity)
+    if entity.domain == "light":
+        return "light"
+    if entity.domain == "switch":
+        if any(token in text for token in {"steckdose", "socket", "plug", "outlet", "shelly"}):
+            return "socket"
+        return "switch_socket"
+    if entity.domain == "button" or entity.domain == "input_button":
+        return "button"
+    if entity.domain == "cover":
+        return "cover_shutter"
+    if entity.domain == "climate":
+        return "heating"
+    if entity.domain == "lock":
+        return "lock"
+    if entity.domain == "fan":
+        return "fan"
+    if entity.domain in {"media_player", "remote"}:
+        return "media_tv"
+    if entity.domain == "scene":
+        return "scene"
+    if entity.domain in {"input_boolean", "number"}:
+        return "helper"
+    return entity.domain
+
+
+def _measurement_category(entity: HaEntitySummary) -> str:
+    device_class = entity.device_class or ""
+    text = _entity_text(entity)
+    if any(
+        token in text
+        for token in {
+            "pv",
+            "solar",
+            "photovoltaik",
+            "akku",
+            "batterie",
+            "battery",
+            "einspeisung",
+            "wechselrichter",
+            "inverter",
+        }
+    ):
+        return "pv_battery_grid"
+    if entity.domain == "weather":
+        return "weather"
+    if device_class == "illuminance":
+        return "brightness"
+    if device_class == "temperature":
+        return "temperature"
+    if device_class in {"humidity", "moisture"}:
+        return "humidity"
+    if device_class in {"power", "energy", "current", "voltage", "apparent_power"}:
+        return "energy_power"
+    if device_class in {"battery", "signal_strength"}:
+        return "diagnostic"
+    return "measurement"
+
+
+def _binary_category(entity: HaEntitySummary) -> str:
+    device_class = entity.device_class or ""
+    if device_class in {"motion", "occupancy", "presence"}:
+        return "presence_motion"
+    if device_class in {"door", "garage_door", "opening", "window"}:
+        return "opening"
+    if device_class in {"smoke", "safety", "problem"}:
+        return "safety"
+    if device_class in {"lock"}:
+        return "lock_state"
+    return "binary"
+
+
+def _context_category(entity: HaEntitySummary) -> str:
+    text = _entity_text(entity)
+    if entity.domain.startswith("input_"):
+        return "helper"
+    if entity.domain in {"person", "device_tracker", "zone"}:
+        return "presence_location"
+    if entity.domain == "weather":
+        return "weather"
+    if entity.domain in {"light"}:
+        return "light_state"
+    if entity.domain in {"switch"}:
+        if any(token in text for token in {"steckdose", "socket", "plug", "outlet", "shelly"}):
+            return "socket_state"
+        return "switch_state"
+    if entity.domain in {"climate"}:
+        return "heating_state"
+    if entity.domain in {"fan", "humidifier"}:
+        return "ventilation_state"
+    if entity.domain in {"cover"}:
+        return "cover_state"
+    return entity.domain
+
+
+def _entity_text(entity: HaEntitySummary) -> str:
+    return " ".join(
+        value.lower().replace("_", " ")
+        for value in [
+            entity.entity_id,
+            entity.friendly_name,
+            entity.area_name,
+            entity.device_name,
+        ]
+        if value
+    )

app/ha/models.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import datetime
+
 from pydantic import BaseModel
 
 
@@ -15,6 +17,7 @@ class HaEntitySummary(BaseModel):
     entity_id: str
     domain: str
     state: str | None = None
+    last_changed: datetime | None = None
     state_class: str | None = None
     device_class: str | None = None
     unit_of_measurement: str | None = None
@@ -23,3 +26,10 @@ class HaEntitySummary(BaseModel):
     area_name: str | None = None
     device_id: str | None = None
     device_name: str | None = None
+
+
+class HaAutomationSummary(BaseModel):
+    entity_id: str
+    config_id: str
+    friendly_name: str
+    enabled: bool

app/ha/reader.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
+from threading import RLock
 from typing import Any
 import logging
 
-from app.ha.exceptions import HaClientError
+from app.ha.exceptions import HaClientError, HaHttpError
 
 from app.ha.client import HaClient
 from app.ha.discovery import DiscoveredEntity, discover_entities
@@ -17,7 +18,7 @@ from app.ha.history import (
     normalize_logbook_payload,
     normalize_state_history_payload,
 )
-from app.ha.models import HaEntitySummary
+from app.ha.models import HaAutomationSummary, HaEntitySummary
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +26,11 @@ logger = logging.getLogger(__name__)
 class HaReader:
     def __init__(self, client: HaClient) -> None:
         self._client = client
+        self._automation_cache: list[
+            tuple[HaAutomationSummary, dict[str, object]]
+        ] = []
+        self._automation_cache_at: datetime | None = None
+        self._automation_cache_lock = RLock()
 
     def read_entities(self) -> Sequence[HaEntitySummary]:
         entities = self._client.list_entities()
@@ -53,6 +59,7 @@ class HaReader:
                     entity_id=entity_id,
                     domain=domain,
                     state=_optional_str(item.get("state")),
+                    last_changed=_optional_datetime(item.get("last_changed")),
                     state_class=_optional_str(attributes.get("state_class")),
                     device_class=_optional_str(attributes.get("device_class")),
                     unit_of_measurement=_optional_str(attributes.get("unit_of_measurement")),
@@ -111,8 +118,114 @@ class HaReader:
     ) -> Sequence[object]:
         return self._client.call_service(domain, service, service_data)
 
+    def find_automations_for_entity(
+        self,
+        entity_id: str,
+    ) -> list[HaAutomationSummary]:
+        current_states = {
+            raw_entity_id: item.get("state") == "on"
+            for item in self._client.list_entities()
+            if isinstance((raw_entity_id := item.get("entity_id")), str)
+            and raw_entity_id.startswith("automation.")
+        }
+        matches = [
+            summary.model_copy(
+                update={
+                    "enabled": current_states.get(
+                        summary.entity_id,
+                        summary.enabled,
+                    )
+                }
+            )
+            for summary, config in self._read_automation_configs()
+            if _contains_exact_value(config, entity_id)
+        ]
+        return sorted(matches, key=lambda item: item.entity_id)
+
+    def _read_automation_configs(
+        self,
+    ) -> list[tuple[HaAutomationSummary, dict[str, object]]]:
+        now = datetime.now(timezone.utc)
+        with self._automation_cache_lock:
+            if (
+                self._automation_cache_at is not None
+                and now - self._automation_cache_at < timedelta(minutes=10)
+            ):
+                return list(self._automation_cache)
+            configs: list[tuple[HaAutomationSummary, dict[str, object]]] = []
+            for item in self._client.list_entities():
+                raw_entity_id = item.get("entity_id")
+                if not isinstance(raw_entity_id, str) or not raw_entity_id.startswith(
+                    "automation."
+                ):
+                    continue
+                attributes = item.get("attributes")
+                if not isinstance(attributes, dict):
+                    continue
+                config_id = attributes.get("id")
+                if not isinstance(config_id, str) or not config_id:
+                    continue
+                try:
+                    config = self._client.get_automation_config(config_id)
+                except HaHttpError as exc:
+                    if exc.status_code == 404:
+                        logger.info(
+                            "Automation config not exposed by Home Assistant for %s.",
+                            raw_entity_id,
+                        )
+                        continue
+                    logger.warning(
+                        "Automation config unavailable for %s: %s",
+                        raw_entity_id,
+                        exc,
+                    )
+                    continue
+                except (HaClientError, ValueError) as exc:
+                    logger.warning(
+                        "Automation config unavailable for %s: %s",
+                        raw_entity_id,
+                        exc,
+                    )
+                    continue
+                configs.append(
+                    (
+                        HaAutomationSummary(
+                            entity_id=raw_entity_id,
+                            config_id=config_id,
+                            friendly_name=str(
+                                attributes.get("friendly_name") or raw_entity_id
+                            ),
+                            enabled=item.get("state") == "on",
+                        ),
+                        config,
+                    )
+                )
+            self._automation_cache = configs
+            self._automation_cache_at = now
+            return list(configs)
+
 
 def _optional_str(value: object) -> str | None:
     if value is None or value == "":
         return None
     return str(value)
+
+
+def _optional_datetime(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return parsed if parsed.tzinfo is not None else None
+
+
+def _contains_exact_value(value: object, expected: str) -> bool:
+    if value == expected:
+        return True
+    if isinstance(value, dict):
+        return any(_contains_exact_value(item, expected) for item in value.values())
+    if isinstance(value, list):
+        return any(_contains_exact_value(item, expected) for item in value)
+    return False

app/main.py

@@ -1,9 +1,13 @@
 import asyncio
+import json
+import logging
 from contextlib import asynccontextmanager, suppress
 from collections.abc import AsyncIterator
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
 
+import websockets
 from fastapi import FastAPI
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
@@ -16,17 +20,33 @@ from app.behavior.engine import BehaviorEngine
 from app.config import load_settings
 from app.core.exception_handlers import register_exception_handlers
 from app.ha.client import HaClient, HaClientSettings
+from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 from app.ml.registry.model_registry import ModelRegistry
 from backend.routes.ml import init_ml_routes
 
+logger = logging.getLogger(__name__)
+
+class _WsStatus:
+    """Einfacher Status-Tracker für den WebSocket-Listener.
+
+    Wird als Attribut an app.state gehängt und enthält:
+    - status: "disconnected" | "connecting" | "connected" | "reconnecting" | "error"
+    - error: str | None (Fehlermeldung bei status=error)
+    """
+    def __init__(self) -> None:
+        self.status: str = "disconnected"
+        self.error: str | None = None
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
     settings = app.state.settings
     client: HaClient | None = None
+    startup_task: asyncio.Task[None] | None = None
     reconcile_task: asyncio.Task[None] | None = None
-    prediction_task: asyncio.Task[None] | None = None
+    event_listener_task: asyncio.Task[None] | None = None
+    fallback_task: asyncio.Task[None] | None = None
     app.state.registry = ModelRegistry(settings.model_store)
     app.state.actuator_store = ActuatorStore(settings.actuator_store)
     if hasattr(app.state, "ha_reader"):
@@ -54,22 +74,30 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
             store=app.state.actuator_store,
             settings=settings,
         )
-        await asyncio.to_thread(app.state.actuator_service.reconcile_all, "startup")
+        app.state.ws_status = _WsStatus()
-        await asyncio.to_thread(app.state.behavior_engine.train_all)
+        startup_task = asyncio.create_task(_startup_reconciliation(app))
-        await asyncio.to_thread(app.state.behavior_engine.evaluate_all)
         reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
-        prediction_task = asyncio.create_task(_periodic_prediction(app))
+        event_listener_task = asyncio.create_task(_ha_event_listener(app, client))
+        fallback_task = asyncio.create_task(_fallback_prediction(app))
     try:
         yield
     finally:
+        if startup_task is not None:
+            startup_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await startup_task
         if reconcile_task is not None:
             reconcile_task.cancel()
             with suppress(asyncio.CancelledError):
                 await reconcile_task
-        if prediction_task is not None:
+        if event_listener_task is not None:
-            prediction_task.cancel()
+            event_listener_task.cancel()
             with suppress(asyncio.CancelledError):
-                await prediction_task
+                await event_listener_task
+        if fallback_task is not None:
+            fallback_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await fallback_task
         if client is not None:
             client.close()
 
@@ -77,7 +105,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
     title="SillyHome Next API",
     description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.5.0",
+    version="1.2.0",
     lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -94,10 +122,26 @@ app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 def health() -> dict[str, str]:
     return {"status": "ok"}
 
+@app.get("/health/websocket")
+def websocket_health() -> dict[str, object]:
+    """Gibt den aktuellen Status des WebSocket-Listeners zurück.
+
+    Antwort:
+    - status: "disconnected" | "connecting" | "connected" | "reconnecting" | "error"
+    - error: str | None (nur bei status=error)
+    """
+    ws_status = getattr(app.state, "ws_status", None)
+    if ws_status is None:
+        return {"status": "unavailable", "error": "WebSocket-Listener nicht initialisiert"}
+    return {"status": ws_status.status, "error": ws_status.error}
+
 
 @app.get("/")
 def root() -> FileResponse:
-    return FileResponse(STATIC_DIR / "index.html")
+    return FileResponse(
+        STATIC_DIR / "index.html",
+        headers={"Cache-Control": "no-store, max-age=0"},
+    )
 
 
 async def _periodic_reconciliation(app: FastAPI) -> None:
@@ -106,16 +150,254 @@ async def _periodic_reconciliation(app: FastAPI) -> None:
         service = getattr(app.state, "actuator_service", None)
         if not isinstance(service, ActuatorReconciliationService):
             continue
+        try:
             await asyncio.to_thread(service.reconcile_all, "scheduled")
             engine = getattr(app.state, "behavior_engine", None)
             if isinstance(engine, BehaviorEngine):
                 await asyncio.to_thread(engine.train_all)
+        except Exception:
+            logger.exception("Geplante Reconciliation fehlgeschlagen; nächster Lauf versucht es erneut.")
 
 
-async def _periodic_prediction(app: FastAPI) -> None:
+async def _startup_reconciliation(app: FastAPI) -> None:
+    delay_seconds = 5
     while True:
-        await asyncio.sleep(app.state.settings.prediction_interval_seconds)
+        service = getattr(app.state, "actuator_service", None)
         engine = getattr(app.state, "behavior_engine", None)
-        if not isinstance(engine, BehaviorEngine):
+        if not isinstance(service, ActuatorReconciliationService) or not isinstance(
-            continue
+            engine,
+            BehaviorEngine,
+        ):
+            return
+        try:
+            await asyncio.to_thread(service.reconcile_all, "startup")
+            await asyncio.to_thread(engine.train_all)
             await asyncio.to_thread(engine.evaluate_all)
+            logger.info("Startup-Reconciliation erfolgreich abgeschlossen.")
+            return
+        except Exception as exc:
+            logger.warning(
+                "Startup-Reconciliation verschoben: %s. Neuer Versuch in %ss.",
+                exc,
+                delay_seconds,
+            )
+            await asyncio.sleep(delay_seconds)
+            delay_seconds = min(delay_seconds * 2, 60)
+
+
+async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
+    """Hört auf Home-Assistant-Websocket-Events und löst sofortige Vorhersagen aus."""
+    settings = app.state.settings
+    engine = app.state.behavior_engine
+    ha_reader = getattr(app.state, "ha_reader", None)
+    store = app.state.actuator_store
+    if (
+        not isinstance(engine, BehaviorEngine)
+        or not isinstance(store, ActuatorStore)
+        or not isinstance(ha_reader, HaReader)
+    ):
+        logger.error("BehaviorEngine oder ActuatorStore nicht initialisiert")
+        ws_status = getattr(app.state, "ws_status", None)
+        if ws_status is not None:
+            ws_status.status = "error"
+            ws_status.error = "BehaviorEngine oder ActuatorStore nicht initialisiert"
+        return
+    state_cache: dict[str, HaEntitySummary] = {}
+    ha_url = str(settings.ha_url).rstrip("/")
+    ws_url = ha_url.replace("http://", "ws://").replace("https://", "wss://") + "/api/websocket"
+    auth_token = cast(str, settings.ha_token)
+    ws_status = getattr(app.state, "ws_status", None)
+    while True:
+        if ws_status is not None:
+            ws_status.status = "connecting"
+        try:
+            async with websockets.connect(
+                ws_url,
+                ping_interval=20,
+                ping_timeout=10,
+            ) as websocket:
+                auth_required_msg = await websocket.recv()
+                auth_required_data = json.loads(auth_required_msg)
+                if auth_required_data.get("type") != "auth_required":
+                    logger.error("Unerwartete WebSocket-Authentifizierungsaufforderung")
+                    if ws_status is not None:
+                        ws_status.status = "error"
+                        ws_status.error = "Unerwartete Authentifizierungsaufforderung"
+                    await asyncio.sleep(5)
+                    continue
+
+                await websocket.send(json.dumps({"type": "auth", "access_token": auth_token}))
+                auth_result_msg = await websocket.recv()
+                auth_result_data = json.loads(auth_result_msg)
+                if auth_result_data.get("type") != "auth_ok":
+                    logger.error("WebSocket-Authentifizierung fehlgeschlagen")
+                    if ws_status is not None:
+                        ws_status.status = "error"
+                        ws_status.error = "Authentifizierung fehlgeschlagen"
+                    await asyncio.sleep(5)
+                    continue
+
+                logger.info("WebSocket-Verbindung zu Home Assistant hergestellt")
+                state_cache = await asyncio.to_thread(_load_ha_state_cache, ha_reader)
+                if ws_status is not None:
+                    ws_status.status = "connected"
+                    ws_status.error = None
+                # Auf alle State Changes subscriben
+                subscribe_msg = {
+                    "id": 1,
+                    "type": "subscribe_events",
+                    "event_type": "state_changed"
+                }
+                await websocket.send(json.dumps(subscribe_msg))
+                while True:
+                    message = await websocket.recv()
+                    try:
+                        data = json.loads(message)
+                        if data.get("type") != "event":
+                            continue
+                        event = data.get("event", {})
+                        if event.get("event_type") != "state_changed":
+                            continue
+                        event_data = event.get("data", {})
+                        if not isinstance(event_data, dict):
+                            logger.warning("State-Changed-Event ohne gültige Daten empfangen")
+                            continue
+                        entity_id = event_data.get("entity_id")
+                        if not entity_id:
+                            continue
+                        new_state = event_data.get("new_state")
+                        _update_ha_state_cache(state_cache, entity_id, new_state)
+                        if not _is_relevant_state_change(store, str(entity_id)):
+                            continue
+                        # Prüfe, ob Entity ein Aktor oder relevanter Kontext ist
+                        # Sofortige Vorhersage für betroffene Aktoren auslösen
+                        await asyncio.to_thread(
+                            engine.handle_state_change,
+                            entity_id,
+                            new_state,
+                            current_entities=list(state_cache.values()),
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning("Ungültige JSON-Nachricht von HA-WebSocket")
+                    except Exception as exc:
+                        logger.exception("Fehler bei Event-Verarbeitung: %s", exc)
+        except (
+            websockets.exceptions.ConnectionClosed,
+            websockets.exceptions.InvalidStatus,
+            OSError,
+        ) as exc:
+            logger.warning("WebSocket-Verbindung unterbrochen: %s. Wiederholung in 1s...", exc)
+            if ws_status is not None:
+                ws_status.status = "reconnecting"
+                ws_status.error = str(exc)
+            await asyncio.sleep(1)
+        except Exception as exc:
+            logger.exception("Unerwarteter Fehler im Event-Listener: %s", exc)
+            if ws_status is not None:
+                ws_status.status = "error"
+                ws_status.error = str(exc)
+            await asyncio.sleep(1)
+
+
+# Fallback: periodische Vorhersage falls Event-Stream ausfällt
+async def _fallback_prediction(app: FastAPI) -> None:
+    """Periodische Vorhersage als Fallback, wenn WebSocket-Listener nicht verbunden ist.
+
+    Dies verhindert kompletten Ausfall der Vorhersagen bei Netzwerkproblemen.
+    """
+    while True:
+        ws_status = getattr(app.state, "ws_status", None)
+        websocket_connected = ws_status is not None and ws_status.status == "connected"
+        await asyncio.sleep(
+            app.state.settings.prediction_interval_seconds
+            if websocket_connected
+            else min(5, app.state.settings.prediction_interval_seconds)
+        )
+        # Nur ausführen, wenn WebSocket nicht verbunden ist
+        ws_status = getattr(app.state, "ws_status", None)
+        if ws_status is None or ws_status.status != "connected":
+            engine = getattr(app.state, "behavior_engine", None)
+            if isinstance(engine, BehaviorEngine):
+                logger.debug(
+                    "Fallback-Vorhersage aktiv (WebSocket-Status: %s)",
+                    ws_status.status if ws_status else "unavailable",
+                )
+                try:
+                    await asyncio.to_thread(engine.evaluate_all)
+                except Exception:
+                    logger.exception("Fallback-Vorhersage fehlgeschlagen.")
+
+
+def _load_ha_state_cache(reader: HaReader) -> dict[str, HaEntitySummary]:
+    return {entity.entity_id: entity for entity in reader.read_entities()}
+
+
+def _update_ha_state_cache(
+    state_cache: dict[str, HaEntitySummary],
+    entity_id: str,
+    new_state: object,
+) -> None:
+    if not isinstance(new_state, dict):
+        state_cache.pop(entity_id, None)
+        return
+    state_cache[entity_id] = _ha_entity_from_event(
+        entity_id,
+        new_state,
+        state_cache.get(entity_id),
+    )
+
+
+def _is_relevant_state_change(store: ActuatorStore, entity_id: str) -> bool:
+    for record in store.list():
+        if record.actuator_entity_id == entity_id:
+            return True
+        if record.assignment.selected_numeric_entity_id == entity_id:
+            return True
+        if entity_id in record.assignment.selected_context_entity_ids:
+            return True
+    return False
+
+
+def _ha_entity_from_event(
+    entity_id: str,
+    new_state: dict[str, object],
+    previous: HaEntitySummary | None,
+) -> HaEntitySummary:
+    attributes = new_state.get("attributes")
+    attr = attributes if isinstance(attributes, dict) else {}
+    state_class = _optional_event_string(attr.get("state_class"))
+    device_class = _optional_event_string(attr.get("device_class"))
+    unit_of_measurement = _optional_event_string(attr.get("unit_of_measurement"))
+    friendly_name = _optional_event_string(attr.get("friendly_name"))
+    return HaEntitySummary(
+        entity_id=entity_id,
+        domain=entity_id.split(".", 1)[0],
+        state=_optional_event_string(new_state.get("state")),
+        last_changed=_event_datetime(new_state.get("last_changed"))
+        or _event_datetime(new_state.get("last_updated")),
+        state_class=state_class or (previous.state_class if previous else None),
+        device_class=device_class or (previous.device_class if previous else None),
+        unit_of_measurement=unit_of_measurement
+        or (previous.unit_of_measurement if previous else None),
+        friendly_name=friendly_name or (previous.friendly_name if previous else None),
+        area_id=previous.area_id if previous else None,
+        area_name=previous.area_name if previous else None,
+        device_id=previous.device_id if previous else None,
+        device_name=previous.device_name if previous else None,
+    )
+
+
+def _optional_event_string(value: object) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _event_datetime(value: object) -> datetime | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed

docs/BEHAVIOR_ENGINE.md

@@ -0,0 +1,73 @@
+# Verhaltensmodell und Berechnung
+
+## Datenfluss
+
+1. Nutzer wählt einen Aktor.
+2. `ActuatorReconciliationService` ordnet Kontext-Entities zu.
+3. `BehaviorEngine.train()` liest Aktor- und Kontexthistorie.
+4. Aktor-Zustandswechsel werden als `BehaviorPattern` gespeichert.
+5. `BehaviorEngine.evaluate()` vergleicht aktuelle Zustände mit den Mustern.
+6. Shadow zeigt nur die Vorhersage. Active darf sie ausführen.
+
+## Herkunft und Gewicht
+
+- HA-Benutzer: `source=user`, Gewicht `1.0`
+- eindeutig erkannte HA-Automation oder Script: `source=automation`, Gewicht `1.0`
+- physisch oder unbekannt: `source=physical_or_unknown`, Gewicht `0.7`
+- eigene SillyHome-Ausführung: wird verworfen
+
+Manuelle und eindeutig automatisierte Handlungen zählen für die Freigabe.
+
+## Kausale Muster
+
+Wechselt ein Kontextsensor höchstens drei Sekunden vor der Aktorhandlung, wird
+der Wechsel gespeichert:
+
+```text
+binary_sensor.tuer: off -> on
+light.raum: off -> on
+```
+
+Eine kausale Vorhersage gilt nur, wenn derselbe Kontextzustand frisch ist. Das
+Standardfenster ist zweimal `SILLYHOME_PREDICTION_INTERVAL_SECONDS`.
+
+## Nicht-kausale Bewertung
+
+Für Muster ohne frischen Trigger:
+
+```text
+score = weight * (
+  0.45 * time_score
+  + 0.45 * context_score
+  + 0.10 * weekday_score
+)
+```
+
+Die Confidence ist der mittlere Score, begrenzt durch die Mindestunterstützung:
+
+```text
+confidence = mean(scores) * min(1, support / min_behavior_actions)
+```
+
+## Ausführungsbedingungen
+
+Eine Vorhersage wird nur ausgeführt, wenn alle Bedingungen erfüllt sind:
+
+- Betriebsart `active`
+- Confidence mindestens `SILLYHOME_PREDICTION_CONFIDENCE`
+- Zielzustand ist noch nicht erreicht
+- Domain und Zustand sind erlaubt
+- Cooldown erlaubt die Aktion
+
+Der Cooldown sperrt nur eine schnelle Wiederholung desselben Zielzustands.
+Eine Gegenaktion, beispielsweise `on` gefolgt von `off`, bleibt sofort erlaubt.
+
+## Freigabe
+
+`activation_ready=true`, wenn:
+
+- Verhaltensstatus `trained`
+- mindestens `SILLYHOME_MIN_BEHAVIOR_ACTIONS` eindeutig zugeordnete manuelle
+  oder automatisierte Handlungen vorhanden sind
+
+Die UI zeigt `activation_reason` immer an.

docs/CONTROL_HANDOFF.md

@@ -0,0 +1,47 @@
+# Übergabe zwischen SillyHome und HA-Automationen
+
+## Erkennung
+
+SillyHome liest aktive `automation.*`-Entities, lädt deren Konfiguration über
+die Home-Assistant-API und sucht darin nach der exakten Aktor-Entity-ID.
+Namensähnlichkeit allein reicht nicht.
+
+## Betriebsarten
+
+### Shadow
+
+- SillyHome lernt und prognostiziert.
+- SillyHome schaltet nicht.
+- HA-Automationen können normal weiterlaufen.
+
+### Active parallel
+
+- SillyHome darf schalten.
+- Passende HA-Automationen bleiben aktiv.
+- Diese Betriebsart kann doppelte Auslöser verursachen und ist nur für Tests.
+
+### Active mit Übernahme
+
+- SillyHome wird zuerst aktiviert.
+- Danach werden aktuell aktive, passend erkannte HA-Automationen pausiert.
+- Nur erfolgreich pausierte Automationen werden für eine spätere
+  Wiederherstellung gespeichert.
+- Scheitert die Pause, fällt SillyHome auf Shadow zurück und stellt bereits
+  pausierte Automationen wieder her.
+
+## Stoppen
+
+Zwei bewusste Optionen:
+
+- SillyHome stoppen und pausierte HA-Automationen fortsetzen.
+- SillyHome stoppen und HA-Automationen pausiert lassen.
+
+Einzelne passende Automationen können im Dashboard jederzeit pausiert oder
+fortgesetzt werden.
+
+In Home Assistant bedeutet:
+
+```text
+automation.turn_off = pausieren/deaktivieren
+automation.turn_on  = fortsetzen/aktivieren
+```

docs/DEBUGGING.md

@@ -0,0 +1,63 @@
+# Debugging
+
+## Vorhersage korrekt, aber keine Ausführung
+
+1. Aktor-Details öffnen.
+2. `Betriebsart` prüfen.
+3. `Freigabestatus` prüfen.
+4. Text hinter der Vorhersage lesen. `execution_reason` nennt exakt:
+   - Shadow-Modus
+   - Confidence unter Schaltschwelle
+   - Zielzustand bereits erreicht
+   - Cooldown aktiv
+   - ausgeführt
+5. Live-Zustand des Aktors und Triggers in HA prüfen.
+6. Add-on-Logs prüfen.
+
+## Weder SillyHome noch HA-Automation schaltet
+
+1. SillyHome-Modus prüfen.
+2. Unter `Passende Home-Assistant-Automationen` den Zustand prüfen.
+3. Bei Shadow mindestens eine gewünschte HA-Automation fortsetzen.
+4. Bei Active mit Übernahme müssen die passenden HA-Automationen pausiert sein.
+
+## Freigabe fehlt
+
+Die UI zeigt den Grund immer als `activation_reason`.
+
+Prüfen:
+
+```text
+behavior.status
+behavior.sample_count
+behavior.high_confidence_sample_count
+behavior.activation_ready
+behavior.activation_reason
+```
+
+## Entität fehlt in der Liste
+
+Den vollständigen Entitätsnamen direkt eingeben. Der Server akzeptiert nur
+existierende, unterstützte Aktoren. Ein unbekannter Name liefert `404`.
+
+## Standarddiagnose lokal
+
+```bash
+.venv/bin/pytest tests/behavior/test_engine.py -q
+.venv/bin/pytest tests/api/test_actuators.py -q
+.venv/bin/ruff check app tests
+.venv/bin/mypy app backend tests
+```
+
+## Standarddiagnose im HA-Add-on
+
+```bash
+ha apps info 58adbe1e_sillyhome_next
+ha apps logs 58adbe1e_sillyhome_next
+```
+
+Health aus einem Add-on mit Zugriff auf das interne Netz:
+
+```bash
+wget -qO- http://58adbe1e-sillyhome-next:8000/health
+```

docs/OPERATIONS.md

@@ -0,0 +1,87 @@
+# Entwicklung, Release und Betrieb
+
+## Lokales Setup
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e '.[dev]'
+cp .env.example .env
+.venv/bin/uvicorn app.main:app --reload
+```
+
+`SILLYHOME_HA_URL` und `SILLYHOME_HA_TOKEN` nur lokal in `.env` setzen.
+
+## Qualitätsprüfung
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+```
+
+## Release
+
+1. Version in allen vier Stellen ändern:
+   `pyproject.toml`, `addon/config.yaml`, `app/main.py`, `CHANGELOG.md`.
+2. Qualitätsprüfung ausführen.
+3. Feature-Branch committen und pushen.
+4. Pull Request nach `main` erstellen und mergen.
+5. Annotiertes Tag auf dem Merge-Commit erstellen.
+6. Gitea-Release aus demselben Tag erstellen.
+
+Beispiel:
+
+```bash
+git tag -a v0.7.0 -m 'SillyHome Next 0.7.0'
+git push origin v0.7.0
+```
+
+## Home-Assistant-Update
+
+Vorher Teil-Backup des Add-ons erstellen. Danach:
+
+```bash
+ha store reload
+ha apps info 58adbe1e_sillyhome_next
+ha apps update 58adbe1e_sillyhome_next
+ha apps info 58adbe1e_sillyhome_next
+ha apps logs 58adbe1e_sillyhome_next
+```
+
+Kein Home-Assistant-Neustart ist erforderlich.
+
+## Live-Verifikation
+
+Pflicht:
+
+```bash
+wget -qO- http://58adbe1e-sillyhome-next:8000/health
+wget -qO- http://58adbe1e-sillyhome-next:8000/v1/actuators
+```
+
+Für einen Aktor prüfen:
+
+- `behavior.mode`
+- `behavior.activation_ready`
+- `behavior.activation_reason`
+- `behavior.related_automations`
+- `behavior.paused_automation_entity_ids`
+- `behavior.prediction.execution_reason`
+
+Bei einer Übernahme testen:
+
+1. Passende HA-Automation ist vorher `on`.
+2. SillyHome übernimmt.
+3. SillyHome ist `active`.
+4. Passende HA-Automation ist `off`.
+5. Trigger erzeugt erwartete Aktoraktion.
+6. Gegenaktion wird trotz Cooldown ausgeführt.
+7. SillyHome stoppen und Automationen fortsetzen.
+8. SillyHome ist `shadow`, HA-Automation wieder `on`.
+
+## Rollback
+
+Bevorzugt das vor dem Update erstellte HA-Teil-Backup wiederherstellen.
+Alternativ vorherige Git-Version in `addon/config.yaml` veröffentlichen und das
+Add-on erneut aktualisieren.

docs/V1_0_0_OPERATING_GUIDE.md

@@ -0,0 +1,126 @@
+# SillyHome Next 1.0.0 Operating Guide
+
+Diese Version stabilisiert den produktiven Kern: schnelle Dashboard-Nutzung,
+lokales Caching, klare Aktor-/Sensor-Kategorien und nachvollziehbare Freigabe
+gelernter Aktionen.
+
+Die detaillierte Abnahme steht in
+[`V1_0_ACCEPTANCE.md`](V1_0_ACCEPTANCE.md). Dort sind erledigte, teilweise
+erledigte und fuer v1.0.x offene Punkte getrennt dokumentiert.
+
+## Grundprinzip
+
+- Home Assistant bleibt die Quelle fuer aktuelle States und Services.
+- SillyHome cached schwere Entity-/Discovery-Metadaten lokal als JSON.
+- Die Startansicht liest nur lokale Store-/Cache-Daten.
+- Vollstaendige Discovery, Vorschlaege und Detailanalysen laden blockweise nach.
+- Es gibt keine externen Pings oder Cloud-Abfragen im Dashboard-Startpfad.
+
+## Wichtige Endpunkte
+
+- `GET /health`  
+  Lokaler API-Status ohne externe Abfrage.
+- `GET /health/websocket`  
+  Status des Home-Assistant-WebSocket-Listeners.
+- `GET /v1/actuators/dashboard`  
+  Schnelle Dashboard-Startdaten aus Store und JSON-Cache.
+- `GET /v1/actuators/summary`  
+  Schlanke Liste beobachteter Aktoren ohne Lernmuster-Payload.
+- `GET /v1/actuators/discovery`  
+  Aktor-Auswahl aus gecachten oder frisch geladenen HA-Entities.
+- `GET /v1/actuators/context-options?actuator_entity_id=...`  
+  Sensor-/Kontextvorschlaege fuer einen konkreten Aktor.
+- `POST /v1/actuators/{entity_id}/assignment`  
+  Manuelle Sensor-/Kontextzuordnung speichern.
+- `POST /v1/actuators/{entity_id}/activation`  
+  Freigabe oder Stop des automatischen Schaltens.
+
+## Cache
+
+Der Entity-Cache liegt neben dem Aktor-Store als `ha_entity_cache.json`.
+Er enthaelt HA-Entity-Metadaten wie Friendly Name, Bereich, Device und
+Kategoriegrundlagen.
+
+Der Cache wird geschrieben, wenn Discovery frische HA-Entities liest. Danach
+koennen Dashboard und Summary ohne erneute HA-Vollabfrage Namen, Raeume und
+Gruppen anzeigen.
+
+## Dashboard-Nutzung
+
+1. Startansicht oeffnen.
+2. `System & Cache` zeigt API, WebSocket, Cache-Groesse und geladene
+   Discovery-Gruppen.
+3. `Geraet zum Lernen auswaehlen` nutzt Suche, Typfilter und direkte
+   Entity-ID-Eingabe.
+4. `Beobachtete Geraete` zeigt gelernte Aktoren nach Raum oder Typ gruppiert.
+5. `Details` zeigt Lernfortschritt, Freigabe, Vorhersage, verwendete
+   Sensoren/Zustaende und Entscheidungsgruende.
+
+## Kategorien
+
+Aktoren:
+
+- Licht, LED, Lampen
+- Schalter, Steckdosen, Helper
+- Lueftung, Ventilatoren, Befeuchter/Entfeuchter
+- Heizungen/Klima
+- Rolllaeden/Cover
+- TV/Medien/Fernbedienungen
+- Szenen, Buttons, Schloesser, Ventile
+
+Sensoren und Kontext:
+
+- Luftfeuchtigkeit und Feuchte
+- Temperatur
+- Wetter
+- Helligkeit/Lux
+- Bewegung, Praesenz, Anwesenheit
+- Tuer/Fenster/Oeffnung
+- Licht-/Schalter-/Steckdosenstatus
+- Strom, Leistung, Energie, Einspeisung
+- PV, Akku, Wechselrichter
+- Helper und Szenen
+
+## Qualitaetspruefung
+
+Vor Release:
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+```
+
+Live nach Installation:
+
+```bash
+wget -qO- http://58adbe1e-sillyhome-next:8000/health
+wget -qO- http://58adbe1e-sillyhome-next:8000/health/websocket
+wget -qO /tmp/summary.json http://58adbe1e-sillyhome-next:8000/v1/actuators/summary
+wget -qO /tmp/dashboard.json http://58adbe1e-sillyhome-next:8000/v1/actuators/dashboard
+```
+
+Wenn der Add-on-Container aus dem Agent-Host nicht direkt routbar ist, gilt der
+Home-Assistant-Supervisor als Verifikationsquelle:
+
+- Add-on-Info pruefen: Version, `version_latest`, `update_available`, `state`,
+  `boot` und `watchdog`.
+- Vor Updates eine Home-Assistant-Teil-Sicherung fuer **SillyHome Next**
+  erstellen.
+- Nach einem Store-Reload und Update muss `version == version_latest`,
+  `update_available == false`, `state == started`, `boot == auto` und
+  `watchdog == true` gelten.
+- Den HA-/Ingress-Tab nach jedem Update hart neu laden, weil Home Assistant
+  sonst alte HTML-/JavaScript-Ressourcen aus dem bestehenden Tab verwenden kann.
+- Rollback erfolgt ueber die vorherige Add-on-Teil-Sicherung oder den letzten
+  Git-Tag; beide Referenzen im Release-/Abnahmeprotokoll notieren.
+
+## Rollback
+
+Der stabile Vor-1.0-Stand ist `v0.7.21`. Vor dem 1.0.0-Umbau wurde ein
+Git-Bundle-Backup erstellt:
+
+`/root/.openclaw/workspace/backups/sillyhome-next/`
+
+Bei Problemen kann auf `v0.7.21` zurueck installiert werden.

docs/V1_0_ACCEPTANCE.md

@@ -0,0 +1,82 @@
+# SillyHome Next v1.0 Acceptance
+
+Stand: 2026-06-17
+
+Diese Abnahme trennt belegte Umsetzung von offenen v1.0.x-Nacharbeiten. Der
+Funktionskern bleibt aktorzentriert: Nutzer waehlen Aktoren, SillyHome lernt
+Kontext und Verhalten, laeuft zuerst im Shadow-Modus und schaltet erst nach
+expliziter Freigabe.
+
+## Erfuellt
+
+- Versioniert, gepusht und installiert:
+  - `v1.0.0`: API-/Cache-Umbau
+  - `v1.0.1`: Dashboard-/Performance-Korrektur
+- Startpfad:
+  - `/v1/actuators/dashboard` liefert lokale Startdaten aus Store und Cache.
+  - Dashboard blockiert nicht mehr auf Discovery, Vorschlaegen oder
+    Automation-Refresh.
+  - Frontend bricht den Startdaten-Request nach 4,5 Sekunden ab und bleibt
+    bedienbar.
+- Cache:
+  - HA-Entity-Metadaten werden als `ha_entity_cache.json` gespeichert.
+  - Summary und Dashboard verwenden Friendly Name, Area und Device aus Cache.
+- Keine externen Abfragen im Dashboard-Startpfad:
+  - Kein Cloud-Ping, keine Fremd-API.
+  - HA-Zugriffe bleiben lokal gegen Home Assistant.
+- Dashboard:
+  - Orange ist Primaerfarbe.
+  - Cyan ist sichtbare Komplementaerfarbe.
+  - Rote UI-Flaechen wurden entfernt.
+  - Steuerung, beobachtete Geraete, Lernfortschritt/Freigabe und Systemstatus
+    sind getrennte Bereiche.
+  - Discovery, Vorschlaege und Automation-Suche laden erst bei Nutzeraktion.
+- Lernfortschritt und Freigabe:
+  - Karten zeigen Modus, Status, Handlungen, Vorhersage und Freigabestatus.
+  - Detailansicht zeigt Zuordnung, Sicherheit, Lernstand, Vorhersage,
+    Feedback, passende HA-Automationen und verwendete Sensoren/Zustaende.
+- Direkte HA-Nutzung:
+  - Aktor-Schaltungen laufen ueber Home-Assistant-Serviceaufrufe.
+  - Automation-Steuerung nutzt Home-Assistant-Endpunkte und gecachte
+    Automation-Metadaten.
+- Qualitaet:
+  - `pytest -q`
+  - `ruff check .`
+  - `mypy app backend tests`
+  - `git diff --check`
+- Performance-Budget:
+  - Automatisierter Test prueft Root-HTML und `/v1/actuators/dashboard` gegen
+    das 5-Sekunden-Budget mit kontrollierten Fake-HA-/Cache-Daten.
+- HA-/Ingress-Verifikation:
+  - Supervisor-Update, Add-on-Status, Watchdog, Backup, Ingress-Hard-Reload
+    und Rollback sind im Operating Guide dokumentiert.
+
+## Teilweise Erfuellt
+
+- Bessere Statistik:
+  - Startbereich zeigt Aktoren, Freigabebereitschaft, Aktiv/Shadow,
+    Gelernt/Wartet, gelernte Handlungen, Discovery-Gruppen und Cache-Zeitpunkt.
+  - Noch offen: Verlaufsgrafiken, p95-Latenzen und Trendstatistik je Aktor.
+- Kontrollierte Abarbeitung und Queue:
+  - Reconciliation/Training laufen kontrolliert im Prozess und sind testbar.
+  - Noch offen: sichtbare Job-Queue mit Laufzeit, Fehlern und Retry-Status im
+    Dashboard.
+- Saubere Issues:
+  - v1.0.0-Issues #41 bis #47 wurden geschlossen.
+  - Rueckblickend waren sie zu grob; v1.0.x bekommt feinere Folgeissues fuer
+    Statistik, Queue-Sichtbarkeit und Performance-Budgets.
+
+## Offen Fuer v1.0.x
+
+- Dashboard-Jobstatus fuer Reconciliation, Training, Discovery und
+  Automation-Refresh.
+- Mehr Entscheidungsstatistik pro Aktor: welche Sensoren wie stark
+  beigetragen haben, wie sich Confidence und Sample Count entwickeln.
+
+## Rollback
+
+- Git-Bundle-Backups liegen unter
+  `/root/.openclaw/workspace/backups/sillyhome-next/`.
+- Vor `v1.0.1` wurde ein Home-Assistant-Teilbackup des Add-ons angelegt.
+  Referenz: `18a5b387`.
+- Letzter Vor-1.0-Stand: `v0.7.21`.

docs/V1_1_0_OPERATING_GUIDE.md

@@ -0,0 +1,72 @@
+# SillyHome Next v1.1.0 Operating Guide
+
+## Ziel
+
+v1.1.0 macht das Dashboard zur Zentrale fuer Visualisierung, Einrichtung,
+Sicherheit und manuelles Gegensteuern. Autonomes Schalten bleibt ein kurzer
+lokaler Pfad: Vorhersage und Safety-Profil werden aus bereits vorhandenen Daten
+bewertet, danach folgt direkt der Home-Assistant-Serviceaufruf.
+
+## Sicherheitsmodell
+
+Jeder Aktor hat ein Safety-Profil:
+
+- `stage`: Beobachten, Vorschlagen, Shadow, Teilaktiv oder Aktiv.
+- `manual_block`: harte manuelle Sperre.
+- `min_confidence`: Mindest-Sicherheit fuer autonomes Schalten.
+- `cooldown_seconds`: optionaler Aktor-Cooldown gegen schnelles Hin-und-her.
+- Safety-Regeln: Freigabe, Confidence, Cooldown und manuelle Sperre.
+
+Ein Aktor schaltet nur, wenn alle lokalen Safety-Regeln frei sind, der
+Behavior-Modus aktiv ist, die Freigabe bereit ist, die Confidence passt, der
+Zielzustand noch nicht erreicht ist und der Cooldown abgelaufen ist.
+
+## Transparenz
+
+Die Aktor-Detailansicht trennt:
+
+- Wissen: belegte Fakten aus Historie, Zuordnung und Automationen.
+- Annahmen: heuristische Schluesse wie Zeit-/Kontext-Aehnlichkeit.
+- Unsicherheiten: geringe Datenmenge, unklare Quellen, Review-Bedarf oder
+  negatives Feedback.
+- Beitragsfaktoren: Sensoren, Kontextsignale, aktive Gewichtung und Beitrag.
+- Safety-Blocker: Gruende, warum nicht geschaltet wird.
+
+## Job-Queue
+
+Das Dashboard zeigt die letzten Jobs mit Status, Dauer, Fehler und
+Zusammenfassung. Sichtbar sind:
+
+- Discovery
+- Reconciliation
+- Training
+- Evaluation
+- Automation-Refresh
+
+Die Queue ist persistent in `job_queue.json` und dient als Betriebsanzeige. Sie
+blockiert nicht den Startpfad und nicht den Schaltpfad.
+
+## Manuelles Gegensteuern
+
+Im Dashboard koennen pro Aktor gesetzt werden:
+
+- manuelle Sicherheitssperre
+- Freigabestufe
+- Mindest-Confidence
+- optionaler Cooldown
+- Sensor-Gewichtungen und Gruppen-Gewichtungen
+- Kontextauswahl
+- Feedback: Vorhersage korrekt/falsch
+- HA-Automationen pausieren/fortsetzen
+
+## Qualitaetspruefung
+
+Vor Release:
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+node --check /tmp/sillyhome-dashboard.js
+```

docs/V1_2_0_OPERATING_GUIDE.md

@@ -0,0 +1,62 @@
+# SillyHome Next v1.2.0 Operating Guide
+
+## Ziel
+
+v1.2.0 erweitert die sichere v1.1-Grundlage um adaptive Lernfunktionen. Diese
+Funktionen laufen bei Feedback, Training oder Automation-Refresh und blockieren
+nicht den direkten Schaltpfad.
+
+## Adaptive Gewichtung
+
+Feedback passt die Gewichtung aktuell beteiligter Kontextsignale vorsichtig an:
+
+- korrektes Feedback: +3 Prozentpunkte bis maximal 100 %
+- falsches Feedback: -8 Prozentpunkte bis minimal 10 %
+
+Die Aenderungen werden als `adaptive_weight_updates` gespeichert und im
+Dashboard angezeigt. Manuelle Gewichtungen bleiben weiter direkt korrigierbar.
+
+## Modell-Snapshots und Rollback
+
+Bei jedem Training wird ein Snapshot gespeichert:
+
+- Version-ID
+- Sample Count
+- eindeutig zugeordnete Handlungen
+- durchschnittliche Confidence
+- negative Feedbacks
+- Musterliste
+- Begruendung
+
+Ueber das Dashboard kann auf einen frueheren Snapshot zurueckgerollt werden.
+
+## Automation-Konflikte
+
+Beim Automation-Refresh markiert SillyHome Konflikte, wenn:
+
+- SillyHome fuer einen Aktor aktiv ist
+- eine passende Home-Assistant-Automation ebenfalls aktiv bleibt
+
+Pausierte Automationen werden als kontrolliert markiert.
+
+## Zeitprofile
+
+SillyHome bildet Profile fuer:
+
+- Nacht
+- Morgen
+- Tag
+- Abend
+- Wochenende
+
+Diese Profile zeigen Sample Count, dominanten Zielzustand und Profilklarheit.
+
+## Performance-Grenze
+
+v1.2-Funktionen duerfen den Schaltmoment nicht verlangsamen. Der direkte
+Schaltpfad bleibt:
+
+1. vorhandene aktuelle States nutzen
+2. lokale Safety-Pruefung
+3. direkter Home-Assistant-Serviceaufruf
+4. Persistenz der Entscheidung

docs/ml_api.md

@@ -205,12 +205,44 @@ Shadow-Modus wird niemals geschaltet.
 ### `POST /v1/actuators/{actuator_entity_id}/activation`
 
 ```json
-{"active": true}
+{
+  "active": true,
+  "pause_matching_automations": true,
+  "restore_paused_automations": false
+}
 ```
 
 Aktiviert autonomes Schalten erst nach ausreichendem Training und nur für
-erlaubte Aktor-Domains. Mit `false` wird der Aktor sofort wieder in den
+erlaubte Aktor-Domains. `pause_matching_automations` pausiert eindeutig
-Shadow-Modus versetzt.
+zugeordnete HA-Automationen bei der Übernahme.
+
+Beim Stoppen:
+
+```json
+{
+  "active": false,
+  "pause_matching_automations": false,
+  "restore_paused_automations": true
+}
+```
+
+Damit wird der Aktor in den Shadow-Modus versetzt und zuvor von SillyHome
+pausierte Automationen werden fortgesetzt.
+
+### `POST /v1/actuators/{actuator_entity_id}/related-automations/refresh`
+
+Liest passende HA-Automationen anhand ihrer echten Konfiguration neu ein.
+
+### `POST /v1/actuators/{actuator_entity_id}/related-automations/control`
+
+```json
+{
+  "automation_entity_id": "automation.licht_abstellkammer",
+  "enabled": false
+}
+```
+
+Pausiert oder aktiviert eine eindeutig diesem Aktor zugeordnete Automation.
 
 ## Betrieb
 

docs/ml_training.md

@@ -12,10 +12,10 @@ Für jeden Aktor lädt SillyHome Next:
 - automatisch zugeordnete Mess- und Kontext-Entities
 - deren Zustand zum Zeitpunkt der Handlung
 
-Eindeutig einem Home-Assistant-Benutzer zugeordnete Handlungen erhalten das
+Eindeutig einem Home-Assistant-Benutzer zugeordnete Handlungen und im Logbuch
-höchste Gewicht. Erkannte Automations- und Script-Aktionen werden verworfen.
+erkannte Automations- oder Script-Aktionen erhalten das höchste Gewicht.
-Physische oder nicht eindeutig zuordenbare Bedienungen dürfen das
+Physische oder nicht eindeutig zuordenbare Bedienungen dürfen das Shadow-Modell
-Shadow-Modell ergänzen, reichen allein aber nicht zur Aktivierung.
+ergänzen, reichen allein aber nicht zur Aktivierung.
 
 ## Modell
 
@@ -36,8 +36,8 @@ Kontext. Mehrere passende historische Handlungen erhöhen die Confidence.
 2. `shadow`: Modell ist trainiert; Vorhersagen werden angezeigt, aber nicht ausgeführt.
 3. `active`: Nutzer hat den Aktor ausdrücklich freigegeben.
 
-Die Aktivierung verlangt genügend eindeutig einem Benutzer zugeordnete
+Die Aktivierung verlangt genügend eindeutig zugeordnete manuelle oder
-Handlungen. Ausgeführt werden nur erlaubte Zustände reversibler Domains:
+automatisierte Handlungen. Ausgeführt werden nur erlaubte Zustände reversibler Domains:
 `light`, `switch`, `fan`, `humidifier` und `cover`.
 
 ## Schutzmechanismen
@@ -48,4 +48,4 @@ Handlungen. Ausgeführt werden nur erlaubte Zustände reversibler Domains:
 - keine Ausführung bei bereits erreichtem Zielzustand
 - keine Ausführung unbekannter Zustände oder riskanter Domains
 - eigene Schaltungen werden beim nächsten Training herausgefiltert
-- bekannte Automation-/Script-Aktionen werden nicht als Nutzerverhalten gelernt
+- Automation-/Script-Aktionen zählen nur bei eindeutiger Herkunft im HA-Logbuch

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sillyhome-next"
-version = "0.5.0"
+version = "1.2.0"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
@@ -12,6 +12,7 @@ dependencies = [
   "uvicorn[standard]>=0.29.0",
   "pydantic>=2.6.0",
   "requests>=2.31.0",
+  "websockets>=12.0",
 ]
 
 [project.optional-dependencies]

tests/actuators/test_lifecycle.py

@@ -5,8 +5,8 @@ from pathlib import Path
 
 from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.models import (
+    AssignmentSource,
     LifecycleStatus,
-    ManualOverride,
     model_id_for_actuator,
 )
 from app.actuators.store import ActuatorStore
@@ -78,7 +78,7 @@ def _service(
             model_store=str(tmp_path / "models"),
             automation_store=str(tmp_path / "automations"),
             actuator_store=str(tmp_path / "actuators"),
-            history_days=14,
+            history_days=31,
             min_training_points=5,
             retrain_stale_hours=24,
             reconcile_interval_seconds=900,
@@ -141,7 +141,7 @@ def test_reconciliation_auto_assigns_and_trains_numeric_model(tmp_path: Path) ->
     assert "binary_sensor.abstellkammer_motion" not in artifact.supported_sensors
 
 
-def test_reconciliation_uses_best_automatic_mapping_when_ambiguous(tmp_path: Path) -> None:
+def test_reconciliation_rejects_ambiguous_numeric_mapping(tmp_path: Path) -> None:
     start = datetime(2026, 6, 1, tzinfo=timezone.utc)
     entities = [
         HaEntitySummary(
@@ -181,11 +181,178 @@ def test_reconciliation_uses_best_automatic_mapping_when_ambiguous(tmp_path: Pat
     record = service.configure_actuator("switch.garage_pump")
 
     assert record.assignment.review_required is True
-    assert record.assignment.selected_numeric_entity_id == "sensor.garage_energy"
+    assert record.assignment.selected_numeric_entity_id is None
-    assert record.lifecycle.status is LifecycleStatus.TRAINED
+    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
 
 
-def test_legacy_manual_override_is_cleared_and_automatic_mapping_wins(tmp_path: Path) -> None:
+def test_reconciliation_does_not_cross_assign_other_room_light_energy(
+    tmp_path: Path,
+) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id=(
+                "light.lichtschalter_abstellraum_"
+                "lichtschalter_abstellraum_s1"
+            ),
+            domain="light",
+            friendly_name="Licht Abstellraum",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.licht_badezimmer_energy",
+            domain="sensor",
+            device_class="energy",
+            state_class="total_increasing",
+            unit_of_measurement="kWh",
+            friendly_name="Lichtschalter_Badezimmer Licht Badezimmer energy",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellraum_ture",
+            domain="binary_sensor",
+            device_class="door",
+            friendly_name="Abstellraum Türe",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.briefkasten_open",
+            domain="binary_sensor",
+            device_class="opening",
+            friendly_name="Briefkasten open",
+        ),
+    ]
+    service = _service(
+        tmp_path,
+        entities,
+        {"sensor.licht_badezimmer_energy": _points(8, start, 1.0)},
+    )
+
+    record = service.configure_actuator(
+        "light.lichtschalter_abstellraum_lichtschalter_abstellraum_s1"
+    )
+
+    assert record.assignment.selected_numeric_entity_id is None
+    assert record.assignment.selected_context_entity_ids == [
+        "binary_sensor.abstellraum_ture"
+    ]
+    assert record.assignment.source is AssignmentSource.AUTOMATIC
+    assert record.assignment.confidence == 1.0
+    assert record.assignment.review_required is False
+    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
+
+
+def test_reconciliation_ignores_generic_monitoring_area_for_automatic_context(
+    tmp_path: Path,
+) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Licht Abstellkammer",
+            area_name="Monitoring",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.disk_overheating",
+            domain="binary_sensor",
+            device_class="problem",
+            friendly_name="Max. fehlerhafte Sektoren ueberschritten",
+            area_name="Monitoring",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.router_power",
+            domain="sensor",
+            device_class="power",
+            state_class="measurement",
+            unit_of_measurement="W",
+            friendly_name="Router Leistung",
+            area_name="Monitoring",
+        ),
+    ]
+    service = _service(tmp_path, entities, {"sensor.router_power": _points(8, start, 1.0)})
+
+    record = service.configure_actuator("light.abstellkammer")
+
+    assert record.assignment.selected_numeric_entity_id is None
+    assert record.assignment.selected_context_entity_ids == []
+    assert record.assignment.review_required is True
+    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
+
+
+def test_reconciliation_does_not_auto_select_overload_sensors_by_power_area(
+    tmp_path: Path,
+) -> None:
+    entities = [
+        HaEntitySummary(
+            entity_id="light.treppe_unten",
+            domain="light",
+            friendly_name="Licht Treppe Unten",
+            area_name="Strom",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.shelly_schrank_channel_1_overload",
+            domain="binary_sensor",
+            device_class="problem",
+            friendly_name="Shelly Schrank Channel 1 Überlast",
+            area_name="Strom",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.terrasse_terasse_overheating",
+            domain="binary_sensor",
+            device_class="problem",
+            friendly_name="Terrasse Terasse Überhitzung",
+            area_name="Strom",
+        ),
+    ]
+    service = _service(tmp_path, entities, {})
+
+    record = service.configure_actuator("light.treppe_unten")
+
+    assert record.assignment.selected_context_entity_ids == []
+    assert all(candidate.auto_accepted is False for candidate in record.context_candidates)
+
+
+def test_fan_prefers_humidity_over_power_sensor(tmp_path: Path) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id="fan.bad_lueftung",
+            domain="fan",
+            friendly_name="Bad Lüftung",
+            area_name="Bad",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.bad_luftfeuchtigkeit",
+            domain="sensor",
+            device_class="humidity",
+            state_class="measurement",
+            unit_of_measurement="%",
+            friendly_name="Bad Luftfeuchtigkeit",
+            area_name="Bad",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.bad_power",
+            domain="sensor",
+            device_class="power",
+            state_class="measurement",
+            unit_of_measurement="W",
+            friendly_name="Bad Leistung",
+            area_name="Bad",
+        ),
+    ]
+    service = _service(
+        tmp_path,
+        entities,
+        {
+            "sensor.bad_luftfeuchtigkeit": _points(8, start, 55.0),
+            "sensor.bad_power": _points(8, start, 5.0),
+        },
+    )
+
+    record = service.configure_actuator("fan.bad_lueftung")
+
+    assert record.assignment.selected_numeric_entity_id == "sensor.bad_luftfeuchtigkeit"
+
+
+def test_manual_assignment_persists_and_wins_over_automatic_mapping(tmp_path: Path) -> None:
     start = datetime(2026, 6, 1, tzinfo=timezone.utc)
     entities = [
         HaEntitySummary(
@@ -218,21 +385,54 @@ def test_legacy_manual_override_is_cleared_and_automatic_mapping_wins(tmp_path:
         "sensor.abstellkammer_power": _points(8, start, 30.0),
     }
     service = _service(tmp_path, entities, history)
-    configured = service.configure_actuator("light.abstellkammer")
+    service.configure_actuator("light.abstellkammer")
-    legacy = configured.model_copy(
+    service.set_manual_assignment(
-        update={
+        "light.abstellkammer",
-            "manual_override": ManualOverride(
         numeric_entity_id="sensor.abstellkammer_power",
-                context_entity_ids=[],
+        context_entity_ids=["sensor.abstellkammer_illuminance"],
-                note="Alte manuelle Zuordnung",
+        note="Manuell wichtiger Sensor",
     )
-        }
-    )
-    service._store.upsert(legacy)
 
     restarted = _service(tmp_path, entities, history)
     record = restarted.reconcile_actuator("light.abstellkammer")
 
-    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_illuminance"
+    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_power"
-    assert record.assignment.source.value == "automatic"
+    assert record.assignment.selected_context_entity_ids == ["sensor.abstellkammer_illuminance"]
-    assert record.manual_override is None
+    assert record.assignment.source is AssignmentSource.MANUAL
+    assert record.manual_override is not None
+
+
+def test_manual_assignment_evidence_is_not_duplicated(tmp_path: Path) -> None:
+    entities = [
+        HaEntitySummary(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Abstellkammer Licht",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellkammer_motion",
+            domain="binary_sensor",
+            device_class="motion",
+            friendly_name="Abstellkammer Bewegung",
+            area_name="Abstellkammer",
+        ),
+    ]
+    service = _service(tmp_path, entities, {})
+    service.configure_actuator("light.abstellkammer")
+    for _ in range(3):
+        service.set_manual_assignment(
+            "light.abstellkammer",
+            numeric_entity_id=None,
+            context_entity_ids=["binary_sensor.abstellkammer_motion"],
+            note="Manuell gesetzt",
+        )
+
+    record = service.get_actuator("light.abstellkammer")
+    candidate = next(
+        item
+        for item in record.context_candidates
+        if item.entity_id == "binary_sensor.abstellkammer_motion"
+    )
+
+    assert candidate.evidence.count("Manuell vom Nutzer als relevant festgelegt.") == 1

tests/api/test_actuators.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
+from time import perf_counter
 from datetime import datetime, timedelta
 from pathlib import Path
 
 from fastapi.testclient import TestClient
 
 from app.actuators.lifecycle import ActuatorReconciliationService
+from app.actuators.models import ModelSnapshot
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
 from app.config import Settings
+from app.api.v1.actuators import _deduplicate_actuator_ids
 from app.ha.discovery import DiscoveredEntity
 from app.ha.discovery import discover_entities
 from app.ha.history import (
@@ -17,7 +20,7 @@ from app.ha.history import (
     NumericHistoryPoint,
     StateHistorySeries,
 )
-from app.ha.models import HaEntitySummary
+from app.ha.models import HaAutomationSummary, HaEntitySummary
 from app.ha.reader import HaReader
 from app.main import app
 from app.ml.registry.model_registry import ModelRegistry
@@ -27,8 +30,11 @@ class FakeHaReader(HaReader):
     def __init__(self, entities: list[HaEntitySummary], history: dict[str, list[float]]) -> None:
         self._entities = entities
         self._history = history
+        self.read_entities_calls = 0
+        self.service_calls: list[tuple[str, str, dict[str, object]]] = []
 
     def read_entities(self) -> list[HaEntitySummary]:
+        self.read_entities_calls += 1
         return list(self._entities)
 
     def discover(
@@ -82,6 +88,13 @@ class FakeHaReader(HaReader):
         service: str,
         service_data: dict[str, object],
     ) -> list[object]:
+        self.service_calls.append((domain, service, service_data))
+        return []
+
+    def find_automations_for_entity(
+        self,
+        entity_id: str,
+    ) -> list[HaAutomationSummary]:
         return []
 
 
@@ -101,6 +114,7 @@ def _install_service(tmp_path: Path) -> None:
             unit_of_measurement="lx",
             friendly_name="Abstellkammer Helligkeit",
             area_name="Abstellkammer",
+            state="12",
         ),
         HaEntitySummary(
             entity_id="binary_sensor.abstellkammer_motion",
@@ -108,6 +122,15 @@ def _install_service(tmp_path: Path) -> None:
             device_class="motion",
             friendly_name="Abstellkammer Bewegung",
             area_name="Abstellkammer",
+            state="off",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.pfsense_interface_vpn_inbytes",
+            domain="sensor",
+            device_class="data_size",
+            state_class="measurement",
+            unit_of_measurement="KiB",
+            friendly_name="pfSense Interface VPN inbytes",
         ),
     ]
     settings = Settings(
@@ -173,14 +196,294 @@ def test_actuator_api_configures_reconciles_and_removes(tmp_path: Path) -> None:
         assert client.get("/v1/actuators").json() == []
 
 
-def test_manual_override_endpoint_is_not_exposed(tmp_path: Path) -> None:
+def test_manual_assignment_endpoint_updates_context(tmp_path: Path) -> None:
     with TestClient(app) as client:
         _install_service(tmp_path)
         client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
 
         response = client.post(
-            "/v1/actuators/light.abstellkammer/override",
+            "/v1/actuators/light.abstellkammer/assignment",
-            json={"numeric_entity_id": "sensor.abstellkammer_illuminance"},
+            json={
+                "numeric_entity_id": "sensor.abstellkammer_illuminance",
+                "context_entity_ids": ["binary_sensor.abstellkammer_motion"],
+                "note": "Manuell gesetzt",
+            },
         )
 
-    assert response.status_code == 404
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["assignment"]["source"] == "manual"
+    assert payload["assignment"]["selected_numeric_entity_id"] == (
+        "sensor.abstellkammer_illuminance"
+    )
+    assert payload["assignment"]["selected_context_entity_ids"] == [
+        "binary_sensor.abstellkammer_motion"
+    ]
+
+
+def test_weight_override_endpoint_updates_sensor_relevance(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        client.post(
+            "/v1/actuators/light.abstellkammer/assignment",
+            json={
+                "numeric_entity_id": "sensor.abstellkammer_illuminance",
+                "context_entity_ids": ["binary_sensor.abstellkammer_motion"],
+            },
+        )
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/weights",
+            json={
+                "sensor_weights": {
+                    "sensor.abstellkammer_illuminance": 0.75,
+                    "binary_sensor.abstellkammer_motion": 0.5,
+                },
+                "sensor_weight_groups": [
+                    {
+                        "group_id": "abstellkammer_context",
+                        "name": "Abstellkammer Kontext",
+                        "entity_ids": [
+                            "sensor.abstellkammer_illuminance",
+                            "binary_sensor.abstellkammer_motion",
+                        ],
+                        "weight": 0.8,
+                    }
+                ],
+                "note": "Gewichtung korrigiert",
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["manual_override"]["sensor_weights"]["sensor.abstellkammer_illuminance"] == 0.75
+    assert payload["manual_override"]["sensor_weight_groups"][0]["group_id"] == (
+        "abstellkammer_context"
+    )
+    numeric = {
+        candidate["entity_id"]: candidate
+        for candidate in payload["numeric_candidates"]
+    }
+    assert numeric["sensor.abstellkammer_illuminance"]["manual_weight"] == 0.75
+    assert numeric["sensor.abstellkammer_illuminance"]["effective_weight"] == 0.75
+
+
+def test_safety_profile_can_block_actuator_manually(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/safety",
+            json={
+                "safety": {
+                    "stage": "shadow",
+                    "manual_block": True,
+                    "min_confidence": 0.9,
+                    "cooldown_seconds": 120,
+                    "rules": [
+                        {
+                            "rule_id": "manual_block",
+                            "label": "Manuelle Sperre respektieren",
+                            "enabled": True,
+                            "blocking": True,
+                            "reason": "Test",
+                        }
+                    ],
+                    "note": "Test",
+                }
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["behavior"]["safety"]["manual_block"] is True
+    assert payload["behavior"]["safety"]["min_confidence"] == 0.9
+    assert payload["behavior"]["safety"]["cooldown_seconds"] == 120
+
+
+def test_feedback_adapts_sensor_weights_and_model_can_rollback(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post(
+            "/v1/actuators",
+            json={"actuator_entity_id": "light.abstellkammer"},
+        )
+        record = app.state.actuator_store.get("light.abstellkammer")
+        version_id = "model-test"
+        snapshot = ModelSnapshot(
+            version_id=version_id,
+            sample_count=1,
+            high_confidence_sample_count=1,
+            average_confidence=0.9,
+            patterns=[],
+            reason="Test-Snapshot",
+        )
+        app.state.actuator_store.upsert(
+            record.model_copy(
+                update={
+                    "behavior": record.behavior.model_copy(
+                        update={
+                            "model_snapshots": [snapshot],
+                            "active_model_version": "model-current",
+                            "sample_count": 2,
+                        }
+                    )
+                }
+            )
+        )
+
+        feedback = client.post(
+            "/v1/actuators/light.abstellkammer/feedback",
+            json={"correct": False, "expected_state": "off"},
+        )
+        rollback = client.post(
+            "/v1/actuators/light.abstellkammer/model/rollback",
+            json={"version_id": version_id},
+        )
+
+    assert feedback.status_code == 200
+    feedback_payload = feedback.json()
+    assert feedback_payload["behavior"]["adaptive_weight_updates"]
+    assert feedback_payload["manual_override"]["sensor_weights"]
+    assert rollback.status_code == 200
+    assert rollback.json()["behavior"]["active_model_version"] == version_id
+
+
+def test_summary_is_lightweight_and_uses_cached_entity_metadata(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.get("/v1/actuators/summary")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload[0]["actuator_entity_id"] == "light.abstellkammer"
+    assert payload[0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload[0]["area_name"] == "Abstellkammer"
+    assert "behavior" not in payload[0]
+    assert "numeric_candidates" not in payload[0]
+
+
+def test_dashboard_overview_uses_cache_without_ha_roundtrip(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        reader = app.state.ha_reader
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        calls_before = reader.read_entities_calls
+
+        response = client.get("/v1/actuators/dashboard")
+
+    assert response.status_code == 200
+    assert reader.read_entities_calls == calls_before
+    payload = response.json()
+    assert payload["cache"]["available"] is True
+    assert payload["cache"]["entity_count"] == 4
+    assert payload["actuators"][0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload["discovery_groups"]
+    assert payload["jobs"]["jobs"][-1]["kind"] == "discovery"
+
+
+def test_reconciliation_run_records_visible_job_queue(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post("/v1/actuators/reconciliation/run")
+        jobs = client.get("/v1/actuators/job-queue/state")
+
+    assert response.status_code == 200
+    assert jobs.status_code == 200
+    payload = jobs.json()
+    assert [job["kind"] for job in payload["jobs"][-3:]] == [
+        "reconciliation",
+        "training",
+        "evaluation",
+    ]
+    assert payload["jobs"][-1]["status"] == "completed"
+
+
+def test_dashboard_start_path_stays_within_five_second_budget(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        root_started_at = perf_counter()
+        root_response = client.get("/")
+        root_elapsed = perf_counter() - root_started_at
+
+        dashboard_started_at = perf_counter()
+        dashboard_response = client.get("/v1/actuators/dashboard")
+        dashboard_elapsed = perf_counter() - dashboard_started_at
+
+    assert root_response.status_code == 200
+    assert dashboard_response.status_code == 200
+    assert root_elapsed < 5.0
+    assert dashboard_elapsed < 5.0
+
+
+def test_discovery_reads_entities_once_and_reuses_them(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        reader = app.state.ha_reader
+
+        response = client.get("/v1/actuators/discovery", params={"refresh": True})
+
+    assert response.status_code == 200
+    assert reader.read_entities_calls == 1
+
+
+def test_context_options_returns_learnable_entities(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        response = client.get(
+            "/v1/actuators/context-options",
+            params={"actuator_entity_id": "light.abstellkammer"},
+        )
+
+    assert response.status_code == 200
+    entity_ids = {item["entity_id"] for item in response.json()}
+    assert "sensor.abstellkammer_illuminance" in entity_ids
+    assert "binary_sensor.abstellkammer_motion" in entity_ids
+    assert "sensor.pfsense_interface_vpn_inbytes" not in entity_ids
+
+
+def test_actuator_discovery_prefers_light_over_duplicate_switch() -> None:
+    entities = {
+        "light.schreibtisch": HaEntitySummary(
+            entity_id="light.schreibtisch",
+            domain="light",
+            friendly_name="Schreibtisch Licht",
+            device_id="device-1",
+        ),
+        "switch.schreibtisch": HaEntitySummary(
+            entity_id="switch.schreibtisch",
+            domain="switch",
+            friendly_name="Schreibtisch Schalter",
+            device_id="device-1",
+        ),
+        "cover.rollladen": HaEntitySummary(
+            entity_id="cover.rollladen",
+            domain="cover",
+            friendly_name="Rollladen",
+            device_id="device-2",
+        ),
+    }
+
+    result = _deduplicate_actuator_ids(
+        [
+            ("switch.schreibtisch", "switch_socket"),
+            ("light.schreibtisch", "light"),
+            ("cover.rollladen", "cover_shutter"),
+        ],
+        entities,
+    )
+
+    assert result == ["cover.rollladen", "light.schreibtisch"]

tests/api/test_entities.py

@@ -27,6 +27,7 @@ class FakeHaReader(HaReader):
             entity_id="sensor.temperature",
             domain="sensor",
             device_class="temperature",
+            category="temperature",
             role=EntityRole.MEASUREMENT,
             learnable=True,
             reason="Numerischer Messsensor für Zeitreihen und Training.",
@@ -76,6 +77,7 @@ def test_entities_returns_reader_data() -> None:
                 "entity_id": "sensor.temperature",
                 "domain": "sensor",
                 "state": None,
+                "last_changed": None,
                 "state_class": None,
             "device_class": None,
             "unit_of_measurement": None,
@@ -115,6 +117,7 @@ def test_discovery_filters_entities() -> None:
             "device_class": "temperature",
             "state_class": None,
             "unit_of_measurement": None,
+            "category": "temperature",
             "role": "measurement",
             "learnable": True,
             "reason": "Numerischer Messsensor für Zeitreihen und Training.",

tests/behavior/test_engine.py

@@ -5,7 +5,14 @@ from pathlib import Path
 
 import pytest
 
-from app.actuators.models import BehaviorMode, BehaviorStatus
+from app.actuators.models import (
+    BehaviorMode,
+    BehaviorPattern,
+    BehaviorPrediction,
+    BehaviorState,
+    BehaviorStatus,
+    ExecutionEvent,
+)
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine, predict_behavior, service_for_state
 from app.config import Settings
@@ -14,7 +21,7 @@ from app.ha.history import (
     StateHistoryPoint,
     StateHistorySeries,
 )
-from app.ha.models import HaEntitySummary
+from app.ha.models import HaAutomationSummary, HaEntitySummary
 from app.ha.reader import HaReader
 
 
@@ -30,6 +37,7 @@ class FakeBehaviorReader(HaReader):
         self.history = history
         self.logbook = logbook
         self.service_calls: list[tuple[str, str, dict[str, object]]] = []
+        self.automations: list[HaAutomationSummary] = []
 
     def read_entities(self) -> list[HaEntitySummary]:
         return list(self.entities)
@@ -59,6 +67,12 @@ class FakeBehaviorReader(HaReader):
         self.service_calls.append((domain, service, service_data))
         return []
 
+    def find_automations_for_entity(
+        self,
+        entity_id: str,
+    ) -> list[HaAutomationSummary]:
+        return list(self.automations)
+
 
 def _settings(tmp_path: Path) -> Settings:
     return Settings(
@@ -161,8 +175,8 @@ def test_engine_trains_predicts_in_shadow_and_executes_only_after_approval(
     shadow = engine.evaluate("light.office")
 
     assert trained.behavior.status is BehaviorStatus.TRAINED
-    assert trained.behavior.sample_count == 3
+    assert trained.behavior.sample_count == 6
-    assert trained.behavior.high_confidence_sample_count == 3
+    assert trained.behavior.high_confidence_sample_count == 6
     assert shadow.behavior.mode is BehaviorMode.SHADOW
     assert shadow.behavior.prediction is not None
     assert shadow.behavior.prediction.target_state == "on"
@@ -179,14 +193,240 @@ def test_engine_trains_predicts_in_shadow_and_executes_only_after_approval(
     ]
 
 
-def test_engine_excludes_known_automation_actions(tmp_path: Path) -> None:
+def test_engine_counts_known_automation_actions_like_manual_actions(
+    tmp_path: Path,
+) -> None:
     now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
     engine, _ = _engine(tmp_path, now)
 
     trained = engine.train("light.office")
 
-    assert {pattern.target_state for pattern in trained.behavior.patterns} == {"on"}
+    assert {pattern.target_state for pattern in trained.behavior.patterns} == {
-    assert {pattern.source for pattern in trained.behavior.patterns} == {"user"}
+        "on",
+        "off",
+    }
+    assert {pattern.source for pattern in trained.behavior.patterns} == {
+        "user",
+        "automation",
+    }
+    assert trained.behavior.high_confidence_sample_count == 6
+    assert {pattern.weight for pattern in trained.behavior.patterns} == {1.0}
+
+
+def test_feedback_marks_prediction_correct_as_learning_pattern(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.office")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": [
+                        "binary_sensor.office_presence"
+                    ],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "prediction": BehaviorPrediction(
+                        target_state="on",
+                        confidence=0.9,
+                        generated_at=now,
+                        reason="test",
+                    )
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.office", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.office_presence",
+                domain="binary_sensor",
+                state="on",
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.record_feedback("light.office", correct=True)
+
+    assert result.behavior.patterns[-1].target_state == "on"
+    assert result.behavior.patterns[-1].context_states == {
+        "binary_sensor.office_presence": "on"
+    }
+    assert result.behavior.patterns[-1].source == "user_feedback"
+    assert result.behavior.reason == "Vorhersage wurde vom Nutzer als korrekt bestätigt."
+
+
+def test_feedback_marks_prediction_wrong_and_adds_correction(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.office")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": [
+                        "binary_sensor.office_presence"
+                    ],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.office_presence": "on"},
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=1),
+                        )
+                    ],
+                    "prediction": BehaviorPrediction(
+                        target_state="on",
+                        confidence=0.9,
+                        generated_at=now,
+                        reason="test",
+                    ),
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.office", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.office_presence",
+                domain="binary_sensor",
+                state="on",
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.record_feedback(
+        "light.office",
+        correct=False,
+        expected_state="off",
+    )
+
+    assert result.behavior.patterns[0].weight == 0.1
+    assert result.behavior.patterns[-1].target_state == "off"
+    assert result.behavior.patterns[-1].source == "user_correction"
+    assert result.behavior.reason == "Vorhersage wurde vom Nutzer als falsch markiert."
+
+
+def test_engine_learns_causal_automation_with_activation_credit(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    actuator_points: list[StateHistoryPoint] = []
+    door_points: list[StateHistoryPoint] = []
+    logbook: list[LogbookEntry] = []
+    for days_ago in (3, 2, 1):
+        action_at = now - timedelta(days=days_ago)
+        actuator_points.extend(
+            [
+                StateHistoryPoint(
+                    timestamp=action_at - timedelta(minutes=1),
+                    state="off",
+                ),
+                StateHistoryPoint(timestamp=action_at, state="on"),
+            ]
+        )
+        door_points.extend(
+            [
+                StateHistoryPoint(
+                    timestamp=action_at - timedelta(minutes=1),
+                    state="off",
+                ),
+                StateHistoryPoint(
+                    timestamp=action_at - timedelta(seconds=1),
+                    state="on",
+                ),
+            ]
+        )
+        logbook.append(
+            LogbookEntry(
+                entity_id="light.storage",
+                timestamp=action_at,
+                message="turned on",
+                context_domain="automation",
+                context_service="trigger",
+            )
+        )
+    actuator_points.sort(key=lambda point: point.timestamp)
+    door_points.sort(key=lambda point: point.timestamp)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    store.upsert(
+        record.model_copy(
+            update={
+                "assignment": record.assignment.model_copy(
+                    update={
+                        "selected_context_entity_ids": [
+                            "binary_sensor.storage_door"
+                        ],
+                    }
+                )
+            }
+        )
+    )
+    reader = FakeBehaviorReader(
+        entities=[],
+        history=[
+            StateHistorySeries(
+                entity_id="light.storage",
+                points=actuator_points,
+            ),
+            StateHistorySeries(
+                entity_id="binary_sensor.storage_door",
+                points=door_points,
+            ),
+        ],
+        logbook=logbook,
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    trained = engine.train("light.storage")
+    automation_patterns = [
+        pattern
+        for pattern in trained.behavior.patterns
+        if pattern.source == "automation"
+    ]
+
+    assert len(automation_patterns) == 3
+    assert trained.behavior.high_confidence_sample_count == 3
+    assert {pattern.weight for pattern in automation_patterns} == {1.0}
+    assert {
+        (
+            pattern.trigger_entity_id,
+            pattern.trigger_from_state,
+            pattern.trigger_to_state,
+        )
+        for pattern in automation_patterns
+    } == {("binary_sensor.storage_door", "off", "on")}
+
+    active = engine.set_active("light.storage", active=True)
+
+    assert active.behavior.mode is BehaviorMode.ACTIVE
 
 
 def test_active_mode_rejects_unsafe_domains(tmp_path: Path) -> None:
@@ -209,7 +449,7 @@ def test_active_mode_rejects_unsafe_domains(tmp_path: Path) -> None:
         engine.set_active("lock.front_door", active=True)
 
 
-def test_active_mode_requires_user_attributed_actions(tmp_path: Path) -> None:
+def test_active_mode_requires_trusted_manual_or_automation_actions(tmp_path: Path) -> None:
     settings = _settings(tmp_path)
     store = ActuatorStore(settings.actuator_store)
     record = store.configure("light.office")
@@ -229,14 +469,96 @@ def test_active_mode_requires_user_attributed_actions(tmp_path: Path) -> None:
     reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
     engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
 
-    with pytest.raises(ValueError, match="eindeutig dir zugeordnete"):
+    with pytest.raises(ValueError, match="Freigabe"):
         engine.set_active("light.office", active=True)
 
 
+def test_control_handoff_pauses_and_restores_matching_automation(
+    tmp_path: Path,
+) -> None:
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    store.upsert(
+        record.model_copy(
+            update={
+                "behavior": record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.TRAINED,
+                        "sample_count": 3,
+                        "high_confidence_sample_count": 3,
+                        "activation_ready": True,
+                        "activation_reason": "Freigabe bereit.",
+                    }
+                )
+            }
+        )
+    )
+    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
+    reader.automations = [
+        HaAutomationSummary(
+            entity_id="automation.storage_light",
+            config_id="123",
+            friendly_name="Storage light",
+            enabled=True,
+        )
+    ]
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    active = engine.set_active(
+        "light.storage",
+        active=True,
+        pause_matching_automations=True,
+    )
+    shadow = engine.set_active(
+        "light.storage",
+        active=False,
+        restore_paused_automations=True,
+    )
+
+    assert active.behavior.mode is BehaviorMode.ACTIVE
+    assert active.behavior.paused_automation_entity_ids == [
+        "automation.storage_light"
+    ]
+    assert shadow.behavior.mode is BehaviorMode.SHADOW
+    assert shadow.behavior.paused_automation_entity_ids == []
+    assert reader.service_calls == [
+        (
+            "automation",
+            "turn_off",
+            {"entity_id": "automation.storage_light"},
+        ),
+        (
+            "automation",
+            "turn_on",
+            {"entity_id": "automation.storage_light"},
+        ),
+    ]
+
+
+def test_cooldown_allows_opposite_follow_up_action(tmp_path: Path) -> None:
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+    now = datetime.now(timezone.utc)
+    behavior = BehaviorState(
+        mode=BehaviorMode.ACTIVE,
+        last_executed_at=now - timedelta(seconds=5),
+        execution_events=[
+            ExecutionEvent(target_state="on", executed_at=now - timedelta(seconds=5))
+        ],
+    )
+
+    assert engine._cooldown_elapsed(behavior, now, "off") is True
+    assert engine._cooldown_elapsed(behavior, now, "on") is False
+
+
 @pytest.mark.parametrize(
     ("domain", "state", "service"),
     [
         ("light", "on", "turn_on"),
+        ("media_player", "off", "turn_off"),
         ("switch", "off", "turn_off"),
         ("cover", "open", "open_cover"),
         ("cover", "closed", "close_cover"),
@@ -259,3 +581,200 @@ def test_prediction_requires_temporal_support() -> None:
         min_support=3,
         window_minutes=30,
     ) is None
+
+
+def test_prediction_uses_fresh_causal_context_transition_outside_time_window() -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    patterns = [
+        BehaviorPattern(
+            target_state="on",
+            minute_of_day=60,
+            weekday=0,
+            context_states={"binary_sensor.storage_door": "on"},
+            trigger_entity_id="binary_sensor.storage_door",
+            trigger_from_state="off",
+            trigger_to_state="on",
+            source="automation",
+            weight=0.7,
+            observed_at=now - timedelta(days=days_ago),
+        )
+        for days_ago in (3, 2, 1)
+    ]
+
+    prediction = predict_behavior(
+        patterns,
+        current_context={"binary_sensor.storage_door": "on"},
+        current_context_changed_at={
+            "binary_sensor.storage_door": now - timedelta(seconds=10)
+        },
+        now=now,
+        min_support=3,
+        window_minutes=30,
+    )
+
+    assert prediction is not None
+    assert prediction.target_state == "on"
+    assert prediction.matching_patterns == 3
+    assert prediction.confidence == 0.7
+    assert "frischen Sensorwechsel" in prediction.reason
+
+
+def test_prediction_ignores_stale_causal_context_state() -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    pattern = BehaviorPattern(
+        target_state="on",
+        minute_of_day=60,
+        weekday=0,
+        context_states={"binary_sensor.storage_door": "on"},
+        trigger_entity_id="binary_sensor.storage_door",
+        trigger_from_state="off",
+        trigger_to_state="on",
+        source="automation",
+        weight=0.7,
+        observed_at=now - timedelta(days=1),
+    )
+
+    assert predict_behavior(
+        [pattern],
+        current_context={"binary_sensor.storage_door": "on"},
+        current_context_changed_at={
+            "binary_sensor.storage_door": now - timedelta(minutes=5)
+        },
+        now=now,
+        min_support=1,
+        window_minutes=30,
+    ) is None
+
+
+def test_state_change_uses_websocket_context_state_for_immediate_action(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": ["binary_sensor.storage_door"],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="off",
+                last_changed=now - timedelta(minutes=5),
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    engine.handle_state_change(
+        "binary_sensor.storage_door",
+        {"state": "on", "last_changed": now.isoformat()},
+    )
+
+    assert reader.service_calls == [
+        ("light", "turn_on", {"entity_id": "light.storage"})
+    ]
+
+
+def test_state_change_uses_event_cache_without_rest_state_query(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": ["binary_sensor.storage_door"],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[],
+        history=[],
+        logbook=[],
+    )
+
+    def fail_read_entities() -> list[HaEntitySummary]:
+        raise AssertionError("Event-Auswertung darf keinen REST-State lesen.")
+
+    reader.read_entities = fail_read_entities  # type: ignore[method-assign]
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    engine.handle_state_change(
+        "binary_sensor.storage_door",
+        {"state": "on", "last_changed": now.isoformat()},
+        current_entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="on",
+                last_changed=now,
+            ),
+        ],
+    )
+
+    assert reader.service_calls == [
+        ("light", "turn_on", {"entity_id": "light.storage"})
+    ]

tests/ha/test_discovery.py

@@ -74,3 +74,60 @@ def test_discovery_filters_domain_and_learnable() -> None:
     result = discover_entities(entities, domains={" SENSOR "}, learnable=True)
 
     assert [item.entity_id for item in result] == ["sensor.temperature"]
+
+
+@pytest.mark.parametrize(
+    ("entity", "category"),
+    [
+        (
+            HaEntitySummary(entity_id="climate.bad", domain="climate"),
+            "heating",
+        ),
+        (
+            HaEntitySummary(entity_id="lock.front_door", domain="lock"),
+            "lock",
+        ),
+        (
+            HaEntitySummary(entity_id="input_boolean.sleep_mode", domain="input_boolean"),
+            "helper",
+        ),
+        (
+            HaEntitySummary(entity_id="media_player.tv", domain="media_player"),
+            "media_tv",
+        ),
+        (
+            HaEntitySummary(
+                entity_id="sensor.brightness",
+                domain="sensor",
+                device_class="illuminance",
+            ),
+            "brightness",
+        ),
+        (
+            HaEntitySummary(
+                entity_id="binary_sensor.motion",
+                domain="binary_sensor",
+                device_class="motion",
+            ),
+            "presence_motion",
+        ),
+    ],
+)
+def test_classify_entity_categories(entity: HaEntitySummary, category: str) -> None:
+    assert classify_entity(entity).category == category
+
+
+@pytest.mark.parametrize(
+    "entity",
+    [
+        HaEntitySummary(entity_id="automation.lights", domain="automation"),
+        HaEntitySummary(entity_id="update.core", domain="update"),
+    ],
+)
+def test_classify_excludes_non_actuator_management_entities(
+    entity: HaEntitySummary,
+) -> None:
+    result = classify_entity(entity)
+
+    assert result.role is EntityRole.UNSUPPORTED
+    assert result.learnable is False

tests/ha/test_ha_client.py

@@ -108,6 +108,27 @@ def test_list_entity_metadata_calls_template_api() -> None:
     }
 
 
+def test_list_entity_metadata_batches_template_calls() -> None:
+    responses = []
+    for index in range(3):
+        response = _response()
+        response.text = (
+            f'[{{"entity_id":"sensor.test_{index}",'
+            f'"area_name":"Area {index}","device_name":"Device {index}"}}]'
+        )
+        responses.append(response)
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.post = Mock(side_effect=responses)  # type: ignore[method-assign]
+
+    entity_ids = [f"sensor.test_{index}" for index in range(401)]
+    metadata = client.list_entity_metadata(entity_ids)
+
+    assert client._session.post.call_count == 3
+    assert metadata["sensor.test_0"]["area_name"] == "Area 0"
+    assert metadata["sensor.test_1"]["device_name"] == "Device 1"
+    assert metadata["sensor.test_2"]["device_name"] == "Device 2"
+
+
 def test_get_logbook_filters_entity_and_period() -> None:
     response = _response(payload=[{"entity_id": "light.office"}])
     client = _client_with_response(response)

tests/ha/test_ha_reader.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from datetime import datetime, timezone
 
 from app.ha.client import HaClient, HaClientSettings
+from app.ha.exceptions import HaHttpError
 from app.ha.reader import HaReader
 
 
@@ -15,6 +16,7 @@ class FakeHaClient(HaClient):
             {
                 "entity_id": "sensor.temperature",
                 "state": "21.5",
+                "last_changed": "2026-06-14T12:00:00+00:00",
                 "attributes": {
                     "state_class": "measurement",
                     "device_class": "temperature",
@@ -87,6 +89,7 @@ def test_ha_reader_returns_summaries() -> None:
     sensor = next(item for item in summaries if item.entity_id == "sensor.temperature")
     assert sensor.unit_of_measurement == "°C"
     assert sensor.state == "21.5"
+    assert sensor.last_changed == datetime(2026, 6, 14, 12, 0, tzinfo=timezone.utc)
     assert sensor.area_name == "Kueche"
     assert sensor.device_name == "Thermometer"
 
@@ -123,3 +126,48 @@ def test_ha_reader_normalizes_state_history_and_logbook() -> None:
 
     assert history[0].points[0].state == "21.5"
     assert logbook[0].context_user_id == "user-1"
+
+
+def test_ha_reader_finds_automation_that_targets_entity() -> None:
+    client = FakeHaClient()
+    client.list_entities = lambda: [  # type: ignore[method-assign]
+        {
+            "entity_id": "automation.storage_light",
+            "state": "on",
+            "attributes": {
+                "id": "123",
+                "friendly_name": "Storage light",
+            },
+        }
+    ]
+    client.get_automation_config = lambda automation_id: {  # type: ignore[method-assign]
+        "id": automation_id,
+        "target": {"entity_id": "light.storage"},
+    }
+    reader = HaReader(client)
+
+    matches = reader.find_automations_for_entity("light.storage")
+
+    assert len(matches) == 1
+    assert matches[0].entity_id == "automation.storage_light"
+    assert matches[0].enabled is True
+
+
+def test_ha_reader_ignores_automation_configs_not_exposed_by_ha() -> None:
+    client = FakeHaClient()
+    client.list_entities = lambda: [  # type: ignore[method-assign]
+        {
+            "entity_id": "automation.storage_light",
+            "state": "on",
+            "attributes": {
+                "id": "123",
+                "friendly_name": "Storage light",
+            },
+        }
+    ]
+    client.get_automation_config = lambda automation_id: (_ for _ in ()).throw(  # type: ignore[method-assign]
+        HaHttpError(404, "Resource not found")
+    )
+    reader = HaReader(client)
+
+    assert reader.find_automations_for_entity("light.storage") == []

tests/test_addon_config.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+
+def test_addon_does_not_expose_internal_learning_parameters() -> None:
+    config = Path("addon/config.yaml").read_text(encoding="utf-8")
+
+    assert "\noptions:" not in config
+    assert "\nschema:" not in config
+    assert "prediction_confidence" not in config
+    assert "execution_cooldown_seconds" not in config
+
+
+def test_addon_version_invalidates_application_build_layer() -> None:
+    dockerfile = Path("addon/Dockerfile").read_text(encoding="utf-8")
+
+    config_copy = dockerfile.index("COPY config.yaml /tmp/addon-config.yaml")
+    repository_clone = dockerfile.index("git clone --depth 1 --branch main")
+    assert config_copy < repository_clone

tests/test_dashboard.py

@@ -9,7 +9,38 @@ def test_dashboard_is_served_at_root() -> None:
 
     assert response.status_code == 200
     assert "SillyHome Next" in response.text
-    assert "Aktor freigeben" in response.text
+    assert "Arbeitsdashboard für gelernte Home-Assistant-Bedienung" in response.text
-    assert "ausdrücklichen Freigabe pro Aktor" in response.text
+    assert "So gehst du vor" in response.text
+    assert "Steuerung" in response.text
+    assert "Entitätsname oder Gerät aus Home Assistant" in response.text
+    assert "Oder aus Liste wählen" in response.text
+    assert "Liste durchsuchen" in response.text
+    assert "Geräteliste bei Bedarf laden" in response.text
+    assert "Vorschläge können Home Assistant stark abfragen" in response.text
+    assert "Wie gewohnt bedienen" in response.text
+    assert "Ohne deine spätere Freigabe wird nichts geschaltet" in response.text
+    assert "Du wählst keine Sensoren und erstellst keine Regeln" in response.text
+    assert "Freigabestatus" in response.text
+    assert "SillyHome übernehmen lassen" in response.text
+    assert "Passende Home-Assistant-Automationen" in response.text
+    assert "Pausieren" in response.text
+    assert "Davon erkannte HA-Automationen" in response.text
+    assert "Aktuelle Situation auswerten" in response.text
+    assert "Kontext selbst festlegen" in response.text
+    assert "Entity-IDs manuell ergänzen" in response.text
+    assert "manual-context-freeform" in response.text
+    assert "Diese Kontext-Auswahl speichern" in response.text
+    assert "manual-context-select" in response.text
+    assert "Die Prüfung simuliert keinen Sensorwechsel" in response.text
+    assert "Kein frischer passender Sensorwechsel erkannt" in response.text
+    assert "Vorhersage jetzt prüfen" not in response.text
+    assert "record.behavior.activation_ready" in response.text
+    assert "record.behavior.status ===" not in response.text
+    assert "record.behavior_status || record.behavior?.status" in response.text
+    assert 'api("v1/actuators")' not in response.text
+    assert 'api("v1/actuators/summary")' in response.text
+    assert 'api("v1/entities")' not in response.text
+    assert 'details class="collapsible"' in response.text
+    assert 'class="group-panel"' in response.text
     assert "Automation-Entwurf" not in response.text
     assert "Manuelle Overrides" not in response.text

tests/test_main.py

@@ -0,0 +1,150 @@
+import asyncio
+from collections.abc import Sequence
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import anyio
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.actuators.store import ActuatorStore
+from app.behavior.engine import BehaviorEngine
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
+from app.main import _ha_event_listener, app as fastapi_app, lifespan
+
+
+class _FakeWebSocket:
+    def __init__(self, messages: list[str | BaseException]) -> None:
+        self._messages = messages
+        self.sent: list[dict[str, object]] = []
+
+    async def __aenter__(self) -> "_FakeWebSocket":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        return None
+
+    async def recv(self) -> str:
+        message = self._messages.pop(0)
+        if isinstance(message, BaseException):
+            raise message
+        return message
+
+    async def send(self, message: str) -> None:
+        import json
+
+        self.sent.append(json.loads(message))
+
+
+class _RecordingBehaviorEngine(BehaviorEngine):
+    def __init__(self, tmp_path: Path) -> None:
+        super().__init__(
+            ha_reader=MagicMock(),
+            store=ActuatorStore(tmp_path / "actuators"),
+            settings=MagicMock(),
+        )
+        self.state_changes: list[
+            tuple[str, dict[str, object] | None, Sequence[HaEntitySummary] | None]
+        ] = []
+
+    def handle_state_change(
+        self,
+        entity_id: str,
+        new_state: dict[str, object] | None,
+        *,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> None:
+        self.state_changes.append((entity_id, new_state, current_entities))
+
+
+class _FakeHaReader(HaReader):
+    def __init__(self) -> None:
+        pass
+
+    def read_entities(self) -> list[HaEntitySummary]:
+        return [
+            HaEntitySummary(
+                entity_id="light.test",
+                domain="light",
+                state="off",
+            )
+        ]
+
+
+def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
+    async def run_test() -> None:
+        fake_ws = _FakeWebSocket(
+            [
+                '{"type":"auth_required"}',
+                '{"type":"auth_ok"}',
+                (
+                    '{"type":"event","event":{"event_type":"state_changed",'
+                    '"data":{"entity_id":"light.test","new_state":{"state":"on"}}}}'
+                ),
+                asyncio.CancelledError(),
+            ]
+        )
+
+        with patch("websockets.connect", return_value=fake_ws) as connect:
+            try:
+                await _ha_event_listener(mock_app, mock_client)
+            except asyncio.CancelledError:
+                pass
+
+        connect.assert_called_once_with(
+            "ws://homeassistant:8123/api/websocket",
+            ping_interval=20,
+            ping_timeout=10,
+        )
+        assert fake_ws.sent == [
+            {"type": "auth", "access_token": "test-token"},
+            {"id": 1, "type": "subscribe_events", "event_type": "state_changed"},
+        ]
+
+    mock_app = MagicMock()
+    mock_app.state.settings = MagicMock()
+    mock_app.state.settings.ha_url = "http://homeassistant:8123"
+    mock_app.state.settings.ha_token = "test-token"
+    mock_app.state.ws_status = MagicMock()
+    mock_engine = _RecordingBehaviorEngine(tmp_path)
+    mock_app.state.behavior_engine = mock_engine
+    mock_app.state.ha_reader = _FakeHaReader()
+    mock_store = ActuatorStore(tmp_path / "store")
+    mock_store.configure("light.test")
+    mock_app.state.actuator_store = mock_store
+    mock_client = MagicMock()
+
+    anyio.run(run_test)
+    assert len(mock_engine.state_changes) == 1
+    entity_id, new_state, current_entities = mock_engine.state_changes[0]
+    assert entity_id == "light.test"
+    assert new_state == {"state": "on"}
+    assert current_entities == [
+        HaEntitySummary(entity_id="light.test", domain="light", state="on")
+    ]
+    assert mock_app.state.ws_status.status == "connected"
+    assert mock_app.state.ws_status.error is None
+
+
+def test_lifespan_skips_event_listener_without_ha_config() -> None:
+    app = FastAPI()
+    app.state.settings = MagicMock()
+    app.state.settings.ha_configured = False
+
+    async def run_test() -> None:
+        async with lifespan(app):
+            pass
+
+    anyio.run(run_test)
+
+
+def test_websocket_health_returns_unavailable_without_listener() -> None:
+    with TestClient(fastapi_app) as client:
+        response = client.get("/health/websocket")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "unavailable",
+        "error": "WebSocket-Listener nicht initialisiert",
+    }