Fix dashboard text overflow and close v1 docs gaps

Add actuator sensor weighting controls
Stream dashboard loading and header menu
2026-06-17 11:53:25 +02:00 · 2026-06-17 11:41:46 +02:00 · 2026-06-17 07:55:28 +02:00 · 2026-06-17 07:45:30 +02:00 · 2026-06-17 07:33:30 +02:00 · 2026-06-17 01:19:59 +02:00
53 changed files with 8660 additions and 288 deletions
--- a/.env.example
+++ b/.env.example
@@ -2,3 +2,14 @@ SILLYHOME_HA_URL=http://homeassistant.local:8123
 SILLYHOME_HA_TOKEN=REPLACE_ME_WITH_LONG_LIVED_TOKEN
 SILLYHOME_MODEL_STORE=.model_store
 SILLYHOME_AUTOMATION_STORE=.automation_store
+SILLYHOME_ACTUATOR_STORE=.actuator_store
+SILLYHOME_HISTORY_DAYS=14
+SILLYHOME_MIN_TRAINING_POINTS=24
+SILLYHOME_RETRAIN_STALE_HOURS=24
+SILLYHOME_RECONCILE_INTERVAL_SECONDS=900
+SILLYHOME_MIN_BEHAVIOR_ACTIONS=3
+SILLYHOME_PREDICTION_CONFIDENCE=0.82
+SILLYHOME_PREDICTION_WINDOW_MINUTES=30
+SILLYHOME_PREDICTION_INTERVAL_SECONDS=60
+SILLYHOME_EXECUTION_COOLDOWN_SECONDS=900
+SILLYHOME_TIMEZONE=Europe/Berlin
--- a/.gitea/ISSUE_TEMPLATE/bug.md
+++ b/.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.
--- a/.gitea/PULL_REQUEST_TEMPLATE.md
+++ b/.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:
--- a/AGENTS.md
+++ b/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.
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -1,13 +1,24 @@
 # SillyHome Next — Architekturübersicht

-Ziel ist ein lokales, datensparsames, erklärbares Smart-Home-Intelligenzsystem für Home Assistant. Es analysiert Historie, erkennt Gewohnheiten, erstellt Vorhersagen, empfiehlt Automationen und kann auf Wunsch einfach in Automationen übersetzen. Vier Intelligenzebenen sind vorgesehen: regelbasiert, ML-gestützt, LLM-unterstützt und autonomer Hausagent.
+Ziel ist ein lokales, datensparsames und erklärbares Smart-Home-Intelligenzsystem
+für Home Assistant. Nutzer wählen ausschließlich erlaubte Aktoren. Das System
+ordnet Kontext automatisch zu, erkennt historische Nutzerhandlungen, trainiert
+pro Aktor ein Verhaltensmodell und trifft zunächst nur Shadow-Vorhersagen.
+Autonomes Schalten wird separat pro Aktor freigegeben.

 ## Leitentscheidungen

 - Lokal-first und datensparsam; keine Cloudpflicht.
- Trennung von Datenintegration, Trainingspipeline, Vorhersageservice und Erklärungsschicht.
- Standardintegration über MQTT und Home Assistant WebSocket plus REST.
- Schnittstellen über FastAPI und OpenAI-kompatible Endpunkte.
- Langzeitdaten in PostgreSQL und TimescaleDB; Vektoren für semantische Suche optional.
- Deployment über Docker Compose; Kubernetes optional für erweiterte Betriebsgrößen.
+- Trennung von Datenintegration, Kontextzuordnung, Verhaltenslernen,
+  Vorhersage und Aktorausführung.
+- Logbook-basierte Herkunftserkennung; eindeutig erkannte HA-Automationen
+  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 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.
 - Tests, Docs und Changelog sind Pflichtbestandteil jeder Änderung.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,294 @@
 # Changelog

-## Unreleased
- Deterministische, nutzerverständliche Erklärungen für jede Modellvorhersage
- Persistenter Automation-Freigabeprozess mit sicherem YAML-Export
+## 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
+- Historische Handlungserkennung aus HA-State-History und Logbook-Herkunft
+- Persistentes Verhaltensmodell pro Aktor mit Zeit-, Wochentags- und Kontextmustern
+- Shadow-Vorhersagen vor jeder Ausführungsfreigabe
+- Explizite Aktivierung pro Aktor, Konfidenzschwelle, Cooldown und enge Service-Whitelist
+- Schutz vor dem Lernen erkannter HA-Automationen und eigener Schaltvorgänge
+- Automation-Proposal- und Override-Endpunkte aus dem aktiven Produkt entfernt
+
+## 0.4.0 - 2026-06-13
+- Aktuator-zentrierte Einrichtung: Nutzer wählen nur noch Aktuatoren, Sensoren werden deterministisch gefunden und bewertet
+- Persistente automatische und manuelle Sensorzuordnungen mit Evidenz, Confidence, Review-Gating und Neustart-Sicherheit
+- Autonomer Modell-Lebenszyklus auf echter HA-Historie: Training, Retraining bei Staleness oder Datenänderung, Archivierung von Waisen
+- Neues Dashboard und API für Aktuatorauswahl, Reconciliation, Overrides, Modellstatus und Audit-Trail
+- Neue Container-/Add-on-Defaults für Aktuator-Store und periodische Reconciliation ohne zusätzliche Gerätesteuerung

 ## 0.2.0 - 2026-06-13
 - Klassifizierte Home-Assistant-Entity-Discovery mit Lernrelevanz und Filtern
--- a/15
+++ b/15
@@ -4,7 +4,18 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    SILLYHOME_MODEL_STORE=/app/data/models
-ENV SILLYHOME_AUTOMATION_STORE=/app/data/automations
+ENV SILLYHOME_AUTOMATION_STORE=/app/data/automations \
+    SILLYHOME_ACTUATOR_STORE=/app/data/actuators \
+    SILLYHOME_HISTORY_DAYS=14 \
+    SILLYHOME_MIN_TRAINING_POINTS=24 \
+    SILLYHOME_RETRAIN_STALE_HOURS=24 \
+    SILLYHOME_RECONCILE_INTERVAL_SECONDS=900 \
+    SILLYHOME_MIN_BEHAVIOR_ACTIONS=3 \
+    SILLYHOME_PREDICTION_CONFIDENCE=0.82 \
+    SILLYHOME_PREDICTION_WINDOW_MINUTES=30 \
+    SILLYHOME_PREDICTION_INTERVAL_SECONDS=60 \
+    SILLYHOME_EXECUTION_COOLDOWN_SECONDS=900 \
+    SILLYHOME_TIMEZONE=Europe/Berlin

 WORKDIR /app

@@ -15,7 +26,7 @@ COPY app ./app
 COPY backend ./backend
 RUN python -m pip install --upgrade pip && \
    python -m pip install . && \
-    mkdir -p /app/data/models /app/data/automations && \
+    mkdir -p /app/data/models /app/data/automations /app/data/actuators && \
    chown -R sillyhome:sillyhome /app/data

 EXPOSE 8000
--- a/README.md
+++ b/README.md
@@ -1,14 +1,29 @@
 # 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)
+- Arbeitsregeln für Coding-Agenten: [`AGENTS.md`](AGENTS.md)

 ## Reifegrad

-Die aktuelle Entwicklungslinie stellt eine gehärtete technische Basis bereit:
-Home-Assistant-Entities und Historie lesen, Sensoren klassifizieren,
-regelbasierte Bausteine sowie ein lokal trainierbares statistisches
-Baseline-Modell mit persistenter Registry, Confidence und echten
-Evaluationsmetriken.
+Die aktuelle Entwicklungslinie ist vollständig aktor-zentriert: Nutzer wählen
+nur Home-Assistant-Aktuatoren aus. SillyHome Next findet Sensoren, Zustände und
+Kontext automatisch, wertet die vorhandene Historie aus und hält passende
+lokale Modelle autonom aktuell. Es gibt keinen Regel-, Trigger-, Sensor- oder
+YAML-Konfigurationsschritt.

 ## Motivation
 TheSillyHome zeigte die Idee: statt statischer Regeln das Zuhause aus Verhaltensmustern verstehen. Diese Architektur modernisiert den Ansatz in Richtung Explainable AI, hybride Intelligenzebenen und langlebige Wartbarkeit.
@@ -17,7 +32,7 @@ TheSillyHome zeigte die Idee: statt statischer Regeln das Zuhause aus Verhaltens
 - Home Assistant und Sensoren/Aktoren verstehen
 - Historie auswerten und Gewohnheiten erkennen
 - Vorhersagen erstellen und erklären
- Automationen vorschlagen und direkt generieren
+- Persönliches Verhalten pro Aktor lernen und zukünftige Handlungen vorhersagen
 - Lokal-first ohne Cloudpflicht
 - Erweiterbar, testbar, dokumentiert

@@ -46,10 +61,16 @@ uvicorn app.main:app --reload
 - `http://127.0.0.1:8000/v1/entities` - Home-Assistant-Entities
 - `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
+- `POST http://127.0.0.1:8000/v1/actuators/reconciliation/run` - globale Reconciliation manuell anstoßen
 - `http://127.0.0.1:8000/ml/health` - Registry-/Serving-Health
 - `POST http://127.0.0.1:8000/ml/retrain` - Modell-Metadaten aktualisieren
 - `POST http://127.0.0.1:8000/ml/evaluate` - MAE/RMSE/Coverage berechnen
- `POST http://127.0.0.1:8000/v1/automations/proposals` - sicheren Entwurf anlegen

 Ohne vollständige HA-Konfiguration liefert `/v1/entities` bewusst `503`.

@@ -68,7 +89,17 @@ dem Netz muss ein authentifizierender Reverse Proxy vorgeschaltet werden.
 - `SILLYHOME_HA_URL` – Basis-URL deiner Home-Assistant-Instanz (z. B. `http://homeassistant.local:8123`)
 - `SILLYHOME_HA_TOKEN` – Long-Lived Access Token eines dedizierten HA-Benutzers mit minimalen Rechten
 - `SILLYHOME_MODEL_STORE` – Verzeichnis für persistierte Modell-Metadaten
- `SILLYHOME_AUTOMATION_STORE` – Verzeichnis für Automation-Entwürfe
+- `SILLYHOME_ACTUATOR_STORE` – Verzeichnis für persistente Aktor-Zuordnungen und Reconciliation-Status
+- `SILLYHOME_HISTORY_DAYS` – Trainingsfenster für HA-History (1 bis 31 Tage)
+- `SILLYHOME_MIN_TRAINING_POINTS` – Mindestanzahl nutzbarer numerischer Messpunkte vor einem Modelltraining
+- `SILLYHOME_RETRAIN_STALE_HOURS` – Staleness-Grenze für automatisches Retraining
+- `SILLYHOME_RECONCILE_INTERVAL_SECONDS` – Intervall für sichere periodische Reconciliation
+- `SILLYHOME_MIN_BEHAVIOR_ACTIONS` – Mindestzahl gelernter Handlungen vor einer Freigabe
+- `SILLYHOME_PREDICTION_CONFIDENCE` – Mindestkonfidenz für autonomes Schalten
+- `SILLYHOME_PREDICTION_WINDOW_MINUTES` – Zeitfenster um gelernte Handlungsmuster
+- `SILLYHOME_PREDICTION_INTERVAL_SECONDS` – Intervall für Shadow-/Aktiv-Vorhersagen
+- `SILLYHOME_EXECUTION_COOLDOWN_SECONDS` – Mindestabstand zwischen eigenen Schaltungen
+- `SILLYHOME_TIMEZONE` – lokale Zeitzone für Tages- und Wochenmuster

 Niemals Administrator-Tokens oder Passwörter eintragen. `.env` gehört nicht ins
 Versionskontrollsystem.
@@ -81,12 +112,35 @@ unter **Einstellungen → Add-ons → Add-on-Shop → Repositories** diese URL e
 `http://192.168.6.31:3000/pino/sillyhome-next`

 Danach **SillyHome Next** installieren und starten. Das Dashboard wird per Ingress
-geöffnet. Das Add-on nutzt die Supervisor-API nur lesend; Automation-Entwürfe werden
-lokal gespeichert und niemals automatisch ausgeführt.
+geöffnet. Dort werden ausschließlich erlaubte Aktoren ausgewählt; Kontext- und
+Lernentscheidungen erfolgen automatisch.
+
+### Normaler Workflow
+1. Im Dashboard einen Aktor auswählen, zum Beispiel `light.abstellkammer`.
+2. SillyHome Next bewertet automatisch Messwerte, Anwesenheit, Bewegung,
+   Bereiche, Gerätebeziehungen und weitere HA-Kontexte.
+3. Das System verwendet selbstständig die beste verfügbare Zuordnung.
+   Niedrige Sicherheit bleibt als Diagnose sichtbar, verlangt aber keine
+   manuelle Konfiguration.
+4. Sobald genügend Historie vorhanden ist, trainiert und aktualisiert das
+   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. Eindeutig im HA-Logbuch erkannte Automationen
+   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
+Backup öffnen, **SillyHome Next** auswählen und wiederherstellen. Der erste produktive
+Teststand `v0.3.0` wurde als HA-Backup `7df0fca0` gesichert.

 ### Tests
 ```bash
 pytest
 ruff check .
-mypy
+mypy app backend tests
 ```
--- a/addon/Dockerfile
+++ b/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
--- a/addon/config.yaml
+++ b/addon/config.yaml
@@ -1,21 +1,22 @@
 name: SillyHome Next
-version: "0.3.0"
+version: "1.0.5"
 slug: sillyhome_next
-description: Lokale HA-Analyse, Vorhersagen und sichere Automation-Entwürfe
+description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
 url: http://192.168.6.31:3000/pino/sillyhome-next
 arch:
  - amd64
 startup: application
 boot: auto
+watchdog: http://[HOST]:[PORT:8000]/health
 init: false
 ingress: true
 ingress_port: 8000
+panel_title: SillyHome Next
 panel_icon: mdi:home-analytics
+panel_admin: true
 homeassistant_api: true
 hassio_api: false
 auth_api: false
-options: {}
-schema: {}
 map:
  - type: addon_config
    read_only: false
--- a/addon/run.sh
+++ b/addon/run.sh
@@ -5,7 +5,21 @@ export SILLYHOME_HA_URL="${SILLYHOME_HA_URL:-http://supervisor/core}"
 export SILLYHOME_HA_TOKEN="${SILLYHOME_HA_TOKEN:-${SUPERVISOR_TOKEN:-}}"
 export SILLYHOME_MODEL_STORE=/data/models
 export SILLYHOME_AUTOMATION_STORE=/data/automations
+export SILLYHOME_ACTUATOR_STORE=/data/actuators

-mkdir -p "$SILLYHOME_MODEL_STORE" "$SILLYHOME_AUTOMATION_STORE"
+if [ -f /data/options.json ]; then
+  export SILLYHOME_HISTORY_DAYS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("history_days", 14))')"
+  export SILLYHOME_MIN_TRAINING_POINTS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("min_training_points", 24))')"
+  export SILLYHOME_RETRAIN_STALE_HOURS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("retrain_stale_hours", 24))')"
+  export SILLYHOME_RECONCILE_INTERVAL_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("reconcile_interval_seconds", 900))')"
+  export SILLYHOME_MIN_BEHAVIOR_ACTIONS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("min_behavior_actions", 3))')"
+  export SILLYHOME_PREDICTION_CONFIDENCE="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_confidence", 0.82))')"
+  export SILLYHOME_PREDICTION_WINDOW_MINUTES="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_window_minutes", 30))')"
+  export SILLYHOME_PREDICTION_INTERVAL_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_interval_seconds", 60))')"
+  export SILLYHOME_EXECUTION_COOLDOWN_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("execution_cooldown_seconds", 900))')"
+  export SILLYHOME_TIMEZONE="$(python -c 'import json; print(json.load(open("/data/options.json")).get("timezone", "Europe/Berlin"))')"
+fi
+
+mkdir -p "$SILLYHOME_MODEL_STORE" "$SILLYHOME_AUTOMATION_STORE" "$SILLYHOME_ACTUATOR_STORE"
 exec uvicorn app.main:app --app-dir /app --host 0.0.0.0 --port 8000 \
  --proxy-headers --forwarded-allow-ips='*'
--- a/app/actuators/init.py
+++ b/app/actuators/init.py
@@ -0,0 +1,27 @@
+from app.actuators.lifecycle import (
+    ActuatorReconciliationService,
+)
+from app.actuators.models import (
+    ActuatorRecord,
+    AssignmentCandidate,
+    AssignmentSelection,
+    LifecycleAuditEntry,
+    LifecycleStatus,
+    ManualOverride,
+    ReconciliationState,
+    model_id_for_actuator,
+)
+from app.actuators.store import ActuatorStore
+
+__all__ = [
+    "ActuatorReconciliationService",
+    "ActuatorRecord",
+    "ActuatorStore",
+    "AssignmentCandidate",
+    "AssignmentSelection",
+    "LifecycleAuditEntry",
+    "LifecycleStatus",
+    "ManualOverride",
+    "ReconciliationState",
+    "model_id_for_actuator",
+]
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
--- a/app/actuators/models.py
+++ b/app/actuators/models.py
@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+from app.ha.discovery import EntityRole
+
+
+class AssignmentSource(StrEnum):
+    NONE = "none"
+    AUTOMATIC = "automatic"
+    MANUAL = "manual"
+
+
+class LifecycleStatus(StrEnum):
+    PENDING_ASSIGNMENT = "pending_assignment"
+    REVIEW_REQUIRED = "review_required"
+    PENDING_HISTORY = "pending_history"
+    TRAINED = "trained"
+    STALE = "stale"
+    INVALID = "invalid"
+    ORPHANED = "orphaned"
+    ARCHIVED = "archived"
+
+
+class BehaviorMode(StrEnum):
+    SHADOW = "shadow"
+    ACTIVE = "active"
+    PAUSED = "paused"
+
+
+class BehaviorStatus(StrEnum):
+    COLLECTING = "collecting"
+    TRAINED = "trained"
+    BLOCKED = "blocked"
+
+
+class AssignmentCandidate(BaseModel):
+    entity_id: str
+    domain: str
+    role: EntityRole
+    device_class: str | None = None
+    state_class: str | None = None
+    unit_of_measurement: str | None = None
+    friendly_name: str | None = None
+    area_name: str | None = None
+    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)
+
+
+class AssignmentSelection(BaseModel):
+    selected_numeric_entity_id: str | None = None
+    selected_context_entity_ids: list[str] = Field(default_factory=list)
+    source: AssignmentSource = AssignmentSource.NONE
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+    review_required: bool = True
+    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
+
+
+class LifecycleAuditEntry(BaseModel):
+    at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    action: str = Field(min_length=1, max_length=120)
+    reason: str = Field(min_length=1, max_length=500)
+
+
+class ModelLifecycleState(BaseModel):
+    model_id: str
+    status: LifecycleStatus = LifecycleStatus.PENDING_ASSIGNMENT
+    last_reconciled_at: datetime | None = None
+    last_trained_at: datetime | None = None
+    last_history_signature: str | None = None
+    last_history_point_count: int = Field(default=0, ge=0)
+    reason: str = "Noch keine Trainingsdaten ausgewertet."
+    next_action: str = "Aktor auswählen; Kontext und Historie werden automatisch geprüft."
+    audit: list[LifecycleAuditEntry] = Field(default_factory=list)
+
+
+class BehaviorPattern(BaseModel):
+    target_state: str = Field(min_length=1, max_length=100)
+    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
+
+
+class BehaviorPrediction(BaseModel):
+    target_state: str
+    confidence: float = Field(ge=0.0, le=1.0)
+    generated_at: datetime
+    reason: str
+    matching_patterns: int = Field(default=0, ge=0)
+    executed: bool = False
+    execution_reason: str = "Vorhersage wurde noch nicht ausgeführt."
+
+
+class ExecutionEvent(BaseModel):
+    target_state: str
+    executed_at: datetime
+
+
+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
+    approved_at: datetime | None = None
+    sample_count: int = Field(default=0, ge=0)
+    high_confidence_sample_count: int = Field(default=0, ge=0)
+    patterns: list[BehaviorPattern] = Field(default_factory=list)
+    prediction: BehaviorPrediction | None = None
+    last_trained_at: datetime | None = None
+    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."
+
+
+class ActuatorRecord(BaseModel):
+    actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
+    enabled: bool = True
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    assignment: AssignmentSelection = Field(default_factory=AssignmentSelection)
+    manual_override: ManualOverride | None = None
+    numeric_candidates: list[AssignmentCandidate] = Field(default_factory=list)
+    context_candidates: list[AssignmentCandidate] = Field(default_factory=list)
+    lifecycle: ModelLifecycleState
+    behavior: BehaviorState = Field(default_factory=BehaviorState)
+
+
+class ReconciliationState(BaseModel):
+    last_started_at: datetime | None = None
+    last_completed_at: datetime | None = None
+    last_trigger: str | None = None
+    running: bool = False
+    configured_actuators: int = Field(default=0, ge=0)
+    review_required: int = Field(default=0, ge=0)
+    trained_models: int = Field(default=0, ge=0)
+    last_summary: str = "Noch keine Reconciliation ausgeführt."
+
+
+def model_id_for_actuator(actuator_entity_id: str) -> str:
+    return f"actuator.{actuator_entity_id}"
--- a/app/actuators/store.py
+++ b/app/actuators/store.py
@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from threading import RLock
+
+from app.actuators.models import (
+    ActuatorRecord,
+    LifecycleStatus,
+    ModelLifecycleState,
+    ReconciliationState,
+    model_id_for_actuator,
+)
+
+
+class ActuatorStore:
+    def __init__(self, root: str | Path) -> None:
+        self._root = Path(root).resolve()
+        self._actuators_root = self._root / "actuators"
+        self._actuators_root.mkdir(parents=True, exist_ok=True)
+        self._lock = RLock()
+        self._reconciliation_state_path = self._root / "reconciliation_state.json"
+
+    def list(self) -> list[ActuatorRecord]:
+        with self._lock:
+            return [self._load(path) for path in sorted(self._actuators_root.glob("*.json"))]
+
+    def get(self, actuator_entity_id: str) -> ActuatorRecord:
+        with self._lock:
+            target = self._target(actuator_entity_id)
+            if not target.exists():
+                raise KeyError("Aktuator-Konfiguration nicht gefunden.")
+            return self._load(target)
+
+    def upsert(self, record: ActuatorRecord) -> ActuatorRecord:
+        with self._lock:
+            self._persist(record)
+            return record
+
+    def configure(self, actuator_entity_id: str, *, enabled: bool = True) -> ActuatorRecord:
+        with self._lock:
+            target = self._target(actuator_entity_id)
+            if target.exists():
+                record = self._load(target)
+                updated = record.model_copy(
+                    update={
+                        "enabled": enabled,
+                        "updated_at": datetime.now(timezone.utc),
+                    }
+                )
+                self._persist(updated)
+                return updated
+            record = ActuatorRecord(
+                actuator_entity_id=actuator_entity_id,
+                enabled=enabled,
+                lifecycle=ModelLifecycleState(
+                    model_id=model_id_for_actuator(actuator_entity_id),
+                    status=LifecycleStatus.PENDING_ASSIGNMENT,
+                ),
+            )
+            self._persist(record)
+            return record
+
+    def delete(self, actuator_entity_id: str) -> None:
+        with self._lock:
+            target = self._target(actuator_entity_id)
+            if target.exists():
+                target.unlink()
+
+    def load_reconciliation_state(self) -> ReconciliationState:
+        with self._lock:
+            if not self._reconciliation_state_path.exists():
+                return ReconciliationState()
+            try:
+                return ReconciliationState.model_validate_json(
+                    self._reconciliation_state_path.read_text(encoding="utf-8")
+                )
+            except ValueError as exc:
+                raise ValueError("Ungültiger Reconciliation-Status.") from exc
+
+    def save_reconciliation_state(self, state: ReconciliationState) -> ReconciliationState:
+        with self._lock:
+            self._persist_reconciliation_state(state)
+            return state
+
+    def _target(self, actuator_entity_id: str) -> Path:
+        if "." not in actuator_entity_id:
+            raise ValueError("Ungültige actuator_entity_id.")
+        safe_name = actuator_entity_id.replace(".", "__")
+        return self._actuators_root / f"{safe_name}.json"
+
+    def _persist(self, record: ActuatorRecord) -> None:
+        target = self._target(record.actuator_entity_id)
+        temporary = target.with_suffix(".json.tmp")
+        temporary.write_text(
+            json.dumps(record.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, target)
+
+    def _persist_reconciliation_state(self, state: ReconciliationState) -> None:
+        temporary = self._reconciliation_state_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._reconciliation_state_path)
+
+    @staticmethod
+    def _load(path: Path) -> ActuatorRecord:
+        try:
+            return ActuatorRecord.model_validate_json(path.read_text(encoding="utf-8"))
+        except ValueError as exc:
+            raise ValueError(f"Ungültige Aktuator-Konfiguration: {path.name}") from exc
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -0,0 +1,716 @@
+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, SensorWeightGroup
+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 DiscoveredEntity, EntityRole, discover_entities
+from app.ha.exceptions import HaClientError
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
+
+router = APIRouter(prefix="/v1/actuators", tags=["actuators"])
+
+
+class ConfigureActuatorRequest(BaseModel):
+    actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
+    enabled: bool = True
+
+
+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 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]
+
+
+@router.get("/discovery", response_model=list[HaEntitySummary])
+def discover_actuators(
+    request: Request,
+    refresh: bool = Query(default=False),
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> 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:
+        fresh_entities = list(ha_reader.read_entities())
+        _save_cached_entities(request, fresh_entities)
+        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)
+    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,
+    )
+
+
+@router.get("", response_model=list[ActuatorRecord])
+def list_configured(request: Request) -> list[ActuatorRecord]:
+    return _service(request).list_configured()
+
+
+@router.post("", response_model=ActuatorRecord, status_code=201)
+def configure(payload: ConfigureActuatorRequest, request: Request) -> ActuatorRecord:
+    try:
+        record = _service(request).configure_actuator(
+            payload.actuator_entity_id,
+            enabled=payload.enabled,
+        )
+        _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
+
+
+@router.get("/{actuator_entity_id}", response_model=ActuatorRecord)
+def get_actuator(actuator_entity_id: str, request: Request) -> ActuatorRecord:
+    try:
+        return _service(request).get_actuator(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.delete("/{actuator_entity_id}", status_code=204)
+def delete_actuator(actuator_entity_id: str, request: Request) -> None:
+    _service(request).delete_actuator(actuator_entity_id)
+
+
+@router.post("/{actuator_entity_id}/reconcile", response_model=ActuatorRecord)
+def reconcile_actuator(
+    actuator_entity_id: str,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        _service(request).reconcile_actuator(actuator_entity_id, trigger="manual")
+        _behavior(request).train(actuator_entity_id)
+        return _behavior(request).evaluate(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/{actuator_entity_id}/evaluate", response_model=ActuatorRecord)
+def evaluate_actuator(
+    actuator_entity_id: str,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).evaluate(actuator_entity_id)
+    except KeyError as exc:
+        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}/activation", response_model=ActuatorRecord)
+def set_activation(
+    actuator_entity_id: str,
+    payload: ActivationRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        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:
+    try:
+        return _behavior(request).refresh_related_automations(actuator_entity_id)
+    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.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)
+    if not isinstance(store, ActuatorStore):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Actuator Store nicht initialisiert.",
+        )
+    return store.load_reconciliation_state()
+
+
+@router.post("/reconciliation/run", response_model=ReconciliationState)
+def run_reconciliation(
+    request: Request,
+    trigger: str = Query(default="manual", pattern=r"^[a-z0-9_-]{1,32}$"),
+) -> ReconciliationState:
+    state = _service(request).reconcile_all(trigger=trigger)
+    _behavior(request).train_all()
+    _behavior(request).evaluate_all()
+    return state
+
+
+def _service(request: Request) -> ActuatorReconciliationService:
+    service = getattr(request.app.state, "actuator_service", None)
+    if not isinstance(service, ActuatorReconciliationService):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Actuator-Reconciliation nicht initialisiert.",
+        )
+    return service
+
+
+def _behavior(request: Request) -> BehaviorEngine:
+    engine = getattr(request.app.state, "behavior_engine", None)
+    if not isinstance(engine, BehaviorEngine):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            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
--- a/app/behavior/init.py
+++ b/app/behavior/init.py
@@ -0,0 +1 @@
+"""Learning and prediction for actuator behavior."""
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
@@ -0,0 +1,992 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+
+from app.actuators.models import (
+    ActuatorRecord,
+    BehaviorMode,
+    BehaviorPattern,
+    BehaviorPrediction,
+    BehaviorState,
+    BehaviorStatus,
+    ExecutionEvent,
+    RelatedAutomation,
+)
+from app.actuators.store import ActuatorStore
+from app.config import Settings
+from app.ha.exceptions import HaClientError
+from app.ha.history import LogbookEntry, StateHistoryPoint, StateHistorySeries
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
+
+_MAX_PATTERNS = 500
+_MAX_EXECUTION_EVENTS = 100
+_ACTION_LOGBOOK_TOLERANCE = timedelta(seconds=10)
+_CONTEXT_TRIGGER_TOLERANCE = timedelta(seconds=3)
+_OWN_ACTION_TOLERANCE = timedelta(seconds=20)
+_SAFE_ACTIVE_DOMAINS = frozenset({"cover", "fan", "humidifier", "light", "switch"})
+_AUTOMATION_CONTEXT_DOMAINS = frozenset({"automation", "script"})
+logger = logging.getLogger(__name__)
+
+
+class BehaviorEngine:
+    def __init__(
+        self,
+        *,
+        ha_reader: HaReader,
+        store: ActuatorStore,
+        settings: Settings,
+    ) -> None:
+        self._ha_reader = ha_reader
+        self._store = store
+        self._settings = settings
+
+    def train_all(self) -> list[ActuatorRecord]:
+        results: list[ActuatorRecord] = []
+        for record in self._store.list():
+            try:
+                results.append(self.train(record.actuator_entity_id))
+            except Exception:
+                logger.exception("Behavior training failed for %s", record.actuator_entity_id)
+                results.append(record)
+        return results
+
+    def train(self, actuator_entity_id: str) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        raw_context_ids = list(
+            dict.fromkeys(
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+        )
+        context_ids = [
+            entity_id for entity_id in raw_context_ids if isinstance(entity_id, str)
+        ]
+        if not context_ids:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.COLLECTING,
+                        "activation_ready": False,
+                        "activation_reason": (
+                            "Freigabe gesperrt: Noch kein geeigneter Kontext erkannt."
+                        ),
+                        "last_trained_at": now,
+                        "reason": "Noch kein geeigneter Kontext für Verhaltenslernen vorhanden.",
+                    }
+                ),
+            )
+
+        start = now - timedelta(days=self._settings.history_days)
+        history_ids = [actuator_entity_id, *context_ids]
+        try:
+            history = {
+                series.entity_id: series
+                for series in self._ha_reader.read_state_history(history_ids, start, now)
+            }
+        except (HaClientError, ValueError) as exc:
+            logger.warning("Behavior history unavailable for %s: %s", actuator_entity_id, exc)
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.BLOCKED,
+                        "last_trained_at": now,
+                        "reason": f"Home-Assistant-Historie konnte nicht gelesen werden: {exc}",
+                    }
+                ),
+            )
+        actuator_history = history.get(actuator_entity_id)
+        if actuator_history is None or len(actuator_history.points) < 2:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.COLLECTING,
+                        "sample_count": 0,
+                        "high_confidence_sample_count": 0,
+                        "activation_ready": False,
+                        "activation_reason": (
+                            "Freigabe gesperrt: Noch keine historischen "
+                            "Aktorhandlungen gefunden."
+                        ),
+                        "patterns": [],
+                        "last_trained_at": now,
+                        "reason": "Noch keine historischen Aktorhandlungen gefunden.",
+                    }
+                ),
+            )
+
+        try:
+            logbook = list(self._ha_reader.read_logbook(actuator_entity_id, start, now))
+        except (HaClientError, ValueError) as exc:
+            logger.warning("Logbook unavailable for %s: %s", actuator_entity_id, exc)
+            logbook = []
+        patterns = self._build_patterns(
+            actuator_history=actuator_history,
+            context_history=history,
+            context_ids=context_ids,
+            logbook=logbook,
+            own_executions=record.behavior.execution_events,
+        )
+        trusted_actions = sum(
+            1 for pattern in patterns if pattern.source in {"user", "automation"}
+        )
+        status = (
+            BehaviorStatus.TRAINED
+            if len(patterns) >= self._settings.min_behavior_actions
+            else BehaviorStatus.COLLECTING
+        )
+        reason = (
+            f"{len(patterns)} Handlungen mit automatisch erfasstem Kontext gelernt."
+            if status is BehaviorStatus.TRAINED
+            else (
+                f"{len(patterns)} von mindestens {self._settings.min_behavior_actions} "
+                "benötigten Handlungen gelernt."
+            )
+        )
+        activation_ready = (
+            status is BehaviorStatus.TRAINED
+            and trusted_actions >= self._settings.min_behavior_actions
+        )
+        activation_reason = (
+            "Freigabe bereit: Genügend eindeutig zugeordnete Handlungen gelernt."
+            if activation_ready
+            else (
+                "Freigabe gesperrt: "
+                f"{max(0, self._settings.min_behavior_actions - trusted_actions)} "
+                "eindeutig zugeordnete Handlungen fehlen."
+            )
+        )
+        behavior = record.behavior.model_copy(
+            update={
+                "status": status,
+                "sample_count": len(patterns),
+                "high_confidence_sample_count": trusted_actions,
+                "activation_ready": activation_ready,
+                "activation_reason": activation_reason,
+                "patterns": patterns[-_MAX_PATTERNS:],
+                "last_trained_at": now,
+                "reason": reason,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def evaluate_all(self) -> list[ActuatorRecord]:
+        results: list[ActuatorRecord] = []
+        for record in self._store.list():
+            try:
+                results.append(self.evaluate(record.actuator_entity_id))
+            except Exception:
+                logger.exception("Behavior evaluation failed for %s", record.actuator_entity_id)
+                results.append(record)
+        return results
+
+    def evaluate(
+        self,
+        actuator_entity_id: str,
+        *,
+        context_state_overrides: dict[str, str | None] | None = None,
+        context_changed_at_overrides: dict[str, datetime | None] | None = None,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        if current_entities is None:
+            try:
+                current_entities = self._ha_reader.read_entities()
+            except HaClientError as exc:
+                logger.warning("Current HA state unavailable for %s: %s", actuator_entity_id, exc)
+                return self._save_behavior(
+                    record,
+                    record.behavior.model_copy(
+                        update={
+                            "last_evaluated_at": now,
+                            "prediction": None,
+                            "reason": f"Aktueller Home-Assistant-Zustand ist nicht verfügbar: {exc}",
+                        }
+                    ),
+                )
+        entities = {entity.entity_id: entity for entity in current_entities}
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "last_evaluated_at": now,
+                        "prediction": None,
+                        "reason": "Aktor ist aktuell nicht in Home Assistant verfügbar.",
+                    }
+                ),
+            )
+        current_context = {
+            entity_id: entities[entity_id].state
+            for entity_id in (
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+            if entity_id and entity_id in entities and entities[entity_id].state is not None
+        }
+        current_context_changed_at = {
+            entity_id: entities[entity_id].last_changed
+            for entity_id in current_context
+        }
+        selected_context_ids = {
+            entity_id
+            for entity_id in (
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+            if entity_id
+        }
+        for entity_id, state in (context_state_overrides or {}).items():
+            if entity_id in selected_context_ids and state is not None:
+                current_context[entity_id] = state
+        for entity_id, changed_at in (context_changed_at_overrides or {}).items():
+            if entity_id in current_context:
+                current_context_changed_at[entity_id] = changed_at or now
+        prediction = predict_behavior(
+            record.behavior.patterns,
+            current_context=current_context,
+            current_context_changed_at=current_context_changed_at,
+            now=now,
+            min_support=self._settings.min_behavior_actions,
+            window_minutes=self._settings.prediction_window_minutes,
+            causal_window_seconds=self._settings.prediction_interval_seconds * 2,
+            timezone_name=self._settings.timezone,
+        )
+        if prediction is not None:
+            prediction = prediction.model_copy(
+                update={
+                    "execution_reason": self._prediction_execution_reason(
+                        record,
+                        actuator.state,
+                        prediction,
+                        now,
+                    )
+                }
+            )
+        behavior = record.behavior.model_copy(
+            update={
+                "last_evaluated_at": now,
+                "prediction": prediction,
+                "reason": (
+                    prediction.reason
+                    if prediction is not None
+                    else "Aktuell ist kein gelerntes Handlungsmuster fällig."
+                ),
+            }
+        )
+        if (
+            prediction is not None
+            and behavior.mode is BehaviorMode.ACTIVE
+            and prediction.confidence >= self._settings.prediction_confidence
+            and actuator.state != prediction.target_state
+            and self._cooldown_elapsed(
+                behavior,
+                now,
+                prediction.target_state,
+            )
+        ):
+            domain = actuator_entity_id.split(".", 1)[0]
+            service = service_for_state(domain, prediction.target_state)
+            if service is not None:
+                try:
+                    self._ha_reader.call_service(
+                        domain,
+                        service,
+                        {"entity_id": actuator_entity_id},
+                    )
+                except (HaClientError, ValueError) as exc:
+                    logger.error(
+                        "Predicted action failed for %s: %s",
+                        actuator_entity_id,
+                        exc,
+                    )
+                    behavior = behavior.model_copy(
+                        update={
+                            "reason": f"Vorhersage wurde aus Sicherheitsgründen nicht ausgeführt: {exc}"
+                        }
+                    )
+                    return self._save_behavior(record, behavior)
+                event = ExecutionEvent(
+                    target_state=prediction.target_state,
+                    executed_at=now,
+                )
+                behavior = behavior.model_copy(
+                    update={
+                        "prediction": prediction.model_copy(
+                            update={
+                                "executed": True,
+                                "execution_reason": (
+                                    f"Ausgeführt mit {prediction.confidence:.0%} Sicherheit."
+                                ),
+                            }
+                        ),
+                        "last_executed_at": now,
+                        "execution_events": [
+                            *behavior.execution_events,
+                            event,
+                        ][-_MAX_EXECUTION_EVENTS:],
+                        "reason": (
+                            f"Vorhersage mit {prediction.confidence:.0%} Sicherheit ausgeführt."
+                        ),
+                    }
+                )
+            else:
+                behavior = behavior.model_copy(
+                    update={
+                        "reason": (
+                            f"Der vorhergesagte Zustand {prediction.target_state!r} "
+                            "ist für autonomes Schalten nicht freigegeben."
+                        )
+                    }
+                )
+        return self._save_behavior(record, behavior)
+
+    def record_feedback(
+        self,
+        actuator_entity_id: str,
+        *,
+        correct: bool,
+        expected_state: str | None = None,
+    ) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        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("Aktor ist aktuell nicht in Home Assistant verfügbar.")
+        context_ids = [
+            entity_id
+            for entity_id in [
+                record.assignment.selected_numeric_entity_id,
+                *record.assignment.selected_context_entity_ids,
+            ]
+            if entity_id
+        ]
+        current_context = {
+            entity_id: entities[entity_id].state
+            for entity_id in context_ids
+            if entity_id in entities and entities[entity_id].state is not None
+        }
+        prediction = record.behavior.prediction
+        patterns = list(record.behavior.patterns)
+        reason = "Nutzerfeedback gespeichert."
+        if correct and prediction is not None:
+            local = now.astimezone(ZoneInfo(self._settings.timezone))
+            patterns.append(
+                BehaviorPattern(
+                    target_state=prediction.target_state,
+                    minute_of_day=local.hour * 60 + local.minute,
+                    weekday=local.weekday(),
+                    context_states={
+                        entity_id: state
+                        for entity_id, state in current_context.items()
+                        if state is not None
+                    },
+                    source="user_feedback",
+                    weight=1.0,
+                    observed_at=now,
+                )
+            )
+            reason = "Vorhersage wurde vom Nutzer als korrekt bestätigt."
+        else:
+            target = prediction.target_state if prediction is not None else None
+            if target:
+                patterns = [
+                    pattern.model_copy(update={"weight": 0.1})
+                    if pattern.target_state == target
+                    and _pattern_context_matches(pattern, current_context)
+                    else pattern
+                    for pattern in patterns
+                ]
+            if expected_state:
+                local = now.astimezone(ZoneInfo(self._settings.timezone))
+                patterns.append(
+                    BehaviorPattern(
+                        target_state=expected_state,
+                        minute_of_day=local.hour * 60 + local.minute,
+                        weekday=local.weekday(),
+                        context_states={
+                            entity_id: state
+                            for entity_id, state in current_context.items()
+                            if state is not None
+                        },
+                        source="user_correction",
+                        weight=1.0,
+                        observed_at=now,
+                    )
+                )
+            reason = "Vorhersage wurde vom Nutzer als falsch markiert."
+        behavior = record.behavior.model_copy(
+            update={
+                "patterns": patterns[-_MAX_PATTERNS:],
+                "prediction": (
+                    prediction.model_copy(update={"execution_reason": reason})
+                    if prediction is not None
+                    else None
+                ),
+                "reason": reason,
+                "last_trained_at": now,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def refresh_related_automations(self, actuator_entity_id: str) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        related = [
+            RelatedAutomation(
+                entity_id=item.entity_id,
+                config_id=item.config_id,
+                friendly_name=item.friendly_name,
+                enabled=item.enabled,
+            )
+            for item in self._ha_reader.find_automations_for_entity(
+                actuator_entity_id
+            )
+        ]
+        behavior = record.behavior.model_copy(
+            update={"related_automations": related}
+        )
+        return self._save_behavior(record, behavior)
+
+    def set_automation_enabled(
+        self,
+        actuator_entity_id: str,
+        automation_entity_id: str,
+        *,
+        enabled: bool,
+    ) -> ActuatorRecord:
+        record = self.refresh_related_automations(actuator_entity_id)
+        if automation_entity_id not in {
+            item.entity_id for item in record.behavior.related_automations
+        }:
+            raise ValueError(
+                "Die Automation ist diesem Aktor nicht eindeutig zugeordnet."
+            )
+        self._ha_reader.call_service(
+            "automation",
+            "turn_on" if enabled else "turn_off",
+            {"entity_id": automation_entity_id},
+        )
+        related = [
+            item.model_copy(update={"enabled": enabled})
+            if item.entity_id == automation_entity_id
+            else item
+            for item in record.behavior.related_automations
+        ]
+        paused = [
+            entity_id
+            for entity_id in record.behavior.paused_automation_entity_ids
+            if entity_id != automation_entity_id
+        ]
+        behavior = record.behavior.model_copy(
+            update={
+                "related_automations": related,
+                "paused_automation_entity_ids": paused,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def set_active(
+        self,
+        actuator_entity_id: str,
+        *,
+        active: bool,
+        pause_matching_automations: bool = False,
+        restore_paused_automations: bool = False,
+    ) -> ActuatorRecord:
+        record = self.refresh_related_automations(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        if active:
+            domain = actuator_entity_id.split(".", 1)[0]
+            if domain not in _SAFE_ACTIVE_DOMAINS:
+                raise ValueError(
+                    f"Automatisches Schalten ist für die Domain {domain} nicht freigegeben."
+                )
+            if record.behavior.status is not BehaviorStatus.TRAINED:
+                raise ValueError("Das Verhaltensmodell hat noch nicht genügend Handlungen gelernt.")
+            if not record.behavior.activation_ready:
+                raise ValueError(record.behavior.activation_reason)
+            mode = BehaviorMode.ACTIVE
+            approved_at = now
+            behavior = record.behavior.model_copy(
+                update={
+                    "mode": mode,
+                    "approved_at": approved_at,
+                    "reason": (
+                        "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
+                    ),
+                }
+            )
+            record = self._save_behavior(record, behavior)
+            if pause_matching_automations:
+                paused: list[str] = []
+                try:
+                    for automation in record.behavior.related_automations:
+                        if not automation.enabled:
+                            continue
+                        self._ha_reader.call_service(
+                            "automation",
+                            "turn_off",
+                            {"entity_id": automation.entity_id},
+                        )
+                        paused.append(automation.entity_id)
+                except (HaClientError, ValueError):
+                    for entity_id in paused:
+                        try:
+                            self._ha_reader.call_service(
+                                "automation",
+                                "turn_on",
+                                {"entity_id": entity_id},
+                            )
+                        except (HaClientError, ValueError):
+                            logger.exception(
+                                "Failed to restore automation %s after handoff error",
+                                entity_id,
+                            )
+                    rollback = record.behavior.model_copy(
+                        update={
+                            "mode": BehaviorMode.SHADOW,
+                            "approved_at": None,
+                            "reason": (
+                                "Übernahme fehlgeschlagen; SillyHome bleibt im "
+                                "Shadow-Modus."
+                            ),
+                        }
+                    )
+                    self._save_behavior(record, rollback)
+                    raise
+                related = [
+                    automation.model_copy(update={"enabled": False})
+                    if automation.entity_id in paused
+                    else automation
+                    for automation in record.behavior.related_automations
+                ]
+                behavior = record.behavior.model_copy(
+                    update={
+                        "related_automations": related,
+                        "paused_automation_entity_ids": paused,
+                        "reason": (
+                            "SillyHome steuert aktiv; passende HA-Automationen "
+                            "wurden pausiert."
+                        ),
+                    }
+                )
+                return self._save_behavior(record, behavior)
+            return record
+        else:
+            if restore_paused_automations:
+                for entity_id in record.behavior.paused_automation_entity_ids:
+                    self._ha_reader.call_service(
+                        "automation",
+                        "turn_on",
+                        {"entity_id": entity_id},
+                    )
+            mode = BehaviorMode.SHADOW
+            approved_at = None
+            reason = (
+                "Shadow-Modus aktiv; pausierte HA-Automationen wurden fortgesetzt."
+                if restore_paused_automations
+                else "Shadow-Modus aktiv; Vorhersagen werden nicht ausgeführt."
+            )
+        behavior = record.behavior.model_copy(
+            update={
+                "mode": mode,
+                "approved_at": approved_at,
+                "related_automations": [
+                    automation.model_copy(update={"enabled": True})
+                    if (
+                        restore_paused_automations
+                        and automation.entity_id
+                        in record.behavior.paused_automation_entity_ids
+                    )
+                    else automation
+                    for automation in record.behavior.related_automations
+                ],
+                "paused_automation_entity_ids": (
+                    []
+                    if restore_paused_automations
+                    else record.behavior.paused_automation_entity_ids
+                ),
+                "reason": reason,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def _prediction_execution_reason(
+        self,
+        record: ActuatorRecord,
+        current_state: str | None,
+        prediction: BehaviorPrediction,
+        now: datetime,
+    ) -> str:
+        if record.behavior.mode is not BehaviorMode.ACTIVE:
+            return "Nicht ausgeführt: SillyHome ist im Shadow-Modus."
+        if prediction.confidence < self._settings.prediction_confidence:
+            return (
+                "Nicht ausgeführt: Sicherheit liegt unter der "
+                f"Schaltschwelle von {self._settings.prediction_confidence:.0%}."
+            )
+        if current_state == prediction.target_state:
+            return "Nicht ausgeführt: Zielzustand ist bereits erreicht."
+        if not self._cooldown_elapsed(
+            record.behavior,
+            now,
+            prediction.target_state,
+        ):
+            return "Nicht ausgeführt: Sicherheits-Cooldown ist noch aktiv."
+        return "Ausführung ist freigegeben."
+
+    def _build_patterns(
+        self,
+        *,
+        actuator_history: StateHistorySeries,
+        context_history: dict[str, StateHistorySeries],
+        context_ids: list[str],
+        logbook: list[LogbookEntry],
+        own_executions: list[ExecutionEvent],
+    ) -> list[BehaviorPattern]:
+        patterns: list[BehaviorPattern] = []
+        previous_state = actuator_history.points[0].state
+        for point in actuator_history.points[1:]:
+            if point.state == previous_state:
+                continue
+            previous_state = point.state
+            if _matches_own_execution(point, own_executions):
+                continue
+            source, weight = _action_source(point, logbook)
+            trigger = _recent_context_transition(
+                context_history,
+                context_ids,
+                point.timestamp,
+            )
+            contexts = {
+                entity_id: state
+                for entity_id in context_ids
+                if (state := _state_at(context_history.get(entity_id), point.timestamp)) is not None
+            }
+            local = point.timestamp.astimezone(ZoneInfo(self._settings.timezone))
+            patterns.append(
+                BehaviorPattern(
+                    target_state=point.state,
+                    minute_of_day=local.hour * 60 + local.minute,
+                    weekday=local.weekday(),
+                    context_states=contexts,
+                    trigger_entity_id=trigger[0] if trigger else None,
+                    trigger_from_state=trigger[1] if trigger else None,
+                    trigger_to_state=trigger[2] if trigger else None,
+                    source=source,
+                    weight=weight,
+                    observed_at=point.timestamp,
+                )
+            )
+        return patterns
+
+    def _cooldown_elapsed(
+        self,
+        behavior: BehaviorState,
+        now: datetime,
+        target_state: str,
+    ) -> bool:
+        if behavior.last_executed_at is None:
+            return True
+        last_event = behavior.execution_events[-1] if behavior.execution_events else None
+        if last_event is not None and last_event.target_state != target_state:
+            return True
+        return (now - behavior.last_executed_at) >= timedelta(
+            seconds=self._settings.execution_cooldown_seconds
+        )
+
+    def _save_behavior(
+        self,
+        record: ActuatorRecord,
+        behavior: BehaviorState,
+    ) -> ActuatorRecord:
+        updated = record.model_copy(
+            update={
+                "behavior": behavior,
+                "updated_at": datetime.now(timezone.utc),
+            }
+        )
+        return self._store.upsert(updated)
+
+    def handle_state_change(
+        self,
+        entity_id: str,
+        new_state: dict[str, object] | None,
+        *,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> None:
+        """Wird bei jedem HA-State-Change aufgerufen und löst sofortige Vorhersage aus.
+
+        - Wenn entity_id ein Aktor ist: evaluate() direkt.
+        - Wenn entity_id ein Kontext-Entity ist: alle betroffenen Aktoren evaluieren.
+        - Wenn current_entities gesetzt ist, kommt die Auswertung direkt aus dem
+          WebSocket-State-Cache statt aus einer frischen REST-Abfrage.
+        """
+        # Aktor direkt evaluieren
+        for record in self._store.list():
+            if record.actuator_entity_id == entity_id:
+                try:
+                    self.evaluate(record.actuator_entity_id, current_entities=current_entities)
+                except Exception:
+                    logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", record.actuator_entity_id)
+                return
+        event_state = _event_state(new_state)
+        event_changed_at = _event_changed_at(new_state) or datetime.now(timezone.utc)
+        # Kontext-Entity: alle Aktoren finden, die diesen Kontext nutzen
+        affected_actuators = [
+            record.actuator_entity_id
+            for record in self._store.list()
+            if (
+                record.assignment.selected_numeric_entity_id == entity_id
+                or entity_id in record.assignment.selected_context_entity_ids
+            )
+        ]
+        for actuator_entity_id in affected_actuators:
+            try:
+                self.evaluate(
+                    actuator_entity_id,
+                    context_state_overrides={entity_id: event_state},
+                    context_changed_at_overrides={entity_id: event_changed_at},
+                    current_entities=current_entities,
+                )
+            except Exception:
+                logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", actuator_entity_id)
+
+
+def _event_state(new_state: dict[str, object] | None) -> str | None:
+    if not isinstance(new_state, dict):
+        return None
+    state = new_state.get("state")
+    return state if isinstance(state, str) else None
+
+
+def _event_changed_at(new_state: dict[str, object] | None) -> datetime | None:
+    if not isinstance(new_state, dict):
+        return None
+    value = new_state.get("last_changed") or new_state.get("last_updated")
+    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
+
+
+def predict_behavior(
+    patterns: list[BehaviorPattern],
+    *,
+    current_context: dict[str, str | None],
+    now: datetime,
+    min_support: int,
+    window_minutes: int,
+    current_context_changed_at: dict[str, datetime | None] | None = None,
+    causal_window_seconds: int = 120,
+    timezone_name: str = "Europe/Berlin",
+) -> BehaviorPrediction | None:
+    if not patterns:
+        return None
+    local = now.astimezone(ZoneInfo(timezone_name))
+    minute_of_day = local.hour * 60 + local.minute
+    changed_at = current_context_changed_at or {}
+    by_state: dict[str, list[float]] = {}
+    causal_support_by_state: dict[str, int] = {}
+    for pattern in patterns:
+        if pattern.trigger_entity_id and pattern.trigger_to_state:
+            trigger_changed_at = changed_at.get(pattern.trigger_entity_id)
+            trigger_age = (
+                (now - trigger_changed_at).total_seconds()
+                if trigger_changed_at is not None
+                else None
+            )
+            if not (
+                current_context.get(pattern.trigger_entity_id)
+                == pattern.trigger_to_state
+                and trigger_age is not None
+                and 0 <= trigger_age <= causal_window_seconds
+            ):
+                continue
+            comparable = [
+                (entity_id, expected)
+                for entity_id, expected in pattern.context_states.items()
+                if entity_id in current_context
+            ]
+            context_score = (
+                sum(
+                    current_context[entity_id] == expected
+                    for entity_id, expected in comparable
+                )
+                / len(comparable)
+                if comparable
+                else 0.5
+            )
+            score = pattern.weight * (0.85 + 0.15 * context_score)
+            by_state.setdefault(pattern.target_state, []).append(score)
+            causal_support_by_state[pattern.target_state] = (
+                causal_support_by_state.get(pattern.target_state, 0) + 1
+            )
+            continue
+        distance = _circular_minute_distance(minute_of_day, pattern.minute_of_day)
+        if distance > window_minutes:
+            continue
+        time_score = 1.0 - (distance / max(window_minutes, 1))
+        weekday_score = (
+            1.0
+            if local.weekday() == pattern.weekday
+            else 0.5
+            if (local.weekday() >= 5) == (pattern.weekday >= 5)
+            else 0.0
+        )
+        comparable = [
+            (entity_id, expected)
+            for entity_id, expected in pattern.context_states.items()
+            if entity_id in current_context
+        ]
+        context_score = (
+            sum(current_context[entity_id] == expected for entity_id, expected in comparable)
+            / len(comparable)
+            if comparable
+            else 0.5
+        )
+        score = pattern.weight * (
+            0.45 * time_score + 0.45 * context_score + 0.10 * weekday_score
+        )
+        by_state.setdefault(pattern.target_state, []).append(score)
+    if not by_state:
+        return None
+    target_state, scores = max(
+        by_state.items(),
+        key=lambda item: (sum(item[1]), len(item[1]), item[0]),
+    )
+    support = len(scores)
+    causal_support = causal_support_by_state.get(target_state, 0)
+    confidence = min(1.0, (sum(scores) / support) * min(1.0, support / min_support))
+    if confidence <= 0:
+        return None
+    return BehaviorPrediction(
+        target_state=target_state,
+        confidence=round(confidence, 4),
+        generated_at=now,
+        matching_patterns=support,
+        reason=(
+            (
+                f"{causal_support} historische Handlungen folgten demselben "
+                "frischen Sensorwechsel."
+            )
+            if causal_support
+            else f"{support} ähnliche Handlungsmuster passen zu Zeit und aktuellem Kontext."
+        ),
+    )
+
+
+def service_for_state(domain: str, target_state: str) -> str | None:
+    if domain in {"fan", "humidifier", "light", "media_player", "remote", "switch"}:
+        return {"on": "turn_on", "off": "turn_off"}.get(target_state)
+    if domain == "scene":
+        return "turn_on" if target_state == "on" else None
+    if domain == "cover":
+        return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
+    return None
+
+
+def _state_at(series: StateHistorySeries | None, timestamp: datetime) -> str | None:
+    if series is None:
+        return None
+    state: str | None = None
+    for point in series.points:
+        if point.timestamp > timestamp:
+            break
+        state = point.state
+    return state
+
+
+def _action_source(
+    point: StateHistoryPoint,
+    logbook: list[LogbookEntry],
+) -> tuple[str, float]:
+    nearest = min(
+        logbook,
+        key=lambda item: abs(item.timestamp - point.timestamp),
+        default=None,
+    )
+    if nearest is None or abs(nearest.timestamp - point.timestamp) > _ACTION_LOGBOOK_TOLERANCE:
+        return "physical_or_unknown", 0.7
+    if nearest.context_user_id:
+        return "user", 1.0
+    if nearest.context_domain in _AUTOMATION_CONTEXT_DOMAINS:
+        return "automation", 1.0
+    return "physical_or_unknown", 0.7
+
+
+def _matches_own_execution(
+    point: StateHistoryPoint,
+    own_executions: list[ExecutionEvent],
+) -> bool:
+    return any(
+        event.target_state == point.state
+        and abs(event.executed_at - point.timestamp) <= _OWN_ACTION_TOLERANCE
+        for event in own_executions
+    )
+
+
+def _pattern_context_matches(
+    pattern: BehaviorPattern,
+    current_context: dict[str, str | None],
+) -> bool:
+    comparable = [
+        (entity_id, expected)
+        for entity_id, expected in pattern.context_states.items()
+        if entity_id in current_context
+    ]
+    if not comparable:
+        return False
+    return all(current_context[entity_id] == expected for entity_id, expected in comparable)
+
+
+def _recent_context_transition(
+    history: dict[str, StateHistorySeries],
+    context_ids: list[str],
+    timestamp: datetime,
+) -> tuple[str, str, str] | None:
+    nearest: tuple[timedelta, str, str, str] | None = None
+    for entity_id in context_ids:
+        series = history.get(entity_id)
+        if series is None:
+            continue
+        previous_state: str | None = None
+        for point in series.points:
+            if point.timestamp > timestamp:
+                break
+            if previous_state is not None and point.state != previous_state:
+                age = timestamp - point.timestamp
+                if age <= _CONTEXT_TRIGGER_TOLERANCE and (
+                    nearest is None or age < nearest[0]
+                ):
+                    nearest = (age, entity_id, previous_state, point.state)
+            previous_state = point.state
+    if nearest is None:
+        return None
+    return nearest[1], nearest[2], nearest[3]
+
+
+def _circular_minute_distance(left: int, right: int) -> int:
+    direct = abs(left - right)
+    return min(direct, 1440 - direct)
--- a/app/config.py
+++ b/app/config.py
@@ -10,6 +10,17 @@ class Settings:
    ha_token: str | None = None
    model_store: str = ".model_store"
    automation_store: str = ".automation_store"
+    actuator_store: str = ".actuator_store"
+    history_days: int = 14
+    min_training_points: int = 24
+    retrain_stale_hours: int = 24
+    reconcile_interval_seconds: int = 900
+    min_behavior_actions: int = 3
+    prediction_confidence: float = 0.82
+    prediction_window_minutes: int = 30
+    prediction_interval_seconds: int = 60
+    execution_cooldown_seconds: int = 900
+    timezone: str = "Europe/Berlin"

    @property
    def ha_configured(self) -> bool:
@@ -22,4 +33,26 @@ def load_settings() -> Settings:
        ha_token=os.getenv("SILLYHOME_HA_TOKEN") or os.getenv("HA_TOKEN"),
        model_store=os.getenv("SILLYHOME_MODEL_STORE", ".model_store"),
        automation_store=os.getenv("SILLYHOME_AUTOMATION_STORE", ".automation_store"),
+        actuator_store=os.getenv("SILLYHOME_ACTUATOR_STORE", ".actuator_store"),
+        history_days=max(1, min(31, int(os.getenv("SILLYHOME_HISTORY_DAYS", "14")))),
+        min_training_points=max(2, int(os.getenv("SILLYHOME_MIN_TRAINING_POINTS", "24"))),
+        retrain_stale_hours=max(1, int(os.getenv("SILLYHOME_RETRAIN_STALE_HOURS", "24"))),
+        reconcile_interval_seconds=max(
+            60, int(os.getenv("SILLYHOME_RECONCILE_INTERVAL_SECONDS", "900"))
+        ),
+        min_behavior_actions=max(2, int(os.getenv("SILLYHOME_MIN_BEHAVIOR_ACTIONS", "3"))),
+        prediction_confidence=max(
+            0.5,
+            min(0.99, float(os.getenv("SILLYHOME_PREDICTION_CONFIDENCE", "0.82"))),
+        ),
+        prediction_window_minutes=max(
+            5, min(120, int(os.getenv("SILLYHOME_PREDICTION_WINDOW_MINUTES", "30")))
+        ),
+        prediction_interval_seconds=max(
+            30, int(os.getenv("SILLYHOME_PREDICTION_INTERVAL_SECONDS", "60"))
+        ),
+        execution_cooldown_seconds=max(
+            60, int(os.getenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "900"))
+        ),
+        timezone=os.getenv("SILLYHOME_TIMEZONE", "Europe/Berlin"),
    )
--- a/app/ha/client.py
+++ b/app/ha/client.py
@@ -3,7 +3,9 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from datetime import datetime
+import json
 import re
+from typing import Any
 from urllib.parse import quote

 import requests
@@ -18,7 +20,9 @@ from app.ha.exceptions import (
 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)
@@ -83,6 +87,93 @@ class HaClient:
            )
        return payload

+    def get_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[object]:
+        self._validate_period([entity_id], start_time, end_time)
+        start = quote(start_time.isoformat(), safe=":+")
+        payload = self._get_json(
+            f"/api/logbook/{start}",
+            params={
+                "entity": entity_id,
+                "end_time": end_time.isoformat(),
+            },
+        )
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "Logbook-Antwort von Home Assistant hat unerwartetes Format."
+            )
+        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,
+        service: str,
+        service_data: dict[str, object],
+    ) -> list[object]:
+        if not _SERVICE_PART_PATTERN.fullmatch(domain):
+            raise ValueError("Ungültige Service-Domain.")
+        if not _SERVICE_PART_PATTERN.fullmatch(service):
+            raise ValueError("Ungültiger Service-Name.")
+        payload = self._post_json(f"/api/services/{domain}/{service}", service_data)
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "Service-Antwort von Home Assistant hat unerwartetes Format."
+            )
+        return payload
+
+    def list_entity_metadata(self, entity_ids: list[str]) -> dict[str, dict[str, str | None]]:
+        if not entity_ids:
+            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:
+            payload = json.loads(rendered)
+        except json.JSONDecodeError as exc:
+            raise HaUnexpectedPayloadError("Entity-Metadaten konnten nicht gelesen werden.") from exc
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError("Entity-Metadaten haben ein unerwartetes Format.")
+        result: dict[str, dict[str, str | None]] = {}
+        for item in payload:
+            if not isinstance(item, dict):
+                raise HaUnexpectedPayloadError("Entity-Metadaten haben ein unerwartetes Format.")
+            entity_id = item.get("entity_id")
+            if not isinstance(entity_id, str) or "." not in entity_id:
+                raise HaUnexpectedPayloadError("Entity-Metadaten enthalten ungültige entity_id.")
+            result[entity_id] = {
+                key: _optional_string(item.get(key))
+                for key in ("area_id", "area_name", "device_id", "device_name")
+            }
+        return result
+
    def _get_json(
        self,
        path: str,
@@ -125,3 +216,106 @@ class HaClient:
            ) from exc

        return payload
+
+    def _post_json(self, path: str, payload: Any) -> object:
+        try:
+            response = self._session.post(
+                f"{self._settings.url.rstrip('/')}{path}",
+                json=payload,
+                timeout=self._settings.timeout_seconds,
+            )
+        except requests.Timeout as exc:
+            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
+        except requests.RequestException as exc:
+            raise HaHttpError(
+                getattr(getattr(exc, "response", None), "status_code", 502),
+                "Netzwerkfehler beim Zugriff auf Home Assistant.",
+            ) from exc
+        if response.status_code in (401, 403):
+            raise HaAuthError(
+                response.status_code,
+                "Authentifizierung bei Home Assistant fehlgeschlagen.",
+            )
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant ist kein gültiges JSON."
+            ) from exc
+
+    def _post_text(self, path: str, payload: dict[str, str]) -> str:
+        try:
+            response = self._session.post(
+                f"{self._settings.url.rstrip('/')}{path}",
+                json=payload,
+                timeout=self._settings.timeout_seconds,
+            )
+        except requests.Timeout as exc:
+            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
+        except requests.RequestException as exc:
+            raise HaHttpError(
+                getattr(getattr(exc, "response", None), "status_code", 502),
+                "Netzwerkfehler beim Zugriff auf Home Assistant.",
+            ) from exc
+
+        if response.status_code in (401, 403):
+            raise HaAuthError(
+                response.status_code,
+                "Authentifizierung bei Home Assistant fehlgeschlagen.",
+            )
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
+        return response.text
+
+    @staticmethod
+    def _validate_period(
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> None:
+        if not entity_ids:
+            raise ValueError("Mindestens eine entity_id ist erforderlich.")
+        if len(entity_ids) > 100:
+            raise ValueError("Es können höchstens 100 Entities abgefragt werden.")
+        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.")
+        if start_time.tzinfo is None or end_time.tzinfo is None:
+            raise ValueError("start_time und end_time müssen eine Zeitzone enthalten.")
+        if end_time <= start_time:
+            raise ValueError("end_time muss nach start_time liegen.")
+        if (end_time - start_time).total_seconds() > _MAX_HISTORY_SECONDS:
+            raise ValueError("History-Abfragen sind auf 31 Tage begrenzt.")
+
+
+def _metadata_template(entity_ids: list[str]) -> str:
+    ids = json.dumps(entity_ids, ensure_ascii=True)
+    return (
+        "{% set ids = "
+        f"{ids}"
+        " %}["
+        "{% for entity_id in ids %}"
+        "{% set device = device_id(entity_id) %}"
+        "{{ "
+        "{"
+        "\"entity_id\": entity_id,"
+        "\"area_id\": area_id(entity_id),"
+        "\"area_name\": area_name(entity_id),"
+        "\"device_id\": device,"
+        "\"device_name\": device_attr(device, 'name') if device else none"
+        "}"
+        " | tojson }}"
+        "{% if not loop.last %},{% endif %}"
+        "{% endfor %}]"
+    )
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None or value == "":
+        return None
+    return str(value)
--- a/app/ha/discovery.py
+++ b/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"})
-_LEARNABLE_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "weather"})
+_CONTEXT_DOMAINS = frozenset({
+    "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
+    )
--- a/app/ha/history.py
+++ b/app/ha/history.py
@@ -18,6 +18,25 @@ class EntityHistorySeries(BaseModel):
    points: list[NumericHistoryPoint]


+class StateHistoryPoint(BaseModel):
+    timestamp: datetime
+    state: str
+
+
+class StateHistorySeries(BaseModel):
+    entity_id: str
+    points: list[StateHistoryPoint]
+
+
+class LogbookEntry(BaseModel):
+    entity_id: str
+    timestamp: datetime
+    message: str = ""
+    context_user_id: str | None = None
+    context_domain: str | None = None
+    context_service: str | None = None
+
+
 def normalize_history_payload(payload: object) -> list[EntityHistorySeries]:
    if not isinstance(payload, list):
        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
@@ -33,6 +52,68 @@ def normalize_history_payload(payload: object) -> list[EntityHistorySeries]:
    return sorted(normalized, key=lambda item: item.entity_id)


+def normalize_state_history_payload(payload: object) -> list[StateHistorySeries]:
+    if not isinstance(payload, list):
+        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
+    normalized: list[StateHistorySeries] = []
+    for raw_series in payload:
+        if not isinstance(raw_series, list):
+            raise HaUnexpectedPayloadError("History-Serie muss eine Liste sein.")
+        entity_id: str | None = None
+        points: list[StateHistoryPoint] = []
+        for raw_entry in raw_series:
+            if not isinstance(raw_entry, dict):
+                raise HaUnexpectedPayloadError("History-Eintrag muss ein Objekt sein.")
+            raw_entity_id = raw_entry.get("entity_id")
+            if raw_entity_id is not None:
+                if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
+                    raise HaUnexpectedPayloadError(
+                        "History-Eintrag enthält ungültige entity_id."
+                    )
+                if entity_id is not None and entity_id != raw_entity_id:
+                    raise HaUnexpectedPayloadError("History-Serie enthält mehrere Entities.")
+                entity_id = raw_entity_id
+            raw_state = raw_entry.get("state")
+            if not isinstance(raw_state, str) or raw_state in {"unknown", "unavailable"}:
+                continue
+            if entity_id is None:
+                raise HaUnexpectedPayloadError("History-Serie enthält keine entity_id.")
+            timestamp = _parse_timestamp(
+                raw_entry.get("last_changed") or raw_entry.get("last_updated")
+            )
+            if not points or points[-1].state != raw_state:
+                points.append(StateHistoryPoint(timestamp=timestamp, state=raw_state))
+        if entity_id is not None and points:
+            points.sort(key=lambda point: point.timestamp)
+            normalized.append(StateHistorySeries(entity_id=entity_id, points=points))
+    return sorted(normalized, key=lambda item: item.entity_id)
+
+
+def normalize_logbook_payload(payload: object, entity_id: str) -> list[LogbookEntry]:
+    if not isinstance(payload, list):
+        raise HaUnexpectedPayloadError("Logbook-Payload muss eine Liste sein.")
+    entries: list[LogbookEntry] = []
+    for raw_entry in payload:
+        if not isinstance(raw_entry, dict):
+            raise HaUnexpectedPayloadError("Logbook-Eintrag muss ein Objekt sein.")
+        raw_entity_id = raw_entry.get("entity_id")
+        if raw_entity_id != entity_id:
+            continue
+        entries.append(
+            LogbookEntry(
+                entity_id=entity_id,
+                timestamp=_parse_timestamp(raw_entry.get("when")),
+                message=str(raw_entry.get("message") or ""),
+                context_user_id=_optional_string(raw_entry.get("context_user_id")),
+                context_domain=_optional_string(
+                    raw_entry.get("context_domain") or raw_entry.get("domain")
+                ),
+                context_service=_optional_string(raw_entry.get("context_service")),
+            )
+        )
+    return sorted(entries, key=lambda item: item.timestamp)
+
+
 def _normalize_series(raw_series: list[object]) -> EntityHistorySeries | None:
    entity_id: str | None = None
    points: list[NumericHistoryPoint] = []
@@ -89,3 +170,9 @@ def _parse_timestamp(value: object) -> datetime:
    if parsed.tzinfo is None:
        raise HaUnexpectedPayloadError("History-Zeitstempel muss eine Zeitzone enthalten.")
    return parsed
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None or value == "":
+        return None
+    return str(value)
--- a/app/ha/models.py
+++ b/app/ha/models.py
@@ -1,5 +1,7 @@
 from __future__ import annotations

+from datetime import datetime
+
 from pydantic import BaseModel


@@ -14,6 +16,20 @@ class HaState(BaseModel):
 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
+    friendly_name: str | None = None
+    area_id: str | None = None
+    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
--- a/app/ha/reader.py
+++ b/app/ha/reader.py
@@ -1,21 +1,49 @@
 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, HaHttpError

 from app.ha.client import HaClient
 from app.ha.discovery import DiscoveredEntity, discover_entities
-from app.ha.history import EntityHistorySeries, normalize_history_payload
-from app.ha.models import HaEntitySummary
+from app.ha.history import (
+    EntityHistorySeries,
+    LogbookEntry,
+    StateHistorySeries,
+    normalize_history_payload,
+    normalize_logbook_payload,
+    normalize_state_history_payload,
+)
+from app.ha.models import HaAutomationSummary, HaEntitySummary
+
+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()
+        entity_ids = [
+            raw_entity_id
+            for item in entities
+            if isinstance((raw_entity_id := item.get("entity_id")), str) and "." in raw_entity_id
+        ]
+        try:
+            metadata_by_entity = self._client.list_entity_metadata(entity_ids)
+        except (HaClientError, ValueError) as exc:
+            logger.warning("HA metadata enrichment skipped: %s", exc)
+            metadata_by_entity = {}
        summaries: list[HaEntitySummary] = []
        for item in entities:
            raw_entity_id = item.get("entity_id")
@@ -25,13 +53,25 @@ class HaReader:
            domain = entity_id.split(".", 1)[0]
            raw_attributes = item.get("attributes") or {}
            attributes: dict[str, Any] = raw_attributes if isinstance(raw_attributes, dict) else {}
+            metadata = metadata_by_entity.get(entity_id, {})
            summaries.append(
                HaEntitySummary(
                    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")),
+                    friendly_name=_optional_str(attributes.get("friendly_name")),
+                    area_id=_optional_str(metadata.get("area_id") or attributes.get("area_id")),
+                    area_name=_optional_str(metadata.get("area_name") or attributes.get("area_name")),
+                    device_id=_optional_str(metadata.get("device_id") or attributes.get("device_id")),
+                    device_name=_optional_str(
+                        metadata.get("device_name")
+                        or attributes.get("device_name")
+                        or attributes.get("device")
+                    ),
                )
            )
        return summaries
@@ -52,8 +92,140 @@ class HaReader:
        payload = self._client.get_history(entity_ids, start_time, end_time)
        return normalize_history_payload(payload)

+    def read_state_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[StateHistorySeries]:
+        payload = self._client.get_history(entity_ids, start_time, end_time)
+        return normalize_state_history_payload(payload)
+
+    def read_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[LogbookEntry]:
+        payload = self._client.get_logbook(entity_id, start_time, end_time)
+        return normalize_logbook_payload(payload, entity_id)
+
+    def call_service(
+        self,
+        domain: str,
+        service: str,
+        service_data: dict[str, object],
+    ) -> 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
--- a/app/main.py
+++ b/app/main.py
@@ -1,31 +1,60 @@
-from contextlib import asynccontextmanager
+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

+from app.actuators.lifecycle import ActuatorReconciliationService
+from app.actuators.store import ActuatorStore
+from app.api.v1.actuators import router as actuators_router
 from app.api.v1.entities import router as entities_router
-from app.api.v1.automations import router as automations_router
-from app.automations.store import AutomationStore
+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
+    event_listener_task: asyncio.Task[None] | None = None
+    fallback_task: asyncio.Task[None] | None = None
    app.state.registry = ModelRegistry(settings.model_store)
-    app.state.automation_store = AutomationStore(settings.automation_store)
+    app.state.actuator_store = ActuatorStore(settings.actuator_store)
    if hasattr(app.state, "ha_reader"):
        del app.state.ha_reader
+    if hasattr(app.state, "actuator_service"):
+        del app.state.actuator_service
+    if hasattr(app.state, "behavior_engine"):
+        del app.state.behavior_engine
    if settings.ha_configured:
        client = HaClient(
            settings=HaClientSettings(
@@ -34,9 +63,41 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            )
        )
        app.state.ha_reader = HaReader(client=client)
+        app.state.actuator_service = ActuatorReconciliationService(
+            ha_reader=app.state.ha_reader,
+            store=app.state.actuator_store,
+            registry=app.state.registry,
+            settings=settings,
+        )
+        app.state.behavior_engine = BehaviorEngine(
+            ha_reader=app.state.ha_reader,
+            store=app.state.actuator_store,
+            settings=settings,
+        )
+        app.state.ws_status = _WsStatus()
+        startup_task = asyncio.create_task(_startup_reconciliation(app))
+        reconcile_task = asyncio.create_task(_periodic_reconciliation(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 event_listener_task is not None:
+            event_listener_task.cancel()
+            with suppress(asyncio.CancelledError):
+                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()

@@ -44,13 +105,13 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
    title="SillyHome Next API",
    description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.3.0",
+    version="1.0.5",
    lifespan=lifespan,
 )
 app.state.settings = load_settings()
 register_exception_handlers(app)
 app.include_router(entities_router)
-app.include_router(automations_router)
+app.include_router(actuators_router)
 init_ml_routes(app, model_store=app.state.settings.model_store)

 STATIC_DIR = Path(__file__).with_name("static")
@@ -61,7 +122,282 @@ 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:
+    while True:
+        await asyncio.sleep(app.state.settings.reconcile_interval_seconds)
+        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 _startup_reconciliation(app: FastAPI) -> None:
+    delay_seconds = 5
+    while True:
+        service = getattr(app.state, "actuator_service", None)
+        engine = getattr(app.state, "behavior_engine", None)
+        if not isinstance(service, ActuatorReconciliationService) or not isinstance(
+            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
--- a/app/ml/registry/model_registry.py
+++ b/app/ml/registry/model_registry.py
@@ -20,6 +20,8 @@ class ModelRegistry:
    def __init__(self, root: str | Path) -> None:
        self._root = Path(root).resolve()
        self._root.mkdir(parents=True, exist_ok=True)
+        self._archive_root = self._root / "archive"
+        self._archive_root.mkdir(parents=True, exist_ok=True)
        self._artifacts: dict[str, TrainedArtifact] = {}
        self._lock = RLock()
        self._load_existing()
@@ -43,10 +45,27 @@ class ModelRegistry:
                raise KeyError(f"Artifact '{artifact_id}' nicht registriert.")
            return self._artifacts[artifact_id]

+    def get_optional(self, artifact_id: str) -> TrainedArtifact | None:
+        self._validate_artifact_id(artifact_id)
+        with self._lock:
+            return self._artifacts.get(artifact_id)
+
    def list_models(self) -> Iterable[TrainedArtifact]:
        with self._lock:
            return [self._artifacts[key] for key in sorted(self._artifacts)]

+    def archive(self, artifact_id: str) -> bool:
+        self._validate_artifact_id(artifact_id)
+        with self._lock:
+            artifact = self._artifacts.pop(artifact_id, None)
+            source = self._root / f"{artifact_id}.json"
+            if not source.exists():
+                return artifact is not None
+            target = self._archive_root / f"{artifact_id}.json"
+            os.replace(source, target)
+            logger.info("Modell archiviert: %s", target)
+            return True
+
    def _load_existing(self) -> None:
        for source in sorted(self._root.glob("*.json")):
            try:
--- a/app/static/index.html
+++ b/app/static/index.html
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -9,9 +9,21 @@ services:
    environment:
      SILLYHOME_MODEL_STORE: /app/data/models
      SILLYHOME_AUTOMATION_STORE: /app/data/automations
+      SILLYHOME_ACTUATOR_STORE: /app/data/actuators
+      SILLYHOME_HISTORY_DAYS: 14
+      SILLYHOME_MIN_TRAINING_POINTS: 24
+      SILLYHOME_RETRAIN_STALE_HOURS: 24
+      SILLYHOME_RECONCILE_INTERVAL_SECONDS: 900
+      SILLYHOME_MIN_BEHAVIOR_ACTIONS: 3
+      SILLYHOME_PREDICTION_CONFIDENCE: 0.82
+      SILLYHOME_PREDICTION_WINDOW_MINUTES: 30
+      SILLYHOME_PREDICTION_INTERVAL_SECONDS: 60
+      SILLYHOME_EXECUTION_COOLDOWN_SECONDS: 900
+      SILLYHOME_TIMEZONE: Europe/Berlin
    volumes:
      - model-data:/app/data/models
      - automation-data:/app/data/automations
+      - actuator-data:/app/data/actuators
    read_only: true
    tmpfs:
      - /tmp
@@ -24,3 +36,4 @@ services:
 volumes:
  model-data:
  automation-data:
+  actuator-data:
--- a/docs/BEHAVIOR_ENGINE.md
+++ b/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.
--- a/docs/CONTROL_HANDOFF.md
+++ b/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
+```
--- a/docs/DEBUGGING.md
+++ b/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
+```
--- a/docs/OPERATIONS.md
+++ b/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.
--- a/docs/V1_0_0_OPERATING_GUIDE.md
+++ b/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.
--- a/docs/V1_0_ACCEPTANCE.md
+++ b/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`.
--- a/docs/automations.md
+++ b/docs/automations.md
@@ -1,14 +1,6 @@
-# Automation-Vorschläge
+# Keine manuell erzeugten Automationen

-SillyHome Next führt Automationen niemals automatisch aus. Der Workflow ist:
-
-1. Vorschlag als `draft` erstellen.
-2. Inhalt und Ziel-Entity prüfen.
-3. Mit aktueller Revision explizit freigeben oder ablehnen.
-4. Nur freigegebene Vorschläge als Home-Assistant-YAML exportieren.
-5. Das YAML außerhalb von SillyHome Next in Home Assistant importieren.
-
-Erlaubt sind numerische Sensor-Trigger und Aktionsdienste aus den Domains
-`light`, `switch`, `climate`, `fan` und `cover`. Shell-Kommandos, Skripte und
-beliebige Service-Domains werden abgewiesen. Eine einmal getroffene Entscheidung
-kann nicht überschrieben werden; Änderungen benötigen einen neuen Vorschlag.
+Seit `v0.5.0` erstellt SillyHome Next keine YAML-Automationen und bietet keinen
+Regel- oder Trigger-Editor mehr an. Der produktive Ablauf besteht aus
+Aktorauswahl, automatischem Verhaltenslernen, Shadow-Vorhersage und einer
+separaten Ausführungsfreigabe pro Aktor.
--- a/docs/ha_data.md
+++ b/docs/ha_data.md
@@ -14,6 +14,15 @@ Trainings- und Erklärungsprozesse.
 - `actuator`: mögliche Automationsziele, nicht als Trainingssensor verwendet
 - `unsupported`: noch nicht klassifizierte Entity-Typen

+Zusätzlich reichert `HaReader` verfügbare Metadaten wie `friendly_name`,
+Bereich und Gerät aus Home Assistant an. Für die aktor-zentrierte Zuordnung
+nutzt SillyHome Next bevorzugt:
+
+- `area_id` und `area_name`
+- `device_id` und `device_name`
+- Friendly Names und Entity-ID-Tokens
+- Domain und `device_class`
+
 Optionale Query-Parameter:

 - `domain=sensor` kann mehrfach angegeben werden
@@ -32,7 +41,8 @@ Historische Zustände werden über Home Assistants
 Die Normalisierung übernimmt nur endliche numerische Zustände. `unknown`,
 `unavailable`, nichtnumerische Werte, `NaN` und unendliche Werte werden nicht
 als Trainingsdaten verwendet. Ergebnisse werden je Entity chronologisch
-sortiert.
+sortiert. Binäre Kontext-Entities werden bewusst nicht in numerische
+Trainingsreihen konvertiert.

 ## Datenschutz und Betrieb

--- a/docs/ml_api.md
+++ b/docs/ml_api.md
@@ -1,7 +1,7 @@
 # ML-Serving-API

 Diese Dokumentation beschreibt die REST-Endpunkte der aktuellen
-Modell-Artefakt- und Vorhersage-Schnittstelle.
+Modell-Artefakt-, Vorhersage- und aktor-zentrierten Lifecycle-Schnittstelle.

 Das Serving verwendet ein lokal trainiertes statistisches Baseline-Modell.

@@ -15,6 +15,8 @@ Das Serving verwendet ein lokal trainiertes statistisches Baseline-Modell.
 - Einzelvorhersage: `/predict`
 - Batchvorhersage: `/batch`

+Die aktor-zentrierte API liegt unter `/v1/actuators`.
+
 Der Standard-Start erfolgt über `uvicorn app.main:app`, danach stehen HA- und
 ML-Routen in derselben Anwendung bereit.

@@ -168,14 +170,88 @@ Batch-Vorhersage für mehrere Sensorwerte.
 - `422 Unprocessable Content`: Sensor wird vom Modell nicht unterstützt oder Eingabe ist ungültig.
 - `503 Service Unavailable`: Registry ist nicht initialisiert.

+## Aktuator-zentrierte API
+
+### `GET /v1/actuators/discovery`
+
+Listet unterstützte Aktuatoren mit angereicherter HA-Metadatenbasis.
+
+### `POST /v1/actuators`
+
+Registriert einen Aktor. Das System ermittelt passende Messwerte und
+Kontext-Entities vollständig automatisch, trainiert bei ausreichender Historie
+ein Modell und liefert Zuordnung, Confidence, Evidenz und Lifecycle-Status zur
+Diagnose zurück.
+
+**Request**
+```json
+{
+  "actuator_entity_id": "light.abstellkammer",
+  "enabled": true
+}
+```
+
+### `POST /v1/actuators/reconciliation/run`
+
+Führt eine sichere globale Reconciliation aus. Die periodische Add-on-Schleife
+ruft denselben idempotenten Ablauf auf, startet aber keine Services in Home
+Assistant.
+
+### `POST /v1/actuators/{actuator_entity_id}/evaluate`
+
+Erstellt aus aktuellem Kontext eine neue Shadow- oder Aktiv-Vorhersage. Im
+Shadow-Modus wird niemals geschaltet.
+
+### `POST /v1/actuators/{actuator_entity_id}/activation`
+
+```json
+{
+  "active": true,
+  "pause_matching_automations": true,
+  "restore_paused_automations": false
+}
+```
+
+Aktiviert autonomes Schalten erst nach ausreichendem Training und nur für
+erlaubte Aktor-Domains. `pause_matching_automations` pausiert eindeutig
+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

-Die produktive App lädt Artefakte aus `SILLYHOME_MODEL_STORE`. Neue Artefakte
-werden über `/ml/retrain`, `RetrainingService` oder direkt über
-`ModelRegistry.register(...)` registriert. Die Registry speichert validiertes
-JSON atomisch und lädt es beim Neustart. Die API sollte nur in einem
-vertrauenswürdigen Netz oder hinter einem authentifizierenden Reverse Proxy
-erreichbar sein.
+Die produktive App lädt Artefakte aus `SILLYHOME_MODEL_STORE`. Aktor- und
+Reconciliation-Zustände liegen atomisch in
+`SILLYHOME_ACTUATOR_STORE`. Neue Artefakte werden über `/ml/retrain`,
+`RetrainingService` oder den aktor-zentrierten Lifecycle registriert. Die API
+sollte nur in einem vertrauenswürdigen Netz oder hinter einem
+authentifizierenden Reverse Proxy erreichbar sein.

 ## Verweise

--- a/docs/ml_training.md
+++ b/docs/ml_training.md
@@ -1,68 +1,51 @@
-# ML Training- und Evaluations-Workflow
+# Verhaltenslernen und Vorhersage

-SillyHome Next trainiert ein lokales statistisches Baseline-Modell pro Sensor
-und Merkmal. Es benötigt keine Cloud und keine externe ML-Laufzeit.
+Seit `v0.5.0` ist der produktive Lernpfad aktor-zentriert. Nutzer wählen nur
+einen Aktor; Sensoren, Kontext und Modelle werden automatisch verwaltet.

-## 1. Daten sammeln
+## Datengrundlage

-Alle Trainingsvektoren werden über `FeatureStore.add(...)` oder `add_batch(...)` eingepflegt. Jeder Vektor enthält eine Sensor-ID sowie ein Dictionary mit Merkmalen.
+Für jeden Aktor lädt SillyHome Next:

-## 2. Statistisches Artefakt erzeugen
+- dessen Zustandswechsel aus der Home-Assistant-Historie
+- Logbook-Einträge zur Herkunft der Handlung
+- automatisch zugeordnete Mess- und Kontext-Entities
+- deren Zustand zum Zeitpunkt der Handlung

-```python
-store = FeatureStore()
-store.add(FeatureVector(sensor_id="sensor.kitchen", values={"temperature": 21.0}))
-pipeline = TrainingPipeline(store)
-artifact = pipeline.run("my_artifact")
-pipeline.export("my_artifact")
-```
+Eindeutig einem Home-Assistant-Benutzer zugeordnete Handlungen und im Logbuch
+erkannte Automations- oder Script-Aktionen erhalten das höchste Gewicht.
+Physische oder nicht eindeutig zuordenbare Bedienungen dürfen das Shadow-Modell
+ergänzen, reichen allein aber nicht zur Aktivierung.

-`TrainingPipeline.run(...)` berechnet für jedes numerische Merkmal:
+## Modell

- Stichprobenzahl
- Mittelwert und Standardabweichung
- Minimum und Maximum
- linearen Trend mit Steigung und Achsenabschnitt
+Das lokale Modell speichert pro beobachteter Handlung:

-Die nächste Vorhersage kombiniert den letzten beobachteten Wert mit der
-trainierten Trendsteigung. Die Confidence berücksichtigt Datenmenge und
-Stabilität.
+- Zielzustand
+- lokale Tageszeit
+- Wochentag
+- Kontextzustände
+- Herkunft und Gewicht

-## 3. Modell evaluieren
+Eine Vorhersage bewertet zeitliche Nähe, Wochentagsmuster und aktuellen
+Kontext. Mehrere passende historische Handlungen erhöhen die Confidence.

-```python
-evaluator = Evaluator(pipeline)
-report = evaluator.evaluate(artifact.artifact_id, validation_samples)
-```
+## Betriebsstufen

-Der Report enthält echte numerische Vergleichsmetriken:
- `artifact_id`
- `sample_size`
- `mae` (Mean Absolute Error)
- `rmse` (Root Mean Squared Error)
- `coverage` für den Anteil auswertbarer Merkmale
+1. `collecting`: Noch nicht genügend Handlungen vorhanden.
+2. `shadow`: Modell ist trainiert; Vorhersagen werden angezeigt, aber nicht ausgeführt.
+3. `active`: Nutzer hat den Aktor ausdrücklich freigegeben.

-## 4. Modell registrieren
+Die Aktivierung verlangt genügend eindeutig zugeordnete manuelle oder
+automatisierte Handlungen. Ausgeführt werden nur erlaubte Zustände reversibler Domains:
+`light`, `switch`, `fan`, `humidifier` und `cover`.

-Das trainierte Artefakt kann anschließend über `ModelRegistry.register(artifact)` bereitgestellt werden. Die ML-Serving-API stellt es unter `/ml/predict` und `/ml/batch` zur Verfügung.
+## Schutzmechanismen

-## 5. Retraining ausführen
-
-`RetrainingService.retrain(...)` führt genau einen Trainingslauf aus und ersetzt
-ein vorhandenes Artefakt mit derselben ID atomisch in der Registry:
-
-```python
-service = RetrainingService(registry)
-result = service.retrain("home-model", vectors)
-```
-
-Scheduler, Cronjobs oder Home-Assistant-Automationen können alternativ die
-zustandslose Funktion `retrain_model(registry, artifact_id, vectors)` aufrufen.
-Der Service startet bewusst keinen eigenen Hintergrundprozess. Über
-`POST /ml/retrain` kann derselbe Ablauf per API angestoßen werden.
-
-## Hinweise
- Für reproduzierbare Sensor-Reihenfolgen wird in `TrainingPipeline.run(...)` eine sortierte Sensor-Liste verwendet.
- Fehlende Trainingsdaten lösen `ValueError` aus; nicht registrierte Artefakte lösen `KeyError` aus.
- Nur endliche numerische Werte werden trainiert.
- `coverage` bleibt im Bereich 0 bis 1.
+- explizite Freigabe pro Aktor
+- konfigurierbare Mindestkonfidenz
+- Cooldown zwischen Schaltungen
+- keine Ausführung bei bereits erreichtem Zielzustand
+- keine Ausführung unbekannter Zustände oder riskanter Domains
+- eigene Schaltungen werden beim nächsten Training herausgefiltert
+- Automation-/Script-Aktionen zählen nur bei eindeutiger Herkunft im HA-Logbuch
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "sillyhome-next"
-version = "0.3.0"
+version = "1.0.5"
 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]
--- a/tests/actuators/test_actuator_store.py
+++ b/tests/actuators/test_actuator_store.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from app.actuators.models import ReconciliationState
+from app.actuators.store import ActuatorStore
+
+
+def test_actuator_store_persists_record_and_reconciliation_state(tmp_path: Path) -> None:
+    store = ActuatorStore(tmp_path)
+    store.configure("light.abstellkammer")
+    state = ReconciliationState(last_summary="ok", configured_actuators=1)
+
+    store.save_reconciliation_state(state)
+
+    restarted = ActuatorStore(tmp_path)
+    assert restarted.get("light.abstellkammer").actuator_entity_id == "light.abstellkammer"
+    assert restarted.load_reconciliation_state().last_summary == "ok"
--- a/tests/actuators/test_lifecycle.py
+++ b/tests/actuators/test_lifecycle.py
@@ -0,0 +1,438 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from app.actuators.lifecycle import ActuatorReconciliationService
+from app.actuators.models import (
+    AssignmentSource,
+    LifecycleStatus,
+    model_id_for_actuator,
+)
+from app.actuators.store import ActuatorStore
+from app.config import Settings
+from app.ha.discovery import DiscoveredEntity
+from app.ha.discovery import discover_entities
+from app.ha.history import EntityHistorySeries, NumericHistoryPoint
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
+from app.ml.registry.model_registry import ModelRegistry
+
+
+class FakeActuatorReader(HaReader):
+    def __init__(
+        self,
+        entities: list[HaEntitySummary],
+        history_by_entity: dict[str, list[NumericHistoryPoint]],
+    ) -> None:
+        self._entities = entities
+        self._history_by_entity = history_by_entity
+
+    def read_entities(self) -> list[HaEntitySummary]:
+        return list(self._entities)
+
+    def discover(
+        self,
+        domains: set[str] | None = None,
+        learnable: bool | None = None,
+    ) -> list[DiscoveredEntity]:
+        return discover_entities(self._entities, domains=domains, learnable=learnable)
+
+    def read_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[EntityHistorySeries]:
+        series: list[EntityHistorySeries] = []
+        for entity_id in entity_ids:
+            points = [
+                point
+                for point in self._history_by_entity.get(entity_id, [])
+                if start_time <= point.timestamp <= end_time
+            ]
+            if points:
+                series.append(EntityHistorySeries(entity_id=entity_id, points=points))
+        return series
+
+
+def _points(count: int, start: datetime, value: float) -> list[NumericHistoryPoint]:
+    return [
+        NumericHistoryPoint(timestamp=start + timedelta(hours=index), value=value + index)
+        for index in range(count)
+    ]
+
+
+def _service(
+    tmp_path: Path,
+    entities: list[HaEntitySummary],
+    history_by_entity: dict[str, list[NumericHistoryPoint]],
+) -> ActuatorReconciliationService:
+    return ActuatorReconciliationService(
+        ha_reader=FakeActuatorReader(entities, history_by_entity),
+        store=ActuatorStore(tmp_path / "actuators"),
+        registry=ModelRegistry(tmp_path / "models"),
+        settings=Settings(
+            ha_url="http://ha.local",
+            ha_token="token",
+            model_store=str(tmp_path / "models"),
+            automation_store=str(tmp_path / "automations"),
+            actuator_store=str(tmp_path / "actuators"),
+            history_days=31,
+            min_training_points=5,
+            retrain_stale_hours=24,
+            reconcile_interval_seconds=900,
+        ),
+    )
+
+
+def test_reconciliation_auto_assigns_and_trains_numeric_model(tmp_path: Path) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Abstellkammer Licht",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.abstellkammer_illuminance",
+            domain="sensor",
+            device_class="illuminance",
+            state_class="measurement",
+            unit_of_measurement="lx",
+            friendly_name="Abstellkammer Helligkeit",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellkammer_motion",
+            domain="binary_sensor",
+            device_class="motion",
+            friendly_name="Abstellkammer Bewegung",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.kitchen_temperature",
+            domain="sensor",
+            device_class="temperature",
+            state_class="measurement",
+            unit_of_measurement="°C",
+            friendly_name="Kueche Temperatur",
+            area_name="Kueche",
+        ),
+    ]
+    service = _service(
+        tmp_path,
+        entities,
+        {
+            "sensor.abstellkammer_illuminance": _points(8, start, 10.0),
+            "sensor.kitchen_temperature": _points(8, start, 18.0),
+        },
+    )
+
+    record = service.configure_actuator("light.abstellkammer")
+
+    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_illuminance"
+    assert record.assignment.selected_context_entity_ids == ["binary_sensor.abstellkammer_motion"]
+    assert record.assignment.review_required is False
+    assert record.lifecycle.status is LifecycleStatus.TRAINED
+    artifact = service._registry.load_artifact(model_id_for_actuator("light.abstellkammer"))
+    assert artifact.supported_sensors == ("sensor.abstellkammer_illuminance",)
+    assert "binary_sensor.abstellkammer_motion" not in artifact.supported_sensors
+
+
+def test_reconciliation_rejects_ambiguous_numeric_mapping(tmp_path: Path) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id="switch.garage_pump",
+            domain="switch",
+            friendly_name="Garage Pumpe",
+            area_name="Garage",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.garage_power",
+            domain="sensor",
+            device_class="power",
+            state_class="measurement",
+            unit_of_measurement="W",
+            friendly_name="Garage Leistung",
+            area_name="Garage",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.garage_energy",
+            domain="sensor",
+            device_class="energy",
+            state_class="measurement",
+            unit_of_measurement="kWh",
+            friendly_name="Garage Energie",
+            area_name="Garage",
+        ),
+    ]
+    service = _service(
+        tmp_path,
+        entities,
+        {
+            "sensor.garage_power": _points(8, start, 10.0),
+            "sensor.garage_energy": _points(8, start, 11.0),
+        },
+    )
+
+    record = service.configure_actuator("switch.garage_pump")
+
+    assert record.assignment.review_required is True
+    assert record.assignment.selected_numeric_entity_id is None
+    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
+
+
+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(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Abstellkammer Licht",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.abstellkammer_illuminance",
+            domain="sensor",
+            device_class="illuminance",
+            state_class="measurement",
+            unit_of_measurement="lx",
+            friendly_name="Abstellkammer Helligkeit",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.abstellkammer_power",
+            domain="sensor",
+            device_class="power",
+            state_class="measurement",
+            unit_of_measurement="W",
+            friendly_name="Abstellkammer Leistung",
+            area_name="Abstellkammer",
+        ),
+    ]
+    history = {
+        "sensor.abstellkammer_illuminance": _points(8, start, 10.0),
+        "sensor.abstellkammer_power": _points(8, start, 30.0),
+    }
+    service = _service(tmp_path, entities, history)
+    service.configure_actuator("light.abstellkammer")
+    service.set_manual_assignment(
+        "light.abstellkammer",
+        numeric_entity_id="sensor.abstellkammer_power",
+        context_entity_ids=["sensor.abstellkammer_illuminance"],
+        note="Manuell wichtiger Sensor",
+    )
+
+    restarted = _service(tmp_path, entities, history)
+    record = restarted.reconcile_actuator("light.abstellkammer")
+
+    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_power"
+    assert record.assignment.selected_context_entity_ids == ["sensor.abstellkammer_illuminance"]
+    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
--- a/tests/api/test_actuators.py
+++ b/tests/api/test_actuators.py
@@ -0,0 +1,382 @@
+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.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 (
+    EntityHistorySeries,
+    LogbookEntry,
+    NumericHistoryPoint,
+    StateHistorySeries,
+)
+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
+
+
+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
+
+    def read_entities(self) -> list[HaEntitySummary]:
+        self.read_entities_calls += 1
+        return list(self._entities)
+
+    def discover(
+        self,
+        domains: set[str] | None = None,
+        learnable: bool | None = None,
+    ) -> list[DiscoveredEntity]:
+        return discover_entities(self._entities, domains=domains, learnable=learnable)
+
+    def read_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[EntityHistorySeries]:
+        base = start_time
+        return [
+            EntityHistorySeries(
+                entity_id=entity_id,
+                points=[
+                    NumericHistoryPoint(
+                        timestamp=base + timedelta(hours=index),
+                        value=value,
+                    )
+                    for index, value in enumerate(self._history.get(entity_id, []))
+                ],
+            )
+            for entity_id in entity_ids
+            if entity_id in self._history
+        ]
+
+    def read_state_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[StateHistorySeries]:
+        return []
+
+    def read_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[LogbookEntry]:
+        return []
+
+    def call_service(
+        self,
+        domain: str,
+        service: str,
+        service_data: dict[str, object],
+    ) -> list[object]:
+        return []
+
+    def find_automations_for_entity(
+        self,
+        entity_id: str,
+    ) -> list[HaAutomationSummary]:
+        return []
+
+
+def _install_service(tmp_path: Path) -> None:
+    entities = [
+        HaEntitySummary(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Abstellkammer Licht",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.abstellkammer_illuminance",
+            domain="sensor",
+            device_class="illuminance",
+            state_class="measurement",
+            unit_of_measurement="lx",
+            friendly_name="Abstellkammer Helligkeit",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellkammer_motion",
+            domain="binary_sensor",
+            device_class="motion",
+            friendly_name="Abstellkammer Bewegung",
+            area_name="Abstellkammer",
+        ),
+        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(
+        ha_url="http://ha.local",
+        ha_token="token",
+        model_store=str(tmp_path / "models"),
+        automation_store=str(tmp_path / "automations"),
+        actuator_store=str(tmp_path / "actuators"),
+        history_days=14,
+        min_training_points=5,
+        retrain_stale_hours=24,
+        reconcile_interval_seconds=900,
+    )
+    app.state.registry = ModelRegistry(tmp_path / "models")
+    app.state.actuator_store = ActuatorStore(tmp_path / "actuators")
+    app.state.ha_reader = FakeHaReader(
+        entities,
+        {"sensor.abstellkammer_illuminance": [10, 11, 12, 13, 14, 15]},
+    )
+    app.state.actuator_service = ActuatorReconciliationService(
+        ha_reader=app.state.ha_reader,
+        store=app.state.actuator_store,
+        registry=app.state.registry,
+        settings=settings,
+    )
+    app.state.behavior_engine = BehaviorEngine(
+        ha_reader=app.state.ha_reader,
+        store=app.state.actuator_store,
+        settings=settings,
+    )
+
+
+def test_actuator_api_configures_reconciles_and_removes(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+
+        created = client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        assert created.status_code == 201
+        assert created.json()["assignment"]["selected_numeric_entity_id"] == (
+            "sensor.abstellkammer_illuminance"
+        )
+
+        listed = client.get("/v1/actuators")
+        assert listed.status_code == 200
+        assert listed.json()[0]["lifecycle"]["status"] == "trained"
+        assert listed.json()[0]["behavior"]["mode"] == "shadow"
+
+        evaluation = client.post("/v1/actuators/light.abstellkammer/evaluate")
+        assert evaluation.status_code == 200
+
+        premature_activation = client.post(
+            "/v1/actuators/light.abstellkammer/activation",
+            json={"active": True},
+        )
+        assert premature_activation.status_code == 409
+
+        reconciliation = client.post("/v1/actuators/reconciliation/run")
+        assert reconciliation.status_code == 200
+        assert reconciliation.json()["trained_models"] == 1
+
+        removed = client.delete("/v1/actuators/light.abstellkammer")
+        assert removed.status_code == 204
+        assert client.get("/v1/actuators").json() == []
+
+
+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/assignment",
+            json={
+                "numeric_entity_id": "sensor.abstellkammer_illuminance",
+                "context_entity_ids": ["binary_sensor.abstellkammer_motion"],
+                "note": "Manuell gesetzt",
+            },
+        )
+
+    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_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"]
+
+
+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"]
--- a/tests/api/test_automations.py
+++ b/tests/api/test_automations.py
@@ -1,59 +1,17 @@
-from pathlib import Path
-
 from fastapi.testclient import TestClient

-from app.automations.store import AutomationStore
 from app.main import app


-def _payload() -> dict[str, object]:
-    return {
-        "alias": "Licht bei Dunkelheit",
-        "description": "Schaltet das Flurlicht unter dem Helligkeitsgrenzwert ein.",
-        "trigger": {"entity_id": "sensor.hall_illuminance", "below": 10},
-        "action": {
-            "service": "light.turn_on",
-            "entity_id": "light.hall",
-            "data": {"brightness_pct": 40},
-        },
-    }
-
-
-def test_proposal_requires_explicit_approval_before_yaml(tmp_path: Path) -> None:
+def test_automation_api_is_not_exposed() -> None:
    with TestClient(app) as client:
-        app.state.automation_store = AutomationStore(tmp_path)
-        created = client.post("/v1/automations/proposals", json=_payload())
-        proposal_id = created.json()["proposal_id"]
-        blocked = client.get(f"/v1/automations/proposals/{proposal_id}/yaml")
-        approved = client.post(
-            f"/v1/automations/proposals/{proposal_id}/approve",
-            json={"expected_revision": 1},
+        response = client.post(
+            "/v1/automations/proposals",
+            json={
+                "alias": "Nicht mehr verfügbar",
+                "trigger": {"entity_id": "sensor.hall_illuminance", "below": 10},
+                "action": {"service": "light.turn_on", "entity_id": "light.hall"},
+            },
        )
-        exported = client.get(f"/v1/automations/proposals/{proposal_id}/yaml")
-    assert created.status_code == 201
-    assert created.json()["status"] == "draft"
-    assert blocked.status_code == 409
-    assert approved.json()["status"] == "approved"
-    assert "service: light.turn_on" in exported.text

-
-def test_proposal_rejects_unsafe_service_domain(tmp_path: Path) -> None:
-    payload = _payload()
-    payload["action"] = {
-        "service": "shell_command.run",
-        "entity_id": "light.hall",
-        "data": {},
-    }
-    with TestClient(app) as client:
-        app.state.automation_store = AutomationStore(tmp_path)
-        response = client.post("/v1/automations/proposals", json=payload)
-    assert response.status_code == 422
-
-
-def test_proposal_requires_numeric_threshold(tmp_path: Path) -> None:
-    payload = _payload()
-    payload["trigger"] = {"entity_id": "sensor.hall_illuminance"}
-    with TestClient(app) as client:
-        app.state.automation_store = AutomationStore(tmp_path)
-        response = client.post("/v1/automations/proposals", json=payload)
-    assert response.status_code == 422
+    assert response.status_code == 404
--- a/tests/api/test_entities.py
+++ b/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.",
@@ -73,11 +74,18 @@ def test_entities_returns_reader_data() -> None:
    assert response.status_code == 200
    assert response.json() == [
        {
-            "entity_id": "sensor.temperature",
-            "domain": "sensor",
-            "state_class": None,
+                "entity_id": "sensor.temperature",
+                "domain": "sensor",
+                "state": None,
+                "last_changed": None,
+                "state_class": None,
            "device_class": None,
            "unit_of_measurement": None,
+            "friendly_name": None,
+            "area_id": None,
+            "area_name": None,
+            "device_id": None,
+            "device_name": None,
        }
    ]

@@ -109,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.",
--- a/tests/behavior/test_engine.py
+++ b/tests/behavior/test_engine.py
@@ -0,0 +1,780 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+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
+from app.ha.history import (
+    LogbookEntry,
+    StateHistoryPoint,
+    StateHistorySeries,
+)
+from app.ha.models import HaAutomationSummary, HaEntitySummary
+from app.ha.reader import HaReader
+
+
+class FakeBehaviorReader(HaReader):
+    def __init__(
+        self,
+        *,
+        entities: list[HaEntitySummary],
+        history: list[StateHistorySeries],
+        logbook: list[LogbookEntry],
+    ) -> None:
+        self.entities = entities
+        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)
+
+    def read_state_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[StateHistorySeries]:
+        return [series for series in self.history if series.entity_id in entity_ids]
+
+    def read_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[LogbookEntry]:
+        return [entry for entry in self.logbook if entry.entity_id == entity_id]
+
+    def call_service(
+        self,
+        domain: str,
+        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 list(self.automations)
+
+
+def _settings(tmp_path: Path) -> Settings:
+    return Settings(
+        actuator_store=str(tmp_path / "actuators"),
+        model_store=str(tmp_path / "models"),
+        automation_store=str(tmp_path / "automations"),
+        history_days=14,
+        min_behavior_actions=3,
+        prediction_confidence=0.8,
+        prediction_window_minutes=30,
+        execution_cooldown_seconds=900,
+        timezone="Europe/Berlin",
+    )
+
+
+def _reader(now: datetime) -> FakeBehaviorReader:
+    actuator_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"),
+                StateHistoryPoint(timestamp=action_at + timedelta(hours=6), state="off"),
+            ]
+        )
+        logbook.extend(
+            [
+                LogbookEntry(
+                    entity_id="light.office",
+                    timestamp=action_at,
+                    message="turned on",
+                    context_user_id="user-1",
+                ),
+                LogbookEntry(
+                    entity_id="light.office",
+                    timestamp=action_at + timedelta(hours=6),
+                    message="turned off",
+                    context_domain="automation",
+                    context_service="trigger",
+                ),
+            ]
+        )
+    actuator_points.sort(key=lambda point: point.timestamp)
+    context_points = [
+        StateHistoryPoint(timestamp=now - timedelta(days=7), state="on"),
+    ]
+    return FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.office", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.office_presence",
+                domain="binary_sensor",
+                state="on",
+            ),
+        ],
+        history=[
+            StateHistorySeries(entity_id="light.office", points=actuator_points),
+            StateHistorySeries(
+                entity_id="binary_sensor.office_presence",
+                points=context_points,
+            ),
+        ],
+        logbook=logbook,
+    )
+
+
+def _engine(tmp_path: Path, now: datetime) -> tuple[BehaviorEngine, FakeBehaviorReader]:
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.office")
+    store.upsert(
+        record.model_copy(
+            update={
+                "assignment": record.assignment.model_copy(
+                    update={
+                        "selected_context_entity_ids": [
+                            "binary_sensor.office_presence"
+                        ],
+                    }
+                )
+            }
+        )
+    )
+    reader = _reader(now)
+    return (
+        BehaviorEngine(ha_reader=reader, store=store, settings=settings),
+        reader,
+    )
+
+
+def test_engine_trains_predicts_in_shadow_and_executes_only_after_approval(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    engine, reader = _engine(tmp_path, now)
+
+    trained = engine.train("light.office")
+    shadow = engine.evaluate("light.office")
+
+    assert trained.behavior.status is BehaviorStatus.TRAINED
+    assert trained.behavior.sample_count == 6
+    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"
+    assert reader.service_calls == []
+
+    engine.set_active("light.office", active=True)
+    active = engine.evaluate("light.office")
+
+    assert active.behavior.mode is BehaviorMode.ACTIVE
+    assert active.behavior.prediction is not None
+    assert active.behavior.prediction.executed is True
+    assert reader.service_calls == [
+        ("light", "turn_on", {"entity_id": "light.office"})
+    ]
+
+
+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",
+        "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:
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("lock.front_door")
+    store.upsert(
+        record.model_copy(
+            update={
+                "behavior": record.behavior.model_copy(
+                    update={"status": BehaviorStatus.TRAINED}
+                )
+            }
+        )
+    )
+    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    with pytest.raises(ValueError, match="nicht freigegeben"):
+        engine.set_active("lock.front_door", active=True)
+
+
+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")
+    store.upsert(
+        record.model_copy(
+            update={
+                "behavior": record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.TRAINED,
+                        "sample_count": 3,
+                        "high_confidence_sample_count": 0,
+                    }
+                )
+            }
+        )
+    )
+    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    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"),
+        ("lock", "unlocked", None),
+    ],
+)
+def test_service_for_state_is_strictly_allowlisted(
+    domain: str,
+    state: str,
+    service: str | None,
+) -> None:
+    assert service_for_state(domain, state) == service
+
+
+def test_prediction_requires_temporal_support() -> None:
+    assert predict_behavior(
+        [],
+        current_context={},
+        now=datetime.now(timezone.utc),
+        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"})
+    ]
--- a/tests/ha/test_discovery.py
+++ b/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
--- a/tests/ha/test_ha_client.py
+++ b/tests/ha/test_ha_client.py
@@ -88,6 +88,76 @@ def test_get_history_calls_home_assistant_history_api() -> None:
    assert call.kwargs["params"]["end_time"] == "2026-06-02T00:00:00+00:00"


+def test_list_entity_metadata_calls_template_api() -> None:
+    response = _response()
+    response.text = (
+        '[{"entity_id":"sensor.temperature","area_name":"Kueche","device_name":"Thermometer"}]'
+    )
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.post = Mock(return_value=response)  # type: ignore[method-assign]
+
+    metadata = client.list_entity_metadata(["sensor.temperature"])
+
+    assert metadata == {
+        "sensor.temperature": {
+            "area_id": None,
+            "area_name": "Kueche",
+            "device_id": None,
+            "device_name": "Thermometer",
+        }
+    }
+
+
+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)
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
+
+    payload = client.get_logbook("light.office", start, end)
+
+    assert payload == [{"entity_id": "light.office"}]
+    call = client._session.get.call_args  # type: ignore[attr-defined]
+    assert "/api/logbook/2026-06-01T00:00:00+00:00" in call.args[0]
+    assert call.kwargs["params"]["entity"] == "light.office"
+
+
+def test_call_service_posts_to_home_assistant() -> None:
+    response = _response(payload=[])
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.post = Mock(return_value=response)  # type: ignore[method-assign]
+
+    result = client.call_service("light", "turn_on", {"entity_id": "light.office"})
+
+    assert result == []
+    client._session.post.assert_called_once_with(
+        "http://ha.local/api/services/light/turn_on",
+        json={"entity_id": "light.office"},
+        timeout=10,
+    )
+
+
@pytest.mark.parametrize(
    ("entity_ids", "start", "end"),
    [
--- a/tests/ha/test_ha_reader.py
+++ b/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",
@@ -44,6 +46,39 @@ class FakeHaClient(HaClient):
            ]
        ]

+    def list_entity_metadata(self, entity_ids: list[str]) -> dict[str, dict[str, str | None]]:
+        return {
+            "sensor.temperature": {
+                "area_id": "kitchen",
+                "area_name": "Kueche",
+                "device_id": "device-1",
+                "device_name": "Thermometer",
+            }
+        }
+
+    def get_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[object]:
+        return [
+            {
+                "entity_id": entity_id,
+                "when": start_time.isoformat(),
+                "message": "turned on",
+                "context_user_id": "user-1",
+            }
+        ]
+
+    def call_service(
+        self,
+        domain: str,
+        service: str,
+        service_data: dict[str, object],
+    ) -> list[object]:
+        return []
+

 def test_ha_reader_returns_summaries() -> None:
    reader = HaReader(FakeHaClient())
@@ -53,6 +88,10 @@ def test_ha_reader_returns_summaries() -> None:
    assert domains == {"sensor", "light"}
    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"


 def test_ha_reader_discovers_learnable_sensors() -> None:
@@ -75,3 +114,60 @@ def test_ha_reader_normalizes_history() -> None:

    assert history[0].entity_id == "sensor.temperature"
    assert history[0].points[0].value == 21.5
+
+
+def test_ha_reader_normalizes_state_history_and_logbook() -> None:
+    reader = HaReader(FakeHaClient())
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
+
+    history = reader.read_state_history(["light.living_room"], start, end)
+    logbook = reader.read_logbook("light.living_room", start, end)
+
+    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") == []
--- a/tests/ha/test_history.py
+++ b/tests/ha/test_history.py
@@ -5,7 +5,11 @@ from datetime import datetime, timezone
 import pytest

 from app.ha.exceptions import HaUnexpectedPayloadError
-from app.ha.history import normalize_history_payload
+from app.ha.history import (
+    normalize_history_payload,
+    normalize_logbook_payload,
+    normalize_state_history_payload,
+)


 def test_normalize_history_payload_groups_and_sorts_numeric_states() -> None:
@@ -90,3 +94,46 @@ def test_normalize_history_payload_rejects_malformed_structure(payload: object)

 def test_normalize_history_payload_accepts_empty_series() -> None:
    assert normalize_history_payload([[]]) == []
+
+
+def test_normalize_state_history_keeps_categorical_changes() -> None:
+    result = normalize_state_history_payload(
+        [
+            [
+                {
+                    "entity_id": "light.office",
+                    "state": "off",
+                    "last_changed": "2026-06-01T08:00:00+00:00",
+                },
+                {
+                    "state": "on",
+                    "last_changed": "2026-06-01T08:05:00+00:00",
+                },
+                {
+                    "state": "on",
+                    "last_changed": "2026-06-01T08:06:00+00:00",
+                },
+            ]
+        ]
+    )
+
+    assert [point.state for point in result[0].points] == ["off", "on"]
+
+
+def test_normalize_logbook_preserves_action_origin() -> None:
+    result = normalize_logbook_payload(
+        [
+            {
+                "entity_id": "light.office",
+                "when": "2026-06-01T08:05:00+00:00",
+                "message": "turned on",
+                "context_user_id": "user-1",
+                "context_domain": "light",
+                "context_service": "turn_on",
+            }
+        ],
+        "light.office",
+    )
+
+    assert result[0].context_user_id == "user-1"
+    assert result[0].context_service == "turn_on"
--- a/tests/test_addon_config.py
+++ b/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
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -10,6 +10,17 @@ def test_load_settings_reads_documented_environment(monkeypatch: MonkeyPatch) ->
    monkeypatch.setenv("SILLYHOME_HA_TOKEN", "secret")
    monkeypatch.setenv("SILLYHOME_MODEL_STORE", "/tmp/models")
    monkeypatch.setenv("SILLYHOME_AUTOMATION_STORE", "/tmp/automations")
+    monkeypatch.setenv("SILLYHOME_ACTUATOR_STORE", "/tmp/actuators")
+    monkeypatch.setenv("SILLYHOME_HISTORY_DAYS", "7")
+    monkeypatch.setenv("SILLYHOME_MIN_TRAINING_POINTS", "12")
+    monkeypatch.setenv("SILLYHOME_RETRAIN_STALE_HOURS", "48")
+    monkeypatch.setenv("SILLYHOME_RECONCILE_INTERVAL_SECONDS", "600")
+    monkeypatch.setenv("SILLYHOME_MIN_BEHAVIOR_ACTIONS", "4")
+    monkeypatch.setenv("SILLYHOME_PREDICTION_CONFIDENCE", "0.9")
+    monkeypatch.setenv("SILLYHOME_PREDICTION_WINDOW_MINUTES", "20")
+    monkeypatch.setenv("SILLYHOME_PREDICTION_INTERVAL_SECONDS", "45")
+    monkeypatch.setenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "1200")
+    monkeypatch.setenv("SILLYHOME_TIMEZONE", "Europe/Berlin")

    settings = load_settings()

@@ -17,4 +28,15 @@ def test_load_settings_reads_documented_environment(monkeypatch: MonkeyPatch) ->
    assert settings.ha_token == "secret"
    assert settings.model_store == "/tmp/models"
    assert settings.automation_store == "/tmp/automations"
+    assert settings.actuator_store == "/tmp/actuators"
+    assert settings.history_days == 7
+    assert settings.min_training_points == 12
+    assert settings.retrain_stale_hours == 48
+    assert settings.reconcile_interval_seconds == 600
+    assert settings.min_behavior_actions == 4
+    assert settings.prediction_confidence == 0.9
+    assert settings.prediction_window_minutes == 20
+    assert settings.prediction_interval_seconds == 45
+    assert settings.execution_cooldown_seconds == 1200
+    assert settings.timezone == "Europe/Berlin"
    assert settings.ha_configured
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -9,4 +9,38 @@ def test_dashboard_is_served_at_root() -> None:

    assert response.status_code == 200
    assert "SillyHome Next" in response.text
-    assert "Automation-Entwurf" in response.text
+    assert "Arbeitsdashboard für gelernte Home-Assistant-Bedienung" 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
--- a/tests/test_main.py
+++ b/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",
+    }
Author	SHA1	Message	Date
Otto	ca253d1e6c	Fix dashboard text overflow and close v1 docs gaps Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 11:53:25 +02:00
Otto	b9b5def7bb	Add actuator sensor weighting controls Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 11:41:46 +02:00
Otto	94530d3ecf	Stream dashboard loading and header menu Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 07:55:28 +02:00
Otto	63b8684197	Document v1 acceptance and dashboard stats Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 07:45:30 +02:00
Otto	f8801e469a	Polish v1 dashboard loading and layout Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 07:33:30 +02:00
Otto	787516ac67	Avoid per-request discovery classification in dashboard Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 01:19:59 +02:00
Otto	7ba9807a4e	Prepare SillyHome Next 1.0.0 dashboard and API rework Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 01:13:43 +02:00
Otto	4db4276b95	Rework dashboard loading and cache entity metadata Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:41:50 +02:00
Otto	98a2b2cc38	Fix dashboard summary status rendering Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:21:14 +02:00
Otto	387e027fe2	Use lightweight actuator dashboard summaries Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:09:35 +02:00
Otto	f8bee92e64	Optimize dashboard categories and context loading Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:02:19 +02:00
Otto	9ddb065f62	Speed up HA event processing Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:58:58 +02:00
Otto	8222f24ebe	Group configured actuator overview Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:51:02 +02:00
Otto	a7a2f8c78a	Make SillyHome startup resilient Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:43:41 +02:00
Otto	faf4099756	Load actuator suggestions asynchronously Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 12:14:51 +02:00
Otto	1b2b76455a	Tighten context onboarding and actuator suggestions Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 12:06:03 +02:00
Otto	18999ff68a	Limit actuator picker results Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 11:43:00 +02:00
Otto	e2826e92ec	Improve SillyHome discovery and feedback learning Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 11:38:32 +02:00
Otto	c5f42a39a9	Fix realtime HA state-change execution Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 10:50:28 +02:00
Otto	309b33b812	Use fresh HA event state for behavior triggers Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-15 19:37:45 +02:00
Otto	9db7cde179	Fix HA websocket keepalive fallback Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-15 19:30:02 +02:00
Otto	3140f65527	Fix HA websocket state change handling Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-15 18:15:14 +02:00
Otto	5727053951	fix: hide diagnostic context suggestions Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 23:47:14 +02:00
Otto	658516cd96	fix: narrow manual context suggestions Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 23:42:50 +02:00
Otto	8cd8f3e3b7	feat: improve actor-specific context selection Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 23:35:38 +02:00
Otto	09e14689a3	feat: add manual context assignment and fix actuator discovery Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 23:15:00 +02:00
Otto	d87d3abc00	fix: batch ha metadata and improve mobile dashboard Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 22:52:42 +02:00
Otto	2ae5576b8f	fix: complete websocket delivery for v0.7.1 Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 22:30:29 +02:00
Otto	51d23e0a9a	feat: WebSocket-Healthcheck und Status-Tracking\n\n- Fügt _WsStatus-Klasse hinzu, die den aktuellen Verbindungsstatus verfolgt\n- Neuer Endpoint /health/websocket gibt Status zurück (connected/connecting/error)\n- Event-Listener aktualisiert den Status bei allen Zustandsänderungen\n- Fallback-Task wird korrekt im lifespan verwaltet\n- Bessere Fehlerbehandlung und Statusmeldungen\n\nImproves observability of the event-based architecture. Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 17:55:44 +02:00
Otto	c8f491ba1a	feat: event-basierte Vorhersage via HA-WebSocket\n\n- Entfernt periodisches Prediction-Intervall (60s)\n- Fügt WebSocket-Listener hinzu, der bei jedem State Change sofort evaluiert\n- BehaviorEngine.handle_state_change() identifiziert betroffene Aktoren und löst evaluate() aus\n- Fallback periodische Vorhersage bleibt als Backup\n- pyproject: websockets dependency\n- tests: test_main.py für Event-Listener\n\nCloses #39 Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 17:23:29 +02:00
Otto	f9c7c27e00	Merge pull request 'v0.7.0: sichere Steuerungsübergabe und klare Bedienung' (#40 ) from feature/control-handoff-v0.7.0 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 16:22:18 +02:00
Otto	b3cf68eade	CONTROL-001: add safe HA automation handoff Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 16:21:57 +02:00
Otto	77f328c4a8	Merge pull request 'v0.6.2: HA-Automationen gleichwertig lernen' (#39 ) from feature/automation-equality-v0.6.2 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 15:58:44 +02:00
Otto	7ad97320a2	BEHAVIOR-004: trust HA automation actions Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 15:58:05 +02:00
Otto	58d3126a35	Merge pull request 'v0.6.1: sichtbare Rückmeldung bei Situationsprüfung' (#38 ) from fix/evaluation-feedback-v0.6.1 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 15:38:26 +02:00
Otto	1c5eab14b6	UI-003: show prediction evaluation feedback Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 15:38:11 +02:00
Otto	87ae051238	Merge pull request 'v0.6.0: kausales Shadow-Lernen aus Sensorwechseln' (#37 ) from feature/causal-shadow-v0.6.0 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 15:35:22 +02:00
Otto	fb76d89204	BEHAVIOR-003: learn causal shadow triggers Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 15:35:07 +02:00
Otto	1370d02c15	Merge pull request 'v0.5.4: korrekter Kontext- und Freigabestatus' (#36 ) from fix/context-status-v0.5.4 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 15:29:07 +02:00
Otto	100f5af578	UI-002: align context and activation status Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 15:28:52 +02:00
Otto	ede6b87dbd	Merge pull request 'v0.5.3: sichere Sensorzuordnung für Aktoren' (#35 ) from fix/sensor-assignment-v0.5.3 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 15:19:55 +02:00
Otto	47e8c7e549	ASSIGN-001: reject unrelated actuator sensors Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 15:19:30 +02:00
Otto	ef7e0c5600	Merge pull request 'v0.5.2: Add-on-Build liefert zuverlässig aktuellen Code' (#34 ) from fix/addon-cache-v0.5.2 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 11:38:51 +02:00
Otto	8d070fc9ca	BUILD-001: invalidate addon application cache per release Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 11:38:36 +02:00
Otto	ba15cc4d83	Merge pull request 'v0.5.1: verständliche Ingress-Führung und vereinfachte Add-on-Konfiguration' (#33 ) from fix/ingress-guidance-v0.5.1 into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 11:03:20 +02:00
Otto	da51ac2063	UI-001: simplify addon setup and explain ingress workflow Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 11:02:38 +02:00
Otto	ce568056fc	Merge pull request 'v0.5.0: behavior learning, shadow prediction and safe activation' (#32 ) from feature/actuator-sensor-lifecycle into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details Merge pull request v0.5.0 behavior learning and safe activation (#32)	2026-06-14 10:41:16 +02:00
Otto	da4603be17	BEHAVIOR-002: isolate per-actuator runtime failures Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 10:40:19 +02:00
Otto	b215f23dd9	Merge remote-tracking branch 'origin/main' into feature/actuator-sensor-lifecycle Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-14 10:38:33 +02:00
Otto	fa250216be	BEHAVIOR-001: learn and predict actuator actions Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 10:37:59 +02:00
Otto	685feb57b3	Merge pull request 'ACT-001: actuator-first sensor assignment and lifecycle' (#31 ) from feature/actuator-sensor-lifecycle into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-13 22:47:14 +02:00
Otto	6305f52cd2	ACT-001: actuator-first sensor lifecycle Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details	2026-06-13 22:45:07 +02:00
Otto	7ed667f954	Merge pull request 'OPS-001: Persist HA panel and rollback instructions' (#30 ) from feature/ha-ops into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-13 21:18:25 +02:00
Otto	d6631fe752	OPS-001: persist HA panel and rollback instructions Some checks failed quality / test (3.11) (pull_request) Has been cancelled Details quality / test (3.13) (pull_request) Has been cancelled Details quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-13 21:18:24 +02:00
Otto	9f4fc2f4ce	Merge pull request 'MVP: Dashboard and Home Assistant add-on' (#29 ) from feature/mvp-testable into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-13 21:12:31 +02:00
Otto	9ddb86cc1a	Merge pull request 'AUTO-001: Safe Automation Approval Workflow' (#28 ) from feature/automation-approval into main Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-13 20:21:22 +02:00
				`@@ -0,0 +1 @@`
				`"""Learning and prediction for actuator behavior."""`